// 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" #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" 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 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; int killCount; int TKCount; char IPstring[32]; // yeah, I know, could be 16, but, just in case... } 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; //can't put these in playerstate, crashes game (need to change exe?) int otherKillerMOD; int otherKillerVehWeapon; int otherKillerWeaponType; }; //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_allowTeamVote; 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"