gameconfig.c

Go to the documentation of this file.

#ifdef WIN32
#define OpenFile  W32OpenFile
#endif
#include "gameconfig.h"
#include "net.h"
#include "playernet.h"
#include "obstacle.h"
#include "vector.h"
#include "notice.h"
#include <assert.h>
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef WIN32
#undef OpenFile
#endif

ClientData *configListStart = NULL, *configListEnd = NULL;

GameOptions gameOpts = { 0 };

SDL_Rect *spawnAreas[TEAM_MAX];
SDL_Rect *goalAreas[TEAM_MAX];

BattleFieldError bfErr;

#define MAX_TOKEN_LEN  8

static Vector cfgMsgBuffVec = {
    NULL,                              // Vector::lessOp
    BufferVecDestr,                    // Vector::destructOp
    NULL,                              // Vector::array
    sizeof(NetBuffer*),                // Vector::itemSize
    0,                                 // Vector::items
    0,                                 // Vector::size
    32                                 // Vector::minSize
};

static Uint32 *optionMsgFlags = NULL; 

static Uint32 lastTransmit = 0;

static Uint16 nextItem  = 0;

static Uint16 remainOptionMsgs = 0;

static DESTMAPTYPE destMap[DESTMAPLEN] = { 0 };

static const Vector configInitVec = {
    NULL,                      // Vector::lessOp
    NULL,                      // Vector::destructOp
    NULL,                      // Vector::array
    sizeof(SDL_Rect),          // Vector::itemSize
    0,                         // Vector::items
    0,                         // Vector::size
    64                         // Vector::minSize
};

#define FILENAMELEN  (64 - sizeof(FILE*) - sizeof(int) - 4)

struct ConfigFileStackFrame_t {
    FILE *file;
    int line;
    Sint16 xoffset;
    Sint16 yoffset;
    Uint16 width;
    Uint16 height;
    char filename[FILENAMELEN];
    union {
        Uint8 flags;
        struct {
            Bool  flipHoriz : 1;
            Bool  flipVert  : 1;
            Bool  transpose : 1;
        };
    };
};

typedef struct ConfigFileStackFrame_t  ConfigFileStackFrame;

static void ErrorOut(ConfigFileStackFrame *frame, const rtsa_char *format, ...) {
    va_list args;
    rtsa_char errmsg[BFLDERRLEN];
    // get the variable argument list
    va_start(args, format);
    // produce the error message minus the header
    vprnstr(errmsg, BFLDERRLEN, format, args);
    // finished with the variable argument list
    va_end(args);
    // check for a frame
    if (frame) {
        // grab the error location
        bfErr.line = frame->line;
        strncpy(bfErr.file, frame->filename, 80);
        // produce the final error sting including the header
        prnstr(bfErr.msg, BFLDERRLEN, strings[STRING_ERR_READ], frame->filename,
        frame->line, errmsg);
    }
    else {
        // set the error location to indicate the lack of a location
        bfErr.line = -1;
        bfErr.file[0] = 0;
        bfErr.msg[0] = 0;
        // produce the final error sting including the header
        prnstr(bfErr.msg, BFLDERRLEN, strings[STRING_ERR_READ], errmsg);
    }       
    // output to stderr the message
    prnfile(stderr, bfErr.msg);
    // newline
    witechar('\n', stderr);
    // set the error flag
    gameOpts.flags |= OPT_ERROR;
}

static Bool OpenFile(ConfigFileStackFrame *frame) {
    // No backslashes!  It prevents cross platform compatibility.
    if (strchr(frame->filename, '\\')) {
        ErrorOut(frame, strings[STRING_ERR_BACKSLASH], frame->filename);
        frame->file = NULL;
        return FALSE;
    }
    // try to open the file in the user's home directory
        // try to open the file in the working directory
        if ((frame->file = fopen(frame->filename, "rb")) == NULL) {
            // try to open the file in the program's directory
                // failed!
                return FALSE;
        }
    // success!
    return TRUE;
}

static Bool ReadToken(ConfigFileStackFrame *frame, char *buff, int loop) {
    // read in the whole token
    for (; loop < MAX_TOKEN_LEN; loop++) {
        // read the next character
        if ((buff[loop] = tolower(fgetc(frame->file))) == EOF) {
            // bad token
            ErrorOut(frame, strings[STRING_ERR_IO]);
            // terminate with error condition
            return FALSE;
        }
        // check for a line break
        if (buff[loop] == '\n') frame->line++;
        if ((buff[loop] == '\n') || (buff[loop] == '\r')) {
            // end of token in bad spot
            buff[loop] = 0;
            ErrorOut(frame, strings[STRING_ERR_EOL]);
            // terminate with error condition
            return FALSE;
        }
        // check for a space
        if (isspace(buff[loop])) {
            // whole token read
            break;
        }
    }
    // assure NULL termination at the end of the token
    buff[loop] = 0;
    // success!
    return TRUE;
}

static Bool ReadInts(ConfigFileStackFrame *frame, int *array, int flags,
int xoff, int yoff) {
    // attempt to read in the parameters
    if (((flags & 1) &&
    (fscanf(frame->file, "%d %d", &array[0], &array[1]) != 2)) || ((flags & 2)
    && (fscanf(frame->file, "%d %d", &array[2], &array[3]) != 2))) {
        // did not read in all the parameters
        ErrorOut(frame, strings[STRING_ERR_PARAM]);
        // terminate with error condition
        return FALSE;
    }
    // when both coordinates & width/height are given, flipping may change the
    // data
    if (flags == 3) {
        // transpose?
        if (frame->transpose) {
            int x, y;
            x = array[0];
            y = array[1];
            array[0] = y;
            array[1] = x;
            x = array[2];
            y = array[3];
            array[2] = y;
            array[3] = x;
        }
        // flips only done after the size is set
        if (frame->width) {
            // flip hozizontally
            if (frame->flipHoriz) {
                array[0] = frame->width - array[0] - array[2];
            }
            // flip vertically
            if (frame->flipVert) {
                array[1] = frame->height - array[1] - array[3];
            }
        }
    }
    // if coordinates were read . . .
    if (flags & 1) {
        int xsize, ysize;
        // find the maximum width & height
        if (gameOpts.width) {
            // use what it already set
            xsize = gameOpts.width;
            ysize = gameOpts.height;
        }
        else {
            // use the absolute maximums
            xsize = ysize = 2048;
            // show a warning
            /*
            printf(
            "Battlefield warning: %s, line %i:\n\tSpecified location before size statement\n", \
            (frame)->filename, (frame)->line);
            */
        }
        // add in the offsets
        array[0] += xoff;
        array[1] += yoff;
        if ((array[0] < 0) || (array[1] < 0) || (array[0] >= xsize) ||
        (array[1] >= ysize)) {
            // bad x/y
            ErrorOut(frame, strings[STRING_ERR_XYRANGE]);
            // terminate with error condition
            return FALSE;
        }
    }
    // if width & height were read . . .
    if (flags & 2) {
        // check parameter ranges
        if ((array[2] < 1) || (array[3] < 1) || (array[2] >= 2048) ||
        (array[3] >= 2048)) {
            // bad width / height
            ErrorOut(frame, strings[STRING_ERR_WHRANGE]);
            // terminate with error condition
            return FALSE;
        }
    }
    // success!
    return TRUE;
}

static Bool ReadAreaParams(ConfigFileStackFrame *frame, Vector *areas) {
    SDL_Rect *area;
    int vals[4];
    char token[MAX_TOKEN_LEN] = { 0 };
    // read the owning team
    if (!ReadToken(frame, token, 0)) {
        return FALSE;
    }
    // check for red team
    if (strcmp(token, "red") == 0) {
        // obtain the place to put the spawn area
        area = VectorAdd(&areas[TEAM_RED]);
    }
    // check for blue team
    else if (strcmp(token, "blue") == 0) {
        // obtain the place to put the spawn area
        area = VectorAdd(&areas[TEAM_BLUE]);
    }
    // bad team?
    else {
        // invalid team
        ErrorOut(frame, strings[STRING_ERR_BADOWN], token);
        // terminate with error condition
        return FALSE;
    }
    // no memory?
    if (area == NULL) {
        // no memory
        ErrorOut(frame, strings[STRING_ERR_MEM]);
        // terminate with error condition
        return FALSE;
    }
    // read in the area definition
    if (!ReadInts(frame, vals, 3, frame->xoffset, frame->yoffset)) {
        return FALSE;
    }
    // set the spawn area's values
    area->x = vals[0];  // different datatypes; no
    area->y = vals[1];  // better way to do this now
    area->w = vals[2];
    area->h = vals[3];
    // success!
    return TRUE;
}

static Bool CopyAreaData(Vector *input, SDL_Rect **output) {
    // attempt to allocate memory
    if ((*output = malloc(sizeof(SDL_Rect) * input->items)) == NULL) {
        // no more memory
        free(obstacles); // already allocated
        obstacles = NULL;
        ErrorOut(NULL, strings[STRING_ERR_MEM]);
        return FALSE;
    }
    // copy the area data
    memcpy(*output, input->array, sizeof(SDL_Rect) * input->items);
    return TRUE;
}

static void StartLoadConfig(const char *fname) {
    // signals an error and exits the function cleanly
    #define SigErr   goto StartLoadConfig_cleanup

    ConfigFileStackFrame *frame;
    Vector stack = configInitVec, blocks = configInitVec;
    Vector goals[TEAM_MAX], spawns[TEAM_MAX];
    int xoff = 0, yoff = 0;  // offset values
    int loop;
    // finish the vector initalization
    stack.itemSize = sizeof(ConfigFileStackFrame);
    spawns[TEAM_RED] = spawns[TEAM_BLUE] = goals[TEAM_RED] = goals[TEAM_BLUE]
    = configInitVec;
    // this part allocates memory for the vectors -- check for error
    if (!VectorInit(&stack, 64) || !VectorInit(&blocks, 64) ||
    !VectorInit(&spawns[TEAM_RED], 64) || !VectorInit(&spawns[TEAM_BLUE], 64) ||
    !VectorInit(&goals[TEAM_RED], 64) || !VectorInit(&goals[TEAM_BLUE], 64)) {
        // failure!
        SigErr;
    }
    // clear out the size of the battle field
    gameOpts.width = gameOpts.height = 0;

    // create the initial stack frame
    if ((frame = VectorAdd(&stack)) == NULL) {
        // no memory
        ErrorOut(NULL, strings[STRING_ERR_MEM]);
        // exit with error
        SigErr;
    }
    frame->flags = 0;
    frame->width = frame->height = 0;
    frame->xoffset = frame->yoffset = 0;
    frame->line = 1;

    // ----- Read in the configuration from a file -----

    // copy over the file name
    strncpy(frame->filename, fname, FILENAMELEN);
    // assure null termination (if needed, this is probably going to fail)
    frame->filename[FILENAMELEN - 1] = 0;
    // open the file and check for error
    if (!OpenFile(frame)) {
        // show an error
        ErrorOut(frame, strings[STRING_ERR_FOPEN], frame->filename);
        SigErr;
    }

    // loop through the files
    do {
        char token[MAX_TOKEN_LEN] = { 0 };
        // loop while reading the file
        while ((token[0] = tolower(fgetc(frame->file))) != EOF) {
            int vals[4];  // x, y, w, h
            // check for a newline
            if (token[0] == '\n') {
                // increment the line count
                frame->line++;
            }
            // check for a pound sign -- indicates a comment
            else if (token[0] == '#') {
                // read to the end-of-line
                do {
                    // check for error or end-of-file
                    if ((token[0] = fgetc(frame->file)) == EOF) {
                        // continue on with the outer loop
                        break;
                    }
                } while ((token[0] != '\n') && (token[0] != '\r'));
                // increment the line count
                frame->line++;
            }
            // check for the start of a keyword
            else if (isalnum(token[0])) {
                SDL_Rect *rect;
                if (!ReadToken(frame, token, 1)) {
                    // cleanup on error
                    goto StartLoadConfig_cleanup;
                }

                // -- check for a block token --
                if (strcmp(token, "block") == 0) {
                    // attempt to read in the parameters
                    if (!ReadInts(frame, vals, 3, frame->xoffset,
                    frame->yoffset)) {
                        goto StartLoadConfig_cleanup;
                    }
                    // add room for the block and check for failure
                    if ((rect = (SDL_Rect*)VectorAdd(&blocks)) == NULL) {
                        // no memory
                        ErrorOut(frame, strings[STRING_ERR_MEM]);
                        // terminate with error condition
                        SigErr;
                    }
                    // set the obstacle's values
                    rect->x = vals[0];  // different datatypes; no
                    rect->y = vals[1];  // better way to do this now
                    rect->w = vals[2];
                    rect->h = vals[3];
                }

                // -- check for a flip token --
                else if (strcmp(token, "flip") == 0) {
                    // read in the next token
                    if (!ReadToken(frame, token, 0)) {
                        // cleanup on error
                        goto StartLoadConfig_cleanup;
                    }
                    // check the tokem
                    if (strcmp(token, "none") == 0) {
                        // clear the flipping flags
                        frame->flags = 0;
                    }
                    else if (strcmp(token, "trans") == 0) {
                        // set the transpose flag
                        frame->transpose = TRUE;
                    }
                    else if (strcmp(token, "horiz") == 0) {
                        // set the horizontal flip flag
                        frame->flipHoriz = TRUE;
                    }
                    else if (strcmp(token, "vert") == 0) {
                        // set the vertical flip flag
                        frame->flipVert = TRUE;
                    }
                    else {
                        // bad token
                        ErrorOut(frame, strings[STRING_ERR_INVLDKEY], token);
                        // terminate with error condition
                        SigErr;
                    }
                }
                
                // -- check for a goal token --
                else if (strcmp(token, "goal") == 0) {
                    if (!ReadAreaParams(frame, goals)) {
                        SigErr;
                    }
                }
                
                // -- check for an include token --
                else if (strcmp(token, "include") == 0) {
                    char fname[128];
                    ConfigFileStackFrame *incFrame;
                    // prepare offsets
                    xoff = frame->xoffset;
                    yoff = frame->yoffset;
                    // loop through white space
                    do {
                        // check for EOF
                        if ((fname[0] = fgetc(frame->file)) == EOF) {
                            // early EOF
                            ErrorOut(frame, strings[STRING_ERR_EOFINC]);
                            // terminate with error condition
                            SigErr;
                        }
                    } while (isspace(fname[0]));
                    // loop until semi-colon while filling the file name
                    for (loop = 1; loop < 128; loop++) {
                        // get the next byte
                        if ((fname[loop] = fgetc(frame->file)) == EOF) {
                            // bad name
                            fname[loop] = 0;
                            ErrorOut(frame, strings[STRING_ERR_EOFNAME], fname);
                            // terminate with error condition
                            SigErr;
                        }
                        // check for the end of the file name
                        if ((fname[loop] == ';') || (fname[loop] == '\n') ||
                        (fname[loop] == '\r')) {
                            // terminate the string
                            fname[loop] = 0;
                            // get out of this loop
                            break;
                        }
                    }
                    // check for too long of a string
                    if (loop == 127) {
                        // shorten the name
                        fname[10] = 0;
                        // output the error
                        ErrorOut(frame, strings[STRING_ERR_NAMELONG], fname);
                        // terminate with error condition
                        SigErr;
                    }
                    // create a new stack frame
                    if ((incFrame = VectorAdd(&stack)) == NULL) {
                        // inadequate memory
                        ErrorOut(frame, strings[STRING_ERR_MEM]);
                        // terminate with error condition
                        SigErr;
                    }
                    // copy over the file name
                    strcpy(incFrame->filename, fname);
                    // attempt to open the file
                    if (!OpenFile(incFrame)) {
                        // could not open file
                        ErrorOut(frame, strings[STRING_ERR_FOPEN], fname);
                        // terminate with error condition
                        SigErr;
                    }
                    // push the rest of the values onto the stack
                    incFrame->flags  = frame->flags;
                    incFrame->width  = frame->width;
                    incFrame->height = frame->height;
                    frame = incFrame;
                    frame->line = 1;
                    frame->xoffset = xoff;
                    frame->yoffset = yoff;
                }

                // -- check for an offset token --
                else if (strcmp(token, "offset") == 0) {
                    // attempt to read in the parameters
                    if (!ReadInts(frame, vals, 1, xoff, yoff)) {
                        goto StartLoadConfig_cleanup;
                    }
                    // copy over the new offsets
                    frame->xoffset = vals[0];
                    frame->yoffset = vals[1];
                }

                // -- check for a size token --
                else if (strcmp(token, "size") == 0) {
                    // attempt to read in the parameters
                    if (!ReadInts(frame, vals, 2, 0, 0)) {
                        goto StartLoadConfig_cleanup;
                    }
                    // see if a size was not already set
                    if (gameOpts.width == 0) {
                        // check for a field that is too small
                        if ((vals[2] < 32) || (vals[3] < 32)) {
                            // need some room for tanks
                            ErrorOut(frame, strings[STRING_ERR_FLDSMALL],
                            vals[2], vals[3]);
                            // terminate with error condition
                            SigErr;
                        }
                        // copy over the new size
                        gameOpts.width = vals[2];
                        gameOpts.height = vals[3];
                    }
                    // copy the size to this stack frame
                    frame->width = vals[2];
                    frame->height = vals[3];
                }

                // -- check for a spawn token --
                else if (strcmp(token, "spawn") == 0) {
                    if (!ReadAreaParams(frame, spawns)) {
                        SigErr;
                    }
                }
                else {
                    // assure null termination
                    token[MAX_TOKEN_LEN - 1] = 0;
                    // this isn't a tokem
                    ErrorOut(frame, strings[STRING_ERR_INVLDKEY], token);
                    // terminate with error condition
                    SigErr;
                }
            }
        }
        // pop the stack
        fclose(frame->file);
        VectorPop(&stack);
        // get a pointer to the current frame
        frame = &(((ConfigFileStackFrame*)(stack.array))[stack.items - 1]);
        // check for another frame at an earlier position on the stack
        if (stack.items > 1) {
            // grab the previous stack frame's offset values
            xoff = (frame - 1)->xoffset;
            yoff = (frame - 1)->yoffset;
        }
        // check for top of stack
        else if (stack.items == 1) {
            // no previous offsets
            xoff = yoff = 0;
        }
    } while (stack.items > 0); // loop until the stack is exhausted
    // see if a size for the battle field wasn't specified
    if (gameOpts.height == 0) {
        // no size
        ErrorOut(NULL, strings[STRING_ERR_NOSIZE]);
        // terminate with error condition
        SigErr;
    }
    // check for no spawn areas for each team
    if (spawns[TEAM_RED].items == 0) {
        // must have spawn areas
        ErrorOut(NULL, strings[STRING_ERR_NOREDSPN]);
        // terminate with error condition
        SigErr;
    }
    if (spawns[TEAM_BLUE].items == 0) {
        // must have spawn areas
        ErrorOut(NULL, strings[STRING_ERR_NOBLSPN]);
        // terminate with error condition
        SigErr;
    }
    // for CTF games . . .
    if (gameOpts.flags & OPT_ISCTF) {
        // check for no spawn areas for each team
        if (goals[TEAM_RED].items == 0) {
            // must have goal areas
            ErrorOut(NULL, strings[STRING_ERR_NOREDGOAL]);
            // terminate with error condition
            SigErr;
        }
        if (goals[TEAM_BLUE].items == 0) {
            // must have goal areas
            ErrorOut(NULL, strings[STRING_ERR_NOBLGOAL]);
            // terminate with error condition
            SigErr;
        }
    }

    // provide status output on the battlefield
    prnout(strings[STRING_BF_STAT], spawns[TEAM_RED].items,
    spawns[TEAM_BLUE].items, goals[TEAM_RED].items, goals[TEAM_BLUE].items,
    blocks.items);

    // ----- Move the accumulated data from the vectors to the config -----
    //       data structures

    // Start by allocating memory.
    // obstacles
    if (blocks.items > 0) {
        Obstacle *obst;
        SDL_Rect *rect;
        if ((obst = obstacles = malloc((loop = blocks.items) *
        sizeof(Obstacle))) == NULL) {
            // no more memory
            ErrorOut(NULL, strings[STRING_ERR_MEM]);
            SigErr;
        }
        // copy them
        for (rect = blocks.array; loop > 0; loop--, rect++, obst++) {
            obst->loc = *rect;
        }
    }

    // spawn areas - red team
    if (!CopyAreaData(&(spawns[TEAM_RED]), &(spawnAreas[TEAM_RED]))) {
        SigErr;
    }
    // spawn areas - blue team
    if (!CopyAreaData(&(spawns[TEAM_BLUE]), (&spawnAreas[TEAM_BLUE]))) {
        SigErr;
    }
    // for CTF games . . .
    if (gameOpts.flags & OPT_ISCTF) {
        // goals - red team
        if (!CopyAreaData(&(goals[TEAM_RED]), &(goalAreas[TEAM_RED]))) {
            SigErr;
        }
        // goals - blue team
        if (!CopyAreaData(&(goals[TEAM_BLUE]), &(goalAreas[TEAM_BLUE]))) {
            SigErr;
        }
    }
    // set the game options to match
    gameOpts.obstacles = blocks.items;
    gameOpts.spawnAreas[TEAM_RED] = spawns[TEAM_RED].items;
    gameOpts.spawnAreas[TEAM_BLUE] = spawns[TEAM_BLUE].items;
    
    // cleanup
    StartLoadConfig_cleanup:
    // close any files still open in case of error
    frame = &(((ConfigFileStackFrame*)(stack.array))[stack.items - 1]);
    for (loop = stack.items - 1; loop >=0; loop--, frame--) {
        if (frame->file) {
            fclose(frame->file);
        }
    }
    // deallocate all vectors
    VectorDestroy(&stack);
    VectorDestroy(&blocks);
    VectorDestroy(&spawns[TEAM_RED]);
    VectorDestroy(&spawns[TEAM_BLUE]);
    VectorDestroy(&goals[TEAM_RED]);
    VectorDestroy(&goals[TEAM_BLUE]);
    #undef SigErr
}

static Bool MakeAreaBuffers(Uint8 *totalAreas, SDL_Rect **areas, Uint8 type) {
    // set stores the number of rectangkes that can be stored in a message.
    // Becasue of the message format, the number will vary.
    unsigned int loop, team, set = 0;
    SDL_Rect *area;
    Uint8 *ptr = NULL;
    NetBuffer *buff = NULL;

    // make the messages describing the areas (goal or spawn)
    for (team = 0; team < 2; team++) {  // loop through teams
        for (area = areas[team], loop = 0;  // loop through areas
        loop < totalAreas[team]; area++, loop++) {
            // see if a new buffer is needed
            if ((ptr == NULL) ||
            ((MSG_MAX_SIZE - (int)(buff->data - ptr)) < 10)) {
                NetBuffer **spot;
                // first, fill out the stored buffer struct for the just
                // completed message
                if (buff) {
                    buff->length = (Sint16)(ptr - buff->data);
                }
                // allocate another buffer and check for failure
                if ((buff = BufferNew()) == NULL) {
                    // failed
                    return FALSE;
                }
                // get a spot in the vector
                if ((spot = VectorAdd(&cfgMsgBuffVec)) == NULL) {
                    // free the buffer
                    BufferFree(buff);
                    return FALSE;
                }
                // finish storing the new buffer's data
                *spot = buff;
                // write the start of the buffer
                buff->data[0] = type;
                ptr = buff->data + 5;  // skip past the message ID & total msgs
                MSG_WRITE_16(ptr, cfgMsgBuffVec.items - 1);
                MSG_WRITE_8(ptr, totalAreas[TEAM_RED]);
                MSG_WRITE_8(ptr, totalAreas[TEAM_BLUE]);
                // clear the number of areas in the set
                set = 0;
            }
            // see if a new set needs to be made
            if (set == 0) {
                // compute the max number of areas for the next set
                if ((set = (MSG_MAX_SIZE - (int)(ptr - buff->data) - 2) >> 3) >
                (totalAreas[team] - loop)) {
                    // the maximum number of areas exceeds the number of
                    // remaining areas, so handle the remaining areas only
                    set = totalAreas[team] - loop;
                }
                // check for too many areas to fit into a set
                if (set > 64) {
                    // restrict to the amounmt that will fit
                    set = 64;
                }
                // write out the set header
                MSG_WRITE_8(ptr, loop);
                MSG_WRITE_8(ptr, (set - 1) | (team << 6));
            }
            // decrement the count for the next area
            set--;
            // write the next area
            MSG_WRITE_16(ptr, area->x);
            MSG_WRITE_16(ptr, area->y);
            MSG_WRITE_16(ptr, area->w);
            MSG_WRITE_16(ptr, area->h);
        }
        assert(set == 0);
    }
    // filled any buffers?
    if (buff) {
        // set its length
        buff->length = (Sint16)(ptr - buff->data);
    }
    return TRUE;
}

static Bool MakeBuffers() {
    unsigned int loop;
    Uint8 *ptr;
    Obstacle *obst;
    NetBuffer *buff, **spot;
    
    // allocate the game options buffer
    if ((buff = BufferNew()) == NULL) {
        return FALSE;
    }
    // get a spot in the vector
    if ((spot = VectorAdd(&cfgMsgBuffVec)) == NULL) {
        // free the buffer
        BufferFree(buff);
        return FALSE;
    }
    *spot = buff;
    ptr = buff->data;
    buff->length = 20;
    // don't change the length in the next loop
    buff = NULL;
    // build the game options message
    ptr[0] = MSG_TYPE_OPTION;
    ptr[3] = gameOpts.flags;
    ptr += 4;
    MSG_WRITE_32(ptr, gameOpts.duration);
    MSG_WRITE_16(ptr, gameOpts.teamScore[TEAM_RED]);
    MSG_WRITE_16(ptr, gameOpts.teamScore[TEAM_BLUE]);
    MSG_WRITE_16(ptr, gameOpts.winScore);
    MSG_WRITE_16(ptr, gameOpts.width);
    MSG_WRITE_16(ptr, gameOpts.height);
    // Do not write the total number of messages now. The value must be written
    // later when it is known how many messages are in the game configuration.

    // make the messages describing all the obstacles
    for (obst = obstacles, loop = 0; loop < gameOpts.obstacles; obst++, loop++) {
        // check for a need to get a new buffer
        if ((loop % MAX_OBSTACLES_PER_MSG) == 0) {
            // first, fill out the length of the completed messages in the
            // stored buffer struct
            if (buff) {
                buff->length = (Sint16)(ptr - buff->data);
            }
            // allocate another buffer and check for failure
            if ((buff = BufferNew()) == NULL) {
                // failed
                goto MakeBuffers_failure;
            }
            // get a spot in the vector
            if ((spot = VectorAdd(&cfgMsgBuffVec)) == NULL) {
                // free the buffer
                BufferFree(buff);
                goto MakeBuffers_failure;
            }
            // store the  buffer
            *spot = buff;
            // write the start of the buffer
            buff->data[0] = MSG_TYPE_OBSTACLE;
            ptr = buff->data + 5;    // skip past the message ID & total msgs
            MSG_WRITE_16(ptr, cfgMsgBuffVec.items - 1);
            MSG_WRITE_16(ptr, gameOpts.obstacles);
            MSG_WRITE_16(ptr, loop);
        }
        // add the next obstacle to the buffer
        MSG_WRITE_16(ptr, obst->loc.x);
        MSG_WRITE_16(ptr, obst->loc.y);
        MSG_WRITE_16(ptr, obst->loc.w);
        MSG_WRITE_16(ptr, obst->loc.h);
    }
    // if there were any obstacle messages . . .
    if (buff) {
        // store the length of the last message
        buff->length = (Sint16)(ptr - buff->data);
        // prevent the next loop from changing the length
        buff = NULL;
    }
    // make messages describing the spawn areas
    if (!MakeAreaBuffers(gameOpts.spawnAreas, spawnAreas, MSG_TYPE_SPAWN)) {
        goto MakeBuffers_failure;
    }
    // make the messages describing the goal areas
    if (!MakeAreaBuffers(gameOpts.goalAreas, goalAreas, MSG_TYPE_GOAL)) {
        goto MakeBuffers_failure;
    }

    // success
    prnout(strings[STRING_CMPLOPT],
    gameOpts.totalMsgs = gameOpts.rcvdMsgs = cfgMsgBuffVec.items);
    
    // get a pointer to the first option message
    spot = (NetBuffer**)(cfgMsgBuffVec.array);
    // write the number of messages to the game options buffer
    MSG_WRITE_16C((*spot)->data, 18, gameOpts.totalMsgs);
    // loop through the other messages to write the total value to them
    for (spot++, loop = gameOpts.totalMsgs - 1; loop > 0; loop--, spot++) {
        MSG_WRITE_16C((*spot)->data, 3, gameOpts.totalMsgs);
    }
    return TRUE;

    // failure
    MakeBuffers_failure:
    // deallocate all messages
    VectorDestroy(&cfgMsgBuffVec);
    // send back failure code
    return FALSE;
}

// should setup some data and start the game config loading on the I/O thread
Bool InitGameConfig(const char *fname) {
    // clear error status
    gameOpts.flags &= ~OPT_ERROR;
    // initialize the vector of configuration message buffers
    if (!VectorInit(&cfgMsgBuffVec, cfgMsgBuffVec.minSize)) {
        // failure
        return FALSE;
    }
    // load the configuration from the file
    StartLoadConfig(fname);
    // check for failure
    if (gameOpts.flags & OPT_ERROR) {
        // failure -- deallocate the vector
        free(cfgMsgBuffVec.array);
        cfgMsgBuffVec.array = NULL;
        return FALSE;
    }
    // build the network messages that will describe the field to clients
    if (!MakeBuffers()) {
        // failure -- deallocate the vector
        free(cfgMsgBuffVec.array);
        cfgMsgBuffVec.array = NULL;
        return FALSE;
    }
    // success!
    gameOpts.flags |= OPT_ISSET;
    return TRUE;
}

void UninitGameConfig() {
    int loop;
    // clear the pointers for the game config sending list
    configListStart = configListEnd = NULL;
    // clear the next transmission index
    nextItem = 0;
    // eliminate obstacles
    ObstacleUninit();
    // eliminate areas
    for (loop = 0; loop < 2; loop++) {
        if ((gameOpts.goalAreas[loop] > 0) && goalAreas[loop]) {
            free(goalAreas[loop]);
        }
        goalAreas[loop] = NULL;
        gameOpts.goalAreas[loop] = 0;
        if ((gameOpts.spawnAreas[loop] > 0) && spawnAreas[loop]) {
            free(spawnAreas[loop]);
        }
        spawnAreas[loop] = NULL;
        gameOpts.spawnAreas[loop] = 0;
    }
    // if the message flags are still allocated . . .
    if (optionMsgFlags) {
        // deallocate them
        free(optionMsgFlags);
        optionMsgFlags = NULL;
    }
    // clear the game options
    memset(&gameOpts, 0, sizeof(gameOpts));
    // clear the destination map for config messages
    memset(destMap, 0, sizeof(destMap));
    // remove all message buffers
    VectorDestroy(&cfgMsgBuffVec);
}

void AddToConfigList(ClientData *client) {
    MsgDescr *msg = NULL;
    Player *p;
    int loop, now, ind, destflag, flags;
    // add the client to the config linked list
    if ((client->configPrev = configListEnd) == NULL) {
        configListStart = configListEnd = client;
    }
    else {
        configListEnd->configNext = client;
        configListEnd = client;
    }
    client->configNext = NULL;
    // record the index of the first item it should receive
    client->configFirst = nextItem;
    // add the destination flag
    destMap[ind = GetDestMapIndex(client->cid)] |=
        destflag = GetDestMapFlag(client->cid);
    // use now for the update time
    now = SDL_GetTicks();
    // create a message with player idents for the new client
    for (p = players, loop = MAX_PLAYERS; loop > 0; loop--, p++) {
        // skip this player?
        if (!(p->flags & PLAYER_ACTIVE))
            continue;
        // store flags
        flags = p->flags;
        // set update flags
        p->flags |= PLAYER_UPDATE_IDENT | PLAYER_UPDATE_DFS;
        if (!(p->flags & PLAYER_DEAD)) {
            p->flags |= PLAYER_UPDATE_TANK | PLAYER_UPDATE_SHELL;
        }
        // produce the message
        if ((msg = AppendPlayerData(msg, p, now)) == NULL) {
            // oh, bother
            return;
        }
        // change the message -- no broadcast, and destined only for this new
        // client
        msg->bcast = msg->mcast = FALSE;
        msg->destMap[ind] = destflag;
        // restore original flags
        p->flags = flags;
    }
    // send it
    if (msg) {
        AddMessage(msg);
    }
    // send the score, too
    SendScoreUpdate(NULL, 0);
}

void RemoveFromConfigList(ClientData *client) {
    // in the list and not the first
    if (client->configPrev != NULL) {
        client->configPrev->configNext = client->configNext;
        // last in the list
        if (client->configNext == NULL) {
            configListEnd = client->configPrev;
        }
    }
    // first in the list
    else if (client == configListStart) {
        // also last in the list?
        if ((configListStart = client->configNext) == NULL) {
            configListEnd = NULL;
        }
    }
    // clear the client's list pointers
    client->configNext = client->configPrev = NULL;
    // remove the destination flag
    destMap[GetDestMapIndex(client->cid)] &=
        ~GetDestMapFlag(client->cid);
}

Bool ServiceGameConfig() {
    ClientData *client;
    MsgDescr *msg;
    Uint32 now, loop;
    // check for no clients waiting on the game config, or an unset config, or
    // still waiting for more time to pass

    if ((configListStart == NULL) || !(gameOpts.flags & OPT_ISSET) ||
    (((now = SDL_GetTicks()) - lastTransmit) < 64)) {
        //  do something else
        return TRUE;
    }
    // grab a new message and check for failure
    if ((msg = MessageNew()) == NULL) {
        // could not allocate a message
        return FALSE;
    }
    // grab the corresponding message buffer
    msg->buffer = *(NetBuffer**)VectorItem(&cfgMsgBuffVec, nextItem);
    assert(msg->buffer != NULL);
    assert(msg->buffer->length > 0);
    // Setup the message descriptor.
    msg->approveFunc = NULL;
    msg->ackFunc =  NULL;
    msg->failFunc = NULL;
    msg->bcast = msg->buffLifeUnmanaged = TRUE;  // broadcast OK, keep the buffer
    for (loop = 0; loop < DESTMAPLEN; loop++) {
        msg->destMap[loop] = destMap[loop];  // hope for an optimizing compiler
    }
    // send the messgae to all the clients still in the list
    if (!AddMessage(msg)) {
        //printf("Failed to add config message\n");
        // could not send the message
        return FALSE;
    }
    // advance the index
    if (++nextItem == cfgMsgBuffVec.items) {
        // advanced past the last message -- wrap around back to the first
        // message
        nextItem = 0;
    }
    //msg = NULL;
    // remove clients that have been sent all the config data
    while (configListStart->configFirst == nextItem) {
        // if a message with player data has not been created yet . . .
        //if (!msg) {
            // create it
        //}
        // add this client to the destination list of the player list
        // get a reference to the client that will be removed from the list
        client = configListStart;
        // remove the destination flag
        destMap[GetDestMapIndex(client->cid)] &=
            ~GetDestMapFlag(client->cid);
        // remove the client and see if it was the last client in the list
        if ((configListStart = configListStart->configNext) == NULL) {
            assert(client == configListEnd);
            // fixup the end of the list
            configListEnd = NULL;
            // nothing left to do
            break;
        }
        // clear the client's list pointers
        client->configNext = client->configPrev = NULL;
    }
    // success!
    return TRUE;
}

static Bool FlagCfgMsg(int max, int index) {
    int arrayInd, arrayBit;
    // check for an already allocated array for option message flags
    if (optionMsgFlags == NULL) {
        // allocate the array
        if ((optionMsgFlags = calloc(rounddivup(max, 32), 4)) == NULL) {
            // failure
            return FALSE;
        }
        // set the sizes
        gameOpts.totalMsgs = remainOptionMsgs = max;
    }
    // check for an inconsistent number of option messages
    else if (max != gameOpts.totalMsgs) {
        // could be bad data, so reject this message
        return FALSE;
    }
    // by this point, there should be more options to read
    assert(remainOptionMsgs > 0);
    // compute the array spot of the flag
    arrayInd = bitindex(index, Uint32);
    arrayBit = bitflag(index, Uint32);
    // see if the flag is not already set
    if (!(optionMsgFlags[arrayInd] & arrayBit)) {
        // flag the indicated message as received
        optionMsgFlags[arrayInd] |= arrayBit;
        // one less message to receive
        if (--remainOptionMsgs == 0) {
            // transition to the client state
            networkState = NETSTATE_CLIENT;
            // deallocate the message flags
            free(optionMsgFlags);
            optionMsgFlags = NULL;
        }
        // message is good & new
        return TRUE;
    }
    // message is old -- do not parse
    return FALSE;
}

Bool HandleGameOption(SocketAddr *origin, NetBuffer *buffer, Uint8 *unused,
Uint16 noid) {
    int total;
    // this message is only valid when received by clients
    if ((networkState < NETSTATE_RCVCFG) || (networkState > NETSTATE_CLIENT) ||
    (buffer->length != 20) || !ValidateServer(origin)) {
        // ignore this message
        return FALSE;
    }
    // ack but ignore if this client is no longer reading in the config options
    if (networkState != NETSTATE_RCVCFG) {
        return TRUE;
    }
    // determine the total number of messages
    MSG_READ_16C(buffer->data, 18, total);
    // see if this message should be parsed
    if (FlagCfgMsg(total, 0)) {
        // read in the options
        gameOpts.flags = buffer->data[3];
        MSG_READ_32C(buffer->data, 4,  gameOpts.duration);
        MSG_READ_16C(buffer->data, 8,  gameOpts.teamScore[TEAM_RED]);
        MSG_READ_16C(buffer->data, 10, gameOpts.teamScore[TEAM_BLUE]);
        MSG_READ_16C(buffer->data, 12, gameOpts.winScore);
        MSG_READ_16C(buffer->data, 14, gameOpts.width);
        MSG_READ_16C(buffer->data, 16, gameOpts.height);
    }
    return TRUE;
}

Bool HandleObstacle(SocketAddr *origin, NetBuffer *buffer, Uint8 *unused,
Uint16 noid) {
    int total, msgIndex;
    Uint16 numObst, index, loop;
    Obstacle *obst;
    Uint8 *ptr;
    // this message is only valid when received by clients
    if ((networkState < NETSTATE_RCVCFG) || (networkState > NETSTATE_CLIENT) ||
    !ValidateServer(origin)) {
        // ignore this message
        return FALSE;
    }
    // ack but ignore if this client is no longer reading in the config options
    if (networkState != NETSTATE_RCVCFG) {
        return TRUE;
    }
    // move to the number of option messages
    ptr = buffer->data + 3;
    // read the number of messages
    MSG_READ_16(ptr, total);
    // read the index of this message
    MSG_READ_16(ptr, msgIndex);
    // see if this message has already been read
    if (!FlagCfgMsg(total, msgIndex)) {
        // quit now, but still acknowledge the message
        return TRUE;
    }
    // read the number of obstacles
    MSG_READ_16(ptr, numObst);
    // no obstacles already made?
    if ((gameOpts.obstacles == 0) && (numObst > 0)) {
        // set the new total, allocate memory for it, check for error
        if ((obstacles =
        malloc(sizeof(Obstacle) * (gameOpts.obstacles = numObst))) == NULL) {
            // assure size is zero
            gameOpts.obstacles = 0;
            // set error condition
            gameOpts.flags |= OPT_ERROR;
            // quit this
            return FALSE;
        }
    }
    // check for a change in the total
    else if (gameOpts.obstacles != numObst) {
        // this shouldn't normally happen, but ignore it when it does
        return FALSE;
    }
    // read in the starting index
    MSG_READ_16(ptr, index);
    // not a valid start index?
    if ((index >= numObst) || (index % MAX_OBSTACLES_PER_MSG)) {
        // set error condition
        gameOpts.flags |= OPT_ERROR;
        // quit
        return FALSE;
    }
    // set the maximum number of obstacles
    loop = ((numObst - index) >= MAX_OBSTACLES_PER_MSG) ? MAX_OBSTACLES_PER_MSG
    : numObst - index;
    // loop through all transmitted obstacles
    for (obst = &(obstacles[index]); loop > 0; loop--, obst++) {
        // x coordinate
        MSG_READ_16(ptr, obst->loc.x);
        // y coordinate
        MSG_READ_16(ptr, obst->loc.y);
        // width
        MSG_READ_16(ptr, obst->loc.w);
        // height
        MSG_READ_16(ptr, obst->loc.h);
    }
    return TRUE;
}

Bool HandleArea(SocketAddr *origin, NetBuffer *buffer, Uint8 *unused,
Uint16 noid) {
    int loop, total, msgIndex;
    SDL_Rect *rect, **areas;
    Uint8 *ptr, *numAreas, team, togo;
    // this message is only valid when received by clients
    if ((networkState < NETSTATE_RCVCFG) || (networkState > NETSTATE_CLIENT) ||
    !ValidateServer(origin)) {
        // ignore this message
        return FALSE;
    }
    // ack but ignore if this client is no longer reading in the config options
    if (networkState != NETSTATE_RCVCFG) {
        return TRUE;
    }
    // move to the number of option messages
    ptr = buffer->data + 3;
    // read the number of messages
    MSG_READ_16(ptr, total);
    // read the index of this message
    MSG_READ_16(ptr, msgIndex);
    // see if this message has already been read
    if (!FlagCfgMsg(total, msgIndex)) {
        // quit now, but still acknowledge the message
        return TRUE;
    }
    // setup pointers to the type of area to operate upon
    switch (buffer->data[0]) {
        // spawn areas
        case MSG_TYPE_SPAWN:
            numAreas = gameOpts.spawnAreas;
            areas = spawnAreas;
            break;
        // goal areas
        case MSG_TYPE_GOAL:
            numAreas = gameOpts.goalAreas;
            areas = goalAreas;
            break;
        default:
            // shouldn't ever get here; otherwise, something in the message
            // system is screwed
            assert(0);
            exit(__LINE__);
    }
    // loop through supported teams
    for (loop = 0; loop < 2; loop++, ptr++) {
        // see if the areas have not been created
        if ((numAreas[loop] == 0) && (*ptr > 0)) {
            // set the new total, allocate memory for it, check for error
            if ((areas[loop] =
            malloc(sizeof(SDL_Rect) * (numAreas[loop] = *ptr))) == NULL) {
                // assure size is zero
                numAreas[loop] = 0;
                // set error condition
                gameOpts.flags |= OPT_ERROR;
                // quit this
                return FALSE;
            }
        }
        // check for a change in the total
        else if (numAreas[loop] != *ptr) {
            // this shouldn't normally happen, but ignore it when it does
            return FALSE;
        }
    }
    // loop while there is enough data left in the buffer for at least one more
    // header and one more area rect
    while ((buffer->length - (ptr - buffer->data)) >= 10) {
        // read in the index of the next area
        MSG_READ_8(ptr, loop);
        // read in the number of areas to read
        togo = (*ptr & 0x3F) + 1;
        // read in the owning team
        team = *(ptr++) >> 6;
        // assure the range to be read is within bounds
        if (((loop + togo) > numAreas[team]) ||
        ((ptr - buffer->data + togo * 8) > buffer->length)) {
            // bad data; quit now
            return FALSE;
        }
        // loop through all the indicated areas
        for (rect = &(areas[team][loop]); togo > 0; togo--, rect++) {
            // x coordinate
            MSG_READ_16(ptr, rect->x);
            // y coordinate
            MSG_READ_16(ptr, rect->y);
            // width
            MSG_READ_16(ptr, rect->w);
            // height
            MSG_READ_16(ptr, rect->h);
        }
    }
    return TRUE;
}

Bool HandleScoreUpdate(SocketAddr *origin, NetBuffer *buffer, Uint8 *unused,
Uint16 noid) {
    int playerUpdates, killerID, killedID;
    Uint8 *data;
    Sint16 score;
    // this message is only valid when received by clients
    if (((networkState != NETSTATE_RCVCFG) && (networkState != NETSTATE_CLIENT))
    || (buffer->length < 8) || !ValidateServer(origin)) {
        // ignore this message
        return FALSE;
    }
    // move past message header
    data = buffer->data + 3;
    // read in the new score(s)
    MSG_READ_8(data, playerUpdates);
    // check the range -- can't have more players score than players
    if (playerUpdates > MAX_PLAYERS) {
        // bad data
        return FALSE;
    }
    MSG_READ_16(data, gameOpts.teamScore[TEAM_RED]);
    MSG_READ_16(data, gameOpts.teamScore[TEAM_BLUE]);
    // for each player score update . . .
    for (; playerUpdates > 0; playerUpdates--) {
        MSG_READ_8(data, killerID);
        MSG_READ_8(data, killedID);
        MSG_READ_16(data, score);
        // check data ranges
        if ((killerID >= MAX_PLAYERS) || (killedID >= MAX_PLAYERS)) {
            // bad data
            return FALSE;
        }
        // add the notice on-screen
        AddScoreNotice(killerID, killedID, score);
    }
    // signal the need to render the new score
    gameOpts.flags |= OPT_UPDATESCORE;
    return TRUE;
}

Bool SendScoreUpdate(ScoreUpdate *scores, int len) {
    MsgDescr *msg;
    Uint8 *data;
    // only the server should send scores
    assert(networkState == NETSTATE_SERVER);
    // either scores is not NULL or there are no player score updates
    assert((len == 0) || (scores != NULL));
    // get a message descriptior
    if ((msg = MessageNew()) == NULL) {
        // didn't work
        return FALSE;
    }
    // get a buffer
    if ((msg->buffer = BufferNew()) == NULL) {
        // no buffer
        MessageFree(msg);
        return FALSE;
    }
    data = msg->buffer->data;
    // setup the message descriptor
    msg->approveFunc = NULL;
    msg->ackFunc = NULL;
    msg->failFunc = MsgFailDisconnect;
    msg->interval <<= 2;
    SetDestToAll(msg);
    // build the response message
    MSG_WRITE_8(data, MSG_TYPE_SCORE);
    data += 2;         // move past ID
    MSG_WRITE_8(data, len);
    MSG_WRITE_16(data, gameOpts.teamScore[TEAM_RED]);
    MSG_WRITE_16(data, gameOpts.teamScore[TEAM_BLUE]);
    for (; len > 0; len--, scores++) {
        // killer
        MSG_WRITE_8(data, scores->killerId);
        // killed
        MSG_WRITE_8(data, scores->killedId);
        // new score
        MSG_WRITE_16(data, players[scores->killerId].kills);
    }
    // compute the number of bytes written
    msg->buffer->length = data - msg->buffer->data;
    msg->bcast = TRUE;
    // send it
    SetDestToAll(msg);
    AddMessage(msg);
    return TRUE;
}

---