codemp/cgame/cg_local.h

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
#include "../game/q_shared.h"
#include "tr_types.h"
#include "../game/bg_public.h"
#include "cg_public.h"

// The entire cgame module is unloaded and reloaded on each level change,
// so there is NO persistant data between levels on the client side.
// If you absolutely need something stored, it can either be kept
// by the server in the server stored userinfos, or stashed in a cvar.

#ifndef __LCC__
#define CGAME_INLINE ID_INLINE
#else
#define CGAME_INLINE //none
#endif

#define NULL_HANDLE                     ((qhandle_t) 0)
#define NULL_SOUND                      ((sfxHandle_t) 0)
#define NULL_FX                         ((fxHandle_t) 0)

#define POWERUP_BLINKS          5

#define POWERUP_BLINK_TIME      1000
#define FADE_TIME                       200
#define PULSE_TIME                      200
#define DAMAGE_DEFLECT_TIME     100
#define DAMAGE_RETURN_TIME      400
#define DAMAGE_TIME                     500
#define LAND_DEFLECT_TIME       150
#define LAND_RETURN_TIME        300
#define STEP_TIME                       200
#define DUCK_TIME                       100
#define PAIN_TWITCH_TIME        200
#define WEAPON_SELECT_TIME      1400
#define ITEM_SCALEUP_TIME       1000

// Zoom vars
#define ZOOM_TIME                       150             // not currently used?
#define MAX_ZOOM_FOV            3.0f
#define ZOOM_IN_TIME            1500.0f 
#define ZOOM_OUT_TIME           100.0f
#define ZOOM_START_PERCENT      0.3f    

#define ITEM_BLOB_TIME          200
#define MUZZLE_FLASH_TIME       20
#define SINK_TIME                       1000            // time for fragments to sink into ground before going away
#define ATTACKER_HEAD_TIME      10000
#define REWARD_TIME                     3000

#define PULSE_SCALE                     1.5                     // amount to scale up the icons when activating

#define MAX_STEP_CHANGE         32

#define MAX_VERTS_ON_POLY       10
#define MAX_MARK_POLYS          256

#define STAT_MINUS                      10      // num frame for '-' stats digit

#define ICON_SIZE                       48
#define CHAR_WIDTH                      32
#define CHAR_HEIGHT                     48
#define TEXT_ICON_SPACE         4

// very large characters
#define GIANT_WIDTH                     32
#define GIANT_HEIGHT            48

#define NUM_FONT_BIG    1
#define NUM_FONT_SMALL  2
#define NUM_FONT_CHUNKY 3

#define NUM_CROSSHAIRS          9

#define TEAM_OVERLAY_MAXNAME_WIDTH      32
#define TEAM_OVERLAY_MAXLOCATION_WIDTH  64

#define WAVE_AMPLITUDE  1
#define WAVE_FREQUENCY  0.4

#define DEFAULT_MODEL                   "kyle"

#define DEFAULT_FORCEPOWERS             "5-1-000000000000000000"
//"rank-side-heal.lev.speed.push.pull.tele.grip.lightning.rage.protect.absorb.teamheal.teamforce.drain.see"

#define DEFAULT_REDTEAM_NAME            "Empire"
#define DEFAULT_BLUETEAM_NAME           "Rebellion"

typedef enum {
        FOOTSTEP_STONEWALK,
        FOOTSTEP_STONERUN,
        FOOTSTEP_METALWALK,
        FOOTSTEP_METALRUN,
        FOOTSTEP_PIPEWALK,
        FOOTSTEP_PIPERUN,
        FOOTSTEP_SPLASH,
        FOOTSTEP_WADE,
        FOOTSTEP_SWIM,
        FOOTSTEP_SNOWWALK,
        FOOTSTEP_SNOWRUN,
        FOOTSTEP_SANDWALK,
        FOOTSTEP_SANDRUN,
        FOOTSTEP_GRASSWALK,
        FOOTSTEP_GRASSRUN,
        FOOTSTEP_DIRTWALK,
        FOOTSTEP_DIRTRUN,
        FOOTSTEP_MUDWALK,
        FOOTSTEP_MUDRUN,
        FOOTSTEP_GRAVELWALK,
        FOOTSTEP_GRAVELRUN,
        FOOTSTEP_RUGWALK,
        FOOTSTEP_RUGRUN,
        FOOTSTEP_WOODWALK,
        FOOTSTEP_WOODRUN,

        FOOTSTEP_TOTAL
} footstep_t;

typedef enum {
        IMPACTSOUND_DEFAULT,
        IMPACTSOUND_METAL,
        IMPACTSOUND_FLESH
} impactSound_t;

//=================================================

// player entities need to track more information
// than any other type of entity.

// note that not every player entity is a client entity,
// because corpses after respawn are outside the normal
// client numbering range

// when changing animation, set animationTime to frameTime + lerping time
// The current lerp will finish out, then it will lerp to the new animation
typedef struct {
        int                     oldFrame;
        int                     oldFrameTime;           // time when ->oldFrame was exactly on

        int                     frame;
        int                     frameTime;                      // time when ->frame will be exactly on

        float           backlerp;

        qboolean        lastFlip; //if does not match torsoFlip/legsFlip, restart the anim.

        int                     lastForcedFrame;

        float           yawAngle;
        qboolean        yawing;
        float           pitchAngle;
        qboolean        pitching;

        float           yawSwingDif;

        int                     animationNumber;
        animation_t     *animation;
        int                     animationTime;          // time when the first frame of the animation will be exact

        float           animationSpeed;         // scale the animation speed
        float           animationTorsoSpeed;

        qboolean        torsoYawing;
} lerpFrame_t;


typedef struct {
        lerpFrame_t             legs, torso, flag;
        int                             painTime;
        int                             painDirection;  // flip from 0 to 1
        int                             lightningFiring;

        // machinegun spinning
        float                   barrelAngle;
        int                             barrelTime;
        qboolean                barrelSpinning;
} playerEntity_t;

//=================================================

// each client has an associated clientInfo_t
// that contains media references necessary to present the
// client model and other color coded effects
// this is regenerated each time a client's configstring changes,
// usually as a result of a userinfo (name, model, etc) change
#define MAX_CUSTOM_COMBAT_SOUNDS        40
#define MAX_CUSTOM_EXTRA_SOUNDS 40
#define MAX_CUSTOM_JEDI_SOUNDS  40
//#define MAX_CUSTOM_SIEGE_SOUNDS..defined in bg_public.h
#define MAX_CUSTOM_DUEL_SOUNDS  40

#define MAX_CUSTOM_SOUNDS       40 //rww - Note that for now these must all be the same, because of the way I am
                                                           //cycling through them and comparing for custom sounds.

typedef struct {
        qboolean                infoValid;

        float                   colorOverride[3];

        saberInfo_t             saber[MAX_SABERS];
        void                    *ghoul2Weapons[MAX_SABERS];

        char                    saberName[64];
        char                    saber2Name[64];

        char                    name[MAX_QPATH];
        team_t                  team;

        int                             duelTeam;

        int                             botSkill;               // 0 = not bot, 1-5 = bot

        int                             frame;

        vec3_t                  color1;
        vec3_t                  color2;

        int                             icolor1;
        int                             icolor2;

        int                             score;                  // updated by score servercmds
        int                             location;               // location index for team mode
        int                             health;                 // you only get this info about your teammates
        int                             armor;
        int                             curWeapon;

        int                             handicap;
        int                             wins, losses;   // in tourney mode

        int                             teamTask;               // task in teamplay (offence/defence)
        qboolean                teamLeader;             // true when this is a team leader

        int                             powerups;               // so can display quad/flag status

        int                             medkitUsageTime;

        int                             breathPuffTime;

        // when clientinfo is changed, the loading of models/skins/sounds
        // can be deferred until you are dead, to prevent hitches in
        // gameplay
        char                    modelName[MAX_QPATH];
        char                    skinName[MAX_QPATH];
//      char                    headModelName[MAX_QPATH];
//      char                    headSkinName[MAX_QPATH];
        char                    forcePowers[MAX_QPATH];
//      char                    redTeam[MAX_TEAMNAME];
//      char                    blueTeam[MAX_TEAMNAME];

        char                    teamName[MAX_TEAMNAME];

        int                             corrTime;

        vec3_t                  lastHeadAngles;
        int                             lookTime;

        int                             brokenLimbs;

        qboolean                deferred;

        qboolean                newAnims;               // true if using the new mission pack animations
        qboolean                fixedlegs;              // true if legs yaw is always the same as torso yaw
        qboolean                fixedtorso;             // true if torso never changes yaw

        vec3_t                  headOffset;             // move head in icon views
        //footstep_t            footsteps;
        gender_t                gender;                 // from model

        qhandle_t               legsModel;
        qhandle_t               legsSkin;

        qhandle_t               torsoModel;
        qhandle_t               torsoSkin;

        //qhandle_t             headModel;
        //qhandle_t             headSkin;

        void                    *ghoul2Model;
        
        qhandle_t               modelIcon;

        qhandle_t               bolt_rhand;
        qhandle_t               bolt_lhand;

        qhandle_t               bolt_head;

        qhandle_t               bolt_motion;

        qhandle_t               bolt_llumbar;

        int                             siegeIndex;
        int                             siegeDesiredTeam;

        sfxHandle_t             sounds[MAX_CUSTOM_SOUNDS];
        sfxHandle_t             combatSounds[MAX_CUSTOM_COMBAT_SOUNDS];
        sfxHandle_t             extraSounds[MAX_CUSTOM_EXTRA_SOUNDS];
        sfxHandle_t             jediSounds[MAX_CUSTOM_JEDI_SOUNDS];
        sfxHandle_t             siegeSounds[MAX_CUSTOM_SIEGE_SOUNDS];
        sfxHandle_t             duelSounds[MAX_CUSTOM_DUEL_SOUNDS];

        int                             legsAnim;
        int                             torsoAnim;

        float           facial_blink;           // time before next blink. If a minus value, we are in blink mode
        float           facial_frown;           // time before next frown. If a minus value, we are in frown mode
        float           facial_aux;                     // time before next aux. If a minus value, we are in aux mode

        int                     superSmoothTime; //do crazy amount of smoothing

#ifdef _XBOX
        int                     friendshipStatus;
#endif
        
} clientInfo_t;

//rww - cheap looping sound struct
#ifdef _XBOX
#define MAX_CG_LOOPSOUNDS 2
#else
#define MAX_CG_LOOPSOUNDS 8
#endif

typedef struct cgLoopSound_s {
        int entityNum;
        vec3_t origin;
        vec3_t velocity;
        sfxHandle_t sfx;
} cgLoopSound_t;

// centity_t have a direct corespondence with gentity_t in the game, but
// only the entityState_t is directly communicated to the cgame
typedef struct centity_s {
        // This comment below is correct, but now m_pVehicle is the first thing in bg shared entity, so it goes first. - AReis
        //rww - entstate must be first, to correspond with the bg shared entity structure
        entityState_t   currentState;   // from cg.frame
        playerState_t   *playerState;   //ptr to playerstate if applicable (for bg ents)
        Vehicle_t               *m_pVehicle; //vehicle data
        void                    *ghoul2; //g2 instance
        int                             localAnimIndex; //index locally (game/cgame) to anim data for this skel
        vec3_t                  modelScale; //needed for g2 collision

        //from here up must be unified with bgEntity_t -rww

        entityState_t   nextState;              // from cg.nextFrame, if available
        qboolean                interpolate;    // true if next is valid to interpolate to
        qboolean                currentValid;   // true if cg.frame holds this entity

        int                             muzzleFlashTime;        // move to playerEntity?
        int                             previousEvent;
//      int                             teleportFlag;

        int                             trailTime;              // so missile trails can handle dropped initial packets
        int                             dustTrailTime;
        int                             miscTime;

        vec3_t                  damageAngles;
        int                             damageTime;

        int                             snapShotTime;   // last time this entity was found in a snapshot

        playerEntity_t  pe;

//      int                             errorTime;              // decay the error from this time
//      vec3_t                  errorOrigin;
//      vec3_t                  errorAngles;
        
//      qboolean                extrapolated;   // false if origin / angles is an interpolation
//      vec3_t                  rawOrigin;
        vec3_t                  rawAngles;

        vec3_t                  beamEnd;

        // exact interpolated position of entity on this frame
        vec3_t                  lerpOrigin;
        vec3_t                  lerpAngles;

#if 0
        //add up bone offsets until next client frame before adding them in
        qboolean                hasRagOffset;
        vec3_t                  ragOffsets;
        int                             ragOffsetTime;
#endif

        vec3_t                  ragLastOrigin;
        int                             ragLastOriginTime;

        qboolean                noLumbar; //if true only do anims and things on model_root instead of lower_lumbar, this will be the case for some NPCs.
        qboolean                noFace;

        //For keeping track of the current surface status in relation to the entitystate surface fields.
        int                             npcLocalSurfOn;
        int                             npcLocalSurfOff;

        int                             eventAnimIndex;

        clientInfo_t    *npcClient; //dynamically allocated - always free it, and never stomp over it.

        int                             weapon;

        void                    *ghoul2weapon; //rww - pointer to ghoul2 instance of the current 3rd person weapon

        float                   radius;
        int                             boltInfo;

        //sometimes used as a bolt index, but these values are also used as generic values for clientside entities
        //at times
        int                             bolt1;
        int                             bolt2;
        int                             bolt3;
        int                             bolt4;

        float                   bodyHeight;

        int                             torsoBolt;
        
        vec3_t                  turAngles;

        vec3_t                  frame_minus1;
        vec3_t                  frame_minus2;

        int                             frame_minus1_refreshed;
        int                             frame_minus2_refreshed;

        void                    *frame_hold; //pointer to a ghoul2 instance

        int                             frame_hold_time;
        int                             frame_hold_refreshed;

        void                    *grip_arm; //pointer to a ghoul2 instance

        int                             trickAlpha;
        int                             trickAlphaTime;

        int                             teamPowerEffectTime;
        qboolean                teamPowerType; //0 regen, 1 heal, 2 drain, 3 absorb

        qboolean                isRagging;
        qboolean                ownerRagging;
        int                             overridingBones;

        int                             bodyFadeTime;
        vec3_t                  pushEffectOrigin;

        cgLoopSound_t   loopingSound[MAX_CG_LOOPSOUNDS];
        int                             numLoopingSounds;

        int                             serverSaberHitIndex;
        int                             serverSaberHitTime;
        qboolean                serverSaberFleshImpact; //true if flesh, false if anything else.

        qboolean                ikStatus;

        qboolean                saberWasInFlight;

        float                   smoothYaw;

        int                             uncloaking;
        qboolean                cloaked;

        int                             vChatTime;
} centity_t;


//======================================================================

// local entities are created as a result of events or predicted actions,
// and live independently from all server transmitted entities

typedef struct markPoly_s {
        struct markPoly_s       *prevMark, *nextMark;
        int                     time;
        qhandle_t       markShader;
        qboolean        alphaFade;              // fade alpha instead of rgb
        float           color[4];
        poly_t          poly;
        polyVert_t      verts[MAX_VERTS_ON_POLY];
} markPoly_t;


typedef enum {
        LE_MARK,
        LE_EXPLOSION,
        LE_SPRITE_EXPLOSION,
        LE_FADE_SCALE_MODEL, // currently only for Demp2 shock sphere
        LE_FRAGMENT,
        LE_PUFF,
        LE_MOVE_SCALE_FADE,
        LE_FALL_SCALE_FADE,
        LE_FADE_RGB,
        LE_SCALE_FADE,
        LE_SCOREPLUM,
        LE_OLINE,
        LE_SHOWREFENTITY,
        LE_LINE
} leType_t;

typedef enum {
        LEF_PUFF_DONT_SCALE = 0x0001,                   // do not scale size over time
        LEF_TUMBLE                      = 0x0002,                       // tumble over time, used for ejecting shells
        LEF_FADE_RGB            = 0x0004,                       // explicitly fade
        LEF_NO_RANDOM_ROTATE= 0x0008                    // MakeExplosion adds random rotate which could be bad in some cases
} leFlag_t;

typedef enum {
        LEMT_NONE,
        LEMT_BURN,
        LEMT_BLOOD
} leMarkType_t;                 // fragment local entities can leave marks on walls

typedef enum {
        LEBS_NONE,
        LEBS_BLOOD,
        LEBS_BRASS,
        LEBS_METAL,
        LEBS_ROCK
} leBounceSoundType_t;  // fragment local entities can make sounds on impacts

typedef struct localEntity_s {
        struct localEntity_s    *prev, *next;
        leType_t                leType;
        int                             leFlags;

        int                             startTime;
        int                             endTime;
        int                             fadeInTime;

        float                   lifeRate;                       // 1.0 / (endTime - startTime)

        trajectory_t    pos;
        trajectory_t    angles;

        float                   bounceFactor;           // 0.0 = no bounce, 1.0 = perfect
        int                             bounceSound;            // optional sound index to play upon bounce

        float                   alpha;
        float                   dalpha;

        int                             forceAlpha;

        float                   color[4];

        float                   radius;

        float                   light;
        vec3_t                  lightColor;

        leMarkType_t            leMarkType;             // mark to leave on fragment impact
        leBounceSoundType_t     leBounceSoundType;

        union {
                struct {
                        float radius;
                        float dradius;
                        vec3_t startRGB;
                        vec3_t dRGB;
                } sprite;
                struct {
                        float width;
                        float dwidth;
                        float length;
                        float dlength;
                        vec3_t startRGB;
                        vec3_t dRGB;
                } trail;
                struct {
                        float width;
                        float dwidth;
                        // Below are bezier specific.
                        vec3_t                  control1;                               // initial position of control points
                        vec3_t                  control2;
                        vec3_t                  control1_velocity;              // initial velocity of control points
                        vec3_t                  control2_velocity;
                        vec3_t                  control1_acceleration;  // constant acceleration of control points
                        vec3_t                  control2_acceleration;
                } line;
                struct {
                        float width;
                        float dwidth;
                        float width2;
                        float dwidth2;
                        vec3_t startRGB;
                        vec3_t dRGB;
                } line2;
                struct {
                        float width;
                        float dwidth;
                        float width2;
                        float dwidth2;
                        float height;
                        float dheight;
                } cylinder;
                struct {
                        float width;
                        float dwidth;
                } electricity;
                struct
                {
                        // fight the power! open and close brackets in the same column!
                        float radius;
                        float dradius;
                        qboolean (*thinkFn)(struct localEntity_s *le);
                        vec3_t  dir;    // magnitude is 1, but this is oldpos - newpos right before the
                                                        //particle is sent to the renderer
                        // may want to add something like particle::localEntity_s *le (for the particle's think fn)
                } particle;
                struct
                {
                        qboolean        dontDie;
                        vec3_t          dir;
                        float           variance;
                        int                     delay;
                        int                     nextthink;
                        qboolean        (*thinkFn)(struct localEntity_s *le);
                        int                     data1;
                        int                     data2;
                } spawner;
                struct
                {
                        float radius;
                } fragment;
        } data;

        refEntity_t             refEntity;              
} localEntity_t;

//======================================================================


typedef struct {
        int                             client;
        int                             score;
        int                             ping;
        int                             time;
        int                             scoreFlags;
        int                             powerUps;
        int                             accuracy;
        int                             impressiveCount;
        int                             excellentCount;
        int                             guantletCount;
        int                             defendCount;
        int                             assistCount;
        int                             captures;
        qboolean        perfect;
        int                             team;
} score_t;


// each WP_* weapon enum has an associated weaponInfo_t
// that contains media references necessary to present the
// weapon and its effects
typedef struct weaponInfo_s {
        qboolean                registered;
        gitem_t                 *item;

        qhandle_t               handsModel;                     // the hands don't actually draw, they just position the weapon
        qhandle_t               weaponModel;            // this is the pickup model
        qhandle_t               viewModel;                      // this is the in-view model used by the player
        qhandle_t               barrelModel;
        qhandle_t               flashModel;

        vec3_t                  weaponMidpoint;         // so it will rotate centered instead of by tag

        float                   flashDlight;
        vec3_t                  flashDlightColor;

        qhandle_t               weaponIcon;
        qhandle_t               ammoIcon;

        qhandle_t               ammoModel;

        sfxHandle_t             flashSound[4];          // fast firing weapons randomly choose
        sfxHandle_t             firingSound;
        sfxHandle_t             chargeSound;
        fxHandle_t              muzzleEffect;
        qhandle_t               missileModel;
        sfxHandle_t             missileSound;
        void                    (*missileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
        float                   missileDlight;
        vec3_t                  missileDlightColor;
        int                             missileRenderfx;
        sfxHandle_t             missileHitSound;

        sfxHandle_t             altFlashSound[4];
        sfxHandle_t             altFiringSound;
        sfxHandle_t             altChargeSound;
        fxHandle_t              altMuzzleEffect;
        qhandle_t               altMissileModel;
        sfxHandle_t             altMissileSound;
        void                    (*altMissileTrailFunc)( centity_t *, const struct weaponInfo_s *wi );
        float                   altMissileDlight;
        vec3_t                  altMissileDlightColor;
        int                             altMissileRenderfx;
        sfxHandle_t             altMissileHitSound;

        sfxHandle_t             selectSound;

        sfxHandle_t             readySound;
        float                   trailRadius;
        float                   wiTrailTime;

} weaponInfo_t;


// each IT_* item has an associated itemInfo_t
// that constains media references necessary to present the
// item and its effects
typedef struct {
        qboolean                registered;
        qhandle_t               models[MAX_ITEM_MODELS];
        qhandle_t               icon;
/*
Ghoul2 Insert Start
*/
        void                    *g2Models[MAX_ITEM_MODELS];
        float                   radius[MAX_ITEM_MODELS];
/*
Ghoul2 Insert End
*/
} itemInfo_t;


typedef struct {
        int                             itemNum;
} powerupInfo_t;


#define MAX_SKULLTRAIL          10

typedef struct {
        vec3_t positions[MAX_SKULLTRAIL];
        int numpositions;
} skulltrail_t;


#define MAX_REWARDSTACK         10
#define MAX_SOUNDBUFFER         20

//======================================================================

// all cg.stepTime, cg.duckTime, cg.landTime, etc are set to cg.time when the action
// occurs, and they will have visible effects for #define STEP_TIME or whatever msec after

#define MAX_PREDICTED_EVENTS    16


#define MAX_CHATBOX_ITEMS               5
typedef struct chatBoxItem_s
{
        char    string[MAX_SAY_TEXT];
        int             time;
        int             lines;
} chatBoxItem_t;

typedef struct {
        int                     clientFrame;            // incremented each frame

        int                     clientNum;
        
        qboolean        demoPlayback;
        qboolean        levelShot;                      // taking a level menu screenshot
        int                     deferredPlayerLoading;
        qboolean        loading;                        // don't defer players at initial startup
        qboolean        intermissionStarted;    // don't play voice rewards, because game will end shortly

        // there are only one or two snapshot_t that are relevent at a time
        int                     latestSnapshotNum;      // the number of snapshots the client system has received
        int                     latestSnapshotTime;     // the time from latestSnapshotNum, so we don't need to read the snapshot yet

        snapshot_t      *snap;                          // cg.snap->serverTime <= cg.time
        snapshot_t      *nextSnap;                      // cg.nextSnap->serverTime > cg.time, or NULL
//      snapshot_t      activeSnapshots[2];

        float           frameInterpolation;     // (float)( cg.time - cg.frame->serverTime ) / (cg.nextFrame->serverTime - cg.frame->serverTime)

        qboolean        mMapChange;

        qboolean        thisFrameTeleport;
        qboolean        nextFrameTeleport;

        int                     frametime;              // cg.time - cg.oldTime

        int                     time;                   // this is the time value that the client
                                                                // is rendering at.
        int                     oldTime;                // time at last frame, used for missile trails and prediction checking

        int                     physicsTime;    // either cg.snap->time or cg.nextSnap->time

        int                     timelimitWarnings;      // 5 min, 1 min, overtime
        int                     fraglimitWarnings;

        qboolean        mapRestart;                     // set on a map restart to set back the weapon

        qboolean        mInRMG; //rwwRMG - added
        qboolean        mRMGWeather; //rwwRMG - added

        qboolean        renderingThirdPerson;           // during deaths, chasecams, etc

        // prediction state
        qboolean        hyperspace;                             // true if prediction has hit a trigger_teleport
        playerState_t   predictedPlayerState;
        playerState_t   predictedVehicleState;
        
        //centity_t             predictedPlayerEntity;
        //rww - I removed this and made it use cg_entities[clnum] directly.

        qboolean        validPPS;                               // clear until the first call to CG_PredictPlayerState
        int                     predictedErrorTime;
        vec3_t          predictedError;

        int                     eventSequence;
        int                     predictableEvents[MAX_PREDICTED_EVENTS];

        float           stepChange;                             // for stair up smoothing
        int                     stepTime;

        float           duckChange;                             // for duck viewheight smoothing
        int                     duckTime;

        float           landChange;                             // for landing hard
        int                     landTime;

        // input state sent to server
        int                     weaponSelect;

        int                     forceSelect;
        int                     itemSelect;

        // auto rotating items
        vec3_t          autoAngles;
        vec3_t          autoAxis[3];
        vec3_t          autoAnglesFast;
        vec3_t          autoAxisFast[3];

        // view rendering
        refdef_t        refdef;

#ifdef _XBOX
        qboolean widescreen;
#endif

        // zoom key
        qboolean        zoomed;
        int                     zoomTime;
        float           zoomSensitivity;

        // information screen text during loading
        char            infoScreenText[MAX_STRING_CHARS];

        // scoreboard
        int                     scoresRequestTime;
        int                     numScores;
        int                     selectedScore;
        int                     teamScores[2];
        score_t         scores[MAX_CLIENTS];
        qboolean        showScores;
        qboolean        scoreBoardShowing;
        int                     scoreFadeTime;
        char            killerName[MAX_NAME_LENGTH];
        char                    spectatorList[MAX_STRING_CHARS];                // list of names
        int                             spectatorLen;                                                                                           // length of list
        float                   spectatorWidth;                                                                                 // width in device units
        int                             spectatorTime;                                                                                  // next time to offset
        int                             spectatorPaintX;                                                                                // current paint x
        int                             spectatorPaintX2;                                                                               // current paint x
        int                             spectatorOffset;                                                                                // current offset from start
        int                             spectatorPaintLen;                                                                      // current offset from start

        // skull trails
        skulltrail_t    skulltrails[MAX_CLIENTS];

        // centerprinting
        int                     centerPrintTime;
        int                     centerPrintCharWidth;
        int                     centerPrintY;
        char            centerPrint[1024];
        int                     centerPrintLines;

        // low ammo warning state
        int                     lowAmmoWarning;         // 1 = low, 2 = empty

        // kill timers for carnage reward
        int                     lastKillTime;

        // crosshair client ID
        int                     crosshairClientNum;
        int                     crosshairClientTime;

        int                     crosshairVehNum;
        int                     crosshairVehTime;

        // powerup active flashing
        int                     powerupActive;
        int                     powerupTime;

        // attacking player
        int                     attackerTime;
        int                     voiceTime;

        // reward medals
        int                     rewardStack;
        int                     rewardTime;
        int                     rewardCount[MAX_REWARDSTACK];
        qhandle_t       rewardShader[MAX_REWARDSTACK];
        qhandle_t       rewardSound[MAX_REWARDSTACK];

        // sound buffer mainly for announcer sounds
        int                     soundBufferIn;
        int                     soundBufferOut;
        int                     soundTime;
        qhandle_t       soundBuffer[MAX_SOUNDBUFFER];

        // for voice chat buffer
        int                     voiceChatTime;
        int                     voiceChatBufferIn;
        int                     voiceChatBufferOut;

        // warmup countdown
        int                     warmup;
        int                     warmupCount;

        //==========================

        int                     itemPickup;
        int                     itemPickupTime;
        int                     itemPickupBlendTime;    // the pulse around the crosshair is timed seperately

        int                     weaponSelectTime;
        int                     weaponAnimation;
        int                     weaponAnimationTime;

        // blend blobs
        float           damageTime;
        float           damageX, damageY, damageValue;

        // status bar head
        float           headYaw;
        float           headEndPitch;
        float           headEndYaw;
        int                     headEndTime;
        float           headStartPitch;
        float           headStartYaw;
        int                     headStartTime;

        // view movement
        float           v_dmg_time;
        float           v_dmg_pitch;
        float           v_dmg_roll;

        vec3_t          kick_angles;    // weapon kicks
        int                     kick_time;
        vec3_t          kick_origin;

        // temp working variables for player view
        float           bobfracsin;
        int                     bobcycle;
        float           xyspeed;
        int     nextOrbitTime;

        //qboolean cameraMode;          // if rendering from a loaded camera
        int                     loadLCARSStage;

        int                     forceHUDTotalFlashTime;
        int                     forceHUDNextFlashTime;
        qboolean        forceHUDActive;                         // Flag to show force hud is off/on

        // development tool
        refEntity_t             testModelEntity;
        char                    testModelName[MAX_QPATH];
        qboolean                testGun;

        int                     VHUDFlashTime;
        qboolean        VHUDTurboFlag;

        // HUD stuff
        float                   HUDTickFlashTime;
        qboolean                HUDArmorFlag;
        qboolean                HUDHealthFlag;
        qboolean                iconHUDActive;
        float                   iconHUDPercent;
        float                   iconSelectTime;
        float                   invenSelectTime;
        float                   forceSelectTime;

        vec3_t                  lastFPFlashPoint;

/*
Ghoul2 Insert Start
*/
        int                             testModel;
        // had to be moved so we wouldn't wipe these out with the memset - these have STL in them and shouldn't be cleared that way
        snapshot_t      activeSnapshots[2];
/*
Ghoul2 Insert End
*/

        char                            sharedBuffer[MAX_CG_SHARED_BUFFER_SIZE];

        short                           radarEntityCount;
        short                           radarEntities[MAX_CLIENTS+16];

        short                           bracketedEntityCount;
        short                           bracketedEntities[MAX_CLIENTS+16];

        float                           distanceCull;

        chatBoxItem_t           chatItems[MAX_CHATBOX_ITEMS];
        int                                     chatItemActive;
        
#if 0
        int                                     snapshotTimeoutTime;
#endif
        
} cg_t;

#define MAX_TICS        14

typedef struct forceTicPos_s
{
        int                             x;
        int                             y;
        int                             width;
        int                             height;
        char                    *file;
        qhandle_t               tic;
} forceTicPos_t;
extern forceTicPos_t forceTicPos[];
extern forceTicPos_t ammoTicPos[];

typedef struct cgscreffects_s
{
        float           FOV;
        float