codemp/game/bg_misc.c File Reference

#include "q_shared.h"
#include "bg_public.h"
#include "bg_strap.h"
#include "../cgame/cg_local.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Defines
#define	MAX_POOL_SIZE   512000
Functions
qboolean	BG_FileExists (const char *fileName)
char *	CG_NewString (const char *string)
void	BG_ParseField (BG_field_t *l_fields, const char *key, const char *value, byte *ent)
qboolean	BG_LegalizedForcePowers (char *powerOut, int maxRank, qboolean freeSaber, int teamForce, int gametype, int fpDisabled)
float	vectoyaw (const vec3_t vec)
qboolean	BG_HasYsalamiri (int gametype, playerState_t *ps)
qboolean	BG_CanUseFPNow (int gametype, playerState_t *ps, int time, forcePowers_t power)
gitem_t *	BG_FindItemForPowerup (powerup_t pw)
gitem_t *	BG_FindItemForHoldable (holdable_t pw)
gitem_t *	BG_FindItemForWeapon (weapon_t weapon)
gitem_t *	BG_FindItemForAmmo (ammo_t ammo)
gitem_t *	BG_FindItem (const char *classname)
qboolean	BG_PlayerTouchesItem (playerState_t *ps, entityState_t *item, int atTime)
int	BG_ProperForceIndex (int power)
void	BG_CycleForce (playerState_t *ps, int direction)
int	BG_GetItemIndexByTag (int tag, int type)
qboolean	BG_IsItemSelectable (playerState_t *ps, int item)
void	BG_CycleInven (playerState_t *ps, int direction)
qboolean	BG_CanItemBeGrabbed (int gametype, const entityState_t *ent, const playerState_t *ps)
void	BG_EvaluateTrajectory (const trajectory_t *tr, int atTime, vec3_t result)
void	BG_EvaluateTrajectoryDelta (const trajectory_t *tr, int atTime, vec3_t result)
void	BG_AddPredictableEventToPlayerstate (int newEvent, int eventParm, playerState_t *ps)
void	BG_TouchJumpPad (playerState_t *ps, entityState_t *jumppad)
int	BG_EmplacedView (vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint)
qboolean	BG_IsValidCharacterModel (const char *modelName, const char *skinName)
qboolean	BG_ValidateSkinForTeam (const char *modelName, char *skinName, int team, float *colors)
void	BG_PlayerStateToEntityState (playerState_t *ps, entityState_t *s, qboolean snap)
void	BG_PlayerStateToEntityStateExtraPolate (playerState_t *ps, entityState_t *s, int time, qboolean snap)
qhandle_t	trap_R_RegisterModel (const char *name)
qhandle_t	trap_R_RegisterSkin (const char *name)
int	BG_ModelCache (const char *modelName, const char *skinName)
void *	BG_Alloc (int size)
void *	BG_AllocUnaligned (int size)
void *	BG_TempAlloc (int size)
void	BG_TempFree (int size)
char *	BG_StringAlloc (const char *source)
qboolean	BG_OutOfMemory (void)
Variables
const char *	bgToggleableSurfaces [BG_NUM_TOGGLEABLE_SURFACES]
const int	bgToggleableSurfaceDebris [BG_NUM_TOGGLEABLE_SURFACES]
const char *	bg_customSiegeSoundNames [MAX_CUSTOM_SIEGE_SOUNDS]
char *	forceMasteryLevels [NUM_FORCE_MASTERY_LEVELS]
int	forceMasteryPoints [NUM_FORCE_MASTERY_LEVELS]
int	bgForcePowerCost [NUM_FORCE_POWERS][NUM_FORCE_POWER_LEVELS]
int	forcePowerSorted [NUM_FORCE_POWERS]
int	forcePowerDarkLight [NUM_FORCE_POWERS]
int	WeaponReadyAnim [WP_NUM_WEAPONS]
int	WeaponReadyLegsAnim [WP_NUM_WEAPONS]
int	WeaponAttackAnim [WP_NUM_WEAPONS]
gitem_t	bg_itemlist []
int	bg_numItems = sizeof(bg_itemlist) / sizeof(bg_itemlist[0]) - 1
char *	eventnames []

---

Define Documentation

#define MAX_POOL_SIZE   512000

Definition at line 3316 of file bg_misc.c. Referenced by BG_OutOfMemory(), and BG_TempFree().

---

Function Documentation

void BG_AddPredictableEventToPlayerstate (  int  newEvent, int  eventParm, playerState_t *  ps )

Definition at line 2635 of file bg_misc.c. References Com_Printf(), eventnames, playerState_s::eventParms, playerState_s::events, playerState_s::eventSequence, vmCvar_t::integer, MAX_PS_EVENTS, playerState_t, playerState_s::pmove_framecount, qboolean, qfalse, qtrue, and trap_Cvar_Register(). Referenced by G_AddPredictableEvent(), PM_AddEvent(), PM_AddEventWithParm(), PM_SaberLockBreak(), PM_SaberLocked(), PM_SetSaberMove(), and Touch_Item(). { #ifdef _DEBUG { static vmCvar_t showEvents; static qboolean isRegistered = qfalse; if (!isRegistered) { trap_Cvar_Register(&showEvents, "showevents", "0", 0); isRegistered = qtrue; } if ( showEvents.integer != 0 ) { #ifdef QAGAME Com_Printf(" game event svt %5d -> %5d: num = %20s parm %d\n", ps->pmove_framecount/*ps->commandTime*/, ps->eventSequence, eventnames[newEvent], eventParm); #else Com_Printf("Cgame event svt %5d -> %5d: num = %20s parm %d\n", ps->pmove_framecount/*ps->commandTime*/, ps->eventSequence, eventnames[newEvent], eventParm); #endif } } #endif ps->events[ps->eventSequence & (MAX_PS_EVENTS-1)] = newEvent; ps->eventParms[ps->eventSequence & (MAX_PS_EVENTS-1)] = eventParm; ps->eventSequence++; }

void* BG_Alloc (  int  size  )

Definition at line 3328 of file bg_misc.c. References Com_Error(), and ERR_DROP. Referenced by B_Alloc(), BG_AnimsetAlloc(), BG_StringAlloc(), CG_CreateNPCClient(), G_CreateAnimalNPC(), G_CreateFakeClient(), G_CreateFighterNPC(), G_CreateSpeederNPC(), G_CreateWalkerNPC(), New_NPC_t(), ParseAnimationEvtBlock(), UI_AnimsetAlloc(), and UI_InsertG2Pointer(). { bg_poolSize = ((bg_poolSize + 0x00000003) & 0xfffffffc); if (bg_poolSize + size > bg_poolTail) { Com_Error( ERR_DROP, "BG_Alloc: buffer exceeded tail (%d > %d)", bg_poolSize + size, bg_poolTail); return 0; } bg_poolSize += size; return &bg_pool[bg_poolSize-size]; }

void* BG_AllocUnaligned (  int  size  )

Definition at line 3343 of file bg_misc.c. References Com_Error(), and ERR_DROP. { if (bg_poolSize + size > bg_poolTail) { Com_Error( ERR_DROP, "BG_AllocUnaligned: buffer exceeded tail (%d > %d)", bg_poolSize + size, bg_poolTail); return 0; } bg_poolSize += size; return &bg_pool[bg_poolSize-size]; }

qboolean BG_CanItemBeGrabbed (  int  gametype, const entityState_t *  ent, const playerState_t *  ps )

Definition at line 2192 of file bg_misc.c. References playerState_s::ammo, ammoData, bg_itemlist, bg_numItems, playerState_s::clientNum, Com_Error(), Com_Printf(), playerState_s::duelInProgress, EF_DROPPEDWEAPON, entityState_s::eFlags, entityState_t, ERR_DROP, playerState_s::fd, forcedata_s::forcePowersActive, FP_RAGE, entityState_s::generic1, gitem_s::giTag, gitem_t, gitem_s::giType, GT_CTF, GT_CTY, HI_SEEKER, playerState_s::isJediMaster, IT_AMMO, IT_ARMOR, IT_BAD, IT_HEALTH, IT_HOLDABLE, IT_POWERUP, IT_TEAM, IT_WEAPON, ammoData_s::max, entityState_s::modelindex, entityState_s::modelindex2, PERS_TEAM, playerState_s::persistant, playerState_t, entityState_s::powerups, playerState_s::powerups, PW_BLUEFLAG, PW_REDFLAG, PW_YSALAMIRI, qboolean, qfalse, qtrue, gitem_s::quantity, STAT_ARMOR, STAT_HEALTH, STAT_HOLDABLE_ITEMS, STAT_MAX_HEALTH, STAT_WEAPONS, playerState_s::stats, TEAM_BLUE, TEAM_RED, playerState_s::trueJedi, playerState_s::trueNonJedi, weaponData, WP_DET_PACK, WP_SABER, WP_THERMAL, and WP_TRIP_MINE. Referenced by Touch_Item(). { gitem_t *item; if ( ent->modelindex < 1 || ent->modelindex >= bg_numItems ) { Com_Error( ERR_DROP, "BG_CanItemBeGrabbed: index out of range" ); } item = &bg_itemlist[ent->modelindex]; if ( ps ) { if ( ps->trueJedi ) {//force powers and saber only if ( item->giType != IT_TEAM //not a flag && item->giType != IT_ARMOR//not shields && (item->giType != IT_WEAPON || item->giTag != WP_SABER)//not a saber && (item->giType != IT_HOLDABLE || item->giTag != HI_SEEKER)//not a seeker && (item->giType != IT_POWERUP || item->giTag == PW_YSALAMIRI) )//not a force pick-up { return qfalse; } } else if ( ps->trueNonJedi ) {//can't pick up force powerups if ( (item->giType == IT_POWERUP && item->giTag != PW_YSALAMIRI) //if a powerup, can only can pick up ysalamiri || (item->giType == IT_HOLDABLE && item->giTag == HI_SEEKER)//if holdable, cannot pick up seeker || (item->giType == IT_WEAPON && item->giTag == WP_SABER ) )//or if it's a saber { return qfalse; } } if ( ps->isJediMaster && item && (item->giType == IT_WEAPON || item->giType == IT_AMMO)) {//jedi master cannot pick up weapons return qfalse; } if ( ps->duelInProgress ) { //no picking stuff up while in a duel, no matter what the type is return qfalse; } } else {//safety return since below code assumes a non-null ps return qfalse; } switch( item->giType ) { case IT_WEAPON: if (ent->generic1 == ps->clientNum && ent->powerups) { return qfalse; } if (!(ent->eFlags & EF_DROPPEDWEAPON) && (ps->stats[STAT_WEAPONS] & (1 << item->giTag)) && item->giTag != WP_THERMAL && item->giTag != WP_TRIP_MINE && item->giTag != WP_DET_PACK) { //weaponstay stuff.. if this isn't dropped, and you already have it, you don't get it. return qfalse; } if (item->giTag == WP_THERMAL || item->giTag == WP_TRIP_MINE || item->giTag == WP_DET_PACK) { //check to see if full on ammo for this, if so, then.. int ammoIndex = weaponData[item->giTag].ammoIndex; if (ps->ammo[ammoIndex] >= ammoData[ammoIndex].max) { //don't need it return qfalse; } } return qtrue; // weapons are always picked up case IT_AMMO: if (item->giTag == -1) { //special case for "all ammo" packs return qtrue; } if ( ps->ammo[item->giTag] >= ammoData[item->giTag].max) { return qfalse; // can't hold any more } return qtrue; case IT_ARMOR: if ( ps->stats[STAT_ARMOR] >= ps->stats[STAT_MAX_HEALTH]/* * item->giTag*/ ) { return qfalse; } return qtrue; case IT_HEALTH: // small and mega healths will go over the max, otherwise // don't pick up if already at max if ((ps->fd.forcePowersActive & (1 << FP_RAGE))) { return qfalse; } if ( item->quantity == 5 || item->quantity == 100 ) { if ( ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH] * 2 ) { return qfalse; } return qtrue; } if ( ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH] ) { return qfalse; } return qtrue; case IT_POWERUP: if (ps && (ps->powerups[PW_YSALAMIRI])) { if (item->giTag != PW_YSALAMIRI) { return qfalse; } } return qtrue; // powerups are always picked up case IT_TEAM: // team items, such as flags if( gametype == GT_CTF || gametype == GT_CTY ) { // ent->modelindex2 is non-zero on items if they are dropped // we need to know this because we can pick up our dropped flag (and return it) // but we can't pick up our flag at base if (ps->persistant[PERS_TEAM] == TEAM_RED) { if (item->giTag == PW_BLUEFLAG || (item->giTag == PW_REDFLAG && ent->modelindex2) || (item->giTag == PW_REDFLAG && ps->powerups[PW_BLUEFLAG]) ) return qtrue; } else if (ps->persistant[PERS_TEAM] == TEAM_BLUE) { if (item->giTag == PW_REDFLAG || (item->giTag == PW_BLUEFLAG && ent->modelindex2) || (item->giTag == PW_BLUEFLAG && ps->powerups[PW_REDFLAG]) ) return qtrue; } } return qfalse; case IT_HOLDABLE: if ( ps->stats[STAT_HOLDABLE_ITEMS] & (1 << item->giTag)) { return qfalse; } return qtrue; case IT_BAD: Com_Error( ERR_DROP, "BG_CanItemBeGrabbed: IT_BAD" ); default: #ifndef Q3_VM #ifndef NDEBUG // bk0001204 Com_Printf("BG_CanItemBeGrabbed: unknown enum %d\n", item->giType ); #endif #endif break; } return qfalse; }

qboolean BG_CanUseFPNow (  int  gametype, playerState_t *  ps, int  time, forcePowers_t  power )

Definition at line 1810 of file bg_misc.c. References BG_HasYsalamiri(), BROKENLIMB_LARM, BROKENLIMB_RARM, playerState_s::brokenLimbs, playerState_s::duelInProgress, playerState_s::fallingToDeath, forcePowers_t, playerState_s::forceRestricted, FP_DRAIN, FP_GRIP, FP_LEVITATION, FP_LIGHTNING, FP_PULL, FP_PUSH, FP_SABER_DEFENSE, FP_SABER_OFFENSE, playerState_s::m_iVehicleNum, playerState_t, qboolean, qfalse, qtrue, playerState_s::saberLockFrame, playerState_s::saberLockTime, playerState_s::trueNonJedi, playerState_s::weapon, and WP_EMPLACED_GUN. Referenced by ForcePowerUsableOn(), PM_ForceJumpingUp(), PM_WeaponLightsaber(), saberFirstThrown(), WP_ForcePowersUpdate(), and WP_ForcePowerUsable(). { if (BG_HasYsalamiri(gametype, ps)) { return qfalse; } if ( ps->forceRestricted || ps->trueNonJedi ) { return qfalse; } if (ps->weapon == WP_EMPLACED_GUN) { //can't use any of your powers while on an emplaced weapon return qfalse; } if (ps->m_iVehicleNum) { //can't use powers while riding a vehicle (this may change, I don't know) return qfalse; } if (ps->duelInProgress) { if (power != FP_SABER_OFFENSE && power != FP_SABER_DEFENSE && /*power != FP_SABERTHROW &&*/ power != FP_LEVITATION) { if (!ps->saberLockFrame || power != FP_PUSH) { return qfalse; } } } if (ps->saberLockFrame || ps->saberLockTime > time) { if (power != FP_PUSH) { return qfalse; } } if (ps->fallingToDeath) { return qfalse; } if ((ps->brokenLimbs & (1 << BROKENLIMB_RARM)) || (ps->brokenLimbs & (1 << BROKENLIMB_LARM))) { //powers we can't use with a broken arm switch (power) { case FP_PUSH: case FP_PULL: case FP_GRIP: case FP_LIGHTNING: case FP_DRAIN: return qfalse; default: break; } } return qtrue; }

void BG_CycleForce (  playerState_t *  ps, int  direction )

Definition at line 2014 of file bg_misc.c. References BG_ProperForceIndex(), playerState_s::fd, forcedata_s::forcePowerSelected, forcedata_s::forcePowersKnown, forcePowerSorted, FP_LEVITATION, FP_SABER_DEFENSE, FP_SABER_OFFENSE, FP_SABERTHROW, NUM_FORCE_POWERS, and playerState_t. Referenced by CG_NextForcePower_f(), and CG_PrevForcePower_f(). { int i = ps->fd.forcePowerSelected; int x = i; int presel = i; int foundnext = -1; if (!ps->fd.forcePowersKnown & (1 << x) || x >= NUM_FORCE_POWERS || x == -1) { //apparently we have no valid force powers return; } x = BG_ProperForceIndex(x); presel = x; if (direction == 1) { //get the next power x++; } else { //get the previous power x--; } if (x >= NUM_FORCE_POWERS) { //cycled off the end.. cycle around to the first x = 0; } if (x < 0) { //cycled off the beginning.. cycle around to the last x = NUM_FORCE_POWERS-1; } i = forcePowerSorted[x]; //the "sorted" value of this power while (x != presel) { //loop around to the current force power if (ps->fd.forcePowersKnown & (1 << i) && i != ps->fd.forcePowerSelected) { //we have the force power if (i != FP_LEVITATION && i != FP_SABER_OFFENSE && i != FP_SABER_DEFENSE && i != FP_SABERTHROW) { //it's selectable foundnext = i; break; } } if (direction == 1) { //next x++; } else { //previous x--; } if (x >= NUM_FORCE_POWERS) { //loop around x = 0; } if (x < 0) { //loop around x = NUM_FORCE_POWERS-1; } i = forcePowerSorted[x]; //set to the sorted value again } if (foundnext != -1) { //found one, select it ps->fd.forcePowerSelected = foundnext; } }

void BG_CycleInven (  playerState_t *  ps, int  direction )

Definition at line 2121 of file bg_misc.c. References BG_GetItemIndexByTag(), BG_IsItemSelectable(), bg_itemlist, HI_NUM_HOLDABLE, IT_HOLDABLE, playerState_t, STAT_HOLDABLE_ITEM, STAT_HOLDABLE_ITEMS, and playerState_s::stats. Referenced by CG_NextInventory_f(), CG_PrevInventory_f(), and EWebDie(). { int i; int dontFreeze = 0; int original; i = bg_itemlist[ps->stats[STAT_HOLDABLE_ITEM]].giTag; original = i; if (direction == 1) { //next i++; if (i == HI_NUM_HOLDABLE) { i = 1; } } else { //previous i--; if (i == 0) { i = HI_NUM_HOLDABLE-1; } } while (i != original) { //go in a full loop until hitting something, if hit nothing then select nothing if (ps->stats[STAT_HOLDABLE_ITEMS] & (1 << i)) { //we have it, select it. if (BG_IsItemSelectable(ps, i)) { ps->stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(i, IT_HOLDABLE); break; } } if (direction == 1) { //next i++; } else { //previous i--; } if (i <= 0) { //wrap around to the last i = HI_NUM_HOLDABLE-1; } else if (i >= HI_NUM_HOLDABLE) { //wrap around to the first i = 1; } dontFreeze++; if (dontFreeze >= 32) { //yeah, sure, whatever (it's 2 am and I'm paranoid and can't frickin think) break; } } }

int BG_EmplacedView (  vec3_t  baseAngles, vec3_t  angles, float *  newYaw, float  constraint )

Definition at line 2703 of file bg_misc.c. References AngleSubtract(), vec3_t, and YAW. Referenced by CG_EmplacedView(), CG_Player(), EWebThink(), and FireWeapon(). { float dif = AngleSubtract(baseAngles[YAW], angles[YAW]); if (dif > constraint || dif < -constraint) { float amt; if (dif > constraint) { amt = (dif-constraint); dif = constraint; } else if (dif < -constraint) { amt = (dif+constraint); dif = -constraint; } else { amt = 0.0f; } *newYaw = AngleSubtract(angles[YAW], -dif); if (amt > 1.0f || amt < -1.0f) { //significant, force the view return 2; } else { //just a little out of range return 1; } } return 0; }

void BG_EvaluateTrajectory (  const trajectory_t *  tr, int  atTime, vec3_t  result )

Definition at line 2353 of file bg_misc.c. References Com_Error(), cos(), DEFAULT_GRAVITY, DEG2RAD, ERR_DROP, M_PI, sin(), TR_GRAVITY, TR_INTERPOLATE, TR_LINEAR, TR_LINEAR_STOP, TR_NONLINEAR_STOP, TR_SINE, TR_STATIONARY, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trDuration, trajectory_t::trTime, trajectory_t::trType, vec3_t, VectorCopy, and VectorMA. Referenced by BG_PlayerTouchesItem(), CG_AddFragment(), CG_AdjustPositionForMover(), CG_BloodTrail(), CG_CalcEntityLerpPositions(), CG_CheckEvents(), CG_DrawRadar(), CG_ResetPlayerEntity(), fx_runner_think(), G_ExplodeMissile(), G_MoverTeam(), G_RunItem(), G_RunMissile(), G_RunObject(), SetMoverState(), thermalDetonatorExplode(), WP_LobFire(), and WP_SaberPositionUpdate(). { float deltaTime; float phase; switch( tr->trType ) { case TR_STATIONARY: case TR_INTERPOLATE: VectorCopy( tr->trBase, result ); break; case TR_LINEAR: deltaTime = ( atTime - tr->trTime ) * 0.001; // milliseconds to seconds VectorMA( tr->trBase, deltaTime, tr->trDelta, result ); break; case TR_SINE: deltaTime = ( atTime - tr->trTime ) / (float) tr->trDuration; phase = sin( deltaTime * M_PI * 2 ); VectorMA( tr->trBase, phase, tr->trDelta, result ); break; case TR_LINEAR_STOP: if ( atTime > tr->trTime + tr->trDuration ) { atTime = tr->trTime + tr->trDuration; } deltaTime = ( atTime - tr->trTime ) * 0.001; // milliseconds to seconds if ( deltaTime < 0 ) { deltaTime = 0; } VectorMA( tr->trBase, deltaTime, tr->trDelta, result ); break; case TR_NONLINEAR_STOP: if ( atTime > tr->trTime + tr->trDuration ) { atTime = tr->trTime + tr->trDuration; } //new slow-down at end if ( atTime - tr->trTime > tr->trDuration || atTime - tr->trTime <= 0 ) { deltaTime = 0; } else {//FIXME: maybe scale this somehow? So that it starts out faster and stops faster? deltaTime = tr->trDuration*0.001f*((float)cos( DEG2RAD(90.0f - (90.0f*((float)atTime-tr->trTime)/(float)tr->trDuration)) )); } VectorMA( tr->trBase, deltaTime, tr->trDelta, result ); break; case TR_GRAVITY: deltaTime = ( atTime - tr->trTime ) * 0.001; // milliseconds to seconds VectorMA( tr->trBase, deltaTime, tr->trDelta, result ); result[2] -= 0.5 * DEFAULT_GRAVITY * deltaTime * deltaTime; // FIXME: local gravity... break; default: #ifdef QAGAME Com_Error( ERR_DROP, "BG_EvaluateTrajectory: [GAME SIDE] unknown trType: %i", tr->trType ); #else Com_Error( ERR_DROP, "BG_EvaluateTrajectory: [CLIENTGAME SIDE] unknown trType: %i", tr->trType ); #endif break; } }

void BG_EvaluateTrajectoryDelta (  const trajectory_t *  tr, int  atTime, vec3_t  result )

Definition at line 2419 of file bg_misc.c. References Com_Error(), cos(), DEFAULT_GRAVITY, DEG2RAD, ERR_DROP, M_PI, TR_GRAVITY, TR_INTERPOLATE, TR_LINEAR, TR_LINEAR_STOP, TR_NONLINEAR_STOP, TR_SINE, TR_STATIONARY, trajectory_t::trDelta, trajectory_t::trDuration, trajectory_t::trTime, trajectory_t::trType, vec3_t, VectorClear, VectorCopy, and VectorScale. Referenced by CG_ReflectVelocity(), G_BounceItem(), G_BounceMissile(), G_BounceObject(), and G_MissileImpact(). { float deltaTime; float phase; switch( tr->trType ) { case TR_STATIONARY: case TR_INTERPOLATE: VectorClear( result ); break; case TR_LINEAR: VectorCopy( tr->trDelta, result ); break; case TR_SINE: deltaTime = ( atTime - tr->trTime ) / (float) tr->trDuration; phase = cos( deltaTime * M_PI * 2 ); // derivative of sin = cos phase *= 0.5; VectorScale( tr->trDelta, phase, result ); break; case TR_LINEAR_STOP: if ( atTime > tr->trTime + tr->trDuration ) { VectorClear( result ); return; } VectorCopy( tr->trDelta, result ); break; case TR_NONLINEAR_STOP: if ( atTime - tr->trTime > tr->trDuration || atTime - tr->trTime <= 0 ) { VectorClear( result ); return; } deltaTime = tr->trDuration*0.001f*((float)cos( DEG2RAD(90.0f - (90.0f*((float)atTime-tr->trTime)/(float)tr->trDuration)) )); VectorScale( tr->trDelta, deltaTime, result ); break; case TR_GRAVITY: deltaTime = ( atTime - tr->trTime ) * 0.001; // milliseconds to seconds VectorCopy( tr->trDelta, result ); result[2] -= DEFAULT_GRAVITY * deltaTime; // FIXME: local gravity... break; default: Com_Error( ERR_DROP, "BG_EvaluateTrajectoryDelta: unknown trType: %i", tr->trTime ); break; } }

qboolean BG_FileExists (  const char *  fileName  )

Definition at line 319 of file bg_misc.c. References FS_READ, qboolean, qfalse, qtrue, trap_FS_FCloseFile(), and trap_FS_FOpenFile(). Referenced by BG_ValidateSkinForTeam(). { if (fileName && fileName[0]) { int fh = 0; trap_FS_FOpenFile(fileName, &fh, FS_READ); if (fh > 0) { trap_FS_FCloseFile(fh); return qtrue; } } return qfalse; }

gitem_t* BG_FindItem (  const char *  classname  )

Definition at line 1960 of file bg_misc.c. References bg_itemlist, gitem_s::classname, gitem_t, NULL, and Q_stricmp(). Referenced by Cmd_Give_f(), G_CheckTeamItems(), G_PrecacheDispensers(), ItemUse_UseDisp(), and SP_gametype_item(). { gitem_t *it; for ( it = bg_itemlist + 1 ; it->classname ; it++ ) { if ( !Q_stricmp( it->classname, classname) ) return it; } return NULL; }

gitem_t* BG_FindItemForAmmo (  ammo_t  ammo  )

Definition at line 1941 of file bg_misc.c. References bg_itemlist, gitem_s::classname, Com_Error(), ERR_DROP, gitem_s::giTag, gitem_t, gitem_s::giType, IT_AMMO, and NULL. Referenced by NPC_Mark1_Precache(), NPC_Mark2_Precache(), NPC_Probe_Precache(), NPC_Sentry_Precache(), and NPC_ShadowTrooper_Precache(). { gitem_t *it; for ( it = bg_itemlist + 1 ; it->classname ; it++) { if ( it->giType == IT_AMMO && it->giTag == ammo ) { return it; } } Com_Error( ERR_DROP, "Couldn't find item for ammo %i", ammo); return NULL; }

gitem_t* BG_FindItemForHoldable (  holdable_t  pw  )

Definition at line 1901 of file bg_misc.c. References bg_itemlist, bg_numItems, Com_Error(), ERR_DROP, gitem_s::giTag, gitem_t, gitem_s::giType, holdable_t, IT_HOLDABLE, and NULL. Referenced by G_SiegeRegisterWeaponsAndHoldables(), PlaceShield(), and UI_SiegeSetCvarsForClass(). { int i; for ( i = 0 ; i < bg_numItems ; i++ ) { if ( bg_itemlist[i].giType == IT_HOLDABLE && bg_itemlist[i].giTag == pw ) { return &bg_itemlist[i]; } } Com_Error( ERR_DROP, "HoldableItem not found" ); return NULL; }

gitem_t* BG_FindItemForPowerup (  powerup_t  pw  )

Definition at line 1881 of file bg_misc.c. References bg_itemlist, bg_numItems, gitem_s::giTag, gitem_t, gitem_s::giType, IT_POWERUP, IT_TEAM, NULL, and powerup_t. Referenced by CG_DrawFlagModel(), CG_DrawNewTeamInfo(), and TossClientItems(). { int i; for ( i = 0 ; i < bg_numItems ; i++ ) { if ( (bg_itemlist[i].giType == IT_POWERUP || bg_itemlist[i].giType == IT_TEAM) && bg_itemlist[i].giTag == pw ) { return &bg_itemlist[i]; } } return NULL; }

gitem_t* BG_FindItemForWeapon (  weapon_t  weapon  )

Definition at line 1922 of file bg_misc.c. References bg_itemlist, gitem_s::classname, Com_Error(), ERR_DROP, gitem_s::giTag, gitem_t, gitem_s::giType, IT_WEAPON, NULL, and weapon_t. Referenced by CG_Init(), ClearRegisteredItems(), EWebPrecache(), finish_spawning_turretG2(), G_SiegeRegisterWeaponsAndHoldables(), InitShooter(), NPC_ATST_Precache(), NPC_Mark1_Precache(), NPC_Mark2_Precache(), NPC_Precache(), NPC_PrecacheWeapons(), NPC_Probe_Precache(), SP_emplaced_gun(), SP_misc_weapon_shooter(), TossClientItems(), TossClientWeapon(), turret_base_spawn_top(), and UI_SiegeSetCvarsForClass(). { gitem_t *it; for ( it = bg_itemlist + 1 ; it->classname ; it++) { if ( it->giType == IT_WEAPON && it->giTag == weapon ) { return it; } } Com_Error( ERR_DROP, "Couldn't find item for weapon %i", weapon); return NULL; }

int BG_GetItemIndexByTag (  int  tag, int  type )

Definition at line 2092 of file bg_misc.c. References bg_itemlist, bg_numItems, gitem_s::giTag, and gitem_s::giType. Referenced by BG_CycleInven(), BotUseInventoryItem(), CG_DrawInvenSelect(), CG_NextInventory_f(), CG_PrevInventory_f(), PmoveSingle(), TossClientWeapon(), and vmMain(). { //Get the itemlist index from the tag and type int i = 0; while (i < bg_numItems) { if (bg_itemlist[i].giTag == tag && bg_itemlist[i].giType == type) { return i; } i++; } return 0; }

qboolean BG_HasYsalamiri (  int  gametype, playerState_t *  ps )

Definition at line 1794 of file bg_misc.c. References GT_CTY, playerState_t, playerState_s::powerups, PW_BLUEFLAG, PW_REDFLAG, PW_YSALAMIRI, qboolean, qfalse, and qtrue. Referenced by BG_CanUseFPNow(), ForcePowerUsableOn(), PM_ForceJumpingUp(), PM_WeaponLightsaber(), saberFirstThrown(), WP_ForcePowersUpdate(), and WP_ForcePowerUsable(). { if (gametype == GT_CTY && (ps->powerups[PW_REDFLAG] || ps->powerups[PW_BLUEFLAG])) { return qtrue; } if (ps->powerups[PW_YSALAMIRI]) { return qtrue; } return qfalse; }

qboolean BG_IsItemSelectable (  playerState_t *  ps, int  item )

Definition at line 2111 of file bg_misc.c. References HI_AMMODISP, HI_HEALTHDISP, HI_JETPACK, playerState_t, qboolean, qfalse, and qtrue. Referenced by BG_CycleInven(), CG_DrawInvenSelect(), G_ItemUsable(), and PM_ItemUsable(). { if (item == HI_HEALTHDISP || item == HI_AMMODISP || item == HI_JETPACK) { return qfalse; } return qtrue; }

qboolean BG_IsValidCharacterModel (  const char *  modelName, const char *  skinName )

Definition at line 2744 of file bg_misc.c. References Q_stricmp(), qboolean, qfalse, and qtrue. Referenced by BG_ValidateSkinForTeam(), and SetupGameGhoul2Model(). { if (!Q_stricmp(skinName, "menu")) { return qfalse; } else if (!Q_stricmp(modelName, "kyle")) { if (!Q_stricmp(skinName, "fpls")) { return qfalse; } else if (!Q_stricmp(skinName, "fpls2")) { return qfalse; } else if (!Q_stricmp(skinName, "fpls3")) { return qfalse; } } return qtrue; }

qboolean BG_LegalizedForcePowers (  char *  powerOut, int  maxRank, qboolean  freeSaber, int  teamForce, int  gametype, int  fpDisabled )

Definition at line 439 of file bg_misc.c. References atoi(), bgForcePowerCost, FORCE_DARKSIDE, FORCE_LEVEL_3, FORCE_LIGHTSIDE, forceMasteryPoints, forcePowerDarkLight, FP_LEVITATION, FP_SABER_DEFENSE, FP_SABER_OFFENSE, FP_SABERTHROW, FP_TEAM_FORCE, FP_TEAM_HEAL, GT_TEAM, NUM_FORCE_POWERS, Q_strcat(), qboolean, qfalse, qtrue, strcpy(), strlen(), and va(). Referenced by UI_ForceConfigHandle(), UI_ReadLegalForce(), and WP_InitForcePowers(). { char powerBuf[128]; char readBuf[128]; qboolean maintainsValidity = qtrue; int powerLen = strlen(powerOut); int i = 0; int c = 0; int allowedPoints = 0; int usedPoints = 0; int countDown = 0; int final_Side; int final_Powers[NUM_FORCE_POWERS]; if (powerLen >= 128) { //This should not happen. If it does, this is obviously a bogus string. //They can have this string. Because I said so. strcpy(powerBuf, "7-1-032330000000001333"); maintainsValidity = qfalse; } else { strcpy(powerBuf, powerOut); //copy it as the original } //first of all, print the max rank into the string as the rank strcpy(powerOut, va("%i-", maxRank)); while (i < 128 && powerBuf[i] && powerBuf[i] != '-') { i++; } i++; while (i < 128 && powerBuf[i] && powerBuf[i] != '-') { readBuf[c] = powerBuf[i]; c++; i++; } readBuf[c] = 0; i++; //at this point, readBuf contains the intended side final_Side = atoi(readBuf); if (final_Side != FORCE_LIGHTSIDE && final_Side != FORCE_DARKSIDE) { //Not a valid side. You will be dark. Because I said so. (this is something that should never actually happen unless you purposely feed in an invalid config) final_Side = FORCE_DARKSIDE; maintainsValidity = qfalse; } if (teamForce) { //If we are under force-aligned teams, make sure we're on the right side. if (final_Side != teamForce) { final_Side = teamForce; //maintainsValidity = qfalse; //Not doing this, for now. Let them join the team with their filtered powers. } } //Now we have established a valid rank, and a valid side. //Read the force powers in, and cut them down based on the various rules supplied. c = 0; while (i < 128 && powerBuf[i] && powerBuf[i] != '\n' && c < NUM_FORCE_POWERS) { readBuf[0] = powerBuf[i]; readBuf[1] = 0; final_Powers[c] = atoi(readBuf); c++; i++; } //final_Powers now contains all the stuff from the string //Set the maximum allowed points used based on the max rank level, and count the points actually used. allowedPoints = forceMasteryPoints[maxRank]; i = 0; while (i < NUM_FORCE_POWERS) { //if this power doesn't match the side we're on, then 0 it now. if (final_Powers[i] && forcePowerDarkLight[i] && forcePowerDarkLight[i] != final_Side) { final_Powers[i] = 0; //This is only likely to happen with g_forceBasedTeams. Let it slide. } if ( final_Powers[i] && (fpDisabled & (1 << i)) ) { //if this power is disabled on the server via said server option, then we don't get it. final_Powers[i] = 0; } i++; } if (gametype < GT_TEAM) { //don't bother with team powers then final_Powers[FP_TEAM_HEAL] = 0; final_Powers[FP_TEAM_FORCE] = 0; } usedPoints = 0; i = 0; while (i < NUM_FORCE_POWERS) { countDown = 0; countDown = final_Powers[i]; while (countDown > 0) { usedPoints += bgForcePowerCost[i][countDown]; //[fp index][fp level] //if this is jump, or we have a free saber and it's offense or defense, take the level back down on level 1 if ( countDown == 1 && ((i == FP_LEVITATION) || (i == FP_SABER_OFFENSE && freeSaber) || (i == FP_SABER_DEFENSE && freeSaber)) ) { usedPoints -= bgForcePowerCost[i][countDown]; } countDown--; } i++; } if (usedPoints > allowedPoints) { //Time to do the fancy stuff. (meaning, slowly cut parts off while taking a guess at what is most or least important in the config) int attemptedCycles = 0; int powerCycle = 2; int minPow = 0; if (freeSaber) { minPow = 1; } maintainsValidity = qfalse; while (usedPoints > allowedPoints) { c = 0; while (c < NUM_FORCE_POWERS && usedPoints > allowedPoints) { if (final_Powers[c] && final_Powers[c] < powerCycle) { //kill in order of lowest powers, because the higher powers are probably more important if (c == FP_SABER_OFFENSE && (final_Powers[FP_SABER_DEFENSE] > minPow || final_Powers[FP_SABERTHROW] > 0)) { //if we're on saber attack, only suck it down if we have no def or throw either int whichOne = FP_SABERTHROW; //first try throw if (!final_Powers[whichOne]) { whichOne = FP_SABER_DEFENSE; //if no throw, drain defense } while (final_Powers[whichOne] > 0 && usedPoints > allowedPoints) { if ( final_Powers[whichOne] > 1 || ( (whichOne != FP_SABER_OFFENSE || !freeSaber) && (whichOne != FP_SABER_DEFENSE || !freeSaber) ) ) { //don't take attack or defend down on level 1 still, if it's free usedPoints -= bgForcePowerCost[whichOne][final_Powers[whichOne]]; final_Powers[whichOne]--; } else { break; } } } else { while (final_Powers[c] > 0 && usedPoints > allowedPoints) { if ( final_Powers[c] > 1 || ((c != FP_LEVITATION) && (c != FP_SABER_OFFENSE || !freeSaber) && (c != FP_SABER_DEFENSE || !freeSaber)) ) { usedPoints -= bgForcePowerCost[c][final_Powers[c]]; final_Powers[c]--; } else { break; } } } } c++; } powerCycle++; attemptedCycles++; if (attemptedCycles > NUM_FORCE_POWERS) { //I think this should be impossible. But just in case. break; } } if (usedPoints > allowedPoints) { //Still? Fine then.. we will kill all of your powers, except the freebies. i = 0; while (i < NUM_FORCE_POWERS) { final_Powers[i] = 0; if (i == FP_LEVITATION || (i == FP_SABER_OFFENSE && freeSaber) || (i == FP_SABER_DEFENSE && freeSaber)) { final_Powers[i] = 1; } i++; } usedPoints = 0; } } if (freeSaber) { if (final_Powers[FP_SABER_OFFENSE] < 1) { final_Powers[FP_SABER_OFFENSE] = 1; } if (final_Powers[FP_SABER_DEFENSE] < 1) { final_Powers[FP_SABER_DEFENSE] = 1; } } if (final_Powers[FP_LEVITATION] < 1) { final_Powers[FP_LEVITATION] = 1; } i = 0; while (i < NUM_FORCE_POWERS) { if (final_Powers[i] > FORCE_LEVEL_3) { final_Powers[i] = FORCE_LEVEL_3; } i++; } if (fpDisabled) { //If we specifically have attack or def disabled, force them up to level 3. It's the way //things work for the case of all powers disabled. //If jump is disabled, down-cap it to level 1. Otherwise don't do a thing. if (fpDisabled & (1 << FP_LEVITATION)) { final_Powers[FP_LEVITATION] = 1; } if (fpDisabled & (1 << FP_SABER_OFFENSE)) { final_Powers[FP_SABER_OFFENSE] = 3; } if (fpDisabled & (1 << FP_SABER_DEFENSE)) { final_Powers[FP_SABER_DEFENSE] = 3; } } if (final_Powers[FP_SABER_OFFENSE] < 1) { final_Powers[FP_SABER_DEFENSE] = 0; final_Powers[FP_SABERTHROW] = 0; } //We finally have all the force powers legalized and stored locally. //Put them all into the string and return the result. We already have //the rank there, so print the side and the powers now. Q_strcat(powerOut, 128, va("%i-", final_Side)); i = strlen(powerOut); c = 0; while (c < NUM_FORCE_POWERS) { strcpy(readBuf, va("%i", final_Powers[c])); powerOut[i] = readBuf[0]; c++; i++; } powerOut[i] = 0; return maintainsValidity; }

int BG_ModelCache (  const char *  modelName, const char *  skinName )

Definition at line 3200 of file bg_misc.c. References NULL, trap_G2API_CleanGhoul2Models(), trap_G2API_InitGhoul2Model(), trap_R_RegisterModel(), and trap_R_RegisterSkin(). Referenced by BG_PrecacheSabersForSiegeTeam(). { #ifdef QAGAME void *g2 = NULL; if (skinName && skinName[0]) { trap_R_RegisterSkin(skinName); } //I could hook up a precache ghoul2 function, but oh well, this works trap_G2API_InitGhoul2Model(&g2, modelName, 0, 0, 0, 0, 0); if (g2) { //now get rid of it trap_G2API_CleanGhoul2Models(&g2); } return 0; #else if (skinName && skinName[0]) { trap_R_RegisterSkin(skinName); } return trap_R_RegisterModel(modelName); #endif }

qboolean BG_OutOfMemory (  void   )

Definition at line 3392 of file bg_misc.c. References MAX_POOL_SIZE, and qboolean. { return bg_poolSize >= MAX_POOL_SIZE; }

void BG_ParseField (  BG_field_t *  l_fields, const char *  key, const char *  value, byte *  ent )

Definition at line 358 of file bg_misc.c. References atof(), atoi(), byte, CG_NewString(), G_NewString(), gentity_t, Q3_SetParm(), Q_stricmp(), sscanf(), and vec3_t. Referenced by CG_SpawnCGameEntFromVars(), G_SpawnGEntityFromSpawnVars(), and SP_worldspawn(). { BG_field_t *f; byte *b; float v; vec3_t vec; for ( f=l_fields ; f->name ; f++ ) { if ( !Q_stricmp(f->name, key) ) { // found it b = (byte *)ent; switch( f->type ) { case F_LSTRING: #ifdef QAGAME *(char **)(b+f->ofs) = G_NewString (value); #else *(char **)(b+f->ofs) = CG_NewString (value); #endif break; case F_VECTOR: sscanf (value, "%f %f %f", &vec[0], &vec[1], &vec[2]); ((float *)(b+f->ofs))[0] = vec[0]; ((float *)(b+f->ofs))[1] = vec[1]; ((float *)(b+f->ofs))[2] = vec[2]; break; case F_INT: *(int *)(b+f->ofs) = atoi(value); break; case F_FLOAT: *(float *)(b+f->ofs) = atof(value); break; case F_ANGLEHACK: v = atof(value); ((float *)(b+f->ofs))[0] = 0; ((float *)(b+f->ofs))[1] = v; ((float *)(b+f->ofs))[2] = 0; break; #ifdef QAGAME case F_PARM1: case F_PARM2: case F_PARM3: case F_PARM4: case F_PARM5: case F_PARM6: case F_PARM7: case F_PARM8: case F_PARM9: case F_PARM10: case F_PARM11: case F_PARM12: case F_PARM13: case F_PARM14: case F_PARM15: case F_PARM16: Q3_SetParm( ((gentity_t *)(ent))->s.number, (f->type - F_PARM1), (char *) value ); break; #endif default: case F_IGNORE: break; } return; } } }

void BG_PlayerStateToEntityState (  playerState_t *  ps, entityState_t *  s, qboolean  snap )

Definition at line 2887 of file bg_misc.c. References entityState_s::activeForcePass, playerState_s::activeForcePass, entityState_s::angles2, entityState_s::apos, entityState_s::bolt1, entityState_s::brokenLimbs, playerState_s::brokenLimbs, playerState_s::clientNum, entityState_s::clientNum, entityState_s::constantLight, entityState_s::customRGBA, playerState_s::customRGBA, playerState_s::duelInProgress, EF_DEAD, EF_SEEKERDRONE, entityState_s::eFlags, playerState_s::eFlags, entityState_s::eFlags2, playerState_s::eFlags2, playerState_s::electrifyTime, playerState_s::emplacedIndex, entityState_s::emplacedOwner, playerState_s::entityEventSequence, entityState_t, ET_INVISIBLE, ET_PLAYER, entityState_s::eType, entityState_s::event, entityState_s::eventParm, playerState_s::eventParms, playerState_s::events, playerState_s::eventSequence, playerState_s::externalEvent, playerState_s::externalEventParm, playerState_s::fd, entityState_s::fireflag, entityState_s::forceFrame, forcedata_s::forceMindtrickTargetIndex, forcedata_s::forceMindtrickTargetIndex2, forcedata_s::forceMindtrickTargetIndex3, forcedata_s::forceMindtrickTargetIndex4, entityState_s::forcePowersActive, forcedata_s::forcePowersActive, entityState_s::generic1, playerState_s::generic1, entityState_s::genericenemyindex, playerState_s::genericEnemyIndex, GIB_HEALTH, entityState_s::groundEntityNum, playerState_s::groundEntityNum, entityState_s::hasLookTarget, playerState_s::hasLookTarget, entityState_s::heldByClient, playerState_s::heldByClient, playerState_s::holocronBits, entityState_s::iModelScale, playerState_s::iModelScale, entityState_s::isJediMaster, playerState_s::isJediMaster, playerState_s::lastHitLoc, entityState_s::legsAnim, playerState_s::legsAnim, entityState_s::legsFlip, playerState_s::legsFlip, entityState_s::lookTarget, playerState_s::lookTarget, entityState_s::loopSound, playerState_s::loopSound, entityState_s::m_iVehicleNum, playerState_s::m_iVehicleNum, MAX_POWERUPS, MAX_PS_EVENTS, entityState_s::modelindex2, playerState_s::movementDir, entityState_s::number, playerState_s::origin, entityState_s::origin2, entityState_s::otherEntityNum2, playerState_t, PM_INTERMISSION, PM_SPECTATOR, playerState_s::pm_type, entityState_s::pos, entityState_s::powerups, playerState_s::powerups, entityState_s::ragAttach, playerState_s::ragAttach, forcedata_s::saberAnimLevel, entityState_s::saberEntityNum, playerState_s::saberEntityNum, entityState_s::saberHolstered, playerState_s::saberHolstered, entityState_s::saberInFlight, playerState_s::saberInFlight, playerState_s::saberLockFrame, entityState_s::saberMove, playerState_s::saberMove, entityState_s::speed, playerState_s::speed, STAT_HEALTH, playerState_s::stats, entityState_s::time2, entityState_s::torsoAnim, playerState_s::torsoAnim, entityState_s::torsoFlip, playerState_s::torsoFlip, TR_INTERPOLATE, trajectory_t::trBase, trajectory_t::trDelta, entityState_s::trickedentindex, entityState_s::trickedentindex2, entityState_s::trickedentindex3, entityState_s::trickedentindex4, trajectory_t::trType, VectorCopy, playerState_s::velocity, playerState_s::viewangles, entityState_s::weapon, playerState_s::weapon, playerState_s::weaponChargeTime, playerState_s::weaponstate, and YAW. Referenced by CG_AddPacketEntities(), CG_SetInitialSnapshot(), ClientEndFrame(), ClientSpawn(), ClientThink_real(), NPC_ApplyRoff(), SendPendingPredictableEvents(), and TeleportPlayer(). { int i; if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPECTATOR ) { s->eType = ET_INVISIBLE; } else if ( ps->stats[STAT_HEALTH] <= GIB_HEALTH ) { s->eType = ET_INVISIBLE; } else { s->eType = ET_PLAYER; } s->number = ps->clientNum; s->pos.trType = TR_INTERPOLATE; VectorCopy( ps->origin, s->pos.trBase ); if ( snap ) { SnapVector( s->pos.trBase ); } // set the trDelta for flag direction VectorCopy( ps->velocity, s->pos.trDelta ); s->apos.trType = TR_INTERPOLATE; VectorCopy( ps->viewangles, s->apos.trBase ); if ( snap ) { SnapVector( s->apos.trBase ); } s->trickedentindex = ps->fd.forceMindtrickTargetIndex; s->trickedentindex2 = ps->fd.forceMindtrickTargetIndex2; s->trickedentindex3 = ps->fd.forceMindtrickTargetIndex3; s->trickedentindex4 = ps->fd.forceMindtrickTargetIndex4; s->forceFrame = ps->saberLockFrame; s->emplacedOwner = ps->electrifyTime; s->speed = ps->speed; s->genericenemyindex = ps->genericEnemyIndex; s->activeForcePass = ps->activeForcePass; s->angles2[YAW] = ps->movementDir; s->legsAnim = ps->legsAnim; s->torsoAnim = ps->torsoAnim; s->legsFlip = ps->legsFlip; s->torsoFlip = ps->torsoFlip; s->clientNum = ps->clientNum; // ET_PLAYER looks here instead of at number // so corpses can also reference the proper config s->eFlags = ps->eFlags; s->eFlags2 = ps->eFlags2; s->saberInFlight = ps->saberInFlight; s->saberEntityNum = ps->saberEntityNum; s->saberMove = ps->saberMove; s->forcePowersActive = ps->fd.forcePowersActive; if (ps->duelInProgress) { s->bolt1 = 1; } else { s->bolt1 = 0; } s->otherEntityNum2 = ps->emplacedIndex; s->saberHolstered = ps->saberHolstered; if (ps->genericEnemyIndex != -1) { s->eFlags |= EF_SEEKERDRONE; } if ( ps->stats[STAT_HEALTH] <= 0 ) { s->eFlags |= EF_DEAD; } else { s->eFlags &= ~EF_DEAD; } if ( ps->externalEvent ) { s->event = ps->externalEvent; s->eventParm = ps->externalEventParm; } else if ( ps->entityEventSequence < ps->eventSequence ) { int seq; if ( ps->entityEventSequence < ps->eventSequence - MAX_PS_EVENTS) { ps->entityEventSequence = ps->eventSequence - MAX_PS_EVENTS; } seq = ps->entityEventSequence & (MAX_PS_EVENTS-1); s->event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 ); s->eventParm = ps->eventParms[ seq ]; ps->entityEventSequence++; } s->weapon = ps->weapon; s->groundEntityNum = ps->groundEntityNum; s->powerups = 0; for ( i = 0 ; i < MAX_POWERUPS ; i++ ) { if ( ps->powerups[ i ] ) { s->powerups |= 1 << i; } } s->loopSound = ps->loopSound; s->generic1 = ps->generic1; //NOT INCLUDED IN ENTITYSTATETOPLAYERSTATE: s->modelindex2 = ps->weaponstate; s->constantLight = ps->weaponChargeTime; VectorCopy(ps->lastHitLoc, s->origin2); s->isJediMaster = ps->isJediMaster; s->time2 = ps->holocronBits; s->fireflag = ps->fd.saberAnimLevel; s->heldByClient = ps->heldByClient; s->ragAttach = ps->ragAttach; s->iModelScale = ps->iModelScale; s->brokenLimbs = ps->brokenLimbs; s->hasLookTarget = ps->hasLookTarget; s->lookTarget = ps->lookTarget; s->customRGBA[0] = ps->customRGBA[0]; s->customRGBA[1] = ps->customRGBA[1]; s->customRGBA[2] = ps->customRGBA[2]; s->customRGBA[3] = ps->customRGBA[3]; s->m_iVehicleNum = ps->m_iVehicleNum; }

void BG_PlayerStateToEntityStateExtraPolate (  playerState_t *  ps, entityState_t *  s, int  time, qboolean  snap )

Definition at line 3037 of file bg_misc.c. References entityState_s::activeForcePass, playerState_s::activeForcePass, entityState_s::angles2, entityState_s::apos, entityState_s::bolt1, entityState_s::brokenLimbs, playerState_s::brokenLimbs, playerState_s::clientNum, entityState_s::clientNum, entityState_s::constantLight, entityState_s::customRGBA, playerState_s::customRGBA, playerState_s::duelInProgress, EF_DEAD, EF_SEEKERDRONE, entityState_s::eFlags, playerState_s::eFlags, entityState_s::eFlags2, playerState_s::eFlags2, playerState_s::electrifyTime, playerState_s::emplacedIndex, entityState_s::emplacedOwner, playerState_s::entityEventSequence, entityState_t, ET_INVISIBLE, ET_PLAYER, entityState_s::eType, entityState_s::event, entityState_s::eventParm, playerState_s::eventParms, playerState_s::events, playerState_s::eventSequence, playerState_s::externalEvent, playerState_s::externalEventParm, playerState_s::fd, entityState_s::fireflag, entityState_s::forceFrame, forcedata_s::forceMindtrickTargetIndex, forcedata_s::forceMindtrickTargetIndex2, forcedata_s::forceMindtrickTargetIndex3, forcedata_s::forceMindtrickTargetIndex4, entityState_s::forcePowersActive, forcedata_s::forcePowersActive, entityState_s::generic1, playerState_s::generic1, entityState_s::genericenemyindex, playerState_s::genericEnemyIndex, GIB_HEALTH, entityState_s::groundEntityNum, playerState_s::groundEntityNum, entityState_s::hasLookTarget, playerState_s::hasLookTarget, entityState_s::heldByClient, playerState_s::heldByClient, playerState_s::holocronBits, entityState_s::iModelScale, playerState_s::iModelScale, entityState_s::isJediMaster, playerState_s::isJediMaster, playerState_s::lastHitLoc, entityState_s::legsAnim, playerState_s::legsAnim, entityState_s::legsFlip, playerState_s::legsFlip, entityState_s::lookTarget, playerState_s::lookTarget, entityState_s::loopSound, playerState_s::loopSound, entityState_s::m_iVehicleNum, playerState_s::m_iVehicleNum, MAX_POWERUPS, MAX_PS_EVENTS, entityState_s::modelindex2, playerState_s::movementDir, entityState_s::number, playerState_s::origin, entityState_s::origin2, entityState_s::otherEntityNum2, playerState_t, PM_INTERMISSION, PM_SPECTATOR, playerState_s::pm_type, entityState_s::pos, entityState_s::powerups, playerState_s::powerups, entityState_s::ragAttach, playerState_s::ragAttach, forcedata_s::saberAnimLevel, entityState_s::saberEntityNum, playerState_s::saberEntityNum, entityState_s::saberHolstered, playerState_s::saberHolstered, entityState_s::saberInFlight, playerState_s::saberInFlight, playerState_s::saberLockFrame, entityState_s::saberMove, playerState_s::saberMove, entityState_s::speed, playerState_s::speed, STAT_HEALTH, playerState_s::stats, entityState_s::time2, entityState_s::torsoAnim, playerState_s::torsoAnim, entityState_s::torsoFlip, playerState_s::torsoFlip, TR_INTERPOLATE, TR_LINEAR_STOP, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trDuration, entityState_s::trickedentindex, entityState_s::trickedentindex2, entityState_s::trickedentindex3, entityState_s::trickedentindex4, trajectory_t::trTime, trajectory_t::trType, VectorCopy, playerState_s::velocity, playerState_s::viewangles, entityState_s::weapon, playerState_s::weapon, playerState_s::weaponChargeTime, playerState_s::weaponstate, and YAW. Referenced by ClientEndFrame(), and ClientThink_real(). { int i; if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPECTATOR ) { s->eType = ET_INVISIBLE; } else if ( ps->stats[STAT_HEALTH] <= GIB_HEALTH ) { s->eType = ET_INVISIBLE; } else { s->eType = ET_PLAYER; } s->number = ps->clientNum; s->pos.trType = TR_LINEAR_STOP; VectorCopy( ps->origin, s->pos.trBase ); if ( snap ) { SnapVector( s->pos.trBase ); } // set the trDelta for flag direction and linear prediction VectorCopy( ps->velocity, s->pos.trDelta ); // set the time for linear prediction s->pos.trTime = time; // set maximum extra polation time s->pos.trDuration = 50; // 1000 / sv_fps (default = 20) s->apos.trType = TR_INTERPOLATE; VectorCopy( ps->viewangles, s->apos.trBase ); if ( snap ) { SnapVector( s->apos.trBase ); } s->trickedentindex = ps->fd.forceMindtrickTargetIndex; s->trickedentindex2 = ps->fd.forceMindtrickTargetIndex2; s->trickedentindex3 = ps->fd.forceMindtrickTargetIndex3; s->trickedentindex4 = ps->fd.forceMindtrickTargetIndex4; s->forceFrame = ps->saberLockFrame; s->emplacedOwner = ps->electrifyTime; s->speed = ps->speed; s->genericenemyindex = ps->genericEnemyIndex; s->activeForcePass = ps->activeForcePass; s->angles2[YAW] = ps->movementDir; s->legsAnim = ps->legsAnim; s->torsoAnim = ps->torsoAnim; s->legsFlip = ps->legsFlip; s->torsoFlip = ps->torsoFlip; s->clientNum = ps->clientNum; // ET_PLAYER looks here instead of at number // so corpses can also reference the proper config s->eFlags = ps->eFlags; s->eFlags2 = ps->eFlags2; s->saberInFlight = ps->saberInFlight; s->saberEntityNum = ps->saberEntityNum; s->saberMove = ps->saberMove; s->forcePowersActive = ps->fd.forcePowersActive; if (ps->duelInProgress) { s->bolt1 = 1; } else { s->bolt1 = 0; } s->otherEntityNum2 = ps->emplacedIndex; s->saberHolstered = ps->saberHolstered; if (ps->genericEnemyIndex != -1) { s->eFlags |= EF_SEEKERDRONE; } if ( ps->stats[STAT_HEALTH] <= 0 ) { s->eFlags |= EF_DEAD; } else { s->eFlags &= ~EF_DEAD; } if ( ps->externalEvent ) { s->event = ps->externalEvent; s->eventParm = ps->externalEventParm; } else if ( ps->entityEventSequence < ps->eventSequence ) { int seq; if ( ps->entityEventSequence < ps->eventSequence - MAX_PS_EVENTS) { ps->entityEventSequence = ps->eventSequence - MAX_PS_EVENTS; } seq = ps->entityEventSequence & (MAX_PS_EVENTS-1); s->event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 ); s->eventParm = ps->eventParms[ seq ]; ps->entityEventSequence++; } s->weapon = ps->weapon; s->groundEntityNum = ps->groundEntityNum; s->powerups = 0; for ( i = 0 ; i < MAX_POWERUPS ; i++ ) { if ( ps->powerups[ i ] ) { s->powerups |= 1 << i; } } s->loopSound = ps->loopSound; s->generic1 = ps->generic1; //NOT INCLUDED IN ENTITYSTATETOPLAYERSTATE: s->modelindex2 = ps->weaponstate; s->constantLight = ps->weaponChargeTime; VectorCopy(ps->lastHitLoc, s->origin2); s->isJediMaster = ps->isJediMaster; s->time2 = ps->holocronBits; s->fireflag = ps->fd.saberAnimLevel; s->heldByClient = ps->heldByClient; s->ragAttach = ps->ragAttach; s->iModelScale = ps->iModelScale; s->brokenLimbs = ps->brokenLimbs; s->hasLookTarget = ps->hasLookTarget; s->lookTarget = ps->lookTarget; s->customRGBA[0] = ps->customRGBA[0]; s->customRGBA[1] = ps->customRGBA[1]; s->customRGBA[2] = ps->customRGBA[2]; s->customRGBA[3] = ps->customRGBA[3]; s->m_iVehicleNum = ps->m_iVehicleNum; }

qboolean BG_PlayerTouchesItem (  playerState_t *  ps, entityState_t *  item, int  atTime )

Definition at line 1979 of file bg_misc.c. References BG_EvaluateTrajectory(), entityState_t, playerState_s::origin, playerState_t, entityState_s::pos, qboolean, qfalse, qtrue, and vec3_t. Referenced by G_TouchTriggers(). { vec3_t origin; BG_EvaluateTrajectory( &item->pos, atTime, origin ); // we are ignoring ducked differences here if ( ps->origin[0] - origin[0] > 44 || ps->origin[0] - origin[0] < -50 || ps->origin[1] - origin[1] > 36 || ps->origin[1] - origin[1] < -36 || ps->origin[2] - origin[2] > 36 || ps->origin[2] - origin[2] < -36 ) { return qfalse; } return qtrue; }

int BG_ProperForceIndex (  int  power  )

Definition at line 1997 of file bg_misc.c. References forcePowerSorted, and NUM_FORCE_POWERS. Referenced by BG_CycleForce(), and CG_DrawForceSelect(). { int i = 0; while (i < NUM_FORCE_POWERS) { if (forcePowerSorted[i] == power) { return i; } i++; } return -1; }

char* BG_StringAlloc (  const char *  source  )

Definition at line 3383 of file bg_misc.c. References BG_Alloc(), strcpy(), and strlen(). { char *dest; dest = BG_Alloc ( strlen ( source ) + 1 ); strcpy ( dest, source ); return dest; }

void* BG_TempAlloc (  int  size  )

Definition at line 3356 of file bg_misc.c. References Com_Error(), and ERR_DROP. Referenced by B_TempAlloc(), BG_VehicleLoadParms(), BG_VehWeaponLoadParms(), and NPC_ParseParms(). { size = ((size + 0x00000003) & 0xfffffffc); if (bg_poolTail - size < bg_poolSize) { Com_Error( ERR_DROP, "BG_TempAlloc: buffer exceeded head (%d > %d)", bg_poolTail - size, bg_poolSize); return 0; } bg_poolTail -= size; return &bg_pool[bg_poolTail]; }

void BG_TempFree (  int  size  )

Definition at line 3371 of file bg_misc.c. References Com_Error(), ERR_DROP, and MAX_POOL_SIZE. Referenced by B_TempFree(), BG_VehicleLoadParms(), BG_VehWeaponLoadParms(), and NPC_ParseParms(). { size = ((size + 0x00000003) & 0xfffffffc); if (bg_poolTail+size > MAX_POOL_SIZE) { Com_Error( ERR_DROP, "BG_TempFree: tail greater than size (%d > %d)", bg_poolTail+size, MAX_POOL_SIZE ); } bg_poolTail += size; }

void BG_TouchJumpPad (  playerState_t *  ps, entityState_t *  jumppad )

Definition at line 2667 of file bg_misc.c. References AngleNormalize180(), entityState_t, fabs(), playerState_s::jumppad_ent, playerState_s::jumppad_frame, entityState_s::number, entityState_s::origin2, PITCH, playerState_t, PM_FLOAT, PM_JETPACK, PM_NORMAL, playerState_s::pm_type, playerState_s::pmove_framecount, vec3_t, vectoangles(), VectorCopy, and playerState_s::velocity. Referenced by trigger_push_touch(). { vec3_t angles; float p; int effectNum; // spectators don't use jump pads if ( ps->pm_type != PM_NORMAL && ps->pm_type != PM_JETPACK && ps->pm_type != PM_FLOAT ) { return; } // if we didn't hit this same jumppad the previous frame // then don't play the event sound again if we are in a fat trigger if ( ps->jumppad_ent != jumppad->number ) { vectoangles( jumppad->origin2, angles); p = fabs( AngleNormalize180( angles[PITCH] ) ); if( p < 45 ) { effectNum = 0; } else { effectNum = 1; } } // remember hitting this jumppad this frame ps->jumppad_ent = jumppad->number; ps->jumppad_frame = ps->pmove_framecount; // give the player the velocity from the jumppad VectorCopy( jumppad->origin2, ps->velocity ); }

qboolean BG_ValidateSkinForTeam (  const char *  modelName, char *  skinName, int  team, float *  colors )

Definition at line 2768 of file bg_misc.c. References BG_FileExists(), BG_IsValidCharacterModel(), MAX_QPATH, Q_strcat(), Q_stricmp(), Q_stricmpn(), Q_strncmp(), Q_strncpyz(), qboolean, qfalse, qtrue, strchr(), strlen(), TEAM_BLUE, TEAM_RED, and va(). Referenced by CG_NewClientInfo(), and SetupGameGhoul2Model(). { if (!Q_stricmpn(modelName, "jedi_",5)) { //argh, it's a custom player skin! if (team == TEAM_RED && colors) { colors[0] = 1.0f; colors[1] = 0.0f; colors[2] = 0.0f; } else if (team == TEAM_BLUE && colors) { colors[0] = 0.0f; colors[1] = 0.0f; colors[2] = 1.0f; } return qtrue; } if (team == TEAM_RED) { if ( Q_stricmp( "red", skinName ) != 0 ) {//not "red" if ( Q_stricmp( "blue", skinName ) == 0 || Q_stricmp( "default", skinName ) == 0 || strchr(skinName, '|')//a multi-skin playerModel || !BG_IsValidCharacterModel(modelName, skinName) ) { Q_strncpyz(skinName, "red", MAX_QPATH); return qfalse; } else {//need to set it to red int len = strlen( skinName ); if ( len < 3 ) {//too short to be "red" Q_strcat(skinName, MAX_QPATH, "_red"); } else { char *start = &skinName[len-3]; if ( Q_strncmp( "red", start, 3 ) != 0 ) {//doesn't already end in "red" if ( len+4 >= MAX_QPATH ) {//too big to append "_red" Q_strncpyz(skinName, "red", MAX_QPATH); return qfalse; } else { Q_strcat(skinName, MAX_QPATH, "_red"); } } } //if file does not exist, set to "red" if ( !BG_FileExists( va( "models/players/%s/model_%s.skin", modelName, skinName ) ) ) { Q_strncpyz(skinName, "red", MAX_QPATH); } return qfalse; } } } else if (team == TEAM_BLUE) { if ( Q_stricmp( "blue", skinName ) != 0 ) { if ( Q_stricmp( "red", skinName ) == 0 || Q_stricmp( "default", skinName ) == 0 || strchr(skinName, '|')//a multi-skin playerModel || !BG_IsValidCharacterModel(modelName, skinName) ) { Q_strncpyz(skinName, "blue", MAX_QPATH); return qfalse; } else {//need to set it to blue int len = strlen( skinName ); if ( len < 4 ) {//too short to be "blue" Q_strcat(skinName, MAX_QPATH, "_blue"); } else { char *start = &skinName[len-4]; if ( Q_strncmp( "blue", start, 4 ) != 0 ) {//doesn't already end in "blue" if ( len+5 >= MAX_QPATH ) {//too big to append "_blue" Q_strncpyz(skinName, "blue", MAX_QPATH); return qfalse; } else { Q_strcat(skinName, MAX_QPATH, "_blue"); } } } //if file does not exist, set to "blue" if ( !BG_FileExists( va( "models/players/%s/model_%s.skin", modelName, skinName ) ) ) { Q_strncpyz(skinName, "blue", MAX_QPATH); } return qfalse; } } } return qtrue; }

char* CG_NewString (  const char *  string  )

Definition at line 3344 of file cg_main.c. References CG_StrPool_Alloc(), and strlen(). Referenced by BG_ParseField(). { char *newb, *new_p; int i,l; l = strlen(string) + 1; newb = CG_StrPool_Alloc( l ); new_p = newb; // turn \n into a real linefeed for ( i=0 ; i< l ; i++ ) { if (string[i] == '\\' && i < l-1) { i++; if (string[i] == 'n') { *new_p++ = '\n'; } else { *new_p++ = '\\'; } } else { *new_p++ = string[i]; } } return newb; }

qhandle_t trap_R_RegisterModel (  const char *  name  )

Definition at line 266 of file cg_syscalls.c. { return syscall( CG_R_REGISTERMODEL, name ); }

qhandle_t trap_R_RegisterSkin (  const char *  name  )

Definition at line 270 of file cg_syscalls.c. { return syscall( CG_R_REGISTERSKIN, name ); }

float vectoyaw (  const vec3_t  vec  )

Definition at line 1773 of file bg_misc.c. References atan2(), M_PI, PITCH, vec3_t, and YAW. Referenced by ClientCommand(), ClientThink_real(), LookAtKiller(), NAV_Bypass(), NAVNEW_SidestepBlocker(), NPC_BSFlee(), NPC_BSSearch(), NPC_BSWander(), PM_AdjustAngleForWallJump(), PM_AdjustAngleForWallRun(), and PM_AdjustAngleForWallRunUp(). { float yaw; if (vec[YAW] == 0 && vec[PITCH] == 0) { yaw = 0; } else { if (vec[PITCH]) { yaw = ( atan2( vec[YAW], vec[PITCH]) * 180 / M_PI ); } else if (vec[YAW] > 0) { yaw = 90; } else { yaw = 270; } if (yaw < 0) { yaw += 360; } } return yaw; }

---

Variable Documentation

const char* bg_customSiegeSoundNames[MAX_CUSTOM_SIEGE_SOUNDS]

Definition at line 113 of file bg_misc.c. Referenced by CG_CustomSound(), CG_GetStringForVoiceSound(), CG_LoadCISounds(), and G_InitGame().

gitem_t bg_itemlist[]

Definition at line 795 of file bg_misc.c. Referenced by BG_CanItemBeGrabbed(), BG_CycleInven(), BG_FindItem(), BG_FindItemForAmmo(), BG_FindItemForHoldable(), BG_FindItemForPowerup(), BG_FindItemForWeapon(), BG_GetItemIndexByTag(), CG_DrawInvenSelect(), CG_EntityEvent(), CG_Init(), CG_InitG2Weapons(), CG_LoadingItem(), CG_NextInventory_f(), CG_PrevInventory_f(), CG_RegisterItemVisuals(), CG_RegisterWeapon(), EWebDie(), FinishSpawningItem(), G_CallSpawn(), G_CheckTeamItems(), G_DriveATST(), G_ItemUsable(), G_SpecialSpawnItem(), LaunchItem(), NPC_PrecacheWeapons(), Pickup_Holdable(), PM_ItemUsable(), RegisterItem(), TossClientWeapon(), and TryUse().

int bg_numItems = sizeof(bg_itemlist) / sizeof(bg_itemlist[0]) - 1

Definition at line 1771 of file bg_misc.c. Referenced by BG_CanItemBeGrabbed(), BG_FindItemForHoldable(), BG_FindItemForPowerup(), BG_GetItemIndexByTag(), CG_EntityEvent(), CG_Init(), CG_RegisterItemVisuals(), and SaveRegisteredItems().

int bgForcePowerCost[NUM_FORCE_POWERS][NUM_FORCE_POWER_LEVELS]

Initial value: { { 0, 2, 4, 6 }, { 0, 0, 2, 6 }, { 0, 2, 4, 6 }, { 0, 1, 3, 6 }, { 0, 1, 3, 6 }, { 0, 4, 6, 8 }, { 0, 1, 3, 6 }, { 0, 2, 5, 8 }, { 0, 4, 6, 8 }, { 0, 2, 5, 8 }, { 0, 1, 3, 6 }, { 0, 1, 3, 6 }, { 0, 1, 3, 6 }, { 0, 2, 4, 6 }, { 0, 2, 5, 8 }, { 0, 1, 5, 8 }, { 0, 1, 5, 8 }, { 0, 4, 6, 8 } } Definition at line 174 of file bg_misc.c. Referenced by _UI_Refresh(), BG_LegalizedForcePowers(), UI_DrawForceStars(), UI_ForceConfigHandle(), UI_ForcePowerRank_HandleKey(), UI_ReadLegalForce(), and UpdateForceUsed().

const int bgToggleableSurfaceDebris[BG_NUM_TOGGLEABLE_SURFACES]

Definition at line 78 of file bg_misc.c. Referenced by CG_G2Animated().

const char* bgToggleableSurfaces[BG_NUM_TOGGLEABLE_SURFACES]

Definition at line 34 of file bg_misc.c. Referenced by CG_G2Animated(), and NPC_SetSurfaceOnOff().

char* eventnames[]

Definition at line 2464 of file bg_misc.c. Referenced by BG_AddPredictableEventToPlayerstate().

char* forceMasteryLevels[NUM_FORCE_MASTERY_LEVELS]

Initial value: { "MASTERY0", "MASTERY1", "MASTERY2", "MASTERY3", "MASTERY4", "MASTERY5", "MASTERY6", "MASTERY7", } Definition at line 150 of file bg_misc.c. Referenced by CG_DrawInformation().

int forceMasteryPoints[NUM_FORCE_MASTERY_LEVELS]

Initial value: { 0, 5, 10, 20, 30, 50, 75, 100 } Definition at line 162 of file bg_misc.c. Referenced by BG_LegalizedForcePowers(), UI_ForceConfigHandle(), UI_ReadLegalForce(), and UpdateForceUsed().

int forcePowerDarkLight[NUM_FORCE_POWERS]

Initial value: { FORCE_LIGHTSIDE, 0, 0, 0, 0, FORCE_LIGHTSIDE, FORCE_DARKSIDE, FORCE_DARKSIDE, FORCE_DARKSIDE, FORCE_LIGHTSIDE, FORCE_LIGHTSIDE, FORCE_LIGHTSIDE, FORCE_DARKSIDE, FORCE_DARKSIDE, 0, 0, 0, 0 } Definition at line 219 of file bg_misc.c. Referenced by BG_LegalizedForcePowers(), CG_Player(), SP_misc_holocron(), and WP_ForcePowersUpdate().

int forcePowerSorted[NUM_FORCE_POWERS]

Initial value: { FP_TELEPATHY, FP_HEAL, FP_ABSORB, FP_PROTECT, FP_TEAM_HEAL, FP_LEVITATION, FP_SPEED, FP_PUSH, FP_PULL, FP_SEE, FP_LIGHTNING, FP_DRAIN, FP_RAGE, FP_GRIP, FP_TEAM_FORCE, FP_SABER_OFFENSE, FP_SABER_DEFENSE, FP_SABERTHROW } Definition at line 197 of file bg_misc.c. Referenced by BG_CycleForce(), BG_ProperForceIndex(), CG_DrawForceSelect(), and vmMain().

int WeaponAttackAnim[WP_NUM_WEAPONS]

Initial value: { BOTH_ATTACK1, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_STAND2, BOTH_ATTACK2, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_THERMAL_THROW, BOTH_ATTACK3, BOTH_ATTACK3, BOTH_ATTACK2, BOTH_STAND1, BOTH_ATTACK1 } Definition at line 294 of file bg_misc.c.

int WeaponReadyAnim[WP_NUM_WEAPONS]

Initial value: { TORSO_DROPWEAP1, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, BOTH_STAND2, TORSO_WEAPONREADY2, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, TORSO_WEAPONREADY3, TORSO_WEAPONREADY10, TORSO_WEAPONREADY10, TORSO_WEAPONREADY10, TORSO_WEAPONREADY3, TORSO_WEAPONREADY2, BOTH_STAND1, TORSO_WEAPONREADY1 } Definition at line 242 of file bg_misc.c. Referenced by BG_G2PlayerAngles(), and ClientSpawn().

int WeaponReadyLegsAnim[WP_NUM_WEAPONS]

Initial value: { BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND2, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1, BOTH_STAND1 } Definition at line 268 of file bg_misc.c.