codemp/cgame/cg_local.h File Reference

#include "../game/q_shared.h"
#include "tr_types.h"
#include "../game/bg_public.h"
#include "cg_public.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Data Structures
struct	centity_s
struct	cg_t
struct	cgEffects_t
struct	cgLoopSound_s
struct	cgMedia_t
struct	cgs_t
struct	cgscreffects_s
struct	chatBoxItem_s
struct	clientInfo_t
struct	forceTicPos_s
struct	itemInfo_t
struct	lerpFrame_t
struct	localEntity_s
struct	markPoly_s
struct	playerEntity_t
struct	powerupInfo_t
struct	score_t
struct	siegeExtended_s
struct	skulltrail_t
struct	weaponInfo_s
Defines
#define	CGAME_INLINE   ID_INLINE
#define	NULL_HANDLE   ((qhandle_t) 0)
#define	NULL_SOUND   ((sfxHandle_t) 0)
#define	NULL_FX   ((fxHandle_t) 0)
#define	POWERUP_BLINKS   5
#define	POWERUP_BLINK_TIME   1000
#define	FADE_TIME   200
#define	PULSE_TIME   200
#define	DAMAGE_DEFLECT_TIME   100
#define	DAMAGE_RETURN_TIME   400
#define	DAMAGE_TIME   500
#define	LAND_DEFLECT_TIME   150
#define	LAND_RETURN_TIME   300
#define	STEP_TIME   200
#define	DUCK_TIME   100
#define	PAIN_TWITCH_TIME   200
#define	WEAPON_SELECT_TIME   1400
#define	ITEM_SCALEUP_TIME   1000
#define	ZOOM_TIME   150
#define	MAX_ZOOM_FOV   3.0f
#define	ZOOM_IN_TIME   1500.0f
#define	ZOOM_OUT_TIME   100.0f
#define	ZOOM_START_PERCENT   0.3f
#define	ITEM_BLOB_TIME   200
#define	MUZZLE_FLASH_TIME   20
#define	SINK_TIME   1000
#define	ATTACKER_HEAD_TIME   10000
#define	REWARD_TIME   3000
#define	PULSE_SCALE   1.5
#define	MAX_STEP_CHANGE   32
#define	MAX_VERTS_ON_POLY   10
#define	MAX_MARK_POLYS   256
#define	STAT_MINUS   10
#define	ICON_SIZE   48
#define	CHAR_WIDTH   32
#define	CHAR_HEIGHT   48
#define	TEXT_ICON_SPACE   4
#define	GIANT_WIDTH   32
#define	GIANT_HEIGHT   48
#define	NUM_FONT_BIG   1
#define	NUM_FONT_SMALL   2
#define	NUM_FONT_CHUNKY   3
#define	NUM_CROSSHAIRS   9
#define	TEAM_OVERLAY_MAXNAME_WIDTH   32
#define	TEAM_OVERLAY_MAXLOCATION_WIDTH   64
#define	WAVE_AMPLITUDE   1
#define	WAVE_FREQUENCY   0.4
#define	DEFAULT_MODEL   "kyle"
#define	DEFAULT_FORCEPOWERS   "5-1-000000000000000000"
#define	DEFAULT_REDTEAM_NAME   "Empire"
#define	DEFAULT_BLUETEAM_NAME   "Rebellion"
#define	MAX_CUSTOM_COMBAT_SOUNDS   40
#define	MAX_CUSTOM_EXTRA_SOUNDS   40
#define	MAX_CUSTOM_JEDI_SOUNDS   40
#define	MAX_CUSTOM_DUEL_SOUNDS   40
#define	MAX_CUSTOM_SOUNDS   40
#define	MAX_CG_LOOPSOUNDS   8
#define	MAX_SKULLTRAIL   10
#define	MAX_REWARDSTACK   10
#define	MAX_SOUNDBUFFER   20
#define	MAX_PREDICTED_EVENTS   16
#define	MAX_CHATBOX_ITEMS   5
#define	MAX_TICS   14
#define	NUM_CHUNK_MODELS   4
Typedefs
typedef cgLoopSound_s	cgLoopSound_t
typedef centity_s	centity_t
typedef markPoly_s	markPoly_t
typedef localEntity_s	localEntity_t
typedef weaponInfo_s	weaponInfo_t
typedef chatBoxItem_s	chatBoxItem_t
typedef forceTicPos_s	forceTicPos_t
typedef cgscreffects_s	cgscreffects_t
typedef siegeExtended_s	siegeExtended_t
Enumerations
enum	footstep_t {   FOOTSTEP_STONEWALK, FOOTSTEP_STONERUN, FOOTSTEP_METALWALK, FOOTSTEP_METALRUN,   FOOTSTEP_PIPEWALK, FOOTSTEP_PIPERUN, FOOTSTEP_SPLASH, FOOTSTEP_WADE,   FOOTSTEP_SWIM, FOOTSTEP_SNOWWALK, FOOTSTEP_SNOWRUN, FOOTSTEP_SANDWALK,   FOOTSTEP_SANDRUN, FOOTSTEP_GRASSWALK, FOOTSTEP_GRASSRUN, FOOTSTEP_DIRTWALK,   FOOTSTEP_DIRTRUN, FOOTSTEP_MUDWALK, FOOTSTEP_MUDRUN, FOOTSTEP_GRAVELWALK,   FOOTSTEP_GRAVELRUN, FOOTSTEP_RUGWALK, FOOTSTEP_RUGRUN, FOOTSTEP_WOODWALK,   FOOTSTEP_WOODRUN, FOOTSTEP_TOTAL }
enum	impactSound_t { IMPACTSOUND_DEFAULT, IMPACTSOUND_METAL, IMPACTSOUND_FLESH }
enum	leType_t {   LE_MARK, LE_EXPLOSION, LE_SPRITE_EXPLOSION, LE_FADE_SCALE_MODEL,   LE_FRAGMENT, LE_PUFF, LE_MOVE_SCALE_FADE, LE_FALL_SCALE_FADE,   LE_FADE_RGB, LE_SCALE_FADE, LE_SCOREPLUM, LE_OLINE,   LE_SHOWREFENTITY, LE_LINE }
enum	leFlag_t { LEF_PUFF_DONT_SCALE = 0x0001, LEF_TUMBLE = 0x0002, LEF_FADE_RGB = 0x0004, LEF_NO_RANDOM_ROTATE = 0x0008 }
enum	leMarkType_t { LEMT_NONE, LEMT_BURN, LEMT_BLOOD }
enum	leBounceSoundType_t {   LEBS_NONE, LEBS_BLOOD, LEBS_BRASS, LEBS_METAL,   LEBS_ROCK }
enum	{   CHUNK_METAL1 = 0, CHUNK_METAL2, CHUNK_ROCK1, CHUNK_ROCK2,   CHUNK_ROCK3, CHUNK_CRATE1, CHUNK_CRATE2, CHUNK_WHITE_METAL,   NUM_CHUNK_TYPES }
enum	q3print_t { SYSTEM_PRINT, CHAT_PRINT, TEAMCHAT_PRINT }
Functions
void	CGCam_Shake (float intensity, int duration)
void	CGCam_SetMusicMult (float multiplier, int duration)
void	CG_DrawMiscEnts (void)
const char *	CG_ConfigString (int index)
const char *	CG_Argv (int arg)
void QDECL	CG_Printf (const char *msg,...)
void QDECL	CG_Error (const char *msg,...)
void	CG_StartMusic (qboolean bForceStart)
void	CG_UpdateCvars (void)
int	CG_CrosshairPlayer (void)
int	CG_LastAttacker (void)
void	CG_LoadMenus (const char *menuFile)
void	CG_KeyEvent (int key, qboolean down)
void	CG_MouseEvent (int x, int y)
void	CG_EventHandling (int type)
void	CG_RankRunFrame (void)
void	CG_SetScoreSelection (void *menu)
void	CG_BuildSpectatorString (void)
void	CG_NextInventory_f (void)
void	CG_PrevInventory_f (void)
void	CG_NextForcePower_f (void)
void	CG_PrevForcePower_f (void)
void	CG_TestModel_f (void)
void	CG_TestGun_f (void)
void	CG_TestModelNextFrame_f (void)
void	CG_TestModelPrevFrame_f (void)
void	CG_TestModelNextSkin_f (void)
void	CG_TestModelPrevSkin_f (void)
void	CG_ZoomDown_f (void)
void	CG_ZoomUp_f (void)
void	CG_AddBufferedSound (sfxHandle_t sfx)
void	CG_DrawActiveFrame (int serverTime, stereoFrame_t stereoView, qboolean demoPlayback)
void	CG_TestG2Model_f (void)
void	CG_TestModelSurfaceOnOff_f (void)
void	CG_ListModelSurfaces_f (void)
void	CG_ListModelBones_f (void)
void	CG_TestModelSetAnglespre_f (void)
void	CG_TestModelSetAnglespost_f (void)
void	CG_TestModelAnimate_f (void)
void	CG_FillRect (float x, float y, float width, float height, const float *color)
void	CG_DrawPic (float x, float y, float width, float height, qhandle_t hShader)
void	CG_DrawRotatePic (float x, float y, float width, float height, float angle, qhandle_t hShader)
void	CG_DrawRotatePic2 (float x, float y, float width, float height, float angle, qhandle_t hShader)
void	CG_DrawString (float x, float y, const char *string, float charWidth, float charHeight, const float *modulate)
void	CG_DrawNumField (int x, int y, int width, int value, int charWidth, int charHeight, int style, qboolean zeroFill)
void	CG_DrawStringExt (int x, int y, const char *string, const float *setColor, qboolean forceColor, qboolean shadow, int charWidth, int charHeight, int maxChars)
void	CG_DrawBigString (int x, int y, const char *s, float alpha)
void	CG_DrawBigStringColor (int x, int y, const char *s, vec4_t color)
void	CG_DrawSmallString (int x, int y, const char *s, float alpha)
void	CG_DrawSmallStringColor (int x, int y, const char *s, vec4_t color)
int	CG_DrawStrlen (const char *str)
float *	CG_FadeColor (int startMsec, int totalMsec)
float *	CG_TeamColor (int team)
void	CG_TileClear (void)
void	CG_ColorForHealth (vec4_t hcolor)
void	CG_GetColorForHealth (int health, int armor, vec4_t hcolor)
void	UI_DrawProportionalString (int x, int y, const char *str, int style, vec4_t color)
void	UI_DrawScaledProportionalString (int x, int y, const char *str, int style, vec4_t color, float scale)
void	CG_DrawRect (float x, float y, float width, float height, float size, const float *color)
void	CG_DrawSides (float x, float y, float w, float h, float size)
void	CG_DrawTopBottom (float x, float y, float w, float h, float size)
void	CG_AddLagometerFrameInfo (void)
void	CG_AddLagometerSnapshotInfo (snapshot_t *snap)
void	CG_CenterPrint (const char *str, int y, int charWidth)
void	CG_DrawHead (float x, float y, float w, float h, int clientNum, vec3_t headAngles)
void	CG_DrawActive (stereoFrame_t stereoView)
void	CG_DrawFlagModel (float x, float y, float w, float h, int team, qboolean force2D)
void	CG_DrawTeamBackground (int x, int y, int w, int h, float alpha, int team)
void	CG_OwnerDraw (float x, float y, float w, float h, float text_x, float text_y, int ownerDraw, int ownerDrawFlags, int align, float special, float scale, vec4_t color, qhandle_t shader, int textStyle, int font)
void	CG_Text_Paint (float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style, int iMenuFont)
int	CG_Text_Width (const char *text, float scale, int iMenuFont)
int	CG_Text_Height (const char *text, float scale, int iMenuFont)
float	CG_GetValue (int ownerDraw)
qboolean	CG_OwnerDrawVisible (int flags)
void	CG_RunMenuScript (char **args)
qboolean	CG_DeferMenuScript (char **args)
void	CG_ShowResponseHead (void)
void	CG_GetTeamColor (vec4_t *color)
const char *	CG_GetGameStatusText (void)
const char *	CG_GetKillerText (void)
void	CG_Draw3DModel (float x, float y, float w, float h, qhandle_t model, void *ghoul2, int g2radius, qhandle_t skin, vec3_t origin, vec3_t angles)
void	CG_Text_PaintChar (float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader)
const char *	CG_GameTypeString (void)
qboolean	CG_YourTeamHasFlag (void)
qboolean	CG_OtherTeamHasFlag (void)
qhandle_t	CG_StatusHandle (int task)
qboolean	CG_RagDoll (centity_t *cent, vec3_t forcedAngles)
qboolean	CG_G2TraceCollide (trace_t *tr, const vec3_t mins, const vec3_t maxs, const vec3_t lastValidStart, const vec3_t lastValidEnd)
void	CG_AddGhoul2Mark (int shader, float size, vec3_t start, vec3_t end, int entnum, vec3_t entposition, float entangle, void *ghoul2, vec3_t scale, int lifeTime)
void	CG_CreateNPCClient (clientInfo_t **ci)
void	CG_DestroyNPCClient (clientInfo_t **ci)
void	CG_Player (centity_t *cent)
void	CG_ResetPlayerEntity (centity_t *cent)
void	CG_AddRefEntityWithPowerups (refEntity_t *ent, entityState_t *state, int team)
void	CG_NewClientInfo (int clientNum, qboolean entitiesInitialized)
sfxHandle_t	CG_CustomSound (int clientNum, const char *soundName)
void	CG_PlayerShieldHit (int entitynum, vec3_t angles, int amount)
void	CG_BuildSolidList (void)
int	CG_PointContents (const vec3_t point, int passEntityNum)
void	CG_Trace (trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int skipNumber, int mask)
void	CG_G2Trace (trace_t *result, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int skipNumber, int mask)
void	CG_PredictPlayerState (void)
void	CG_LoadDeferredPlayers (void)
void	CG_CheckEvents (centity_t *cent)
const char *	CG_PlaceString (int rank)
void	CG_EntityEvent (centity_t *cent, vec3_t position)
void	CG_PainEvent (centity_t *cent, int health)
void	CG_ReattachLimb (centity_t *source)
void	CG_S_AddLoopingSound (int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
void	CG_S_AddRealLoopingSound (int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
void	CG_S_StopLoopingSound (int entityNum, sfxHandle_t sfx)
void	CG_S_UpdateLoopingSounds (int entityNum)
void	CG_SetEntitySoundPosition (centity_t *cent)
void	CG_AddPacketEntities (qboolean isPortal)
void	CG_ManualEntityRender (centity_t *cent)
void	CG_Beam (centity_t *cent)
void	CG_AdjustPositionForMover (const vec3_t in, int moverNum, int fromTime, int toTime, vec3_t out)
void	CG_PositionEntityOnTag (refEntity_t *entity, const refEntity_t *parent, qhandle_t parentModel, char *tagName)
void	CG_PositionRotatedEntityOnTag (refEntity_t *entity, const refEntity_t *parent, qhandle_t parentModel, char *tagName)
void	ScaleModelAxis (refEntity_t *ent)
void	TurretClientRun (centity_t *ent)
void	CG_GetClientWeaponMuzzleBoltPoint (int clIndex, vec3_t to)
void	CG_NextWeapon_f (void)
void	CG_PrevWeapon_f (void)
void	CG_Weapon_f (void)
void	CG_WeaponClean_f (void)
void	CG_RegisterWeapon (int weaponNum)
void	CG_RegisterItemVisuals (int itemNum)
void	CG_FireWeapon (centity_t *cent, qboolean alt_fire)
void	CG_MissileHitWall (int weapon, int clientNum, vec3_t origin, vec3_t dir, impactSound_t soundType, qboolean alt_fire, int charge)
void	CG_MissileHitPlayer (int weapon, vec3_t origin, vec3_t dir, int entityNum, qboolean alt_fire)
void	CG_AddViewWeapon (playerState_t *ps)
void	CG_AddPlayerWeapon (refEntity_t *parent, playerState_t *ps, centity_t *cent, int team, vec3_t newAngles, qboolean thirdPerson)
void	CG_DrawWeaponSelect (void)
void	CG_DrawIconBackground (void)
void	CG_OutOfAmmoChange (int oldWeapon)
void	CG_InitMarkPolys (void)
void	CG_AddMarks (void)
void	CG_ImpactMark (qhandle_t markShader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary)
void	CG_InitLocalEntities (void)
localEntity_t *	CG_AllocLocalEntity (void)
void	CG_AddLocalEntities (void)
localEntity_t *	CG_SmokePuff (const vec3_t p, const vec3_t vel, float radius, float r, float g, float b, float a, float duration, int startTime, int fadeInTime, int leFlags, qhandle_t hShader)
void	CG_BubbleTrail (vec3_t start, vec3_t end, float spacing)
void	CG_GlassShatter (int entnum, vec3_t dmgPt, vec3_t dmgDir, float dmgRadius, int maxShards)
void	CG_ScorePlum (int client, vec3_t org, int score)
void	CG_Chunks (int owner, vec3_t origin, const vec3_t normal, const vec3_t mins, const vec3_t maxs, float speed, int numChunks, material_t chunkType, int customChunk, float baseScale)
void	CG_MiscModelExplosion (vec3_t mins, vec3_t maxs, int size, material_t chunkType)
void	CG_Bleed (vec3_t origin, int entityNum)
localEntity_t *	CG_MakeExplosion (vec3_t origin, vec3_t dir, qhandle_t hModel, int numframes, qhandle_t shader, int msec, qboolean isSprite, float scale, int flags)
void	CG_SurfaceExplosion (vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke)
void	CG_TestLine (vec3_t start, vec3_t end, int time, unsigned int color, int radius)
void	CG_InitGlass (void)
void	CG_ProcessSnapshots (void)
void	CG_LoadingString (const char *s)
void	CG_LoadingItem (int itemNum)
void	CG_LoadingClient (int clientNum)
void	CG_DrawInformation (void)
qboolean	CG_DrawOldScoreboard (void)
void	CG_DrawOldTourneyScoreboard (void)
qboolean	CG_ConsoleCommand (void)
void	CG_InitConsoleCommands (void)
void	CG_ExecuteNewServerCommands (int latestSequence)
void	CG_ParseServerinfo (void)
void	CG_SetConfigValues (void)
void	CG_ShaderStateChanged (void)
int	CG_IsMindTricked (int trickIndex1, int trickIndex2, int trickIndex3, int trickIndex4, int client)
void	CG_Respawn (void)
void	CG_TransitionPlayerState (playerState_t *ps, playerState_t *ops)
void	CG_CheckChangedPredictableEvents (playerState_t *ps)
void	CG_InitSiegeMode (void)
void	CG_SiegeRoundOver (centity_t *ent, int won)
void	CG_SiegeObjectiveCompleted (centity_t *ent, int won, int objectivenum)
void	trap_Print (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)
void	trap_Cvar_Register (vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags)
void	trap_Cvar_Update (vmCvar_t *vmCvar)
void	trap_Cvar_Set (const char *var_name, const char *value)
void	trap_Cvar_VariableStringBuffer (const char *var_name, char *buffer, int bufsize)
int	trap_Cvar_GetHiddenVarValue (const char *name)
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 (const char *text)
void	trap_AddCommand (const char *cmdName)
void	trap_SendClientCommand (const char *s)
void	trap_UpdateScreen (void)
void	trap_CM_LoadMap (const char *mapname, qboolean SubBSP)
int	trap_CM_NumInlineModels (void)
clipHandle_t	trap_CM_InlineModel (int index)
clipHandle_t	trap_CM_TempBoxModel (const vec3_t mins, const vec3_t maxs)
int	trap_CM_PointContents (const vec3_t p, clipHandle_t model)
int	trap_CM_TransformedPointContents (const vec3_t p, clipHandle_t model, const vec3_t origin, const vec3_t angles)
void	trap_CM_BoxTrace (trace_t *results, const vec3_t start, const vec3_t end, const vec3_t mins, const vec3_t maxs, clipHandle_t model, int brushmask)
void	trap_CM_TransformedBoxTrace (trace_t *results, const vec3_t start, const vec3_t end, const vec3_t mins, const vec3_t maxs, clipHandle_t model, int brushmask, const vec3_t origin, const vec3_t angles)
int	trap_CM_MarkFragments (int numPoints, const vec3_t *points, const vec3_t projection, int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer)
int	trap_S_GetVoiceVolume (int entityNum)
void	trap_S_MuteSound (int entityNum, int entchannel)
void	trap_S_StartSound (vec3_t origin, int entityNum, int entchannel, sfxHandle_t sfx)
void	trap_S_StopLoopingSound (int entnum)
void	trap_S_StartLocalSound (sfxHandle_t sfx, int channelNum)
void	trap_S_ClearLoopingSounds (void)
void	trap_S_AddLoopingSound (int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
void	trap_S_AddRealLoopingSound (int entityNum, const vec3_t origin, const vec3_t velocity, sfxHandle_t sfx)
void	trap_S_UpdateEntityPosition (int entityNum, const vec3_t origin)
void	trap_S_Respatialize (int entityNum, const vec3_t origin, vec3_t axis[3], int inwater)
void	trap_S_ShutUp (qboolean shutUpFactor)
sfxHandle_t	trap_S_RegisterSound (const char *sample)
void	trap_S_StartBackgroundTrack (const char *intro, const char *loop, qboolean bReturnWithoutStarting)
void	trap_S_StopBackgroundTrack (void)
void	trap_S_UpdateAmbientSet (const char *name, vec3_t origin)
void	trap_AS_ParseSets (void)
void	trap_AS_AddPrecacheEntry (const char *name)
int	trap_S_AddLocalSet (const char *name, vec3_t listener_origin, vec3_t origin, int entID, int time)
sfxHandle_t	trap_AS_GetBModelSound (const char *name, int stage)
void	trap_R_LoadWorldMap (const char *mapname)
qhandle_t	trap_R_RegisterModel (const char *name)
qhandle_t	trap_R_RegisterSkin (const char *name)
qhandle_t	trap_R_RegisterShader (const char *name)
qhandle_t	trap_R_RegisterShaderNoMip (const char *name)
qhandle_t	trap_R_RegisterFont (const char *name)
int	trap_R_Font_StrLenPixels (const char *text, const int iFontIndex, const float scale)
int	trap_R_Font_StrLenChars (const char *text)
int	trap_R_Font_HeightPixels (const int iFontIndex, const float scale)
void	trap_R_Font_DrawString (int ox, int oy, const char *text, const float *rgba, const int setIndex, int iCharLimit, const float scale)
qboolean	trap_Language_IsAsian (void)
qboolean	trap_Language_UsesSpaces (void)
unsigned	trap_AnyLanguage_ReadCharFromString (const char *psText, int *piAdvanceCount, qboolean *pbIsTrailingPunctuation)
void	trap_R_ClearScene (void)
void	trap_R_ClearDecals (void)
void	trap_R_AddRefEntityToScene (const refEntity_t *re)
void	trap_R_AddPolyToScene (qhandle_t hShader, int numVerts, const polyVert_t *verts)
void	trap_R_AddPolysToScene (qhandle_t hShader, int numVerts, const polyVert_t *verts, int numPolys)
void	trap_R_AddDecalToScene (qhandle_t shader, const vec3_t origin, const vec3_t dir, float orientation, float r, float g, float b, float a, qboolean alphaFade, float radius, qboolean temporary)
void	trap_R_AddLightToScene (const vec3_t org, float intensity, float r, float g, float b)
int	trap_R_LightForPoint (vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir)
void	trap_R_RenderScene (const refdef_t *fd)
void	trap_R_SetColor (const float *rgba)
void	trap_R_DrawStretchPic (float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader)
void	trap_R_ModelBounds (clipHandle_t model, vec3_t mins, vec3_t maxs)
int	trap_R_LerpTag (orientation_t *tag, clipHandle_t mod, int startFrame, int endFrame, float frac, const char *tagName)
void	trap_R_DrawRotatePic (float x, float y, float w, float h, float s1, float t1, float s2, float t2, float a, qhandle_t hShader)
void	trap_R_DrawRotatePic2 (float x, float y, float w, float h, float s1, float t1, float s2, float t2, float a, qhandle_t hShader)
void	trap_R_SetRangeFog (float range)
void	trap_R_SetRefractProp (float alpha, float stretch, qboolean prepost, qboolean negate)
void	trap_R_RemapShader (const char *oldShader, const char *newShader, const char *timeOffset)
void	trap_R_GetLightStyle (int style, color4ub_t color)
void	trap_R_SetLightStyle (int style, int color)
void	trap_R_GetBModelVerts (int bmodelIndex, vec3_t *verts, vec3_t normal)
void	trap_R_GetDistanceCull (float *f)
void	trap_R_GetRealRes (int *w, int *h)
void	trap_R_AutomapElevAdj (float newHeight)
qboolean	trap_R_InitWireframeAutomap (void)
void	trap_FX_AddLine (const vec3_t start, const vec3_t end, float size1, float size2, float sizeParm, float alpha1, float alpha2, float alphaParm, const vec3_t sRGB, const vec3_t eRGB, float rgbParm, int killTime, qhandle_t shader, int flags)
void	trap_GetGlconfig (glconfig_t *glconfig)
void	trap_GetGameState (gameState_t *gamestate)
void	trap_GetCurrentSnapshotNumber (int *snapshotNumber, int *serverTime)
qboolean	trap_GetSnapshot (int snapshotNumber, snapshot_t *snapshot)
qboolean	trap_GetDefaultState (int entityIndex, entityState_t *state)
qboolean	trap_GetServerCommand (int serverCommandNumber)
int	trap_GetCurrentCmdNumber (void)
qboolean	trap_GetUserCmd (int cmdNumber, usercmd_t *ucmd)
void	trap_SetUserCmdValue (int stateValue, float sensitivityScale, float mPitchOverride, float mYawOverride, float mSensitivityOverride, int fpSel, int invenSel, qboolean fighterControls)
void	trap_SetClientForceAngle (int time, vec3_t angle)
void	trap_SetClientTurnExtent (float turnAdd, float turnSub, int turnTime)
void	trap_OpenUIMenu (int menuID)
void	testPrintInt (char *string, int i)
void	testPrintFloat (char *string, float f)
int	trap_MemoryRemaining (void)
qboolean	trap_Key_IsDown (int keynum)
int	trap_Key_GetCatcher (void)
void	trap_Key_SetCatcher (int catcher)
int	trap_Key_GetKey (const char *binding)
void	BG_CycleInven (playerState_t *ps, int direction)
int	BG_ProperForceIndex (int power)
void	BG_CycleForce (playerState_t *ps, int direction)
int	trap_CIN_PlayCinematic (const char *arg0, int xpos, int ypos, int width, int height, int bits)
e_status	trap_CIN_StopCinematic (int handle)
e_status	trap_CIN_RunCinematic (int handle)
void	trap_CIN_DrawCinematic (int handle)
void	trap_CIN_SetExtents (int handle, int x, int y, int w, int h)
void	trap_SnapVector (float *v)
qboolean	trap_loadCamera (const char *name)
void	trap_startCamera (int time)
qboolean	trap_getCameraInfo (int time, vec3_t *origin, vec3_t *angles)
qboolean	trap_GetEntityToken (char *buffer, int bufferSize)
qboolean	trap_R_inPVS (const vec3_t p1, const vec3_t p2, byte *mask)
int	trap_FX_InitSystem (refdef_t *)
void	trap_FX_SetRefDef (refdef_t *refdef)
int	trap_FX_RegisterEffect (const char *file)
void	trap_FX_PlayEffect (const char *file, vec3_t org, vec3_t fwd, int vol, int rad)
void	trap_FX_PlayEntityEffect (const char *file, vec3_t org, vec3_t axis[3], const int boltInfo, const int entNum, int vol, int rad)
void	trap_FX_PlayEffectID (int id, vec3_t org, vec3_t fwd, int vol, int rad)
void	trap_FX_PlayPortalEffectID (int id, vec3_t org, vec3_t fwd, int vol, int rad)
void	trap_FX_PlayEntityEffectID (int id, vec3_t org, vec3_t axis[3], const int boltInfo, const int pGhoul2, int vol, int rad)
void	trap_FX_PlayBoltedEffectID (int id, vec3_t org, void *pGhoul2, const int boltNum, const int entNum, const int modelNum, int iLooptime, qboolean isRelative)
void	trap_FX_AddScheduledEffects (qboolean skyPortal)
void	trap_FX_Draw2DEffects (float screenXScale, float screenYScale)
qboolean	trap_FX_FreeSystem (void)
void	trap_FX_AdjustTime (int time)
void	trap_FX_Reset (void)
void	trap_FX_AddPoly (addpolyArgStruct_t *p)
void	trap_FX_AddBezier (addbezierArgStruct_t *p)
void	trap_FX_AddPrimitive (effectTrailArgStruct_t *p)
void	trap_FX_AddSprite (addspriteArgStruct_t *p)
void	trap_FX_AddElectricity (addElectricityArgStruct_t *p)
int	trap_SP_GetStringTextString (const char *text, char *buffer, int bufferLength)
void	trap_CG_RegisterSharedMemory (char *memory)
int	trap_CM_RegisterTerrain (const char *config)
void	trap_RMG_Init (int terrainID, const char *terrainInfo)
void	trap_RE_InitRendererTerrain (const char *info)
void	trap_R_WeatherContentsOverride (int contents)
void	trap_R_WorldEffectCommand (const char *cmd)
void	trap_WE_AddWeatherZone (const vec3_t mins, const vec3_t maxs)
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)
void	trap_TrueMalloc (void **ptr, int size)
void	trap_TrueFree (void **ptr)
void	CG_ClearParticles (void)
void	CG_AddParticles (void)
void	CG_ParticleSnow (qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum)
void	CG_ParticleSmoke (qhandle_t pshader, centity_t *cent)
void	CG_AddParticleShrapnel (localEntity_t *le)
void	CG_ParticleSnowFlurry (qhandle_t pshader, centity_t *cent)
void	CG_ParticleBulletDebris (vec3_t org, vec3_t vel, int duration)
void	CG_ParticleSparks (vec3_t org, vec3_t vel, int duration, float x, float y, float speed)
void	CG_ParticleDust (centity_t *cent, vec3_t origin, vec3_t dir)
void	CG_ParticleMisc (qhandle_t pshader, vec3_t origin, int size, int duration, float alpha)
void	CG_ParticleExplosion (char *animStr, vec3_t origin, vec3_t vel, int duration, int sizeStart, int sizeEnd)
const char *	CG_GetStringEdString (char *refSection, char *refName)
int	CG_NewParticleArea (int num)
void	FX_TurretProjectileThink (centity_t *cent, const struct weaponInfo_s *weapon)
void	FX_TurretHitWall (vec3_t origin, vec3_t normal)
void	FX_TurretHitPlayer (vec3_t origin, vec3_t normal, qboolean humanoid)
void	FX_ConcussionHitWall (vec3_t origin, vec3_t normal)
void	FX_ConcussionHitPlayer (vec3_t origin, vec3_t normal, qboolean humanoid)
void	FX_ConcussionProjectileThink (centity_t *cent, const struct weaponInfo_s *weapon)
void	FX_ConcAltShot (vec3_t start, vec3_t end)
void	CG_Spark (vec3_t origin, vec3_t dir)
void	FX_BryarHitWall (vec3_t origin, vec3_t normal)
void	FX_BryarAltHitWall (vec3_t origin, vec3_t normal, int power)
void	FX_BryarHitPlayer (vec3_t origin, vec3_t normal, qboolean humanoid)
void	FX_BryarAltHitPlayer (vec3_t origin, vec3_t normal, qboolean humanoid)
void	FX_BlasterProjectileThink (centity_t *cent, const struct weaponInfo_s *weapon)
void	FX_BlasterAltFireThink (centity_t *cent, const struct weaponInfo_s *weapon)
void	FX_BlasterWeaponHitWall (vec3_t origin, vec3_t normal)
void	FX_BlasterWeaponHitPlayer (vec3_t origin, vec3_t normal, qboolean humanoid)
void	FX_ForceDrained (vec3_t origin, vec3_t dir)
void	trap_G2API_CollisionDetect (CollisionRecord_t *collRecMap, void *ghoul2, const vec3_t angles, const vec3_t position, int frameNumber, int entNum, const vec3_t rayStart, const vec3_t rayEnd, const 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, const vec3_t rayStart, const vec3_t rayEnd, const vec3_t scale, int traceFlags, int useLod, float fRadius)
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_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_SkinlessModel (void *ghlInfo, int modelIndex)
int	trap_G2API_GetNumGoreMarks (void *ghlInfo, int modelIndex)
void	trap_G2API_AddSkinGore (void *ghlInfo, SSkinGoreData *gore)
void	trap_G2API_ClearSkinGore (void *ghlInfo)
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)
qboolean	trap_G2API_AttachEnt (int *boltInfo, void *ghlInfoTo, int toBoltIndex, int entNum, int toModelNum)
void	trap_G2API_CleanGhoul2Models (void **ghoul2Ptr)
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)
qboolean	trap_G2API_GetBoneFrame (void *ghoul2, const char *boneName, const int currentTime, float *currentFrame, int *modelList, const int modelIndex)
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)
int	trap_G2API_GetTime (void)
void	trap_G2API_SetTime (int time, int clock)
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)
qboolean	trap_G2API_RagPCJConstraint (void *ghoul2, const char *boneName, vec3_t min, vec3_t max)
qboolean	trap_G2API_RagPCJGradientSpeed (void *ghoul2, const char *boneName, const float speed)
qboolean	trap_G2API_RagEffectorGoal (void *ghoul2, const char *boneName, vec3_t pos)
qboolean	trap_G2API_GetRagBonePos (void *ghoul2, const char *boneName, vec3_t pos, vec3_t entAngles, vec3_t entPos, vec3_t entScale)
qboolean	trap_G2API_RagEffectorKick (void *ghoul2, const char *boneName, vec3_t velocity)
qboolean	trap_G2API_RagForceSolve (void *ghoul2, qboolean force)
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)
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)
void	trap_G2API_GetSurfaceName (void *ghoul2, int surfNumber, int modelIndex, char *fillBuf)
void	CG_Init_CG (void)
void	CG_Init_CGents (void)
void	CG_SetGhoul2Info (refEntity_t *ent, centity_t *cent)
void	CG_CreateBBRefEnts (entityState_t *s1, vec3_t origin)
void	CG_InitG2Weapons (void)
void	CG_ShutDownG2Weapons (void)
void	CG_CopyG2WeaponInstance (centity_t *cent, int weaponNum, void *toGhoul2)
void *	CG_G2WeaponInstance (centity_t *cent, int weapon)
void	CG_CheckPlayerG2Weapons (playerState_t *ps, centity_t *cent)
void	CG_SetSiegeTimerCvar (int msec)
Variables
forceTicPos_t	forceTicPos []
forceTicPos_t	ammoTicPos []
cgscreffects_t	cgScreenEffects
siegeExtended_t	cg_siegeExtendedData [MAX_CLIENTS]
cgs_t	cgs
cg_t	cg
centity_t	cg_entities [MAX_GENTITIES]
centity_t *	cg_permanents [MAX_GENTITIES]
int	cg_numpermanents
weaponInfo_t	cg_weapons [MAX_WEAPONS]
itemInfo_t	cg_items [MAX_ITEMS]
markPoly_t	cg_markPolys [MAX_MARK_POLYS]
vmCvar_t	cg_centertime
vmCvar_t	cg_runpitch
vmCvar_t	cg_runroll
vmCvar_t	cg_bobup
vmCvar_t	cg_bobpitch
vmCvar_t	cg_bobroll
vmCvar_t	cg_shadows
vmCvar_t	cg_renderToTextureFX
vmCvar_t	cg_drawTimer
vmCvar_t	cg_drawFPS
vmCvar_t	cg_drawSnapshot
vmCvar_t	cg_draw3dIcons
vmCvar_t	cg_drawIcons
vmCvar_t	cg_drawAmmoWarning
vmCvar_t	cg_drawCrosshair
vmCvar_t	cg_drawCrosshairNames
vmCvar_t	cg_drawRadar
vmCvar_t	cg_drawVehLeadIndicator
vmCvar_t	cg_drawAutomap
vmCvar_t	cg_drawScores
vmCvar_t	cg_dynamicCrosshair
vmCvar_t	cg_dynamicCrosshairPrecision
vmCvar_t	cg_drawRewards
vmCvar_t	cg_drawTeamOverlay
vmCvar_t	cg_teamOverlayUserinfo
vmCvar_t	cg_crosshairX
vmCvar_t	cg_crosshairY
vmCvar_t	cg_crosshairSize
vmCvar_t	cg_crosshairHealth
vmCvar_t	cg_drawStatus
vmCvar_t	cg_draw2D
vmCvar_t	cg_animSpeed
vmCvar_t	cg_debugAnim
vmCvar_t	cg_debugPosition
vmCvar_t	cg_debugEvents
vmCvar_t	cg_errorDecay
vmCvar_t	cg_nopredict
vmCvar_t	cg_noPlayerAnims
vmCvar_t	cg_showmiss
vmCvar_t	cg_showVehMiss
vmCvar_t	cg_footsteps
vmCvar_t	cg_addMarks
vmCvar_t	cg_gun_frame
vmCvar_t	cg_gun_x
vmCvar_t	cg_gun_y
vmCvar_t	cg_gun_z
vmCvar_t	cg_drawGun
vmCvar_t	cg_viewsize
vmCvar_t	cg_autoswitch
vmCvar_t	cg_ignore
vmCvar_t	cg_simpleItems
vmCvar_t	cg_fov
vmCvar_t	cg_zoomFov
vmCvar_t	cg_swingAngles
vmCvar_t	cg_oldPainSounds
vmCvar_t	cg_ragDoll
vmCvar_t	cg_jumpSounds
vmCvar_t	cg_autoMap
vmCvar_t	cg_autoMapX
vmCvar_t	cg_autoMapY
vmCvar_t	cg_autoMapW
vmCvar_t	cg_autoMapH
vmCvar_t	bg_fighterAltControl
vmCvar_t	cg_chatBox
vmCvar_t	cg_chatBoxHeight
vmCvar_t	cg_saberModelTraceEffect
vmCvar_t	cg_saberClientVisualCompensation
vmCvar_t	cg_g2TraceLod
vmCvar_t	cg_fpls
vmCvar_t	cg_ghoul2Marks
vmCvar_t	cg_optvehtrace
vmCvar_t	cg_saberDynamicMarks
vmCvar_t	cg_saberDynamicMarkTime
vmCvar_t	cg_saberContact
vmCvar_t	cg_saberTrail
vmCvar_t	cg_duelHeadAngles
vmCvar_t	cg_speedTrail
vmCvar_t	cg_auraShell
vmCvar_t	cg_repeaterOrb
vmCvar_t	cg_animBlend
vmCvar_t	cg_dismember
vmCvar_t	cg_thirdPersonSpecialCam
vmCvar_t	cg_thirdPerson
vmCvar_t	cg_thirdPersonRange
vmCvar_t	cg_thirdPersonAngle
vmCvar_t	cg_thirdPersonPitchOffset
vmCvar_t	cg_thirdPersonVertOffset
vmCvar_t	cg_thirdPersonCameraDamp
vmCvar_t	cg_thirdPersonTargetDamp
vmCvar_t	cg_thirdPersonAlpha
vmCvar_t	cg_thirdPersonHorzOffset
vmCvar_t	cg_stereoSeparation
vmCvar_t	cg_lagometer
vmCvar_t	cg_drawEnemyInfo
vmCvar_t	cg_synchronousClients
vmCvar_t	cg_stats
vmCvar_t	cg_forceModel
vmCvar_t	cg_buildScript
vmCvar_t	cg_paused
vmCvar_t	cg_blood
vmCvar_t	cg_predictItems
vmCvar_t	cg_deferPlayers
vmCvar_t	cg_drawFriend
vmCvar_t	cg_teamChatsOnly
vmCvar_t	cg_noVoiceChats
vmCvar_t	cg_noVoiceText
vmCvar_t	cg_scorePlum
vmCvar_t	cg_hudFiles
vmCvar_t	cg_smoothClients
vmCvar_t	pmove_fixed
vmCvar_t	pmove_msec
vmCvar_t	cg_cameraOrbit
vmCvar_t	cg_cameraOrbitDelay
vmCvar_t	cg_timescaleFadeEnd
vmCvar_t	cg_timescaleFadeSpeed
vmCvar_t	cg_timescale
vmCvar_t	cg_cameraMode
vmCvar_t	cg_smallFont
vmCvar_t	cg_bigFont
vmCvar_t	cg_noTaunt
vmCvar_t	cg_noProjectileTrail
vmCvar_t	cg_currentSelectedPlayer
vmCvar_t	cg_currentSelectedPlayerName
vmCvar_t	cg_recordSPDemo
vmCvar_t	cg_recordSPDemoName
vmCvar_t	ui_myteam
vmCvar_t	cg_snapshotTimeout
vmCvar_t	cg_debugBB
int	sortedTeamPlayers [TEAM_MAXOVERLAY]
int	numSortedTeamPlayers
char	systemChat [256]
qboolean	initparticles

---

Define Documentation

#define ATTACKER_HEAD_TIME   10000

Definition at line 49 of file cg_local.h.

#define CGAME_INLINE   ID_INLINE

Definition at line 14 of file cg_local.h.

#define CHAR_HEIGHT   48

Definition at line 63 of file cg_local.h.

#define CHAR_WIDTH   32

Definition at line 62 of file cg_local.h.

#define DAMAGE_DEFLECT_TIME   100

Definition at line 28 of file cg_local.h.

#define DAMAGE_RETURN_TIME   400

Definition at line 29 of file cg_local.h.

#define DAMAGE_TIME   500

Definition at line 30 of file cg_local.h. Referenced by CG_DamageFeedback().

#define DEFAULT_BLUETEAM_NAME   "Rebellion"

Definition at line 88 of file cg_local.h. Referenced by CG_LoadClientInfo().

#define DEFAULT_FORCEPOWERS   "5-1-000000000000000000"

Definition at line 84 of file cg_local.h. Referenced by BotUtilizePersonality(), and CG_RegisterCvars().

#define DEFAULT_MODEL   "kyle"

Definition at line 82 of file cg_local.h. Referenced by CG_LoadClientInfo(), and CG_RegisterCvars().

#define DEFAULT_REDTEAM_NAME   "Empire"

Definition at line 87 of file cg_local.h. Referenced by CG_LoadClientInfo().

#define DUCK_TIME   100

Definition at line 34 of file cg_local.h.

#define FADE_TIME   200

Definition at line 26 of file cg_local.h. Referenced by CG_DrawOldScoreboard(), and CG_FadeColor().

#define GIANT_HEIGHT   48

Definition at line 68 of file cg_local.h.

#define GIANT_WIDTH   32

Definition at line 67 of file cg_local.h.

#define ICON_SIZE   48

Definition at line 61 of file cg_local.h.

#define ITEM_BLOB_TIME   200

Definition at line 46 of file cg_local.h.

#define ITEM_SCALEUP_TIME   1000

Definition at line 37 of file cg_local.h.

#define LAND_DEFLECT_TIME   150

Definition at line 31 of file cg_local.h.

#define LAND_RETURN_TIME   300

Definition at line 32 of file cg_local.h.

#define MAX_CG_LOOPSOUNDS   8

Definition at line 321 of file cg_local.h. Referenced by CG_S_AddLoopingSound().

#define MAX_CHATBOX_ITEMS   5

Definition at line 747 of file cg_local.h. Referenced by CG_ChatBox_AddString().

#define MAX_CUSTOM_COMBAT_SOUNDS   40

Definition at line 187 of file cg_local.h.

#define MAX_CUSTOM_DUEL_SOUNDS   40

Definition at line 191 of file cg_local.h. Referenced by CG_LoadCISounds().

#define MAX_CUSTOM_EXTRA_SOUNDS   40

Definition at line 188 of file cg_local.h.

#define MAX_CUSTOM_JEDI_SOUNDS   40

Definition at line 189 of file cg_local.h.

#define MAX_CUSTOM_SOUNDS   40

Definition at line 193 of file cg_local.h. Referenced by CG_CustomSound(), and CG_LoadCISounds().

#define MAX_MARK_POLYS   256

Definition at line 57 of file cg_local.h. Referenced by CG_InitMarkPolys().

#define MAX_PREDICTED_EVENTS   16

Definition at line 744 of file cg_local.h. Referenced by CG_CheckChangedPredictableEvents(), and CG_CheckPlayerstateEvents().

#define MAX_REWARDSTACK   10

Definition at line 736 of file cg_local.h.

#define MAX_SKULLTRAIL   10

Definition at line 728 of file cg_local.h.

#define MAX_SOUNDBUFFER   20

Definition at line 737 of file cg_local.h. Referenced by CG_AddBufferedSound().

#define MAX_STEP_CHANGE   32

Definition at line 54 of file cg_local.h. Referenced by CG_EntityEvent().

#define MAX_TICS   14

Definition at line 1016 of file cg_local.h.

#define MAX_VERTS_ON_POLY   10

Definition at line 56 of file cg_local.h. Referenced by CG_CreateSaberMarks(), and CG_ImpactMark().

#define MAX_ZOOM_FOV   3.0f

Definition at line 41 of file cg_local.h.

#define MUZZLE_FLASH_TIME   20

Definition at line 47 of file cg_local.h. Referenced by CG_AddPlayerWeapon().

#define NULL_FX   ((fxHandle_t) 0)

Definition at line 21 of file cg_local.h. Referenced by CG_RegisterWeapon().

#define NULL_HANDLE   ((qhandle_t) 0)

Definition at line 19 of file cg_local.h. Referenced by CG_RegisterWeapon().

#define NULL_SOUND   ((sfxHandle_t) 0)

Definition at line 20 of file cg_local.h. Referenced by CG_RegisterWeapon().

#define NUM_CHUNK_MODELS   4

Definition at line 1061 of file cg_local.h.

#define NUM_CROSSHAIRS   9

Definition at line 74 of file cg_local.h. Referenced by AssetCache().

#define NUM_FONT_BIG   1

Definition at line 70 of file cg_local.h. Referenced by CG_DrawNumField().

#define NUM_FONT_CHUNKY   3

Definition at line 72 of file cg_local.h. Referenced by CG_DrawNumField().

#define NUM_FONT_SMALL   2

Definition at line 71 of file cg_local.h. Referenced by CG_DrawArmor(), CG_DrawForcePower(), CG_DrawHealth(), and CG_DrawNumField().

#define PAIN_TWITCH_TIME   200

Definition at line 35 of file cg_local.h.

#define POWERUP_BLINK_TIME   1000

Definition at line 25 of file cg_local.h.

#define POWERUP_BLINKS   5

Definition at line 23 of file cg_local.h.

#define PULSE_SCALE   1.5

Definition at line 52 of file cg_local.h.

#define PULSE_TIME   200

Definition at line 27 of file cg_local.h.

#define REWARD_TIME   3000

Definition at line 50 of file cg_local.h.

#define SINK_TIME   1000

Definition at line 48 of file cg_local.h. Referenced by CG_AddFragment().

#define STAT_MINUS   10

Definition at line 59 of file cg_local.h. Referenced by CG_DrawNumField().

#define STEP_TIME   200

Definition at line 33 of file cg_local.h. Referenced by CG_EntityEvent().

#define TEAM_OVERLAY_MAXLOCATION_WIDTH   64

Definition at line 77 of file cg_local.h.

#define TEAM_OVERLAY_MAXNAME_WIDTH   32

Definition at line 76 of file cg_local.h.

#define TEXT_ICON_SPACE   4

Definition at line 64 of file cg_local.h.

#define WAVE_AMPLITUDE   1

Definition at line 79 of file cg_local.h.

#define WAVE_FREQUENCY   0.4

Definition at line 80 of file cg_local.h.

#define WEAPON_SELECT_TIME   1400

Definition at line 36 of file cg_local.h. Referenced by CG_DrawForceSelect(), CG_DrawIconBackground(), CG_DrawInvenSelect(), and CG_DrawWeaponSelect().

#define ZOOM_IN_TIME   1500.0f

Definition at line 42 of file cg_local.h.

#define ZOOM_OUT_TIME   100.0f

Definition at line 43 of file cg_local.h. Referenced by CG_DrawSkyBoxPortal().

#define ZOOM_START_PERCENT   0.3f

Definition at line 44 of file cg_local.h.

#define ZOOM_TIME   150

Definition at line 40 of file cg_local.h.

---

Typedef Documentation

typedef struct centity_s centity_t

Referenced by BG_MySaber(), CG_AddBracketedEnt(), CG_AddPacketEntities(), CG_AddPlayerWeapon(), CG_AddRadarEnt(), CG_AddSaberBlade(), CG_AddViewWeapon(), CG_AdjustPositionForMover(), CG_Beam(), CG_BracketEntity(), CG_BuildSolidList(), CG_CalcEntityLerpPositions(), CG_CalcEWebMuzzlePoint(), CG_CalcMuzzlePoint(), CG_CalcVehicleMuzzlePoint(), CG_CalcVehMuzzle(), CG_CheckChangedPredictableEvents(), CG_CheckEvents(), CG_CheckPassengerTurretView(), CG_CheckPlayerG2Weapons(), CG_CheckPlayerstateEvents(), CG_CheckTargetVehicle(), CG_CheckThirdPersonAlpha(), CG_CopyG2WeaponInstance(), CG_CreateDistortionTrailPart(), CG_Disintegration(), CG_DrawActiveFrame(), CG_DrawBracketedEntities(), CG_DrawEWebHealth(), CG_DrawHealthBar(), CG_DrawHUD(), CG_DrawPlayerShield(), CG_DrawPlayerSphere(), CG_DrawRadar(), CG_DrawSiegeInfo(), CG_DrawVehicleAmmo(), CG_DrawVehicleAmmoLower(), CG_DrawVehicleAmmoUpper(), CG_DrawVehicleArmor(), CG_DrawVehicleDamage(), CG_DrawVehicleDamageHUD(), CG_DrawVehicleHud(), CG_DrawVehicleShields(), CG_DrawVehicleSpeed(), CG_DrawVehicleTurboRecharge(), CG_DrawVehicleWeaponsLinked(), CG_EntityEvent(), CG_FireWeapon(), CG_G2Animated(), CG_G2AnimEntModelLoad(), CG_G2MarkEvent(), CG_G2PlayerHeadAnims(), CG_G2SaberEffects(), CG_G2ServerBoneAngles(), CG_G2TraceCollide(), CG_G2WeaponInstance(), CG_GetClientWeaponMuzzleBoltPoint(), CG_GetValue(), CG_InATST(), CG_InFighter(), CG_InRoll(), CG_InRollAnim(), CG_ManualEntityRender(), CG_NewClientInfo(), CG_OilSlickRemove(), CG_PainEvent(), CG_ParseSiegeExtendedDataEntry(), CG_Particle_OilParticle(), CG_Particle_OilSlick(), CG_ParticleBloodCloud(), CG_ParticleDust(), CG_ParticleSmoke(), CG_ParticleSnowFlurry(), CG_PlayDoorLoopSound(), CG_PlayDoorSound(), CG_Player(), CG_PlayerAnimEventDo(), CG_PlayerHitFX(), CG_PlayerShieldHit(), CG_PmoveClientPointerUpdate(), CG_PointContents(), CG_PredictPlayerState(), CG_RadiusForCent(), CG_RagDoll(), CG_ReattachLimb(), CG_ResetPlayerEntity(), CG_ROFF_NotetrackCallback(), CG_S_AddLoopingSound(), CG_S_StopLoopingSound(), CG_S_UpdateLoopingSounds(), CG_SaberCompWork(), CG_SetEntitySoundPosition(), CG_SetGhoul2Info(), CG_SetInitialSnapshot(), CG_SiegeObjectiveCompleted(), CG_SiegeRoundOver(), CG_SnowLink(), CG_Special(), CG_ThereIsAMaster(), CG_ToggleBinoculars(), CG_TransitionPermanent(), CG_TriggerAnimSounds(), CG_UpdateSoundTrackers(), CG_VehicleAttachDroidUnit(), CG_VehicleShouldDrawShields(), CG_VehicleWeaponImpact(), CG_VehMuzzleFireFX(), DoFall(), FX_BlasterAltFireThink(), FX_BlasterProjectileThink(), FX_BowcasterAltProjectileThink(), FX_BowcasterProjectileThink(), FX_BryarAltProjectileThink(), FX_BryarProjectileThink(), FX_ConcussionProjectileThink(), FX_DEMP2_ProjectileThink(), FX_DrawPortableShield(), FX_FlechetteAltProjectileThink(), FX_FlechetteProjectileThink(), FX_RepeaterAltProjectileThink(), FX_RepeaterProjectileThink(), FX_RocketAltProjectileThink(), FX_RocketProjectileThink(), FX_TurretProjectileThink(), G2_BoltToGhoul2Model(), and TurretClientRun().

typedef struct cgLoopSound_s cgLoopSound_t

Referenced by CG_S_AddLoopingSound(), CG_S_StopLoopingSound(), and CG_S_UpdateLoopingSounds().

typedef struct cgscreffects_s cgscreffects_t

typedef struct chatBoxItem_s chatBoxItem_t

Referenced by CG_ChatBox_AddString(), and CG_ChatBox_ArrayInsert().

typedef struct forceTicPos_s forceTicPos_t

typedef struct localEntity_s localEntity_t

Referenced by CG_AddFadeRGB(), CG_AddFragment(), CG_AddLine(), CG_AddLocalEntities(), CG_AddOLine(), CG_AddParticleShrapnel(), CG_AddRefEntity(), CG_AddScorePlum(), CG_AllocLocalEntity(), CG_Bleed(), CG_BloodPool(), CG_BloodTrail(), CG_BubbleTrail(), CG_Chunks(), CG_FragmentBounceMark(), CG_FragmentBounceSound(), CG_FreeLocalEntity(), CG_LaunchGib(), CG_MakeExplosion(), CG_ReflectVelocity(), CG_ScorePlum(), CG_SmokePuff(), CG_SurfaceExplosion(), CG_TestLine(), CG_ThrowChunk(), FX_AddOrientedLine(), FX_DEMP2_AltDetonate(), and FX_DrawPortableShield().

typedef struct markPoly_s markPoly_t

Referenced by CG_AddMarks(), CG_AllocMark(), CG_CreateSaberMarks(), CG_FreeMarkPoly(), and CG_ImpactMark().

typedef struct siegeExtended_s siegeExtended_t

Referenced by CG_DrawSiegeInfo().

typedef struct weaponInfo_s weaponInfo_t

Referenced by CG_AddPlayerWeapon(), CG_AddViewWeapon(), CG_DrawWeaponSelect(), CG_EntityEvent(), CG_FireWeapon(), CG_RegisterWeapon(), and TurretClientRun().

---

Enumeration Type Documentation

anonymous enum

Enumeration values: CHUNK_METAL1  CHUNK_METAL2  CHUNK_ROCK1  CHUNK_ROCK2  CHUNK_ROCK3  CHUNK_CRATE1  CHUNK_CRATE2  CHUNK_WHITE_METAL  NUM_CHUNK_TYPES  Definition at line 1049 of file cg_local.h. { CHUNK_METAL1 = 0, CHUNK_METAL2, CHUNK_ROCK1, CHUNK_ROCK2, CHUNK_ROCK3, CHUNK_CRATE1, CHUNK_CRATE2, CHUNK_WHITE_METAL, NUM_CHUNK_TYPES };

enum footstep_t

Enumeration values: FOOTSTEP_STONEWALK  FOOTSTEP_STONERUN  FOOTSTEP_METALWALK  FOOTSTEP_METALRUN  FOOTSTEP_PIPEWALK  FOOTSTEP_PIPERUN  FOOTSTEP_SPLASH  FOOTSTEP_WADE  FOOTSTEP_SWIM  FOOTSTEP_SNOWWALK  FOOTSTEP_SNOWRUN  FOOTSTEP_SANDWALK  FOOTSTEP_SANDRUN  FOOTSTEP_GRASSWALK  FOOTSTEP_GRASSRUN  FOOTSTEP_DIRTWALK  FOOTSTEP_DIRTRUN  FOOTSTEP_MUDWALK  FOOTSTEP_MUDRUN  FOOTSTEP_GRAVELWALK  FOOTSTEP_GRAVELRUN  FOOTSTEP_RUGWALK  FOOTSTEP_RUGRUN  FOOTSTEP_WOODWALK  FOOTSTEP_WOODRUN  FOOTSTEP_TOTAL  Definition at line 90 of file cg_local.h. Referenced by CG_EntityEvent(). { FOOTSTEP_STONEWALK, FOOTSTEP_STONERUN, FOOTSTEP_METALWALK, FOOTSTEP_METALRUN, FOOTSTEP_PIPEWALK, FOOTSTEP_PIPERUN, FOOTSTEP_SPLASH, FOOTSTEP_WADE, FOOTSTEP_SWIM, FOOTSTEP_SNOWWALK, FOOTSTEP_SNOWRUN, FOOTSTEP_SANDWALK, FOOTSTEP_SANDRUN, FOOTSTEP_GRASSWALK, FOOTSTEP_GRASSRUN, FOOTSTEP_DIRTWALK, FOOTSTEP_DIRTRUN, FOOTSTEP_MUDWALK, FOOTSTEP_MUDRUN, FOOTSTEP_GRAVELWALK, FOOTSTEP_GRAVELRUN, FOOTSTEP_RUGWALK, FOOTSTEP_RUGRUN, FOOTSTEP_WOODWALK, FOOTSTEP_WOODRUN, FOOTSTEP_TOTAL } footstep_t;

enum impactSound_t

Enumeration values: IMPACTSOUND_DEFAULT  IMPACTSOUND_METAL  IMPACTSOUND_FLESH  Definition at line 120 of file cg_local.h. { IMPACTSOUND_DEFAULT, IMPACTSOUND_METAL, IMPACTSOUND_FLESH } impactSound_t;

enum leBounceSoundType_t

Enumeration values: LEBS_NONE  LEBS_BLOOD  LEBS_BRASS  LEBS_METAL  LEBS_ROCK  Definition at line 511 of file cg_local.h. Referenced by CG_Chunks(). { LEBS_NONE, LEBS_BLOOD, LEBS_BRASS, LEBS_METAL, LEBS_ROCK } leBounceSoundType_t; // fragment local entities can make sounds on impacts

enum leFlag_t

Enumeration values: LEF_PUFF_DONT_SCALE  LEF_TUMBLE  LEF_FADE_RGB  LEF_NO_RANDOM_ROTATE  Definition at line 498 of file cg_local.h. { LEF_PUFF_DONT_SCALE = 0x0001, // do not scale size over time LEF_TUMBLE = 0x0002, // tumble over time, used for ejecting shells LEF_FADE_RGB = 0x0004, // explicitly fade LEF_NO_RANDOM_ROTATE= 0x0008 // MakeExplosion adds random rotate which could be bad in some cases } leFlag_t;

enum leMarkType_t

Enumeration values: LEMT_NONE  LEMT_BURN  LEMT_BLOOD  Definition at line 505 of file cg_local.h. { LEMT_NONE, LEMT_BURN, LEMT_BLOOD } leMarkType_t; // fragment local entities can leave marks on walls

enum leType_t

Enumeration values: LE_MARK  LE_EXPLOSION  LE_SPRITE_EXPLOSION  LE_FADE_SCALE_MODEL  LE_FRAGMENT  LE_PUFF  LE_MOVE_SCALE_FADE  LE_FALL_SCALE_FADE  LE_FADE_RGB  LE_SCALE_FADE  LE_SCOREPLUM  LE_OLINE  LE_SHOWREFENTITY  LE_LINE  Definition at line 481 of file cg_local.h. { LE_MARK, LE_EXPLOSION, LE_SPRITE_EXPLOSION, LE_FADE_SCALE_MODEL, // currently only for Demp2 shock sphere LE_FRAGMENT, LE_PUFF, LE_MOVE_SCALE_FADE, LE_FALL_SCALE_FADE, LE_FADE_RGB, LE_SCALE_FADE, LE_SCOREPLUM, LE_OLINE, LE_SHOWREFENTITY, LE_LINE } leType_t;

enum q3print_t

Enumeration values: SYSTEM_PRINT  CHAT_PRINT  TEAMCHAT_PRINT  Definition at line 2373 of file cg_local.h. { SYSTEM_PRINT, CHAT_PRINT, TEAMCHAT_PRINT } q3print_t; // bk001201 - warning: useless keyword or type name in empty declaration

---

Function Documentation

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. { 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_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; }

void CG_AddBufferedSound (  sfxHandle_t  sfx  )

Definition at line 1934 of file cg_view.c. References cg, MAX_SOUNDBUFFER, sfxHandle_t, cg_t::soundBuffer, cg_t::soundBufferIn, and cg_t::soundBufferOut. Referenced by CG_CheckLocalSounds(), and CG_EntityEvent(). { if ( !sfx ) return; cg.soundBuffer[cg.soundBufferIn] = sfx; cg.soundBufferIn = (cg.soundBufferIn + 1) % MAX_SOUNDBUFFER; if (cg.soundBufferIn == cg.soundBufferOut) { cg.soundBufferOut++; } }

void CG_AddGhoul2Mark (  int  shader, float  size, vec3_t  start, vec3_t  end, int  entnum, vec3_t  entposition, float  entangle, void *  ghoul2, vec3_t  scale, int  lifeTime )

Definition at line 5738 of file cg_players.c. References SSkinGoreData_s::angles, SSkinGoreData_s::backFaces, SSkinGoreData_s::baseModelOnly, cg, cg_ghoul2Marks, SSkinGoreData_s::currentTime, SSkinGoreData_s::entNum, flrand(), SSkinGoreData_s::frontFaces, SSkinGoreData_s::goreScaleStartFraction, SSkinGoreData_s::growDuration, SSkinGoreData_s::hitLocation, vmCvar_t::integer, SSkinGoreData_s::lifeTime, memset(), SSkinGoreData_s::position, qfalse, qtrue, SSkinGoreData_s::rayDirection, SSkinGoreData_s::scale, SSkinGoreData_s::shader, SSkinGoreData_s::SSize, SSkinGoreData, SSkinGoreData_s::theta, cg_t::time, trap_G2API_AddSkinGore(), trap_G2API_GetNumGoreMarks(), SSkinGoreData_s::TSize, vec3_t, VectorCopy, VectorNormalize(), VectorSet, VectorSubtract, and YAW. Referenced by CG_G2MarkEvent(), and CG_SaberCompWork(). { SSkinGoreData goreSkin; assert(ghoul2); memset ( &goreSkin, 0, sizeof(goreSkin) ); if (trap_G2API_GetNumGoreMarks(ghoul2, 0) >= cg_ghoul2Marks.integer) { //you've got too many marks already return; } goreSkin.growDuration = -1; // default expandy time goreSkin.goreScaleStartFraction = 1.0; // default start scale goreSkin.frontFaces = qtrue; goreSkin.backFaces = qtrue; goreSkin.lifeTime = lifeTime; //last randomly 10-20 seconds /* if (lifeTime) { goreSkin.fadeOutTime = lifeTime*0.1; //default fade duration is relative to lifetime. } goreSkin.fadeRGB = qtrue; //fade on RGB instead of alpha (this depends on the shader really, modify if needed) */ //rwwFIXMEFIXME: fade has sorting issues with other non-fading decals, disabled until fixed goreSkin.baseModelOnly = qfalse; goreSkin.currentTime = cg.time; goreSkin.entNum = entnum; goreSkin.SSize = size; goreSkin.TSize = size; goreSkin.theta = flrand(0.0f,6.28f); goreSkin.shader = shader; if (!scale[0] && !scale[1] && !scale[2]) { VectorSet(goreSkin.scale, 1.0f, 1.0f, 1.0f); } else { VectorCopy(goreSkin.scale, scale); } VectorCopy (start, goreSkin.hitLocation); VectorSubtract(end, start, goreSkin.rayDirection); if (VectorNormalize(goreSkin.rayDirection)<.1f) { return; } VectorCopy ( entposition, goreSkin.position ); goreSkin.angles[YAW] = entangle; trap_G2API_AddSkinGore(ghoul2, &goreSkin); }

void CG_AddLagometerFrameInfo (  void   )

Definition at line 4161 of file cg_draw.c. References cg, lagometer_t::frameCount, lagometer_t::frameSamples, LAG_SAMPLES, lagometer, cg_t::latestSnapshotTime, and cg_t::time. Referenced by CG_DrawActiveFrame(). { int offset; offset = cg.time - cg.latestSnapshotTime; lagometer.frameSamples[ lagometer.frameCount & ( LAG_SAMPLES - 1) ] = offset; lagometer.frameCount++; }

void CG_AddLagometerSnapshotInfo (  snapshot_t *  snap  )

Definition at line 4179 of file cg_draw.c. References LAG_SAMPLES, lagometer, snapshot_t::ping, snapshot_t::snapFlags, lagometer_t::snapshotCount, lagometer_t::snapshotFlags, and lagometer_t::snapshotSamples. { // dropped packet if ( !snap ) { lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = -1; lagometer.snapshotCount++; return; } // add this snapshot's info lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->ping; lagometer.snapshotFlags[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->snapFlags; lagometer.snapshotCount++; }

void CG_AddLocalEntities (  void   )

Definition at line 789 of file cg_localents.c. References cg, cg_activeLocalEntities, CG_AddFadeRGB(), CG_AddFragment(), CG_AddLine(), CG_AddOLine(), CG_AddRefEntity(), CG_AddScorePlum(), CG_Error(), CG_FreeLocalEntity(), localEntity_s::endTime, LE_EXPLOSION, LE_FADE_RGB, LE_FADE_SCALE_MODEL, LE_FALL_SCALE_FADE, LE_FRAGMENT, LE_LINE, LE_MARK, LE_MOVE_SCALE_FADE, LE_OLINE, LE_PUFF, LE_SCALE_FADE, LE_SCOREPLUM, LE_SHOWREFENTITY, LE_SPRITE_EXPLOSION, localEntity_s::leType, localEntity_t, localEntity_s::prev, and cg_t::time. Referenced by CG_DrawActiveFrame(). { localEntity_t *le, *next; // walk the list backwards, so any new local entities generated // (trails, marks, etc) will be present this frame le = cg_activeLocalEntities.prev; for ( ; le != &cg_activeLocalEntities ; le = next ) { // grab next now, so if the local entity is freed we // still have it next = le->prev; if ( cg.time >= le->endTime ) { CG_FreeLocalEntity( le ); continue; } switch ( le->leType ) { default: CG_Error( "Bad leType: %i", le->leType ); break; case LE_MARK: break; case LE_SPRITE_EXPLOSION: CG_AddSpriteExplosion( le ); break; case LE_EXPLOSION: CG_AddExplosion( le ); break; case LE_FADE_SCALE_MODEL: CG_AddFadeScaleModel( le ); break; case LE_FRAGMENT: // gibs and brass CG_AddFragment( le ); break; case LE_PUFF: CG_AddPuff( le ); break; case LE_MOVE_SCALE_FADE: // water bubbles CG_AddMoveScaleFade( le ); break; case LE_FADE_RGB: // teleporters, railtrails CG_AddFadeRGB( le ); break; case LE_FALL_SCALE_FADE: // gib blood trails CG_AddFallScaleFade( le ); break; case LE_SCALE_FADE: // rocket trails CG_AddScaleFade( le ); break; case LE_SCOREPLUM: CG_AddScorePlum( le ); break; case LE_OLINE: CG_AddOLine( le ); break; case LE_SHOWREFENTITY: CG_AddRefEntity( le ); break; case LE_LINE: // oriented lines for FX CG_AddLine( le ); break; } } }

void CG_AddMarks (  void   )

Definition at line 221 of file cg_marks.c. References markPoly_s::alphaFade, cg, cg_activeMarkPolys, cg_addMarks, CG_FreeMarkPoly(), markPoly_s::color, vmCvar_t::integer, MARK_FADE_TIME, MARK_TOTAL_TIME, markPoly_t, markPoly_s::markShader, polyVert_t::modulate, markPoly_s::nextMark, poly_s::numVerts, markPoly_s::poly, cg_t::time, markPoly_s::time, trap_R_AddPolyToScene(), and markPoly_s::verts. Referenced by CG_DrawActiveFrame(). { int j; markPoly_t *mp, *next; int t; int fade; if ( !cg_addMarks.integer ) { return; } mp = cg_activeMarkPolys.nextMark; for ( ; mp != &cg_activeMarkPolys ; mp = next ) { // grab next now, so if the local entity is freed we // still have it next = mp->nextMark; // see if it is time to completely remove it if ( cg.time > mp->time + MARK_TOTAL_TIME ) { CG_FreeMarkPoly( mp ); continue; } // fade out the energy bursts //if ( mp->markShader == cgs.media.energyMarkShader ) { if (0) { fade = 450 - 450 * ( (cg.time - mp->time ) / 3000.0 ); if ( fade < 255 ) { if ( fade < 0 ) { fade = 0; } if ( mp->verts[0].modulate[0] != 0 ) { for ( j = 0 ; j < mp->poly.numVerts ; j++ ) { mp->verts[j].modulate[0] = mp->color[0] * fade; mp->verts[j].modulate[1] = mp->color[1] * fade; mp->verts[j].modulate[2] = mp->color[2] * fade; } } } } // fade all marks out with time t = mp->time + MARK_TOTAL_TIME - cg.time; if ( t < MARK_FADE_TIME ) { fade = 255 * t / MARK_FADE_TIME; if ( mp->alphaFade ) { for ( j = 0 ; j < mp->poly.numVerts ; j++ ) { mp->verts[j].modulate[3] = fade; } } else { float f = (float)t / MARK_FADE_TIME; for ( j = 0 ; j < mp->poly.numVerts ; j++ ) { mp->verts[j].modulate[0] = mp->color[0] * f; mp->verts[j].modulate[1] = mp->color[1] * f; mp->verts[j].modulate[2] = mp->color[2] * f; } } } else { for ( j = 0 ; j < mp->poly.numVerts ; j++ ) { mp->verts[j].modulate[0] = mp->color[0]; mp->verts[j].modulate[1] = mp->color[1]; mp->verts[j].modulate[2] = mp->color[2]; } } trap_R_AddPolyToScene( mp->markShader, mp->poly.numVerts, mp->verts ); } }

void CG_AddPacketEntities (  qboolean  isPortal  )

Definition at line 3412 of file cg_ents.c. References AnglesToAxis(), cg_t::autoAngles, cg_t::autoAnglesFast, cg_t::autoAxis, cg_t::autoAxisFast, BG_PlayerStateToEntityState(), centity_s::bodyHeight, cg_t::bracketedEntityCount, centity_t, cg, CG_CheckPlayerG2Weapons(), cg_entities, cg_numpermanents, cg_permanents, playerState_s::clientNum, centity_s::currentState, centity_s::currentValid, snapshot_t::entities, ET_NPC, ET_PLAYER, entityState_s::eType, cg_t::frameInterpolation, entityState_s::isPortalEnt, entityState_s::m_iVehicleNum, playerState_s::m_iVehicleNum, cg_t::nextSnap, entityState_s::number, snapshot_t::numEntities, entityState_s::owner, playerState_t, entityState_s::pos, cg_t::predictedPlayerState, cg_t::predictedVehicleState, snapshot_t::ps, qfalse, cg_t::radarEntityCount, snapshot_t::serverTime, cg_t::snap, cg_t::time, TR_INTERPOLATE, and trajectory_t::trType. Referenced by CG_DrawActiveFrame(), and CG_DrawSkyBoxPortal(). { int num; centity_t *cent; playerState_t *ps; if (isPortal) { for ( num = 0 ; num < cg.snap->numEntities ; num++ ) { cent = &cg_entities[ cg.snap->entities[ num ].number ]; if (cent->currentState.isPortalEnt) { CG_AddCEntity( cent ); } } return; } // set cg.frameInterpolation if ( cg.nextSnap ) { int delta; delta = (cg.nextSnap->serverTime - cg.snap->serverTime); if ( delta == 0 ) { cg.frameInterpolation = 0; } else { cg.frameInterpolation = (float)( cg.time - cg.snap->serverTime ) / delta; } } else { cg.frameInterpolation = 0; // actually, it should never be used, because // no entities should be marked as interpolating } // the auto-rotating items will all have the same axis cg.autoAngles[0] = 0; cg.autoAngles[1] = ( cg.time & 2047 ) * 360 / 2048.0; cg.autoAngles[2] = 0; cg.autoAnglesFast[0] = 0; cg.autoAnglesFast[1] = ( cg.time & 1023 ) * 360 / 1024.0f; cg.autoAnglesFast[2] = 0; AnglesToAxis( cg.autoAngles, cg.autoAxis ); AnglesToAxis( cg.autoAnglesFast, cg.autoAxisFast ); // Reset radar entities cg.radarEntityCount = 0; cg.bracketedEntityCount = 0; // generate and add the entity from the playerstate ps = &cg.predictedPlayerState; CG_CheckPlayerG2Weapons(ps, &cg_entities[cg.predictedPlayerState.clientNum]); BG_PlayerStateToEntityState( ps, &cg_entities[cg.predictedPlayerState.clientNum].currentState, qfalse ); if (cg.predictedPlayerState.m_iVehicleNum) { //add the vehicle I'm riding first //BG_PlayerStateToEntityState( &cg.predictedVehicleState, &cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState, qfalse ); //cg_entities[cg.predictedPlayerState.m_iVehicleNum].currentState.eType = ET_NPC; centity_t *veh = &cg_entities[cg.predictedPlayerState.m_iVehicleNum]; if (veh->currentState.owner == cg.predictedPlayerState.clientNum) { BG_PlayerStateToEntityState( &cg.predictedVehicleState, &veh->currentState, qfalse ); veh->currentState.eType = ET_NPC; veh->currentState.pos.trType = TR_INTERPOLATE; } CG_AddCEntity(veh); veh->bodyHeight = cg.time; //indicate we have already been added } CG_AddCEntity( &cg_entities[cg.predictedPlayerState.clientNum] ); /* // lerp the non-predicted value for lightning gun origins CG_CalcEntityLerpPositions( &cg_entities[ cg.snap->ps.clientNum ] ); */ //No longer have to do this. // add each entity sent over by the server for ( num = 0 ; num < cg.snap->numEntities ; num++ ) { // Don't re-add ents that have been predicted. if (cg.snap->entities[ num ].number != cg.snap->ps.clientNum) { cent = &cg_entities[ cg.snap->entities[ num ].number ]; if (cent->currentState.eType == ET_PLAYER && cent->currentState.m_iVehicleNum) { //add his veh first int j = 0; while (j < cg.snap->numEntities) { if (cg.snap->entities[j].number == cent->currentState.m_iVehicleNum) { centity_t *veh = &cg_entities[cg.snap->entities[j].number]; CG_AddCEntity(veh); veh->bodyHeight = cg.time; //indicate we have already been added break; } j++; } } else if (cent->currentState.eType == ET_NPC && cent->currentState.m_iVehicleNum && cent->bodyHeight == cg.time) { //never add a vehicle with a pilot, his pilot entity will get him added first. //if we were to add the vehicle after the pilot, the pilot's bolt would lag a frame behind. continue; } CG_AddCEntity( cent ); } } for(num=0;num<cg_numpermanents;num++) { cent = cg_permanents[num]; if (cent->currentValid) { CG_AddCEntity( cent ); } } }

void CG_AddParticles (  void   )

Definition at line 1081 of file cg_marks.c. References active_particles, particle_s::alpha, particle_s::alphavel, AngleVectors(), cg, CG_AddParticleToScene(), CG_ClearParticles(), cparticle_t, particle_s::endtime, free_particles, initparticles, particle_s::next, NULL, oldtime, particle_s::org, P_ANIM, P_BAT, P_BLEED, P_FLAT_SCALEUP_FADE, P_SMOKE, P_SMOKE_IMPACT, P_SPRITE, P_WEATHER_FLURRY, pvforward, pvright, pvup, cg_t::refdef, rforward, ROLL, rright, rup, cg_t::time, particle_s::time, particle_s::type, vec3_t, vectoangles(), VectorCopy, and refdef_t::viewaxis. Referenced by CG_DrawActiveFrame(). { cparticle_t *p, *next; float alpha; float time, time2; vec3_t org; int color; cparticle_t *active, *tail; int type; vec3_t rotate_ang; if (!initparticles) CG_ClearParticles (); VectorCopy( cg.refdef.viewaxis[0], pvforward ); VectorCopy( cg.refdef.viewaxis[1], pvright ); VectorCopy( cg.refdef.viewaxis[2], pvup ); vectoangles( cg.refdef.viewaxis[0], rotate_ang ); roll += ((cg.time - oldtime) * 0.1) ; rotate_ang[ROLL] += (roll*0.9); AngleVectors ( rotate_ang, rforward, rright, rup); oldtime = cg.time; active = NULL; tail = NULL; for (p=active_particles ; p ; p=next) { next = p->next; time = (cg.time - p->time)*0.001; alpha = p->alpha + time*p->alphavel; if (alpha <= 0) { // faded out p->next = free_particles; free_particles = p; p->type = 0; p->color = 0; p->alpha = 0; continue; } if (p->type == P_SMOKE || p->type == P_ANIM || p->type == P_BLEED || p->type == P_SMOKE_IMPACT) { if (cg.time > p->endtime) { p->next = free_particles; free_particles = p; p->type = 0; p->color = 0; p->alpha = 0; continue; } } if (p->type == P_WEATHER_FLURRY) { if (cg.time > p->endtime) { p->next = free_particles; free_particles = p; p->type = 0; p->color = 0; p->alpha = 0; continue; } } if (p->type == P_FLAT_SCALEUP_FADE) { if (cg.time > p->endtime) { p->next = free_particles; free_particles = p; p->type = 0; p->color = 0; p->alpha = 0; continue; } } if ((p->type == P_BAT || p->type == P_SPRITE) && p->endtime < 0) { // temporary sprite CG_AddParticleToScene (p, p->org, alpha); p->next = free_particles; free_particles = p; p->type = 0; p->color = 0; p->alpha = 0; continue; } p->next = NULL; if (!tail) active = tail = p; else { tail->next = p; tail = p; } if (alpha > 1.0) alpha = 1; color = p->color; time2 = time*time; org[0] = p->org[0] + p->vel[0]*time + p->accel[0]*time2; org[1] = p->org[1] + p->vel[1]*time + p->accel[1]*time2; org[2] = p->org[2] + p->vel[2]*time + p->accel[2]*time2; type = p->type; CG_AddParticleToScene (p, org, alpha); } active_particles = active; }

void CG_AddParticleShrapnel (  localEntity_t *  le  )

Definition at line 1550 of file cg_marks.c. References localEntity_t. { return; }

void CG_AddPlayerWeapon (  refEntity_t *  parent, playerState_t *  ps, centity_t *  cent, int  team, vec3_t  newAngles, qboolean  thirdPerson )

Definition at line 404 of file cg_weapons.c. References addspriteArgStruct_s::accel, addspriteArgStruct_t, weaponInfo_s::altMuzzleEffect, AnglesToAxis(), refEntity_t::axis, weaponInfo_s::barrelModel, addspriteArgStruct_s::bounce, cgMedia_t::bryarFrontFlash, centity_t, cg, cg_entities, CG_IsMindTricked(), CG_PositionEntityOnTag(), CG_PositionRotatedEntityOnTag(), CG_RegisterWeapon(), cg_weapons, CGCam_Shake(), cgs, playerState_s::clientNum, entityState_s::clientNum, entityState_s::constantLight, centity_s::currentState, addspriteArgStruct_s::dscale, addspriteArgStruct_s::eAlpha, EF_ALT_FIRING, EF_FIRING, entityState_s::eFlags, weaponInfo_s::firingSound, addspriteArgStruct_s::flags, weaponInfo_s::flashDlightColor, cgs_t::gameModels, centity_s::ghoul2, cgMedia_t::greenFrontFlash, weaponInfo_s::handsModel, refEntity_t::hModel, cg_t::lastFPFlashPoint, centity_s::lerpOrigin, addspriteArgStruct_s::life, refEntity_t::lightingOrigin, playerEntity_t::lightningFiring, cgMedia_t::lightningFlash, cgs_t::media, memset(), entityState_s::modelindex2, centity_s::modelScale, MUZZLE_FLASH_TIME, weaponInfo_s::muzzleEffect, centity_s::muzzleFlashTime, entityState_s::number, refEntity_t::origin, ORIGIN, addspriteArgStruct_s::origin, centity_s::pe, PITCH, playerState_t, PM_SPECTATOR, playerState_s::pm_type, POSITIVE_X, entityState_s::powerups, cg_t::predictedPlayerState, snapshot_t::ps, qfalse, qtrue, rand(), random, weaponInfo_s::readySound, refEntity_t::renderfx, cg_t::renderingThirdPerson, ROLL, addspriteArgStruct_s::rotation, addspriteArgStruct_s::sAlpha, addspriteArgStruct_s::scale, addspriteArgStruct_s::shader, refEntity_t::shadowPlane, cg_t::snap, cg_t::time, trap_FX_AddSprite(), trap_FX_PlayEffectID(), trap_FX_PlayEntityEffectID(), trap_G2API_GetBoltMatrix(), trap_G2API_HasGhoul2ModelOnIndex(), trap_R_AddLightToScene(), trap_R_RegisterModel(), trap_S_AddLoopingSound(), entityState_s::trickedentindex, entityState_s::trickedentindex2, entityState_s::trickedentindex3, entityState_s::trickedentindex4, vec3_origin, vec3_t, VectorClear, VectorCopy, addspriteArgStruct_s::vel, weaponInfo_s::viewModel, entityState_s::weapon, WEAPON_CHARGING, WEAPON_CHARGING_ALT, weapon_t, weaponInfo_t, weaponInfo_s::weaponModel, WP_BOWCASTER, WP_BRYAR_OLD, WP_BRYAR_PISTOL, WP_DEMP2, WP_EMPLACED_GUN, WP_STUN_BATON, and YAW. Referenced by CG_AddViewWeapon(), and CG_Player(). { refEntity_t gun; refEntity_t barrel; vec3_t angles; weapon_t weaponNum; weaponInfo_t *weapon; centity_t *nonPredictedCent; refEntity_t flash; weaponNum = cent->currentState.weapon; if (cent->currentState.weapon == WP_EMPLACED_GUN) { return; } if (cg.predictedPlayerState.pm_type == PM_SPECTATOR && cent->currentState.number == cg.predictedPlayerState.clientNum) { //spectator mode, don't draw it... return; } CG_RegisterWeapon( weaponNum ); weapon = &cg_weapons[weaponNum]; /* Ghoul2 Insert Start */ memset( &gun, 0, sizeof( gun ) ); // only do this if we are in first person, since world weapons are now handled on the server by Ghoul2 if (!thirdPerson) { // add the weapon VectorCopy( parent->lightingOrigin, gun.lightingOrigin ); gun.shadowPlane = parent->shadowPlane; gun.renderfx = parent->renderfx; if (ps) { // this player, in first person view gun.hModel = weapon->viewModel; } else { gun.hModel = weapon->weaponModel; } if (!gun.hModel) { return; } if ( !ps ) { // add weapon ready sound cent->pe.lightningFiring = qfalse; if ( ( cent->currentState.eFlags & EF_FIRING ) && weapon->firingSound ) { // lightning gun and guantlet make a different sound when fire is held down trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->firingSound ); cent->pe.lightningFiring = qtrue; } else if ( weapon->readySound ) { trap_S_AddLoopingSound( cent->currentState.number, cent->lerpOrigin, vec3_origin, weapon->readySound ); } } CG_PositionEntityOnTag( &gun, parent, parent->hModel, "tag_weapon"); if (!CG_IsMindTricked(cent->currentState.trickedentindex, cent->currentState.trickedentindex2, cent->currentState.trickedentindex3, cent->currentState.trickedentindex4, cg.snap->ps.clientNum)) { CG_AddWeaponWithPowerups( &gun, cent->currentState.powerups ); //don't draw the weapon if the player is invisible /* if ( weaponNum == WP_STUN_BATON ) { gun.shaderRGBA[0] = gun.shaderRGBA[1] = gun.shaderRGBA[2] = 25; gun.customShader = trap_R_RegisterShader( "gfx/effects/stunPass" ); gun.renderfx = RF_RGB_TINT | RF_FIRST_PERSON | RF_DEPTHHACK; trap_R_AddRefEntityToScene( &gun ); } */ } if (weaponNum == WP_STUN_BATON) { int i = 0; while (i < 3) { memset( &barrel, 0, sizeof( barrel ) ); VectorCopy( parent->lightingOrigin, barrel.lightingOrigin ); barrel.shadowPlane = parent->shadowPlane; barrel.renderfx = parent->renderfx; if (i == 0) { barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel.md3"); } else if (i == 1) { barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel2.md3"); } else { barrel.hModel = trap_R_RegisterModel("models/weapons2/stun_baton/baton_barrel3.md3"); } angles[YAW] = 0; angles[PITCH] = 0; angles[ROLL] = 0; AnglesToAxis( angles, barrel.axis ); if (i == 0) { CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" ); } else if (i == 1) { CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel2" ); } else { CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel3" ); } CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups ); i++; } } else { // add the spinning barrel if ( weapon->barrelModel ) { memset( &barrel, 0, sizeof( barrel ) ); VectorCopy( parent->lightingOrigin, barrel.lightingOrigin ); barrel.shadowPlane = parent->shadowPlane; barrel.renderfx = parent->renderfx; barrel.hModel = weapon->barrelModel; angles[YAW] = 0; angles[PITCH] = 0; angles[ROLL] = 0; AnglesToAxis( angles, barrel.axis ); CG_PositionRotatedEntityOnTag( &barrel, parent/*&gun*/, /*weapon->weaponModel*/weapon->handsModel, "tag_barrel" ); CG_AddWeaponWithPowerups( &barrel, cent->currentState.powerups ); } } } /* Ghoul2 Insert End */ memset (&flash, 0, sizeof(flash)); CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash"); VectorCopy(flash.origin, cg.lastFPFlashPoint); // Do special charge bits //----------------------- if ( (ps || cg.renderingThirdPerson || cg.predictedPlayerState.clientNum != cent->currentState.number) && ( ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_PISTOL ) || ( cent->currentState.modelindex2 == WEAPON_CHARGING_ALT && cent->currentState.weapon == WP_BRYAR_OLD ) || ( cent->currentState.weapon == WP_BOWCASTER && cent->currentState.modelindex2 == WEAPON_CHARGING ) || ( cent->currentState.weapon == WP_DEMP2 && cent->currentState.modelindex2 == WEAPON_CHARGING_ALT) ) ) { int shader = 0; float val = 0.0f; float scale = 1.0f; addspriteArgStruct_t fxSArgs; vec3_t flashorigin, flashdir; if (!thirdPerson) { VectorCopy(flash.origin, flashorigin); VectorCopy(flash.axis[0], flashdir); } else { mdxaBone_t boltMatrix; if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1)) { //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case return; } // go away and get me the bolt position for this frame please if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale))) { // Couldn't find bolt point. return; } BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin); BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir); } if ( cent->currentState.weapon == WP_BRYAR_PISTOL || cent->currentState.weapon == WP_BRYAR_OLD) { // Hardcoded max charge time of 1 second val = ( cg.time - cent->currentState.constantLight ) * 0.001f; shader = cgs.media.bryarFrontFlash; } else if ( cent->currentState.weapon == WP_BOWCASTER ) { // Hardcoded max charge time of 1 second val = ( cg.time - cent->currentState.constantLight ) * 0.001f; shader = cgs.media.greenFrontFlash; } else if ( cent->currentState.weapon == WP_DEMP2 ) { val = ( cg.time - cent->currentState.constantLight ) * 0.001f; shader = cgs.media.lightningFlash; scale = 1.75f; } if ( val < 0.0f ) { val = 0.0f; } else if ( val > 1.0f ) { val = 1.0f; if (ps && cent->currentState.number == ps->clientNum) { CGCam_Shake( /*0.1f*/0.2f, 100 ); } } else { if (ps && cent->currentState.number == ps->clientNum) { CGCam_Shake( val * val * /*0.3f*/0.6f, 100 ); } } val += random() * 0.5f; VectorCopy(flashorigin, fxSArgs.origin); VectorClear(fxSArgs.vel); VectorClear(fxSArgs.accel); fxSArgs.scale = 3.0f*val*scale; fxSArgs.dscale = 0.0f; fxSArgs.sAlpha = 0.7f; fxSArgs.eAlpha = 0.7f; fxSArgs.rotation = random()*360; fxSArgs.bounce = 0.0f; fxSArgs.life = 1.0f; fxSArgs.shader = shader; fxSArgs.flags = 0x08000000; //FX_AddSprite( flash.origin, NULL, NULL, 3.0f * val, 0.0f, 0.7f, 0.7f, WHITE, WHITE, random() * 360, 0.0f, 1.0f, shader, FX_USE_ALPHA ); trap_FX_AddSprite(&fxSArgs); } // make sure we aren't looking at cg.predictedPlayerEntity for LG nonPredictedCent = &cg_entities[cent->currentState.clientNum]; // if the index of the nonPredictedCent is not the same as the clientNum // then this is a fake player (like on teh single player podiums), so // go ahead and use the cent if( ( nonPredictedCent - cg_entities ) != cent->currentState.clientNum ) { nonPredictedCent = cent; } // add the flash if ( ( weaponNum == WP_DEMP2) && ( nonPredictedCent->currentState.eFlags & EF_FIRING ) ) { // continuous flash } else { // impulse flash if ( cg.time - cent->muzzleFlashTime > MUZZLE_FLASH_TIME) { return; } } if ( ps || cg.renderingThirdPerson || cent->currentState.number != cg.predictedPlayerState.clientNum ) { // Make sure we don't do the thirdperson model effects for the local player if we're in first person vec3_t flashorigin, flashdir; refEntity_t flash; memset (&flash, 0, sizeof(flash)); if (!thirdPerson) { CG_PositionEntityOnTag( &flash, &gun, gun.hModel, "tag_flash"); VectorCopy(flash.origin, flashorigin); VectorCopy(flash.axis[0], flashdir); } else { mdxaBone_t boltMatrix; if (!trap_G2API_HasGhoul2ModelOnIndex(&(cent->ghoul2), 1)) { //it's quite possible that we may have have no weapon model and be in a valid state, so return here if this is the case return; } // go away and get me the bolt position for this frame please if (!(trap_G2API_GetBoltMatrix(cent->ghoul2, 1, 0, &boltMatrix, newAngles, cent->lerpOrigin, cg.time, cgs.gameModels, cent->modelScale))) { // Couldn't find bolt point. return; } BG_GiveMeVectorFromMatrix(&boltMatrix, ORIGIN, flashorigin); BG_GiveMeVectorFromMatrix(&boltMatrix, POSITIVE_X, flashdir); } if ( cg.time - cent->muzzleFlashTime <= MUZZLE_FLASH_TIME + 10 ) { // Handle muzzle flashes if ( cent->currentState.eFlags & EF_ALT_FIRING ) { // Check the alt firing first. if (weapon->altMuzzleEffect) { if (!thirdPerson) { trap_FX_PlayEntityEffectID(weapon->altMuzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1 ); } else { trap_FX_PlayEffectID(weapon->altMuzzleEffect, flashorigin, flashdir, -1, -1); } } } else { // Regular firing if (weapon->muzzleEffect) { if (!thirdPerson) { trap_FX_PlayEntityEffectID(weapon->muzzleEffect, flashorigin, flash.axis, -1, -1, -1, -1 ); } else { trap_FX_PlayEffectID(weapon->muzzleEffect, flashorigin, flashdir, -1, -1); } } } } // add lightning bolt CG_LightningBolt( nonPredictedCent, flashorigin ); if ( weapon->flashDlightColor[0] || weapon->flashDlightColor[1] || weapon->flashDlightColor[2] ) { trap_R_AddLightToScene( flashorigin, 300 + (rand()&31), weapon->flashDlightColor[0], weapon->flashDlightColor[1], weapon->flashDlightColor[2] ); } } }

void CG_AddRefEntityWithPowerups (  refEntity_t *  ent, entityState_t *  state, int  team )

Definition at line 5059 of file cg_players.c. References cg, CG_IsMindTricked(), playerState_s::clientNum, entityState_t, snapshot_t::ps, cg_t::snap, trap_R_AddRefEntityToScene(), entityState_s::trickedentindex, entityState_s::trickedentindex2, entityState_s::trickedentindex3, and entityState_s::trickedentindex4. { if (CG_IsMindTricked(state->trickedentindex, state->trickedentindex2, state->trickedentindex3, state->trickedentindex4, cg.snap->ps.clientNum)) { return; //this entity is mind-tricking the current client, so don't render it } trap_R_AddRefEntityToScene( ent ); }

void CG_AddViewWeapon (  playerState_t *  ps  )

Definition at line 766 of file cg_weapons.c. References AnglesToAxis(), refEntity_t::axis, refEntity_t::backlerp, lerpFrame_t::backlerp, centity_t, cg, CG_AddPlayerWeapon(), cg_drawGun, cg_entities, cg_fov, cg_gun_frame, cg_gun_x, cg_gun_y, cg_gun_z, CG_RegisterWeapon(), cg_weapons, cgs, cgs_t::clientinfo, playerState_s::clientNum, entityState_s::clientNum, centity_s::currentState, EF_FIRING, playerState_s::eFlags, ET_NPC, entityState_s::eType, refEntity_t::frame, lerpFrame_t::frame, weaponInfo_s::handsModel, refEntity_t::hModel, vmCvar_t::integer, memset(), centity_s::npcClient, refEntity_t::oldframe, lerpFrame_t::oldFrame, refEntity_t::origin, centity_s::pe, PERS_TEAM, playerState_s::persistant, playerState_t, PM_INTERMISSION, playerState_s::pm_type, cg_t::predictedPlayerState, qfalse, cg_t::refdef, refEntity_t::renderfx, cg_t::renderingThirdPerson, RF_DEPTHHACK, RF_FIRST_PERSON, TEAM_SPECTATOR, cg_t::testGun, playerEntity_t::torso, entityState_s::torsoAnim, vmCvar_t::value, vec3_t, VectorCopy, VectorMA, refdef_t::viewaxis, refdef_t::vieworg, playerState_s::weapon, weaponInfo_t, and playerState_s::zoomMode. Referenced by CG_DrawActiveFrame(). { refEntity_t hand; centity_t *cent; clientInfo_t *ci; float fovOffset; vec3_t angles; weaponInfo_t *weapon; float cgFov = cg_fov.value; if (cgFov < 1) { cgFov = 1; } if (cgFov > 97) { cgFov = 97; } if ( ps->persistant[PERS_TEAM] == TEAM_SPECTATOR ) { return; } if ( ps->pm_type == PM_INTERMISSION ) { return; } // no gun if in third person view or a camera is active //if ( cg.renderingThirdPerson || cg.cameraMode) { if ( cg.renderingThirdPerson ) { return; } // allow the gun to be completely removed if ( !cg_drawGun.integer || cg.predictedPlayerState.zoomMode) { vec3_t origin; if ( cg.predictedPlayerState.eFlags & EF_FIRING ) { // special hack for lightning gun... VectorCopy( cg.refdef.vieworg, origin ); VectorMA( origin, -8, cg.refdef.viewaxis[2], origin ); CG_LightningBolt( &cg_entities[ps->clientNum], origin ); } return; } // don't draw if testing a gun model if ( cg.testGun ) { return; } // drop gun lower at higher fov if ( cgFov > 90 ) { fovOffset = -0.2 * ( cgFov - 90 ); } else { fovOffset = 0; } cent = &cg_entities[cg.predictedPlayerState.clientNum]; CG_RegisterWeapon( ps->weapon ); weapon = &cg_weapons[ ps->weapon ]; memset (&hand, 0, sizeof(hand)); // set up gun position CG_CalculateWeaponPosition( hand.origin, angles ); VectorMA( hand.origin, cg_gun_x.value, cg.refdef.viewaxis[0], hand.origin ); VectorMA( hand.origin, cg_gun_y.value, cg.refdef.viewaxis[1], hand.origin ); VectorMA( hand.origin, (cg_gun_z.value+fovOffset), cg.refdef.viewaxis[2], hand.origin ); AnglesToAxis( angles, hand.axis ); // map torso animations to weapon animations if ( cg_gun_frame.integer ) { // development tool hand.frame = hand.oldframe = cg_gun_frame.integer; hand.backlerp = 0; } else { // get clientinfo for animation map if (cent->currentState.eType == ET_NPC) { if (!cent->npcClient) { return; } ci = cent->npcClient; } else { ci = &cgs.clientinfo[ cent->currentState.clientNum ]; } hand.frame = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.frame, cent->currentState.torsoAnim ); hand.oldframe = CG_MapTorsoToWeaponFrame( ci, cent->pe.torso.oldFrame, cent->currentState.torsoAnim ); hand.backlerp = cent->pe.torso.backlerp; // Handle the fringe situation where oldframe is invalid if ( hand.frame == -1 ) { hand.frame = 0; hand.oldframe = 0; hand.backlerp = 0; } else if ( hand.oldframe == -1 ) { hand.oldframe = hand.frame; hand.backlerp = 0; } } hand.hModel = weapon->handsModel; hand.renderfx = RF_DEPTHHACK | RF_FIRST_PERSON;// | RF_MINLIGHT; // add everything onto the hand CG_AddPlayerWeapon( &hand, ps, &cg_entities[cg.predictedPlayerState.clientNum], ps->persistant[PERS_TEAM], angles, qfalse ); }

void CG_AdjustPositionForMover (  const vec3_t  in, int  moverNum, int  fromTime, int  toTime, vec3_t  out )

Definition at line 2994 of file cg_ents.c. References entityState_s::apos, BG_EvaluateTrajectory(), centity_t, cg_entities, centity_s::currentState, ENTITYNUM_MAX_NORMAL, ET_MOVER, entityState_s::eType, entityState_s::pos, vec3_t, VectorAdd, VectorCopy, and VectorSubtract. Referenced by CG_CalcEntityLerpPositions(), and CG_PredictPlayerState(). { centity_t *cent; vec3_t oldOrigin, origin, deltaOrigin; vec3_t oldAngles, angles, deltaAngles; if ( moverNum <= 0 || moverNum >= ENTITYNUM_MAX_NORMAL ) { VectorCopy( in, out ); return; } cent = &cg_entities[ moverNum ]; if ( cent->currentState.eType != ET_MOVER ) { VectorCopy( in, out ); return; } BG_EvaluateTrajectory( &cent->currentState.pos, fromTime, oldOrigin ); BG_EvaluateTrajectory( &cent->currentState.apos, fromTime, oldAngles ); BG_EvaluateTrajectory( &cent->currentState.pos, toTime, origin ); BG_EvaluateTrajectory( &cent->currentState.apos, toTime, angles ); VectorSubtract( origin, oldOrigin, deltaOrigin ); VectorSubtract( angles, oldAngles, deltaAngles ); VectorAdd( in, deltaOrigin, out ); // FIXME: origin change when on a rotating object }

localEntity_t* CG_AllocLocalEntity (  void   )

Definition at line 60 of file cg_localents.c. References cg_activeLocalEntities, cg_freeLocalEntities, CG_FreeLocalEntity(), localEntity_t, memset(), localEntity_s::next, and localEntity_s::prev. Referenced by CG_Bleed(), CG_BubbleTrail(), CG_Chunks(), CG_LaunchGib(), CG_MakeExplosion(), CG_ScorePlum(), CG_SmokePuff(), CG_TestLine(), CG_ThrowChunk(), FX_AddOrientedLine(), and FX_DEMP2_AltDetonate(). { localEntity_t *le; if ( !cg_freeLocalEntities ) { // no free entities, so free the one at the end of the chain // remove the oldest active entity CG_FreeLocalEntity( cg_activeLocalEntities.prev ); } le = cg_freeLocalEntities; cg_freeLocalEntities = cg_freeLocalEntities->next; memset( le, 0, sizeof( *le ) ); // link into the active list le->next = cg_activeLocalEntities.next; le->prev = &cg_activeLocalEntities; cg_activeLocalEntities.next->prev = le; cg_activeLocalEntities.next = le; return le; }

const char* CG_Argv (  int  arg  )

Definition at line 1263 of file cg_main.c. References MAX_STRING_CHARS, and trap_Argv(). Referenced by CG_ConsoleCommand(), CG_ParseSiegeExtendedData(), CG_TestModel_f(), CG_Weapon_f(), and CG_WeaponClean_f(). { static char buffer[MAX_STRING_CHARS]; trap_Argv( arg, buffer, sizeof( buffer ) ); return buffer; }

void CG_Beam (  centity_t *  cent  )

Definition at line 2921 of file cg_ents.c. References refEntity_t::axis, AxisClear(), centity_t, CG_SetGhoul2Info(), centity_s::currentState, entityState_t, memset(), refEntity_t::oldorigin, refEntity_t::origin, entityState_s::origin2, entityState_s::pos, refEntity_t::renderfx, refEntity_t::reType, RF_NOSHADOW, RT_BEAM, trap_R_AddRefEntityToScene(), trajectory_t::trBase, and VectorCopy. Referenced by CG_EntityEvent(). { refEntity_t ent; entityState_t *s1; s1 = &cent->currentState; // create the render entity memset (&ent, 0, sizeof(ent)); VectorCopy( s1->pos.trBase, ent.origin ); VectorCopy( s1->origin2, ent.oldorigin ); AxisClear( ent.axis ); ent.reType = RT_BEAM; ent.renderfx = RF_NOSHADOW; /* Ghoul2 Insert Start */ CG_SetGhoul2Info(&ent, cent); /* Ghoul2 Insert End */ // add to refresh list trap_R_AddRefEntityToScene(&ent); }

void CG_Bleed (  vec3_t  origin, int  entityNum )

Definition at line 1489 of file cg_effects.c. References cg, CG_AllocLocalEntity(), cg_blood, playerState_s::clientNum, refEntity_t::customShader, localEntity_s::endTime, vmCvar_t::integer, LE_EXPLOSION, localEntity_s::leType, localEntity_t, refEntity_t::origin, snapshot_t::ps, refEntity_t::radius, rand(), localEntity_s::refEntity, refEntity_t::renderfx, refEntity_t::reType, RF_THIRD_PERSON, refEntity_t::rotation, RT_SPRITE, cg_t::snap, localEntity_s::startTime, cg_t::time, vec3_t, and VectorCopy. { localEntity_t *ex; if ( !cg_blood.integer ) { return; } ex = CG_AllocLocalEntity(); ex->leType = LE_EXPLOSION; ex->startTime = cg.time; ex->endTime = ex->startTime + 500; VectorCopy ( origin, ex->refEntity.origin); ex->refEntity.reType = RT_SPRITE; ex->refEntity.rotation = rand() % 360; ex->refEntity.radius = 24; ex->refEntity.customShader = 0;//cgs.media.bloodExplosionShader; // don't show player's own blood in view if ( entityNum == cg.snap->ps.clientNum ) { ex->refEntity.renderfx |= RF_THIRD_PERSON; } }

void CG_BubbleTrail (  vec3_t  start, vec3_t  end, float  spacing )

Definition at line 15 of file cg_effects.c. References cg, CG_AllocLocalEntity(), cg_noProjectileTrail, localEntity_s::color, crandom, refEntity_t::customShader, localEntity_s::endTime, vmCvar_t::integer, LE_MOVE_SCALE_FADE, LEF_PUFF_DONT_SCALE, localEntity_s::leFlags, localEntity_s::leType, localEntity_s::lifeRate, localEntity_t, localEntity_s::pos, refEntity_t::radius, rand(), random, localEntity_s::refEntity, refEntity_t::reType, refEntity_t::rotation, RT_SPRITE, refEntity_t::shaderRGBA, refEntity_t::shaderTime, localEntity_s::startTime, cg_t::time, TR_LINEAR, trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, vec3_t, VectorAdd, VectorCopy, VectorMA, VectorNormalize(), VectorScale, and VectorSubtract. { vec3_t move; vec3_t vec; float len; int i; if ( cg_noProjectileTrail.integer ) { return; } VectorCopy (start, move); VectorSubtract (end, start, vec); len = VectorNormalize (vec); // advance a random amount first i = rand() % (int)spacing; VectorMA( move, i, vec, move ); VectorScale (vec, spacing, vec); for ( ; i < len; i += spacing ) { localEntity_t *le; refEntity_t *re; le = CG_AllocLocalEntity(); le->leFlags = LEF_PUFF_DONT_SCALE; le->leType = LE_MOVE_SCALE_FADE; le->startTime = cg.time; le->endTime = cg.time + 1000 + random() * 250; le->lifeRate = 1.0 / ( le->endTime - le->startTime ); re = &le->refEntity; re->shaderTime = cg.time / 1000.0f; re->reType = RT_SPRITE; re->rotation = 0; re->radius = 3; re->customShader = 0;//cgs.media.waterBubbleShader; re->shaderRGBA[0] = 0xff; re->shaderRGBA[1] = 0xff; re->shaderRGBA[2] = 0xff; re->shaderRGBA[3] = 0xff; le->color[3] = 1.0; le->pos.trType = TR_LINEAR; le->pos.trTime = cg.time; VectorCopy( move, le->pos.trBase ); le->pos.trDelta[0] = crandom()*5; le->pos.trDelta[1] = crandom()*5; le->pos.trDelta[2] = crandom()*5 + 6; VectorAdd (move, vec, move); } }

void CG_BuildSolidList (  void   )

Definition at line 46 of file cg_predict.c. References centity_t, cg, cg_entities, cg_numpermanents, cg_permanents, playerState_s::clientNum, centity_s::currentState, centity_s::currentValid, DEFAULT_MAXS_2, DEFAULT_MINS_2, snapshot_t::entities, entityState_t, ET_ITEM, ET_PUSH_TRIGGER, ET_TELEPORT_TRIGGER, ET_TERRAIN, entityState_s::eType, centity_s::lerpOrigin, MAX_ENTITIES_IN_SNAPSHOT, cg_t::nextFrameTeleport, cg_t::nextSnap, centity_s::nextState, entityState_s::number, snapshot_t::numEntities, playerState_s::origin, playerMaxs, playerMins, cg_t::predictedPlayerState, snapshot_t::ps, qfalse, qtrue, cg_t::snap, entityState_s::solid, cg_t::thisFrameTeleport, vec3_t, and VectorSubtract. Referenced by CG_SetInitialSnapshot(). { int i; centity_t *cent; snapshot_t *snap; entityState_t *ent; vec3_t difference; float dsquared; cg_numSolidEntities = 0; cg_numTriggerEntities = 0; if ( cg.nextSnap && !cg.nextFrameTeleport && !cg.thisFrameTeleport ) { snap = cg.nextSnap; } else { snap = cg.snap; } for ( i = 0 ; i < snap->numEntities ; i++ ) { cent = &cg_entities[ snap->entities[ i ].number ]; ent = &cent->currentState; if ( ent->eType == ET_ITEM || ent->eType == ET_PUSH_TRIGGER || ent->eType == ET_TELEPORT_TRIGGER ) { cg_triggerEntities[cg_numTriggerEntities] = cent; cg_numTriggerEntities++; continue; } if ( cent->nextState.solid ) { cg_solidEntities[cg_numSolidEntities] = cent; cg_numSolidEntities++; continue; } } //rww - Horrible, terrible, awful hack. //We don't send your client entity from the server, //so it isn't added into the solid list from the snapshot, //and in addition, it has no solid data. So we will force //adding it in based on a hardcoded player bbox size. //This will cause issues if the player box size is ever //changed.. if (cg_numSolidEntities < MAX_ENTITIES_IN_SNAPSHOT) { vec3_t playerMins = {-15, -15, DEFAULT_MINS_2}; vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2}; int i, j, k; i = playerMaxs[0]; if (i<1) i = 1; if (i>255) i = 255; // z is not symetric j = (-playerMins[2]); if (j<1) j = 1; if (j>255) j = 255; // and z playerMaxs can be negative... k = (playerMaxs[2]+32); if (k<1) k = 1; if (k>255) k = 255; cg_solidEntities[cg_numSolidEntities] = &cg_entities[cg.predictedPlayerState.clientNum]; cg_solidEntities[cg_numSolidEntities]->currentState.solid = (k<<16) | (j<<8) | i; cg_numSolidEntities++; } dsquared = /*RMG_distancecull.value*/5000+500; dsquared *= dsquared; for(i=0;i<cg_numpermanents;i++) { cent = cg_permanents[i]; VectorSubtract(cent->lerpOrigin, snap->ps.origin, difference); if (cent->currentState.eType == ET_TERRAIN || ((difference[0]*difference[0]) + (difference[1]*difference[1]) + (difference[2]*difference[2])) <= dsquared) { cent->currentValid = qtrue; if ( cent->nextState.solid ) { cg_solidEntities[cg_numSolidEntities] = cent; cg_numSolidEntities++; } } else { cent->currentValid = qfalse; } } }

void CG_BuildSpectatorString (  void   )

Definition at line 2480 of file cg_main.c. References cg, CG_SiegeCountCvars(), cgs, cgs_t::clientinfo, clientInfo_t::infoValid, MAX_CLIENTS, clientInfo_t::name, Q_strcat(), cg_t::spectatorLen, cg_t::spectatorList, cg_t::spectatorWidth, strlen(), clientInfo_t::team, TEAM_SPECTATOR, and va(). { int i; cg.spectatorList[0] = 0; // Count up the number of players per team and per class CG_SiegeCountCvars(); for (i = 0; i < MAX_CLIENTS; i++) { if (cgs.clientinfo[i].infoValid && cgs.clientinfo[i].team == TEAM_SPECTATOR ) { Q_strcat(cg.spectatorList, sizeof(cg.spectatorList), va("%s ", cgs.clientinfo[i].name)); } } i = strlen(cg.spectatorList); if (i != cg.spectatorLen) { cg.spectatorLen = i; cg.spectatorWidth = -1; } }

void CG_CenterPrint (  const char *  str, int  y, int  charWidth )

Definition at line 4398 of file cg_draw.c. References cg_t::centerPrint, cg_t::centerPrintCharWidth, cg_t::centerPrintLines, cg_t::centerPrintTime, cg_t::centerPrintY, cg, Q_strncpyz(), and cg_t::time. Referenced by Board(), CG_DrawSiegeMessageNonMenu(), and CG_EntityEvent(). { char *s; Q_strncpyz( cg.centerPrint, str, sizeof(cg.centerPrint) ); cg.centerPrintTime = cg.time; cg.centerPrintY = y; cg.centerPrintCharWidth = charWidth; // count the number of lines for centering cg.centerPrintLines = 1; s = cg.centerPrint; while( *s ) { if (*s == '\n') cg.centerPrintLines++; s++; } }

void CG_CheckChangedPredictableEvents (  playerState_t *  ps  )

Definition at line 257 of file cg_playerstate.c. References centity_t, cg, cg_entities, CG_EntityEvent(), CG_Printf(), cg_showmiss, playerState_s::clientNum, centity_s::currentState, entityState_s::event, entityState_s::eventParm, playerState_s::eventParms, playerState_s::events, playerState_s::eventSequence, cg_t::eventSequence, vmCvar_t::integer, centity_s::lerpOrigin, MAX_PREDICTED_EVENTS, MAX_PS_EVENTS, playerState_t, and cg_t::predictableEvents. { int i; int event; centity_t *cent; cent = &cg_entities[ps->clientNum]; for ( i = ps->eventSequence - MAX_PS_EVENTS ; i < ps->eventSequence ; i++ ) { // if (i >= cg.eventSequence) { continue; } // if this event is not further back in than the maximum predictable events we remember if (i > cg.eventSequence - MAX_PREDICTED_EVENTS) { // if the new playerstate event is different from a previously predicted one if ( ps->events[i & (MAX_PS_EVENTS-1)] != cg.predictableEvents[i & (MAX_PREDICTED_EVENTS-1) ] ) { event = ps->events[ i & (MAX_PS_EVENTS-1) ]; cent->currentState.event = event; cent->currentState.eventParm = ps->eventParms[ i & (MAX_PS_EVENTS-1) ]; CG_EntityEvent( cent, cent->lerpOrigin ); cg.predictableEvents[ i & (MAX_PREDICTED_EVENTS-1) ] = event; if ( cg_showmiss.integer ) { CG_Printf("WARNING: changed predicted event\n"); } } } } }

void CG_CheckEvents (  centity_t *  cent  )

Definition at line 3526 of file cg_event.c. References BG_EvaluateTrajectory(), centity_t, cg, CG_EntityEvent(), CG_SetEntitySoundPosition(), centity_s::currentState, EF_PLAYER_EVENT, entityState_s::eFlags, ET_EVENTS, entityState_s::eType, EV_EVENT_BITS, entityState_s::event, centity_s::lerpOrigin, entityState_s::number, entityState_s::otherEntityNum, entityState_s::pos, centity_s::previousEvent, snapshot_t::serverTime, and cg_t::snap. Referenced by CG_SetInitialSnapshot(). { // check for event-only entities if ( cent->currentState.eType > ET_EVENTS ) { if ( cent->previousEvent ) { return; // already fired } // if this is a player event set the entity number of the client entity number if ( cent->currentState.eFlags & EF_PLAYER_EVENT ) { cent->currentState.number = cent->currentState.otherEntityNum; } cent->previousEvent = 1; cent->currentState.event = cent->currentState.eType - ET_EVENTS; } else { // check for events riding with another entity if ( cent->currentState.event == cent->previousEvent ) { return; } cent->previousEvent = cent->currentState.event; if ( ( cent->currentState.event & ~EV_EVENT_BITS ) == 0 ) { return; } } // calculate the position at exactly the frame time BG_EvaluateTrajectory( &cent->currentState.pos, cg.snap->serverTime, cent->lerpOrigin ); CG_SetEntitySoundPosition( cent ); CG_EntityEvent( cent, cent->lerpOrigin ); }

void CG_CheckPlayerG2Weapons (  playerState_t *  ps, centity_t *  cent )

Definition at line 2494 of file cg_weapons.c. References BG_SI_SetDesiredLength(), centity_t, CG_CopyG2WeaponInstance(), cg_entities, CG_G2WeaponInstance(), cgs, CHAN_AUTO, cgs_t::clientinfo, playerState_s::clientNum, centity_s::currentState, EF_DEAD, entityState_s::eFlags, ET_NPC, entityState_s::eType, centity_s::ghoul2, centity_s::ghoul2weapon, centity_s::lerpOrigin, NULL, entityState_s::number, PERS_TEAM, playerState_s::persistant, playerState_t, playerState_s::pm_flags, PMF_FOLLOW, playerState_s::saberHolstered, entityState_s::saberInFlight, centity_s::saberWasInFlight, TEAM_SPECTATOR, centity_s::torsoBolt, trap_S_StartSound(), centity_s::weapon, playerState_s::weapon, and WP_SABER. Referenced by CG_AddPacketEntities(). { if (!ps) { assert(0); return; } if (ps->pm_flags & PMF_FOLLOW) { return; } if (cent->currentState.eType == ET_NPC) { assert(0); return; } // should we change the gun model on this player? if (cent->currentState.saberInFlight) { cent->ghoul2weapon = CG_G2WeaponInstance(cent, WP_SABER); } if (cent->currentState.eFlags & EF_DEAD) { //no updating weapons when dead cent->ghoul2weapon = NULL; return; } if (cent->torsoBolt) { //got our limb cut off, no updating weapons until it's restored cent->ghoul2weapon = NULL; return; } if (cgs.clientinfo[ps->clientNum].team == TEAM_SPECTATOR || ps->persistant[PERS_TEAM] == TEAM_SPECTATOR) { cent->ghoul2weapon = cg_entities[ps->clientNum].ghoul2weapon = NULL; cent->weapon = cg_entities[ps->clientNum].weapon = 0; return; } if (cent->ghoul2 && cent->ghoul2weapon != CG_G2WeaponInstance(cent, ps->weapon) && ps->clientNum == cent->currentState.number) //don't want spectator mode forcing one client's weapon instance over another's { CG_CopyG2WeaponInstance(cent, ps->weapon, cent->ghoul2); cent->ghoul2weapon = CG_G2WeaponInstance(cent, ps->weapon); if (cent->weapon == WP_SABER && cent->weapon != ps->weapon && !ps->saberHolstered) { //switching away from the saber //trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" )); if (cgs.clientinfo[ps->clientNum].saber[0].soundOff && !ps->saberHolstered) { trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[0].soundOff); } if (cgs.clientinfo[ps->clientNum].saber[1].soundOff && cgs.clientinfo[ps->clientNum].saber[1].model[0] && !ps->saberHolstered) { trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[1].soundOff); } } else if (ps->weapon == WP_SABER && cent->weapon != ps->weapon && !cent->saberWasInFlight) { //switching to the saber //trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" )); if (cgs.clientinfo[ps->clientNum].saber[0].soundOn) { trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[0].soundOn); } if (cgs.clientinfo[ps->clientNum].saber[1].soundOn) { trap_S_StartSound(cent->lerpOrigin, cent->currentState.number, CHAN_AUTO, cgs.clientinfo[ps->clientNum].saber[1].soundOn); } BG_SI_SetDesiredLength(&cgs.clientinfo[ps->clientNum].saber[0], 0, -1); BG_SI_SetDesiredLength(&cgs.clientinfo[ps->clientNum].saber[1], 0, -1); } cent->weapon = ps->weapon; } }

void CG_Chunks (  int  owner, vec3_t  origin, const vec3_t  normal, const vec3_t  mins, const vec3_t  maxs, float  speed, int  numChunks, material_t  chunkType, int  customChunk, float  baseScale )

Definition at line 1061 of file cg_effects.c. References localEntity_s::angles, refEntity_t::axis, AxisCopy(), axisDefault, localEntity_s::bounceFactor, cg, CG_AllocLocalEntity(), cgs, CHAN_BODY, CHUNK_CRATE1, CHUNK_CRATE2, CHUNK_METAL1, CHUNK_METAL2, CHUNK_ROCK1, CHUNK_ROCK2, CHUNK_ROCK3, CHUNK_WHITE_METAL, cgMedia_t::chunkModels, cgMedia_t::chunkSound, crandom, cgMedia_t::crateBreakSound, localEntity_s::endTime, flrand(), cgs_t::gameModels, cgMedia_t::glassChunkSound, cgMedia_t::grateSound, refEntity_t::hModel, LE_FRAGMENT, localEntity_s::leBounceSoundType, leBounceSoundType_t, LEBS_METAL, LEBS_NONE, LEBS_ROCK, LEF_TUMBLE, localEntity_s::leFlags, localEntity_s::leType, localEntity_t, MAT_CRATE1, MAT_CRATE2, MAT_DRK_STONE, MAT_ELEC_METAL, MAT_ELECTRICAL, MAT_GLASS, MAT_GLASS_METAL, MAT_GRATE1, MAT_GREY_STONE, MAT_LT_STONE, MAT_METAL, MAT_METAL2, MAT_METAL3, MAT_NONE, MAT_ROPE, MAT_SNOWY_ROCK, MAT_WHITE_METAL, material_t, cgs_t::media, refEntity_t::modelScale, refEntity_t::nonNormalizedAxes, NULL, refEntity_t::origin, localEntity_s::pos, Q_irand(), qboolean, qfalse, qtrue, localEntity_s::radius, rand(), random, localEntity_s::refEntity, cgMedia_t::rockBreakSound, ScaleModelAxis(), cg_t::time, TR_GRAVITY, TR_LINEAR, trap_S_RegisterSound(), trap_S_StartSound(), trajectory_t::trBase, trajectory_t::trDelta, trajectory_t::trTime, trajectory_t::trType, va(), vec3_t, VectorCopy, VectorNormalize(), VectorScale, VectorSet, and VectorSubtract. Referenced by CG_EntityEvent(). { localEntity_t *le; refEntity_t *re; vec3_t dir; int i, j, k; int chunkModel = 0; leBounceSoundType_t bounce = LEBS_NONE; float r, speedMod = 1.0f; qboolean chunk = qfalse; if ( chunkType == MAT_NONE ) { // Well, we should do nothing return; } // Set up our chunk sound info...breaking sounds are done here so they are done once on breaking..some return instantly because the chunks are done with effects instead of models switch( chunkType ) { case MAT_GLASS: trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.glassChunkSound ); return; break; case MAT_GRATE1: trap_S_StartSound( NULL, owner, CHAN_BODY, cgs.media.grateSound ); return; break; case MAT_ELECTRICAL:// (sparks) trap_S_StartSound( NULL, owner, CHAN_BODY, trap_S_RegisterSound (va("sound/ambience/spark%d.wav", Q_irand(1, 6))) ); return; break; case MAT_DRK_STONE: case MAT_LT_STONE: case