gamestate.c

Go to the documentation of this file.

#include "states.h"
#include "game.h"
#include "color.h"
#include "gameconfig.h"
#include "obstacle.h"
#include "playernet.h"
#include "tanksprite.h"
#include "name.h"
#include "net.h"
#include "notice.h"
#include "menustate.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#ifdef USE_SDLIMAGE
#include <SDL_image.h>
#endif
#ifdef USE_AUDIO
#include "audio.h"
#endif

Uint8 eventState[EC_MAX];

extern Uint32 frameTime;

RenderItem background;

static Sint16 scores[2];

#define BORDER_WIDTH  4

static RenderItem border[4];

static void RenderScore(Bool forceRender) {
    // for now, support only two teams
    int loop;
    for (loop = 0; loop < 2; loop++) {
        // has this team's score changed?
        if (forceRender ||
        (scores[loop] != gameOpts.teamScore[TEAM_RED + loop])) {
            // record the new displayed score
            scores[loop] = gameOpts.teamScore[TEAM_RED + loop];
            // render the text
            TextRenderString(&textItems[TEXTITEM_REDSCORE + loop], FONT_SCORE,
            0, colorFmtInd[COLOR_RED + loop],
            #ifdef USE_GETTEXT
            L"%d",
            #else
            "%d",
            #endif
            scores[loop]);
            // place the score on screen
            textItems[TEXTITEM_REDSCORE + loop].loc.y = 5;
            if (loop) {
                textItems[TEXTITEM_BLUESCORE].loc.x =
                dInfo.pw - textItems[TEXTITEM_BLUESCORE].loc.w - 5;
            }
            else {
                textItems[TEXTITEM_REDSCORE].loc.x = 5;
            }
            PlaceRenderItem(&textItems[TEXTITEM_REDSCORE + loop]);
        }
    }
}

static void SetupScrolling() {
    // check for a field that can fit on screen
    if ((dInfo.lw >= gameOpts.width) && (dInfo.lh >= gameOpts.height)) {
        // it fits; no scrolling
        dInfo.scrollField = FALSE;
        // reset layer offsets
        SetLayerOffset(&(layers[LAYER_OBSTACLES]), 0, 0);
        SetLayerOffset(&(layers[LAYER_NAMES]), 0, 0);
        SetLayerOffset(&(layers[LAYER_TANKS]), 0, 0);
    }
    else {
        // it doesn't fit; use scrolling
        dInfo.scrollField = TRUE;
        // no need to set layer offsets -- this must be done every frame
    }
}

static Bool GraphicReset() {
    // assure everything is rendered
    ForceRenderAll();
    #ifdef USE_SDLIMAGE
    // load an image
    if ((back = IMG_Load("back.jpg")) == NULL) {
    #endif
        // put the solid color backgound in place
        background.loc.w = dInfo.pw;
        background.loc.h = dInfo.ph;
        background.renderer = SolidFillRenderer;
        background.data = &(colorVals[COLOR_REGBACK]);
    #ifdef USE_SDLIMAGE
    }
    else {
        SDL_Surface *back;
        // Convert the image to the same format the display is using to
        // improve performance. Use a software surface if there is no hardware
        // acceleration because that will be faster.
        if ((background.data = SDL_ConvertSurface(back, dInfo.display->format,
        FASTEST_SURFACE)) == NULL) {
            // couldn't do it, so keep the loaded surface
            background.data = back;
        }
        else {
            // get rid of the less desirable surface
            SDL_FreeSurface(back);
        }
        // put the backgound image in place
        background.loc.w = ((SDL_Surface*)(background.data))->w;
        background.loc.h = ((SDL_Surface*)(background.data))->h;
        background.renderer = GenericSurfaceRenderer;
    }
    #endif
    // assure good color values
    SetupColorVals();
    // set the text color
    colorFmtInd[COLOR_TEXT] = colorFmtInd[COLOR_WHITE];
    // initalize the text system
    TextSetupStatePlay();
    // place the score
    RenderScore(TRUE);
    SetupScrolling();
    return TRUE;
}

int GameInit() {
    Player *p;
    int loop;
    // initialize global data
    memset(eventState, 0, EC_MAX);
    memset(&background, 0, sizeof(background));
    // setup position of screen parts
    dInfo.luw = dInfo.luh = 3;
    dInfo.lw = dInfo.pw / dInfo.luw;
    dInfo.lh = dInfo.ph / dInfo.luh;
    // flag the need to render the game
    dInfo.showGame = TRUE;
    // initialize the score
    textItems[TEXTITEM_REDSCORE].renderer =
    textItems[TEXTITEM_BLUESCORE].renderer = GenericSurfaceRenderer;
    AddRenderItem(&textItems[TEXTITEM_REDSCORE], LAYER_TEXT);
    AddRenderItem(&textItems[TEXTITEM_BLUESCORE], LAYER_TEXT);
    // run through stuff that may need to be run again later
    if (!GraphicReset()) return STATE_ERROR;
    
    if (networkState == NETSTATE_SERVER) {
        // ---- test code ----
        // load up a battlefield
        if (!InitGameConfig("field.bfld")) {
            TextUnsetState();
            // change to the state that displays the error
            return STATE_BFLDERR;
        }
        // advance the target time of the next frame
        frameTime += SRV_FRAME_OFFSET;
        
        // ---- not so testy ----
        // initialize the first player
        localPlayer = 0;
    }
    // configure scrolling
    SetupScrolling();
    // if scrolling is needed . . .
    if (dInfo.scrollField) {
        // put view in the center of the field.
        // calculate the offsets
        int x = -(gameOpts.width >> 1) * dInfo.luw + (dInfo.pw >> 1);
        int y = -(gameOpts.height >> 1) * dInfo.luh + (dInfo.ph >> 1);
        // move the layers to match
        SetLayerOffset(&(layers[LAYER_OBSTACLES]), x, y);
        SetLayerOffset(&(layers[LAYER_NAMES]), x, y);
        SetLayerOffset(&(layers[LAYER_TANKS]), x, y);
    }
    // setup obstacles
    ObstacleInit();
    // put in the background
    AddRenderItem(&background, LAYER_BACKGROUND);
    PlaceRenderItem(&background);
    
    // setup local player data
    players[localPlayer].pid = localPlayer;
    players[localPlayer].flags |= PLAYER_ACTIVE | PLAYER_UPDATE_IDENT |
    PLAYER_DEAD;
    players[localPlayer].team = menuSettings->team;
    //players[localPlayer].deadTime = DEAD_TIME + 1;
    players[localPlayer].x = 1 << 8;
    players[localPlayer].y = (12 * localPlayer) << 8;
    // grab the local player's name
    GetLocalPlayerName(players[localPlayer].name);
    // add the player to the game
    AddPlayer(&players[localPlayer]);
    // update times
    //players[localPlayer].localUpdate++;

    if (networkState != NETSTATE_SERVER) {
        MsgDescr *msg;
        // assemble a message to inform the server about this client's ident
        if ((msg = AppendPlayerData(NULL, &players[localPlayer], 1)) == NULL) {
            // failed to build the message
            return STATE_ERROR;
        }
        // add the message to the system
        if (!AddMessage(msg)) {
            // failed to send the message
            return STATE_ERROR;
        }
    }
    // grab the current time
    frameTime = SDL_GetTicks();
    // record now as the time when all players are updated
    
    // fixup all player positions and sizes
    for (p = players, loop = 0; loop < MAX_PLAYERS; loop++, p++) {
        // only need to adjust active players
        if (p->flags & PLAYER_ACTIVE) {
            p->localUpdate = frameTime;
            p->tank.loc.x = (p->x >> 8) * dInfo.luw;
            p->tank.loc.y = (p->y >> 8) * dInfo.luh;
            p->tank.loc.w = dInfo.luw * 8;
            p->tank.loc.h = dInfo.luh * 8;
            //p->tank.renderer = DrawTank;
            p->shell.loc.w = dInfo.luw;
            p->shell.loc.h = dInfo.luh;
            p->shell.data = &(colorVals[p->team]);
            
            if (!(p->flags & PLAYER_DEAD)) {
                assert(p->pid == loop);
                //QueuePlaceTank(loop);
                //QueuePlaceName(loop);
                PlaceRenderItem(&(p->tank));
                PlacePlayerLabel(p);
                if (p->flags & PLAYER_SHOT) {
                    PlaceRenderItem(&(p->shell));
                }
            }
        }
    }
    // eliminate the menu settings
    free(menuSettings);
    menuSettings = NULL;

    // create a border around the battlefield
    border[0].renderer = border[1].renderer = border[2].renderer =
    border[3].renderer = SolidFillRenderer;
    border[0].data = border[1].data = border[2].data = border[3].data =
    &(colorVals[COLOR_BLACK]);
    // top
    border[0].loc.x = -BORDER_WIDTH * dInfo.luw;
    border[0].loc.y = -BORDER_WIDTH * dInfo.luh;
    border[0].loc.w = (gameOpts.width + (BORDER_WIDTH << 1)) * dInfo.luw;
    border[0].loc.h = BORDER_WIDTH * dInfo.luh;
    // bottom
    border[1].loc.x = -BORDER_WIDTH * dInfo.luw;
    border[1].loc.y = gameOpts.height * dInfo.luh;
    border[1].loc.w = (gameOpts.width + (BORDER_WIDTH << 1)) * dInfo.luw;
    border[1].loc.h = BORDER_WIDTH * dInfo.luh;
    // left
    border[2].loc.x = -BORDER_WIDTH * dInfo.luw;
    border[2].loc.y = 0;
    border[2].loc.w = BORDER_WIDTH * dInfo.luw;
    border[2].loc.h = gameOpts.height * dInfo.luh;
    // right
    border[3].loc.x = gameOpts.width * dInfo.luw;
    border[3].loc.y = 0;
    border[3].loc.w = BORDER_WIDTH * dInfo.luw;
    border[3].loc.h = gameOpts.height * dInfo.luh;
    // give them to the renderer
    AddRenderItem(&border[0], LAYER_OBSTACLES);
    AddRenderItem(&border[1], LAYER_OBSTACLES);
    AddRenderItem(&border[2], LAYER_OBSTACLES);
    AddRenderItem(&border[3], LAYER_OBSTACLES);
    PlaceRenderItem(&border[0]);
    PlaceRenderItem(&border[1]);
    PlaceRenderItem(&border[2]);
    PlaceRenderItem(&border[3]);

    // success
    return STATE_OK;
}

int GameUninit() {
    int loop;
    Player *p;
    #ifdef USE_AUDIO
    // stop all sounds
    StopAllSounds();
    #endif
    // loop through players to eliminate thier dynamic data
    for (p = players, loop = MAX_PLAYERS; loop > 0; loop--, p++) {
        RemovePlayer(p);
    }
    UninitGameConfig();
    // reset layer offsets to zero
    SetupScrolling();
    TextUnsetState();
    // 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);
    // take out the border
    RemoveRenderItem(&border[0]);
    RemoveRenderItem(&border[1]);
    RemoveRenderItem(&border[2]);
    RemoveRenderItem(&border[3]);
    // notices
    RemoveAllNotices();
    // re-render whole next frame
    ForceRenderAll();
    // remove all surfaces from the overlays
    // clear the game render flag
    dInfo.showGame = FALSE;
    // reset the target time for the next frame to remove the difference
    // between client and server
    loop = SDL_GetTicks();
    frameTime = loop - (loop % FRAME_DURATION) + FRAME_DURATION;
    return STATE_OK;
}

int GameRun() {
    static Bool enableLables = FALSE;
    static int animTest = 0;
    SDL_Event event;
    
    // handle a change in the network state
    if ((networkState != NETSTATE_CLIENT)
    && (networkState != NETSTATE_SERVER)) {
        // there is no longer a running game, so go back to the menu
        return STATE_MENUROOT;
    }
    // loop through all waiting events
    while (SDL_PollEvent(&event)) {
        // figure event type
        switch (event.type) {
            case SDL_QUIT:
                return STATE_QUIT;
                break;
            case SDL_ACTIVEEVENT:
                // some strange focus thing
                /*
                if (event.active.gain == 0)
                    eventState[EC_INACTIVE] = TRUE;
                else
                    eventState[EC_INACTIVE] = FALSE;
                */
                break;
            case SDL_KEYDOWN:
                // handle key presses
                switch (event.key.keysym.sym) {
                    case SDLK_ESCAPE:
                        return STATE_QUIT;
                        break;
                    case SDLK_UP:
                    case SDLK_w:
                        eventState[EC_FORWARD] |= 1;
                        break;
                    case SDLK_DOWN:
                    case SDLK_s:
                        eventState[EC_BACKWARD] |= 1;
                        break;
                    case SDLK_LEFT:
                    case SDLK_a:
                        eventState[EC_ROTLEFT] |= 1;
                        break;
                    case SDLK_RIGHT:
                    case SDLK_d:
                        eventState[EC_ROTRIGHT] |= 1;
                        break;
                    case SDLK_RETURN:
                    case SDLK_SPACE:
                        eventState[EC_FIRE] |= 1;
                        break;
                    // case SDLK_l:
                    //   use for score listing display toggle
                    case SDLK_n:
                        if (dInfo.showLabels) {
                            DisablePlayerLabels();
                        }
                        else {
                            enableLables = TRUE;
                            dInfo.showLabels = TRUE;
                        }
                        break;
                    case SDLK_KP_PLUS:
                        animTest++;
                        break;
                    case SDLK_KP_MINUS:
                        animTest--;
                        break;
                    case SDLK_f:
                        #ifndef WIN32
                        if (!eventState[EC_FS_TOGGLE]) {
                            SDL_WM_ToggleFullScreen(dInfo.display);
                            ForceRenderAll();
                            RenderScore(TRUE);
                            SetupScrolling();
                        }
                        #else
                        // ???
                        // will need to call GraphicReset()
                        //GraphicReset();
                        #endif
                    default:
                        break;
                }
                break;
            case SDL_KEYUP:
                switch (event.key.keysym.sym) {
                    case SDLK_UP:
                    case SDLK_w:
                        eventState[EC_FORWARD] = 0;
                        break;
                    case SDLK_DOWN:
                    case SDLK_s:
                        eventState[EC_BACKWARD] = 0;
                        break;
                    case SDLK_LEFT:
                    case SDLK_a:
                        eventState[EC_ROTLEFT] = 0;
                        break;
                    case SDLK_RIGHT:
                    case SDLK_d:
                        eventState[EC_ROTRIGHT] = 0;
                        break;
                    case SDLK_RETURN:
                    case SDLK_SPACE:
                        eventState[EC_FIRE] = 0;
                        break;
                    case SDLK_c:
                        ClearRenderItem(&(players[0].tank));
                        break;
                    case SDLK_v:
                        PlaceRenderItem(&(players[0].tank));
                        break;
                    case SDLK_r:
                        ForceRenderAll();
                    default:
                        break;
                }
                break;
            case SDL_JOYAXISMOTION:
                if (!(SDL_GetAppState() & SDL_APPINPUTFOCUS)) break;
                // x-axis
                if (event.jaxis.axis == 0) {
                    // right
                    if (event.jaxis.value > 16384) {
                        eventState[EC_ROTRIGHT] |= 1;
                        eventState[EC_ROTLEFT] = 0;
                    }
                    // left
                    else if (event.jaxis.value < -16384) {
                        eventState[EC_ROTLEFT] |= 1;
                        eventState[EC_ROTRIGHT] = 0;
                    }
                    // center
                    else {
                        eventState[EC_ROTLEFT] = 0;
                        eventState[EC_ROTRIGHT] = 0;
                    }
                }
                // y-axis
                else if (event.jaxis.axis == 1) {
                    // down
                    if (event.jaxis.value > 16384) {
                        eventState[EC_BACKWARD] |= 1;
                        eventState[EC_FORWARD] = 0;
                    }
                    // up
                    else if (event.jaxis.value < -16384) {
                        eventState[EC_FORWARD] |= 1;
                        eventState[EC_BACKWARD] = 0;
                    }
                    // center
                    else {
                        eventState[EC_FORWARD] = 0;
                        eventState[EC_BACKWARD] = 0;
                    }
                }
                break;
            case SDL_JOYBUTTONDOWN:
                if (!(SDL_GetAppState() & SDL_APPINPUTFOCUS)) break;
                eventState[EC_FIRE] |= 1;
                break;
            case SDL_JOYBUTTONUP:
                if (!(SDL_GetAppState() & SDL_APPINPUTFOCUS)) break;
                eventState[EC_FIRE] = 0;
                break;
            case SDL_VIDEORESIZE:
                ResizeWindow(event.resize.w, event.resize.h);
                // for solid color backgrounds . . .
                if (background.renderer == SolidFillRenderer) {
                    // match the size of the window
                    background.loc.w = dInfo.pw;
                    background.loc.h = dInfo.ph;
                }
                RenderScore(TRUE);
                SetupScrolling();
                // extra steps to configure to the new size
            default:
                break;
        }
    }
    // respond to events
    HandleInput(eventState);
    // ----- run network code ----
    ProcessNetworkMessages();
    // additional to send data
    if ((networkState == NETSTATE_CLIENT) &&
    (players[localPlayer].flags & PLAYER_CLIENT_MASK)) {
        MsgDescr *msg;
        // assemble a message to inform the server about this client
        if ((msg = AppendPlayerData(NULL, &players[localPlayer], frameTime))
        == NULL) {
            // failed to build the message
            return STATE_ERROR;
        }
        // add the message to the system
        if (!AddMessage(msg)) {
            // failed to send the message
            return STATE_ERROR;
        }
        // clear the update flags
        players[localPlayer].flags &= ~PLAYER_UPDATE_ITEMS;
    }
    else if (networkState == NETSTATE_SERVER) {
        MsgDescr *msg = NULL;
        Player *p;
        int loop;
        // loop through the clients
        for (p = players, loop = 0; loop < MAX_PLAYERS; loop++, p++) {
            // only deal with active players and players requiring an update
            if (!(p->flags & PLAYER_ACTIVE) ||
            !(p->flags & PLAYER_UPDATE_ITEMS)) continue;
            // assemble a message to inform clients about this player
            if ((msg = AppendPlayerData(msg, p, frameTime)) == NULL) {
                // failed to build the message
                return STATE_ERROR;
            }
            // clear the update flags
            p->flags &= ~PLAYER_UPDATE_ITEMS; //~0x700;
        }
        // check for an unsent message
        if (msg) {
            AddMessage(msg);
        }
    }
    // score update?
    if (gameOpts.flags & OPT_UPDATESCORE) {
        // clear the update flag
        gameOpts.flags &= ~OPT_UPDATESCORE;
        //  render
        RenderScore(FALSE);
    }
    // scrollable field and living player?
    if (dInfo.scrollField && !(players[localPlayer].flags & PLAYER_DEAD)) {
        // compute the offsets needed to put the player in the middle
        int x = -(players[localPlayer].x >> 8) * dInfo.luw + (dInfo.pw >> 1);
        int y = -(players[localPlayer].y >> 8) * dInfo.luh + (dInfo.ph >> 1);
        // see if the offsets differ from the layer
        if ((x != layers[LAYER_OBSTACLES].offX) ||
        (y != layers[LAYER_OBSTACLES].offY)) {
            // move the layers to match the player's new position
            SetLayerOffset(&(layers[LAYER_OBSTACLES]), x, y);
            SetLayerOffset(&(layers[LAYER_NAMES]), x, y);
            SetLayerOffset(&(layers[LAYER_TANKS]), x, y);
        }
    }
    // show respawn message?
    if ((players[localPlayer].flags & PLAYER_DEAD) &&
    (players[localPlayer].deadTime > DEAD_TIME)) {
        if (!textItems[TEXTITEM_RESPAWN].enableDraw) {
            // set position to mid-screen
            textItems[TEXTITEM_RESPAWN].loc.x =
            (dInfo.pw - textItems[TEXTITEM_RESPAWN].loc.w) >> 1;
            textItems[TEXTITEM_RESPAWN].loc.y =
            (dInfo.ph - textItems[TEXTITEM_RESPAWN].loc.h) >> 1;
            // show the message
            PlaceRenderItem(&textItems[TEXTITEM_RESPAWN]);
        }
    }
    else if (textItems[TEXTITEM_RESPAWN].enableDraw) {
        ClearRenderItem(&textItems[TEXTITEM_RESPAWN]);
    }
    // if requested, re-enable player labels
    if (enableLables) {
        enableLables = FALSE;
        EnablePlayerLabels();
    }
    
    // handle notices
    UpdateNotices(frameTime);
        
    // stay in this state
    return STATE_PLAY;
}

---