splashstate.c

Go to the documentation of this file.

#include <SDL_image.h>
#include <string.h>
#include <stdlib.h>
#include "states.h"
#include "color.h"
#include "obstacle.h"
#include "tanksprite.h"
#include "message.h"

extern RenderItem background;

Uint32 startTime;

Player *tanks;

static void SplashResize() {
    int loop;
    // assure good color values
    SetupColorVals();   
    // put the backgound image in place
    background.loc.w = dInfo.pw;
    background.loc.h = dInfo.ph;
    PlaceRenderItem(&background);
    // title at the top
    textItems[TEXTITEM_TITLE].loc.y = TOP_MARGIN;
    // author a short distance down
    textItems[TEXTITEM_AUTH].loc.y = textItems[TEXTITEM_TITLE].loc.y +
    textItems[TEXTITEM_TITLE].loc.h + TOP_MARGIN;
    // is there a translator?
    if (textItems[TEXTITEM_TRANS].parent) {
        // place the translator credit further down
        textItems[TEXTITEM_TRANS].loc.y = textItems[TEXTITEM_AUTH].loc.y +
        textItems[TEXTITEM_AUTH].loc.h + TOP_MARGIN;
    }
    // GPL notice up from the bottom
    textItems[TEXTITEM_GPL].loc.y = dInfo.ph - textItems[TEXTITEM_GPL].loc.h
    - BOTTOM_MARGIN;
    // loop to p[ace things up from the bottom -- this was more useful before
    // multi-line text support was added
    for (loop = TEXTITEM_GPL - 1; loop >= TEXTITEM_COPYRIGHT; loop--) {
        textItems[loop].loc.y = textItems[loop + 1].loc.y -
        textItems[loop].loc.h;
    }
    // center all text horizontally
    for (loop = TEXTITEM_TITLE; loop < TEXTITEM_GPL + 1; loop++) {
        // make sure the item exists -- translator may not
        if (textItems[loop].parent) {
            // compute the centered location
            textItems[loop].loc.x = (dInfo.pw >> 1) -
            (textItems[loop].loc.w >> 1);
            // place the item
            PlaceRenderItem(&(textItems[loop]));
        }
    }
    // place two tanks
    tanks[0].tank.loc.w = tanks[0].tank.loc.h =
    tanks[1].tank.loc.w = tanks[1].tank.loc.h = dInfo.luw << 3;
    tanks[0].tank.loc.x = 32;
    tanks[1].tank.loc.x = dInfo.pw - tanks[0].tank.loc.w - 32;
    tanks[0].tank.loc.y = tanks[1].tank.loc.y =
    (dInfo.ph - tanks[0].tank.loc.h) >> 1;
    PlaceRenderItem(&(tanks[0].tank));
    PlaceRenderItem(&(tanks[1].tank));
}

int SplashInit() {
    memset(&background, 0, sizeof(background));
    // get memory for a couple tanks to use as icons
    if ((tanks = calloc(2, sizeof(Player))) == NULL) {
        // out of memory
        return STATE_ERROR;
    }
    // setup position of screen parts
    dInfo.luw = dInfo.luh = 8;
    dInfo.lw = dInfo.pw / dInfo.luw;
    dInfo.lh = dInfo.ph / dInfo.luh;
    // put the backgound image in place
    background.renderer = SolidFillRenderer;
    background.data = &(colorVals[COLOR_REGBACK]);
    AddRenderItem(&background, LAYER_BACKGROUND);
    // initalize two tanks
    tanks[0].tank.renderer = tanks[1].tank.renderer = DrawTank;
    tanks[0].rot = 4 << 8;
    //tanks[0].team = 0; // implied because of calloc
    tanks[1].rot = 12 << 8;
    tanks[1].team++;
    AddRenderItem(&(tanks[0].tank), LAYER_TANKS);
    AddRenderItem(&(tanks[1].tank), LAYER_TANKS);
    // set the text color
    colorFmtInd[COLOR_TEXT] = colorFmtInd[COLOR_BLACK];
    // attempt to render all the text off-screen
    if (!TextSetupStateSplash()) return STATE_ERROR;
    // place all the text
    SplashResize();
    // record the time
    startTime = SDL_GetTicks();
    return STATE_OK;
}

int SplashUninit() {
    // see if a background image, rather than a color, was used
    if (background.renderer == GenericSurfaceRenderer) {
        // remove the background image
        SDL_FreeSurface(background.data);
    }
    RemoveRenderItem(&background);
    RemoveRenderItem(&(tanks[0].tank));
    RemoveRenderItem(&(tanks[1].tank));
    free(tanks);
    TextUnsetState();
    return STATE_OK;
}

int SplashRun() {
    SDL_Event event;
    
    // loop through all waiting events
    while (SDL_PollEvent(&event)) {
        // figure event type
        switch (event.type) {
            case SDL_QUIT:
                return STATE_QUIT;
                break;
            case SDL_KEYDOWN:
                // check for a request to quit the program
                if (event.key.keysym.sym == SDLK_ESCAPE)
                    return STATE_QUIT;
                break;
            case SDL_KEYUP:
            case SDL_JOYBUTTONDOWN:
                // enforce a minimum delay
                if ((SDL_GetTicks() - startTime) > 127)
                    return STATE_MENUROOT;
                break;
            case SDL_VIDEORESIZE:
                ResizeWindow(event.resize.w, event.resize.h);
                SplashResize();
            default:
                break;
        }
    }
    // ----- run network code ----
    // Without this, if the client quickly connects to a server it will not
    // respond until running the menu state, which can be long enough for the
    // server to decide that the client is not responding.
    ProcessNetworkMessages();
    // see if enough time has been spent on the splash screen
    if ((SDL_GetTicks() - startTime) > 4095) {
        // move on to the menu
        return STATE_MENUROOT;
    }
    // continue with the splash screen
    return STATE_SPLASH;
}

---