codemp/game/g_local.h

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_local.h -- local definitions for game module

#include "q_shared.h"
#include "bg_public.h"
#include "bg_vehicles.h"
#include "g_public.h"

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

typedef struct gentity_s gentity_t;
typedef struct gclient_s gclient_t;

//npc stuff
#include "b_public.h"

extern int gPainMOD;
extern int gPainHitLoc;
extern vec3_t gPainPoint;

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

// the "gameversion" client command will print this plus compile date
#define GAMEVERSION     "basejka_mod"

#define BODY_QUEUE_SIZE         8

#ifndef INFINITE
#define INFINITE                        1000000
#endif

#define FRAMETIME                       100                                     // msec
#define CARNAGE_REWARD_TIME     3000
#define REWARD_SPRITE_TIME      2000

#define INTERMISSION_DELAY_TIME 1000
#define SP_INTERMISSION_DELAY_TIME      5000

//primarily used by NPCs
#define START_TIME_LINK_ENTS            FRAMETIME*1 // time-delay after map start at which all ents have been spawned, so can link them
#define START_TIME_FIND_LINKS           FRAMETIME*2 // time-delay after map start at which you can find linked entities
#define START_TIME_MOVERS_SPAWNED       FRAMETIME*2 // time-delay after map start at which all movers should be spawned
#define START_TIME_REMOVE_ENTS          FRAMETIME*3 // time-delay after map start to remove temporary ents
#define START_TIME_NAV_CALC                     FRAMETIME*4 // time-delay after map start to connect waypoints and calc routes
#define START_TIME_FIND_WAYPOINT        FRAMETIME*5 // time-delay after map start after which it's okay to try to find your best waypoint

// gentity->flags
#define FL_GODMODE                              0x00000010
#define FL_NOTARGET                             0x00000020
#define FL_TEAMSLAVE                    0x00000400      // not the first on the team
#define FL_NO_KNOCKBACK                 0x00000800
#define FL_DROPPED_ITEM                 0x00001000
#define FL_NO_BOTS                              0x00002000      // spawn point not for bot use
#define FL_NO_HUMANS                    0x00004000      // spawn point just for bots
#define FL_FORCE_GESTURE                0x00008000      // force gesture on client
#define FL_INACTIVE                             0x00010000      // inactive
#define FL_NAVGOAL                              0x00020000      // for npc nav stuff
#define FL_DONT_SHOOT                   0x00040000
#define FL_SHIELDED                             0x00080000
#define FL_UNDYING                              0x00100000      // takes damage down to 1, but never dies

//ex-eFlags -rww
#define FL_BOUNCE                               0x00100000              // for missiles
#define FL_BOUNCE_HALF                  0x00200000              // for missiles
#define FL_BOUNCE_SHRAPNEL              0x00400000              // special shrapnel flag

//vehicle game-local stuff -rww
#define FL_VEH_BOARDING                 0x00800000              // special shrapnel flag

//breakable flags -rww
#define FL_DMG_BY_SABER_ONLY            0x01000000 //only take dmg from saber
#define FL_DMG_BY_HEAVY_WEAP_ONLY       0x02000000 //only take dmg from explosives

#define FL_BBRUSH                                       0x04000000 //I am a breakable brush

#ifndef FINAL_BUILD
#define DEBUG_SABER_BOX
#endif

#define MAX_G_SHARED_BUFFER_SIZE                8192
extern char gSharedBuffer[MAX_G_SHARED_BUFFER_SIZE];

// movers are things like doors, plats, buttons, etc
typedef enum {
        MOVER_POS1,
        MOVER_POS2,
        MOVER_1TO2,
        MOVER_2TO1
} moverState_t;

#define SP_PODIUM_MODEL         "models/mapobjects/podium/podium4.md3"

typedef enum 
{
        HL_NONE = 0,
        HL_FOOT_RT,
        HL_FOOT_LT,
        HL_LEG_RT,
        HL_LEG_LT,
        HL_WAIST,
        HL_BACK_RT,
        HL_BACK_LT,
        HL_BACK,
        HL_CHEST_RT,
        HL_CHEST_LT,
        HL_CHEST,
        HL_ARM_RT,
        HL_ARM_LT,
        HL_HAND_RT,
        HL_HAND_LT,
        HL_HEAD,
        HL_GENERIC1,
        HL_GENERIC2,
        HL_GENERIC3,
        HL_GENERIC4,
        HL_GENERIC5,
        HL_GENERIC6,
        HL_MAX
};

//============================================================================
extern void *precachedKyle;
extern void *g2SaberInstance;

extern qboolean gEscaping;
extern int gEscapeTime;

struct gentity_s {
        //rww - entstate must be first, to correspond with the bg shared entity structure
        entityState_t   s;                              // communicated by server to clients
        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 the same as centity_t/bgEntity_t

        entityShared_t  r;                              // shared by both the server system and game

        //rww - these are shared icarus things. They must be in this order as well in relation to the entityshared structure.
        int                             taskID[NUM_TIDS];
        parms_t                 *parms;
        char                    *behaviorSet[NUM_BSETS];
        char                    *script_targetname;
        int                             delayScriptTime;
        char                    *fullName;

        //rww - targetname and classname are now shared as well. ICARUS needs access to them.
        char                    *targetname;
        char                    *classname;                     // set in QuakeEd

        //rww - and yet more things to share. This is because the nav code is in the exe because it's all C++.
        int                             waypoint;                       //Set once per frame, if you've moved, and if someone asks
        int                             lastWaypoint;           //To make sure you don't double-back
        int                             lastValidWaypoint;      //ALWAYS valid -used for tracking someone you lost
        int                             noWaypointTime;         //Debouncer - so don't keep checking every waypoint in existance every frame that you can't find one
        int                             combatPoint;
        int                             failedWaypoints[MAX_FAILED_NODES];
        int                             failedWaypointCheckTime;

        int                             next_roff_time; //rww - npc's need to know when they're getting roff'd

        // DO NOT MODIFY ANYTHING ABOVE THIS, THE SERVER
        // EXPECTS THE FIELDS IN THAT ORDER!
        //================================

        struct gclient_s        *client;                        // NULL if not a client

        gNPC_t          *NPC;//Only allocated if the entity becomes an NPC
        int                     cantHitEnemyCounter;//HACK - Makes them look for another enemy on the same team if the one they're after can't be hit

        qboolean        noLumbar; //see note in cg_local.h

        qboolean        inuse;

        int                     lockCount; //used by NPCs

        int                     spawnflags;                     // set in QuakeEd

        int                     teamnodmg;                      // damage will be ignored if it comes from this team

        char            *roffname;                      // set in QuakeEd
        char            *rofftarget;            // set in QuakeEd

        char            *healingclass; //set in quakeed
        char            *healingsound; //set in quakeed
        int                     healingrate; //set in quakeed
        int                     healingDebounce; //debounce for generic object healing shiz

        char            *ownername;

        int                     objective;
        int                     side;

        int                     passThroughNum;         // set to index to pass through (+1) for missiles

        int                     aimDebounceTime;
        int                     painDebounceTime;
        int                     attackDebounceTime;
        int                     alliedTeam;                     // only useable by this team, never target this team

        int                     roffid;                         // if roffname != NULL then set on spawn

        qboolean        neverFree;                      // if true, FreeEntity will only unlink
                                                                        // bodyque uses this

        int                     flags;                          // FL_* variables

        char            *model;
        char            *model2;
        int                     freetime;                       // level.time when the object was freed
        
        int                     eventTime;                      // events will be cleared EVENT_VALID_MSEC after set
        qboolean        freeAfterEvent;
        qboolean        unlinkAfterEvent;

        qboolean        physicsObject;          // if true, it can be pushed by movers and fall off edges
                                                                        // all game items are physicsObjects, 
        float           physicsBounce;          // 1.0 = continuous bounce, 0.0 = no bounce
        int                     clipmask;                       // brushes with this content value will be collided against
                                                                        // when moving.  items and corpses do not collide against
                                                                        // players, for instance

//Only used by NPC_spawners
        char            *NPC_type;
        char            *NPC_targetname;
        char            *NPC_target;

        // movers
        moverState_t moverState;
        int                     soundPos1;
        int                     sound1to2;
        int                     sound2to1;
        int                     soundPos2;
        int                     soundLoop;
        gentity_t       *parent;
        gentity_t       *nextTrain;
        gentity_t       *prevTrain;
        vec3_t          pos1, pos2;

        //for npc's
        vec3_t          pos3;

        char            *message;

        int                     timestamp;              // body queue sinking, etc

        float           angle;                  // set in editor, -1 = up, -2 = down
        char            *target;
        char            *target2;
        char            *target3;               //For multiple targets, not used for firing/triggering/using, though, only for path branches
        char            *target4;               //For multiple targets, not used for firing/triggering/using, though, only for path branches
        char            *target5;               //mainly added for siege items
        char            *target6;               //mainly added for siege items

        char            *team;
        char            *targetShaderName;
        char            *targetShaderNewName;
        gentity_t       *target_ent;

        char            *closetarget;
        char            *opentarget;
        char            *paintarget;

        char            *goaltarget;
        char            *idealclass;

        float           radius;

        int                     maxHealth; //used as a base for crosshair health display

        float           speed;
        vec3_t          movedir;
        float           mass;
        int                     setTime;

//Think Functions
        int                     nextthink;
        void            (*think)(gentity_t *self);
        void            (*reached)(gentity_t *self);    // movers call this when hitting endpoint
        void            (*blocked)(gentity_t *self, gentity_t *other);
        void            (*touch)(gentity_t *self, gentity_t *other, trace_t *trace);
        void            (*use)(gentity_t *self, gentity_t *other, gentity_t *activator);
        void            (*pain)(gentity_t *self, gentity_t *attacker, int damage);
        void            (*die)(gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);

        int                     pain_debounce_time;
        int                     fly_sound_debounce_time;        // wind tunnel
        int                     last_move_time;

//Health and damage fields
        int                     health;
        qboolean        takedamage;
        material_t      material;

        int                     damage;
        int                     dflags;
        int                     splashDamage;   // quad will increase this without increasing radius
        int                     splashRadius;
        int                     methodOfDeath;
        int                     splashMethodOfDeath;

        int                     locationDamage[HL_MAX];         // Damage accumulated on different body locations

        int                     count;
        int                     bounceCount;
        qboolean        alt_fire;

        gentity_t       *chain;
        gentity_t       *enemy;
        gentity_t       *lastEnemy;
        gentity_t       *activator;
        gentity_t       *teamchain;             // next entity in team
        gentity_t       *teammaster;    // master of the team

        int                     watertype;
        int                     waterlevel;

        int                     noise_index;

        // timing variables
        float           wait;
        float           random;
        int                     delay;

        //generic values used by various entities for different purposes.
        int                     genericValue1;
        int                     genericValue2;
        int                     genericValue3;
        int                     genericValue4;
        int                     genericValue5;
        int                     genericValue6;
        int                     genericValue7;
        int                     genericValue8;
        int                     genericValue9;
        int                     genericValue10;
        int                     genericValue11;
        int                     genericValue12;
        int                     genericValue13;
        int                     genericValue14;
        int                     genericValue15;

        char            *soundSet;

        qboolean        isSaberEntity;

        int                     damageRedirect; //if entity takes damage, redirect to..
        int                     damageRedirectTo; //this entity number

        vec3_t          epVelocity;
        float           epGravFactor;

        gitem_t         *item;                  // for bonus items
};

#define DAMAGEREDIRECT_HEAD             1
#define DAMAGEREDIRECT_RLEG             2
#define DAMAGEREDIRECT_LLEG             3

typedef enum {
        CON_DISCONNECTED,
        CON_CONNECTING,
        CON_CONNECTED
};
typedef int clientConnected_t;

typedef enum {
        SPECTATOR_NOT,
        SPECTATOR_FREE,
        SPECTATOR_FOLLOW,
        SPECTATOR_SCOREBOARD
} spectatorState_t;

typedef enum {
        TEAM_BEGIN,             // Beginning a team game, spawn at base
        TEAM_ACTIVE             // Now actively playing
} playerTeamStateState_t;

typedef struct {
        playerTeamStateState_t  state;

        int                     location;

        int                     captures;
        int                     basedefense;
        int                     carrierdefense;
        int                     flagrecovery;
        int                     fragcarrier;
        int                     assists;

        float           lasthurtcarrier;
        float           lastreturnedflag;
        float           flagsince;
        float           lastfraggedcarrier;
} playerTeamState_t;

// the auto following clients don't follow a specific client
// number, but instead follow the first two active players
#define FOLLOW_ACTIVE1  -1
#define FOLLOW_ACTIVE2  -2

// client data that stays across multiple levels or tournament restarts
// this is achieved by writing all the data to cvar strings at game shutdown
// time and reading them back at connection time.  Anything added here
// MUST be dealt with in G_InitSessionData() / G_ReadSessionData() / G_WriteSessionData()
typedef struct {
        team_t          sessionTeam;
        int                     spectatorTime;          // for determining next-in-line to play
        spectatorState_t        spectatorState;
        int                     spectatorClient;        // for chasecam and follow mode
        int                     wins, losses;           // tournament stats
        int                     selectedFP;                     // check against this, if doesn't match value in playerstate then update userinfo
        int                     saberLevel;                     // similar to above method, but for current saber attack level
        qboolean        setForce;                       // set to true once player is given the chance to set force powers
        int                     updateUITime;           // only update userinfo for FP/SL if < level.time
        qboolean        teamLeader;                     // true when this client is a team leader
        char            siegeClass[64];
        char            saberType[64];
        char            saber2Type[64];
        int                     duelTeam;
        int                     siegeDesiredTeam;
} clientSession_t;

// playerstate mGameFlags
#define PSG_VOTED                               (1<<0)          // already cast a vote
#define PSG_TEAMVOTED                   (1<<1)          // already cast a team vote

//
#define MAX_NETNAME                     36
#define MAX_VOTE_COUNT          3

// client data that stays across multiple respawns, but is cleared
// on each level change or team change at ClientBegin()
typedef struct {
        clientConnected_t       connected;      
        usercmd_t       cmd;                            // we would lose angles if not persistant
        qboolean        localClient;            // true if "ip" info key is "localhost"
        qboolean        initialSpawn;           // the first spawn should be at a cool location
        qboolean        predictItemPickup;      // based on cg_predictItems userinfo
        qboolean        pmoveFixed;                     //
        char            netname[MAX_NETNAME];
        int                     netnameTime;                            // Last time the name was changed
        int                     maxHealth;                      // for handicapping
        int                     enterTime;                      // level.time the client entered the game
        playerTeamState_t teamState;    // status in teamplay games
        int                     voteCount;                      // to prevent people from constantly calling votes
        int                     teamVoteCount;          // to prevent people from constantly calling votes
        qboolean        teamInfo;                       // send team overlay updates?
} clientPersistant_t;

typedef struct renderInfo_s
{
        //In whole degrees, How far to let the different model parts yaw and pitch
        int             headYawRangeLeft;
        int             headYawRangeRight;
        int             headPitchRangeUp;
        int             headPitchRangeDown;

        int             torsoYawRangeLeft;
        int             torsoYawRangeRight;
        int             torsoPitchRangeUp;
        int             torsoPitchRangeDown;

        int             legsFrame;
        int             torsoFrame;

        float   legsFpsMod;
        float   torsoFpsMod;

        //Fields to apply to entire model set, individual model's equivalents will modify this value
        vec3_t  customRGB;//Red Green Blue, 0 = don't apply
        int             customAlpha;//Alpha to apply, 0 = none?

        //RF?
        int                     renderFlags;

        //
        vec3_t          muzzlePoint;
        vec3_t          muzzleDir;
        vec3_t          muzzlePointOld;
        vec3_t          muzzleDirOld;
        //vec3_t                muzzlePointNext;        // Muzzle point one server frame in the future!
        //vec3_t                muzzleDirNext;
        int                     mPCalcTime;//Last time muzzle point was calced

        //
        float           lockYaw;//

        //
        vec3_t          headPoint;//Where your tag_head is
        vec3_t          headAngles;//where the tag_head in the torso is pointing
        vec3_t          handRPoint;//where your right hand is
        vec3_t          handLPoint;//where your left hand is
        vec3_t          crotchPoint;//Where your crotch is
        vec3_t          footRPoint;//where your right hand is
        vec3_t          footLPoint;//where your left hand is
        vec3_t          torsoPoint;//Where your chest is
        vec3_t          torsoAngles;//Where the chest is pointing
        vec3_t          eyePoint;//Where your eyes are
        vec3_t          eyeAngles;//Where your eyes face
        int                     lookTarget;//Which ent to look at with lookAngles
        lookMode_t      lookMode;
        int                     lookTargetClearTime;//Time to clear the lookTarget
        int                     lastVoiceVolume;//Last frame's voice volume
        vec3_t          lastHeadAngles;//Last headAngles, NOT actual facing of head model
        vec3_t          headBobAngles;//headAngle offsets
        vec3_t          targetHeadBobAngles;//head bob angles will try to get to targetHeadBobAngles
        int                     lookingDebounceTime;//When we can stop using head looking angle behavior
        float           legsYaw;//yaw angle your legs are actually rendering at

        //for tracking legitimate bolt indecies
        void            *lastG2; //if it doesn't match ent->ghoul2, the bolts are considered invalid.
        int                     headBolt;
        int                     handRBolt;
        int                     handLBolt;
        int                     torsoBolt;
        int                     crotchBolt;
        int                     footRBolt;
        int                     footLBolt;
        int                     motionBolt;

        int                     boltValidityTime;
} renderInfo_t;

// this structure is cleared on each ClientSpawn(),
// except for 'client->pers' and 'client->sess'
struct gclient_s {
        // ps MUST be the first element, because the server expects it
        playerState_t   ps;                             // communicated by server to clients

        // the rest of the structure is private to game
        clientPersistant_t      pers;
        clientSession_t         sess;

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

        int                     tossableItemDebounce;

        int                     bodyGrabTime;
        int                     bodyGrabIndex;

        int                     pushEffectTime;

        int                     invulnerableTimer;

        int                     saberCycleQueue;

        int                     legsAnimExecute;
        int                     torsoAnimExecute;
        qboolean        legsLastFlip;
        qboolean        torsoLastFlip;

        qboolean        readyToExit;            // wishes to leave the intermission

        qboolean        noclip;

        int                     lastCmdTime;            // level.time of last usercmd_t, for EF_CONNECTION
                                                                        // we can't just use pers.lastCommand.time, because
                                                                        // of the g_sycronousclients case
        int                     buttons;
        int                     oldbuttons;
        int                     latched_buttons;

        vec3_t          oldOrigin;

        // sum up damage over an entire frame, so
        // shotgun blasts give a single big kick
        int                     damage_armor;           // damage absorbed by armor
        int                     damage_blood;           // damage taken out of health
        int                     damage_knockback;       // impact damage
        vec3_t          damage_from;            // origin for vector calculation
        qboolean        damage_fromWorld;       // if true, don't use the damage_from vector

        int                     damageBoxHandle_Head; //entity number of head damage box
        int                     damageBoxHandle_RLeg; //entity number of right leg damage box
        int                     damageBoxHandle_LLeg; //entity number of left leg damage box

        int                     accurateCount;          // for "impressive" reward sound

        int                     accuracy_shots;         // total number of shots
        int                     accuracy_hits;          // total number of hits

        //
        int                     lastkilled_client;      // last client that this client killed
        int                     lasthurt_client;        // last client that damaged this client
        int                     lasthurt_mod;           // type of damage the client did

        // timers
        int                     respawnTime;            // can respawn when time > this, force after g_forcerespwan
        int                     inactivityTime;         // kick players when time > this
        qboolean        inactivityWarning;      // qtrue if the five seoond warning has been given
        int                     rewardTime;                     // clear the EF_AWARD_IMPRESSIVE, etc when time > this

        int                     airOutTime;

        int                     lastKillTime;           // for multiple kill rewards

        qboolean        fireHeld;                       // used for hook
        gentity_t       *hook;                          // grapple hook if out

        int                     switchTeamTime;         // time the player switched teams

        int                     switchDuelTeamTime;             // time the player switched duel teams

        int                     switchClassTime;        // class changed debounce timer

        // timeResidual is used to handle events that happen every second
        // like health / armor countdowns and regeneration
        int                     timeResidual;

        char            *areabits;

        int                     g2LastSurfaceHit; //index of surface hit during the most recent ghoul2 collision performed on this client.
        int                     g2LastSurfaceTime; //time when the surface index was set (to make sure it's up to date)

        int                     corrTime;

        vec3_t          lastHeadAngles;
        int                     lookTime;

        int                     brokenLimbs;

        qboolean        noCorpse; //don't leave a corpse on respawn this time.

        int                     jetPackTime;

        qboolean        jetPackOn;
        int                     jetPackToggleTime;
        int                     jetPackDebRecharge;
        int                     jetPackDebReduce;

        int                     cloakToggleTime;
        int                     cloakDebRecharge;
        int                     cloakDebReduce;

        int                     saberStoredIndex; //stores saberEntityNum from playerstate for when it's set to 0 (indicating saber was knocked out of the air)

        int                     saberKnockedTime; //if saber gets knocked away, can't pull it back until this value is < level.time

        vec3_t          olderSaberBase; //Set before lastSaberBase_Always, to whatever lastSaberBase_Always was previously
        qboolean        olderIsValid;   //is it valid?

        vec3_t          lastSaberDir_Always; //every getboltmatrix, set to saber dir
        vec3_t          lastSaberBase_Always; //every getboltmatrix, set to saber base
        int                     lastSaberStorageTime; //server time that the above two values were updated (for making sure they aren't out of date)

        qboolean        hasCurrentPosition;     //are lastSaberTip and lastSaberBase valid?

        int                     dangerTime;             // level.time when last attack occured

        int                     idleTime;               //keep track of when to play an idle anim on the client.

        int                     idleHealth;             //stop idling if health decreases
        vec3_t          idleViewAngles; //stop idling if viewangles change

        int                     forcePowerSoundDebounce; //if > level.time, don't do certain sound events again (drain sound, absorb sound, etc)

        char            modelname[MAX_QPATH];

        qboolean        fjDidJump;

        qboolean        ikStatus;

        int                     throwingIndex;
        int                     beingThrown;
        int                     doingThrow;

        float           hiddenDist;//How close ents have to be to pick you up as an enemy
        vec3_t          hiddenDir;//Normalized direction in which NPCs can't see you (you are hidden)

        renderInfo_t    renderInfo;

        //mostly NPC stuff:
        npcteam_t       playerTeam;
        npcteam_t       enemyTeam;
        char            *squadname;
        gentity_t       *team_leader;
        gentity_t       *leader;
        gentity_t       *follower;
        int                     numFollowers;
        gentity_t       *formationGoal;
        int                     nextFormGoal;
        class_t         NPC_class;

        vec3_t          pushVec;
        int                     pushVecTime;

        int                     siegeClass;
        int                     holdingObjectiveItem;

        //time values for when being healed/supplied by supplier class
        int                     isMedHealed;
        int                     isMedSupplied;

        //seperate debounce time for refilling someone's ammo as a supplier
        int                     medSupplyDebounce;

        //used in conjunction with ps.hackingTime
        int                     isHacking;
        vec3_t          hackingAngles;

        //debounce time for sending extended siege data to certain classes
        int                     siegeEDataSend;

        int                     ewebIndex; //index of e-web gun if spawned
        int                     ewebTime; //e-web use debounce
        int                     ewebHealth; //health of e-web (to keep track between deployments)

        int                     inSpaceIndex; //ent index of space trigger if inside one
        int                     inSpaceSuffocation; //suffocation timer

        int                     tempSpectate; //time to force spectator mode

        //keep track of last person kicked and the time so we don't hit multiple times per kick
        int                     jediKickIndex;
        int                     jediKickTime;

        //special moves (designed for kyle boss npc, but useable by players in mp)
        int                     grappleIndex;
        int                     grappleState;

        int                     solidHack;

        int                     noLightningTime;

        unsigned        mGameFlags;

        //fallen duelist
        qboolean        iAmALoser;

        int                     lastGenCmd;
        int                     lastGenCmdTime;
};

//Interest points

#define MAX_INTEREST_POINTS             64

typedef struct 
{
        vec3_t          origin;
        char            *target;
} interestPoint_t;

//Combat points

#define MAX_COMBAT_POINTS               512

typedef struct 
{
        vec3_t          origin;
        int                     flags;
//      char            *NPC_targetname;
//      team_t          team;
        qboolean        occupied;
        int                     waypoint;
        int                     dangerTime;
} combatPoint_t;

// Alert events

#define MAX_ALERT_EVENTS        32

typedef enum
{
        AET_SIGHT,
        AET_SOUND,
} alertEventType_e;

typedef enum
{
        AEL_MINOR,                      //Enemy responds to the sound, but only by looking
        AEL_SUSPICIOUS,         //Enemy looks at the sound, and will also investigate it
        AEL_DISCOVERED,         //Enemy knows the player is around, and will actively hunt
        AEL_DANGER,                     //Enemy should try to find cover
        AEL_DANGER_GREAT,       //Enemy should run like hell!
} alertEventLevel_e;

typedef struct alertEvent_s
{
        vec3_t                          position;       //Where the event is located
        float                           radius;         //Consideration radius
        alertEventLevel_e       level;          //Priority level of the event
        alertEventType_e        type;           //Event type (sound,sight)
        gentity_t                       *owner;         //Who made the sound
        float                           light;          //ambient light level at point
        float                           addLight;       //additional light- makes it more noticable, even in darkness
        int                                     ID;                     //unique... if get a ridiculous number, this will repeat, but should not be a problem as it's just comparing it to your lastAlertID
        int                                     timestamp;      //when it was created
} alertEvent_t;

//
// this structure is cleared as each map is entered
//
typedef struct
{
        char    targetname[MAX_QPATH];
        char    target[MAX_QPATH];
        char    target2[MAX_QPATH];
        char    target3[MAX_QPATH];
        char    target4[MAX_QPATH];
        int             nodeID;
} waypointData_t;

typedef struct {
        struct gclient_s        *clients;               // [maxclients]

        struct gentity_s        *gentities;
        int                     gentitySize;
        int                     num_entities;           // current number, <= MAX_GENTITIES

        int                     warmupTime;                     // restart match at this time

        fileHandle_t    logFile;

        // store latched cvars here that we want to get at often
        int                     maxclients;

        int                     framenum;
        int                     time;                                   // in msec
        int                     previousTime;                   // so movers can back up when blocked

        int                     startTime;                              // level.time the map was started

        int                     teamScores[TEAM_NUM_TEAMS];
        int                     lastTeamLocationTime;           // last time of client team location update

        qboolean        newSession;                             // don't use any old session data, because
                                                                                // we changed gametype

        qboolean        restarted;                              // waiting for a map_restart to fire

        int                     numConnectedClients;
        int                     numNonSpectatorClients; // includes connecting clients
        int                     numPlayingClients;              // connected, non-spectators
        int                     sortedClients[MAX_CLIENTS];             // sorted by score
        int                     follow1, follow2;               // clientNums for auto-follow spectators

        int                     snd_fry;                                // sound index for standing in lava

        int                     snd_hack;                               //hacking loop sound
    int                 snd_medHealed;                  //being healed by supply class
        int                     snd_medSupplied;                //being supplied by supply class

        int                     warmupModificationCount;        // for detecting if g_warmup is changed

        // voting state
        char            voteString[MAX_STRING_CHARS];
        char            voteDisplayString[MAX_STRING_CHARS];
        int                     voteTime;                               // level.time vote was called
        int                     voteExecuteTime;                // time the vote is executed
        int                     voteYes;
        int                     voteNo;
        int                     numVotingClients;               // set by CalculateRanks

        qboolean        votingGametype;
        int                     votingGametypeTo;

        // team voting state
        char            teamVoteString[2][MAX_STRING_CHARS];
        int                     teamVoteTime[2];                // level.time vote was called
        int                     teamVoteYes[2];
        int                     teamVoteNo[2];
        int                     numteamVotingClients[2];// set by CalculateRanks

        // spawn variables
        qboolean        spawning;                               // the G_Spawn*() functions are valid
        int                     numSpawnVars;
        char            *spawnVars[MAX_SPAWN_VARS][2];  // key / value pairs
        int                     numSpawnVarChars;
        char            spawnVarChars[MAX_SPAWN_VARS_CHARS];

        // intermission state
        int                     intermissionQueued;             // intermission was qualified, but
                                                                                // wait INTERMISSION_DELAY_TIME before
                                                                                // actually going there so the last
                                                                                // frag can be watched.  Disable future
                                                                                // kills during this delay
        int                     intermissiontime;               // time the intermission was started
        char            *changemap;
        qboolean        readyToExit;                    // at least one client wants to exit
        int                     exitTime;
        vec3_t          intermission_origin;    // also used for spectator spawns
        vec3_t          intermission_angle;

        qboolean        locationLinked;                 // target_locations get linked
        gentity_t       *locationHead;                  // head of the location list
        int                     bodyQueIndex;                   // dead bodies
        gentity_t       *bodyQue[BODY_QUEUE_SIZE];
        int                     portalSequence;

        alertEvent_t    alertEvents[ MAX_ALERT_EVENTS ];
        int                             numAlertEvents;
        int                             curAlertID;

        AIGroupInfo_t   groups[MAX_FRAME_GROUPS];

        //Interest points- squadmates automatically look at these if standing around and close to them
        interestPoint_t interestPoints[MAX_INTEREST_POINTS];
        int                     numInterestPoints;

        //Combat points- NPCs in bState BS_COMBAT_POINT will find their closest empty combat_point
        combatPoint_t   combatPoints[MAX_COMBAT_POINTS];
        int                     numCombatPoints;

        //rwwRMG - added:
        int                     mNumBSPInstances;
        int                     mBSPInstanceDepth;
        vec3_t          mOriginAdjust;
        float           mRotationAdjust;
        char            *mTargetAdjust;

        char            mTeamFilter[MAX_QPATH];

} level_locals_t;


//
// g_spawn.c
//
qboolean        G_SpawnString( const char *key, const char *defaultString, char **out );
// spawn string returns a temporary reference, you must CopyString() if you want to keep it
qboolean        G_SpawnFloat( const char *key, const char *defaultString, float *out );
qboolean        G_SpawnInt( const char *key, const char *defaultString, int *out );
qboolean        G_SpawnVector( const char *key, const char *defaultString, float *out );
void            G_SpawnEntitiesFromString( qboolean inSubBSP );
char *G_NewString( const char *string );

//
// g_cmds.c
//
void Cmd_Score_f (gentity_t *ent);
void StopFollowing( gentity_t *ent );
void BroadcastTeamChange( gclient_t *client, int oldTeam );
void SetTeam( gentity_t *ent, char *s );
void Cmd_FollowCycle_f( gentity_t *ent, int dir );
void Cmd_SaberAttackCycle_f(gentity_t *ent);
int G_ItemUsable(playerState_t *ps, int forcedUse);
void Cmd_ToggleSaber_f(gentity_t *ent);
void Cmd_EngageDuel_f(gentity_t *ent);

gentity_t *G_GetDuelWinner(gclient_t *client);

//
// g_items.c
//
void ItemUse_Binoculars(gentity_t *ent);
void ItemUse_Shield(gentity_t *ent);
void ItemUse_Sentry(gentity_t *ent);

void Jetpack_Off(gentity_t *ent);
void Jetpack_On(gentity_t *ent);
void ItemUse_Jetpack(gentity_t *ent);
void ItemUse_UseCloak( gentity_t *ent );
void ItemUse_UseDisp(gentity_t *ent, int type);
void ItemUse_UseEWeb(gentity_t *ent);
void G_PrecacheDispensers(void);

void ItemUse_Seeker(gentity_t *ent);
void ItemUse_MedPack(gentity_t *ent);
void ItemUse_MedPack_Big(gentity_t *ent);

void G_CheckTeamItems( void );
void G_RunItem( gentity_t *ent );
void RespawnItem( gentity_t *ent );

void UseHoldableItem( gentity_t *ent );
void PrecacheItem (gitem_t *it);
gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle );
gentity_t *LaunchItem( gitem_t *item, vec3_t origin, vec3_t velocity );
void SetRespawn (gentity_t *ent, float delay);
void G_SpawnItem (gentity_t *ent, gitem_t *item);
void FinishSpawningItem( gentity_t *ent );
void Think_Weapon (gentity_t *ent);
int ArmorIndex (gentity_t *ent);
void    Add_Ammo (gentity_t *ent, int weapon, int count);
void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace);

void ClearRegisteredItems( void );
void RegisterItem( gitem_t *item );
void SaveRegisteredItems( void );

//
// g_utils.c
//
int             G_ModelIndex( const char *name );
int             G_SoundIndex( const char *name );
int             G_SoundSetIndex(const char *name);
int             G_EffectIndex( const char *name );
int             G_BSPIndex( const char *name );
int             G_IconIndex( const char* name );

qboolean        G_PlayerHasCustomSkeleton(gentity_t *ent);

void    G_TeamCommand( team_t team, char *cmd );
void    G_ScaleNetHealth(gentity_t *self);
void    G_KillBox (gentity_t *ent);
gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match);
int             G_RadiusList ( vec3_t origin, float radius,     gentity_t *ignore, qboolean takeDamage, gentity_t *ent_list[MAX_GENTITIES]);

void    G_Throw( gentity_t *targ, vec3_t newDir, float push );

void    G_FreeFakeClient(gclient_t **cl);
void    G_CreateFakeClient(int entNum, gclient_t **cl);
void    G_CleanAllFakeClients(void);

void    G_SetAnim(gentity_t *ent, usercmd_t *ucmd, int setAnimParts, int anim, int setAnimFlags, int blendTime);
gentity_t *G_PickTarget (char *targetname);
void    GlobalUse(gentity_t *self, gentity_t *other, gentity_t *activator);
void    G_UseTargets2( gentity_t *ent, gentity_t *activator, const char *string );
void    G_UseTargets (gentity_t *ent, gentity_t *activator);
void    G_SetMovedir ( vec3_t angles, vec3_t movedir);
void    G_SetAngles( gentity_t *ent, vec3_t angles );

void    G_InitGentity( gentity_t *e );
gentity_t       *G_Spawn (void);
gentity_t *G_TempEntity( vec3_t origin, int event );
gentity_t       *G_PlayEffect(int fxID, vec3_t org, vec3_t ang);
gentity_t       *G_PlayEffectID(const int fxID, vec3_t org, vec3_t ang);
gentity_t *G_ScreenShake(vec3_t org, gentity_t *target, float intensity, int duration, qboolean global);
void    G_MuteSound( int entnum, int channel );
void    G_Sound( gentity_t *ent, int channel, int soundIndex );
void    G_SoundAtLoc( vec3_t loc, int channel, int soundIndex );
void    G_EntitySound( gentity_t *ent, int channel, int soundIndex );
void    TryUse( gentity_t *ent );
void    G_SendG2KillQueue(void);
void    G_KillG2Queue(int entNum);
void    G_FreeEntity( gentity_t *e );
qboolean        G_EntitiesFree( void );

qboolean G_ActivateBehavior (gentity_t *self, int bset );

void    G_TouchTriggers (gentity_t *ent);
void    G_TouchSolids (gentity_t *ent);
void    GetAnglesForDirection( const vec3_t p1, const vec3_t p2, vec3_t out );

//
// g_object.c
//

extern void G_RunObject                 ( gentity_t *ent );


float   *tv (float x, float y, float z);
char    *vtos( const vec3_t v );

void G_AddPredictableEvent( gentity_t *ent, int event, int eventParm );
void G_AddEvent( gentity_t *ent, int event, int eventParm );
void G_SetOrigin( gentity_t *ent, vec3_t origin );
qboolean G_CheckInSolid (gentity_t *self, qboolean fix);
void AddRemap(const char *oldShader, const char *newShader, float timeOffset);
const char *BuildShaderStateConfig(void);
/*
Ghoul2 Insert Start
*/
int G_BoneIndex( const char *name );

#include "../namespace_begin.h"

qhandle_t       trap_R_RegisterSkin( const char *name );

// CG specific API access
void            trap_G2_ListModelSurfaces(void *ghlInfo);
void            trap_G2_ListModelBones(void *ghlInfo, int frame);
void            trap_G2_SetGhoul2ModelIndexes(void *ghoul2, qhandle_t *modelList, qhandle_t *skinList);
qboolean        trap_G2_HaveWeGhoul2Models(void *ghoul2);
qboolean        trap_G2API_GetBoltMatrix(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
                                                                const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
qboolean        trap_G2API_GetBoltMatrix_NoReconstruct(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
                                                                const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
qboolean        trap_G2API_GetBoltMatrix_NoRecNoRot(void *ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix,
                                                                const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale);
int                     trap_G2API_InitGhoul2Model(void **ghoul2Ptr, const char *fileName, int modelIndex, qhandle_t customSkin,
                                                  qhandle_t customShader, int modelFlags, int lodBias);
qboolean        trap_G2API_SetSkin(void *ghoul2, int modelIndex, qhandle_t customSkin, qhandle_t renderSkin);

int                     trap_G2API_Ghoul2Size ( void* ghlInfo );

int                     trap_G2API_AddBolt(void *ghoul2, int modelIndex, const char *boneName);
void            trap_G2API_SetBoltInfo(void *ghoul2, int modelIndex, int boltInfo);

int                     trap_G2API_CopyGhoul2Instance(void *g2From, void *g2To, int modelIndex);
void            trap_G2API_CopySpecificGhoul2Model(void *g2From, int modelFrom, void *g2To, int modelTo);
void            trap_G2API_DuplicateGhoul2Instance(void *g2From, void **g2To);
qboolean        trap_G2API_HasGhoul2ModelOnIndex(void *ghlInfo, int modelIndex);
qboolean        trap_G2API_RemoveGhoul2Model(void *ghlInfo, int modelIndex);
qboolean        trap_G2API_RemoveGhoul2Models(void *ghlInfo);
void            trap_G2API_CleanGhoul2Models(void **ghoul2Ptr);
void            trap_G2API_CollisionDetect ( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position,
                                                                int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, int traceFlags, int useLod, float fRadius );
void            trap_G2API_CollisionDetectCache ( CollisionRecord_t *collRecMap, void* ghoul2, const vec3_t angles, const vec3_t position,
                                                                int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, int traceFlags, int useLod, float fRadius );

qboolean        trap_G2API_SetBoneAngles(void *ghoul2, int modelIndex, const char *boneName, const vec3_t angles, const int flags,
                                                                const int up, const int right, const int forward, qhandle_t *modelList,
                                                                int blendTime , int currentTime );
void            trap_G2API_GetGLAName(void *ghoul2, int modelIndex, char *fillBuf);
qboolean        trap_G2API_SetBoneAnim(void *ghoul2, const int modelIndex, const char *boneName, const int startFrame, const int endFrame,
                                                          const int flags, const float animSpeed, const int currentTime, const float setFrame , const int blendTime );
qboolean        trap_G2API_GetBoneAnim(void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *startFrame,
                                                                int *endFrame, int *flags, float *animSpeed, int *modelList, const int modelIndex);
void            trap_G2API_GetSurfaceName(void *ghoul2, int surfNumber, int modelIndex, char *fillBuf);
qboolean        trap_G2API_SetRootSurface(void *ghoul2, const int modelIndex, const char *surfaceName);
qboolean        trap_G2API_SetSurfaceOnOff(void *ghoul2, const char *surfaceName, const int flags);
qboolean        trap_G2API_SetNewOrigin(void *ghoul2, const int boltIndex);
qboolean        trap_G2API_DoesBoneExist(void *ghoul2, int modelIndex, const char *boneName);
int                     trap_G2API_GetSurfaceRenderStatus(void *ghoul2, const int modelIndex, const char *surfaceName);

void            trap_G2API_AbsurdSmoothing(void *ghoul2, qboolean status);

void            trap_G2API_SetRagDoll(void *ghoul2, sharedRagDollParams_t *params);
void            trap_G2API_AnimateG2Models(void *ghoul2, int time, sharedRagDollUpdateParams_t *params);

//additional ragdoll options -rww
qboolean        trap_G2API_RagPCJConstraint(void *ghoul2, const char *boneName, vec3_t min, vec3_t max); //override default pcj bonee constraints
qboolean        trap_G2API_RagPCJGradientSpeed(void *ghoul2, const char *boneName, const float speed); //override the default gradient movespeed for a pcj bone
qboolean        trap_G2API_RagEffectorGoal(void *ghoul2, const char *boneName, vec3_t pos); //override an effector bone's goal position (world coordinates)
qboolean        trap_G2API_GetRagBonePos(void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale); //current position of said bone is put into pos (world coordinates)
qboolean        trap_G2API_RagEffectorKick(void *ghoul2, const char *boneName, vec3_t velocity); //add velocity to a rag bone
qboolean        trap_G2API_RagForceSolve(void *ghoul2, qboolean force); //make sure we are actively performing solve/settle routines, if desired

qboolean        trap_G2API_SetBoneIKState(void *ghoul2, int time, const char *boneName, int ikState, sharedSetBoneIKStateParams_t *params);
qboolean        trap_G2API_IKMove(void *ghoul2, int time, sharedIKMoveParams_t *params);

//for removing bones so they no longer have their own seperate animation hierarchy. Or whatever reason you may have. -rww
qboolean        trap_G2API_RemoveBone(void *ghoul2, const char *boneName, int modelIndex);

void            trap_G2API_AttachInstanceToEntNum(void *ghoul2, int entityNum, qboolean server);
void            trap_G2API_ClearAttachedInstance(int entityNum);
void            trap_G2API_CleanEntAttachments(void);
qboolean        trap_G2API_OverrideServer(void *serverInstance);

#include "../namespace_end.h"

/*
Ghoul2 Insert End
*/

//
// g_combat.c
//
qboolean CanDamage (gentity_t *targ, vec3_t origin);
void G_Damage (gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod);
qboolean G_RadiusDamage (vec3_t origin, gentity_t *attacker, float damage, float radius, gentity_t *ignore, gentity_t *missile, int mod);
void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath );
void TossClientWeapon(gentity_t *self, vec3_t direction, float speed);
void TossClientItems( gentity_t *self );
void TossClientCubes( gentity_t *self );
void ExplodeDeath( gentity_t *self );
void G_CheckForDismemberment(gentity_t *ent, gentity_t *enemy, vec3_t point, int damage, int deathAnim, qboolean postDeath);
extern int gGAvoidDismember;


// damage flags
#define DAMAGE_NORMAL                           0x00000000      // No flags set.
#define DAMAGE_RADIUS                           0x00000001      // damage was indirect
#define DAMAGE_NO_ARMOR                         0x00000002      // armour does not protect from this damage
#define DAMAGE_NO_KNOCKBACK                     0x00000004      // do not affect velocity, just view angles
#define DAMAGE_NO_PROTECTION            0x00000008  // armor, shields, invulnerability, and godmode have no effect
#define DAMAGE_NO_TEAM_PROTECTION       0x00000010  // armor, shields, invulnerability, and godmode have no effect
//JK2 flags
#define DAMAGE_EXTRA_KNOCKBACK          0x00000040      // add extra knockback to this damage
#define DAMAGE_DEATH_KNOCKBACK          0x00000080      // only does knockback on death of target
#define DAMAGE_IGNORE_TEAM                      0x00000100      // damage is always done, regardless of teams
#define DAMAGE_NO_DAMAGE                        0x00000200      // do no actual damage but react as if damage was taken
#define DAMAGE_HALF_ABSORB                      0x00000400      // half shields, half health
#define DAMAGE_HALF_ARMOR_REDUCTION     0x00000800      // This damage doesn't whittle down armor as efficiently.
#define DAMAGE_HEAVY_WEAP_CLASS         0x00001000      // Heavy damage
#define DAMAGE_NO_HIT_LOC                       0x00002000      // No hit location
#define DAMAGE_NO_SELF_PROTECTION       0x00004000      // Dont apply half damage to self attacks
#define DAMAGE_NO_DISMEMBER                     0x00008000      // Dont do dismemberment
#define DAMAGE_SABER_KNOCKBACK1         0x00010000      // Check the attacker's first saber for a knockbackScale
#define DAMAGE_SABER_KNOCKBACK2         0x00020000      // Check the attacker's second saber for a knockbackScale
#define DAMAGE_SABER_KNOCKBACK1_B2      0x00040000      // Check the attacker's first saber for a knockbackScale2
#define DAMAGE_SABER_KNOCKBACK2_B2      0x00080000      // Check the attacker's second saber for a knockbackScale2
//
// g_exphysics.c
//
void G_RunExPhys(gentity_t *ent, float gravity, float mass, float bounce, qboolean autoKill, int *g2Bolts, int numG2Bolts);

//
// g_missile.c
//
void G_ReflectMissile( gentity_t *ent, gentity_t *missile, vec3_t forward );

void G_RunMissile( gentity_t *ent );

gentity_t *CreateMissile( vec3_t org, vec3_t dir, float vel, int life, 
                                                        gentity_t *owner, qboolean altFire);
void G_BounceProjectile( vec3_t start, vec3_t impact, vec3_t dir, vec3_t endout );
void G_ExplodeMissile( gentity_t *ent );

void WP_FireBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire );


//
// g_mover.c
//
extern int      BMS_START;
extern int      BMS_MID;
extern int      BMS_END;

#define SPF_BUTTON_USABLE               1
#define SPF_BUTTON_FPUSHABLE    2
void G_PlayDoorLoopSound( gentity_t *ent );
void G_PlayDoorSound( gentity_t *ent, int type );
void G_RunMover( gentity_t *ent );
void Touch_DoorTrigger( gentity_t *ent, gentity_t *other, trace_t *trace );

//
// g_trigger.c
//
void trigger_teleporter_touch (gentity_t *self, gentity_t *other, trace_t *trace );


//
// g_misc.c
//
#define MAX_REFNAME     32
#define START_TIME_LINK_ENTS            FRAMETIME*1

#define RTF_NONE        0
#define RTF_NAVGOAL     0x00000001

typedef struct reference_tag_s
{
        char            name[MAX_REFNAME];
        vec3_t          origin;
        vec3_t          angles;
        int                     flags;  //Just in case
        int                     radius; //For nav goals
        qboolean        inuse;
} reference_tag_t;

void TAG_Init( void );
reference_tag_t *TAG_Find( const char *owner, const char *name );
reference_tag_t *TAG_Add( const char *name, const char *owner, vec3_t origin, vec3_t angles, int radius, int flags );
int     TAG_GetOrigin( const char *owner, const char *name, vec3_t origin );
int     TAG_GetOrigin2( const char *owner, const char *name, vec3_t origin );
int     TAG_GetAngles( const char *owner, const char *name, vec3_t angles );
int TAG_GetRadius( const char *owner, const char *name );
int TAG_GetFlags( const char *owner, const char *name );

void TeleportPlayer( gentity_t *player, vec3_t origin, vec3_t angles );

//
// g_weapon.c
//
void WP_FireTurretMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod, gentity_t *ignore );
void WP_FireGenericBlasterMissile( gentity_t *ent, vec3_t start, vec3_t dir, qboolean altFire, int damage, int velocity, int mod );
qboolean LogAccuracyHit( gentity_t *target, gentity_t *attacker );
void CalcMuzzlePoint ( gentity_t *ent, vec3_t forward, vec3_t right, vec3_t up, vec3_t muzzlePoint );
void SnapVectorTowards( vec3_t v, vec3_t to );
qboolean CheckGauntletAttack( gentity_t *ent );


//
// g_client.c
//
team_t TeamCount( int ignoreClientNum, int team );
int TeamLeader( int team );
team_t PickTeam( int ignoreClientNum );
void SetClientViewAngle( gentity_t *ent, vec3_t angle );
gentity_t *SelectSpawnPoint ( vec3_t avoidPoint, vec3_t origin, vec3_t angles, team_t team );
void MaintainBodyQueue(gentity_t *ent);
void respawn (gentity_t *ent);
void BeginIntermission (void);
void InitBodyQue (void);
void ClientSpawn( gentity_t *ent );
void player_die (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int mod);
void AddScore( gentity_t *ent, vec3_t origin, int score );
void CalculateRanks( void );
qboolean SpotWouldTelefrag( gentity_t *spot );

extern gentity_t *gJMSaberEnt;

//
// g_svcmds.c
//
qboolean        ConsoleCommand( void );
void G_ProcessIPBans(void);
qboolean G_FilterPacket (char *from);

//
// g_weapon.c
//
void FireWeapon( gentity_t *ent, qboolean altFire );
void BlowDetpacks(gentity_t *ent);

//
// p_hud.c
//
void MoveClientToIntermission (gentity_t *client);
void G_SetStats (gentity_t *ent);
void DeathmatchScoreboardMessage (gentity_t *client);

//
// g_cmds.c
//

//
// g_pweapon.c
//


//
// g_main.c
//
extern vmCvar_t g_ff_objectives;
extern qboolean gDoSlowMoDuel;
extern int gSlowMoDuelTime;

void G_PowerDuelCount(int *loners, int *doubles, qboolean countSpec);

void FindIntermissionPoint( void );
void SetLeader(int team, int client);
void CheckTeamLeader( int team );
void G_RunThink (gentity_t *ent);
void QDECL G_LogPrintf( const char *fmt, ... );
void SendScoreboardMessageToAllClients( void );
void QDECL G_Printf( const char *fmt, ... );
void QDECL G_Error( const char *fmt, ... );
const char *G_GetStringEdString(char *refSection, char *refName);

//
// g_client.c
//
char *ClientConnect( int clientNum, qboolean firstTime, qboolean isBot );
void ClientUserinfoChanged( int clientNum );
void ClientDisconnect( int clientNum );
void ClientBegin( int clientNum, qboolean allowTeamReset );
void G_BreakArm(gentity_t *ent, int arm);
void G_UpdateClientAnims(gentity_t *self, float animSpeedScale);
void ClientCommand( int clientNum );

//
// g_active.c
//
void G_CheckClientTimeouts      ( gentity_t *ent );
void ClientThink                        ( int clientNum, usercmd_t *ucmd );
void ClientEndFrame                     ( gentity_t *ent );
void G_RunClient                        ( gentity_t *ent );

//
// g_team.c
//
qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 );
void Team_CheckDroppedItem( gentity_t *dropped );

//
// g_mem.c
//
void *G_Alloc( int size );
void G_InitMemory( void );
void Svcmd_GameMem_f( void );

//
// g_session.c
//
void G_ReadSessionData( gclient_t *client );
void G_InitSessionData( gclient_t *client, char *userinfo, qboolean isBot );

void G_InitWorldSession( void );
void G_WriteSessionData( void );

//
// NPC_senses.cpp
//
extern void AddSightEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, float addLight ); //addLight = 0.0f
extern void AddSoundEvent( gentity_t *owner, vec3_t position, float radius, alertEventLevel_e alertLevel, qboolean needLOS ); //needLOS = qfalse
extern qboolean G_CheckForDanger( gentity_t *self, int alertEvent );
extern int G_CheckAlertEvents( gentity_t *self, qboolean checkSight, qboolean checkSound, float maxSeeDist, float maxHearDist, int ignoreAlert, qboolean mustHaveOwner, int minAlertLevel ); //ignoreAlert = -1, mustHaveOwner = qfalse, minAlertLevel = AEL_MINOR
extern qboolean G_CheckForDanger( gentity_t *self, int alertEvent );
extern qboolean G_ClearLOS( gentity_t *self, const vec3_t start, const vec3_t end );
extern qboolean G_ClearLOS2( gentity_t *self, gentity_t *ent, const vec3_t end );
extern qboolean G_ClearLOS3( gentity_t *self, const vec3_t start, gentity_t *ent );
extern qboolean G_ClearLOS4( gentity_t *self, gentity_t *ent );
extern qboolean G_ClearLOS5( gentity_t *self, const vec3_t end );

//
// g_arenas.c
//
void UpdateTournamentInfo( void );
//void SpawnModelsOnVictoryPads( void );
//void Svcmd_AbortPodium_f( void );

//
// g_bot.c
//
void G_InitBots( qboolean restart );
char *G_GetBotInfoByNumber( int num );
char *G_GetBotInfoByName( const char *name );
void G_CheckBotSpawn( void );
void G_RemoveQueuedBotBegin( int clientNum );
qboolean G_BotConnect( int clientNum, qboolean restart );
void Svcmd_AddBot_f( void );
void Svcmd_BotList_f( void );
void BotInterbreedEndMatch( void );
qboolean G_DoesMapSupportGametype(const char *mapname, int gametype);
const char *G_RefreshNextMap(int gametype, qboolean forced);

// w_force.c / w_saber.c
gentity_t *G_PreDefSound(vec3_t org, int pdSound);
qboolean HasSetSaberOnly(void);
void WP_ForcePowerStop( gentity_t *self, forcePowers_t forcePower );
void WP_SaberPositionUpdate( gentity_t *self, usercmd_t *ucmd );
int WP_SaberCanBlock(gentity_t *self, vec3_t point, int dflags, int mod, qboolean projectile, int attackStr);
void WP_SaberInitBladeData( gentity_t *ent );
void WP_InitForcePowers( gentity_t *ent );
void WP_SpawnInitForcePowers( gentity_t *ent );
void WP_ForcePowersUpdate( gentity_t *self, usercmd_t *ucmd );
int ForcePowerUsableOn(gentity_t *attacker, gentity_t *other, forcePowers_t forcePower);
void ForceHeal( gentity_t *self );
void ForceSpeed( gentity_t *self, int forceDuration );
void ForceRage( gentity_t *self );
void ForceGrip( gentity_t *self );
void ForceProtect( gentity_t *self );
void ForceAbsorb( gentity_t *self );
void ForceTeamHeal( gentity_t *self );
void ForceTeamForceReplenish( gentity_t *self );
void ForceSeeing( gentity_t *self );
void ForceThrow( gentity_t *self, qboolean pull );
void ForceTelepathy(gentity_t *self);
qboolean Jedi_DodgeEvasion( gentity_t *self, gentity_t *shooter, trace_t *tr, int hitLoc );

// g_log.c
void QDECL G_LogPrintf( const char *fmt, ... );
void QDECL G_LogWeaponPickup(int client, int weaponid);
void QDECL G_LogWeaponFire(int client, int weaponid);
void QDECL G_LogWeaponDamage(int client, int mod, int amount);
void QDECL G_LogWeaponKill(int client, int mod);
void QDECL G_LogWeaponDeath(int client, int weaponid);
void QDECL G_LogWeaponFrag(int attacker, int deadguy);
void QDECL G_LogWeaponPowerup(int client, int powerupid);
void QDECL G_LogWeaponItem(int client, int itemid);
void QDECL G_LogWeaponInit(void);
void QDECL G_LogWeaponOutput(void);
void QDECL G_LogExit( const char *string );
void QDECL G_ClearClientLog(int client);

// g_siege.c
void InitSiegeMode(void);
void G_SiegeClientExData(gentity_t *msgTarg);

// g_timer
//Timing information
void            TIMER_Clear( void );
void            TIMER_Clear2( gentity_t *ent );
void            TIMER_Set( gentity_t *ent, const char *identifier, int duration );
int                     TIMER_Get( gentity_t *ent, const char *identifier );
qboolean        TIMER_Done( gentity_t *ent, const char *identifier );
qboolean        TIMER_Start( gentity_t *self, const char *identifier, int duration );
qboolean        TIMER_Done2( gentity_t *ent, const char *identifier, qboolean remove );
qboolean        TIMER_Exists( gentity_t *ent, const char *identifier );
void            TIMER_Remove( gentity_t *ent, const char *identifier );

float NPC_GetHFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float hFOV );
float NPC_GetVFOVPercentage( vec3_t spot, vec3_t from, vec3_t facing, float vFOV );


extern void G_SetEnemy (gentity_t *self, gentity_t *enemy);
qboolean InFront( vec3_t spot, vec3_t from, vec3_t fromAngles, float threshHold );

// ai_main.c
#define MAX_FILEPATH                    144

int             OrgVisible              ( vec3_t org1, vec3_t org2, int ignore);
void    BotOrder                ( gentity_t *ent, int clientnum, int ordernum);
int             InFieldOfVision ( vec3_t viewangles, float fov, vec3_t angles);

// ai_util.c
void B_InitAlloc(void);
void B_CleanupAlloc(void);

//bot settings
typedef struct bot_settings_s
{
        char personalityfile[MAX_FILEPATH];
        float skill;
        char team[MAX_FILEPATH];
} bot_settings_t;

int BotAISetup( int restart );
int BotAIShutdown( int restart );
int BotAILoadMap( int restart );
int BotAISetupClient(int client, struct bot_settings_s *settings, qboolean restart);
int BotAIShutdownClient( int client, qboolean restart );
int BotAIStartFrame( int time );

#include "g_team.h" // teamplay specific stuff


extern  level_locals_t  level;
extern  gentity_t               g_entities[MAX_GENTITIES];

#define FOFS(x) ((int)&(((gentity_t *)0)->x))

extern  vmCvar_t        g_gametype;
extern  vmCvar_t        g_dedicated;
extern  vmCvar_t        g_developer;
extern  vmCvar_t        g_cheats;
extern  vmCvar_t        g_maxclients;                   // allow this many total, including spectators
extern  vmCvar_t        g_maxGameClients;               // allow this many active
extern  vmCvar_t        g_restarted;

extern  vmCvar_t        g_trueJedi;

extern  vmCvar_t        g_autoMapCycle;
extern  vmCvar_t        g_dmflags;
extern  vmCvar_t        g_maxForceRank;
extern  vmCvar_t        g_forceBasedTeams;
extern  vmCvar_t        g_privateDuel;

extern  vmCvar_t        g_allowNPC;

extern  vmCvar_t        g_armBreakage;

extern  vmCvar_t        g_saberLocking;
extern  vmCvar_t        g_saberLockFactor;
extern  vmCvar_t        g_saberTraceSaberFirst;

extern  vmCvar_t        d_saberKickTweak;

extern  vmCvar_t        d_powerDuelPrint;

extern  vmCvar_t        d_saberGhoul2Collision;
extern  vmCvar_t        g_saberBladeFaces;
extern  vmCvar_t        d_saberAlwaysBoxTrace;
extern  vmCvar_t        d_saberBoxTraceSize;

extern  vmCvar_t        d_siegeSeekerNPC;

extern  vmCvar_t        g_debugMelee;
extern  vmCvar_t        g_stepSlideFix;

extern  vmCvar_t        g_noSpecMove;

#ifdef _DEBUG
extern  vmCvar_t        g_disableServerG2;
#endif

extern  vmCvar_t        d_perPlayerGhoul2;

extern  vmCvar_t        d_projectileGhoul2Collision;

extern  vmCvar_t        g_g2TraceLod;

extern  vmCvar_t        g_optvehtrace;

extern  vmCvar_t        g_locationBasedDamage;

extern  vmCvar_t        g_allowHighPingDuelist;

extern  vmCvar_t        g_logClientInfo;

extern  vmCvar_t        g_slowmoDuelEnd;

extern  vmCvar_t        g_saberDamageScale;

extern  vmCvar_t        g_useWhileThrowing;

extern  vmCvar_t        g_RMG;

extern  vmCvar_t        g_svfps;

extern  vmCvar_t        g_forceRegenTime;
extern  vmCvar_t        g_spawnInvulnerability;
extern  vmCvar_t        g_forcePowerDisable;
extern  vmCvar_t        g_weaponDisable;

extern  vmCvar_t        g_allowDuelSuicide;
extern  vmCvar_t        g_fraglimitVoteCorrection;

extern  vmCvar_t        g_duelWeaponDisable;
extern  vmCvar_t        g_fraglimit;
extern  vmCvar_t        g_duel_fraglimit;
extern  vmCvar_t        g_timelimit;
extern  vmCvar_t        g_capturelimit;
extern  vmCvar_t        d_saberInterpolate;
extern  vmCvar_t        g_friendlyFire;
extern  vmCvar_t        g_friendlySaber;
extern  vmCvar_t        g_password;
extern  vmCvar_t        g_needpass;
extern  vmCvar_t        g_gravity;
extern  vmCvar_t        g_speed;
extern  vmCvar_t        g_knockback;
extern  vmCvar_t        g_quadfactor;
extern  vmCvar_t        g_forcerespawn;
extern  vmCvar_t        g_siegeRespawn;
extern  vmCvar_t        g_inactivity;
extern  vmCvar_t        g_debugMove;
extern  vmCvar_t        g_debugAlloc;
#ifndef FINAL_BUILD
extern  vmCvar_t        g_debugDamage;
#endif
extern  vmCvar_t        g_debugServerSkel;
extern  vmCvar_t        g_weaponRespawn;
extern  vmCvar_t        g_weaponTeamRespawn;
extern  vmCvar_t        g_adaptRespawn;
extern  vmCvar_t        g_synchronousClients;
extern  vmCvar_t        g_motd;
extern  vmCvar_t        g_warmup;
extern  vmCvar_t        g_doWarmup;
extern  vmCvar_t        g_blood;
extern  vmCvar_t        g_allowVote;
extern  vmCvar_t        g_teamAutoJoin;
extern  vmCvar_t        g_teamForceBalance;
extern  vmCvar_t        g_banIPs;
extern  vmCvar_t        g_filterBan;
extern  vmCvar_t        g_debugForward;
extern  vmCvar_t        g_debugRight;
extern  vmCvar_t        g_debugUp;
//extern        vmCvar_t        g_redteam;
//extern        vmCvar_t        g_blueteam;
extern  vmCvar_t        g_smoothClients;

#include "../namespace_begin.h"
extern  vmCvar_t        pmove_fixed;
extern  vmCvar_t        pmove_msec;
#include "../namespace_end.h"

extern  vmCvar_t        g_enableBreath;
extern  vmCvar_t        g_singlePlayer;
extern  vmCvar_t        g_dismember;
extern  vmCvar_t        g_forceDodge;
extern  vmCvar_t        g_timeouttospec;

extern  vmCvar_t        g_saberDmgVelocityScale;
extern  vmCvar_t        g_saberDmgDelay_Idle;
extern  vmCvar_t        g_saberDmgDelay_Wound;

#ifndef FINAL_BUILD
extern  vmCvar_t        g_saberDebugPrint;
#endif

extern  vmCvar_t        g_siegeTeamSwitch;

extern  vmCvar_t        bg_fighterAltControl;

#ifdef DEBUG_SABER_BOX
extern  vmCvar_t        g_saberDebugBox;
#endif

//NPC nav debug
extern vmCvar_t         d_altRoutes;
extern vmCvar_t         d_patched;
extern  vmCvar_t        d_noIntermissionWait;

extern  vmCvar_t        g_siegeTeam1;
extern  vmCvar_t        g_siegeTeam2;

extern  vmCvar_t        g_austrian;

extern  vmCvar_t        g_powerDuelStartHealth;
extern  vmCvar_t        g_powerDuelEndHealth;

extern vmCvar_t         g_showDuelHealths;

#include "../namespace_begin.h"

void    trap_Printf( const char *fmt );
void    trap_Error( const char *fmt );
int             trap_Milliseconds( void );
void    trap_PrecisionTimer_Start(void **theNewTimer);
int             trap_PrecisionTimer_End(void *theTimer);
int             trap_Argc( void );
void    trap_Argv( int n, char *buffer, int bufferLength );
void    trap_Args( char *buffer, int bufferLength );
int             trap_FS_FOpenFile( const char *qpath, fileHandle_t *f, fsMode_t mode );
void    trap_FS_Read( void *buffer, int len, fileHandle_t f );
void    trap_FS_Write( const void *buffer, int len, fileHandle_t f );
void    trap_FS_FCloseFile( fileHandle_t f );
int             trap_FS_GetFileList( const char *path, const char *extension, char *listbuf, int bufsize );
void    trap_SendConsoleCommand( int exec_when, const char *text );
void    trap_Cvar_Register( vmCvar_t *cvar, const char *var_name, const char *value, int flags );
void    trap_Cvar_Update( vmCvar_t *cvar );
void    trap_Cvar_Set( const char *var_name, const char *value );
int             trap_Cvar_VariableIntegerValue( const char *var_name );
float   trap_Cvar_VariableValue( const char *var_name );
void    trap_Cvar_VariableStringBuffer( const char *var_name, char *buffer, int bufsize );
void    trap_LocateGameData( gentity_t *gEnts, int numGEntities, int sizeofGEntity_t, playerState_t *gameClients, int sizeofGameClient );
void    trap_DropClient( int clientNum, const char *reason );
void    trap_SendServerCommand( int clientNum, const char *text );
void    trap_SetConfigstring( int num, const char *string );
void    trap_GetConfigstring( int num, char *buffer, int bufferSize );
void    trap_GetUserinfo( int num, char *buffer, int bufferSize );
void    trap_SetUserinfo( int num, const char *buffer );
void    trap_GetServerinfo( char *buffer, int bufferSize );
void    trap_SetServerCull(float cullDistance);
void    trap_SetBrushModel( gentity_t *ent, const char *name );
void    trap_Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask );
void    trap_G2Trace( trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentmask, int g2TraceType, int traceLod );
int             trap_PointContents( const vec3_t point, int passEntityNum );
qboolean trap_InPVS( const vec3_t p1, const vec3_t p2 );
qboolean trap_InPVSIgnorePortals( const vec3_t p1, const vec3_t p2 );
void    trap_AdjustAreaPortalState( gentity_t *ent, qboolean open );
qboolean trap_AreasConnected( int area1, int area2 );
void    trap_LinkEntity( gentity_t *ent );
void    trap_UnlinkEntity( gentity_t *ent );
int             trap_EntitiesInBox( const vec3_t mins, const vec3_t maxs, int *entityList, int maxcount );
qboolean trap_EntityContact( const vec3_t mins, const vec3_t maxs, const gentity_t *ent );
int             trap_BotAllocateClient( void );
void    trap_BotFreeClient( int clientNum );
void    trap_GetUsercmd( int clientNum, usercmd_t *cmd );
qboolean        trap_GetEntityToken( char *buffer, int bufferSize );

//adding giant gamebreaking features post-alpha is fun!
void    trap_SiegePersSet(siegePers_t *pers);
void    trap_SiegePersGet(siegePers_t *pers);

#ifdef BOT_ZMALLOC
void    *trap_BotGetMemoryGame(int size);
void    trap_BotFreeMemoryGame(void *ptr);
#endif

int             trap_DebugPolygonCreate(int color, int numPoints, vec3_t *points);
void    trap_DebugPolygonDelete(int id);

int             trap_BotLibSetup( void );
int             trap_BotLibShutdown( void );
int             trap_BotLibVarSet(char *var_name, char *value);
int             trap_BotLibVarGet(char *var_name, char *value, int size);
int             trap_BotLibDefine(char *string);
int             trap_BotLibStartFrame(float time);
int             trap_BotLibLoadMap(const char *mapname);
int             trap_BotLibUpdateEntity(int ent, void /* struct bot_updateentity_s */ *bue);
int             trap_BotLibTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3);

int             trap_BotGetSnapshotEntity( int clientNum, int sequence );
int             trap_BotGetServerCommand(int clientNum, char *message, int size);
void    trap_BotUserCommand(int client, usercmd_t *ucmd);

int             trap_AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas);
int             trap_AAS_AreaInfo( int areanum, void /* struct aas_areainfo_s */ *info );
void    trap_AAS_EntityInfo(int entnum, void /* struct aas_entityinfo_s */ *info);

int             trap_AAS_Initialized(void);
void    trap_AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs);
float   trap_AAS_Time(void);

int             trap_AAS_PointAreaNum(vec3_t point);
int             trap_AAS_PointReachabilityAreaIndex(vec3_t point);
int             trap_AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas);

int             trap_AAS_PointContents(vec3_t point);
int             trap_AAS_NextBSPEntity(int ent);
int             trap_AAS_ValueForBSPEpairKey(int ent, char *key, char *value, int size);
int             trap_AAS_VectorForBSPEpairKey(int ent, char *key, vec3_t v);
int             trap_AAS_FloatForBSPEpairKey(int ent, char *key, float *value);
int             trap_AAS_IntForBSPEpairKey(int ent, char *key, int *value);

int             trap_AAS_AreaReachability(int areanum);

int             trap_AAS_AreaTravelTimeToGoalArea(int areanum, vec3_t origin, int goalareanum, int travelflags);
int             trap_AAS_EnableRoutingArea( int areanum, int enable );
int             trap_AAS_PredictRoute(void /*struct aas_predictroute_s*/ *route, int areanum, vec3_t origin,
                                                        int goalareanum, int travelflags, int maxareas, int maxtime,
                                                        int stopevent, int stopcontents, int stoptfl, int stopareanum);

int             trap_AAS_AlternativeRouteGoals(vec3_t start, int startareanum, vec3_t goal, int goalareanum, int travelflags,
                                                                                void /*struct aas_altroutegoal_s*/ *altroutegoals, int maxaltroutegoals,
                                                                                int type);
int             trap_AAS_Swimming(vec3_t origin);
int             trap_AAS_PredictClientMovement(void /* aas_clientmove_s */ *move, int entnum, vec3_t origin, int presencetype, int onground, vec3_t velocity, vec3_t cmdmove, int cmdframes, int maxframes, float frametime, int stopevent, int stopareanum, int visualize);


void    trap_EA_Say(int client, char *str);
void    trap_EA_SayTeam(int client, char *str);
void    trap_EA_Command(int client, char *command);

void    trap_EA_Action(int client, int action);
void    trap_EA_Gesture(int client);
void    trap_EA_Talk(int client);
void    trap_EA_Attack(int client);
void    trap_EA_Use(int client);
void    trap_EA_Respawn(int client);
void    trap_EA_Crouch(int client);
void    trap_EA_MoveUp(int client);
void    trap_EA_MoveDown(int client);
void    trap_EA_MoveForward(int client);
void    trap_EA_MoveBack(int client);
void    trap_EA_MoveLeft(int client);
void    trap_EA_MoveRight(int client);
void    trap_EA_SelectWeapon(int client, int weapon);
void    trap_EA_Jump(int client);
void    trap_EA_DelayedJump(int client);
void    trap_EA_Move(int client, vec3_t dir, float speed);
void    trap_EA_View(int client, vec3_t viewangles);
void    trap_EA_Alt_Attack(int client);
void    trap_EA_ForcePower(int client);

void    trap_EA_EndRegular(int client, float thinktime);
void    trap_EA_GetInput(int client, float thinktime, void /* struct bot_input_s */ *input);
void    trap_EA_ResetInput(int client);


int             trap_BotLoadCharacter(char *charfile, float skill);
void    trap_BotFreeCharacter(int character);
float   trap_Characteristic_Float(int character, int index);
float   trap_Characteristic_BFloat(int character, int index, float min, float max);
int             trap_Characteristic_Integer(int character, int index);
int             trap_Characteristic_BInteger(int character, int index, int min, int max);
void    trap_Characteristic_String(int character, int index, char *buf, int size);

int             trap_BotAllocChatState(void);
void    trap_BotFreeChatState(int handle);
void    trap_BotQueueConsoleMessage(int chatstate, int type, char *message);
void    trap_BotRemoveConsoleMessage(int chatstate, int handle);
int             trap_BotNextConsoleMessage(int chatstate, void /* struct bot_consolemessage_s */ *cm);
int             trap_BotNumConsoleMessages(int chatstate);
void    trap_BotInitialChat(int chatstate, char *type, int mcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );
int             trap_BotNumInitialChats(int chatstate, char *type);
int             trap_BotReplyChat(int chatstate, char *message, int mcontext, int vcontext, char *var0, char *var1, char *var2, char *var3, char *var4, char *var5, char *var6, char *var7 );
int             trap_BotChatLength(int chatstate);
void    trap_BotEnterChat(int chatstate, int client, int sendto);
void    trap_BotGetChatMessage(int chatstate, char *buf, int size);
int             trap_StringContains(char *str1, char *str2, int casesensitive);
int             trap_BotFindMatch(char *str, void /* struct bot_match_s */ *match, unsigned long int context);
void    trap_BotMatchVariable(void /* struct bot_match_s */ *match, int variable, char *buf, int size);
void    trap_UnifyWhiteSpaces(char *string);
void    trap_BotReplaceSynonyms(char *string, unsigned long int context);
int             trap_BotLoadChatFile(int chatstate, char *chatfile, char *chatname);
void    trap_BotSetChatGender(int chatstate, int gender);
void    trap_BotSetChatName(int chatstate, char *name, int client);
void    trap_BotResetGoalState(int goalstate);
void    trap_BotRemoveFromAvoidGoals(int goalstate, int number);
void    trap_BotResetAvoidGoals(int goalstate);
void    trap_BotPushGoal(int goalstate, void /* struct bot_goal_s */ *goal);
void    trap_BotPopGoal(int goalstate);
void    trap_BotEmptyGoalStack(int goalstate);
void    trap_BotDumpAvoidGoals(int goalstate);
void    trap_BotDumpGoalStack(int goalstate);
void    trap_BotGoalName(int number, char *name, int size);
int             trap_BotGetTopGoal(int goalstate, void /* struct bot_goal_s */ *goal);
int             trap_BotGetSecondGoal(int goalstate, void /* struct bot_goal_s */ *goal);
int             trap_BotChooseLTGItem(int goalstate, vec3_t origin, int *inventory, int travelflags);
int             trap_BotChooseNBGItem(int goalstate, vec3_t origin, int *inventory, int travelflags, void /* struct bot_goal_s */ *ltg, float maxtime);
int             trap_BotTouchingGoal(vec3_t origin, void /* struct bot_goal_s */ *goal);
int             trap_BotItemGoalInVisButNotVisible(int viewer, vec3_t eye, vec3_t viewangles, void /* struct bot_goal_s */ *goal);
int             trap_BotGetNextCampSpotGoal(int num, void /* struct bot_goal_s */ *goal);
int             trap_BotGetMapLocationGoal(char *name, void /* struct bot_goal_s */ *goal);
int             trap_BotGetLevelItemGoal(int index, char *classname, void /* struct bot_goal_s */ *goal);
float   trap_BotAvoidGoalTime(int goalstate, int number);
void    trap_BotSetAvoidGoalTime(int goalstate, int number, float avoidtime);
void    trap_BotInitLevelItems(void);
void    trap_BotUpdateEntityItems(void);
int             trap_BotLoadItemWeights(int goalstate, char *filename);
void    trap_BotFreeItemWeights(int goalstate);
void    trap_BotInterbreedGoalFuzzyLogic(int parent1, int parent2, int child);
void    trap_BotSaveGoalFuzzyLogic(int goalstate, char *filename);
void    trap_BotMutateGoalFuzzyLogic(int goalstate, float range);
int             trap_BotAllocGoalState(int state);
void    trap_BotFreeGoalState(int handle);

void    trap_BotResetMoveState(int movestate);
void    trap_BotMoveToGoal(void /* struct bot_moveresult_s */ *result, int movestate, void /* struct bot_goal_s */ *goal, int travelflags);
int             trap_BotMoveInDirection(int movestate, vec3_t dir, float speed, int type);
void    trap_BotResetAvoidReach(int movestate);
void    trap_BotResetLastAvoidReach(int movestate);
int             trap_BotReachabilityArea(vec3_t origin, int testground);
int             trap_BotMovementViewTarget(int movestate, void /* struct bot_goal_s */ *goal, int travelflags, float lookahead, vec3_t target);
int             trap_BotPredictVisiblePosition(vec3_t origin, int areanum, void /* struct bot_goal_s */ *goal, int travelflags, vec3_t target);
int             trap_BotAllocMoveState(void);
void    trap_BotFreeMoveState(int handle);
void    trap_BotInitMoveState(int handle, void /* struct bot_initmove_s */ *initmove);
void    trap_BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type);

int             trap_BotChooseBestFightWeapon(int weaponstate, int *inventory);
void    trap_BotGetWeaponInfo(int weaponstate, int weapon, void /* struct weaponinfo_s */ *weaponinfo);
int             trap_BotLoadWeaponWeights(int weaponstate, char *filename);
int             trap_BotAllocWeaponState(void);
void    trap_BotFreeWeaponState(int weaponstate);
void    trap_BotResetWeaponState(int weaponstate);

int             trap_GeneticParentsAndChildSelection(int numranks, float *ranks, int *parent1, int *parent2, int *child);

void    trap_SnapVector( float *v );

int trap_SP_GetStringTextString(const char *text, char *buffer, int bufferLength);

qboolean        trap_ROFF_Clean( void );
void            trap_ROFF_UpdateEntities( void );
int                     trap_ROFF_Cache( char *file );
qboolean        trap_ROFF_Play( int entID, int roffID, qboolean doTranslation );
qboolean        trap_ROFF_Purge_Ent( int entID );

//rww - dynamic vm memory allocation!
void            trap_TrueMalloc(void **ptr, int size);
void            trap_TrueFree(void **ptr);

//rww - icarus traps
int                     trap_ICARUS_RunScript( gentity_t *ent, const char *name );
qboolean        trap_ICARUS_RegisterScript( const char *name, qboolean bCalledDuringInterrogate);

void            trap_ICARUS_Init( void );
qboolean        trap_ICARUS_ValidEnt( gentity_t *ent );
qboolean        trap_ICARUS_IsInitialized( int entID );
qboolean        trap_ICARUS_MaintainTaskManager( int entID );
qboolean        trap_ICARUS_IsRunning( int entID );
qboolean        trap_ICARUS_TaskIDPending(gentity_t *ent, int taskID);
void            trap_ICARUS_InitEnt( gentity_t *ent );
void            trap_ICARUS_FreeEnt( gentity_t *ent );
void            trap_ICARUS_AssociateEnt( gentity_t *ent );
void            trap_ICARUS_Shutdown( void );
void            trap_ICARUS_TaskIDSet(gentity_t *ent, int taskType, int taskID);
void            trap_ICARUS_TaskIDComplete(gentity_t *ent, int taskType);
void            trap_ICARUS_SetVar(int taskID, int entID, const char *type_name, const char *data);
int                     trap_ICARUS_VariableDeclared(const char *type_name);
int                     trap_ICARUS_GetFloatVariable( const char *name, float *value );
int                     trap_ICARUS_GetStringVariable( const char *name, const char *value );
int                     trap_ICARUS_GetVectorVariable( const char *name, const vec3_t value );


//rww - BEGIN NPC NAV TRAPS
void            trap_Nav_Init( void );
void            trap_Nav_Free( void );
qboolean        trap_Nav_Load( const char *filename, int checksum );
qboolean        trap_Nav_Save( const char *filename, int checksum );
int                     trap_Nav_AddRawPoint( vec3_t point, int flags, int radius );
void            trap_Nav_CalculatePaths( qboolean recalc ); //recalc = qfalse
void            trap_Nav_HardConnect( int first, int second );

void            trap_Nav_ShowNodes( void );
void            trap_Nav_ShowEdges( void );
void            trap_Nav_ShowPath( int start, int end );
int                     trap_Nav_GetNearestNode( gentity_t *ent, int lastID, int flags, int targetID );
int                     trap_Nav_GetBestNode( int startID, int endID, int rejectID ); //rejectID = NODE_NONE
int                     trap_Nav_GetNodePosition( int nodeID, vec3_t out );
int                     trap_Nav_GetNodeNumEdges( int nodeID );
int                     trap_Nav_GetNodeEdge( int nodeID, int edge );
int                     trap_Nav_GetNumNodes( void );
qboolean        trap_Nav_Connected( int startID, int endID );
int                     trap_Nav_GetPathCost( int startID, int endID );
int                     trap_Nav_GetEdgeCost( int startID, int endID );
int                     trap_Nav_GetProjectedNode( vec3_t origin, int nodeID );
void            trap_Nav_CheckFailedNodes( gentity_t *ent );
void            trap_Nav_AddFailedNode( gentity_t *ent, int nodeID );
qboolean        trap_Nav_NodeFailed( gentity_t *ent, int nodeID );
qboolean        trap_Nav_NodesAreNeighbors( int startID, int endID );
void            trap_Nav_ClearFailedEdge( failedEdge_t  *failedEdge );
void            trap_Nav_ClearAllFailedEdges( void );
int                     trap_Nav_EdgeFailed( int startID, int endID );
void            trap_Nav_AddFailedEdge( int entID, int startID, int endID );
qboolean        trap_Nav_CheckFailedEdge( failedEdge_t *failedEdge );
void            trap_Nav_CheckAllFailedEdges( void );
qboolean        trap_Nav_RouteBlocked( int startID, int testEdgeID, int endID, int rejectRank );
int                     trap_Nav_GetBestNodeAltRoute( int startID, int endID, int *pathCost, int rejectID ); //rejectID = NODE_NONE
int                     trap_Nav_GetBestNodeAltRoute2( int startID, int endID, int rejectID ); //rejectID = NODE_NONE
int                     trap_Nav_GetBestPathBetweenEnts( gentity_t *ent, gentity_t *goal, int flags );
int                     trap_Nav_GetNodeRadius( int nodeID );
void            trap_Nav_CheckBlockedEdges( void );
void            trap_Nav_ClearCheckedNodes( void );
int                     trap_Nav_CheckedNode(int wayPoint, int ent); //return int was byte
void            trap_Nav_SetCheckedNode(int wayPoint, int ent, int value); //int value was byte value
void            trap_Nav_FlagAllNodes( int newFlag );
qboolean        trap_Nav_GetPathsCalculated(void);
void            trap_Nav_SetPathsCalculated(qboolean newVal);
//rww - END NPC NAV TRAPS

void            trap_SV_RegisterSharedMemory(char *memory);

void trap_SetActiveSubBSP(int index);
int     trap_CM_RegisterTerrain(const char *config);
void trap_RMG_Init(int terrainID);

void trap_Bot_UpdateWaypoints(int wpnum, wpobject_t **wps);
void trap_Bot_CalculatePaths(int rmg);

#include "../namespace_end.h"