codemp/cgame/cg_main.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_main.c -- initialization and primary entry point for cgame
#include "cg_local.h"

#include "../ui/ui_shared.h"
// display context for new ui stuff
displayContextDef_t cgDC;

#if !defined(CL_LIGHT_H_INC)
        #include "cg_lights.h"
#endif

extern int cgSiegeRoundState;
extern int cgSiegeRoundTime;
/*
Ghoul2 Insert Start
*/
void CG_InitItems(void);
/*
Ghoul2 Insert End
*/

void CG_InitJetpackGhoul2(void);
void CG_CleanJetpackGhoul2(void);

vec4_t colorTable[CT_MAX] = 
{
{0, 0, 0, 0},                   // CT_NONE
{0, 0, 0, 1},                   // CT_BLACK
{1, 0, 0, 1},                   // CT_RED
{0, 1, 0, 1},                   // CT_GREEN
{0, 0, 1, 1},                   // CT_BLUE
{1, 1, 0, 1},                   // CT_YELLOW
{1, 0, 1, 1},                   // CT_MAGENTA
{0, 1, 1, 1},                   // CT_CYAN
{1, 1, 1, 1},                   // CT_WHITE
{0.75f, 0.75f, 0.75f, 1},       // CT_LTGREY
{0.50f, 0.50f, 0.50f, 1},       // CT_MDGREY
{0.25f, 0.25f, 0.25f, 1},       // CT_DKGREY
{0.15f, 0.15f, 0.15f, 1},       // CT_DKGREY2

{0.810f, 0.530f, 0.0f,  1},     // CT_VLTORANGE -- needs values
{0.810f, 0.530f, 0.0f,  1},     // CT_LTORANGE
{0.610f, 0.330f, 0.0f,  1},     // CT_DKORANGE
{0.402f, 0.265f, 0.0f,  1},     // CT_VDKORANGE

{0.503f, 0.375f, 0.996f, 1},    // CT_VLTBLUE1
{0.367f, 0.261f, 0.722f, 1},    // CT_LTBLUE1
{0.199f, 0.0f,   0.398f, 1},    // CT_DKBLUE1
{0.160f, 0.117f, 0.324f, 1},    // CT_VDKBLUE1

{0.300f, 0.628f, 0.816f, 1},    // CT_VLTBLUE2 -- needs values
{0.300f, 0.628f, 0.816f, 1},    // CT_LTBLUE2
{0.191f, 0.289f, 0.457f, 1},    // CT_DKBLUE2
{0.125f, 0.250f, 0.324f, 1},    // CT_VDKBLUE2

{0.796f, 0.398f, 0.199f, 1},    // CT_VLTBROWN1 -- needs values
{0.796f, 0.398f, 0.199f, 1},    // CT_LTBROWN1
{0.558f, 0.207f, 0.027f, 1},    // CT_DKBROWN1
{0.328f, 0.125f, 0.035f, 1},    // CT_VDKBROWN1

{0.996f, 0.796f, 0.398f, 1},    // CT_VLTGOLD1 -- needs values
{0.996f, 0.796f, 0.398f, 1},    // CT_LTGOLD1
{0.605f, 0.441f, 0.113f, 1},    // CT_DKGOLD1
{0.386f, 0.308f, 0.148f, 1},    // CT_VDKGOLD1

{0.648f, 0.562f, 0.784f, 1},    // CT_VLTPURPLE1 -- needs values
{0.648f, 0.562f, 0.784f, 1},    // CT_LTPURPLE1
{0.437f, 0.335f, 0.597f, 1},    // CT_DKPURPLE1
{0.308f, 0.269f, 0.375f, 1},    // CT_VDKPURPLE1

{0.816f, 0.531f, 0.710f, 1},    // CT_VLTPURPLE2 -- needs values
{0.816f, 0.531f, 0.710f, 1},    // CT_LTPURPLE2
{0.566f, 0.269f, 0.457f, 1},    // CT_DKPURPLE2
{0.343f, 0.226f, 0.316f, 1},    // CT_VDKPURPLE2

{0.929f, 0.597f, 0.929f, 1},    // CT_VLTPURPLE3
{0.570f, 0.371f, 0.570f, 1},    // CT_LTPURPLE3
{0.355f, 0.199f, 0.355f, 1},    // CT_DKPURPLE3
{0.285f, 0.136f, 0.230f, 1},    // CT_VDKPURPLE3

{0.953f, 0.378f, 0.250f, 1},    // CT_VLTRED1
{0.953f, 0.378f, 0.250f, 1},    // CT_LTRED1
{0.593f, 0.121f, 0.109f, 1},    // CT_DKRED1
{0.429f, 0.171f, 0.113f, 1},    // CT_VDKRED1
{.25f, 0, 0, 1},                                        // CT_VDKRED
{.70f, 0, 0, 1},                                        // CT_DKRED
        
{0.717f, 0.902f, 1.0f,   1},            // CT_VLTAQUA
{0.574f, 0.722f, 0.804f, 1},            // CT_LTAQUA
{0.287f, 0.361f, 0.402f, 1},            // CT_DKAQUA
{0.143f, 0.180f, 0.201f, 1},            // CT_VDKAQUA

{0.871f, 0.386f, 0.375f, 1},            // CT_LTPINK
{0.435f, 0.193f, 0.187f, 1},            // CT_DKPINK
{         0,    .5f,    .5f, 1},                // CT_LTCYAN
{         0,   .25f,   .25f, 1},                // CT_DKCYAN
{   .179f, .51f,   .92f, 1},            // CT_LTBLUE3
{   .199f, .71f,   .92f, 1},            // CT_LTBLUE3
{   .5f,   .05f,    .4f, 1},            // CT_DKBLUE3

{   0.0f,   .613f,  .097f, 1},          // CT_HUD_GREEN
{   0.835f, .015f,  .015f, 1},          // CT_HUD_RED
{       .567f,  .685f,  1.0f,   .75f},  // CT_ICON_BLUE
{       .515f,  .406f,  .507f,  1},             // CT_NO_AMMO_RED
{   1.0f,   .658f,  .062f, 1},          // CT_HUD_ORANGE

};

#include "holocronicons.h"

int cgWeatherOverride = 0;

int forceModelModificationCount = -1;

void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum );
void CG_Shutdown( void );

void CG_CalcEntityLerpPositions( centity_t *cent );
void CG_ROFF_NotetrackCallback( centity_t *cent, const char *notetrack);

#include "../namespace_begin.h"
void UI_CleanupGhoul2(void);
#include "../namespace_end.h"

static int      C_PointContents(void);
static void C_GetLerpOrigin(void);
static void C_GetLerpData(void);
static void C_Trace(void);
static void C_G2Trace(void);
static void C_G2Mark(void);
static int      CG_RagCallback(int callType);
static void C_GetBoltPos(void);
static void C_ImpactMark(void);

#ifdef _XBOX
#define MAX_MISC_ENTS   500
#else
#define MAX_MISC_ENTS   4000
#endif

//static refEntity_t    *MiscEnts = 0;
//static float          *Radius = 0;
static refEntity_t      MiscEnts[MAX_MISC_ENTS]; //statically allocated for now.
static float            Radius[MAX_MISC_ENTS];
static float            zOffset[MAX_MISC_ENTS]; //some models need a z offset for culling, because of stupid wrong model origins

static int                      NumMiscEnts = 0;

extern autoMapInput_t cg_autoMapInput; //cg_view.c
extern int cg_autoMapInputTime;
extern vec3_t cg_autoMapAngle;

void CG_MiscEnt(void);
void CG_DoCameraShake( vec3_t origin, float intensity, int radius, int time );

//do we have any force powers that we would normally need to cycle to?
qboolean CG_NoUseableForce(void)
{
        int i = FP_HEAL;
        while (i < NUM_FORCE_POWERS)
        {
                if (i != FP_SABERTHROW &&
                        i != FP_SABER_OFFENSE &&
                        i != FP_SABER_DEFENSE &&
                        i != FP_LEVITATION)
                { //valid selectable power
                        if (cg.predictedPlayerState.fd.forcePowersKnown & (1 << i))
                        { //we have it
                                return qfalse;
                        }
                }
                i++;
        }

        //no useable force powers, I guess.
        return qtrue;
}

/*
================
vmMain

This is the only way control passes into the module.
This must be the very first function compiled into the .q3vm file
================
*/
#include "../namespace_begin.h"
int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11  ) {

        switch ( command ) {
        case CG_INIT:
                CG_Init( arg0, arg1, arg2 );
                return 0;
        case CG_SHUTDOWN:
                CG_Shutdown();
                return 0;
        case CG_CONSOLE_COMMAND:
                return CG_ConsoleCommand();
        case CG_DRAW_ACTIVE_FRAME:
                CG_DrawActiveFrame( arg0, arg1, arg2 );
                return 0;
        case CG_CROSSHAIR_PLAYER:
                return CG_CrosshairPlayer();
        case CG_LAST_ATTACKER:
                return CG_LastAttacker();
        case CG_KEY_EVENT:
                CG_KeyEvent(arg0, arg1);
                return 0;
        case CG_MOUSE_EVENT:
                cgDC.cursorx = cgs.cursorX;
                cgDC.cursory = cgs.cursorY;
                CG_MouseEvent(arg0, arg1);
                return 0;
        case CG_EVENT_HANDLING:
                CG_EventHandling(arg0);
                return 0;

        case CG_POINT_CONTENTS:
                return C_PointContents();

        case CG_GET_LERP_ORIGIN:
                C_GetLerpOrigin();
                return 0;

        case CG_GET_LERP_DATA:
                C_GetLerpData();
                return 0;

        case CG_GET_GHOUL2:
                return (int)cg_entities[arg0].ghoul2; //NOTE: This is used by the effect bolting which is actually not used at all.
                                                                                          //I'm fairly sure if you try to use it with vm's it will just give you total
                                                                                          //garbage. In other words, use at your own risk.

        case CG_GET_MODEL_LIST:
                return (int)cgs.gameModels;

        case CG_CALC_LERP_POSITIONS:
                CG_CalcEntityLerpPositions( &cg_entities[arg0] );
                return 0;

        case CG_TRACE:
                C_Trace();
                return 0;
        case CG_GET_SORTED_FORCE_POWER:
                return forcePowerSorted[arg0];
        case CG_G2TRACE:
                C_G2Trace();
                return 0;

        case CG_G2MARK:
                C_G2Mark();
                return 0;

        case CG_RAG_CALLBACK:
                return CG_RagCallback(arg0);

        case CG_INCOMING_CONSOLE_COMMAND:
                //rww - let mod authors filter client console messages so they can cut them off if they want.
                //return 1 if the command is ok. Otherwise, you can set char 0 on the command str to 0 and return
                //0 to not execute anything, or you can fill conCommand in with something valid and return 0
                //in order to have that string executed in place. Some example code:
#if 0
                {
                        TCGIncomingConsoleCommand       *icc = (TCGIncomingConsoleCommand *)cg.sharedBuffer;
                        if (strstr(icc->conCommand, "wait"))
                        { //filter out commands contaning wait
                                Com_Printf("You can't use commands containing the string wait with MyMod v1.0\n");
                                icc->conCommand[0] = 0;
                                return 0;
                        }
                        else if (strstr(icc->conCommand, "blah"))
                        { //any command containing the string "blah" is redirected to "quit"
                                strcpy(icc->conCommand, "quit");
                                return 0;
                        }
                }
#endif
                return 1;

        case CG_GET_USEABLE_FORCE:
                return CG_NoUseableForce();

        case CG_GET_ORIGIN:
                VectorCopy(cg_entities[arg0].currentState.pos.trBase, (float *)arg1);
                return 0;

        case CG_GET_ANGLES:
                VectorCopy(cg_entities[arg0].currentState.apos.trBase, (float *)arg1);
                return 0;

        case CG_GET_ORIGIN_TRAJECTORY:
                return (int)&cg_entities[arg0].nextState.pos;

        case CG_GET_ANGLE_TRAJECTORY:
                return (int)&cg_entities[arg0].nextState.apos;

        case CG_ROFF_NOTETRACK_CALLBACK:
                CG_ROFF_NotetrackCallback( &cg_entities[arg0], (const char *)arg1 );
                return 0;

        case CG_IMPACT_MARK:
                C_ImpactMark();
                return 0;

        case CG_MAP_CHANGE:
                // this trap map be called more than once for a given map change, as the
                // server is going to attempt to send out multiple broadcasts in hopes that
                // the client will receive one of them
                cg.mMapChange = qtrue;
                return 0;

        case CG_AUTOMAP_INPUT:
                //special input during automap mode -rww
                {
                        autoMapInput_t *autoInput = (autoMapInput_t *)cg.sharedBuffer;

                        memcpy(&cg_autoMapInput, autoInput, sizeof(autoMapInput_t));

                        if (!arg0)
                        { //if this is non-0, it's actually a one-frame mouse event
                                cg_autoMapInputTime = cg.time + 1000;
                        }
                        else
                        {
                                if (cg_autoMapInput.yaw)
                                {
                                        cg_autoMapAngle[YAW] += cg_autoMapInput.yaw;
                                }

                                if (cg_autoMapInput.pitch)
                                {
                                        cg_autoMapAngle[PITCH] += cg_autoMapInput.pitch;
                                }
                                cg_autoMapInput.yaw = 0.0f;
                                cg_autoMapInput.pitch = 0.0f;
                        }
                }
                return 0;

        case CG_MISC_ENT:
                CG_MiscEnt();
                return 0;

        case CG_FX_CAMERASHAKE:
                {
                        TCGCameraShake  *data = (TCGCameraShake *)cg.sharedBuffer;
                        
                        CG_DoCameraShake( data->mOrigin, data->mIntensity, data->mRadius, data->mTime );
                }
                return 0;

        default:
                CG_Error( "vmMain: unknown command %i", command );
                break;
        }
        return -1;
}
#include "../namespace_end.h"

static int C_PointContents(void)
{
        TCGPointContents        *data = (TCGPointContents *)cg.sharedBuffer;

        return CG_PointContents( data->mPoint, data->mPassEntityNum );
}

static void C_GetLerpOrigin(void)
{
        TCGVectorData           *data = (TCGVectorData *)cg.sharedBuffer;

        VectorCopy(cg_entities[data->mEntityNum].lerpOrigin, data->mPoint);
}

static void C_GetLerpData(void)
{//only used by FX system to pass to getboltmat
        TCGGetBoltData          *data = (TCGGetBoltData *)cg.sharedBuffer;

        VectorCopy(cg_entities[data->mEntityNum].lerpOrigin, data->mOrigin);
        VectorCopy(cg_entities[data->mEntityNum].modelScale, data->mScale);
        VectorCopy(cg_entities[data->mEntityNum].lerpAngles, data->mAngles);
        if (cg_entities[data->mEntityNum].currentState.eType == ET_PLAYER)
        { //normal player
                data->mAngles[PITCH] = 0.0f;
                data->mAngles[ROLL] = 0.0f;
        }
        else if (cg_entities[data->mEntityNum].currentState.eType == ET_NPC)
        { //an NPC
                Vehicle_t *pVeh = cg_entities[data->mEntityNum].m_pVehicle;
                if (!pVeh)
                { //for vehicles, we may or may not want to 0 out pitch and roll
                        data->mAngles[PITCH] = 0.0f;
                        data->mAngles[ROLL] = 0.0f;
                }
                else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
                { //speeder wants no pitch but a roll
                        data->mAngles[PITCH] = 0.0f;
                }
                else if (pVeh->m_pVehicleInfo->type != VH_FIGHTER)
                { //fighters want all angles
                        data->mAngles[PITCH] = 0.0f;
                        data->mAngles[ROLL] = 0.0f;
                }
        }
}

static void C_Trace(void)
{
        TCGTrace        *td = (TCGTrace *)cg.sharedBuffer;

        CG_Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
}

static void C_G2Trace(void)
{
        TCGTrace        *td = (TCGTrace *)cg.sharedBuffer;

        CG_G2Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
}

static void C_G2Mark(void)
{
        TCGG2Mark       *td = (TCGG2Mark *)cg.sharedBuffer;
        trace_t         tr;
        vec3_t          end;

        VectorMA(td->start, 64, td->dir, end);
        CG_G2Trace(&tr, td->start, NULL, NULL, end, ENTITYNUM_NONE, MASK_PLAYERSOLID);

        if (tr.entityNum < ENTITYNUM_WORLD &&
                cg_entities[tr.entityNum].ghoul2)
        { //hit someone with a ghoul2 instance, let's project the decal on them then.
                centity_t *cent = &cg_entities[tr.entityNum];

                //CG_TestLine(tr.endpos, end, 2000, 0x0000ff, 1);

                CG_AddGhoul2Mark(td->shader, td->size, tr.endpos, end, tr.entityNum,
                        cent->lerpOrigin, cent->lerpAngles[YAW], cent->ghoul2, cent->modelScale,
                        Q_irand(2000, 4000));
                //I'm making fx system decals have a very short lifetime.
        }
}

static void CG_DebugBoxLines(vec3_t mins, vec3_t maxs, int duration)
{
        vec3_t start;
        vec3_t end;
        vec3_t vert;

        float x = maxs[0] - mins[0];
        float y = maxs[1] - mins[1];

        start[2] = maxs[2];
        vert[2] = mins[2];

        vert[0] = mins[0];
        vert[1] = mins[1];
        start[0] = vert[0];
        start[1] = vert[1];
        CG_TestLine(start, vert, duration, 0x00000ff, 1);

        vert[0] = mins[0];
        vert[1] = maxs[1];
        start[0] = vert[0];
        start[1] = vert[1];
        CG_TestLine(start, vert, duration, 0x00000ff, 1);

        vert[0] = maxs[0];
        vert[1] = mins[1];
        start[0] = vert[0];
        start[1] = vert[1];
        CG_TestLine(start, vert, duration, 0x00000ff, 1);

        vert[0] = maxs[0];
        vert[1] = maxs[1];
        start[0] = vert[0];
        start[1] = vert[1];
        CG_TestLine(start, vert, duration, 0x00000ff, 1);

        // top of box
        VectorCopy(maxs, start);
        VectorCopy(maxs, end);
        start[0] -= x;
        CG_TestLine(start, end, duration, 0x00000ff, 1);
        end[0] = start[0];
        end[1] -= y;
        CG_TestLine(start, end, duration, 0x00000ff, 1);
        start[1] = end[1];
        start[0] += x;
        CG_TestLine(start, end, duration, 0x00000ff, 1);
        CG_TestLine(start, maxs, duration, 0x00000ff, 1);
        // bottom of box
        VectorCopy(mins, start);
        VectorCopy(mins, end);
        start[0] += x;
        CG_TestLine(start, end, duration, 0x00000ff, 1);
        end[0] = start[0];
        end[1] += y;
        CG_TestLine(start, end, duration, 0x00000ff, 1);
        start[1] = end[1];
        start[0] -= x;
        CG_TestLine(start, end, duration, 0x00000ff, 1);
        CG_TestLine(start, mins, duration, 0x00000ff, 1);
}

//handle ragdoll callbacks, for events and debugging -rww
static int CG_RagCallback(int callType)
{
        switch(callType)
        {
        case RAG_CALLBACK_DEBUGBOX:
                {
                        ragCallbackDebugBox_t *callData = (ragCallbackDebugBox_t *)cg.sharedBuffer;

                        CG_DebugBoxLines(callData->mins, callData->maxs, callData->duration);
                }
                break;
        case RAG_CALLBACK_DEBUGLINE:
                {
                        ragCallbackDebugLine_t *callData = (ragCallbackDebugLine_t *)cg.sharedBuffer;

                        CG_TestLine(callData->start, callData->end, callData->time, callData->color, callData->radius);
                }
                break;
        case RAG_CALLBACK_BONESNAP:
                {
                        ragCallbackBoneSnap_t *callData = (ragCallbackBoneSnap_t *)cg.sharedBuffer;
                        centity_t *cent = &cg_entities[callData->entNum];
                        int snapSound = trap_S_RegisterSound(va("sound/player/bodyfall_human%i.wav", Q_irand(1, 3)));

                        trap_S_StartSound(cent->lerpOrigin, callData->entNum, CHAN_AUTO, snapSound);
                }
        case RAG_CALLBACK_BONEIMPACT:
                break;
        case RAG_CALLBACK_BONEINSOLID:
#if 0
                {
                        ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cg.sharedBuffer;

                        if (callData->solidCount > 16)
                        { //don't bother if we're just tapping into solidity, we'll probably recover on our own
                                centity_t *cent = &cg_entities[callData->entNum];
                                vec3_t slideDir;

                                VectorSubtract(cent->lerpOrigin, callData->bonePos, slideDir);
                                VectorAdd(cent->ragOffsets, slideDir, cent->ragOffsets);

                                cent->hasRagOffset = qtrue;
                        }
                }
#endif
                break;
        case RAG_CALLBACK_TRACELINE:
                {
                        ragCallbackTraceLine_t *callData = (ragCallbackTraceLine_t *)cg.sharedBuffer;

                        CG_Trace(&callData->tr, callData->start, callData->mins, callData->maxs,
                                callData->end, callData->ignore, callData->mask);
                }
                break;
        default:
                Com_Error(ERR_DROP, "Invalid callType in CG_RagCallback");
                break;
        }

        return 0;
}

static void C_ImpactMark(void)
{
        TCGImpactMark   *data = (TCGImpactMark *)cg.sharedBuffer;

        /*
        CG_ImpactMark((int)arg0, (const float *)arg1, (const float *)arg2, (float)arg3,
                (float)arg4, (float)arg5, (float)arg6, (float)arg7, qtrue, (float)arg8, qfalse);
        */
        CG_ImpactMark(data->mHandle, data->mPoint, data->mAngle, data->mRotation,
                data->mRed, data->mGreen, data->mBlue, data->mAlphaStart, qtrue, data->mSizeStart, qfalse);
}

void CG_MiscEnt(void)
{
        int                     modelIndex;
        refEntity_t     *RefEnt;
        TCGMiscEnt      *data = (TCGMiscEnt *)cg.sharedBuffer;
        vec3_t          mins, maxs;
        float           *radius, *zOff;

        if (NumMiscEnts >= MAX_MISC_ENTS)
        {
                return;
        }
        
        radius = &Radius[NumMiscEnts];
        zOff = &zOffset[NumMiscEnts];
        RefEnt = &MiscEnts[NumMiscEnts++];

        modelIndex = trap_R_RegisterModel(data->mModel);
        if (modelIndex == 0)
        {
                Com_Error(ERR_DROP, "client_model has invalid model definition");
                return;
        }

        *zOff = 0;

        memset(RefEnt, 0, sizeof(refEntity_t));
        RefEnt->reType = RT_MODEL;
        RefEnt->hModel = modelIndex;
        RefEnt->frame = 0;
        trap_R_ModelBounds(modelIndex, mins, maxs);
        VectorCopy(data->mScale, RefEnt->modelScale);
        VectorCopy(data->mOrigin, RefEnt->origin);

        VectorScaleVector(mins, data->mScale, mins);
        VectorScaleVector(maxs, data->mScale, maxs);
        *radius = Distance(mins, maxs);

        AnglesToAxis( data->mAngles, RefEnt->axis );
        ScaleModelAxis(RefEnt);
}

void CG_DrawMiscEnts(void)
{
        int                     i;
        refEntity_t     *RefEnt;
        float           *radius, *zOff;
        vec3_t          difference;
        vec3_t          cullOrigin;

        RefEnt = MiscEnts;
        radius = Radius;
        zOff = zOffset;
        for(i=0;i<NumMiscEnts;i++)
        {
                VectorCopy(RefEnt->origin, cullOrigin);
                cullOrigin[2] += 1.0f;

                if (*zOff)
                {
                        cullOrigin[2] += *zOff;
                }

                if (cg.snap && trap_R_inPVS(cg.refdef.vieworg, cullOrigin, cg.snap->areamask))
                {
                        VectorSubtract(RefEnt->origin, cg.refdef.vieworg, difference);
                        if (VectorLength(difference)-(*radius) <= cg.distanceCull)
                        {
                                trap_R_AddRefEntityToScene(RefEnt);
                        }
                }
                RefEnt++;
                radius++;
                zOff++;
        }
}

/*
Ghoul2 Insert Start
*/
/*
void CG_ResizeG2Bolt(boltInfo_v *bolt, int newCount)
{
        bolt->resize(newCount);
}

void CG_ResizeG2Surface(surfaceInfo_v *surface, int newCount)
{
        surface->resize(newCount);
}

void CG_ResizeG2Bone(boneInfo_v *bone, int newCount)
{
        bone->resize(newCount);
}

void CG_ResizeG2(CGhoul2Info_v *ghoul2, int newCount)
{
        ghoul2->resize(newCount);
}

void CG_ResizeG2TempBone(mdxaBone_v *tempBone, int newCount)
{
        tempBone->resize(newCount);
}
*/
/*
Ghoul2 Insert End
*/
cg_t                            cg;
cgs_t                           cgs;
centity_t                       cg_entities[MAX_GENTITIES];

centity_t                       *cg_permanents[MAX_GENTITIES]; //rwwRMG - added
int                                     cg_numpermanents = 0;

weaponInfo_t            cg_weapons[MAX_WEAPONS];
itemInfo_t                      cg_items[MAX_ITEMS];


vmCvar_t        cg_centertime;
vmCvar_t        cg_runpitch;
vmCvar_t        cg_runroll;
vmCvar_t        cg_bobup;
vmCvar_t        cg_bobpitch;
vmCvar_t        cg_bobroll;
//vmCvar_t      cg_swingSpeed;
vmCvar_t        cg_shadows;
vmCvar_t        cg_renderToTextureFX;
vmCvar_t        cg_drawTimer;
vmCvar_t        cg_drawFPS;
vmCvar_t        cg_drawSnapshot;
vmCvar_t        cg_draw3dIcons;
vmCvar_t        cg_drawIcons;
vmCvar_t        cg_drawAmmoWarning;
vmCvar_t        cg_drawCrosshair;
vmCvar_t        cg_drawCrosshairNames;
vmCvar_t        cg_drawRadar;
vmCvar_t        cg_drawVehLeadIndicator;
vmCvar_t        cg_dynamicCrosshair;
vmCvar_t        cg_dynamicCrosshairPrecision;
vmCvar_t        cg_drawRewards;
vmCvar_t        cg_drawScores;
vmCvar_t        cg_crosshairSize;
vmCvar_t        cg_crosshairX;
vmCvar_t        cg_crosshairY;
vmCvar_t        cg_crosshairHealth;
vmCvar_t        cg_draw2D;
vmCvar_t        cg_drawStatus;
vmCvar_t        cg_animSpeed;
vmCvar_t        cg_debugAnim;
vmCvar_t        cg_debugSaber;
vmCvar_t        cg_debugPosition;
vmCvar_t        cg_debugEvents;
vmCvar_t        cg_errorDecay;
vmCvar_t        cg_nopredict;
vmCvar_t        cg_noPlayerAnims;
vmCvar_t        cg_showmiss;
vmCvar_t        cg_showVehMiss;
vmCvar_t        cg_footsteps;
vmCvar_t        cg_addMarks;
vmCvar_t        cg_viewsize;
vmCvar_t        cg_drawGun;
vmCvar_t        cg_gun_frame;
vmCvar_t        cg_gun_x;
vmCvar_t        cg_gun_y;
vmCvar_t        cg_gun_z;
vmCvar_t        cg_autoswitch;
vmCvar_t        cg_ignore;
vmCvar_t        cg_simpleItems;
vmCvar_t        cg_fov;
vmCvar_t        cg_zoomFov;

vmCvar_t        cg_swingAngles;

vmCvar_t        cg_oldPainSounds;

vmCvar_t        cg_ragDoll;

vmCvar_t        cg_jumpSounds;

vmCvar_t        cg_autoMap;
vmCvar_t        cg_autoMapX;
vmCvar_t        cg_autoMapY;
vmCvar_t        cg_autoMapW;
vmCvar_t        cg_autoMapH;

#ifndef _XBOX   // Hmmm. This is also in game. I think this is safe.
vmCvar_t        bg_fighterAltControl;
#endif

vmCvar_t        cg_chatBox;
vmCvar_t        cg_chatBoxHeight;

vmCvar_t        cg_saberModelTraceEffect;

vmCvar_t        cg_saberClientVisualCompensation;

vmCvar_t        cg_g2TraceLod;

vmCvar_t        cg_fpls;

vmCvar_t        cg_ghoul2Marks;

vmCvar_t        cg_optvehtrace;

vmCvar_t        cg_saberDynamicMarks;
vmCvar_t        cg_saberDynamicMarkTime;

vmCvar_t        cg_saberContact;
vmCvar_t        cg_saberTrail;

vmCvar_t        cg_duelHeadAngles;

vmCvar_t        cg_speedTrail;
vmCvar_t        cg_auraShell;

vmCvar_t        cg_repeaterOrb;

vmCvar_t        cg_animBlend;

vmCvar_t        cg_dismember;

vmCvar_t        cg_thirdPersonSpecialCam;

vmCvar_t        cg_thirdPerson;
vmCvar_t        cg_thirdPersonRange;
vmCvar_t        cg_thirdPersonAngle;
vmCvar_t        cg_thirdPersonPitchOffset;
vmCvar_t        cg_thirdPersonVertOffset;
vmCvar_t        cg_thirdPersonCameraDamp;
vmCvar_t        cg_thirdPersonTargetDamp;

vmCvar_t        cg_thirdPersonAlpha;
vmCvar_t        cg_thirdPersonHorzOffset;

vmCvar_t        cg_stereoSeparation;
vmCvar_t        cg_lagometer;
vmCvar_t        cg_drawEnemyInfo;
vmCvar_t        cg_synchronousClients;
vmCvar_t        cg_stats;
vmCvar_t        cg_buildScript;
vmCvar_t        cg_forceModel;
vmCvar_t        cg_paused;
vmCvar_t        cg_blood;
vmCvar_t        cg_predictItems;
vmCvar_t        cg_deferPlayers;
vmCvar_t        cg_drawTeamOverlay;
vmCvar_t        cg_teamOverlayUserinfo;
vmCvar_t        cg_drawFriend;
vmCvar_t        cg_teamChatsOnly;
vmCvar_t        cg_hudFiles;
vmCvar_t        cg_scorePlum;
vmCvar_t        cg_smoothClients;

#include "../namespace_begin.h"
vmCvar_t        pmove_fixed;
//vmCvar_t      cg_pmove_fixed;
vmCvar_t        pmove_msec;
// nmckenzie: DUEL_HEALTH
vmCvar_t        g_showDuelHealths;
#include "../namespace_end.h"

vmCvar_t        cg_pmove_msec;
vmCvar_t        cg_cameraMode;
vmCvar_t        cg_cameraOrbit;
vmCvar_t        cg_cameraOrbitDelay;
vmCvar_t        cg_timescaleFadeEnd;
vmCvar_t        cg_timescaleFadeSpeed;
vmCvar_t        cg_timescale;
vmCvar_t        cg_noTaunt;
vmCvar_t        cg_noProjectileTrail;
//vmCvar_t      cg_trueLightning;
/*
Ghoul2 Insert Start
*/
vmCvar_t        cg_debugBB;
/*
Ghoul2 Insert End
*/
//vmCvar_t      cg_redTeamName;
//vmCvar_t      cg_blueTeamName;
vmCvar_t        cg_currentSelectedPlayer;
vmCvar_t        cg_currentSelectedPlayerName;
//vmCvar_t      cg_singlePlayerActive;
vmCvar_t        cg_recordSPDemo;
vmCvar_t        cg_recordSPDemoName;
vmCvar_t        cg_showVehBounds;

vmCvar_t        ui_myteam;

vmCvar_t        cg_snapshotTimeout;

typedef struct {
        vmCvar_t        *vmCvar;
        char            *cvarName;
        char            *defaultString;
        int                     cvarFlags;
} cvarTable_t;

static cvarTable_t cvarTable[] = { // bk001129
        { &cg_ignore, "cg_ignore", "0", 0 },    // used for debugging
        { &cg_autoswitch, "cg_autoswitch", "1", CVAR_ARCHIVE },
        { &cg_drawGun, "cg_drawGun", "1", CVAR_ARCHIVE },
        { &cg_zoomFov, "cg_zoomfov", "40.0", CVAR_ARCHIVE },
        { &cg_fov, "cg_fov", "80", CVAR_ARCHIVE },
        { &cg_viewsize, "cg_viewsize", "100", CVAR_ARCHIVE },
        { &cg_stereoSeparation, "cg_stereoSeparation", "0.4", CVAR_ARCHIVE  },
        { &cg_shadows, "cg_shadows", "1", CVAR_ARCHIVE  },
        { &cg_renderToTextureFX, "cg_renderToTextureFX", "1", CVAR_ARCHIVE  },
        { &cg_draw2D, "cg_draw2D", "1", CVAR_ARCHIVE  },
        { &cg_drawStatus, "cg_drawStatus", "1", CVAR_ARCHIVE  },
        { &cg_drawTimer, "cg_drawTimer", "0", CVAR_ARCHIVE  },
        { &cg_drawFPS, "cg_drawFPS", "0", CVAR_ARCHIVE  },
        { &cg_drawSnapshot, "cg_drawSnapshot", "0", CVAR_ARCHIVE  },
        { &cg_draw3dIcons, "cg_draw3dIcons", "1", CVAR_ARCHIVE  },
        { &cg_drawIcons, "cg_drawIcons", "1", CVAR_ARCHIVE  },
        { &cg_drawAmmoWarning, "cg_drawAmmoWarning", "0", CVAR_ARCHIVE  },
        { &cg_drawEnemyInfo, "cg_drawEnemyInfo", "1", CVAR_ARCHIVE  },
        { &cg_drawCrosshair, "cg_drawCrosshair", "1", CVAR_ARCHIVE },
        { &cg_drawCrosshairNames, "cg_drawCrosshairNames", "1", CVAR_ARCHIVE },
        { &cg_drawRadar, "cg_drawRadar", "1", CVAR_ARCHIVE },
        { &cg_drawVehLeadIndicator, "cg_drawVehLeadIndicator", "1", CVAR_ARCHIVE },
        { &cg_drawScores,                 "cg_drawScores", "1", CVAR_ARCHIVE },
        { &cg_dynamicCrosshair, "cg_dynamicCrosshair", "1", CVAR_ARCHIVE },
        //Enables ghoul2 traces for crosshair traces.. more precise when pointing at others, but slower.
        //And if the server doesn't have g2 col enabled, it won't match up the same.
        { &cg_dynamicCrosshairPrecision, "cg_dynamicCrosshairPrecision", "1", CVAR_ARCHIVE },
        { &cg_drawRewards, "cg_drawRewards", "1", CVAR_ARCHIVE },
        { &cg_crosshairSize, "cg_crosshairSize", "24", CVAR_ARCHIVE },
        { &cg_crosshairHealth, "cg_crosshairHealth", "0", CVAR_ARCHIVE },
        { &cg_crosshairX, "cg_crosshairX", "0", CVAR_ARCHIVE },
        { &cg_crosshairY, "cg_crosshairY", "0", CVAR_ARCHIVE },
        { &cg_simpleItems, "cg_simpleItems", "0", CVAR_ARCHIVE },
        { &cg_addMarks, "cg_marks", "1", CVAR_ARCHIVE },
        { &cg_lagometer, "cg_lagometer", "0", CVAR_ARCHIVE },
        { &cg_gun_x, "cg_gunX", "0", CVAR_CHEAT },
        { &cg_gun_y, "cg_gunY", "0", CVAR_CHEAT },
        { &cg_gun_z, "cg_gunZ", "0", CVAR_CHEAT },
        { &cg_centertime, "cg_centertime", "3", CVAR_CHEAT },
        { &cg_runpitch, "cg_runpitch", "0.002", CVAR_ARCHIVE},
        { &cg_runroll, "cg_runroll", "0.005", CVAR_ARCHIVE },
        { &cg_bobup , "cg_bobup", "0.005", CVAR_ARCHIVE },
        { &cg_bobpitch, "cg_bobpitch", "0.002", CVAR_ARCHIVE },
        { &cg_bobroll, "cg_bobroll", "0.002", CVAR_ARCHIVE },
        //{ &cg_swingSpeed, "cg_swingSpeed", "0.3", CVAR_CHEAT },
        { &cg_animSpeed, "cg_animspeed", "1", CVAR_CHEAT },
        { &cg_debugAnim, "cg_debuganim", "0", CVAR_CHEAT },
        { &cg_debugSaber, "cg_debugsaber", "0", CVAR_CHEAT },
        { &cg_debugPosition, "cg_debugposition", "0", CVAR_CHEAT },
        { &cg_debugEvents, "cg_debugevents", "0", CVAR_CHEAT },
        { &cg_errorDecay, "cg_errordecay", "100", 0 },
        { &cg_nopredict, "cg_nopredict", "0", 0 },
        { &cg_noPlayerAnims, "cg_noplayeranims", "0", CVAR_CHEAT },
        { &cg_showmiss, "cg_showmiss", "0", 0 },
        { &cg_showVehMiss, "cg_showVehMiss", "0", 0 },
        { &cg_footsteps, "cg_footsteps", "3", CVAR_ARCHIVE },
        { &cg_swingAngles, "cg_swingAngles", "1", 0 },

        { &cg_oldPainSounds, "cg_oldPainSounds", "0", 0 },

        { &cg_ragDoll, "broadsword", "0", 0 },

        { &cg_jumpSounds, "cg_jumpSounds", "0", 0 },

        { &cg_autoMap, "r_autoMap", "0", CVAR_ARCHIVE },
        { &cg_autoMapX, "r_autoMapX", "496", CVAR_ARCHIVE },
        { &cg_autoMapY, "r_autoMapY", "32", CVAR_ARCHIVE },
        { &cg_autoMapW, "r_autoMapW", "128", CVAR_ARCHIVE },
        { &cg_autoMapH, "r_autoMapH", "128", CVAR_ARCHIVE },

        { &bg_fighterAltControl, "bg_fighterAltControl", "0", CVAR_SERVERINFO },

        { &cg_chatBox, "cg_chatBox", "10000", CVAR_ARCHIVE },
        { &cg_chatBoxHeight, "cg_chatBoxHeight", "350", CVAR_ARCHIVE },

        { &cg_saberModelTraceEffect, "cg_saberModelTraceEffect", "0", 0 },

        //allows us to trace between server frames on the client to see if we're visually
        //hitting the last entity we detected a hit on from the server.
        { &cg_saberClientVisualCompensation, "cg_saberClientVisualCompensation", "1", 0 },

        { &cg_g2TraceLod, "cg_g2TraceLod", "2", 0 },

        { &cg_fpls, "cg_fpls", "0", 0 },

        { &cg_ghoul2Marks, "cg_ghoul2Marks", "16", 0 },

        { &cg_optvehtrace, "com_optvehtrace", "0", 0 },

        { &cg_saberDynamicMarks, "cg_saberDynamicMarks", "0", 0 },
        { &cg_saberDynamicMarkTime, "cg_saberDynamicMarkTime", "60000", 0 },

        { &cg_saberContact, "cg_saberContact", "1", 0 },
        { &cg_saberTrail, "cg_saberTrail", "1", 0 },

        { &cg_duelHeadAngles, "cg_duelHeadAngles", "0", 0 },

        { &cg_speedTrail, "cg_speedTrail", "1", 0 },
        { &cg_auraShell, "cg_auraShell", "1", 0 },

        { &cg_repeaterOrb, "cg_repeaterOrb", "0", 0 },

        { &cg_animBlend, "cg_animBlend", "1", 0 },

        { &cg_dismember, "cg_dismember", "0", CVAR_ARCHIVE },

        { &cg_thirdPersonSpecialCam, "cg_thirdPersonSpecialCam", "0", 0 },

        { &cg_thirdPerson, "cg_thirdPerson", "0", CVAR_ARCHIVE },
        { &cg_thirdPersonRange, "cg_thirdPersonRange", "80", CVAR_CHEAT },
        { &cg_thirdPersonAngle, "cg_thirdPersonAngle", "0", CVAR_CHEAT },
        { &cg_thirdPersonPitchOffset, "cg_thirdPersonPitchOffset", "0", CVAR_CHEAT },
        { &cg_thirdPersonVertOffset, "cg_thirdPersonVertOffset", "16", CVAR_CHEAT },
        { &cg_thirdPersonCameraDamp, "cg_thirdPersonCameraDamp", "0.3", 0 },
        { &cg_thirdPersonTargetDamp, "cg_thirdPersonTargetDamp", "0.5", CVAR_CHEAT },
        
        { &cg_thirdPersonHorzOffset, "cg_thirdPersonHorzOffset", "0", CVAR_CHEAT },
        { &cg_thirdPersonAlpha, "cg_thirdPersonAlpha",  "1.0", CVAR_CHEAT },

        { &cg_forceModel, "cg_forceModel", "0", CVAR_ARCHIVE  },
        { &cg_predictItems, "cg_predictItems", "1", CVAR_ARCHIVE },
        { &cg_deferPlayers, "cg_deferPlayers", "1", CVAR_ARCHIVE },
        { &cg_drawTeamOverlay, "cg_drawTeamOverlay", "0", CVAR_ARCHIVE },
        { &cg_teamOverlayUserinfo, "teamoverlay", "0", CVAR_ROM | CVAR_USERINFO },
        { &cg_stats, "cg_stats", "0", 0 },
        { &cg_drawFriend, "cg_drawFriend", "1", CVAR_ARCHIVE },
        { &cg_teamChatsOnly, "cg_teamChatsOnly", "0", CVAR_ARCHIVE },
        // the following variables are created in other parts of the system,
        // but we also reference them here
        { &cg_buildScript, "com_buildScript", "0", 0 }, // force loading of all possible data amd error on failures
        { &cg_paused, "cl_paused", "0", CVAR_ROM },
        { &cg_blood, "com_blood", "1", CVAR_ARCHIVE },
        { &cg_synchronousClients, "g_synchronousClients", "0", 0 },     // communicated by systeminfo

//      { &cg_redTeamName, "g_redteam", DEFAULT_REDTEAM_NAME, CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO },
//      { &cg_blueTeamName, "g_blueteam", DEFAULT_BLUETEAM_NAME, CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO },
        { &cg_currentSelectedPlayer, "cg_currentSelectedPlayer", "0", CVAR_ARCHIVE},
        { &cg_currentSelectedPlayerName, "cg_currentSelectedPlayerName", "", CVAR_ARCHIVE},
//      { &cg_singlePlayerActive, "ui_singlePlayerActive", "0", CVAR_USERINFO},
        { &cg_recordSPDemo, "ui_recordSPDemo", "0", CVAR_ARCHIVE},
        { &cg_recordSPDemoName, "ui_recordSPDemoName", "", CVAR_ARCHIVE},

        { &cg_cameraOrbit, "cg_cameraOrbit", "0", CVAR_CHEAT},
        { &cg_cameraOrbitDelay, "cg_cameraOrbitDelay", "50", CVAR_ARCHIVE},
        { &cg_timescaleFadeEnd, "cg_timescaleFadeEnd", "1", 0},
        { &cg_timescaleFadeSpeed, "cg_timescaleFadeSpeed", "0", 0},
        { &cg_timescale, "timescale", "1", 0},
        { &cg_scorePlum, "cg_scorePlums", "1",  CVAR_ARCHIVE},
        { &cg_hudFiles, "cg_hudFiles", "ui/jahud.txt", CVAR_ARCHIVE},
        { &cg_smoothClients, "cg_smoothClients", "1",  CVAR_ARCHIVE},
        { &cg_cameraMode, "com_cameraMode", "0", CVAR_CHEAT},

        { &pmove_fixed, "pmove_fixed", "0", 0},
        { &pmove_msec, "pmove_msec", "8", 0},
        { &cg_noTaunt, "cg_noTaunt", "0", CVAR_ARCHIVE},
        { &cg_noProjectileTrail, "cg_noProjectileTrail", "0", CVAR_ARCHIVE},
//      { &cg_trueLightning, "cg_trueLightning", "0.0", CVAR_ARCHIVE},
        { &cg_showVehBounds, "cg_showVehBounds", "0", 0},

        { &ui_myteam, "ui_myteam", "0", CVAR_ROM|CVAR_INTERNAL},
        { &cg_snapshotTimeout, "cg_snapshotTimeout", "10", CVAR_ARCHIVE },

//      { &cg_pmove_fixed, "cg_pmove_fixed", "0", CVAR_USERINFO | CVAR_ARCHIVE }
/*
Ghoul2 Insert Start
*/
        { &cg_debugBB, "debugBB", "0", 0},
/*
Ghoul2 Insert End
*/
};

static int  cvarTableSize = sizeof( cvarTable ) / sizeof( cvarTable[0] );

/*
=================
CG_RegisterCvars
=================
*/
void CG_RegisterCvars( void ) {
        int                     i;
        cvarTable_t     *cv;
        char            var[MAX_TOKEN_CHARS];

        for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
                trap_Cvar_Register( cv->vmCvar, cv->cvarName,
                        cv->defaultString, cv->cvarFlags );
        }

        // see if we are also running the server on this machine
        trap_Cvar_VariableStringBuffer( "sv_running", var, sizeof( var ) );
        cgs.localServer = atoi( var );

        forceModelModificationCount = cg_forceModel.modificationCount;

        trap_Cvar_Register(NULL, "model", DEFAULT_MODEL, CVAR_USERINFO | CVAR_ARCHIVE );
        trap_Cvar_Register(NULL, "forcepowers", DEFAULT_FORCEPOWERS, CVAR_USERINFO | CVAR_ARCHIVE );

        // Cvars uses for transferring data between client and server
        trap_Cvar_Register(NULL, "ui_about_gametype",           "0", CVAR_ROM|CVAR_INTERNAL );