codemp/game/g_saga.c

Go to the documentation of this file.

// Copyright (C) 2000-2002 Raven Software, Inc.
//
/*****************************************************************************
 * name:                g_saga.c
 *
 * desc:                Game-side module for Siege gametype.
 *
 * $Author: Rich Whitehouse $ 
 * $Revision: 1.6 $
 *
 *****************************************************************************/
#include "g_local.h"
#include "bg_saga.h"

#define SIEGEITEM_STARTOFFRADAR 8

static char             team1[512];
static char             team2[512];

siegePers_t     g_siegePersistant = {qfalse, 0, 0};

int                     imperial_goals_required = 0;
int                     imperial_goals_completed = 0;
int                     rebel_goals_required = 0;
int                     rebel_goals_completed = 0;

int                     imperial_time_limit = 0;
int                     rebel_time_limit = 0;

int                     gImperialCountdown = 0;
int                     gRebelCountdown = 0;

int                     rebel_attackers = 0;
int                     imperial_attackers = 0;

qboolean        gSiegeRoundBegun = qfalse;
qboolean        gSiegeRoundEnded = qfalse;
qboolean        gSiegeRoundWinningTeam = 0;
int                     gSiegeBeginTime = Q3_INFINITE;

int                     g_preroundState = 0; //default to starting as spec (1 is starting ingame)

void LogExit( const char *string );
void SetTeamQuick(gentity_t *ent, int team, qboolean doBegin);

static char gParseObjectives[MAX_SIEGE_INFO_SIZE];
static char gObjectiveCfgStr[1024];

//go through all classes on a team and register their
//weapons and items for precaching.
void G_SiegeRegisterWeaponsAndHoldables(int team)
{
        siegeTeam_t *stm = BG_SiegeFindThemeForTeam(team);

        if (stm)
        {
                int i = 0;
                siegeClass_t *scl;
                while (i < stm->numClasses)
                {
                        scl = stm->classes[i];

                        if (scl)
                        {
                                int j = 0;
                                while (j < WP_NUM_WEAPONS)
                                {
                                        if (scl->weapons & (1 << j))
                                        { //we use this weapon so register it.
                                                RegisterItem(BG_FindItemForWeapon(j));
                                        }
                                        j++;
                                }
                                j = 0;
                                while (j < HI_NUM_HOLDABLE)
                                {
                                        if (scl->invenItems & (1 << j))
                                        { //we use this item so register it.
                                                RegisterItem(BG_FindItemForHoldable(j));
                                        }
                                        j++;
                                }
                        }
                        i++;
                }
        }
}

//tell clients that this team won and print it on their scoreboard for intermission
//or whatever.
void SiegeSetCompleteData(int team)
{
        trap_SetConfigstring(CS_SIEGE_WINTEAM, va("%i", team));
}

void InitSiegeMode(void)
{
        vmCvar_t                mapname;
        char                    levelname[512];
        char                    teamIcon[128];
        char                    goalreq[64];
        char                    teams[2048];
        char                    objective[MAX_SIEGE_INFO_SIZE];
        char                    objecStr[8192];
        int                             len = 0;
        int                             i = 0;
//      int                             j = 0;
        int                             objectiveNumTeam1 = 0;
        int                             objectiveNumTeam2 = 0;
        fileHandle_t    f;

        if (g_gametype.integer != GT_SIEGE)
        {
                goto failure;
        }

        //reset
        SiegeSetCompleteData(0);

        //get pers data in case it existed from last level
        if (g_siegeTeamSwitch.integer)
        {
                trap_SiegePersGet(&g_siegePersistant);
                if (g_siegePersistant.beatingTime)
                {
                        trap_SetConfigstring(CS_SIEGE_TIMEOVERRIDE, va("%i", g_siegePersistant.lastTime));
                }
                else
                {
                        trap_SetConfigstring(CS_SIEGE_TIMEOVERRIDE, "0");
                }
        }
        else
        { //hmm, ok, nothing.
                trap_SetConfigstring(CS_SIEGE_TIMEOVERRIDE, "0");
        }

        imperial_goals_completed = 0;
        rebel_goals_completed = 0;

        trap_Cvar_Register( &mapname, "mapname", "", CVAR_SERVERINFO | CVAR_ROM );

        Com_sprintf(levelname, sizeof(levelname), "maps/%s.siege\0", mapname.string);

        if (!levelname || !levelname[0])
        {
                goto failure;
        }

        len = trap_FS_FOpenFile(levelname, &f, FS_READ);

        if (!f || len >= MAX_SIEGE_INFO_SIZE)
        {
                goto failure;
        }

        trap_FS_Read(siege_info, len, f);

        trap_FS_FCloseFile(f);

        siege_valid = 1;

        //See if players should be specs or ingame preround
        if (BG_SiegeGetPairedValue(siege_info, "preround_state", teams))
        {
                if (teams[0])
                {
                        g_preroundState = atoi(teams);
                }
        }

        if (BG_SiegeGetValueGroup(siege_info, "Teams", teams))
        {
                if (g_siegeTeam1.string[0] && Q_stricmp(g_siegeTeam1.string, "none"))
                { //check for override
                        strcpy(team1, g_siegeTeam1.string);
                }
                else
                { //otherwise use level default
                        BG_SiegeGetPairedValue(teams, "team1", team1);
                }

                if (g_siegeTeam2.string[0] && Q_stricmp(g_siegeTeam2.string, "none"))
                { //check for override
                        strcpy(team2, g_siegeTeam2.string);
                }
                else
                { //otherwise use level default
                        BG_SiegeGetPairedValue(teams, "team2", team2);
                }
        }
        else
        {
                G_Error("Siege teams not defined");
        }

        if (BG_SiegeGetValueGroup(siege_info, team2, gParseObjectives))
        {
                if (BG_SiegeGetPairedValue(gParseObjectives, "TeamIcon", teamIcon))
                {
                        trap_Cvar_Set( "team2_icon", teamIcon);
                }

                if (BG_SiegeGetPairedValue(gParseObjectives, "RequiredObjectives", goalreq))
                {
                        rebel_goals_required = atoi(goalreq);
                }
                if (BG_SiegeGetPairedValue(gParseObjectives, "Timed", goalreq))
                {
                        rebel_time_limit = atoi(goalreq)*1000;
                        if (g_siegeTeamSwitch.integer &&
                                g_siegePersistant.beatingTime)
                        {
                                gRebelCountdown = level.time + g_siegePersistant.lastTime;
                        }
                        else
                        {
                                gRebelCountdown = level.time + rebel_time_limit;
                        }
                }
                if (BG_SiegeGetPairedValue(gParseObjectives, "attackers", goalreq))
                {
                        rebel_attackers = atoi(goalreq);
                }
        }

        if (BG_SiegeGetValueGroup(siege_info, team1, gParseObjectives))
        {

                if (BG_SiegeGetPairedValue(gParseObjectives, "TeamIcon", teamIcon))
                {
                        trap_Cvar_Set( "team1_icon", teamIcon);
                }

                if (BG_SiegeGetPairedValue(gParseObjectives, "RequiredObjectives", goalreq))
                {
                        imperial_goals_required = atoi(goalreq);
                }
                if (BG_SiegeGetPairedValue(gParseObjectives, "Timed", goalreq))
                {
                        if (rebel_time_limit)
                        {
                                Com_Printf("Tried to set imperial time limit, but there's already a rebel time limit!\nOnly one team can have a time limit.\n");
                        }
                        else
                        {
                                imperial_time_limit = atoi(goalreq)*1000;
                                if (g_siegeTeamSwitch.integer &&
                                        g_siegePersistant.beatingTime)
                                {
                                        gImperialCountdown = level.time + g_siegePersistant.lastTime;
                                }
                                else
                                {
                                        gImperialCountdown = level.time + imperial_time_limit;
                                }
                        }
                }
                if (BG_SiegeGetPairedValue(gParseObjectives, "attackers", goalreq))
                {
                        imperial_attackers = atoi(goalreq);
                }
        }

        //Load the player class types
        BG_SiegeLoadClasses(NULL);

        if (!bgNumSiegeClasses)
        { //We didn't find any?!
                G_Error("Couldn't find any player classes for Siege");
        }

        /*
        //We could probably just see what teams are used on this level,
        //then see what classes are used by those teams, and then precache
        //all weapons for said classes. However, I'm just going to do them
        //all for now.
        while (i < bgNumSiegeClasses)
        {
                cl = &bgSiegeClasses[i];
                j = 0;

                while (j < WP_NUM_WEAPONS)
                {
                        if (cl->weapons & (1 << j))
                        { //we use this weapon so register it.
                                RegisterItem(BG_FindItemForWeapon(j));
                        }

                        j++;
                }

                i++;
        }
        */
        //Ok, I'm adding inventory item precaching now, so I'm finally going to optimize this
        //to only do weapons/items for the current teams used on the level.

        //Now load the teams since we have class data.
        BG_SiegeLoadTeams();

        if (!bgNumSiegeTeams)
        { //React same as with classes.
                G_Error("Couldn't find any player teams for Siege");
        }

        //Get and set the team themes for each team. This will control which classes can be
        //used on each team.
        if (BG_SiegeGetValueGroup(siege_info, team1, gParseObjectives))
        {
                if (BG_SiegeGetPairedValue(gParseObjectives, "UseTeam", goalreq))
                {
                        BG_SiegeSetTeamTheme(SIEGETEAM_TEAM1, goalreq);
                }

                //Now count up the objectives for this team.
                i = 1;
                strcpy(objecStr, va("Objective%i", i));
                while (BG_SiegeGetValueGroup(gParseObjectives, objecStr, objective))
                {
                        objectiveNumTeam1++;
                        i++;
                        strcpy(objecStr, va("Objective%i", i));
                }
        }
        if (BG_SiegeGetValueGroup(siege_info, team2, gParseObjectives))
        {
                if (BG_SiegeGetPairedValue(gParseObjectives, "UseTeam", goalreq))
                {
                        BG_SiegeSetTeamTheme(SIEGETEAM_TEAM2, goalreq);
                }

                //Now count up the objectives for this team.
                i = 1;
                strcpy(objecStr, va("Objective%i", i));
                while (BG_SiegeGetValueGroup(gParseObjectives, objecStr, objective))
                {
                        objectiveNumTeam2++;
                        i++;
                        strcpy(objecStr, va("Objective%i", i));
                }
        }

        //Set the configstring to show status of all current objectives
        strcpy(gObjectiveCfgStr, "t1");
        while (objectiveNumTeam1 > 0)
        { //mark them all as not completed since we just initialized
                Q_strcat(gObjectiveCfgStr, 1024, "-0");
                objectiveNumTeam1--;
        }
        //Finished doing team 1's objectives, now do team 2's
        Q_strcat(gObjectiveCfgStr, 1024, "|t2");
        while (objectiveNumTeam2 > 0)
        {
                Q_strcat(gObjectiveCfgStr, 1024, "-0");
                objectiveNumTeam2--;
        }

        //And finally set the actual config string
        trap_SetConfigstring(CS_SIEGE_OBJECTIVES, gObjectiveCfgStr);

        //precache saber data for classes that use sabers on both teams
        BG_PrecacheSabersForSiegeTeam(SIEGETEAM_TEAM1);
        BG_PrecacheSabersForSiegeTeam(SIEGETEAM_TEAM2);

        G_SiegeRegisterWeaponsAndHoldables(SIEGETEAM_TEAM1);
        G_SiegeRegisterWeaponsAndHoldables(SIEGETEAM_TEAM2);

        return;

failure:
        siege_valid = 0;
}

void G_SiegeSetObjectiveComplete(int team, int objective, qboolean failIt)
{
        char *p = NULL;
        int onObjective = 0;

        if (team == SIEGETEAM_TEAM1)
        {
                p = strstr(gObjectiveCfgStr, "t1");
        }
        else if (team == SIEGETEAM_TEAM2)
        {
                p = strstr(gObjectiveCfgStr, "t2");
        }

        if (!p)
        {
                assert(0);
                return;
        }

        //Parse from the beginning of this team's objectives until we get to the desired objective
        //number.
        while (p && *p && *p != '|')
        {
                if (*p == '-')
                {
                        onObjective++;
                }

                if (onObjective == objective)
                { //this is the one we want
                        //Move to the next char, the status of this objective
                        p++;

                        //Now change it from '0' to '1' if we are completeing the objective
                        //or vice versa if the objective has been taken away
                        if (failIt)
                        {
                                *p = '0';
                        }
                        else
                        {
                                *p = '1';
                        }
                        break;
                }

                p++;
        }

        //Now re-update the configstring.
        trap_SetConfigstring(CS_SIEGE_OBJECTIVES, gObjectiveCfgStr);
}

//Returns qtrue if objective complete currently, otherwise qfalse
qboolean G_SiegeGetCompletionStatus(int team, int objective)
{
        char *p = NULL;
        int onObjective = 0;

        if (team == SIEGETEAM_TEAM1)
        {
                p = strstr(gObjectiveCfgStr, "t1");
        }
        else if (team == SIEGETEAM_TEAM2)
        {
                p = strstr(gObjectiveCfgStr, "t2");
        }

        if (!p)
        {
                assert(0);
                return qfalse;
        }

        //Parse from the beginning of this team's objectives until we get to the desired objective
        //number.
        while (p && *p && *p != '|')
        {
                if (*p == '-')
                {
                        onObjective++;
                }

                if (onObjective == objective)
                { //this is the one we want
                        //Move to the next char, the status of this objective
                        p++;

                        //return qtrue if it's '1', qfalse if it's anything else
                        if (*p == '1')
                        {
                                return qtrue;
                        }
                        else
                        {
                                return qfalse;
                        }
                        break;
                }

                p++;
        }

        return qfalse;
}

void UseSiegeTarget(gentity_t *other, gentity_t *en, char *target)
{ //actually use the player which triggered the object which triggered the siege objective to trigger the target
        gentity_t               *t;
        gentity_t               *ent;

        if ( !en || !en->client )
        { //looks like we don't have access to a player, so just use the activating entity
                ent = other;
        }
        else
        {
                ent = en;
        }

        if (!en)
        {
                return;
        }

        if ( !target )
        {
                return;
        }

        t = NULL;
        while ( (t = G_Find (t, FOFS(targetname), target)) != NULL )
        {
                if ( t == ent )
                {
                        G_Printf ("WARNING: Entity used itself.\n");
                }
                else
                {
                        if ( t->use )
                        {
                                GlobalUse(t, ent, ent);
                        }
                }
                if ( !ent->inuse )
                {
                        G_Printf("entity was removed while using targets\n");
                        return;
                }
        }
}

void SiegeBroadcast_OBJECTIVECOMPLETE(int team, int client, int objective)
{
        gentity_t *te;
        vec3_t nomatter;

        VectorClear(nomatter);

        te = G_TempEntity( nomatter, EV_SIEGE_OBJECTIVECOMPLETE );
        te->r.svFlags |= SVF_BROADCAST;
        te->s.eventParm = team;
        te->s.weapon = client;
        te->s.trickedentindex = objective;
}

void SiegeBroadcast_ROUNDOVER(int winningteam, int winningclient)
{
        gentity_t *te;
        vec3_t nomatter;

        VectorClear(nomatter);

        te = G_TempEntity( nomatter, EV_SIEGE_ROUNDOVER );
        te->r.svFlags |= SVF_BROADCAST;
        te->s.eventParm = winningteam;
        te->s.weapon = winningclient;
}

void BroadcastObjectiveCompletion(int team, int objective, int final, int client)
{
        if (client != ENTITYNUM_NONE && g_entities[client].client && g_entities[client].client->sess.sessionTeam == team)
        { //guy who completed this objective gets points, providing he's on the opposing team
                AddScore(&g_entities[client], g_entities[client].client->ps.origin, SIEGE_POINTS_OBJECTIVECOMPLETED);
        }

        SiegeBroadcast_OBJECTIVECOMPLETE(team, client, objective);
        //G_Printf("Broadcast goal completion team %i objective %i final %i\n", team, objective, final);
}

void AddSiegeWinningTeamPoints(int team, int winner)
{
        int i = 0;
        gentity_t *ent;

        while (i < MAX_CLIENTS)
        {
                ent = &g_entities[i];

                if (ent && ent->client && ent->client->sess.sessionTeam == team)
                {
                        if (i == winner)
                        {
                                AddScore(ent, ent->client->ps.origin, SIEGE_POINTS_TEAMWONROUND+SIEGE_POINTS_FINALOBJECTIVECOMPLETED);
                        }
                        else
                        {
                                AddScore(ent, ent->client->ps.origin, SIEGE_POINTS_TEAMWONROUND);
                        }
                }

                i++;
        }
}

void SiegeClearSwitchData(void)
{
        memset(&g_siegePersistant, 0, sizeof(g_siegePersistant));
        trap_SiegePersSet(&g_siegePersistant);
}

void SiegeDoTeamAssign(void)
{
        int i = 0;
        gentity_t *ent;

        //yeah, this is great...
        while (i < MAX_CLIENTS)
        {
                ent = &g_entities[i];

                if (ent->inuse && ent->client &&
                        ent->client->pers.connected == CON_CONNECTED)
                { //a connected client, switch his frickin teams around
                        if (ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM1)
                        {
                                ent->client->sess.siegeDesiredTeam = SIEGETEAM_TEAM2;
                        }
                        else if (ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM2)
                        {
                                ent->client->sess.siegeDesiredTeam = SIEGETEAM_TEAM1;
                        }

                        if (ent->client->sess.sessionTeam == SIEGETEAM_TEAM1)
                        {
                                SetTeamQuick(ent, SIEGETEAM_TEAM2, qfalse);
                        }
                        else if (ent->client->sess.sessionTeam == SIEGETEAM_TEAM2)
                        {
                                SetTeamQuick(ent, SIEGETEAM_TEAM1, qfalse);
                        }
                }
                i++;
        }
}

void SiegeTeamSwitch(int winTeam, int winTime)
{
        trap_SiegePersGet(&g_siegePersistant);
        if (g_siegePersistant.beatingTime)
        { //was already in "switched" mode, change back
                //announce the winning team.
                //either the first team won again, or the second
                //team beat the time set by the initial team. In any
                //case the winTeam here is the overall winning team.
                SiegeSetCompleteData(winTeam);
                SiegeClearSwitchData();
        }
        else
        { //go into "beat their time" mode
                g_siegePersistant.beatingTime = qtrue;
        g_siegePersistant.lastTeam = winTeam;
                g_siegePersistant.lastTime = winTime;

                trap_SiegePersSet(&g_siegePersistant);
        }
}

void SiegeRoundComplete(int winningteam, int winningclient)
{
        vec3_t nomatter;
        char teamstr[1024];
        int originalWinningClient = winningclient;

        //G_Printf("Team %i won\n", winningteam);

        if (winningclient != ENTITYNUM_NONE && g_entities[winningclient].client &&
                g_entities[winningclient].client->sess.sessionTeam != winningteam)
        { //this person just won the round for the other team..
                winningclient = ENTITYNUM_NONE;
        }

        VectorClear(nomatter);

        SiegeBroadcast_ROUNDOVER(winningteam, winningclient);

        AddSiegeWinningTeamPoints(winningteam, winningclient);

        //Instead of exiting like this, fire off a target, and let it handle things.
        //Can be a script or whatever the designer wants.
        if (winningteam == SIEGETEAM_TEAM1)
        {
                Com_sprintf(teamstr, sizeof(teamstr), team1);
        }
        else
        {
                Com_sprintf(teamstr, sizeof(teamstr), team2);
        }

        trap_SetConfigstring(CS_SIEGE_STATE, va("3|%i", level.time)); //ended
        gSiegeRoundBegun = qfalse;
        gSiegeRoundEnded = qtrue;
        gSiegeRoundWinningTeam = winningteam;

        if (BG_SiegeGetValueGroup(siege_info, teamstr, gParseObjectives))
        {
                if (!BG_SiegeGetPairedValue(gParseObjectives, "roundover_target", teamstr))
                { //didn't find the name of the thing to target upon win, just logexit now then.
                        LogExit( "Objectives completed" );
                        return;
                }
                
                if (originalWinningClient == ENTITYNUM_NONE)
                { //oh well, just find something active and use it then.
            int i = 0;
                        gentity_t *ent;

                        while (i < MAX_CLIENTS)
                        {
                                ent = &g_entities[i];

                                if (ent->inuse)
                                { //sure, you'll do.
                    originalWinningClient = ent->s.number;
                                        break;
                                }

                                i++;
                        }
                }
                G_UseTargets2(&g_entities[originalWinningClient], &g_entities[originalWinningClient], teamstr);
        }

        if (g_siegeTeamSwitch.integer &&
                (imperial_time_limit || rebel_time_limit))
        { //handle stupid team switching crap
                int time = 0;
                if (imperial_time_limit)
                {
                        time = imperial_time_limit-(gImperialCountdown-level.time);
                }
                else if (rebel_time_limit)
                {
                        time = rebel_time_limit-(gRebelCountdown-level.time);
                }

                if (time < 1)
                {
                        time = 1;
                }
                SiegeTeamSwitch(winningteam, time);
        }
        else
        { //assure it's clear for next round
                SiegeClearSwitchData();
        }
}

void G_ValidateSiegeClassForTeam(gentity_t *ent, int team)
{
        siegeClass_t *scl;
        siegeTeam_t *stm;
        int newClassIndex = -1;
        if (ent->client->siegeClass == -1)
        { //uh.. sure.
                return;
        }

        scl = &bgSiegeClasses[ent->client->siegeClass];

        stm = BG_SiegeFindThemeForTeam(team);
        if (stm)
        {
                int i = 0;

                while (i < stm->numClasses)
                { //go through the team and see its valid classes, can we find one that matches our current player class?
                        if (stm->classes[i])
                        {
                                if (!Q_stricmp(scl->name, stm->classes[i]->name))
                                { //the class we're using is already ok for this team.
                                        return;
                                }
                                if (stm->classes[i]->playerClass == scl->playerClass ||
                                        newClassIndex == -1)
                                {
                                        newClassIndex = i;
                                }
                        }
                        i++;
                }

                if (newClassIndex != -1)
                { //ok, let's find it in the global class array
                        ent->client->siegeClass = BG_SiegeFindClassIndexByName(stm->classes[newClassIndex]->name);
                        strcpy(ent->client->sess.siegeClass, stm->classes[newClassIndex]->name);
                }
        }
}

//bypass most of the normal checks in SetTeam
void SetTeamQuick(gentity_t *ent, int team, qboolean doBegin)
{
        char userinfo[MAX_INFO_STRING];

        trap_GetUserinfo( ent->s.number, userinfo, sizeof( userinfo ) );

        if (g_gametype.integer == GT_SIEGE)
        {
                G_ValidateSiegeClassForTeam(ent, team);
        }

        ent->client->sess.sessionTeam = team;

        if (team == TEAM_SPECTATOR)
        {
                ent->client->sess.spectatorState = SPECTATOR_FREE;
                Info_SetValueForKey(userinfo, "team", "s");
        }
        else
        {
                ent->client->sess.spectatorState = SPECTATOR_NOT;
                if (team == TEAM_RED)
                {
                        Info_SetValueForKey(userinfo, "team", "r");
                }
                else if (team == TEAM_BLUE)
                {
                        Info_SetValueForKey(userinfo, "team", "b");
                }
                else
                {
                        Info_SetValueForKey(userinfo, "team", "?");
                }
        }

        trap_SetUserinfo( ent->s.number, userinfo );

        ent->client->sess.spectatorClient = 0;

        ent->client->pers.teamState.state = TEAM_BEGIN;

        ClientUserinfoChanged( ent->s.number );

        if (doBegin)
        {
                ClientBegin( ent->s.number, qfalse );
        }
}

void SiegeRespawn(gentity_t *ent)
{
        gentity_t *tent;

        if (ent->client->sess.sessionTeam != ent->client->sess.siegeDesiredTeam)
        {
                SetTeamQuick(ent, ent->client->sess.siegeDesiredTeam, qtrue);
        }
        else
        {
                ClientSpawn(ent);
                // add a teleportation effect
                tent = G_TempEntity( ent->client->ps.origin, EV_PLAYER_TELEPORT_IN );
                tent->s.clientNum = ent->s.clientNum;
        }
}

void SiegeBeginRound(int entNum)
{ //entNum is just used as something to fire targets from.
        char targname[1024];

        if (!g_preroundState)
        { //if players are not ingame on round start then respawn them now
                int i = 0;
                gentity_t *ent;
                qboolean spawnEnt = qfalse;

                //respawn everyone now
                while (i < MAX_CLIENTS)
                {
                        ent = &g_entities[i];

                        if (ent->inuse && ent->client)
                        {
                                if (ent->client->sess.sessionTeam != TEAM_SPECTATOR &&
                                        !(ent->client->ps.pm_flags & PMF_FOLLOW))
                                { //not a spec, just respawn them
                                        spawnEnt = qtrue;
                                }
                                else if (ent->client->sess.sessionTeam == TEAM_SPECTATOR &&
                                        (ent->client->sess.siegeDesiredTeam == TEAM_RED ||
                                         ent->client->sess.siegeDesiredTeam == TEAM_BLUE))
                                { //spectator but has a desired team
                                        spawnEnt = qtrue;
                                }
                        }

                        if (spawnEnt)
                        {
                                SiegeRespawn(ent);

                                spawnEnt = qfalse;
                        }
                        i++;
                }
        }

        //Now check if there's something to fire off at the round start, if so do it.
        if (BG_SiegeGetPairedValue(siege_info, "roundbegin_target", targname))
        {
                if (targname[0])
                {
                        G_UseTargets2(&g_entities[entNum], &g_entities[entNum], targname);
                }
        }

        trap_SetConfigstring(CS_SIEGE_STATE, va("0|%i", level.time)); //we're ready to g0g0g0
}

void SiegeCheckTimers(void)
{
        int i=0;
        gentity_t *ent;
        int numTeam1 = 0;
        int numTeam2 = 0;

        if (g_gametype.integer != GT_SIEGE)
        {
                return;
        }

        if (level.intermissiontime)
        {
                return;
        }

        if (gSiegeRoundEnded)
        {
                return;
        }

        if (!gSiegeRoundBegun)
        { //check if anyone is active on this team - if not, keep the timer set up.
                i = 0;

                while (i < MAX_CLIENTS)
                {
                        ent = &g_entities[i];

                        if (ent && ent->inuse && ent->client &&
                                ent->client->pers.connected == CON_CONNECTED &&
                                ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM1)
                        {
                                numTeam1++;
                        }
                        i++;
                }

                i = 0;

                while (i < MAX_CLIENTS)
                {
                        ent = &g_entities[i];

                        if (ent && ent->inuse && ent->client &&
                                ent->client->pers.connected == CON_CONNECTED &&
                                ent->client->sess.siegeDesiredTeam == SIEGETEAM_TEAM2)
                        {
                                numTeam2++;
                        }
                        i++;
                }

                if (g_siegeTeamSwitch.integer &&
                        g_siegePersistant.beatingTime)
                {
                        gImperialCountdown = level.time + g_siegePersistant.lastTime;
                        gRebelCountdown = level.time + g_siegePersistant.lastTime;
                }
                else
                {
                        gImperialCountdown = level.time + imperial_time_limit;
                        gRebelCountdown = level.time + rebel_time_limit;
                }
        }

        if (imperial_time_limit)
        { //team1
                if (gImperialCountdown < level.time)
                {
                        SiegeRoundComplete(SIEGETEAM_TEAM2, ENTITYNUM_NONE);
                        imperial_time_limit = 0;
                        return;
                }
        }

        if (rebel_time_limit)
        { //team2
                if (gRebelCountdown < level.time)
                {
                        SiegeRoundComplete(SIEGETEAM_TEAM1, ENTITYNUM_NONE);
                        rebel_time_limit = 0;
                        return;
                }
        }

        if (!gSiegeRoundBegun)
        {
                if (!numTeam1 || !numTeam2)
                { //don't have people on both teams yet.
                        gSiegeBeginTime = level.time + SIEGE_ROUND_BEGIN_TIME;
                        trap_SetConfigstring(CS_SIEGE_STATE, "1"); //"waiting for players on both teams"
                }
                else if (gSiegeBeginTime < level.time)
                { //mark the round as having begun
                        gSiegeRoundBegun = qtrue;
                        SiegeBeginRound(i); //perform any round start tasks
                }
                else if (gSiegeBeginTime > (level.time + SIEGE_ROUND_BEGIN_TIME))
                {
                        gSiegeBeginTime = level.time + SIEGE_ROUND_BEGIN_TIME;
                }
                else
                {
                        trap_SetConfigstring(CS_SIEGE_STATE, va("2|%i", gSiegeBeginTime - SIEGE_ROUND_BEGIN_TIME)); //getting ready to begin
                }
        }
}

void SiegeObjectiveCompleted(int team, int objective, int final, int client)
{
        int goals_completed, goals_required;

        if (gSiegeRoundEnded)
        {
                return;
        }

        //Update the configstring status
        G_SiegeSetObjectiveComplete(team, objective, qfalse);

        if (final != -1)
        {
                if (team == SIEGETEAM_TEAM1)
                {
                        imperial_goals_completed++;
                }
                else
                {
                        rebel_goals_completed++;
                }
        }

        if (team == SIEGETEAM_TEAM1)
        {
                goals_completed = imperial_goals_completed;
                goals_required = imperial_goals_required;
        }
        else
        {
                goals_completed = rebel_goals_completed;
                goals_required = rebel_goals_required;
        }

        if (final == 1 || goals_completed >= goals_required)
        {
                SiegeRoundComplete(team, client);
        }
        else
        {
                BroadcastObjectiveCompletion(team, objective, final, client);
        }
}

void siegeTriggerUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
{
        char                    teamstr[64];
        char                    objectivestr[64];
        char                    desiredobjective[MAX_SIEGE_INFO_SIZE];
        int                             clUser = ENTITYNUM_NONE;
        int                             final = 0;
        int                             i = 0;

        if (!siege_valid)
        {
                return;
        }

        if (!(ent->s.eFlags & EF_RADAROBJECT))
        { //toggle radar on and exit if it is not showing up already
                ent->s.eFlags |= EF_RADAROBJECT;
                return;
        }

        if (activator && activator->client)
        { //activator will hopefully be the person who triggered this event
                clUser = activator->s.number;
        }

        if (ent->side == SIEGETEAM_TEAM1)
        {
                Com_sprintf(teamstr, sizeof(teamstr), team1);
        }
        else
        {
                Com_sprintf(teamstr, sizeof(teamstr), team2);
        }

        if (BG_SiegeGetValueGroup(siege_info, teamstr, gParseObjectives))
        {
                Com_sprintf(objectivestr, sizeof(objectivestr), "Objective%i", ent->objective);

                if (BG_SiegeGetValueGroup(gParseObjectives, objectivestr, desiredobjective))
                {
                        if (BG_SiegeGetPairedValue(desiredobjective, "final", teamstr))
                        {
                                final = atoi(teamstr);
                        }

                        if (BG_SiegeGetPairedValue(desiredobjective, "target", teamstr))
                        {
                                while (teamstr[i])
                                {
                                        if (teamstr[i] == '\r' ||
                                                teamstr[i] == '\n')
                                        {
                                                teamstr[i] = '\0';
                                        }

                                        i++;
                                }
                                UseSiegeTarget(other, activator, teamstr);
                        }

                        if (ent->target && ent->target[0])
                        { //use this too
                                UseSiegeTarget(other, activator, ent->target);
                        }

                        SiegeObjectiveCompleted(ent->side, ent->objective, final, clUser);
                }
        }
}

/*QUAKED info_siege_objective (1 0 1) (-16 -16 -24) (16 16 32) ? x x STARTOFFRADAR
STARTOFFRADAR - start not displaying on radar, don't display until used.

"objective" - specifies the objective to complete upon activation
"side" - set to 1 to specify an imperial goal, 2 to specify rebels
"icon" - icon that represents the objective on the radar
*/
void SP_info_siege_objective (gentity_t *ent)
{
        char* s;

        if (!siege_valid || g_gametype.integer != GT_SIEGE)
        {
                G_FreeEntity(ent);
                return;
        }

        ent->use = siegeTriggerUse;
        G_SpawnInt( "objective", "0", &ent->objective);
        G_SpawnInt( "side", "0", &ent->side);

        if (!ent->objective || !ent->side)
        { //j00 fux0red something up
                G_FreeEntity(ent);
                G_Printf("ERROR: info_siege_objective without an objective or side value\n");
                return;
        }

        //Set it up to be drawn on radar
        if (!(ent->spawnflags & SIEGEITEM_STARTOFFRADAR))
        {
                ent->s.eFlags |= EF_RADAROBJECT;
        }

        //All clients want to know where it is at all times for radar
        ent->r.svFlags |= SVF_BROADCAST;

        G_SpawnString( "icon", "", &s );
        
        if (s && s[0])
        { 
                // We have an icon, so index it now.  We are reusing the genericenemyindex
                // variable rather than adding a new one to the entity state.
                ent->s.genericenemyindex = G_IconIndex(s);
        }

        ent->s.brokenLimbs = ent->side;
        ent->s.frame = ent->objective;
        trap_LinkEntity(ent);
}


void SiegeIconUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
{ //toggle it on and off
        if (ent->s.eFlags & EF_RADAROBJECT)
        {
                ent->s.eFlags &= ~EF_RADAROBJECT;
                ent->r.svFlags &= ~SVF_BROADCAST;
        }
        else
        {
                ent->s.eFlags |= EF_RADAROBJECT;
                ent->r.svFlags |= SVF_BROADCAST;
        }
}

/*QUAKED info_siege_radaricon (1 0 1) (-16 -16 -24) (16 16 32) ? 
Used to arbitrarily display radar icons at placed location. Can be used
to toggle on and off.

"icon" - icon that represents the objective on the radar
"startoff" - if 1 start off
*/
void SP_info_siege_radaricon (gentity_t *ent)
{
        char* s;
        int i;

        if (!siege_valid || g_gametype.integer != GT_SIEGE)
        {
                G_FreeEntity(ent);
                return;
        }

        G_SpawnInt("startoff", "0", &i);

        if (!i)
        { //start on then
                ent->s.eFlags |= EF_RADAROBJECT;
                ent->r.svFlags |= SVF_BROADCAST;
        }

        G_SpawnString( "icon", "", &s );
        if (!s || !s[0])
        { //that's the whole point of the entity
        Com_Error(ERR_DROP, "misc_siege_radaricon without an icon");
                return;
        }

        ent->use = SiegeIconUse;

        ent->s.genericenemyindex = G_IconIndex(s);

        trap_LinkEntity(ent);
}

void decompTriggerUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
{
        int final = 0;
        char teamstr[1024];
        char objectivestr[64];
        char desiredobjective[MAX_SIEGE_INFO_SIZE];

        if (gSiegeRoundEnded)
        {
                return;
        }

        if (!G_SiegeGetCompletionStatus(ent->side, ent->objective))
        { //if it's not complete then there's nothing to do here
                return;
        }

        //Update the configstring status
        G_SiegeSetObjectiveComplete(ent->side, ent->objective, qtrue);

        //Find out if this objective counts toward the final objective count
        if (ent->side == SIEGETEAM_TEAM1)
        {
                Com_sprintf(teamstr, sizeof(teamstr), team1);
        }
        else
        {
                Com_sprintf(teamstr, sizeof(teamstr), team2);
        }

        if (BG_SiegeGetValueGroup(siege_info, teamstr, gParseObjectives))
        {
                Com_sprintf(objectivestr, sizeof(objectivestr), "Objective%i", ent->objective);

                if (BG_SiegeGetValueGroup(gParseObjectives, objectivestr, desiredobjective))
                {
                        if (BG_SiegeGetPairedValue(desiredobjective, "final", teamstr))
                        {
                                final = atoi(teamstr);
                        }
                }
        }

        //Subtract the goal num if applicable
        if (final != -1)
        {
                if (ent->side == SIEGETEAM_TEAM1)
                {
                        imperial_goals_completed--;
                }
                else
                {
                        rebel_goals_completed--;
                }
        }
}

/*QUAKED info_siege_decomplete (1 0 1) (-16 -16 -24) (16 16 32)
"objective" - specifies the objective to decomplete upon activation
"side" - set to 1 to specify an imperial (team1) goal, 2 to specify rebels (team2)
*/
void SP_info_siege_decomplete (gentity_t *ent)
{
        if (!siege_valid || g_gametype.integer != GT_SIEGE)
        {
                G_FreeEntity(ent);
                return;
        }

        ent->use = decompTriggerUse;
        G_SpawnInt( "objective", "0", &ent->objective);
        G_SpawnInt( "side", "0", &ent->side);

        if (!ent->objective || !ent->side)
        { //j00 fux0red something up
                G_FreeEntity(ent);
                G_Printf("ERROR: info_siege_objective_decomplete without an objective or side value\n");
                return;
        }
}

void siegeEndUse(gentity_t *ent, gentity_t *other, gentity_t *activator)
{
        LogExit("Round ended");
}

/*QUAKED target_siege_end (1 0 1) (-16 -16 -24) (16 16 32)
Do a logexit for siege when used.
*/
void SP_target_siege_end (gentity_t *ent)
{
        if (!siege_valid || g_gametype.integer != GT_SIEGE)
        {
                G_FreeEntity(ent);
                return;
        }

        ent->use = siegeEndUse;
}

#define SIEGE_ITEM_RESPAWN_TIME 20000

void SiegeItemRemoveOwner(gentity_t *ent, gentity_t *carrier)
{
        ent->genericValue2 = 0; //Remove picked-up flag

        ent->genericValue8 = ENTITYNUM_NONE; //Mark entity carrying us as none

        if (carrier)
        {
                carrier->client->holdingObjectiveItem = 0; //The carrier is no longer carrying us
                carrier->r.svFlags &= ~SVF_BROADCAST;
        }
}

static void SiegeItemRespawnEffect(gentity_t *ent, vec3_t newOrg)
{
        vec3_t upAng;

        if (ent->target5 && ent->target5[0])
        {
                G_UseTargets2(ent, ent, ent->target5);
        }

        if (!ent->genericValue10)
        { //no respawn effect
                return;
        }

        VectorSet(upAng, 0, 0, 1);

        //Play it once on the current origin, and once on the origin we're respawning to.
        G_PlayEffectID(ent->genericValue10, ent->r.currentOrigin, upAng);
        G_PlayEffectID(ent->genericValue10, newOrg, upAng);
}

static void SiegeItemRespawnOnOriginalSpot(gentity_t *ent, gentity_t *carrier)
{
        SiegeItemRespawnEffect(ent, ent->pos1);
        G_SetOrigin(ent, ent->pos1);
        SiegeItemRemoveOwner(ent, carrier);
        
        // Stop the item from flashing on the radar
        ent->s.time2 = 0;
}

void SiegeItemThink(gentity_t *ent)
{
        gentity_t *carrier = NULL;

        if (ent->genericValue12)
        { //recharge health
                if (ent->health > 0 && ent->health < ent->maxHealth && ent->genericValue14 < level.time)
                {
            ent->genericValue14 = level.time + ent->genericValue13;
                        ent->health += ent->genericValue12;
                        if (ent->health > ent->maxHealth)
                        {
                                ent->health = ent->maxHealth;
                        }
                }
        }

        if (ent->genericValue8 != ENTITYNUM_NONE)
        { //Just keep sticking it on top of the owner. We need it in the same PVS as him so it will render bolted onto him properly.
                carrier = &g_entities[ent->genericValue8];

                if (carrier->inuse && carrier->client)
                {
                        VectorCopy(carrier->client->ps.origin, ent->r.currentOrigin);
                        trap_LinkEntity(ent);
                }
        }
        else if (ent->genericValue1)
        { //this means we want to run physics on the object
                G_RunExPhys(ent, ent->radius, ent->mass, ent->random, qfalse, NULL, 0);
        }

        //Bolt us to whoever is carrying us if a client
        if (ent->genericValue8 < MAX_CLIENTS)
        {
                ent->s.boltToPlayer = ent->genericValue8+1;
        }
        else
        {
                ent->s.boltToPlayer = 0;
        }


        if (carrier)
        {
                gentity_t *carrier = &g_entities[ent->genericValue8];

                //This checking can be a bit iffy on the death stuff, but in theory we should always
                //get a think in before the default minimum respawn time is exceeded.
                if (!carrier->inuse || !carrier->client ||
                        (carrier->client->sess.sessionTeam != SIEGETEAM_TEAM1 && carrier->client->sess.sessionTeam != SIEGETEAM_TEAM2) ||
                        (carrier->client->ps.pm_flags & PMF_FOLLOW))