e_parse.c

Go to the documentation of this file.

/*
Copyright (C) 2002-2010 UFO: Alien Invasion.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

#include "../../client.h"
#include "e_parse.h"
#include "e_time.h"
#include "e_main.h"

#include "../cl_localentity.h"
#include "../../cl_screen.h"
#include "../../cl_game.h"
#include "../../cl_team.h"
#include "../cl_particle.h"
#include "../cl_actor.h"
#include "../cl_view.h"
#include "../cl_hud.h"
#include "../../ui/ui_main.h"
#include "../../renderer/r_mesh_anim.h"

cvar_t *cl_log_battlescape_events;

typedef struct evTimes_s {
    event_t eType;                  
    struct dbuffer *msg;        
} evTimes_t;

/**********************************************************
 * General battlescape event functions
 **********************************************************/

static void CL_LogEvent (const eventRegister_t *eventData)
{
    qFILE f;

    if (!cl_log_battlescape_events->integer)
        return;

    FS_OpenFile("events.log", &f, FILE_APPEND);
    if (!f.f)
        return;
    else {
        char tbuf[32];

        Com_MakeTimestamp(tbuf, sizeof(tbuf));

        FS_Printf(&f, "%s - %s: %10i %s\n", tbuf, CL_GetConfigString(CS_MAPTITLE), cl.time, eventData->name);
        FS_CloseFile(&f);
    }
}

void CL_BlockBattlescapeEvents (qboolean block)
{
    cl.eventsBlocked = block;
}

static qboolean CL_AreBattlescapeEventsBlocked (void)
{
    return cl.eventsBlocked;
}

static qboolean CL_CheckBattlescapeEvent (int now, void *data)
{
    if (CL_AreBattlescapeEventsBlocked()) {
        return qfalse;
    } else {
        const evTimes_t *event = (evTimes_t *)data;
        const eventRegister_t *eventData = CL_GetEvent(event->eType);

        if (eventData->eventCheck == NULL)
            return qtrue;

        return eventData->eventCheck(eventData, event->msg);
    }
}

static void CL_ExecuteBattlescapeEvent (int now, void *data)
{
    evTimes_t *event = (evTimes_t *)data;
    const eventRegister_t *eventData = CL_GetEvent(event->eType);

    if (event->eType <= EV_START || cls.state == ca_active) {
        Com_DPrintf(DEBUG_EVENTSYS, "event(dispatching at %d): %s %p\n", now, eventData->name, event);

        CL_LogEvent(eventData);

        if (!eventData->eventCallback)
            Com_Error(ERR_DROP, "Event %i doesn't have a callback", event->eType);

        eventData->eventCallback(eventData, event->msg);
    } else {
        Com_DPrintf(DEBUG_EVENTSYS, "event(not executed): %s %p\n", eventData->name, event);
    }

    free_dbuffer(event->msg);
    Mem_Free(event);
}

static void CL_FreeBattlescapeEvent (void *data)
{
    evTimes_t *event = (evTimes_t *)data;
    free_dbuffer(event->msg);
    Mem_Free(event);
}

static qboolean CL_FilterBattlescapeEvents (int when, event_func *func, event_check_func *check, void *data)
{
    return (func != &CL_ExecuteBattlescapeEvent);
}

void CL_ClearBattlescapeEvents (void)
{
    CL_FilterEventQueue(&CL_FilterBattlescapeEvents);
}

void CL_ParseEvent (struct dbuffer *msg)
{
    qboolean now;
    const eventRegister_t *eventData;
    event_t eType = NET_ReadByte(msg);
    if (eType == EV_NULL)
        return;

    /* check instantly flag */
    if (eType & EVENT_INSTANTLY) {
        now = qtrue;
        eType &= ~EVENT_INSTANTLY;
    } else
        now = qfalse;

    /* check if eType is valid */
    if (eType < EV_NULL || eType >= EV_NUM_EVENTS)
        Com_Error(ERR_DROP, "CL_ParseEvent: invalid event %i", eType);

    eventData = CL_GetEvent(eType);
    if (!eventData->eventCallback)
        Com_Error(ERR_DROP, "CL_ParseEvent: no handling function for event %i", eType);

    if (now) {
        /* log and call function */
        CL_LogEvent(eventData);
        Com_DPrintf(DEBUG_EVENTSYS, "event(now): %s\n", eventData->name);
        eventData->eventCallback(eventData, msg);
    } else {
        evTimes_t *cur = Mem_PoolAlloc(sizeof(*cur), cl_genericPool, 0);
        static int lastFrame = 0;
        const int delta = cl.time - lastFrame;
        int when;

        /* copy the buffer as first action, the event time functions can modify the buffer already */
        cur->msg = dbuffer_dup(msg);
        cur->eType = eType;

        /* timestamp (msec) that is used to determine when the event should be executed */
        when = CL_GetEventTime(cur->eType, msg, delta);
        Schedule_Event(when, &CL_ExecuteBattlescapeEvent, &CL_CheckBattlescapeEvent, &CL_FreeBattlescapeEvent, cur);

        lastFrame = cl.time;

        Com_DPrintf(DEBUG_EVENTSYS, "event(at %d): %s %p\n", when, eventData->name, cur);
    }
}