notice.c

Go to the documentation of this file.

#include "notice.h"
#include "color.h"
#include "player.h"
#include <assert.h>

#define MAX_NOTICES  4

#define SPACING  2

struct Notice_t {
    RenderItem text;
    Uint32 expiryTime;
    Uint8 type;
};

typedef struct Notice_t  Notice;

static Notice notices[MAX_NOTICES] = { 0 };

static Notice *order[MAX_NOTICES] = { 
    &notices[0], &notices[1], &notices[2], &notices[3]
};

static int timeouts = 0;

static int notimeouts = 0;

static void RemoveOneNotice(int index) {
    Notice *n = order[index];
    assert(index < MAX_NOTICES);
    // clear it from view
    ClearRenderItem(&(n->text));
    // take it out of the renderer
    RemoveRenderItem(&(n->text));
    // destroy the surface with rendered text
    SDL_FreeSurface(n->text.data);
    n->text.data = NULL;
    // update notice counts
    if (n->expiryTime == NOTICE_NOEXPIRATION) {
        notimeouts--;
    }
    else {
        timeouts--;
    }
    // move remaining notices forward in order
    for (; index < MAX_NOTICES - 1; index++) {
        // also, tag for later placement
        (order[index] = order[index + 1])->text.loc.y = -1;
    }
    // put the pointer to the removed notice at the end
    order[MAX_NOTICES - 1] = n;
}

void AddNotice(Uint32 expiryTime, Uint8 type, rtsa_char *format, ...) {
    Notice *n;
    va_list args;
    int ind;
    Bool add = TRUE;
    assert(type < NOTICE_MAXTYPE);
    // find an available notice
    // first, see if there are greater than the maximum notices
    if ((ind = timeouts + notimeouts) >= MAX_NOTICES) {
        // won't be adding this one's render item
        add = FALSE;
        // find the oldest notice
        if (notimeouts == MAX_NOTICES) {
            // no room -- exit now
            return;
        }
        // the oldest is the last -- clear it from view
        ClearRenderItem(&((n = order[ind = MAX_NOTICES - 1])->text));
    }
    else {
        // add the notice at the end
        n = order[ind];
    }
    // adding a notice w/o a timeout?
    if (expiryTime == NOTICE_NOEXPIRATION) {
        // the notice will be inserted after the last non-timeout notice
        for (; ind > notimeouts; ind--) {
            // move notices down to make room, and tag it for placement
            (order[ind] = order[ind - 1])->text.loc.y = -1;
        }
        // insert the new notice
        order[ind] = n;
        // update count
        if (add) {
            notimeouts++;
        }
    }
    else if (add) {
        timeouts++;
    }
    assert(timeouts + notimeouts <= MAX_NOTICES);
    // get the variable argument list
    va_start(args, format);
    // render the text
    TextRenderStringV(&(n->text), FONT_SCORE, dInfo.pw >> 1,
    colorFmtInd[COLOR_BLACK], format, args);
    // done with the variable args
    va_end(args);
    // mark notice as not yet placed
    n->text.loc.y = -1;
    // fill out the notice
    n->expiryTime = expiryTime;
    n->type = type;
    // render it
    if (add) {
        AddRenderItem(&(n->text), LAYER_TEXT);
    }
}

extern Uint32 frameTime;

void AddScoreNotice(int killerId, int killedId, int score) {
    Player *s = &players[killerId];  // scorer
    Player *l = &players[killedId];  // loser
    // assure good IDs
    assert((killerId < MAX_PLAYERS) && (killedId < MAX_PLAYERS));
    // check for killing of the same team
    if (s->team == l->team) {
        // killer is local player?
        if (s->pid == localPlayer) {
            AddNotice(frameTime + 3000, NOTICE_LOCALTEAMKILL,
            strings[STRING_LOCALTEAMKILLER], l->name);
        }
        // killed is local player?
        else if (l->pid == localPlayer) {
            AddNotice(frameTime + 3000, NOTICE_LOCALTEAMKILL,
            strings[STRING_LOCALTEAMKILLED], s->name);
        }
        else {
            AddNotice(frameTime + 3000, NOTICE_TEAMKILL,
            strings[STRING_TEAMKILL], s->name, l->name);
        }
    }
    else {
        // is scorer local player?
        if (s->pid == localPlayer) {
            AddNotice(frameTime + 3000, NOTICE_LOCALKILL,
            strings[STRING_LOCALKILL], l->name, score);
        }
        else {
            AddNotice(frameTime + 3000, NOTICE_KILL,
            strings[STRING_KILL], s->name, l->name, score);
        }
    }
}

void RemoveNotice(Uint8 type) {
    int loop;
    for (loop = timeouts + notimeouts - 1; loop >= 0; loop--) {
        // is this notice one that needs to be removed?
        if (order[loop]->type == type) {
            RemoveOneNotice(loop);
            // done
            break;
        }
    }
}

void RemoveAllNotices() {
    int loop;
    for (loop = timeouts + notimeouts - 1; loop >= 0; loop--) {
        // clear it from view
        ClearRenderItem(&(order[loop]->text));
        // take it out of the renderer
        RemoveRenderItem(&(order[loop]->text));
        // destroy the surface with rendered text
        SDL_FreeSurface(order[loop]->text.data);
        order[loop]->text.data = NULL;
    }
    // clear out the counts
    timeouts = notimeouts = 0;
}

void UpdateNotices(Uint32 time) {
    Bool placeRemaining = FALSE;
    int loop, top = TOP_MARGIN;
    Notice *n;
    for (loop = 0; loop < timeouts + notimeouts; ) {
        // time to remove?
        if ((n = order[loop])->expiryTime <= time) {
            // remove this one
            RemoveOneNotice(loop);
            // place all remaining notices
            placeRemaining = TRUE;
            // start the loop over -- stay on same index
            continue;
        }
        // need to place the notice?
        if (placeRemaining || (n->text.loc.y == -1)) {
            // place all remaining notices
            placeRemaining = TRUE;
            // compute new spot for this notice
            // center it horizontally
            n->text.loc.x = (dInfo.pw >> 1) - (n->text.loc.w >> 1);
            // place it vertically
            n->text.loc.y = top;
            // render in this spot
            PlaceRenderItem(&(n->text));
        }
        // grab the bottom of this notice for later placements
        top = SPACING + n->text.loc.y + n->text.loc.h;
        // move to the next notice
        loop++;
    }
}

---