playernet.c

Go to the documentation of this file.

#include "color.h"
#include "playernet.h"
#include "game.h"
#include "net.h"
#include <assert.h>
#include <string.h>
#ifdef USE_AUDIO
#include "audio.h"
#endif

#if (MAX_PLAYERS > 256)
#error More than 256 players is not supported.
#endif

MsgDescr *AppendPlayerData(MsgDescr *msg, Player *p, Uint32 time) {
    Uint8 *ptr;
    int flags, len = 3, nameLen;  // this is NOT used uninitialized
    
    // either there is no message to append to, or the message must be
    // a player update message
    assert((msg == NULL) || (msg->buffer->data[0] == MSG_TYPE_PLAYER_UPDATE));
    
    // limit the update and other flags to what is valid to send
    if (networkState == NETSTATE_CLIENT) {
        // clients can only transmit a subset of the flags
        flags = p->flags & (PLAYER_CLIENT_MASK | PLAYER_MOVEMENT_MASK);
    }
    else {
        // servers can transmit any flag
        flags = p->flags;
    }
    // there must be something to update
    assert(flags & PLAYER_UPDATE_ITEMS);
    // compute the length of this addition
    if (flags & PLAYER_UPDATE_IDENT) {
        len += 1 + ((nameLen = (int)rtsa_strlen(p->name)) << 1);
        assert(nameLen < MAX_NAME_LEN); // name must fit
    }
    if (flags & PLAYER_UPDATE_TANK) {
        len += 10;
    }
    if (flags & PLAYER_UPDATE_SHELL) {
        len += 12;
    }
    // only the server can include the DFS data set
    if (flags & PLAYER_UPDATE_DFS) {
        len += 5;
    }
    // for no message or inadequate room . . .
    if ((msg == NULL) || ((MSG_MAX_SIZE - msg->buffer->length) < len)) {
        // if a message was being built, add it to the system
        if ((msg != NULL) && !AddMessage(msg)) {
            // failed; send back an error code
            return NULL;
        }
        // create a new message
        if ((msg = MessageNew()) == NULL) {
            // failed; send back an error code
            return NULL;
        }
        // create a new buffer for the message
        if ((msg->buffer = BufferNew()) == NULL) {
            // failed; remove the message send back an error code
            MessageFree(msg);
            return NULL;
        }
        // setup the message descriptor
        msg->approveFunc = NULL;
        msg->ackFunc = NULL;
        msg->failFunc = MsgFailDisconnect;
        // Write the start of the player update message
        msg->buffer->length = 7;
        msg->buffer->data[0] = MSG_TYPE_PLAYER_UPDATE;
        MSG_WRITE_32C(msg->buffer->data, 3, time);
        // set the destination
        if (networkState == NETSTATE_SERVER) {
            // tell everyone of the update
            SetDestToAll(msg);
        }
        else {
            // this must be set to indicate the server is the destination
            msg->destMap[0] = 1;
        }
    }
    // get a pointer to the next byte of the buffer
    ptr = &(msg->buffer->data[msg->buffer->length]);
    // advance the length
    msg->buffer->length += len;
    // add the player data to the message's buffer
    MSG_WRITE_8(ptr, p->pid);
    // the player flags include the items updated in the message and often
    // updated flags, like the ones for player input
    MSG_WRITE_16(ptr, flags);
    // write name and team
    if (flags & PLAYER_UPDATE_IDENT) { // <65 bytes
        int loop;
        // lower 5 bits are the length of the name string
        // upper 2 bits are the team ID
        MSG_WRITE_8(ptr, nameLen | p->team << 6);
        // produce the name
        loop = TextNativeToUTF16((Uint16*)ptr, MAX_NAME_LEN, p->name,
        nameLen);
        assert(loop == nameLen);
        //memcpy(ptr, p->name, nameLen);
        ptr += nameLen << 1;
    }
    // write dead time, flags, and score
    if (flags & PLAYER_UPDATE_DFS) {
        // 5 bytes -- only transmitted by the server
        //MSG_WRITE_16(ptr, p->flags);
        MSG_WRITE_16(ptr, p->kills);
        MSG_WRITE_16(ptr, p->captures);
        MSG_WRITE_8(ptr, p->deadTime);
    }
    // write a tank position update?
    if (flags & PLAYER_UPDATE_TANK) { // 10 bytes
        MSG_WRITE_32(ptr, p->x);
        MSG_WRITE_32(ptr, p->y);
        MSG_WRITE_16(ptr, p->rot);
    }
    // write shell position
    if (flags & PLAYER_UPDATE_SHELL) { // 12 bytes
        MSG_WRITE_32(ptr, p->shellX);
        MSG_WRITE_32(ptr, p->shellY);
        MSG_WRITE_16(ptr, p->shellRot);
        MSG_WRITE_16(ptr, p->shellDist);
    }
    // assure the correct amount of data was written to the buffer
    assert(ptr == msg->buffer->data + msg->buffer->length);
    // send back the current message
    return msg;
}

static int CalculateOffset(NetBuffer *buffer, int offset) {
    int flags;
    // grab the upper byte of the player flags
    flags = buffer->data[++offset] << 8; // counts the ID
    // if the data is from a client . . .
    if (networkState == NETSTATE_SERVER) {
        // DFS data set cannot be included
        flags &= PLAYER_CLIENT_MASK;
    }
    // if the identity is included . . .
    if ((flags & PLAYER_UPDATE_IDENT) && (++offset < buffer->length)) {
        // . . . count it its length
        offset += (buffer->data[offset + 1] & 0x1F) << 1;
    }
    // compute the length for everything except the identity
    offset += ((flags & PLAYER_UPDATE_TANK)  ? 10 : 0) +
              ((flags & PLAYER_UPDATE_SHELL) ? 12 : 0) +
              ((flags & PLAYER_UPDATE_DFS)   ?  5 : 0) + 2; // counts the flags
    // final bounds check
    if (offset > buffer->length) {
        // too big
        offset = -offset;
    }
    return offset;
}

static Uint8 *ReadPlayer(Uint8 *ptr, Uint32 time) {
    Player *p;
    int flags, pid;
    Bool readTank = FALSE;
    
    // read the player index
    MSG_READ_8(ptr, pid);
    #if (MAX_PLAYERS < 256)
    // check for an index that is outside allowable bounds
    if (pid >= MAX_PLAYERS) return FALSE;
    #endif
    // get a pointer to the player object
    p = &(players[pid]);
    // read the player's flags
    MSG_READ_16(ptr, flags);
    // for servers . . .
    if (networkState == NETSTATE_SERVER) {
        // the client cannot send the DFS data set
        flags &= PLAYER_CLIENT_MASK | PLAYER_MOVEMENT_MASK;
        // store the new flags, but do not let the client change the
        // active or dead flags
        p->flags = (p->flags & (PLAYER_DEAD | PLAYER_ACTIVE |
        PLAYER_MOVEMENT_MASK)) | (flags & ~PLAYER_MOVEMENT_MASK); 
    }
    // for clients . . .
    else {
        // when updating the local player . . .
        if (p->pid == localPlayer) {
            // ignore all player input related flags when the server updates
            // this client's player, and assure it reamins active
            flags = (flags & PLAYER_LOCAL_MASK) | PLAYER_ACTIVE;
            // already dead?
            if (p->flags & PLAYER_DEAD) {
                // ok to read in the tank position
                readTank = TRUE;
            }
            #ifdef USE_AUDIO
            // just killed? only handles remote (non-server) players
            else if (flags & PLAYER_DEAD) {
                // play the death sound
                PlayLocalDeath();
            }
            #endif
            // update the flags
            p->flags = (flags & ~(PLAYER_UPDATE_IDENT | PLAYER_MOVEMENT_MASK |
            PLAYER_UPDATE_TANK | PLAYER_UPDATE_SHELL)) |
            (p->flags & (PLAYER_UPDATE_IDENT | PLAYER_MOVEMENT_MASK |
            PLAYER_UPDATE_TANK | PLAYER_UPDATE_SHELL));
        }
        else {
            // update the flags, but do not change the active flag
            p->flags = (flags & ~(PLAYER_ACTIVE | PLAYER_MOVEMENT_MASK)) |
            (p->flags & (PLAYER_ACTIVE | PLAYER_MOVEMENT_MASK));
            #ifdef USE_AUDIO
            // dead?
            if ((p->flags & PLAYER_DEAD) && ((p->deadTime == 0) ||
            (p->deadTime > DEAD_TIME))) {
                // compute the square of the distance
                int distsq = DistSq(p, &players[localPlayer]);
                // close enough to hear?
                if (distsq < MAX_SQ_DIST) {
                    // play the death sound
                    PlayTankKilled(distsq);
                }
            }
            #endif
        }
        // if the player is dead . . .
        if (p->flags & PLAYER_DEAD) {
            // clear the movement flags and get rid of the shell
            p->flags &= ~(PLAYER_SHOT | PLAYER_FORWARD | PLAYER_BACKWARD |
            PLAYER_ROTRIGHT | PLAYER_ROTLEFT | PLAYER_SHOT);
            // assure no shell is drawn
            ClearRenderItem(&(p->shell));
            RemoveShell(p->pid);
            // ok to read in the tank position
            readTank = TRUE;
        }
    }
    // read name and team
    if (flags & PLAYER_UPDATE_IDENT) { // <33 bytes
        int nameLen;
        // read the combined string length and team
        MSG_READ_8(ptr, nameLen);
        // check for a new update
        if (time > p->lastUpdate.identTime) {
            int len;
            // clear the update flag
            p->flags &= ~PLAYER_UPDATE_IDENT;
            // set the update time
            p->lastUpdate.identTime = time;
            // upper 2 bits are the team ID
            p->team = nameLen >> 6;
            // the lower 5 bits are the length of the name string
            // copy the name
            len = TextUTF16toNative(p->name, MAX_NAME_LEN, (Uint16*)ptr,
            nameLen &= 0x1F);
            assert(len == nameLen);
            //memcpy(p->name, ptr, (nameLen &= 0x1F));
            ptr += nameLen << 1;
            //p->name[nameLen] = 0;  // null terminator not transmitted
            #ifdef MSG_DEBUG
            printf("Got ident for player #%d, %s\n", p->pid, p->name);
            #endif
        }
        else {
            // skip past the old data
            ptr += (nameLen & 0x1F) << 1;
            #ifdef MSG_DEBUG
            printf("Ignoring ident for player #%d, %s\n", p->pid, p->name);
            #endif
        }
    }

    if (!(p->flags & PLAYER_ACTIVE)) {
        p->pid = pid;
        p->flags |= PLAYER_DEAD;
        AddPlayer(p);
    }
    
    assert(pid == p->pid);

    // read dead time, flags, and score
    if (flags & PLAYER_UPDATE_DFS) { // 5 bytes
        // check for a new update
        if (time > p->lastUpdate.dfsTime) {
            // set the update time
            p->lastUpdate.dfsTime = time;
            // read in the data
            MSG_READ_16(ptr, p->kills);
            MSG_READ_16(ptr, p->captures);
            MSG_READ_8(ptr, p->deadTime);
            // no shell -- this player may have scored a kill
            if (!(flags & PLAYER_SHOT)) {
                p->flags &= ~PLAYER_SHOT;
                // assure no visible shell
                ClearRenderItem(&(p->shell));
                RemoveShell(p->pid);
            }
            // if a client and the player is alive
            if (!(flags & PLAYER_DEAD)) {
                // assure the dead flag is not set
                p->flags &= ~PLAYER_DEAD;
            }
            #ifdef MSG_DEBUG
            printf("Got DFS update for player #%d at time %d\n", p->pid, time);
            #endif
        }
        else {
            // skip past the old data
            ptr += 5;
        }
    }
    
    // read tank position
    if (flags & PLAYER_UPDATE_TANK) { // 10 bytes
        // check for a new update
        if ((readTank || (pid != localPlayer)) &&
        (time > p->lastUpdate.tankPosTime)) {
            Uint16 oldRot = p->rot;
            // clear the update flag and apply the new movement flags
            p->flags = (p->flags & ~(PLAYER_UPDATE_TANK | PLAYER_MOVEMENT_MASK))
            | (flags & PLAYER_MOVEMENT_MASK);
            // set the update time
            p->lastUpdate.tankPosTime = time;
            // read in the data
            MSG_READ_32(ptr, p->x);
            MSG_READ_32(ptr, p->y);
            MSG_READ_16(ptr, p->rot);
            // place the tank
            if (!(p->flags & PLAYER_DEAD)) {
                MoveTank(p, 0);
                // rotation only update?
                if (!p->tank.placed && ((oldRot & 0xF00) != (p->rot & 0xF00))) {
                    // record that the whole tank must be redrawn
                    QueuePlaceTank(p->pid);
                }
            }
            #ifdef MSG_DEBUG
            printf("Got tank update for player #%d at time %d\n", p->pid, time);
            printf("\tcoords: x = %d   y = %d\n", p->x >> 8, p->y >> 8);
            #endif
        }
        else {
            // skip past the old or local data
            ptr += 10;
            #ifdef MSG_DEBUG
            printf("Ignoring tank update for player #%d at time %d\n", p->pid,
            time);
            #endif
        }
    }
    
    // read shell position
    if (flags & PLAYER_UPDATE_SHELL) { // 12 bytes
        // check for a new update
        if ((pid != localPlayer) && !(p->flags & PLAYER_DEAD) &&
        (time > p->lastUpdate.tankPosTime)) {
            // clear the update flag
            p->flags &= ~PLAYER_UPDATE_SHELL;
            // set the update time
            p->lastUpdate.shellPosTime = time;
            // read in the data
            MSG_READ_32(ptr, p->shellX);
            MSG_READ_32(ptr, p->shellY);
            MSG_READ_16(ptr, p->shellRot);
            MSG_READ_16(ptr, p->shellDist);
            // setup the shell's location
            p->shell.loc.x = (p->shellX >> 8) * dInfo.luh;
            p->shell.loc.y = (p->shellY >> 8) * dInfo.luh;
            // the shell (shot) flag
            if (flags & PLAYER_SHOT) {
                // set the flag
                p->flags |= PLAYER_SHOT;
                // place it onscreen
                QueuePlaceShell(p->pid);
                #ifdef USE_AUDIO
                // is this not the local player?
                if ((p->pid != localPlayer) &&
                !(players[localPlayer].flags & PLAYER_DEAD)) {
                    // compute the distance to this sound
                    int distsq = DistSq(p, &players[localPlayer]);
                    // if close enough to hear . . .
                    if (distsq < MAX_SQ_DIST) {
                        // play it
                        PlayTankShoot(distsq);
                    }
                }
                #endif
            }
            else {
                // clear the flag
                p->flags &= ~PLAYER_SHOT;
                // take it off-screen
                ClearRenderItem(&(p->shell));
                RemoveShell(p->pid);
            }
        }
        else {
            // skip past the old or local data
            ptr += 12;
        }
    }

    // for servers . . .
    if (networkState == NETSTATE_SERVER) {
        // keep the update flags -- needed to update all clients
        p->flags |= flags & PLAYER_UPDATE_ITEMS;
    }
    
    // return the buffer cursor
    return ptr;
}

Bool HandlePlayerUpdate(SocketAddr *origin, NetBuffer *buffer, Uint8 *clientId,
Uint16 messageId) {
    int len = 7;  // iterating part of message starts after 7 bytes
    Uint32 time;  // common game time of the player update
    Uint8 *ptr;
    // enforce a minimum length
    if (buffer->length < 12) return FALSE;
    // see if this process is a client
    if ((networkState >= NETSTATE_RCVCFG) && (networkState <= NETSTATE_CLIENT)
    && ValidateServer(origin)) {
        int numplay = 0;
        // assure a proper fit for all players
        do {
            // find the next length and check for an error condition
            if ((len = CalculateOffset(buffer, len)) < 0) {
                #ifdef MSG_DEBUG
                printf("Got bad player update in message %d\n", messageId);
                #endif
                // bad data; ignore it
                return FALSE;
            }
            // count another player's data
            numplay++;
        } while (len < buffer->length);
        // assure proper length
        if (len != buffer->length) {
            #ifdef MSG_DEBUG
            printf("Got bad player update in message %d\n", messageId);
            printf("\tMessage length: %i   Calculated length: %i   Players: %i\n",
            buffer->length, len, numplay);
            #endif
            // bad data; ignore it
            return FALSE;
        }
        // the data length is good, so prepare to read it
        ptr = &(buffer->data[3]);
        // parse all the data starting with the time
        MSG_READ_32(ptr, time);
        // next, parse the player data
        for (; numplay > 0; numplay--) {
            ptr = ReadPlayer(ptr, time);
            assert((ptr - buffer->data) <= len);
        }
        assert((ptr - buffer->data) == buffer->length);
    }
    // see if this process is a server
    else if ((networkState == NETSTATE_SERVER) &&
    ValidateClient(origin, buffer->data[len]) &&  // attempt to validate origin
    (CalculateOffset(buffer, len) == buffer->length)) { // check its length
        // set the ID to acknowledge
        *clientId = buffer->data[7];
        // the data length is good, so prepare to read it
        ptr = &(buffer->data[3]);
        // parse all the data starting with the time
        MSG_READ_32(ptr, time);
        // only one player update from a client
        ptr = ReadPlayer(ptr, time);
        assert((ptr - buffer->data) == buffer->length);
    }
    else {
        #ifdef MSG_DEBUG
        printf("Got bad player update in message %d\n", messageId);
        #endif
        // bad data -- ignore this message
        return FALSE;
    }
    return TRUE;
}

Bool SendSpawnRequest() {
    MsgDescr *msg;
    // Send a message to the server to request spawning.
    // get the descriptor
    if ((msg = MessageNew()) == NULL) {
        // failed; nothing more can be done
        return FALSE;
    }
    // get a buffer
    if ((msg->buffer = BufferNew()) == NULL) {
        // failed; relase the message
        MessageFree(msg);
        return FALSE;
    }
    // setup the message descriptor
    msg->approveFunc = NULL;
    msg->ackFunc = NULL;
    msg->failFunc = MsgFailDropConnection;
    msg->buffer->length = 4;
    // build the response message
    msg->buffer->data[0] = MSG_TYPE_PLAYER_SPWAN;
    msg->buffer->data[3] = localPlayer;
    msg->bcast = TRUE;  // broadcast OK
    // set the destination
    msg->destMap[0] = 1;
    // add the message to the system
    return AddMessage(msg);
}

Bool HandlePlayerSpawn(SocketAddr *origin, NetBuffer *buffer, Uint8 *clientId,
Uint16 noid) {
    Player *p;
    // see if this message is bogus
    if ((networkState != NETSTATE_SERVER) || (buffer->length != 4) ||
    !ValidateClient(origin, buffer->data[3])) {  // attempt to validate origin
        // do not ack a bogus message
        return FALSE;
    }
    // grab a pointer to the player
    p = &players[*clientId = buffer->data[3]];
    // see if the request to spawn should be honored
    if ((p->flags & PLAYER_DEAD) && (p->deadTime > DEAD_TIME)) {
        // spawn the player
        SpawnTank(p);
    }
    return TRUE;
}

---