mirror of
https://github.com/ioquake/jedi-academy.git
synced 2024-11-22 04:11:57 +00:00
6e05e1552e
CVE-2006-3401 Stack-based buffer overflow in Quake 3 Engine as used by Quake 3: Arena 1.32b and 1.32c allows remote attackers to cause a denial of service and possibly execute code via long CS_ITEMS values. from Thilo Schulz in ioquake3 svn 813 git fc244c97ef1a5f1c6e7c1f46a098c8f57f271153 Fix critical buffer overflow in cgame, see exploit at http://www.milw0rm.com/exploits/1977
4170 lines
120 KiB
C
4170 lines
120 KiB
C
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
// cg_main.c -- initialization and primary entry point for cgame
|
|
#include "cg_local.h"
|
|
|
|
#include "../ui/ui_shared.h"
|
|
// display context for new ui stuff
|
|
displayContextDef_t cgDC;
|
|
|
|
#if !defined(CL_LIGHT_H_INC)
|
|
#include "cg_lights.h"
|
|
#endif
|
|
|
|
extern int cgSiegeRoundState;
|
|
extern int cgSiegeRoundTime;
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
void CG_InitItems(void);
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
void CG_InitJetpackGhoul2(void);
|
|
void CG_CleanJetpackGhoul2(void);
|
|
|
|
vec4_t colorTable[CT_MAX] =
|
|
{
|
|
{0, 0, 0, 0}, // CT_NONE
|
|
{0, 0, 0, 1}, // CT_BLACK
|
|
{1, 0, 0, 1}, // CT_RED
|
|
{0, 1, 0, 1}, // CT_GREEN
|
|
{0, 0, 1, 1}, // CT_BLUE
|
|
{1, 1, 0, 1}, // CT_YELLOW
|
|
{1, 0, 1, 1}, // CT_MAGENTA
|
|
{0, 1, 1, 1}, // CT_CYAN
|
|
{1, 1, 1, 1}, // CT_WHITE
|
|
{0.75f, 0.75f, 0.75f, 1}, // CT_LTGREY
|
|
{0.50f, 0.50f, 0.50f, 1}, // CT_MDGREY
|
|
{0.25f, 0.25f, 0.25f, 1}, // CT_DKGREY
|
|
{0.15f, 0.15f, 0.15f, 1}, // CT_DKGREY2
|
|
|
|
{0.810f, 0.530f, 0.0f, 1}, // CT_VLTORANGE -- needs values
|
|
{0.810f, 0.530f, 0.0f, 1}, // CT_LTORANGE
|
|
{0.610f, 0.330f, 0.0f, 1}, // CT_DKORANGE
|
|
{0.402f, 0.265f, 0.0f, 1}, // CT_VDKORANGE
|
|
|
|
{0.503f, 0.375f, 0.996f, 1}, // CT_VLTBLUE1
|
|
{0.367f, 0.261f, 0.722f, 1}, // CT_LTBLUE1
|
|
{0.199f, 0.0f, 0.398f, 1}, // CT_DKBLUE1
|
|
{0.160f, 0.117f, 0.324f, 1}, // CT_VDKBLUE1
|
|
|
|
{0.300f, 0.628f, 0.816f, 1}, // CT_VLTBLUE2 -- needs values
|
|
{0.300f, 0.628f, 0.816f, 1}, // CT_LTBLUE2
|
|
{0.191f, 0.289f, 0.457f, 1}, // CT_DKBLUE2
|
|
{0.125f, 0.250f, 0.324f, 1}, // CT_VDKBLUE2
|
|
|
|
{0.796f, 0.398f, 0.199f, 1}, // CT_VLTBROWN1 -- needs values
|
|
{0.796f, 0.398f, 0.199f, 1}, // CT_LTBROWN1
|
|
{0.558f, 0.207f, 0.027f, 1}, // CT_DKBROWN1
|
|
{0.328f, 0.125f, 0.035f, 1}, // CT_VDKBROWN1
|
|
|
|
{0.996f, 0.796f, 0.398f, 1}, // CT_VLTGOLD1 -- needs values
|
|
{0.996f, 0.796f, 0.398f, 1}, // CT_LTGOLD1
|
|
{0.605f, 0.441f, 0.113f, 1}, // CT_DKGOLD1
|
|
{0.386f, 0.308f, 0.148f, 1}, // CT_VDKGOLD1
|
|
|
|
{0.648f, 0.562f, 0.784f, 1}, // CT_VLTPURPLE1 -- needs values
|
|
{0.648f, 0.562f, 0.784f, 1}, // CT_LTPURPLE1
|
|
{0.437f, 0.335f, 0.597f, 1}, // CT_DKPURPLE1
|
|
{0.308f, 0.269f, 0.375f, 1}, // CT_VDKPURPLE1
|
|
|
|
{0.816f, 0.531f, 0.710f, 1}, // CT_VLTPURPLE2 -- needs values
|
|
{0.816f, 0.531f, 0.710f, 1}, // CT_LTPURPLE2
|
|
{0.566f, 0.269f, 0.457f, 1}, // CT_DKPURPLE2
|
|
{0.343f, 0.226f, 0.316f, 1}, // CT_VDKPURPLE2
|
|
|
|
{0.929f, 0.597f, 0.929f, 1}, // CT_VLTPURPLE3
|
|
{0.570f, 0.371f, 0.570f, 1}, // CT_LTPURPLE3
|
|
{0.355f, 0.199f, 0.355f, 1}, // CT_DKPURPLE3
|
|
{0.285f, 0.136f, 0.230f, 1}, // CT_VDKPURPLE3
|
|
|
|
{0.953f, 0.378f, 0.250f, 1}, // CT_VLTRED1
|
|
{0.953f, 0.378f, 0.250f, 1}, // CT_LTRED1
|
|
{0.593f, 0.121f, 0.109f, 1}, // CT_DKRED1
|
|
{0.429f, 0.171f, 0.113f, 1}, // CT_VDKRED1
|
|
{.25f, 0, 0, 1}, // CT_VDKRED
|
|
{.70f, 0, 0, 1}, // CT_DKRED
|
|
|
|
{0.717f, 0.902f, 1.0f, 1}, // CT_VLTAQUA
|
|
{0.574f, 0.722f, 0.804f, 1}, // CT_LTAQUA
|
|
{0.287f, 0.361f, 0.402f, 1}, // CT_DKAQUA
|
|
{0.143f, 0.180f, 0.201f, 1}, // CT_VDKAQUA
|
|
|
|
{0.871f, 0.386f, 0.375f, 1}, // CT_LTPINK
|
|
{0.435f, 0.193f, 0.187f, 1}, // CT_DKPINK
|
|
{ 0, .5f, .5f, 1}, // CT_LTCYAN
|
|
{ 0, .25f, .25f, 1}, // CT_DKCYAN
|
|
{ .179f, .51f, .92f, 1}, // CT_LTBLUE3
|
|
{ .199f, .71f, .92f, 1}, // CT_LTBLUE3
|
|
{ .5f, .05f, .4f, 1}, // CT_DKBLUE3
|
|
|
|
{ 0.0f, .613f, .097f, 1}, // CT_HUD_GREEN
|
|
{ 0.835f, .015f, .015f, 1}, // CT_HUD_RED
|
|
{ .567f, .685f, 1.0f, .75f}, // CT_ICON_BLUE
|
|
{ .515f, .406f, .507f, 1}, // CT_NO_AMMO_RED
|
|
{ 1.0f, .658f, .062f, 1}, // CT_HUD_ORANGE
|
|
|
|
};
|
|
|
|
#include "holocronicons.h"
|
|
|
|
int cgWeatherOverride = 0;
|
|
|
|
int forceModelModificationCount = -1;
|
|
|
|
void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum );
|
|
void CG_Shutdown( void );
|
|
|
|
void CG_CalcEntityLerpPositions( centity_t *cent );
|
|
void CG_ROFF_NotetrackCallback( centity_t *cent, const char *notetrack);
|
|
|
|
#include "../namespace_begin.h"
|
|
void UI_CleanupGhoul2(void);
|
|
#include "../namespace_end.h"
|
|
|
|
static int C_PointContents(void);
|
|
static void C_GetLerpOrigin(void);
|
|
static void C_GetLerpData(void);
|
|
static void C_Trace(void);
|
|
static void C_G2Trace(void);
|
|
static void C_G2Mark(void);
|
|
static int CG_RagCallback(int callType);
|
|
static void C_GetBoltPos(void);
|
|
static void C_ImpactMark(void);
|
|
|
|
#ifdef _XBOX
|
|
#define MAX_MISC_ENTS 500
|
|
#else
|
|
#define MAX_MISC_ENTS 4000
|
|
#endif
|
|
|
|
//static refEntity_t *MiscEnts = 0;
|
|
//static float *Radius = 0;
|
|
static refEntity_t MiscEnts[MAX_MISC_ENTS]; //statically allocated for now.
|
|
static float Radius[MAX_MISC_ENTS];
|
|
static float zOffset[MAX_MISC_ENTS]; //some models need a z offset for culling, because of stupid wrong model origins
|
|
|
|
static int NumMiscEnts = 0;
|
|
|
|
extern autoMapInput_t cg_autoMapInput; //cg_view.c
|
|
extern int cg_autoMapInputTime;
|
|
extern vec3_t cg_autoMapAngle;
|
|
|
|
void CG_MiscEnt(void);
|
|
void CG_DoCameraShake( vec3_t origin, float intensity, int radius, int time );
|
|
|
|
//do we have any force powers that we would normally need to cycle to?
|
|
qboolean CG_NoUseableForce(void)
|
|
{
|
|
int i = FP_HEAL;
|
|
while (i < NUM_FORCE_POWERS)
|
|
{
|
|
if (i != FP_SABERTHROW &&
|
|
i != FP_SABER_OFFENSE &&
|
|
i != FP_SABER_DEFENSE &&
|
|
i != FP_LEVITATION)
|
|
{ //valid selectable power
|
|
if (cg.predictedPlayerState.fd.forcePowersKnown & (1 << i))
|
|
{ //we have it
|
|
return qfalse;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
|
|
//no useable force powers, I guess.
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
================
|
|
vmMain
|
|
|
|
This is the only way control passes into the module.
|
|
This must be the very first function compiled into the .q3vm file
|
|
================
|
|
*/
|
|
#include "../namespace_begin.h"
|
|
int vmMain( int command, int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10, int arg11 ) {
|
|
|
|
switch ( command ) {
|
|
case CG_INIT:
|
|
CG_Init( arg0, arg1, arg2 );
|
|
return 0;
|
|
case CG_SHUTDOWN:
|
|
CG_Shutdown();
|
|
return 0;
|
|
case CG_CONSOLE_COMMAND:
|
|
return CG_ConsoleCommand();
|
|
case CG_DRAW_ACTIVE_FRAME:
|
|
CG_DrawActiveFrame( arg0, arg1, arg2 );
|
|
return 0;
|
|
case CG_CROSSHAIR_PLAYER:
|
|
return CG_CrosshairPlayer();
|
|
case CG_LAST_ATTACKER:
|
|
return CG_LastAttacker();
|
|
case CG_KEY_EVENT:
|
|
CG_KeyEvent(arg0, arg1);
|
|
return 0;
|
|
case CG_MOUSE_EVENT:
|
|
cgDC.cursorx = cgs.cursorX;
|
|
cgDC.cursory = cgs.cursorY;
|
|
CG_MouseEvent(arg0, arg1);
|
|
return 0;
|
|
case CG_EVENT_HANDLING:
|
|
CG_EventHandling(arg0);
|
|
return 0;
|
|
|
|
case CG_POINT_CONTENTS:
|
|
return C_PointContents();
|
|
|
|
case CG_GET_LERP_ORIGIN:
|
|
C_GetLerpOrigin();
|
|
return 0;
|
|
|
|
case CG_GET_LERP_DATA:
|
|
C_GetLerpData();
|
|
return 0;
|
|
|
|
case CG_GET_GHOUL2:
|
|
return (int)cg_entities[arg0].ghoul2; //NOTE: This is used by the effect bolting which is actually not used at all.
|
|
//I'm fairly sure if you try to use it with vm's it will just give you total
|
|
//garbage. In other words, use at your own risk.
|
|
|
|
case CG_GET_MODEL_LIST:
|
|
return (int)cgs.gameModels;
|
|
|
|
case CG_CALC_LERP_POSITIONS:
|
|
CG_CalcEntityLerpPositions( &cg_entities[arg0] );
|
|
return 0;
|
|
|
|
case CG_TRACE:
|
|
C_Trace();
|
|
return 0;
|
|
case CG_GET_SORTED_FORCE_POWER:
|
|
return forcePowerSorted[arg0];
|
|
case CG_G2TRACE:
|
|
C_G2Trace();
|
|
return 0;
|
|
|
|
case CG_G2MARK:
|
|
C_G2Mark();
|
|
return 0;
|
|
|
|
case CG_RAG_CALLBACK:
|
|
return CG_RagCallback(arg0);
|
|
|
|
case CG_INCOMING_CONSOLE_COMMAND:
|
|
//rww - let mod authors filter client console messages so they can cut them off if they want.
|
|
//return 1 if the command is ok. Otherwise, you can set char 0 on the command str to 0 and return
|
|
//0 to not execute anything, or you can fill conCommand in with something valid and return 0
|
|
//in order to have that string executed in place. Some example code:
|
|
#if 0
|
|
{
|
|
TCGIncomingConsoleCommand *icc = (TCGIncomingConsoleCommand *)cg.sharedBuffer;
|
|
if (strstr(icc->conCommand, "wait"))
|
|
{ //filter out commands contaning wait
|
|
Com_Printf("You can't use commands containing the string wait with MyMod v1.0\n");
|
|
icc->conCommand[0] = 0;
|
|
return 0;
|
|
}
|
|
else if (strstr(icc->conCommand, "blah"))
|
|
{ //any command containing the string "blah" is redirected to "quit"
|
|
strcpy(icc->conCommand, "quit");
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
return 1;
|
|
|
|
case CG_GET_USEABLE_FORCE:
|
|
return CG_NoUseableForce();
|
|
|
|
case CG_GET_ORIGIN:
|
|
VectorCopy(cg_entities[arg0].currentState.pos.trBase, (float *)arg1);
|
|
return 0;
|
|
|
|
case CG_GET_ANGLES:
|
|
VectorCopy(cg_entities[arg0].currentState.apos.trBase, (float *)arg1);
|
|
return 0;
|
|
|
|
case CG_GET_ORIGIN_TRAJECTORY:
|
|
return (int)&cg_entities[arg0].nextState.pos;
|
|
|
|
case CG_GET_ANGLE_TRAJECTORY:
|
|
return (int)&cg_entities[arg0].nextState.apos;
|
|
|
|
case CG_ROFF_NOTETRACK_CALLBACK:
|
|
CG_ROFF_NotetrackCallback( &cg_entities[arg0], (const char *)arg1 );
|
|
return 0;
|
|
|
|
case CG_IMPACT_MARK:
|
|
C_ImpactMark();
|
|
return 0;
|
|
|
|
case CG_MAP_CHANGE:
|
|
// this trap map be called more than once for a given map change, as the
|
|
// server is going to attempt to send out multiple broadcasts in hopes that
|
|
// the client will receive one of them
|
|
cg.mMapChange = qtrue;
|
|
return 0;
|
|
|
|
case CG_AUTOMAP_INPUT:
|
|
//special input during automap mode -rww
|
|
{
|
|
autoMapInput_t *autoInput = (autoMapInput_t *)cg.sharedBuffer;
|
|
|
|
memcpy(&cg_autoMapInput, autoInput, sizeof(autoMapInput_t));
|
|
|
|
if (!arg0)
|
|
{ //if this is non-0, it's actually a one-frame mouse event
|
|
cg_autoMapInputTime = cg.time + 1000;
|
|
}
|
|
else
|
|
{
|
|
if (cg_autoMapInput.yaw)
|
|
{
|
|
cg_autoMapAngle[YAW] += cg_autoMapInput.yaw;
|
|
}
|
|
|
|
if (cg_autoMapInput.pitch)
|
|
{
|
|
cg_autoMapAngle[PITCH] += cg_autoMapInput.pitch;
|
|
}
|
|
cg_autoMapInput.yaw = 0.0f;
|
|
cg_autoMapInput.pitch = 0.0f;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
case CG_MISC_ENT:
|
|
CG_MiscEnt();
|
|
return 0;
|
|
|
|
case CG_FX_CAMERASHAKE:
|
|
{
|
|
TCGCameraShake *data = (TCGCameraShake *)cg.sharedBuffer;
|
|
|
|
CG_DoCameraShake( data->mOrigin, data->mIntensity, data->mRadius, data->mTime );
|
|
}
|
|
return 0;
|
|
|
|
default:
|
|
CG_Error( "vmMain: unknown command %i", command );
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
#include "../namespace_end.h"
|
|
|
|
static int C_PointContents(void)
|
|
{
|
|
TCGPointContents *data = (TCGPointContents *)cg.sharedBuffer;
|
|
|
|
return CG_PointContents( data->mPoint, data->mPassEntityNum );
|
|
}
|
|
|
|
static void C_GetLerpOrigin(void)
|
|
{
|
|
TCGVectorData *data = (TCGVectorData *)cg.sharedBuffer;
|
|
|
|
VectorCopy(cg_entities[data->mEntityNum].lerpOrigin, data->mPoint);
|
|
}
|
|
|
|
static void C_GetLerpData(void)
|
|
{//only used by FX system to pass to getboltmat
|
|
TCGGetBoltData *data = (TCGGetBoltData *)cg.sharedBuffer;
|
|
|
|
VectorCopy(cg_entities[data->mEntityNum].lerpOrigin, data->mOrigin);
|
|
VectorCopy(cg_entities[data->mEntityNum].modelScale, data->mScale);
|
|
VectorCopy(cg_entities[data->mEntityNum].lerpAngles, data->mAngles);
|
|
if (cg_entities[data->mEntityNum].currentState.eType == ET_PLAYER)
|
|
{ //normal player
|
|
data->mAngles[PITCH] = 0.0f;
|
|
data->mAngles[ROLL] = 0.0f;
|
|
}
|
|
else if (cg_entities[data->mEntityNum].currentState.eType == ET_NPC)
|
|
{ //an NPC
|
|
Vehicle_t *pVeh = cg_entities[data->mEntityNum].m_pVehicle;
|
|
if (!pVeh)
|
|
{ //for vehicles, we may or may not want to 0 out pitch and roll
|
|
data->mAngles[PITCH] = 0.0f;
|
|
data->mAngles[ROLL] = 0.0f;
|
|
}
|
|
else if (pVeh->m_pVehicleInfo->type == VH_SPEEDER)
|
|
{ //speeder wants no pitch but a roll
|
|
data->mAngles[PITCH] = 0.0f;
|
|
}
|
|
else if (pVeh->m_pVehicleInfo->type != VH_FIGHTER)
|
|
{ //fighters want all angles
|
|
data->mAngles[PITCH] = 0.0f;
|
|
data->mAngles[ROLL] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void C_Trace(void)
|
|
{
|
|
TCGTrace *td = (TCGTrace *)cg.sharedBuffer;
|
|
|
|
CG_Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
|
|
}
|
|
|
|
static void C_G2Trace(void)
|
|
{
|
|
TCGTrace *td = (TCGTrace *)cg.sharedBuffer;
|
|
|
|
CG_G2Trace(&td->mResult, td->mStart, td->mMins, td->mMaxs, td->mEnd, td->mSkipNumber, td->mMask);
|
|
}
|
|
|
|
static void C_G2Mark(void)
|
|
{
|
|
TCGG2Mark *td = (TCGG2Mark *)cg.sharedBuffer;
|
|
trace_t tr;
|
|
vec3_t end;
|
|
|
|
VectorMA(td->start, 64, td->dir, end);
|
|
CG_G2Trace(&tr, td->start, NULL, NULL, end, ENTITYNUM_NONE, MASK_PLAYERSOLID);
|
|
|
|
if (tr.entityNum < ENTITYNUM_WORLD &&
|
|
cg_entities[tr.entityNum].ghoul2)
|
|
{ //hit someone with a ghoul2 instance, let's project the decal on them then.
|
|
centity_t *cent = &cg_entities[tr.entityNum];
|
|
|
|
//CG_TestLine(tr.endpos, end, 2000, 0x0000ff, 1);
|
|
|
|
CG_AddGhoul2Mark(td->shader, td->size, tr.endpos, end, tr.entityNum,
|
|
cent->lerpOrigin, cent->lerpAngles[YAW], cent->ghoul2, cent->modelScale,
|
|
Q_irand(2000, 4000));
|
|
//I'm making fx system decals have a very short lifetime.
|
|
}
|
|
}
|
|
|
|
static void CG_DebugBoxLines(vec3_t mins, vec3_t maxs, int duration)
|
|
{
|
|
vec3_t start;
|
|
vec3_t end;
|
|
vec3_t vert;
|
|
|
|
float x = maxs[0] - mins[0];
|
|
float y = maxs[1] - mins[1];
|
|
|
|
start[2] = maxs[2];
|
|
vert[2] = mins[2];
|
|
|
|
vert[0] = mins[0];
|
|
vert[1] = mins[1];
|
|
start[0] = vert[0];
|
|
start[1] = vert[1];
|
|
CG_TestLine(start, vert, duration, 0x00000ff, 1);
|
|
|
|
vert[0] = mins[0];
|
|
vert[1] = maxs[1];
|
|
start[0] = vert[0];
|
|
start[1] = vert[1];
|
|
CG_TestLine(start, vert, duration, 0x00000ff, 1);
|
|
|
|
vert[0] = maxs[0];
|
|
vert[1] = mins[1];
|
|
start[0] = vert[0];
|
|
start[1] = vert[1];
|
|
CG_TestLine(start, vert, duration, 0x00000ff, 1);
|
|
|
|
vert[0] = maxs[0];
|
|
vert[1] = maxs[1];
|
|
start[0] = vert[0];
|
|
start[1] = vert[1];
|
|
CG_TestLine(start, vert, duration, 0x00000ff, 1);
|
|
|
|
// top of box
|
|
VectorCopy(maxs, start);
|
|
VectorCopy(maxs, end);
|
|
start[0] -= x;
|
|
CG_TestLine(start, end, duration, 0x00000ff, 1);
|
|
end[0] = start[0];
|
|
end[1] -= y;
|
|
CG_TestLine(start, end, duration, 0x00000ff, 1);
|
|
start[1] = end[1];
|
|
start[0] += x;
|
|
CG_TestLine(start, end, duration, 0x00000ff, 1);
|
|
CG_TestLine(start, maxs, duration, 0x00000ff, 1);
|
|
// bottom of box
|
|
VectorCopy(mins, start);
|
|
VectorCopy(mins, end);
|
|
start[0] += x;
|
|
CG_TestLine(start, end, duration, 0x00000ff, 1);
|
|
end[0] = start[0];
|
|
end[1] += y;
|
|
CG_TestLine(start, end, duration, 0x00000ff, 1);
|
|
start[1] = end[1];
|
|
start[0] -= x;
|
|
CG_TestLine(start, end, duration, 0x00000ff, 1);
|
|
CG_TestLine(start, mins, duration, 0x00000ff, 1);
|
|
}
|
|
|
|
//handle ragdoll callbacks, for events and debugging -rww
|
|
static int CG_RagCallback(int callType)
|
|
{
|
|
switch(callType)
|
|
{
|
|
case RAG_CALLBACK_DEBUGBOX:
|
|
{
|
|
ragCallbackDebugBox_t *callData = (ragCallbackDebugBox_t *)cg.sharedBuffer;
|
|
|
|
CG_DebugBoxLines(callData->mins, callData->maxs, callData->duration);
|
|
}
|
|
break;
|
|
case RAG_CALLBACK_DEBUGLINE:
|
|
{
|
|
ragCallbackDebugLine_t *callData = (ragCallbackDebugLine_t *)cg.sharedBuffer;
|
|
|
|
CG_TestLine(callData->start, callData->end, callData->time, callData->color, callData->radius);
|
|
}
|
|
break;
|
|
case RAG_CALLBACK_BONESNAP:
|
|
{
|
|
ragCallbackBoneSnap_t *callData = (ragCallbackBoneSnap_t *)cg.sharedBuffer;
|
|
centity_t *cent = &cg_entities[callData->entNum];
|
|
int snapSound = trap_S_RegisterSound(va("sound/player/bodyfall_human%i.wav", Q_irand(1, 3)));
|
|
|
|
trap_S_StartSound(cent->lerpOrigin, callData->entNum, CHAN_AUTO, snapSound);
|
|
}
|
|
case RAG_CALLBACK_BONEIMPACT:
|
|
break;
|
|
case RAG_CALLBACK_BONEINSOLID:
|
|
#if 0
|
|
{
|
|
ragCallbackBoneInSolid_t *callData = (ragCallbackBoneInSolid_t *)cg.sharedBuffer;
|
|
|
|
if (callData->solidCount > 16)
|
|
{ //don't bother if we're just tapping into solidity, we'll probably recover on our own
|
|
centity_t *cent = &cg_entities[callData->entNum];
|
|
vec3_t slideDir;
|
|
|
|
VectorSubtract(cent->lerpOrigin, callData->bonePos, slideDir);
|
|
VectorAdd(cent->ragOffsets, slideDir, cent->ragOffsets);
|
|
|
|
cent->hasRagOffset = qtrue;
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
case RAG_CALLBACK_TRACELINE:
|
|
{
|
|
ragCallbackTraceLine_t *callData = (ragCallbackTraceLine_t *)cg.sharedBuffer;
|
|
|
|
CG_Trace(&callData->tr, callData->start, callData->mins, callData->maxs,
|
|
callData->end, callData->ignore, callData->mask);
|
|
}
|
|
break;
|
|
default:
|
|
Com_Error(ERR_DROP, "Invalid callType in CG_RagCallback");
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void C_ImpactMark(void)
|
|
{
|
|
TCGImpactMark *data = (TCGImpactMark *)cg.sharedBuffer;
|
|
|
|
/*
|
|
CG_ImpactMark((int)arg0, (const float *)arg1, (const float *)arg2, (float)arg3,
|
|
(float)arg4, (float)arg5, (float)arg6, (float)arg7, qtrue, (float)arg8, qfalse);
|
|
*/
|
|
CG_ImpactMark(data->mHandle, data->mPoint, data->mAngle, data->mRotation,
|
|
data->mRed, data->mGreen, data->mBlue, data->mAlphaStart, qtrue, data->mSizeStart, qfalse);
|
|
}
|
|
|
|
void CG_MiscEnt(void)
|
|
{
|
|
int modelIndex;
|
|
refEntity_t *RefEnt;
|
|
TCGMiscEnt *data = (TCGMiscEnt *)cg.sharedBuffer;
|
|
vec3_t mins, maxs;
|
|
float *radius, *zOff;
|
|
|
|
if (NumMiscEnts >= MAX_MISC_ENTS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
radius = &Radius[NumMiscEnts];
|
|
zOff = &zOffset[NumMiscEnts];
|
|
RefEnt = &MiscEnts[NumMiscEnts++];
|
|
|
|
modelIndex = trap_R_RegisterModel(data->mModel);
|
|
if (modelIndex == 0)
|
|
{
|
|
Com_Error(ERR_DROP, "client_model has invalid model definition");
|
|
return;
|
|
}
|
|
|
|
*zOff = 0;
|
|
|
|
memset(RefEnt, 0, sizeof(refEntity_t));
|
|
RefEnt->reType = RT_MODEL;
|
|
RefEnt->hModel = modelIndex;
|
|
RefEnt->frame = 0;
|
|
trap_R_ModelBounds(modelIndex, mins, maxs);
|
|
VectorCopy(data->mScale, RefEnt->modelScale);
|
|
VectorCopy(data->mOrigin, RefEnt->origin);
|
|
|
|
VectorScaleVector(mins, data->mScale, mins);
|
|
VectorScaleVector(maxs, data->mScale, maxs);
|
|
*radius = Distance(mins, maxs);
|
|
|
|
AnglesToAxis( data->mAngles, RefEnt->axis );
|
|
ScaleModelAxis(RefEnt);
|
|
}
|
|
|
|
void CG_DrawMiscEnts(void)
|
|
{
|
|
int i;
|
|
refEntity_t *RefEnt;
|
|
float *radius, *zOff;
|
|
vec3_t difference;
|
|
vec3_t cullOrigin;
|
|
|
|
RefEnt = MiscEnts;
|
|
radius = Radius;
|
|
zOff = zOffset;
|
|
for(i=0;i<NumMiscEnts;i++)
|
|
{
|
|
VectorCopy(RefEnt->origin, cullOrigin);
|
|
cullOrigin[2] += 1.0f;
|
|
|
|
if (*zOff)
|
|
{
|
|
cullOrigin[2] += *zOff;
|
|
}
|
|
|
|
if (cg.snap && trap_R_inPVS(cg.refdef.vieworg, cullOrigin, cg.snap->areamask))
|
|
{
|
|
VectorSubtract(RefEnt->origin, cg.refdef.vieworg, difference);
|
|
if (VectorLength(difference)-(*radius) <= cg.distanceCull)
|
|
{
|
|
trap_R_AddRefEntityToScene(RefEnt);
|
|
}
|
|
}
|
|
RefEnt++;
|
|
radius++;
|
|
zOff++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
/*
|
|
void CG_ResizeG2Bolt(boltInfo_v *bolt, int newCount)
|
|
{
|
|
bolt->resize(newCount);
|
|
}
|
|
|
|
void CG_ResizeG2Surface(surfaceInfo_v *surface, int newCount)
|
|
{
|
|
surface->resize(newCount);
|
|
}
|
|
|
|
void CG_ResizeG2Bone(boneInfo_v *bone, int newCount)
|
|
{
|
|
bone->resize(newCount);
|
|
}
|
|
|
|
void CG_ResizeG2(CGhoul2Info_v *ghoul2, int newCount)
|
|
{
|
|
ghoul2->resize(newCount);
|
|
}
|
|
|
|
void CG_ResizeG2TempBone(mdxaBone_v *tempBone, int newCount)
|
|
{
|
|
tempBone->resize(newCount);
|
|
}
|
|
*/
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
cg_t cg;
|
|
cgs_t cgs;
|
|
centity_t cg_entities[MAX_GENTITIES];
|
|
|
|
centity_t *cg_permanents[MAX_GENTITIES]; //rwwRMG - added
|
|
int cg_numpermanents = 0;
|
|
|
|
weaponInfo_t cg_weapons[MAX_WEAPONS];
|
|
itemInfo_t cg_items[MAX_ITEMS];
|
|
|
|
|
|
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_swingSpeed;
|
|
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_dynamicCrosshair;
|
|
vmCvar_t cg_dynamicCrosshairPrecision;
|
|
vmCvar_t cg_drawRewards;
|
|
vmCvar_t cg_drawScores;
|
|
vmCvar_t cg_crosshairSize;
|
|
vmCvar_t cg_crosshairX;
|
|
vmCvar_t cg_crosshairY;
|
|
vmCvar_t cg_crosshairHealth;
|
|
vmCvar_t cg_draw2D;
|
|
vmCvar_t cg_drawStatus;
|
|
vmCvar_t cg_animSpeed;
|
|
vmCvar_t cg_debugAnim;
|
|
vmCvar_t cg_debugSaber;
|
|
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_viewsize;
|
|
vmCvar_t cg_drawGun;
|
|
vmCvar_t cg_gun_frame;
|
|
vmCvar_t cg_gun_x;
|
|
vmCvar_t cg_gun_y;
|
|
vmCvar_t cg_gun_z;
|
|
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;
|
|
|
|
#ifndef _XBOX // Hmmm. This is also in game. I think this is safe.
|
|
vmCvar_t bg_fighterAltControl;
|
|
#endif
|
|
|
|
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_buildScript;
|
|
vmCvar_t cg_forceModel;
|
|
vmCvar_t cg_paused;
|
|
vmCvar_t cg_blood;
|
|
vmCvar_t cg_predictItems;
|
|
vmCvar_t cg_deferPlayers;
|
|
vmCvar_t cg_drawTeamOverlay;
|
|
vmCvar_t cg_teamOverlayUserinfo;
|
|
vmCvar_t cg_drawFriend;
|
|
vmCvar_t cg_teamChatsOnly;
|
|
vmCvar_t cg_hudFiles;
|
|
vmCvar_t cg_scorePlum;
|
|
vmCvar_t cg_smoothClients;
|
|
|
|
#include "../namespace_begin.h"
|
|
vmCvar_t pmove_fixed;
|
|
//vmCvar_t cg_pmove_fixed;
|
|
vmCvar_t pmove_msec;
|
|
// nmckenzie: DUEL_HEALTH
|
|
vmCvar_t g_showDuelHealths;
|
|
#include "../namespace_end.h"
|
|
|
|
vmCvar_t cg_pmove_msec;
|
|
vmCvar_t cg_cameraMode;
|
|
vmCvar_t cg_cameraOrbit;
|
|
vmCvar_t cg_cameraOrbitDelay;
|
|
vmCvar_t cg_timescaleFadeEnd;
|
|
vmCvar_t cg_timescaleFadeSpeed;
|
|
vmCvar_t cg_timescale;
|
|
vmCvar_t cg_noTaunt;
|
|
vmCvar_t cg_noProjectileTrail;
|
|
//vmCvar_t cg_trueLightning;
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
vmCvar_t cg_debugBB;
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
//vmCvar_t cg_redTeamName;
|
|
//vmCvar_t cg_blueTeamName;
|
|
vmCvar_t cg_currentSelectedPlayer;
|
|
vmCvar_t cg_currentSelectedPlayerName;
|
|
//vmCvar_t cg_singlePlayerActive;
|
|
vmCvar_t cg_recordSPDemo;
|
|
vmCvar_t cg_recordSPDemoName;
|
|
vmCvar_t cg_showVehBounds;
|
|
|
|
vmCvar_t ui_myteam;
|
|
|
|
vmCvar_t cg_snapshotTimeout;
|
|
|
|
typedef struct {
|
|
vmCvar_t *vmCvar;
|
|
char *cvarName;
|
|
char *defaultString;
|
|
int cvarFlags;
|
|
} cvarTable_t;
|
|
|
|
static cvarTable_t cvarTable[] = { // bk001129
|
|
{ &cg_ignore, "cg_ignore", "0", 0 }, // used for debugging
|
|
{ &cg_autoswitch, "cg_autoswitch", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawGun, "cg_drawGun", "1", CVAR_ARCHIVE },
|
|
{ &cg_zoomFov, "cg_zoomfov", "40.0", CVAR_ARCHIVE },
|
|
{ &cg_fov, "cg_fov", "80", CVAR_ARCHIVE },
|
|
{ &cg_viewsize, "cg_viewsize", "100", CVAR_ARCHIVE },
|
|
{ &cg_stereoSeparation, "cg_stereoSeparation", "0.4", CVAR_ARCHIVE },
|
|
{ &cg_shadows, "cg_shadows", "1", CVAR_ARCHIVE },
|
|
{ &cg_renderToTextureFX, "cg_renderToTextureFX", "1", CVAR_ARCHIVE },
|
|
{ &cg_draw2D, "cg_draw2D", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawStatus, "cg_drawStatus", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawTimer, "cg_drawTimer", "0", CVAR_ARCHIVE },
|
|
{ &cg_drawFPS, "cg_drawFPS", "0", CVAR_ARCHIVE },
|
|
{ &cg_drawSnapshot, "cg_drawSnapshot", "0", CVAR_ARCHIVE },
|
|
{ &cg_draw3dIcons, "cg_draw3dIcons", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawIcons, "cg_drawIcons", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawAmmoWarning, "cg_drawAmmoWarning", "0", CVAR_ARCHIVE },
|
|
{ &cg_drawEnemyInfo, "cg_drawEnemyInfo", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawCrosshair, "cg_drawCrosshair", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawCrosshairNames, "cg_drawCrosshairNames", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawRadar, "cg_drawRadar", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawVehLeadIndicator, "cg_drawVehLeadIndicator", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawScores, "cg_drawScores", "1", CVAR_ARCHIVE },
|
|
{ &cg_dynamicCrosshair, "cg_dynamicCrosshair", "1", CVAR_ARCHIVE },
|
|
//Enables ghoul2 traces for crosshair traces.. more precise when pointing at others, but slower.
|
|
//And if the server doesn't have g2 col enabled, it won't match up the same.
|
|
{ &cg_dynamicCrosshairPrecision, "cg_dynamicCrosshairPrecision", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawRewards, "cg_drawRewards", "1", CVAR_ARCHIVE },
|
|
{ &cg_crosshairSize, "cg_crosshairSize", "24", CVAR_ARCHIVE },
|
|
{ &cg_crosshairHealth, "cg_crosshairHealth", "0", CVAR_ARCHIVE },
|
|
{ &cg_crosshairX, "cg_crosshairX", "0", CVAR_ARCHIVE },
|
|
{ &cg_crosshairY, "cg_crosshairY", "0", CVAR_ARCHIVE },
|
|
{ &cg_simpleItems, "cg_simpleItems", "0", CVAR_ARCHIVE },
|
|
{ &cg_addMarks, "cg_marks", "1", CVAR_ARCHIVE },
|
|
{ &cg_lagometer, "cg_lagometer", "0", CVAR_ARCHIVE },
|
|
{ &cg_gun_x, "cg_gunX", "0", CVAR_CHEAT },
|
|
{ &cg_gun_y, "cg_gunY", "0", CVAR_CHEAT },
|
|
{ &cg_gun_z, "cg_gunZ", "0", CVAR_CHEAT },
|
|
{ &cg_centertime, "cg_centertime", "3", CVAR_CHEAT },
|
|
{ &cg_runpitch, "cg_runpitch", "0.002", CVAR_ARCHIVE},
|
|
{ &cg_runroll, "cg_runroll", "0.005", CVAR_ARCHIVE },
|
|
{ &cg_bobup , "cg_bobup", "0.005", CVAR_ARCHIVE },
|
|
{ &cg_bobpitch, "cg_bobpitch", "0.002", CVAR_ARCHIVE },
|
|
{ &cg_bobroll, "cg_bobroll", "0.002", CVAR_ARCHIVE },
|
|
//{ &cg_swingSpeed, "cg_swingSpeed", "0.3", CVAR_CHEAT },
|
|
{ &cg_animSpeed, "cg_animspeed", "1", CVAR_CHEAT },
|
|
{ &cg_debugAnim, "cg_debuganim", "0", CVAR_CHEAT },
|
|
{ &cg_debugSaber, "cg_debugsaber", "0", CVAR_CHEAT },
|
|
{ &cg_debugPosition, "cg_debugposition", "0", CVAR_CHEAT },
|
|
{ &cg_debugEvents, "cg_debugevents", "0", CVAR_CHEAT },
|
|
{ &cg_errorDecay, "cg_errordecay", "100", 0 },
|
|
{ &cg_nopredict, "cg_nopredict", "0", 0 },
|
|
{ &cg_noPlayerAnims, "cg_noplayeranims", "0", CVAR_CHEAT },
|
|
{ &cg_showmiss, "cg_showmiss", "0", 0 },
|
|
{ &cg_showVehMiss, "cg_showVehMiss", "0", 0 },
|
|
{ &cg_footsteps, "cg_footsteps", "3", CVAR_ARCHIVE },
|
|
{ &cg_swingAngles, "cg_swingAngles", "1", 0 },
|
|
|
|
{ &cg_oldPainSounds, "cg_oldPainSounds", "0", 0 },
|
|
|
|
{ &cg_ragDoll, "broadsword", "0", 0 },
|
|
|
|
{ &cg_jumpSounds, "cg_jumpSounds", "0", 0 },
|
|
|
|
{ &cg_autoMap, "r_autoMap", "0", CVAR_ARCHIVE },
|
|
{ &cg_autoMapX, "r_autoMapX", "496", CVAR_ARCHIVE },
|
|
{ &cg_autoMapY, "r_autoMapY", "32", CVAR_ARCHIVE },
|
|
{ &cg_autoMapW, "r_autoMapW", "128", CVAR_ARCHIVE },
|
|
{ &cg_autoMapH, "r_autoMapH", "128", CVAR_ARCHIVE },
|
|
|
|
{ &bg_fighterAltControl, "bg_fighterAltControl", "0", CVAR_SERVERINFO },
|
|
|
|
{ &cg_chatBox, "cg_chatBox", "10000", CVAR_ARCHIVE },
|
|
{ &cg_chatBoxHeight, "cg_chatBoxHeight", "350", CVAR_ARCHIVE },
|
|
|
|
{ &cg_saberModelTraceEffect, "cg_saberModelTraceEffect", "0", 0 },
|
|
|
|
//allows us to trace between server frames on the client to see if we're visually
|
|
//hitting the last entity we detected a hit on from the server.
|
|
{ &cg_saberClientVisualCompensation, "cg_saberClientVisualCompensation", "1", 0 },
|
|
|
|
{ &cg_g2TraceLod, "cg_g2TraceLod", "2", 0 },
|
|
|
|
{ &cg_fpls, "cg_fpls", "0", 0 },
|
|
|
|
{ &cg_ghoul2Marks, "cg_ghoul2Marks", "16", 0 },
|
|
|
|
{ &cg_optvehtrace, "com_optvehtrace", "0", 0 },
|
|
|
|
{ &cg_saberDynamicMarks, "cg_saberDynamicMarks", "0", 0 },
|
|
{ &cg_saberDynamicMarkTime, "cg_saberDynamicMarkTime", "60000", 0 },
|
|
|
|
{ &cg_saberContact, "cg_saberContact", "1", 0 },
|
|
{ &cg_saberTrail, "cg_saberTrail", "1", 0 },
|
|
|
|
{ &cg_duelHeadAngles, "cg_duelHeadAngles", "0", 0 },
|
|
|
|
{ &cg_speedTrail, "cg_speedTrail", "1", 0 },
|
|
{ &cg_auraShell, "cg_auraShell", "1", 0 },
|
|
|
|
{ &cg_repeaterOrb, "cg_repeaterOrb", "0", 0 },
|
|
|
|
{ &cg_animBlend, "cg_animBlend", "1", 0 },
|
|
|
|
{ &cg_dismember, "cg_dismember", "0", CVAR_ARCHIVE },
|
|
|
|
{ &cg_thirdPersonSpecialCam, "cg_thirdPersonSpecialCam", "0", 0 },
|
|
|
|
{ &cg_thirdPerson, "cg_thirdPerson", "0", CVAR_ARCHIVE },
|
|
{ &cg_thirdPersonRange, "cg_thirdPersonRange", "80", CVAR_CHEAT },
|
|
{ &cg_thirdPersonAngle, "cg_thirdPersonAngle", "0", CVAR_CHEAT },
|
|
{ &cg_thirdPersonPitchOffset, "cg_thirdPersonPitchOffset", "0", CVAR_CHEAT },
|
|
{ &cg_thirdPersonVertOffset, "cg_thirdPersonVertOffset", "16", CVAR_CHEAT },
|
|
{ &cg_thirdPersonCameraDamp, "cg_thirdPersonCameraDamp", "0.3", 0 },
|
|
{ &cg_thirdPersonTargetDamp, "cg_thirdPersonTargetDamp", "0.5", CVAR_CHEAT },
|
|
|
|
{ &cg_thirdPersonHorzOffset, "cg_thirdPersonHorzOffset", "0", CVAR_CHEAT },
|
|
{ &cg_thirdPersonAlpha, "cg_thirdPersonAlpha", "1.0", CVAR_CHEAT },
|
|
|
|
{ &cg_forceModel, "cg_forceModel", "0", CVAR_ARCHIVE },
|
|
{ &cg_predictItems, "cg_predictItems", "1", CVAR_ARCHIVE },
|
|
{ &cg_deferPlayers, "cg_deferPlayers", "1", CVAR_ARCHIVE },
|
|
{ &cg_drawTeamOverlay, "cg_drawTeamOverlay", "0", CVAR_ARCHIVE },
|
|
{ &cg_teamOverlayUserinfo, "teamoverlay", "0", CVAR_ROM | CVAR_USERINFO },
|
|
{ &cg_stats, "cg_stats", "0", 0 },
|
|
{ &cg_drawFriend, "cg_drawFriend", "1", CVAR_ARCHIVE },
|
|
{ &cg_teamChatsOnly, "cg_teamChatsOnly", "0", CVAR_ARCHIVE },
|
|
// the following variables are created in other parts of the system,
|
|
// but we also reference them here
|
|
{ &cg_buildScript, "com_buildScript", "0", 0 }, // force loading of all possible data amd error on failures
|
|
{ &cg_paused, "cl_paused", "0", CVAR_ROM },
|
|
{ &cg_blood, "com_blood", "1", CVAR_ARCHIVE },
|
|
{ &cg_synchronousClients, "g_synchronousClients", "0", 0 }, // communicated by systeminfo
|
|
|
|
// { &cg_redTeamName, "g_redteam", DEFAULT_REDTEAM_NAME, CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO },
|
|
// { &cg_blueTeamName, "g_blueteam", DEFAULT_BLUETEAM_NAME, CVAR_ARCHIVE | CVAR_SERVERINFO | CVAR_USERINFO },
|
|
{ &cg_currentSelectedPlayer, "cg_currentSelectedPlayer", "0", CVAR_ARCHIVE},
|
|
{ &cg_currentSelectedPlayerName, "cg_currentSelectedPlayerName", "", CVAR_ARCHIVE},
|
|
// { &cg_singlePlayerActive, "ui_singlePlayerActive", "0", CVAR_USERINFO},
|
|
{ &cg_recordSPDemo, "ui_recordSPDemo", "0", CVAR_ARCHIVE},
|
|
{ &cg_recordSPDemoName, "ui_recordSPDemoName", "", CVAR_ARCHIVE},
|
|
|
|
{ &cg_cameraOrbit, "cg_cameraOrbit", "0", CVAR_CHEAT},
|
|
{ &cg_cameraOrbitDelay, "cg_cameraOrbitDelay", "50", CVAR_ARCHIVE},
|
|
{ &cg_timescaleFadeEnd, "cg_timescaleFadeEnd", "1", 0},
|
|
{ &cg_timescaleFadeSpeed, "cg_timescaleFadeSpeed", "0", 0},
|
|
{ &cg_timescale, "timescale", "1", 0},
|
|
{ &cg_scorePlum, "cg_scorePlums", "1", CVAR_ARCHIVE},
|
|
{ &cg_hudFiles, "cg_hudFiles", "ui/jahud.txt", CVAR_ARCHIVE},
|
|
{ &cg_smoothClients, "cg_smoothClients", "1", CVAR_ARCHIVE},
|
|
{ &cg_cameraMode, "com_cameraMode", "0", CVAR_CHEAT},
|
|
|
|
{ &pmove_fixed, "pmove_fixed", "0", 0},
|
|
{ &pmove_msec, "pmove_msec", "8", 0},
|
|
{ &cg_noTaunt, "cg_noTaunt", "0", CVAR_ARCHIVE},
|
|
{ &cg_noProjectileTrail, "cg_noProjectileTrail", "0", CVAR_ARCHIVE},
|
|
// { &cg_trueLightning, "cg_trueLightning", "0.0", CVAR_ARCHIVE},
|
|
{ &cg_showVehBounds, "cg_showVehBounds", "0", 0},
|
|
|
|
{ &ui_myteam, "ui_myteam", "0", CVAR_ROM|CVAR_INTERNAL},
|
|
{ &cg_snapshotTimeout, "cg_snapshotTimeout", "10", CVAR_ARCHIVE },
|
|
|
|
// { &cg_pmove_fixed, "cg_pmove_fixed", "0", CVAR_USERINFO | CVAR_ARCHIVE }
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
{ &cg_debugBB, "debugBB", "0", 0},
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
};
|
|
|
|
static int cvarTableSize = sizeof( cvarTable ) / sizeof( cvarTable[0] );
|
|
|
|
/*
|
|
=================
|
|
CG_RegisterCvars
|
|
=================
|
|
*/
|
|
void CG_RegisterCvars( void ) {
|
|
int i;
|
|
cvarTable_t *cv;
|
|
char var[MAX_TOKEN_CHARS];
|
|
|
|
for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
|
|
trap_Cvar_Register( cv->vmCvar, cv->cvarName,
|
|
cv->defaultString, cv->cvarFlags );
|
|
}
|
|
|
|
// see if we are also running the server on this machine
|
|
trap_Cvar_VariableStringBuffer( "sv_running", var, sizeof( var ) );
|
|
cgs.localServer = atoi( var );
|
|
|
|
forceModelModificationCount = cg_forceModel.modificationCount;
|
|
|
|
trap_Cvar_Register(NULL, "model", DEFAULT_MODEL, CVAR_USERINFO | CVAR_ARCHIVE );
|
|
trap_Cvar_Register(NULL, "forcepowers", DEFAULT_FORCEPOWERS, CVAR_USERINFO | CVAR_ARCHIVE );
|
|
|
|
// Cvars uses for transferring data between client and server
|
|
trap_Cvar_Register(NULL, "ui_about_gametype", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_fraglimit", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_capturelimit", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_duellimit", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_timelimit", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_maxclients", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_dmflags", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_mapname", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_hostname", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_needpass", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_about_botminplayers", "0", CVAR_ROM|CVAR_INTERNAL );
|
|
|
|
trap_Cvar_Register(NULL, "ui_tm1_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm2_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm3_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
|
|
trap_Cvar_Register(NULL, "ui_tm1_c0_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm1_c1_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm1_c2_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm1_c3_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm1_c4_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm1_c5_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
|
|
trap_Cvar_Register(NULL, "ui_tm2_c0_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm2_c1_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm2_c2_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm2_c3_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm2_c4_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
trap_Cvar_Register(NULL, "ui_tm2_c5_cnt", "0", CVAR_ROM | CVAR_INTERNAL );
|
|
|
|
}
|
|
|
|
/*
|
|
===================
|
|
CG_SetWeatherOverride
|
|
===================
|
|
*/
|
|
#if 0
|
|
void CG_SetWeatherOverride(int contents)
|
|
{
|
|
if (contents != cgWeatherOverride)
|
|
{ //only do the trap call if we aren't already set to this
|
|
trap_R_WeatherContentsOverride(contents);
|
|
}
|
|
cgWeatherOverride = contents; //keep track of it
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
===================
|
|
CG_ForceModelChange
|
|
===================
|
|
*/
|
|
static void CG_ForceModelChange( void ) {
|
|
int i;
|
|
|
|
for (i=0 ; i<MAX_CLIENTS ; i++) {
|
|
const char *clientInfo;
|
|
void *oldGhoul2;
|
|
|
|
clientInfo = CG_ConfigString( CS_PLAYERS+i );
|
|
if ( !clientInfo[0] ) {
|
|
continue;
|
|
}
|
|
|
|
oldGhoul2 = cgs.clientinfo[i].ghoul2Model;
|
|
CG_NewClientInfo( i, qtrue);
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_UpdateCvars
|
|
=================
|
|
*/
|
|
void CG_UpdateCvars( void ) {
|
|
int i;
|
|
cvarTable_t *cv;
|
|
static int drawTeamOverlayModificationCount = -1;
|
|
|
|
for ( i = 0, cv = cvarTable ; i < cvarTableSize ; i++, cv++ ) {
|
|
trap_Cvar_Update( cv->vmCvar );
|
|
}
|
|
|
|
// check for modications here
|
|
|
|
// If team overlay is on, ask for updates from the server. If its off,
|
|
// let the server know so we don't receive it
|
|
if ( drawTeamOverlayModificationCount != cg_drawTeamOverlay.modificationCount ) {
|
|
drawTeamOverlayModificationCount = cg_drawTeamOverlay.modificationCount;
|
|
|
|
if ( cg_drawTeamOverlay.integer > 0 ) {
|
|
trap_Cvar_Set( "teamoverlay", "1" );
|
|
} else {
|
|
trap_Cvar_Set( "teamoverlay", "0" );
|
|
}
|
|
// FIXME E3 HACK
|
|
trap_Cvar_Set( "teamoverlay", "1" );
|
|
}
|
|
|
|
// if force model changed
|
|
if ( forceModelModificationCount != cg_forceModel.modificationCount ) {
|
|
forceModelModificationCount = cg_forceModel.modificationCount;
|
|
CG_ForceModelChange();
|
|
}
|
|
}
|
|
|
|
int CG_CrosshairPlayer( void ) {
|
|
if ( cg.time > ( cg.crosshairClientTime + 1000 ) ) {
|
|
return -1;
|
|
}
|
|
|
|
if (cg.crosshairClientNum >= MAX_CLIENTS)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return cg.crosshairClientNum;
|
|
}
|
|
|
|
int CG_LastAttacker( void ) {
|
|
if ( !cg.attackerTime ) {
|
|
return -1;
|
|
}
|
|
return cg.snap->ps.persistant[PERS_ATTACKER];
|
|
}
|
|
|
|
void QDECL CG_Printf( const char *msg, ... ) {
|
|
va_list argptr;
|
|
char text[1024];
|
|
|
|
va_start (argptr, msg);
|
|
Q_vsnprintf (text, sizeof(text), msg, argptr);
|
|
va_end (argptr);
|
|
|
|
trap_Print( text );
|
|
}
|
|
|
|
void QDECL CG_Error( const char *msg, ... ) {
|
|
va_list argptr;
|
|
char text[1024];
|
|
|
|
va_start (argptr, msg);
|
|
Q_vsnprintf (text, sizeof(text), msg, argptr);
|
|
va_end (argptr);
|
|
|
|
trap_Error( text );
|
|
}
|
|
|
|
#ifndef CGAME_HARD_LINKED
|
|
// this is only here so the functions in q_shared.c and bg_*.c can link (FIXME)
|
|
|
|
void QDECL Com_Error( int level, const char *error, ... ) {
|
|
va_list argptr;
|
|
char text[1024];
|
|
|
|
va_start (argptr, error);
|
|
Q_vsnprintf (text, sizeof(text), error, argptr);
|
|
va_end (argptr);
|
|
|
|
CG_Error( "%s", text);
|
|
}
|
|
|
|
void QDECL Com_Printf( const char *msg, ... ) {
|
|
va_list argptr;
|
|
char text[1024];
|
|
|
|
va_start (argptr, msg);
|
|
Q_vsnprintf (text, sizeof(text), msg, argptr);
|
|
va_end (argptr);
|
|
|
|
CG_Printf ("%s", text);
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
================
|
|
CG_Argv
|
|
================
|
|
*/
|
|
const char *CG_Argv( int arg ) {
|
|
static char buffer[MAX_STRING_CHARS];
|
|
|
|
trap_Argv( arg, buffer, sizeof( buffer ) );
|
|
|
|
return buffer;
|
|
}
|
|
|
|
|
|
//========================================================================
|
|
|
|
//so shared code can get the local time depending on the side it's executed on
|
|
#include "../namespace_begin.h"
|
|
int BG_GetTime(void)
|
|
{
|
|
return cg.time;
|
|
}
|
|
#include "../namespace_end.h"
|
|
|
|
/*
|
|
=================
|
|
CG_RegisterItemSounds
|
|
|
|
The server says this item is used on this level
|
|
=================
|
|
*/
|
|
static void CG_RegisterItemSounds( int itemNum ) {
|
|
gitem_t *item;
|
|
char data[MAX_QPATH];
|
|
char *s, *start;
|
|
int len;
|
|
|
|
item = &bg_itemlist[ itemNum ];
|
|
|
|
if( item->pickup_sound ) {
|
|
trap_S_RegisterSound( item->pickup_sound );
|
|
}
|
|
|
|
// parse the space seperated precache string for other media
|
|
s = item->sounds;
|
|
if (!s || !s[0])
|
|
return;
|
|
|
|
while (*s) {
|
|
start = s;
|
|
while (*s && *s != ' ') {
|
|
s++;
|
|
}
|
|
|
|
len = s-start;
|
|
if (len >= MAX_QPATH || len < 5) {
|
|
CG_Error( "PrecacheItem: %s has bad precache string",
|
|
item->classname);
|
|
return;
|
|
}
|
|
memcpy (data, start, len);
|
|
data[len] = 0;
|
|
if ( *s ) {
|
|
s++;
|
|
}
|
|
|
|
trap_S_RegisterSound( data );
|
|
}
|
|
|
|
// parse the space seperated precache string for other media
|
|
s = item->precaches;
|
|
if (!s || !s[0])
|
|
return;
|
|
|
|
while (*s) {
|
|
start = s;
|
|
while (*s && *s != ' ') {
|
|
s++;
|
|
}
|
|
|
|
len = s-start;
|
|
if (len >= MAX_QPATH || len < 5) {
|
|
CG_Error( "PrecacheItem: %s has bad precache string",
|
|
item->classname);
|
|
return;
|
|
}
|
|
memcpy (data, start, len);
|
|
data[len] = 0;
|
|
if ( *s ) {
|
|
s++;
|
|
}
|
|
|
|
if ( !strcmp(data+len-3, "efx" )) {
|
|
trap_FX_RegisterEffect( data );
|
|
}
|
|
}
|
|
}
|
|
|
|
static void CG_AS_Register(void)
|
|
{
|
|
const char *soundName;
|
|
int i;
|
|
|
|
// CG_LoadingString( "ambient sound sets" );
|
|
|
|
//Load the ambient sets
|
|
#if 0 //as_preCacheMap was game-side.. that is evil.
|
|
trap_AS_AddPrecacheEntry( "#clear" ); // ;-)
|
|
//FIXME: Don't ask... I had to get around a really nasty MS error in the templates with this...
|
|
namePrecache_m::iterator pi;
|
|
STL_ITERATE( pi, as_preCacheMap )
|
|
{
|
|
cgi_AS_AddPrecacheEntry( ((*pi).first).c_str() );
|
|
}
|
|
#else
|
|
trap_AS_AddPrecacheEntry( "#clear" );
|
|
|
|
for ( i = 1 ; i < MAX_AMBIENT_SETS ; i++ ) {
|
|
soundName = CG_ConfigString( CS_AMBIENT_SET+i );
|
|
if ( !soundName || !soundName[0] )
|
|
{
|
|
break;
|
|
}
|
|
|
|
trap_AS_AddPrecacheEntry(soundName);
|
|
}
|
|
soundName = CG_ConfigString( CS_GLOBAL_AMBIENT_SET );
|
|
if (soundName && soundName[0] && Q_stricmp(soundName, "default"))
|
|
{ //global soundset
|
|
trap_AS_AddPrecacheEntry(soundName);
|
|
}
|
|
#endif
|
|
|
|
trap_AS_ParseSets();
|
|
}
|
|
|
|
//a global weather effect (rain, snow, etc)
|
|
void CG_ParseWeatherEffect(const char *str)
|
|
{
|
|
char *sptr = (char *)str;
|
|
sptr++; //pass the '*'
|
|
trap_R_WorldEffectCommand(sptr);
|
|
}
|
|
|
|
extern int cgSiegeRoundBeganTime;
|
|
void CG_ParseSiegeState(const char *str)
|
|
{
|
|
int i = 0;
|
|
int j = 0;
|
|
// int prevState = cgSiegeRoundState;
|
|
char b[1024];
|
|
|
|
while (str[i] && str[i] != '|')
|
|
{
|
|
b[j] = str[i];
|
|
i++;
|
|
j++;
|
|
}
|
|
b[j] = 0;
|
|
cgSiegeRoundState = atoi(b);
|
|
|
|
if (str[i] == '|')
|
|
{
|
|
j = 0;
|
|
i++;
|
|
while (str[i])
|
|
{
|
|
b[j] = str[i];
|
|
i++;
|
|
j++;
|
|
}
|
|
b[j] = 0;
|
|
// if (cgSiegeRoundState != prevState)
|
|
{ //it changed
|
|
cgSiegeRoundTime = atoi(b);
|
|
if (cgSiegeRoundState == 0 || cgSiegeRoundState == 2)
|
|
{
|
|
cgSiegeRoundBeganTime = cgSiegeRoundTime;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cgSiegeRoundTime = cg.time;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_RegisterSounds
|
|
|
|
called during a precache command
|
|
=================
|
|
*/
|
|
void CG_PrecacheNPCSounds(const char *str);
|
|
void CG_ParseSiegeObjectiveStatus(const char *str);
|
|
extern int cg_beatingSiegeTime;
|
|
extern int cg_siegeWinTeam;
|
|
static void CG_RegisterSounds( void ) {
|
|
int i;
|
|
char items[MAX_ITEMS+1];
|
|
char name[MAX_QPATH];
|
|
const char *soundName;
|
|
|
|
CG_AS_Register();
|
|
|
|
// CG_LoadingString( "sounds" );
|
|
|
|
trap_S_RegisterSound( "sound/weapons/melee/punch1.mp3" );
|
|
trap_S_RegisterSound( "sound/weapons/melee/punch2.mp3" );
|
|
trap_S_RegisterSound( "sound/weapons/melee/punch3.mp3" );
|
|
trap_S_RegisterSound( "sound/weapons/melee/punch4.mp3" );
|
|
trap_S_RegisterSound("sound/movers/objects/saber_slam");
|
|
|
|
trap_S_RegisterSound("sound/player/bodyfall_human1.wav");
|
|
trap_S_RegisterSound("sound/player/bodyfall_human2.wav");
|
|
trap_S_RegisterSound("sound/player/bodyfall_human3.wav");
|
|
|
|
//test effects
|
|
trap_FX_RegisterEffect("effects/mp/test_sparks.efx");
|
|
trap_FX_RegisterEffect("effects/mp/test_wall_impact.efx");
|
|
|
|
cgs.media.oneMinuteSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM004" );
|
|
cgs.media.fiveMinuteSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM005" );
|
|
cgs.media.oneFragSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM001" );
|
|
cgs.media.twoFragSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM002" );
|
|
cgs.media.threeFragSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM003");
|
|
cgs.media.count3Sound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM035" );
|
|
cgs.media.count2Sound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM036" );
|
|
cgs.media.count1Sound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM037" );
|
|
cgs.media.countFightSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM038" );
|
|
|
|
cgs.media.hackerIconShader = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_tech");
|
|
|
|
cgs.media.redSaberGlowShader = trap_R_RegisterShader( "gfx/effects/sabers/red_glow" );
|
|
cgs.media.redSaberCoreShader = trap_R_RegisterShader( "gfx/effects/sabers/red_line" );
|
|
cgs.media.orangeSaberGlowShader = trap_R_RegisterShader( "gfx/effects/sabers/orange_glow" );
|
|
cgs.media.orangeSaberCoreShader = trap_R_RegisterShader( "gfx/effects/sabers/orange_line" );
|
|
cgs.media.yellowSaberGlowShader = trap_R_RegisterShader( "gfx/effects/sabers/yellow_glow" );
|
|
cgs.media.yellowSaberCoreShader = trap_R_RegisterShader( "gfx/effects/sabers/yellow_line" );
|
|
cgs.media.greenSaberGlowShader = trap_R_RegisterShader( "gfx/effects/sabers/green_glow" );
|
|
cgs.media.greenSaberCoreShader = trap_R_RegisterShader( "gfx/effects/sabers/green_line" );
|
|
cgs.media.blueSaberGlowShader = trap_R_RegisterShader( "gfx/effects/sabers/blue_glow" );
|
|
cgs.media.blueSaberCoreShader = trap_R_RegisterShader( "gfx/effects/sabers/blue_line" );
|
|
cgs.media.purpleSaberGlowShader = trap_R_RegisterShader( "gfx/effects/sabers/purple_glow" );
|
|
cgs.media.purpleSaberCoreShader = trap_R_RegisterShader( "gfx/effects/sabers/purple_line" );
|
|
cgs.media.saberBlurShader = trap_R_RegisterShader( "gfx/effects/sabers/saberBlur" );
|
|
cgs.media.swordTrailShader = trap_R_RegisterShader( "gfx/effects/sabers/swordTrail" );
|
|
|
|
cgs.media.forceCoronaShader = trap_R_RegisterShaderNoMip( "gfx/hud/force_swirl" );
|
|
|
|
cgs.media.yellowDroppedSaberShader = trap_R_RegisterShader("gfx/effects/yellow_glow");
|
|
|
|
cgs.media.rivetMarkShader = trap_R_RegisterShader( "gfx/damage/rivetmark" );
|
|
|
|
trap_R_RegisterShader( "gfx/effects/saberFlare" );
|
|
|
|
trap_R_RegisterShader( "powerups/ysalimarishell" );
|
|
|
|
trap_R_RegisterShader( "gfx/effects/forcePush" );
|
|
|
|
trap_R_RegisterShader( "gfx/misc/red_dmgshield" );
|
|
trap_R_RegisterShader( "gfx/misc/red_portashield" );
|
|
trap_R_RegisterShader( "gfx/misc/blue_dmgshield" );
|
|
trap_R_RegisterShader( "gfx/misc/blue_portashield" );
|
|
|
|
trap_R_RegisterShader( "models/map_objects/imp_mine/turret_chair_dmg.tga" );
|
|
|
|
for (i=1 ; i<9 ; i++)
|
|
{
|
|
trap_S_RegisterSound(va("sound/weapons/saber/saberhup%i.wav", i));
|
|
}
|
|
|
|
for (i=1 ; i<10 ; i++)
|
|
{
|
|
trap_S_RegisterSound(va("sound/weapons/saber/saberblock%i.wav", i));
|
|
}
|
|
|
|
for (i=1 ; i<4 ; i++)
|
|
{
|
|
trap_S_RegisterSound(va("sound/weapons/saber/bounce%i.wav", i));
|
|
}
|
|
|
|
trap_S_RegisterSound( "sound/weapons/saber/enemy_saber_on.wav" );
|
|
trap_S_RegisterSound( "sound/weapons/saber/enemy_saber_off.wav" );
|
|
|
|
trap_S_RegisterSound( "sound/weapons/saber/saberhum1.wav" );
|
|
trap_S_RegisterSound( "sound/weapons/saber/saberon.wav" );
|
|
trap_S_RegisterSound( "sound/weapons/saber/saberoffquick.wav" );
|
|
trap_S_RegisterSound( "sound/weapons/saber/saberhitwall1" );
|
|
trap_S_RegisterSound( "sound/weapons/saber/saberhitwall2" );
|
|
trap_S_RegisterSound( "sound/weapons/saber/saberhitwall3" );
|
|
trap_S_RegisterSound("sound/weapons/saber/saberhit.wav");
|
|
trap_S_RegisterSound("sound/weapons/saber/saberhit1.wav");
|
|
trap_S_RegisterSound("sound/weapons/saber/saberhit2.wav");
|
|
trap_S_RegisterSound("sound/weapons/saber/saberhit3.wav");
|
|
|
|
trap_S_RegisterSound("sound/weapons/saber/saber_catch.wav");
|
|
|
|
cgs.media.teamHealSound = trap_S_RegisterSound("sound/weapons/force/teamheal.wav");
|
|
cgs.media.teamRegenSound = trap_S_RegisterSound("sound/weapons/force/teamforce.wav");
|
|
|
|
trap_S_RegisterSound("sound/weapons/force/heal.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/speed.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/see.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/rage.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/lightning");
|
|
trap_S_RegisterSound("sound/weapons/force/lightninghit1");
|
|
trap_S_RegisterSound("sound/weapons/force/lightninghit2");
|
|
trap_S_RegisterSound("sound/weapons/force/lightninghit3");
|
|
trap_S_RegisterSound("sound/weapons/force/drain.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/jumpbuild.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/distract.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/distractstop.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/pull.wav");
|
|
trap_S_RegisterSound("sound/weapons/force/push.wav");
|
|
|
|
for (i=1 ; i<3 ; i++)
|
|
{
|
|
trap_S_RegisterSound(va("sound/weapons/thermal/bounce%i.wav", i));
|
|
}
|
|
|
|
trap_S_RegisterSound("sound/movers/switches/switch2.wav");
|
|
trap_S_RegisterSound("sound/movers/switches/switch3.wav");
|
|
trap_S_RegisterSound("sound/ambience/spark5.wav");
|
|
trap_S_RegisterSound("sound/chars/turret/ping.wav");
|
|
trap_S_RegisterSound("sound/chars/turret/startup.wav");
|
|
trap_S_RegisterSound("sound/chars/turret/shutdown.wav");
|
|
trap_S_RegisterSound("sound/chars/turret/move.wav");
|
|
trap_S_RegisterSound("sound/player/pickuphealth.wav");
|
|
trap_S_RegisterSound("sound/player/pickupshield.wav");
|
|
|
|
trap_S_RegisterSound("sound/effects/glassbreak1.wav");
|
|
|
|
trap_S_RegisterSound( "sound/weapons/rocket/tick.wav" );
|
|
trap_S_RegisterSound( "sound/weapons/rocket/lock.wav" );
|
|
|
|
trap_S_RegisterSound("sound/weapons/force/speedloop.wav");
|
|
|
|
trap_S_RegisterSound("sound/weapons/force/protecthit.mp3"); //PDSOUND_PROTECTHIT
|
|
trap_S_RegisterSound("sound/weapons/force/protect.mp3"); //PDSOUND_PROTECT
|
|
trap_S_RegisterSound("sound/weapons/force/absorbhit.mp3"); //PDSOUND_ABSORBHIT
|
|
trap_S_RegisterSound("sound/weapons/force/absorb.mp3"); //PDSOUND_ABSORB
|
|
trap_S_RegisterSound("sound/weapons/force/jump.mp3"); //PDSOUND_FORCEJUMP
|
|
trap_S_RegisterSound("sound/weapons/force/grip.mp3"); //PDSOUND_FORCEGRIP
|
|
|
|
if ( cgs.gametype >= GT_TEAM || cg_buildScript.integer ) {
|
|
|
|
#ifdef JK2AWARDS
|
|
cgs.media.captureAwardSound = trap_S_RegisterSound( "sound/teamplay/flagcapture_yourteam.wav" );
|
|
#endif
|
|
cgs.media.redLeadsSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM046");
|
|
cgs.media.blueLeadsSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM045");
|
|
cgs.media.teamsTiedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM032" );
|
|
|
|
cgs.media.redScoredSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM044");
|
|
cgs.media.blueScoredSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM043" );
|
|
|
|
if ( cgs.gametype == GT_CTF || cg_buildScript.integer ) {
|
|
cgs.media.redFlagReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM042" );
|
|
cgs.media.blueFlagReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM041" );
|
|
cgs.media.redTookFlagSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM040" );
|
|
cgs.media.blueTookFlagSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM039" );
|
|
}
|
|
if ( cgs.gametype == GT_CTY /*|| cg_buildScript.integer*/ ) {
|
|
cgs.media.redYsalReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM050" );
|
|
cgs.media.blueYsalReturnedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM049" );
|
|
cgs.media.redTookYsalSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM048" );
|
|
cgs.media.blueTookYsalSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM047" );
|
|
}
|
|
}
|
|
|
|
cgs.media.drainSound = trap_S_RegisterSound("sound/weapons/force/drained.mp3");
|
|
|
|
cgs.media.happyMusic = trap_S_RegisterSound("music/goodsmall.mp3");
|
|
cgs.media.dramaticFailure = trap_S_RegisterSound("music/badsmall.mp3");
|
|
|
|
//PRECACHE ALL MUSIC HERE (don't need to precache normally because it's streamed off the disk)
|
|
if (cg_buildScript.integer)
|
|
{
|
|
trap_S_StartBackgroundTrack( "music/mp/duel.mp3", "music/mp/duel.mp3", qfalse );
|
|
}
|
|
|
|
cg.loadLCARSStage = 1;
|
|
|
|
cgs.media.selectSound = trap_S_RegisterSound( "sound/weapons/change.wav" );
|
|
|
|
cgs.media.teleInSound = trap_S_RegisterSound( "sound/player/telein.wav" );
|
|
cgs.media.teleOutSound = trap_S_RegisterSound( "sound/player/teleout.wav" );
|
|
cgs.media.respawnSound = trap_S_RegisterSound( "sound/items/respawn1.wav" );
|
|
|
|
trap_S_RegisterSound( "sound/movers/objects/objectHit.wav" );
|
|
|
|
cgs.media.talkSound = trap_S_RegisterSound( "sound/player/talk.wav" );
|
|
cgs.media.landSound = trap_S_RegisterSound( "sound/player/land1.wav");
|
|
cgs.media.fallSound = trap_S_RegisterSound( "sound/player/fallsplat.wav");
|
|
|
|
cgs.media.crackleSound = trap_S_RegisterSound( "sound/effects/energy_crackle.wav" );
|
|
#ifdef JK2AWARDS
|
|
cgs.media.impressiveSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM025" );
|
|
cgs.media.excellentSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM053" );
|
|
cgs.media.deniedSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM017" );
|
|
cgs.media.humiliationSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM019" );
|
|
cgs.media.defendSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM024" );
|
|
#endif
|
|
|
|
/*
|
|
cgs.media.takenLeadSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM051");
|
|
cgs.media.tiedLeadSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM032");
|
|
cgs.media.lostLeadSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM052");
|
|
*/
|
|
|
|
cgs.media.rollSound = trap_S_RegisterSound( "sound/player/roll1.wav");
|
|
|
|
cgs.media.noforceSound = trap_S_RegisterSound( "sound/weapons/force/noforce" );
|
|
|
|
cgs.media.watrInSound = trap_S_RegisterSound( "sound/player/watr_in.wav");
|
|
cgs.media.watrOutSound = trap_S_RegisterSound( "sound/player/watr_out.wav");
|
|
cgs.media.watrUnSound = trap_S_RegisterSound( "sound/player/watr_un.wav");
|
|
|
|
cgs.media.explosionModel = trap_R_RegisterModel ( "models/map_objects/mp/sphere.md3" );
|
|
cgs.media.surfaceExplosionShader = trap_R_RegisterShader( "surfaceExplosion" );
|
|
|
|
cgs.media.disruptorShader = trap_R_RegisterShader( "gfx/effects/burn");
|
|
|
|
if (cg_buildScript.integer)
|
|
{
|
|
trap_R_RegisterShader( "gfx/effects/turretflashdie" );
|
|
}
|
|
|
|
cgs.media.solidWhite = trap_R_RegisterShader( "gfx/effects/solidWhite_cull" );
|
|
|
|
trap_R_RegisterShader("gfx/misc/mp_light_enlight_disable");
|
|
trap_R_RegisterShader("gfx/misc/mp_dark_enlight_disable");
|
|
|
|
trap_R_RegisterModel ( "models/map_objects/mp/sphere.md3" );
|
|
trap_R_RegisterModel("models/items/remote.md3");
|
|
|
|
cgs.media.holocronPickup = trap_S_RegisterSound( "sound/player/holocron.wav" );
|
|
|
|
// Zoom
|
|
cgs.media.zoomStart = trap_S_RegisterSound( "sound/interface/zoomstart.wav" );
|
|
cgs.media.zoomLoop = trap_S_RegisterSound( "sound/interface/zoomloop.wav" );
|
|
cgs.media.zoomEnd = trap_S_RegisterSound( "sound/interface/zoomend.wav" );
|
|
|
|
for (i=0 ; i<4 ; i++) {
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/stone_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_STONEWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/stone_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_STONERUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/metal_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_METALWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/metal_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_METALRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/pipe_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_PIPEWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/pipe_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_PIPERUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_SPLASH][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_walk%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_WADE][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/water_wade_0%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_SWIM][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/snow_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_SNOWWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/snow_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_SNOWRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/sand_walk%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_SANDWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/sand_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_SANDRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/grass_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_GRASSWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/grass_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_GRASSRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/dirt_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_DIRTWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/dirt_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_DIRTRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/mud_walk%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_MUDWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/mud_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_MUDRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/gravel_walk%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_GRAVELWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/gravel_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_GRAVELRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/rug_step%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_RUGWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/rug_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_RUGRUN][i] = trap_S_RegisterSound (name);
|
|
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/wood_walk%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_WOODWALK][i] = trap_S_RegisterSound (name);
|
|
Com_sprintf (name, sizeof(name), "sound/player/footsteps/wood_run%i.wav", i+1);
|
|
cgs.media.footsteps[FOOTSTEP_WOODRUN][i] = trap_S_RegisterSound (name);
|
|
}
|
|
|
|
// only register the items that the server says we need
|
|
Q_strncpyz(items, CG_ConfigString(CS_ITEMS), sizeof(items));
|
|
|
|
for ( i = 1 ; i < bg_numItems ; i++ ) {
|
|
if ( items[ i ] == '1' || cg_buildScript.integer ) {
|
|
CG_RegisterItemSounds( i );
|
|
}
|
|
}
|
|
|
|
for ( i = 1 ; i < MAX_SOUNDS ; i++ ) {
|
|
soundName = CG_ConfigString( CS_SOUNDS+i );
|
|
if ( !soundName[0] ) {
|
|
break;
|
|
}
|
|
if ( soundName[0] == '*' )
|
|
{
|
|
if (soundName[1] == '$')
|
|
{ //an NPC soundset
|
|
CG_PrecacheNPCSounds(soundName);
|
|
}
|
|
continue; // custom sound
|
|
}
|
|
cgs.gameSounds[i] = trap_S_RegisterSound( soundName );
|
|
}
|
|
|
|
for ( i = 1 ; i < MAX_FX ; i++ ) {
|
|
soundName = CG_ConfigString( CS_EFFECTS+i );
|
|
if ( !soundName[0] ) {
|
|
break;
|
|
}
|
|
|
|
if (soundName[0] == '*')
|
|
{ //it's a special global weather effect
|
|
CG_ParseWeatherEffect(soundName);
|
|
cgs.gameEffects[i] = 0;
|
|
}
|
|
else
|
|
{
|
|
cgs.gameEffects[i] = trap_FX_RegisterEffect( soundName );
|
|
}
|
|
}
|
|
|
|
// register all the server specified icons
|
|
for ( i = 1; i < MAX_ICONS; i ++ )
|
|
{
|
|
const char* iconName;
|
|
|
|
iconName = CG_ConfigString ( CS_ICONS + i );
|
|
if ( !iconName[0] )
|
|
{
|
|
break;
|
|
}
|
|
|
|
cgs.gameIcons[i] = trap_R_RegisterShaderNoMip ( iconName );
|
|
}
|
|
|
|
soundName = CG_ConfigString(CS_SIEGE_STATE);
|
|
|
|
if (soundName[0])
|
|
{
|
|
CG_ParseSiegeState(soundName);
|
|
}
|
|
|
|
soundName = CG_ConfigString(CS_SIEGE_WINTEAM);
|
|
|
|
if (soundName[0])
|
|
{
|
|
cg_siegeWinTeam = atoi(soundName);
|
|
}
|
|
|
|
if (cgs.gametype == GT_SIEGE)
|
|
{
|
|
CG_ParseSiegeObjectiveStatus(CG_ConfigString(CS_SIEGE_OBJECTIVES));
|
|
cg_beatingSiegeTime = atoi(CG_ConfigString(CS_SIEGE_TIMEOVERRIDE));
|
|
if ( cg_beatingSiegeTime )
|
|
{
|
|
CG_SetSiegeTimerCvar ( cg_beatingSiegeTime );
|
|
}
|
|
}
|
|
|
|
cg.loadLCARSStage = 2;
|
|
|
|
// FIXME: only needed with item
|
|
cgs.media.deploySeeker = trap_S_RegisterSound ("sound/chars/seeker/misc/hiss");
|
|
cgs.media.medkitSound = trap_S_RegisterSound ("sound/items/use_bacta.wav");
|
|
|
|
cgs.media.winnerSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM006" );
|
|
cgs.media.loserSound = trap_S_RegisterSound( "sound/chars/protocol/misc/40MOM010" );
|
|
}
|
|
|
|
|
|
//-------------------------------------
|
|
// CG_RegisterEffects
|
|
//
|
|
// Handles precaching all effect files
|
|
// and any shader, model, or sound
|
|
// files an effect may use.
|
|
//-------------------------------------
|
|
static void CG_RegisterEffects( void )
|
|
{
|
|
/*
|
|
const char *effectName;
|
|
int i;
|
|
|
|
for ( i = 1 ; i < MAX_FX ; i++ )
|
|
{
|
|
effectName = CG_ConfigString( CS_EFFECTS + i );
|
|
|
|
if ( !effectName[0] )
|
|
{
|
|
break;
|
|
}
|
|
|
|
trap_FX_RegisterEffect( effectName );
|
|
}
|
|
*/
|
|
//the above was redundant as it's being done in CG_RegisterSounds
|
|
|
|
// Set up the glass effects mini-system.
|
|
CG_InitGlass();
|
|
|
|
//footstep effects
|
|
cgs.effects.footstepMud = trap_FX_RegisterEffect( "materials/mud" );
|
|
cgs.effects.footstepSand = trap_FX_RegisterEffect( "materials/sand" );
|
|
cgs.effects.footstepSnow = trap_FX_RegisterEffect( "materials/snow" );
|
|
cgs.effects.footstepGravel = trap_FX_RegisterEffect( "materials/gravel" );
|
|
//landing effects
|
|
cgs.effects.landingMud = trap_FX_RegisterEffect( "materials/mud_large" );
|
|
cgs.effects.landingSand = trap_FX_RegisterEffect( "materials/sand_large" );
|
|
cgs.effects.landingDirt = trap_FX_RegisterEffect( "materials/dirt_large" );
|
|
cgs.effects.landingSnow = trap_FX_RegisterEffect( "materials/snow_large" );
|
|
cgs.effects.landingGravel = trap_FX_RegisterEffect( "materials/gravel_large" );
|
|
//splashes
|
|
cgs.effects.waterSplash = trap_FX_RegisterEffect( "env/water_impact" );
|
|
cgs.effects.lavaSplash = trap_FX_RegisterEffect( "env/lava_splash" );
|
|
cgs.effects.acidSplash = trap_FX_RegisterEffect( "env/acid_splash" );
|
|
}
|
|
|
|
//===================================================================================
|
|
|
|
extern char *forceHolocronModels[];
|
|
int CG_HandleAppendedSkin(char *modelName);
|
|
void CG_CacheG2AnimInfo(char *modelName);
|
|
/*
|
|
=================
|
|
CG_RegisterGraphics
|
|
|
|
This function may execute for a couple of minutes with a slow disk.
|
|
=================
|
|
*/
|
|
static void CG_RegisterGraphics( void ) {
|
|
int i;
|
|
int breakPoint;
|
|
char items[MAX_ITEMS+1];
|
|
const char *terrainInfo;
|
|
int terrainID;
|
|
|
|
static char *sb_nums[11] = {
|
|
"gfx/2d/numbers/zero",
|
|
"gfx/2d/numbers/one",
|
|
"gfx/2d/numbers/two",
|
|
"gfx/2d/numbers/three",
|
|
"gfx/2d/numbers/four",
|
|
"gfx/2d/numbers/five",
|
|
"gfx/2d/numbers/six",
|
|
"gfx/2d/numbers/seven",
|
|
"gfx/2d/numbers/eight",
|
|
"gfx/2d/numbers/nine",
|
|
"gfx/2d/numbers/minus",
|
|
};
|
|
|
|
static char *sb_t_nums[11] = {
|
|
"gfx/2d/numbers/t_zero",
|
|
"gfx/2d/numbers/t_one",
|
|
"gfx/2d/numbers/t_two",
|
|
"gfx/2d/numbers/t_three",
|
|
"gfx/2d/numbers/t_four",
|
|
"gfx/2d/numbers/t_five",
|
|
"gfx/2d/numbers/t_six",
|
|
"gfx/2d/numbers/t_seven",
|
|
"gfx/2d/numbers/t_eight",
|
|
"gfx/2d/numbers/t_nine",
|
|
"gfx/2d/numbers/t_minus",
|
|
};
|
|
|
|
static char *sb_c_nums[11] = {
|
|
"gfx/2d/numbers/c_zero",
|
|
"gfx/2d/numbers/c_one",
|
|
"gfx/2d/numbers/c_two",
|
|
"gfx/2d/numbers/c_three",
|
|
"gfx/2d/numbers/c_four",
|
|
"gfx/2d/numbers/c_five",
|
|
"gfx/2d/numbers/c_six",
|
|
"gfx/2d/numbers/c_seven",
|
|
"gfx/2d/numbers/c_eight",
|
|
"gfx/2d/numbers/c_nine",
|
|
"gfx/2d/numbers/t_minus", //?????
|
|
};
|
|
|
|
// clear any references to old media
|
|
memset( &cg.refdef, 0, sizeof( cg.refdef ) );
|
|
trap_R_ClearScene();
|
|
|
|
CG_LoadingString( cgs.mapname );
|
|
|
|
//#ifndef _XBOX
|
|
trap_R_LoadWorldMap( cgs.mapname );
|
|
//#endif
|
|
|
|
// precache status bar pics
|
|
// CG_LoadingString( "game media" );
|
|
|
|
for ( i=0 ; i<11 ; i++) {
|
|
cgs.media.numberShaders[i] = trap_R_RegisterShader( sb_nums[i] );
|
|
}
|
|
|
|
cg.loadLCARSStage = 3;
|
|
|
|
for ( i=0; i < 11; i++ )
|
|
{
|
|
cgs.media.numberShaders[i] = trap_R_RegisterShaderNoMip( sb_nums[i] );
|
|
cgs.media.smallnumberShaders[i] = trap_R_RegisterShaderNoMip( sb_t_nums[i] );
|
|
cgs.media.chunkyNumberShaders[i] = trap_R_RegisterShaderNoMip( sb_c_nums[i] );
|
|
}
|
|
|
|
trap_R_RegisterShaderNoMip ( "gfx/mp/pduel_icon_lone" );
|
|
trap_R_RegisterShaderNoMip ( "gfx/mp/pduel_icon_double" );
|
|
|
|
cgs.media.balloonShader = trap_R_RegisterShader( "gfx/mp/chat_icon" );
|
|
cgs.media.vchatShader = trap_R_RegisterShader( "gfx/mp/vchat_icon" );
|
|
|
|
cgs.media.deferShader = trap_R_RegisterShaderNoMip( "gfx/2d/defer.tga" );
|
|
|
|
cgs.media.radarShader = trap_R_RegisterShaderNoMip ( "gfx/menus/radar/radar.png" );
|
|
cgs.media.siegeItemShader = trap_R_RegisterShaderNoMip ( "gfx/menus/radar/goalitem" );
|
|
cgs.media.mAutomapPlayerIcon = trap_R_RegisterShader( "gfx/menus/radar/arrow_w" );
|
|
cgs.media.mAutomapRocketIcon = trap_R_RegisterShader( "gfx/menus/radar/rocket" );
|
|
|
|
cgs.media.wireframeAutomapFrame_left = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_left" );
|
|
cgs.media.wireframeAutomapFrame_right = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_right" );
|
|
cgs.media.wireframeAutomapFrame_top = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_top" );
|
|
cgs.media.wireframeAutomapFrame_bottom = trap_R_RegisterShader( "gfx/mp_automap/mpauto_frame_bottom" );
|
|
|
|
cgs.media.lagometerShader = trap_R_RegisterShaderNoMip("gfx/2d/lag" );
|
|
cgs.media.connectionShader = trap_R_RegisterShaderNoMip( "gfx/2d/net" );
|
|
|
|
trap_FX_InitSystem(&cg.refdef);
|
|
CG_RegisterEffects();
|
|
|
|
cgs.media.boltShader = trap_R_RegisterShader( "gfx/misc/blueLine" );
|
|
|
|
cgs.effects.turretShotEffect = trap_FX_RegisterEffect( "turret/shot" );
|
|
cgs.effects.mEmplacedDeadSmoke = trap_FX_RegisterEffect("emplaced/dead_smoke.efx");
|
|
cgs.effects.mEmplacedExplode = trap_FX_RegisterEffect("emplaced/explode.efx");
|
|
cgs.effects.mTurretExplode = trap_FX_RegisterEffect("turret/explode.efx");
|
|
cgs.effects.mSparkExplosion = trap_FX_RegisterEffect("sparks/spark_explosion.efx");
|
|
cgs.effects.mTripmineExplosion = trap_FX_RegisterEffect("tripMine/explosion.efx");
|
|
cgs.effects.mDetpackExplosion = trap_FX_RegisterEffect("detpack/explosion.efx");
|
|
cgs.effects.mFlechetteAltBlow = trap_FX_RegisterEffect("flechette/alt_blow.efx");
|
|
cgs.effects.mStunBatonFleshImpact = trap_FX_RegisterEffect("stunBaton/flesh_impact.efx");
|
|
cgs.effects.mAltDetonate = trap_FX_RegisterEffect("demp2/altDetonate.efx");
|
|
cgs.effects.mSparksExplodeNoSound = trap_FX_RegisterEffect("sparks/spark_exp_nosnd");
|
|
cgs.effects.mTripMineLaster = trap_FX_RegisterEffect("tripMine/laser.efx");
|
|
cgs.effects.mEmplacedMuzzleFlash = trap_FX_RegisterEffect( "effects/emplaced/muzzle_flash" );
|
|
cgs.effects.mConcussionAltRing = trap_FX_RegisterEffect("concussion/alt_ring");
|
|
|
|
cgs.effects.mHyperspaceStars = trap_FX_RegisterEffect("ships/hyperspace_stars");
|
|
cgs.effects.mBlackSmoke = trap_FX_RegisterEffect( "volumetric/black_smoke" );
|
|
cgs.effects.mShipDestDestroyed = trap_FX_RegisterEffect("effects/ships/dest_destroyed.efx");
|
|
cgs.effects.mShipDestBurning = trap_FX_RegisterEffect("effects/ships/dest_burning.efx");
|
|
cgs.effects.mBobaJet = trap_FX_RegisterEffect("effects/boba/jet.efx");
|
|
|
|
|
|
cgs.effects.itemCone = trap_FX_RegisterEffect("mp/itemcone.efx");
|
|
cgs.effects.mTurretMuzzleFlash = trap_FX_RegisterEffect("effects/turret/muzzle_flash.efx");
|
|
cgs.effects.mSparks = trap_FX_RegisterEffect("sparks/spark_nosnd.efx"); //sparks/spark.efx
|
|
cgs.effects.mSaberCut = trap_FX_RegisterEffect("saber/saber_cut.efx");
|
|
cgs.effects.mSaberBlock = trap_FX_RegisterEffect("saber/saber_block.efx");
|
|
cgs.effects.mSaberBloodSparks = trap_FX_RegisterEffect("saber/blood_sparks_mp.efx");
|
|
cgs.effects.mSaberBloodSparksSmall = trap_FX_RegisterEffect("saber/blood_sparks_25_mp.efx");
|
|
cgs.effects.mSaberBloodSparksMid = trap_FX_RegisterEffect("saber/blood_sparks_50_mp.efx");
|
|
cgs.effects.mSpawn = trap_FX_RegisterEffect("mp/spawn.efx");
|
|
cgs.effects.mJediSpawn = trap_FX_RegisterEffect("mp/jedispawn.efx");
|
|
cgs.effects.mBlasterDeflect = trap_FX_RegisterEffect("blaster/deflect.efx");
|
|
cgs.effects.mBlasterSmoke = trap_FX_RegisterEffect("blaster/smoke_bolton");
|
|
cgs.effects.mForceConfustionOld = trap_FX_RegisterEffect("force/confusion_old.efx");
|
|
|
|
cgs.effects.forceLightning = trap_FX_RegisterEffect( "effects/force/lightning.efx" );
|
|
cgs.effects.forceLightningWide = trap_FX_RegisterEffect( "effects/force/lightningwide.efx" );
|
|
cgs.effects.forceDrain = trap_FX_RegisterEffect( "effects/mp/drain.efx" );
|
|
cgs.effects.forceDrainWide = trap_FX_RegisterEffect( "effects/mp/drainwide.efx" );
|
|
cgs.effects.forceDrained = trap_FX_RegisterEffect( "effects/mp/drainhit.efx");
|
|
|
|
cgs.effects.mDisruptorDeathSmoke = trap_FX_RegisterEffect("disruptor/death_smoke");
|
|
|
|
for ( i = 0 ; i < NUM_CROSSHAIRS ; i++ ) {
|
|
cgs.media.crosshairShader[i] = trap_R_RegisterShaderNoMip( va("gfx/2d/crosshair%c", 'a'+i) );
|
|
}
|
|
|
|
cg.loadLCARSStage = 4;
|
|
|
|
cgs.media.backTileShader = trap_R_RegisterShader( "gfx/2d/backtile" );
|
|
|
|
//precache the fpls skin
|
|
//trap_R_RegisterSkin("models/players/kyle/model_fpls2.skin");
|
|
|
|
cgs.media.itemRespawningPlaceholder = trap_R_RegisterShader("powerups/placeholder");
|
|
cgs.media.itemRespawningRezOut = trap_R_RegisterShader("powerups/rezout");
|
|
|
|
cgs.media.playerShieldDamage = trap_R_RegisterShader("gfx/misc/personalshield");
|
|
cgs.media.protectShader = trap_R_RegisterShader("gfx/misc/forceprotect");
|
|
cgs.media.forceSightBubble = trap_R_RegisterShader("gfx/misc/sightbubble");
|
|
cgs.media.forceShell = trap_R_RegisterShader("powerups/forceshell");
|
|
cgs.media.sightShell = trap_R_RegisterShader("powerups/sightshell");
|
|
|
|
cgs.media.itemHoloModel = trap_R_RegisterModel("models/map_objects/mp/holo.md3");
|
|
|
|
if (cgs.gametype == GT_HOLOCRON || cg_buildScript.integer)
|
|
{
|
|
for ( i=0; i < NUM_FORCE_POWERS; i++ )
|
|
{
|
|
if (forceHolocronModels[i] &&
|
|
forceHolocronModels[i][0])
|
|
{
|
|
trap_R_RegisterModel(forceHolocronModels[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( cgs.gametype == GT_CTF || cgs.gametype == GT_CTY || cg_buildScript.integer ) {
|
|
if (cg_buildScript.integer)
|
|
{
|
|
trap_R_RegisterModel( "models/flags/r_flag.md3" );
|
|
trap_R_RegisterModel( "models/flags/b_flag.md3" );
|
|
trap_R_RegisterModel( "models/flags/r_flag_ysal.md3" );
|
|
trap_R_RegisterModel( "models/flags/b_flag_ysal.md3" );
|
|
}
|
|
|
|
if (cgs.gametype == GT_CTF)
|
|
{
|
|
cgs.media.redFlagModel = trap_R_RegisterModel( "models/flags/r_flag.md3" );
|
|
cgs.media.blueFlagModel = trap_R_RegisterModel( "models/flags/b_flag.md3" );
|
|
}
|
|
else
|
|
{
|
|
cgs.media.redFlagModel = trap_R_RegisterModel( "models/flags/r_flag_ysal.md3" );
|
|
cgs.media.blueFlagModel = trap_R_RegisterModel( "models/flags/b_flag_ysal.md3" );
|
|
}
|
|
|
|
trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_x" );
|
|
trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_x" );
|
|
|
|
trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag_ys" );
|
|
trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag_ys" );
|
|
|
|
trap_R_RegisterShaderNoMip( "gfx/hud/mpi_rflag" );
|
|
trap_R_RegisterShaderNoMip( "gfx/hud/mpi_bflag" );
|
|
|
|
trap_R_RegisterShaderNoMip("gfx/2d/net.tga");
|
|
|
|
cgs.media.flagPoleModel = trap_R_RegisterModel( "models/flag2/flagpole.md3" );
|
|
cgs.media.flagFlapModel = trap_R_RegisterModel( "models/flag2/flagflap3.md3" );
|
|
|
|
cgs.media.redFlagBaseModel = trap_R_RegisterModel( "models/mapobjects/flagbase/red_base.md3" );
|
|
cgs.media.blueFlagBaseModel = trap_R_RegisterModel( "models/mapobjects/flagbase/blue_base.md3" );
|
|
cgs.media.neutralFlagBaseModel = trap_R_RegisterModel( "models/mapobjects/flagbase/ntrl_base.md3" );
|
|
}
|
|
|
|
if ( cgs.gametype >= GT_TEAM || cg_buildScript.integer ) {
|
|
cgs.media.teamRedShader = trap_R_RegisterShader( "sprites/team_red" );
|
|
cgs.media.teamBlueShader = trap_R_RegisterShader( "sprites/team_blue" );
|
|
//cgs.media.redQuadShader = trap_R_RegisterShader("powerups/blueflag" );
|
|
cgs.media.teamStatusBar = trap_R_RegisterShader( "gfx/2d/colorbar.tga" );
|
|
}
|
|
else if ( cgs.gametype == GT_JEDIMASTER )
|
|
{
|
|
cgs.media.teamRedShader = trap_R_RegisterShader( "sprites/team_red" );
|
|
}
|
|
|
|
if (cgs.gametype == GT_POWERDUEL || cg_buildScript.integer)
|
|
{
|
|
cgs.media.powerDuelAllyShader = trap_R_RegisterShader("gfx/mp/pduel_icon_double");//trap_R_RegisterShader("gfx/mp/pduel_gameicon_ally");
|
|
}
|
|
|
|
cgs.media.heartShader = trap_R_RegisterShaderNoMip( "ui/assets/statusbar/selectedhealth.tga" );
|
|
|
|
cgs.media.ysaliredShader = trap_R_RegisterShader( "powerups/ysaliredshell");
|
|
cgs.media.ysaliblueShader = trap_R_RegisterShader( "powerups/ysaliblueshell");
|
|
cgs.media.ysalimariShader = trap_R_RegisterShader( "powerups/ysalimarishell");
|
|
cgs.media.boonShader = trap_R_RegisterShader( "powerups/boonshell");
|
|
cgs.media.endarkenmentShader = trap_R_RegisterShader( "powerups/endarkenmentshell");
|
|
cgs.media.enlightenmentShader = trap_R_RegisterShader( "powerups/enlightenmentshell");
|
|
cgs.media.invulnerabilityShader = trap_R_RegisterShader( "powerups/invulnerabilityshell");
|
|
|
|
#ifdef JK2AWARDS
|
|
cgs.media.medalImpressive = trap_R_RegisterShaderNoMip( "medal_impressive" );
|
|
cgs.media.medalExcellent = trap_R_RegisterShaderNoMip( "medal_excellent" );
|
|
cgs.media.medalGauntlet = trap_R_RegisterShaderNoMip( "medal_gauntlet" );
|
|
cgs.media.medalDefend = trap_R_RegisterShaderNoMip( "medal_defend" );
|
|
cgs.media.medalAssist = trap_R_RegisterShaderNoMip( "medal_assist" );
|
|
cgs.media.medalCapture = trap_R_RegisterShaderNoMip( "medal_capture" );
|
|
#endif
|
|
|
|
// Binocular interface
|
|
cgs.media.binocularCircle = trap_R_RegisterShader( "gfx/2d/binCircle" );
|
|
cgs.media.binocularMask = trap_R_RegisterShader( "gfx/2d/binMask" );
|
|
cgs.media.binocularArrow = trap_R_RegisterShader( "gfx/2d/binSideArrow" );
|
|
cgs.media.binocularTri = trap_R_RegisterShader( "gfx/2d/binTopTri" );
|
|
cgs.media.binocularStatic = trap_R_RegisterShader( "gfx/2d/binocularWindow" );
|
|
cgs.media.binocularOverlay = trap_R_RegisterShader( "gfx/2d/binocularNumOverlay" );
|
|
|
|
cg.loadLCARSStage = 5;
|
|
|
|
// Chunk models
|
|
//FIXME: jfm:? bother to conditionally load these if an ent has this material type?
|
|
for ( i = 0; i < NUM_CHUNK_MODELS; i++ )
|
|
{
|
|
cgs.media.chunkModels[CHUNK_METAL2][i] = trap_R_RegisterModel( va( "models/chunks/metal/metal1_%i.md3", i+1 ) ); //_ /switched\ _
|
|
cgs.media.chunkModels[CHUNK_METAL1][i] = trap_R_RegisterModel( va( "models/chunks/metal/metal2_%i.md3", i+1 ) ); // \switched/
|
|
cgs.media.chunkModels[CHUNK_ROCK1][i] = trap_R_RegisterModel( va( "models/chunks/rock/rock1_%i.md3", i+1 ) );
|
|
cgs.media.chunkModels[CHUNK_ROCK2][i] = trap_R_RegisterModel( va( "models/chunks/rock/rock2_%i.md3", i+1 ) );
|
|
cgs.media.chunkModels[CHUNK_ROCK3][i] = trap_R_RegisterModel( va( "models/chunks/rock/rock3_%i.md3", i+1 ) );
|
|
cgs.media.chunkModels[CHUNK_CRATE1][i] = trap_R_RegisterModel( va( "models/chunks/crate/crate1_%i.md3", i+1 ) );
|
|
cgs.media.chunkModels[CHUNK_CRATE2][i] = trap_R_RegisterModel( va( "models/chunks/crate/crate2_%i.md3", i+1 ) );
|
|
cgs.media.chunkModels[CHUNK_WHITE_METAL][i] = trap_R_RegisterModel( va( "models/chunks/metal/wmetal1_%i.md3", i+1 ) );
|
|
}
|
|
|
|
cgs.media.chunkSound = trap_S_RegisterSound("sound/weapons/explosions/glasslcar");
|
|
cgs.media.grateSound = trap_S_RegisterSound( "sound/effects/grate_destroy" );
|
|
cgs.media.rockBreakSound = trap_S_RegisterSound("sound/effects/wall_smash");
|
|
cgs.media.rockBounceSound[0] = trap_S_RegisterSound("sound/effects/stone_bounce");
|
|
cgs.media.rockBounceSound[1] = trap_S_RegisterSound("sound/effects/stone_bounce2");
|
|
cgs.media.metalBounceSound[0] = trap_S_RegisterSound("sound/effects/metal_bounce");
|
|
cgs.media.metalBounceSound[1] = trap_S_RegisterSound("sound/effects/metal_bounce2");
|
|
cgs.media.glassChunkSound = trap_S_RegisterSound("sound/weapons/explosions/glassbreak1");
|
|
cgs.media.crateBreakSound[0] = trap_S_RegisterSound("sound/weapons/explosions/crateBust1" );
|
|
cgs.media.crateBreakSound[1] = trap_S_RegisterSound("sound/weapons/explosions/crateBust2" );
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
CG_InitItems();
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
memset( cg_weapons, 0, sizeof( cg_weapons ) );
|
|
|
|
// only register the items that the server says we need
|
|
Q_strncpyz(items, CG_ConfigString(CS_ITEMS), sizeof(items));
|
|
|
|
for ( i = 1 ; i < bg_numItems ; i++ ) {
|
|
if ( items[ i ] == '1' || cg_buildScript.integer ) {
|
|
CG_LoadingItem( i );
|
|
CG_RegisterItemVisuals( i );
|
|
}
|
|
}
|
|
|
|
cg.loadLCARSStage = 6;
|
|
|
|
cgs.media.glassShardShader = trap_R_RegisterShader( "gfx/misc/test_crackle" );
|
|
|
|
// doing one shader just makes it look like a shell. By using two shaders with different bulge offsets and different texture scales, it has a much more chaotic look
|
|
cgs.media.electricBodyShader = trap_R_RegisterShader( "gfx/misc/electric" );
|
|
cgs.media.electricBody2Shader = trap_R_RegisterShader( "gfx/misc/fullbodyelectric2" );
|
|
|
|
cgs.media.fsrMarkShader = trap_R_RegisterShader( "footstep_r" );
|
|
cgs.media.fslMarkShader = trap_R_RegisterShader( "footstep_l" );
|
|
cgs.media.fshrMarkShader = trap_R_RegisterShader( "footstep_heavy_r" );
|
|
cgs.media.fshlMarkShader = trap_R_RegisterShader( "footstep_heavy_l" );
|
|
|
|
cgs.media.refractionShader = trap_R_RegisterShader("effects/refraction");
|
|
|
|
cgs.media.cloakedShader = trap_R_RegisterShader( "gfx/effects/cloakedShader" );
|
|
|
|
// wall marks
|
|
cgs.media.shadowMarkShader = trap_R_RegisterShader( "markShadow" );
|
|
cgs.media.wakeMarkShader = trap_R_RegisterShader( "wake" );
|
|
|
|
cgs.media.viewPainShader = trap_R_RegisterShader( "gfx/misc/borgeyeflare" );
|
|
cgs.media.viewPainShader_Shields = trap_R_RegisterShader( "gfx/mp/dmgshader_shields" );
|
|
cgs.media.viewPainShader_ShieldsAndHealth = trap_R_RegisterShader( "gfx/mp/dmgshader_shieldsandhealth" );
|
|
|
|
// register the inline models
|
|
breakPoint = cgs.numInlineModels = trap_CM_NumInlineModels();
|
|
for ( i = 1 ; i < cgs.numInlineModels ; i++ ) {
|
|
char name[10];
|
|
vec3_t mins, maxs;
|
|
int j;
|
|
|
|
Com_sprintf( name, sizeof(name), "*%i", i );
|
|
cgs.inlineDrawModel[i] = trap_R_RegisterModel( name );
|
|
if (!cgs.inlineDrawModel[i])
|
|
{
|
|
breakPoint = i;
|
|
break;
|
|
}
|
|
|
|
trap_R_ModelBounds( cgs.inlineDrawModel[i], mins, maxs );
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
cgs.inlineModelMidpoints[i][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
|
|
}
|
|
}
|
|
|
|
cg.loadLCARSStage = 7;
|
|
|
|
// register all the server specified models
|
|
for (i=1 ; i<MAX_MODELS ; i++) {
|
|
const char *cModelName;
|
|
char modelName[MAX_QPATH];
|
|
|
|
cModelName = CG_ConfigString( CS_MODELS+i );
|
|
if ( !cModelName[0] ) {
|
|
break;
|
|
}
|
|
|
|
strcpy(modelName, cModelName);
|
|
if (strstr(modelName, ".glm") || modelName[0] == '$')
|
|
{ //Check to see if it has a custom skin attached.
|
|
CG_HandleAppendedSkin(modelName);
|
|
CG_CacheG2AnimInfo(modelName);
|
|
}
|
|
|
|
if (modelName[0] != '$' && modelName[0] != '@')
|
|
{ //don't register vehicle names and saber names as models.
|
|
cgs.gameModels[i] = trap_R_RegisterModel( modelName );
|
|
}
|
|
else
|
|
{//FIXME: register here so that stuff gets precached!!!
|
|
cgs.gameModels[i] = 0;
|
|
}
|
|
}
|
|
cg.loadLCARSStage = 8;
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
|
|
// CG_LoadingString( "BSP instances" );
|
|
|
|
for(i = 1; i < MAX_SUB_BSP; i++)
|
|
{
|
|
const char *bspName = 0;
|
|
vec3_t mins, maxs;
|
|
int j;
|
|
int sub = 0;
|
|
char temp[MAX_QPATH];
|
|
|
|
bspName = CG_ConfigString( CS_BSP_MODELS+i );
|
|
if ( !bspName[0] )
|
|
{
|
|
break;
|
|
}
|
|
|
|
trap_CM_LoadMap( bspName, qtrue );
|
|
cgs.inlineDrawModel[breakPoint] = trap_R_RegisterModel( bspName );
|
|
trap_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
|
|
for ( j = 0 ; j < 3 ; j++ )
|
|
{
|
|
cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
|
|
}
|
|
breakPoint++;
|
|
for(sub=1;sub<MAX_MODELS;sub++)
|
|
{
|
|
Com_sprintf(temp, MAX_QPATH, "*%d-%d", i, sub);
|
|
cgs.inlineDrawModel[breakPoint] = trap_R_RegisterModel( temp );
|
|
if (!cgs.inlineDrawModel[breakPoint])
|
|
{
|
|
break;
|
|
}
|
|
trap_R_ModelBounds( cgs.inlineDrawModel[breakPoint], mins, maxs );
|
|
for ( j = 0 ; j < 3 ; j++ )
|
|
{
|
|
cgs.inlineModelMidpoints[breakPoint][j] = mins[j] + 0.5 * ( maxs[j] - mins[j] );
|
|
}
|
|
breakPoint++;
|
|
}
|
|
}
|
|
|
|
// CG_LoadingString( "Creating terrain" );
|
|
for(i = 1; i < MAX_TERRAINS; i++)
|
|
{
|
|
terrainInfo = CG_ConfigString( CS_TERRAINS + i );
|
|
if ( !terrainInfo[0] )
|
|
{
|
|
break;
|
|
}
|
|
|
|
terrainID = trap_CM_RegisterTerrain(terrainInfo);
|
|
|
|
trap_RMG_Init(terrainID, terrainInfo);
|
|
|
|
// Send off the terrainInfo to the renderer
|
|
trap_RE_InitRendererTerrain( terrainInfo );
|
|
}
|
|
|
|
/*
|
|
CG_LoadingString("skins");
|
|
// register all the server specified models
|
|
for (i=1 ; i<MAX_CHARSKINS ; i++) {
|
|
const char *modelName;
|
|
|
|
modelName = CG_ConfigString( CS_CHARSKINS+i );
|
|
if ( !modelName[0] ) {
|
|
break;
|
|
}
|
|
cgs.skins[i] = trap_R_RegisterSkin( modelName );
|
|
}
|
|
*/
|
|
//rww - removed and replaced with CS_G2BONES. For custom skins
|
|
//the new method is to append a * after an indexed model name and
|
|
//then append the skin name after that (note that this is only
|
|
//used for NPCs)
|
|
|
|
// CG_LoadingString("weapons");
|
|
|
|
CG_InitG2Weapons();
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
cg.loadLCARSStage = 9;
|
|
|
|
|
|
// new stuff
|
|
cgs.media.patrolShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/patrol.tga");
|
|
cgs.media.assaultShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/assault.tga");
|
|
cgs.media.campShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/camp.tga");
|
|
cgs.media.followShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/follow.tga");
|
|
cgs.media.defendShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/defend.tga");
|
|
cgs.media.teamLeaderShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/team_leader.tga");
|
|
cgs.media.retrieveShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/retrieve.tga");
|
|
cgs.media.escortShader = trap_R_RegisterShaderNoMip("ui/assets/statusbar/escort.tga");
|
|
cgs.media.cursor = trap_R_RegisterShaderNoMip( "menu/art/3_cursor2" );
|
|
cgs.media.sizeCursor = trap_R_RegisterShaderNoMip( "ui/assets/sizecursor.tga" );
|
|
cgs.media.selectCursor = trap_R_RegisterShaderNoMip( "ui/assets/selectcursor.tga" );
|
|
cgs.media.flagShaders[0] = trap_R_RegisterShaderNoMip("ui/assets/statusbar/flag_in_base.tga");
|
|
cgs.media.flagShaders[1] = trap_R_RegisterShaderNoMip("ui/assets/statusbar/flag_capture.tga");
|
|
cgs.media.flagShaders[2] = trap_R_RegisterShaderNoMip("ui/assets/statusbar/flag_missing.tga");
|
|
|
|
cgs.media.halfShieldModel = trap_R_RegisterModel ( "models/weaphits/testboom.md3" );
|
|
cgs.media.halfShieldShader = trap_R_RegisterShader( "halfShieldShell" );
|
|
|
|
trap_FX_RegisterEffect("force/force_touch");
|
|
|
|
CG_ClearParticles ();
|
|
/*
|
|
for (i=1; i<MAX_PARTICLES_AREAS; i++)
|
|
{
|
|
{
|
|
int rval;
|
|
|
|
rval = CG_NewParticleArea ( CS_PARTICLES + i);
|
|
if (!rval)
|
|
break;
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
const char *CG_GetStringEdString(char *refSection, char *refName)
|
|
{
|
|
static char text[2][1024]={0}; //just incase it's nested
|
|
static int index = 0;
|
|
|
|
index ^= 1;
|
|
trap_SP_GetStringTextString(va("%s_%s", refSection, refName), text[index], sizeof(text[0]));
|
|
return text[index];
|
|
}
|
|
|
|
int CG_GetClassCount(team_t team,int siegeClass );
|
|
int CG_GetTeamNonScoreCount(team_t team);
|
|
|
|
void CG_SiegeCountCvars( void )
|
|
{
|
|
int classGfx[6];
|
|
|
|
trap_Cvar_Set( "ui_tm1_cnt",va("%d",CG_GetTeamNonScoreCount(TEAM_RED )));
|
|
trap_Cvar_Set( "ui_tm2_cnt",va("%d",CG_GetTeamNonScoreCount(TEAM_BLUE )));
|
|
trap_Cvar_Set( "ui_tm3_cnt",va("%d",CG_GetTeamNonScoreCount(TEAM_SPECTATOR )));
|
|
|
|
// This is because the only way we can match up classes is by the gfx handle.
|
|
classGfx[0] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_infantry");
|
|
classGfx[1] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_heavy_weapons");
|
|
classGfx[2] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_demolitionist");
|
|
classGfx[3] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_vanguard");
|
|
classGfx[4] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_support");
|
|
classGfx[5] = trap_R_RegisterShaderNoMip("gfx/mp/c_icon_jedi_general");
|
|
|
|
trap_Cvar_Set( "ui_tm1_c0_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[0])));
|
|
trap_Cvar_Set( "ui_tm1_c1_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[1])));
|
|
trap_Cvar_Set( "ui_tm1_c2_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[2])));
|
|
trap_Cvar_Set( "ui_tm1_c3_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[3])));
|
|
trap_Cvar_Set( "ui_tm1_c4_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[4])));
|
|
trap_Cvar_Set( "ui_tm1_c5_cnt",va("%d",CG_GetClassCount(TEAM_RED,classGfx[5])));
|
|
|
|
trap_Cvar_Set( "ui_tm2_c0_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[0])));
|
|
trap_Cvar_Set( "ui_tm2_c1_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[1])));
|
|
trap_Cvar_Set( "ui_tm2_c2_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[2])));
|
|
trap_Cvar_Set( "ui_tm2_c3_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[3])));
|
|
trap_Cvar_Set( "ui_tm2_c4_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[4])));
|
|
trap_Cvar_Set( "ui_tm2_c5_cnt",va("%d",CG_GetClassCount(TEAM_BLUE,classGfx[5])));
|
|
|
|
}
|
|
|
|
/*
|
|
=======================
|
|
CG_BuildSpectatorString
|
|
|
|
=======================
|
|
*/
|
|
void CG_BuildSpectatorString(void) {
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
===================
|
|
CG_RegisterClients
|
|
===================
|
|
*/
|
|
static void CG_RegisterClients( void ) {
|
|
int i;
|
|
|
|
CG_LoadingClient(cg.clientNum);
|
|
CG_NewClientInfo(cg.clientNum, qfalse);
|
|
|
|
for (i=0 ; i<MAX_CLIENTS ; i++) {
|
|
const char *clientInfo;
|
|
|
|
if (cg.clientNum == i) {
|
|
continue;
|
|
}
|
|
|
|
clientInfo = CG_ConfigString( CS_PLAYERS+i );
|
|
if ( !clientInfo[0]) {
|
|
continue;
|
|
}
|
|
CG_LoadingClient( i );
|
|
CG_NewClientInfo( i, qfalse);
|
|
}
|
|
CG_BuildSpectatorString();
|
|
}
|
|
|
|
//===========================================================================
|
|
|
|
/*
|
|
=================
|
|
CG_ConfigString
|
|
=================
|
|
*/
|
|
const char *CG_ConfigString( int index ) {
|
|
if ( index < 0 || index >= MAX_CONFIGSTRINGS ) {
|
|
CG_Error( "CG_ConfigString: bad index: %i", index );
|
|
}
|
|
return cgs.gameState.stringData + cgs.gameState.stringOffsets[ index ];
|
|
}
|
|
|
|
//==================================================================
|
|
|
|
/*
|
|
======================
|
|
CG_StartMusic
|
|
|
|
======================
|
|
*/
|
|
void CG_StartMusic( qboolean bForceStart ) {
|
|
char *s;
|
|
char parm1[MAX_QPATH], parm2[MAX_QPATH];
|
|
|
|
// start the background music
|
|
s = (char *)CG_ConfigString( CS_MUSIC );
|
|
Q_strncpyz( parm1, COM_Parse( (const char **)&s ), sizeof( parm1 ) );
|
|
Q_strncpyz( parm2, COM_Parse( (const char **)&s ), sizeof( parm2 ) );
|
|
|
|
trap_S_StartBackgroundTrack( parm1, parm2, !bForceStart );
|
|
}
|
|
|
|
#ifndef _XBOX
|
|
char *CG_GetMenuBuffer(const char *filename) {
|
|
int len;
|
|
fileHandle_t f;
|
|
static char buf[MAX_MENUFILE];
|
|
|
|
len = trap_FS_FOpenFile( filename, &f, FS_READ );
|
|
if ( !f ) {
|
|
trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", filename ) );
|
|
return NULL;
|
|
}
|
|
if ( len >= MAX_MENUFILE ) {
|
|
trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", filename, len, MAX_MENUFILE ) );
|
|
trap_FS_FCloseFile( f );
|
|
return NULL;
|
|
}
|
|
|
|
trap_FS_Read( buf, len, f );
|
|
buf[len] = 0;
|
|
trap_FS_FCloseFile( f );
|
|
|
|
return buf;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// ==============================
|
|
// new hud stuff ( mission pack )
|
|
// ==============================
|
|
//
|
|
qboolean CG_Asset_Parse(int handle) {
|
|
pc_token_t token;
|
|
|
|
if (!trap_PC_ReadToken(handle, &token))
|
|
return qfalse;
|
|
if (Q_stricmp(token.string, "{") != 0) {
|
|
return qfalse;
|
|
}
|
|
|
|
while ( 1 ) {
|
|
if (!trap_PC_ReadToken(handle, &token))
|
|
return qfalse;
|
|
|
|
if (Q_stricmp(token.string, "}") == 0) {
|
|
return qtrue;
|
|
}
|
|
|
|
// font
|
|
if (Q_stricmp(token.string, "font") == 0) {
|
|
int pointSize;
|
|
if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
|
|
return qfalse;
|
|
}
|
|
|
|
// cgDC.registerFont(token.string, pointSize, &cgDC.Assets.textFont);
|
|
cgDC.Assets.qhMediumFont = cgDC.RegisterFont(token.string);
|
|
continue;
|
|
}
|
|
|
|
// smallFont
|
|
if (Q_stricmp(token.string, "smallFont") == 0) {
|
|
int pointSize;
|
|
if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
|
|
return qfalse;
|
|
}
|
|
// cgDC.registerFont(token.string, pointSize, &cgDC.Assets.smallFont);
|
|
cgDC.Assets.qhSmallFont = cgDC.RegisterFont(token.string);
|
|
continue;
|
|
}
|
|
|
|
// smallFont
|
|
if (Q_stricmp(token.string, "small2Font") == 0) {
|
|
int pointSize;
|
|
if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
|
|
return qfalse;
|
|
}
|
|
// cgDC.registerFont(token.string, pointSize, &cgDC.Assets.smallFont);
|
|
cgDC.Assets.qhSmall2Font = cgDC.RegisterFont(token.string);
|
|
continue;
|
|
}
|
|
|
|
// font
|
|
if (Q_stricmp(token.string, "bigfont") == 0) {
|
|
int pointSize;
|
|
if (!trap_PC_ReadToken(handle, &token) || !PC_Int_Parse(handle, &pointSize)) {
|
|
return qfalse;
|
|
}
|
|
// cgDC.registerFont(token.string, pointSize, &cgDC.Assets.bigFont);
|
|
cgDC.Assets.qhBigFont = cgDC.RegisterFont(token.string);
|
|
continue;
|
|
}
|
|
|
|
// gradientbar
|
|
if (Q_stricmp(token.string, "gradientbar") == 0) {
|
|
if (!trap_PC_ReadToken(handle, &token)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip(token.string);
|
|
continue;
|
|
}
|
|
|
|
// enterMenuSound
|
|
if (Q_stricmp(token.string, "menuEnterSound") == 0) {
|
|
if (!trap_PC_ReadToken(handle, &token)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.menuEnterSound = trap_S_RegisterSound( token.string );
|
|
continue;
|
|
}
|
|
|
|
// exitMenuSound
|
|
if (Q_stricmp(token.string, "menuExitSound") == 0) {
|
|
if (!trap_PC_ReadToken(handle, &token)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.menuExitSound = trap_S_RegisterSound( token.string );
|
|
continue;
|
|
}
|
|
|
|
// itemFocusSound
|
|
if (Q_stricmp(token.string, "itemFocusSound") == 0) {
|
|
if (!trap_PC_ReadToken(handle, &token)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.itemFocusSound = trap_S_RegisterSound( token.string );
|
|
continue;
|
|
}
|
|
|
|
// menuBuzzSound
|
|
if (Q_stricmp(token.string, "menuBuzzSound") == 0) {
|
|
if (!trap_PC_ReadToken(handle, &token)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.menuBuzzSound = trap_S_RegisterSound( token.string );
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "cursor") == 0) {
|
|
if (!PC_String_Parse(handle, &cgDC.Assets.cursorStr)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.cursor = trap_R_RegisterShaderNoMip( cgDC.Assets.cursorStr);
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "fadeClamp") == 0) {
|
|
if (!PC_Float_Parse(handle, &cgDC.Assets.fadeClamp)) {
|
|
return qfalse;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "fadeCycle") == 0) {
|
|
if (!PC_Int_Parse(handle, &cgDC.Assets.fadeCycle)) {
|
|
return qfalse;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "fadeAmount") == 0) {
|
|
if (!PC_Float_Parse(handle, &cgDC.Assets.fadeAmount)) {
|
|
return qfalse;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "shadowX") == 0) {
|
|
if (!PC_Float_Parse(handle, &cgDC.Assets.shadowX)) {
|
|
return qfalse;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "shadowY") == 0) {
|
|
if (!PC_Float_Parse(handle, &cgDC.Assets.shadowY)) {
|
|
return qfalse;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "shadowColor") == 0) {
|
|
if (!PC_Color_Parse(handle, &cgDC.Assets.shadowColor)) {
|
|
return qfalse;
|
|
}
|
|
cgDC.Assets.shadowFadeClamp = cgDC.Assets.shadowColor[3];
|
|
continue;
|
|
}
|
|
}
|
|
return qfalse; // bk001204 - why not?
|
|
}
|
|
|
|
void CG_ParseMenu(const char *menuFile) {
|
|
pc_token_t token;
|
|
int handle;
|
|
|
|
handle = trap_PC_LoadSource(menuFile);
|
|
if (!handle)
|
|
handle = trap_PC_LoadSource("ui/testhud.menu");
|
|
if (!handle)
|
|
return;
|
|
|
|
while ( 1 ) {
|
|
if (!trap_PC_ReadToken( handle, &token )) {
|
|
break;
|
|
}
|
|
|
|
//if ( Q_stricmp( token, "{" ) ) {
|
|
// Com_Printf( "Missing { in menu file\n" );
|
|
// break;
|
|
//}
|
|
|
|
//if ( menuCount == MAX_MENUS ) {
|
|
// Com_Printf( "Too many menus!\n" );
|
|
// break;
|
|
//}
|
|
|
|
if ( token.string[0] == '}' ) {
|
|
break;
|
|
}
|
|
|
|
if (Q_stricmp(token.string, "assetGlobalDef") == 0) {
|
|
if (CG_Asset_Parse(handle)) {
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
if (Q_stricmp(token.string, "menudef") == 0) {
|
|
// start a new menu
|
|
Menu_New(handle);
|
|
}
|
|
}
|
|
trap_PC_FreeSource(handle);
|
|
}
|
|
|
|
|
|
qboolean CG_Load_Menu(const char **p)
|
|
{
|
|
|
|
char *token;
|
|
|
|
token = COM_ParseExt((const char **)p, qtrue);
|
|
|
|
if (token[0] != '{') {
|
|
return qfalse;
|
|
}
|
|
|
|
while ( 1 ) {
|
|
|
|
token = COM_ParseExt((const char **)p, qtrue);
|
|
|
|
if (Q_stricmp(token, "}") == 0) {
|
|
return qtrue;
|
|
}
|
|
|
|
if ( !token || token[0] == 0 ) {
|
|
return qfalse;
|
|
}
|
|
|
|
CG_ParseMenu(token);
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
static qboolean CG_OwnerDrawHandleKey(int ownerDraw, int flags, float *special, int key) {
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
static int CG_FeederCount(float feederID) {
|
|
int i, count;
|
|
count = 0;
|
|
if (feederID == FEEDER_REDTEAM_LIST) {
|
|
for (i = 0; i < cg.numScores; i++) {
|
|
if (cg.scores[i].team == TEAM_RED) {
|
|
count++;
|
|
}
|
|
}
|
|
} else if (feederID == FEEDER_BLUETEAM_LIST) {
|
|
for (i = 0; i < cg.numScores; i++) {
|
|
if (cg.scores[i].team == TEAM_BLUE) {
|
|
count++;
|
|
}
|
|
}
|
|
} else if (feederID == FEEDER_SCOREBOARD) {
|
|
return cg.numScores;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
|
|
void CG_SetScoreSelection(void *p) {
|
|
menuDef_t *menu = (menuDef_t*)p;
|
|
playerState_t *ps = &cg.snap->ps;
|
|
int i, red, blue;
|
|
red = blue = 0;
|
|
for (i = 0; i < cg.numScores; i++) {
|
|
if (cg.scores[i].team == TEAM_RED) {
|
|
red++;
|
|
} else if (cg.scores[i].team == TEAM_BLUE) {
|
|
blue++;
|
|
}
|
|
if (ps->clientNum == cg.scores[i].client) {
|
|
cg.selectedScore = i;
|
|
}
|
|
}
|
|
|
|
if (menu == NULL) {
|
|
// just interested in setting the selected score
|
|
return;
|
|
}
|
|
|
|
if ( cgs.gametype >= GT_TEAM ) {
|
|
int feeder = FEEDER_REDTEAM_LIST;
|
|
i = red;
|
|
if (cg.scores[cg.selectedScore].team == TEAM_BLUE) {
|
|
feeder = FEEDER_BLUETEAM_LIST;
|
|
i = blue;
|
|
}
|
|
Menu_SetFeederSelection(menu, feeder, i, NULL);
|
|
} else {
|
|
Menu_SetFeederSelection(menu, FEEDER_SCOREBOARD, cg.selectedScore, NULL);
|
|
}
|
|
}
|
|
|
|
// FIXME: might need to cache this info
|
|
static clientInfo_t * CG_InfoFromScoreIndex(int index, int team, int *scoreIndex) {
|
|
int i, count;
|
|
if ( cgs.gametype >= GT_TEAM ) {
|
|
count = 0;
|
|
for (i = 0; i < cg.numScores; i++) {
|
|
if (cg.scores[i].team == team) {
|
|
if (count == index) {
|
|
*scoreIndex = i;
|
|
return &cgs.clientinfo[cg.scores[i].client];
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
*scoreIndex = index;
|
|
return &cgs.clientinfo[ cg.scores[index].client ];
|
|
}
|
|
|
|
static const char *CG_FeederItemText(float feederID, int index, int column,
|
|
qhandle_t *handle1, qhandle_t *handle2, qhandle_t *handle3) {
|
|
gitem_t *item;
|
|
int scoreIndex = 0;
|
|
clientInfo_t *info = NULL;
|
|
int team = -1;
|
|
score_t *sp = NULL;
|
|
|
|
*handle1 = *handle2 = *handle3 = -1;
|
|
|
|
if (feederID == FEEDER_REDTEAM_LIST) {
|
|
team = TEAM_RED;
|
|
} else if (feederID == FEEDER_BLUETEAM_LIST) {
|
|
team = TEAM_BLUE;
|
|
}
|
|
|
|
info = CG_InfoFromScoreIndex(index, team, &scoreIndex);
|
|
sp = &cg.scores[scoreIndex];
|
|
|
|
if (info && info->infoValid) {
|
|
switch (column) {
|
|
case 0:
|
|
if ( info->powerups & ( 1 << PW_NEUTRALFLAG ) ) {
|
|
item = BG_FindItemForPowerup( PW_NEUTRALFLAG );
|
|
*handle1 = cg_items[ ITEM_INDEX(item) ].icon;
|
|
} else if ( info->powerups & ( 1 << PW_REDFLAG ) ) {
|
|
item = BG_FindItemForPowerup( PW_REDFLAG );
|
|
*handle1 = cg_items[ ITEM_INDEX(item) ].icon;
|
|
} else if ( info->powerups & ( 1 << PW_BLUEFLAG ) ) {
|
|
item = BG_FindItemForPowerup( PW_BLUEFLAG );
|
|
*handle1 = cg_items[ ITEM_INDEX(item) ].icon;
|
|
} else {
|
|
/*
|
|
if ( info->botSkill > 0 && info->botSkill <= 5 ) {
|
|
*handle1 = cgs.media.botSkillShaders[ info->botSkill - 1 ];
|
|
} else if ( info->handicap < 100 ) {
|
|
return va("%i", info->handicap );
|
|
}
|
|
*/
|
|
}
|
|
break;
|
|
case 1:
|
|
if (team == -1) {
|
|
return "";
|
|
} else {
|
|
*handle1 = CG_StatusHandle(info->teamTask);
|
|
}
|
|
break;
|
|
case 2:
|
|
if ( cg.snap->ps.stats[ STAT_CLIENTS_READY ] & ( 1 << sp->client ) ) {
|
|
return "Ready";
|
|
}
|
|
if (team == -1) {
|
|
if (cgs.gametype == GT_DUEL || cgs.gametype == GT_POWERDUEL) {
|
|
return va("%i/%i", info->wins, info->losses);
|
|
} else if (info->infoValid && info->team == TEAM_SPECTATOR ) {
|
|
return "Spectator";
|
|
} else {
|
|
return "";
|
|
}
|
|
} else {
|
|
if (info->teamLeader) {
|
|
return "Leader";
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
return info->name;
|
|
break;
|
|
case 4:
|
|
return va("%i", info->score);
|
|
break;
|
|
case 5:
|
|
return va("%4i", sp->time);
|
|
break;
|
|
case 6:
|
|
if ( sp->ping == -1 ) {
|
|
return "connecting";
|
|
}
|
|
return va("%4i", sp->ping);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
static qhandle_t CG_FeederItemImage(float feederID, int index) {
|
|
return 0;
|
|
}
|
|
|
|
static qboolean CG_FeederSelection(float feederID, int index, itemDef_t *item) {
|
|
if ( cgs.gametype >= GT_TEAM ) {
|
|
int i, count;
|
|
int team = (feederID == FEEDER_REDTEAM_LIST) ? TEAM_RED : TEAM_BLUE;
|
|
count = 0;
|
|
for (i = 0; i < cg.numScores; i++) {
|
|
if (cg.scores[i].team == team) {
|
|
if (index == count) {
|
|
cg.selectedScore = i;
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
} else {
|
|
cg.selectedScore = index;
|
|
}
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
static float CG_Cvar_Get(const char *cvar) {
|
|
char buff[128];
|
|
memset(buff, 0, sizeof(buff));
|
|
trap_Cvar_VariableStringBuffer(cvar, buff, sizeof(buff));
|
|
return atof(buff);
|
|
}
|
|
|
|
void CG_Text_PaintWithCursor(float x, float y, float scale, vec4_t color, const char *text, int cursorPos, char cursor, int limit, int style, int iMenuFont) {
|
|
CG_Text_Paint(x, y, scale, color, text, 0, limit, style, iMenuFont);
|
|
}
|
|
|
|
static int CG_OwnerDrawWidth(int ownerDraw, float scale) {
|
|
switch (ownerDraw) {
|
|
case CG_GAME_TYPE:
|
|
return CG_Text_Width(CG_GameTypeString(), scale, FONT_MEDIUM);
|
|
case CG_GAME_STATUS:
|
|
return CG_Text_Width(CG_GetGameStatusText(), scale, FONT_MEDIUM);
|
|
break;
|
|
case CG_KILLER:
|
|
return CG_Text_Width(CG_GetKillerText(), scale, FONT_MEDIUM);
|
|
break;
|
|
case CG_RED_NAME:
|
|
return CG_Text_Width(DEFAULT_REDTEAM_NAME/*cg_redTeamName.string*/, scale, FONT_MEDIUM);
|
|
break;
|
|
case CG_BLUE_NAME:
|
|
return CG_Text_Width(DEFAULT_BLUETEAM_NAME/*cg_blueTeamName.string*/, scale, FONT_MEDIUM);
|
|
break;
|
|
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int CG_PlayCinematic(const char *name, float x, float y, float w, float h) {
|
|
return trap_CIN_PlayCinematic(name, x, y, w, h, CIN_loop);
|
|
}
|
|
|
|
static void CG_StopCinematic(int handle) {
|
|
trap_CIN_StopCinematic(handle);
|
|
}
|
|
|
|
static void CG_DrawCinematic(int handle, float x, float y, float w, float h) {
|
|
trap_CIN_SetExtents(handle, x, y, w, h);
|
|
trap_CIN_DrawCinematic(handle);
|
|
}
|
|
|
|
static void CG_RunCinematicFrame(int handle) {
|
|
trap_CIN_RunCinematic(handle);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_LoadMenus();
|
|
|
|
=================
|
|
*/
|
|
void CG_LoadMenus(const char *menuFile)
|
|
{
|
|
const char *token;
|
|
const char *p;
|
|
int len;
|
|
fileHandle_t f;
|
|
static char buf[MAX_MENUDEFFILE];
|
|
|
|
len = trap_FS_FOpenFile( menuFile, &f, FS_READ );
|
|
|
|
if ( !f )
|
|
{
|
|
trap_Print( va( S_COLOR_RED "menu file not found: %s, using default\n", menuFile ) );
|
|
|
|
len = trap_FS_FOpenFile( "ui/jahud.txt", &f, FS_READ );
|
|
if (!f)
|
|
{
|
|
trap_Print( va( S_COLOR_RED "default menu file not found: ui/hud.txt, unable to continue!\n", menuFile ) );
|
|
}
|
|
}
|
|
|
|
if ( len >= MAX_MENUDEFFILE )
|
|
{
|
|
trap_Print( va( S_COLOR_RED "menu file too large: %s is %i, max allowed is %i", menuFile, len, MAX_MENUDEFFILE ) );
|
|
trap_FS_FCloseFile( f );
|
|
return;
|
|
}
|
|
|
|
trap_FS_Read( buf, len, f );
|
|
buf[len] = 0;
|
|
trap_FS_FCloseFile( f );
|
|
|
|
p = buf;
|
|
|
|
while ( 1 )
|
|
{
|
|
token = COM_ParseExt( &p, qtrue );
|
|
if( !token || token[0] == 0 || token[0] == '}')
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( Q_stricmp( token, "}" ) == 0 )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (Q_stricmp(token, "loadmenu") == 0)
|
|
{
|
|
if (CG_Load_Menu(&p))
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Com_Printf("UI menu load time = %d milli seconds\n", cgi_Milliseconds() - start);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_LoadHudMenu();
|
|
|
|
=================
|
|
*/
|
|
void CG_LoadHudMenu()
|
|
{
|
|
const char *hudSet;
|
|
|
|
cgDC.registerShaderNoMip = &trap_R_RegisterShaderNoMip;
|
|
cgDC.setColor = &trap_R_SetColor;
|
|
cgDC.drawHandlePic = &CG_DrawPic;
|
|
cgDC.drawStretchPic = &trap_R_DrawStretchPic;
|
|
cgDC.drawText = &CG_Text_Paint;
|
|
cgDC.textWidth = &CG_Text_Width;
|
|
cgDC.textHeight = &CG_Text_Height;
|
|
cgDC.registerModel = &trap_R_RegisterModel;
|
|
cgDC.modelBounds = &trap_R_ModelBounds;
|
|
cgDC.fillRect = &CG_FillRect;
|
|
cgDC.drawRect = &CG_DrawRect;
|
|
cgDC.drawSides = &CG_DrawSides;
|
|
cgDC.drawTopBottom = &CG_DrawTopBottom;
|
|
cgDC.clearScene = &trap_R_ClearScene;
|
|
cgDC.addRefEntityToScene = &trap_R_AddRefEntityToScene;
|
|
cgDC.renderScene = &trap_R_RenderScene;
|
|
cgDC.RegisterFont = &trap_R_RegisterFont;
|
|
cgDC.Font_StrLenPixels = &trap_R_Font_StrLenPixels;
|
|
cgDC.Font_StrLenChars = &trap_R_Font_StrLenChars;
|
|
cgDC.Font_HeightPixels = &trap_R_Font_HeightPixels;
|
|
cgDC.Font_DrawString = &trap_R_Font_DrawString;
|
|
cgDC.Language_IsAsian = &trap_Language_IsAsian;
|
|
cgDC.Language_UsesSpaces = &trap_Language_UsesSpaces;
|
|
cgDC.AnyLanguage_ReadCharFromString = &trap_AnyLanguage_ReadCharFromString;
|
|
cgDC.ownerDrawItem = &CG_OwnerDraw;
|
|
cgDC.getValue = &CG_GetValue;
|
|
cgDC.ownerDrawVisible = &CG_OwnerDrawVisible;
|
|
cgDC.runScript = &CG_RunMenuScript;
|
|
cgDC.deferScript = &CG_DeferMenuScript;
|
|
cgDC.getTeamColor = &CG_GetTeamColor;
|
|
cgDC.setCVar = trap_Cvar_Set;
|
|
cgDC.getCVarString = trap_Cvar_VariableStringBuffer;
|
|
cgDC.getCVarValue = CG_Cvar_Get;
|
|
cgDC.drawTextWithCursor = &CG_Text_PaintWithCursor;
|
|
//cgDC.setOverstrikeMode = &trap_Key_SetOverstrikeMode;
|
|
//cgDC.getOverstrikeMode = &trap_Key_GetOverstrikeMode;
|
|
cgDC.startLocalSound = &trap_S_StartLocalSound;
|
|
cgDC.ownerDrawHandleKey = &CG_OwnerDrawHandleKey;
|
|
cgDC.feederCount = &CG_FeederCount;
|
|
cgDC.feederItemImage = &CG_FeederItemImage;
|
|
cgDC.feederItemText = &CG_FeederItemText;
|
|
cgDC.feederSelection = &CG_FeederSelection;
|
|
//cgDC.setBinding = &trap_Key_SetBinding;
|
|
//cgDC.getBindingBuf = &trap_Key_GetBindingBuf;
|
|
//cgDC.keynumToStringBuf = &trap_Key_KeynumToStringBuf;
|
|
//cgDC.executeText = &trap_Cmd_ExecuteText;
|
|
cgDC.Error = &Com_Error;
|
|
cgDC.Print = &Com_Printf;
|
|
cgDC.ownerDrawWidth = &CG_OwnerDrawWidth;
|
|
//cgDC.Pause = &CG_Pause;
|
|
cgDC.registerSound = &trap_S_RegisterSound;
|
|
cgDC.startBackgroundTrack = &trap_S_StartBackgroundTrack;
|
|
cgDC.stopBackgroundTrack = &trap_S_StopBackgroundTrack;
|
|
cgDC.playCinematic = &CG_PlayCinematic;
|
|
cgDC.stopCinematic = &CG_StopCinematic;
|
|
cgDC.drawCinematic = &CG_DrawCinematic;
|
|
cgDC.runCinematicFrame = &CG_RunCinematicFrame;
|
|
|
|
Init_Display(&cgDC);
|
|
|
|
Menu_Reset();
|
|
|
|
hudSet = cg_hudFiles.string;
|
|
if (hudSet[0] == '\0')
|
|
{
|
|
hudSet = "ui/jahud.txt";
|
|
}
|
|
|
|
CG_LoadMenus(hudSet);
|
|
|
|
}
|
|
|
|
void CG_AssetCache() {
|
|
//if (Assets.textFont == NULL) {
|
|
// trap_R_RegisterFont("fonts/arial.ttf", 72, &Assets.textFont);
|
|
//}
|
|
//Assets.background = trap_R_RegisterShaderNoMip( ASSET_BACKGROUND );
|
|
//Com_Printf("Menu Size: %i bytes\n", sizeof(Menus));
|
|
cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( ASSET_GRADIENTBAR );
|
|
cgDC.Assets.fxBasePic = trap_R_RegisterShaderNoMip( ART_FX_BASE );
|
|
cgDC.Assets.fxPic[0] = trap_R_RegisterShaderNoMip( ART_FX_RED );
|
|
cgDC.Assets.fxPic[1] = trap_R_RegisterShaderNoMip( ART_FX_YELLOW );
|
|
cgDC.Assets.fxPic[2] = trap_R_RegisterShaderNoMip( ART_FX_GREEN );
|
|
cgDC.Assets.fxPic[3] = trap_R_RegisterShaderNoMip( ART_FX_TEAL );
|
|
cgDC.Assets.fxPic[4] = trap_R_RegisterShaderNoMip( ART_FX_BLUE );
|
|
cgDC.Assets.fxPic[5] = trap_R_RegisterShaderNoMip( ART_FX_CYAN );
|
|
cgDC.Assets.fxPic[6] = trap_R_RegisterShaderNoMip( ART_FX_WHITE );
|
|
cgDC.Assets.scrollBar = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR );
|
|
cgDC.Assets.scrollBarArrowDown = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWDOWN );
|
|
cgDC.Assets.scrollBarArrowUp = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWUP );
|
|
cgDC.Assets.scrollBarArrowLeft = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWLEFT );
|
|
cgDC.Assets.scrollBarArrowRight = trap_R_RegisterShaderNoMip( ASSET_SCROLLBAR_ARROWRIGHT );
|
|
cgDC.Assets.scrollBarThumb = trap_R_RegisterShaderNoMip( ASSET_SCROLL_THUMB );
|
|
cgDC.Assets.sliderBar = trap_R_RegisterShaderNoMip( ASSET_SLIDER_BAR );
|
|
cgDC.Assets.sliderThumb = trap_R_RegisterShaderNoMip( ASSET_SLIDER_THUMB );
|
|
}
|
|
|
|
/*
|
|
|
|
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
// initialise the cg_entities structure - take into account the ghoul2 stl stuff in the active snap shots
|
|
void CG_Init_CG(void)
|
|
{
|
|
#ifdef _XBOX
|
|
qboolean widescreen = cg.widescreen;
|
|
#endif
|
|
memset( &cg, 0, sizeof(cg));
|
|
#ifdef _XBOX
|
|
cg.widescreen = widescreen;
|
|
#endif
|
|
}
|
|
|
|
#ifdef _XBOX
|
|
void CG_SetWidescreen(qboolean widescreen)
|
|
{
|
|
cg.widescreen = widescreen;
|
|
}
|
|
#endif
|
|
|
|
|
|
// initialise the cg_entities structure - take into account the ghoul2 stl stuff
|
|
void CG_Init_CGents(void)
|
|
{
|
|
|
|
memset(&cg_entities, 0, sizeof(cg_entities));
|
|
}
|
|
|
|
|
|
void CG_InitItems(void)
|
|
{
|
|
memset( cg_items, 0, sizeof( cg_items ) );
|
|
}
|
|
|
|
void CG_TransitionPermanent(void)
|
|
{
|
|
centity_t *cent = cg_entities;
|
|
int i;
|
|
|
|
cg_numpermanents = 0;
|
|
for(i=0;i<MAX_GENTITIES;i++,cent++)
|
|
{
|
|
if (trap_GetDefaultState(i, ¢->currentState))
|
|
{
|
|
cent->nextState = cent->currentState;
|
|
VectorCopy (cent->currentState.origin, cent->lerpOrigin);
|
|
VectorCopy (cent->currentState.angles, cent->lerpAngles);
|
|
cent->currentValid = qtrue;
|
|
|
|
cg_permanents[cg_numpermanents++] = cent;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//this is a 32k custom pool for parsing ents, it can get reset between ent parsing
|
|
//so we don't need a whole lot of memory -rww
|
|
#define MAX_CGSTRPOOL_SIZE 32768
|
|
static int cg_strPoolSize = 0;
|
|
static byte cg_strPool[MAX_CGSTRPOOL_SIZE];
|
|
|
|
char *CG_StrPool_Alloc(int size)
|
|
{
|
|
char *giveThemThis;
|
|
|
|
if (cg_strPoolSize+size >= MAX_CGSTRPOOL_SIZE)
|
|
{
|
|
Com_Error(ERR_DROP, "You exceeded the cgame string pool size. Bad programmer!\n");
|
|
}
|
|
|
|
giveThemThis = (char *) &cg_strPool[cg_strPoolSize];
|
|
cg_strPoolSize += size;
|
|
|
|
//memset it for them, just to be nice.
|
|
memset(giveThemThis, 0, size);
|
|
|
|
return giveThemThis;
|
|
}
|
|
|
|
void CG_StrPool_Reset(void)
|
|
{
|
|
cg_strPoolSize = 0;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
CG_NewString
|
|
|
|
Builds a copy of the string, translating \n to real linefeeds
|
|
so message texts can be multi-line
|
|
=============
|
|
*/
|
|
char *CG_NewString( const char *string )
|
|
{
|
|
char *newb, *new_p;
|
|
int i,l;
|
|
|
|
l = strlen(string) + 1;
|
|
|
|
newb = CG_StrPool_Alloc( l );
|
|
|
|
new_p = newb;
|
|
|
|
// turn \n into a real linefeed
|
|
for ( i=0 ; i< l ; i++ ) {
|
|
if (string[i] == '\\' && i < l-1) {
|
|
i++;
|
|
if (string[i] == 'n') {
|
|
*new_p++ = '\n';
|
|
} else {
|
|
*new_p++ = '\\';
|
|
}
|
|
} else {
|
|
*new_p++ = string[i];
|
|
}
|
|
}
|
|
|
|
return newb;
|
|
}
|
|
|
|
//data to grab our spawn info into
|
|
typedef struct cgSpawnEnt_s
|
|
{
|
|
char *classname;
|
|
vec3_t origin;
|
|
vec3_t angles;
|
|
float angle;
|
|
vec3_t scale;
|
|
float fScale;
|
|
vec3_t mins;
|
|
vec3_t maxs;
|
|
char *model;
|
|
float zoffset;
|
|
int onlyFogHere;
|
|
float fogstart;
|
|
float radarrange;
|
|
} cgSpawnEnt_t;
|
|
|
|
#define CGFOFS(x) ((int)&(((cgSpawnEnt_t *)0)->x))
|
|
|
|
//spawn fields for our cgame "entity"
|
|
BG_field_t cg_spawnFields[] =
|
|
{
|
|
{"classname", CGFOFS(classname), F_LSTRING},
|
|
{"origin", CGFOFS(origin), F_VECTOR},
|
|
{"angles", CGFOFS(angles), F_VECTOR},
|
|
{"angle", CGFOFS(angle), F_FLOAT},
|
|
{"modelscale", CGFOFS(fScale), F_FLOAT},
|
|
{"modelscale_vec", CGFOFS(scale), F_VECTOR},
|
|
{"model", CGFOFS(model), F_LSTRING},
|
|
{"mins", CGFOFS(mins), F_VECTOR},
|
|
{"maxs", CGFOFS(maxs), F_VECTOR},
|
|
{"zoffset", CGFOFS(zoffset), F_FLOAT},
|
|
{"onlyfoghere", CGFOFS(onlyFogHere), F_INT},
|
|
{"fogstart", CGFOFS(fogstart), F_FLOAT},
|
|
{"radarrange", CGFOFS(radarrange), F_FLOAT},
|
|
{NULL}
|
|
};
|
|
|
|
static int cg_numSpawnVars;
|
|
static int cg_numSpawnVarChars;
|
|
static char *cg_spawnVars[MAX_SPAWN_VARS][2];
|
|
static char cg_spawnVarChars[MAX_SPAWN_VARS_CHARS];
|
|
|
|
//get some info from the skyportal ent on the map
|
|
qboolean cg_noFogOutsidePortal = qfalse;
|
|
void CG_CreateSkyPortalFromSpawnEnt(cgSpawnEnt_t *ent)
|
|
{
|
|
if (ent->onlyFogHere)
|
|
{ //only globally fog INSIDE the sky portal
|
|
cg_noFogOutsidePortal = qtrue;
|
|
}
|
|
}
|
|
|
|
//create a skybox portal orientation entity. there -should- only
|
|
//be one of these things per level. if there's more than one the
|
|
//next will just stomp over the last. -rww
|
|
qboolean cg_skyOri = qfalse;
|
|
vec3_t cg_skyOriPos;
|
|
float cg_skyOriScale = 0.0f;
|
|
void CG_CreateSkyOriFromSpawnEnt(cgSpawnEnt_t *ent)
|
|
{
|
|
cg_skyOri = qtrue;
|
|
VectorCopy(ent->origin, cg_skyOriPos);
|
|
cg_skyOriScale = ent->fScale;
|
|
}
|
|
|
|
//get brush box extents, note this does not care about bsp instances.
|
|
void CG_CreateBrushEntData(cgSpawnEnt_t *ent)
|
|
{
|
|
trap_R_ModelBounds(trap_R_RegisterModel(ent->model), ent->mins, ent->maxs);
|
|
}
|
|
|
|
void CG_CreateWeatherZoneFromSpawnEnt(cgSpawnEnt_t *ent)
|
|
{
|
|
CG_CreateBrushEntData(ent);
|
|
trap_WE_AddWeatherZone(ent->mins, ent->maxs);
|
|
}
|
|
|
|
//create a new cgame-only model
|
|
void CG_CreateModelFromSpawnEnt(cgSpawnEnt_t *ent)
|
|
{
|
|
int modelIndex;
|
|
refEntity_t *RefEnt;
|
|
vec3_t mins, maxs;
|
|
float *radius;
|
|
float *zOff;
|
|
|
|
if (NumMiscEnts >= MAX_MISC_ENTS)
|
|
{
|
|
Com_Error(ERR_DROP, "Too many misc_model_static's on level, ask a programmer to raise the limit (currently %i), or take some out.", MAX_MISC_ENTS);
|
|
return;
|
|
}
|
|
|
|
if (!ent || !ent->model || !ent->model[0])
|
|
{
|
|
Com_Error(ERR_DROP, "misc_model_static with no model.");
|
|
return;
|
|
}
|
|
|
|
radius = &Radius[NumMiscEnts];
|
|
zOff = &zOffset[NumMiscEnts];
|
|
RefEnt = &MiscEnts[NumMiscEnts++];
|
|
|
|
modelIndex = trap_R_RegisterModel(ent->model);
|
|
if (modelIndex == 0)
|
|
{
|
|
Com_Error(ERR_DROP, "misc_model_static failed to load model '%s'",ent->model);
|
|
return;
|
|
}
|
|
|
|
memset(RefEnt, 0, sizeof(refEntity_t));
|
|
RefEnt->reType = RT_MODEL;
|
|
RefEnt->hModel = modelIndex;
|
|
RefEnt->frame = 0;
|
|
trap_R_ModelBounds(modelIndex, mins, maxs);
|
|
VectorCopy(ent->scale, RefEnt->modelScale);
|
|
if (ent->fScale)
|
|
{ //use same scale on each axis then
|
|
RefEnt->modelScale[0] = RefEnt->modelScale[1] = RefEnt->modelScale[2] = ent->fScale;
|
|
}
|
|
VectorCopy(ent->origin, RefEnt->origin);
|
|
VectorCopy(ent->origin, RefEnt->lightingOrigin);
|
|
|
|
VectorScaleVector(mins, ent->scale, mins);
|
|
VectorScaleVector(maxs, ent->scale, maxs);
|
|
*radius = Distance(mins, maxs);
|
|
*zOff = ent->zoffset;
|
|
|
|
if (ent->angle)
|
|
{ //only yaw supplied...
|
|
ent->angles[YAW] = ent->angle;
|
|
}
|
|
|
|
AnglesToAxis( ent->angles, RefEnt->axis );
|
|
ScaleModelAxis(RefEnt);
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CG_AddSpawnVarToken
|
|
====================
|
|
*/
|
|
char *CG_AddSpawnVarToken( const char *string )
|
|
{
|
|
int l;
|
|
char *dest;
|
|
|
|
l = strlen( string );
|
|
if ( cg_numSpawnVarChars + l + 1 > MAX_SPAWN_VARS_CHARS ) {
|
|
CG_Error( "CG_AddSpawnVarToken: MAX_SPAWN_VARS" );
|
|
}
|
|
|
|
dest = cg_spawnVarChars + cg_numSpawnVarChars;
|
|
memcpy( dest, string, l+1 );
|
|
|
|
cg_numSpawnVarChars += l + 1;
|
|
|
|
return dest;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
CG_ParseSpawnVars
|
|
|
|
cgame version of G_ParseSpawnVars, for ents that don't really
|
|
need to take up an entity slot (e.g. static models) -rww
|
|
====================
|
|
*/
|
|
qboolean CG_ParseSpawnVars( void )
|
|
{
|
|
char keyname[MAX_TOKEN_CHARS];
|
|
char com_token[MAX_TOKEN_CHARS];
|
|
|
|
cg_numSpawnVars = 0;
|
|
cg_numSpawnVarChars = 0;
|
|
|
|
// parse the opening brace
|
|
if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) ) {
|
|
// end of spawn string
|
|
return qfalse;
|
|
}
|
|
if ( com_token[0] != '{' ) {
|
|
CG_Error( "CG_ParseSpawnVars: found %s when expecting {",com_token );
|
|
}
|
|
|
|
// go through all the key / value pairs
|
|
while ( 1 )
|
|
{
|
|
// parse key
|
|
if ( !trap_GetEntityToken( keyname, sizeof( keyname ) ) )
|
|
{
|
|
CG_Error( "CG_ParseSpawnVars: EOF without closing brace" );
|
|
}
|
|
|
|
if ( keyname[0] == '}' )
|
|
{
|
|
break;
|
|
}
|
|
|
|
// parse value
|
|
if ( !trap_GetEntityToken( com_token, sizeof( com_token ) ) )
|
|
{ //this happens on mike's test level, I don't know why. Fixme?
|
|
//CG_Error( "CG_ParseSpawnVars: EOF without closing brace" );
|
|
break;
|
|
}
|
|
|
|
if ( com_token[0] == '}' )
|
|
{
|
|
CG_Error( "CG_ParseSpawnVars: closing brace without data" );
|
|
}
|
|
if ( cg_numSpawnVars == MAX_SPAWN_VARS )
|
|
{
|
|
CG_Error( "CG_ParseSpawnVars: MAX_SPAWN_VARS" );
|
|
}
|
|
cg_spawnVars[ cg_numSpawnVars ][0] = CG_AddSpawnVarToken( keyname );
|
|
cg_spawnVars[ cg_numSpawnVars ][1] = CG_AddSpawnVarToken( com_token );
|
|
cg_numSpawnVars++;
|
|
}
|
|
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
CG_SpawnCGameEntFromVars
|
|
|
|
See if we should do something for this ent cgame-side -rww
|
|
==============
|
|
*/
|
|
#include "../namespace_begin.h"
|
|
void BG_ParseField( BG_field_t *l_fields, const char *key, const char *value, byte *ent );
|
|
#include "../namespace_end.h"
|
|
|
|
extern float cg_linearFogOverride; //cg_view.c
|
|
extern float cg_radarRange;//cg_draw.c
|
|
void CG_SpawnCGameEntFromVars(void)
|
|
{
|
|
int i;
|
|
cgSpawnEnt_t ent;
|
|
|
|
memset(&ent, 0, sizeof(cgSpawnEnt_t));
|
|
|
|
for (i = 0; i < cg_numSpawnVars; i++)
|
|
{ //shove all this stuff into our data structure used specifically for getting spawn info
|
|
BG_ParseField( cg_spawnFields, cg_spawnVars[i][0], cg_spawnVars[i][1], (byte *)&ent );
|
|
}
|
|
|
|
if (ent.classname && ent.classname[0])
|
|
{ //we'll just stricmp this bastard, since there aren't all that many cgame-only things, and they all have special handling
|
|
if (!Q_stricmp(ent.classname, "worldspawn"))
|
|
{ //I'd like some info off this guy
|
|
if (ent.fogstart)
|
|
{ //linear fog method
|
|
cg_linearFogOverride = ent.fogstart;
|
|
}
|
|
//get radarRange off of worldspawn
|
|
if (ent.radarrange)
|
|
{ //linear fog method
|
|
cg_radarRange = ent.radarrange;
|
|
}
|
|
}
|
|
else if (!Q_stricmp(ent.classname, "misc_model_static"))
|
|
{ //we've got us a static model
|
|
CG_CreateModelFromSpawnEnt(&ent);
|
|
}
|
|
else if (!Q_stricmp(ent.classname, "misc_skyportal_orient"))
|
|
{ //a sky portal orientation point
|
|
CG_CreateSkyOriFromSpawnEnt(&ent);
|
|
}
|
|
else if (!Q_stricmp(ent.classname, "misc_skyportal"))
|
|
{ //might as well parse this thing cgame side for the extra info I want out of it
|
|
CG_CreateSkyPortalFromSpawnEnt(&ent);
|
|
}
|
|
else if (!Q_stricmp(ent.classname, "misc_weather_zone"))
|
|
{ //might as well parse this thing cgame side for the extra info I want out of it
|
|
CG_CreateWeatherZoneFromSpawnEnt(&ent);
|
|
}
|
|
}
|
|
|
|
//reset the string pool for the next entity, if there is one
|
|
CG_StrPool_Reset();
|
|
}
|
|
|
|
/*
|
|
==============
|
|
CG_SpawnCGameOnlyEnts
|
|
|
|
Parses entity string data for cgame-only entities, that we can throw away on
|
|
the server and never even bother sending. -rww
|
|
==============
|
|
*/
|
|
void CG_SpawnCGameOnlyEnts(void)
|
|
{
|
|
//make sure it is reset
|
|
trap_GetEntityToken(NULL, -1);
|
|
|
|
if (!CG_ParseSpawnVars())
|
|
{ //first one is gonna be the world spawn
|
|
CG_Error("no entities for cgame parse");
|
|
}
|
|
else
|
|
{ //parse the world spawn info we want
|
|
CG_SpawnCGameEntFromVars();
|
|
}
|
|
|
|
while(CG_ParseSpawnVars())
|
|
{ //now run through the whole list, and look for things we care about cgame-side
|
|
CG_SpawnCGameEntFromVars();
|
|
}
|
|
}
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
extern playerState_t *cgSendPS[MAX_GENTITIES]; //is not MAX_CLIENTS because NPCs exceed MAX_CLIENTS
|
|
void CG_PmoveClientPointerUpdate();
|
|
|
|
#include "../namespace_begin.h"
|
|
void WP_SaberLoadParms( void );
|
|
void BG_VehicleLoadParms( void );
|
|
#include "../namespace_end.h"
|
|
|
|
/*
|
|
=================
|
|
CG_Init
|
|
|
|
Called after every level change or subsystem restart
|
|
Will perform callbacks to make the loading info screen update.
|
|
=================
|
|
*/
|
|
void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum )
|
|
{
|
|
static gitem_t *item;
|
|
char buf[64];
|
|
const char *s;
|
|
int i = 0;
|
|
|
|
BG_InitAnimsets(); //clear it out
|
|
|
|
trap_CG_RegisterSharedMemory(cg.sharedBuffer);
|
|
|
|
//Load external vehicle data
|
|
BG_VehicleLoadParms();
|
|
|
|
// clear everything
|
|
/*
|
|
Ghoul2 Insert Start
|
|
*/
|
|
|
|
// memset( cg_entities, 0, sizeof( cg_entities ) );
|
|
CG_Init_CGents();
|
|
// this is a No-No now we have stl vector classes in here.
|
|
// memset( &cg, 0, sizeof( cg ) );
|
|
CG_Init_CG();
|
|
CG_InitItems();
|
|
|
|
//create the global jetpack instance
|
|
CG_InitJetpackGhoul2();
|
|
|
|
CG_PmoveClientPointerUpdate();
|
|
|
|
/*
|
|
Ghoul2 Insert End
|
|
*/
|
|
|
|
//Load sabers.cfg data
|
|
WP_SaberLoadParms();
|
|
|
|
// this is kinda dumb as well, but I need to pre-load some fonts in order to have the text available
|
|
// to say I'm loading the assets.... which includes loading the fonts. So I'll set these up as reasonable
|
|
// defaults, then let the menu asset parser (which actually specifies the ingame fonts) load over them
|
|
// if desired during parse. Dunno how legal it is to store in these cgDC things, but it causes no harm
|
|
// and even if/when they get overwritten they'll be legalised by the menu asset parser :-)
|
|
// CG_LoadFonts();
|
|
cgDC.Assets.qhSmallFont = trap_R_RegisterFont("ocr_a");
|
|
cgDC.Assets.qhMediumFont = trap_R_RegisterFont("ergoec");
|
|
cgDC.Assets.qhBigFont = cgDC.Assets.qhMediumFont;
|
|
|
|
memset( &cgs, 0, sizeof( cgs ) );
|
|
memset( cg_weapons, 0, sizeof(cg_weapons) );
|
|
|
|
cg.clientNum = clientNum;
|
|
|
|
cgs.processedSnapshotNum = serverMessageNum;
|
|
cgs.serverCommandSequence = serverCommandSequence;
|
|
|
|
cg.loadLCARSStage = 0;
|
|
|
|
cg.itemSelect = -1;
|
|
cg.forceSelect = -1;
|
|
|
|
// load a few needed things before we do any screen updates
|
|
cgs.media.charsetShader = trap_R_RegisterShaderNoMip( "gfx/2d/charsgrid_med" );
|
|
cgs.media.whiteShader = trap_R_RegisterShader( "white" );
|
|
|
|
cgs.media.loadBarLED = trap_R_RegisterShaderNoMip( "gfx/hud/load_tick" );
|
|
cgs.media.loadBarLEDCap = trap_R_RegisterShaderNoMip( "gfx/hud/load_tick_cap" );
|
|
cgs.media.loadBarLEDSurround= trap_R_RegisterShaderNoMip( "gfx/hud/mp_levelload" );
|
|
|
|
// Force HUD set up
|
|
cg.forceHUDActive = qtrue;
|
|
cg.forceHUDTotalFlashTime = 0;
|
|
cg.forceHUDNextFlashTime = 0;
|
|
|
|
i = WP_NONE+1;
|
|
while (i <= LAST_USEABLE_WEAPON)
|
|
{
|
|
item = BG_FindItemForWeapon(i);
|
|
|
|
if (item && item->icon && item->icon[0])
|
|
{
|
|
cgs.media.weaponIcons[i] = trap_R_RegisterShaderNoMip(item->icon);
|
|
cgs.media.weaponIcons_NA[i] = trap_R_RegisterShaderNoMip(va("%s_na", item->icon));
|
|
}
|
|
else
|
|
{ //make sure it is zero'd (default shader)
|
|
cgs.media.weaponIcons[i] = 0;
|
|
cgs.media.weaponIcons_NA[i] = 0;
|
|
}
|
|
i++;
|
|
}
|
|
trap_Cvar_VariableStringBuffer("com_buildscript", buf, sizeof(buf));
|
|
if (atoi(buf))
|
|
{
|
|
trap_R_RegisterShaderNoMip("gfx/hud/w_icon_saberstaff");
|
|
trap_R_RegisterShaderNoMip("gfx/hud/w_icon_duallightsaber");
|
|
}
|
|
i = 0;
|
|
|
|
// HUD artwork for cycling inventory,weapons and force powers
|
|
cgs.media.weaponIconBackground = trap_R_RegisterShaderNoMip( "gfx/hud/background");
|
|
cgs.media.forceIconBackground = trap_R_RegisterShaderNoMip( "gfx/hud/background_f");
|
|
cgs.media.inventoryIconBackground = trap_R_RegisterShaderNoMip( "gfx/hud/background_i");
|
|
|
|
//rww - precache holdable item icons here
|
|
while (i < bg_numItems)
|
|
{
|
|
if (bg_itemlist[i].giType == IT_HOLDABLE)
|
|
{
|
|
if (bg_itemlist[i].icon)
|
|
{
|
|
cgs.media.invenIcons[bg_itemlist[i].giTag] = trap_R_RegisterShaderNoMip(bg_itemlist[i].icon);
|
|
}
|
|
else
|
|
{
|
|
cgs.media.invenIcons[bg_itemlist[i].giTag] = 0;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
//rww - precache force power icons here
|
|
i = 0;
|
|
|
|
while (i < NUM_FORCE_POWERS)
|
|
{
|
|
cgs.media.forcePowerIcons[i] = trap_R_RegisterShaderNoMip(HolocronIcons[i]);
|
|
|
|
i++;
|
|
}
|
|
cgs.media.rageRecShader = trap_R_RegisterShaderNoMip("gfx/mp/f_icon_ragerec");
|
|
|
|
|
|
//body decal shaders -rww
|
|
cgs.media.bdecal_bodyburn1 = trap_R_RegisterShader("gfx/damage/bodyburnmark1");
|
|
cgs.media.bdecal_saberglow = trap_R_RegisterShader("gfx/damage/saberglowmark");
|
|
cgs.media.bdecal_burn1 = trap_R_RegisterShader("gfx/damage/bodybigburnmark1");
|
|
cgs.media.mSaberDamageGlow = trap_R_RegisterShader("gfx/effects/saberDamageGlow");
|
|
|
|
CG_RegisterCvars();
|
|
|
|
CG_InitConsoleCommands();
|
|
|
|
cg.weaponSelect = WP_BRYAR_PISTOL;
|
|
|
|
cgs.redflag = cgs.blueflag = -1; // For compatibily, default to unset for
|
|
cgs.flagStatus = -1;
|
|
// old servers
|
|
|
|
// get the rendering configuration from the client system
|
|
trap_GetGlconfig( &cgs.glconfig );
|
|
cgs.screenXScale = cgs.glconfig.vidWidth / 640.0;
|
|
cgs.screenYScale = cgs.glconfig.vidHeight / 480.0;
|
|
|
|
// get the gamestate from the client system
|
|
trap_GetGameState( &cgs.gameState );
|
|
|
|
CG_TransitionPermanent(); //rwwRMG - added
|
|
|
|
// check version
|
|
s = CG_ConfigString( CS_GAME_VERSION );
|
|
if ( strcmp( s, GAME_VERSION ) ) {
|
|
CG_Error( "Client/Server game mismatch: %s/%s", GAME_VERSION, s );
|
|
}
|
|
|
|
s = CG_ConfigString( CS_LEVEL_START_TIME );
|
|
cgs.levelStartTime = atoi( s );
|
|
|
|
CG_ParseServerinfo();
|
|
|
|
// load the new map
|
|
// CG_LoadingString( "collision map" );
|
|
|
|
trap_CM_LoadMap( cgs.mapname, qfalse );
|
|
|
|
String_Init();
|
|
|
|
cg.loading = qtrue; // force players to load instead of defer
|
|
|
|
//make sure saber data is loaded before this! (so we can precache the appropriate hilts)
|
|
CG_InitSiegeMode();
|
|
|
|
CG_RegisterSounds();
|
|
|
|
// CG_LoadingString( "graphics" );
|
|
|
|
CG_RegisterGraphics();
|
|
|
|
// CG_LoadingString( "clients" );
|
|
|
|
CG_RegisterClients(); // if low on memory, some clients will be deferred
|
|
|
|
CG_AssetCache();
|
|
CG_LoadHudMenu(); // load new hud stuff
|
|
|
|
cg.loading = qfalse; // future players will be deferred
|
|
|
|
CG_InitLocalEntities();
|
|
|
|
CG_InitMarkPolys();
|
|
|
|
// remove the last loading update
|
|
cg.infoScreenText[0] = 0;
|
|
|
|
// Make sure we have update values (scores)
|
|
CG_SetConfigValues();
|
|
|
|
CG_StartMusic(qfalse);
|
|
|
|
// CG_LoadingString( "Clearing light styles" );
|
|
CG_ClearLightStyles();
|
|
|
|
// CG_LoadingString( "Creating automap data" );
|
|
//init automap
|
|
#ifndef _XBOX
|
|
trap_R_InitWireframeAutomap();
|
|
#endif
|
|
|
|
CG_LoadingString( "" );
|
|
|
|
CG_ShaderStateChanged();
|
|
|
|
trap_S_ClearLoopingSounds();
|
|
|
|
trap_R_GetDistanceCull(&cg.distanceCull);
|
|
|
|
//now get all the cgame only cents
|
|
CG_SpawnCGameOnlyEnts();
|
|
}
|
|
|
|
//makes sure returned string is in localized format
|
|
const char *CG_GetLocationString(const char *loc)
|
|
{
|
|
static char text[1024]={0};
|
|
|
|
if (!loc || loc[0] != '@')
|
|
{ //just a raw string
|
|
return loc;
|
|
}
|
|
|
|
trap_SP_GetStringTextString(loc+1, text, sizeof(text));
|
|
return text;
|
|
}
|
|
|
|
//clean up all the ghoul2 allocations, the nice and non-hackly way -rww
|
|
void CG_KillCEntityG2(int entNum);
|
|
void CG_DestroyAllGhoul2(void)
|
|
{
|
|
int i = 0;
|
|
int j;
|
|
|
|
// Com_Printf("... CGameside GHOUL2 Cleanup\n");
|
|
while (i < MAX_GENTITIES)
|
|
{ //free all dynamically allocated npc client info structs and ghoul2 instances
|
|
CG_KillCEntityG2(i);
|
|
i++;
|
|
}
|
|
|
|
//Clean the weapon instances
|
|
CG_ShutDownG2Weapons();
|
|
|
|
i = 0;
|
|
while (i < MAX_ITEMS)
|
|
{ //and now for items
|
|
j = 0;
|
|
while (j < MAX_ITEM_MODELS)
|
|
{
|
|
if (cg_items[i].g2Models[j] && trap_G2_HaveWeGhoul2Models(cg_items[i].g2Models[j]))
|
|
{
|
|
trap_G2API_CleanGhoul2Models(&cg_items[i].g2Models[j]);
|
|
cg_items[i].g2Models[j] = NULL;
|
|
}
|
|
j++;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
//Clean the global jetpack instance
|
|
CG_CleanJetpackGhoul2();
|
|
}
|
|
|
|
/*
|
|
=================
|
|
CG_Shutdown
|
|
|
|
Called before every level change or subsystem restart
|
|
=================
|
|
*/
|
|
void CG_Shutdown( void )
|
|
{
|
|
BG_ClearAnimsets(); //free all dynamic allocations made through the engine
|
|
|
|
CG_DestroyAllGhoul2();
|
|
|
|
// Com_Printf("... FX System Cleanup\n");
|
|
trap_FX_FreeSystem();
|
|
trap_ROFF_Clean();
|
|
|
|
if (cgWeatherOverride)
|
|
{
|
|
trap_R_WeatherContentsOverride(0); //rwwRMG - reset it engine-side
|
|
}
|
|
|
|
//reset weather
|
|
trap_R_WorldEffectCommand("die");
|
|
|
|
UI_CleanupGhoul2();
|
|
//If there was any ghoul2 stuff in our side of the shared ui code, then remove it now.
|
|
|
|
// some mods may need to do cleanup work here,
|
|
// like closing files or archiving session data
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_NextForcePower_f
|
|
===============
|
|
*/
|
|
void CG_NextForcePower_f( void )
|
|
{
|
|
int current;
|
|
usercmd_t cmd;
|
|
if ( !cg.snap )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
current = trap_GetCurrentCmdNumber();
|
|
trap_GetUserCmd(current, &cmd);
|
|
if ((cmd.buttons & BUTTON_USE) || CG_NoUseableForce())
|
|
{
|
|
CG_NextInventory_f();
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.pm_flags & PMF_FOLLOW)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// BG_CycleForce(&cg.snap->ps, 1);
|
|
if (cg.forceSelect != -1)
|
|
{
|
|
cg.snap->ps.fd.forcePowerSelected = cg.forceSelect;
|
|
}
|
|
|
|
BG_CycleForce(&cg.snap->ps, 1);
|
|
|
|
if (cg.snap->ps.fd.forcePowersKnown & (1 << cg.snap->ps.fd.forcePowerSelected))
|
|
{
|
|
cg.forceSelect = cg.snap->ps.fd.forcePowerSelected;
|
|
cg.forceSelectTime = cg.time;
|
|
}
|
|
}
|
|
|
|
/*
|
|
===============
|
|
CG_PrevForcePower_f
|
|
===============
|
|
*/
|
|
void CG_PrevForcePower_f( void )
|
|
{
|
|
int current;
|
|
usercmd_t cmd;
|
|
if ( !cg.snap )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
current = trap_GetCurrentCmdNumber();
|
|
trap_GetUserCmd(current, &cmd);
|
|
if ((cmd.buttons & BUTTON_USE) || CG_NoUseableForce())
|
|
{
|
|
CG_PrevInventory_f();
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.pm_flags & PMF_FOLLOW)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// BG_CycleForce(&cg.snap->ps, -1);
|
|
if (cg.forceSelect != -1)
|
|
{
|
|
cg.snap->ps.fd.forcePowerSelected = cg.forceSelect;
|
|
}
|
|
|
|
BG_CycleForce(&cg.snap->ps, -1);
|
|
|
|
if (cg.snap->ps.fd.forcePowersKnown & (1 << cg.snap->ps.fd.forcePowerSelected))
|
|
{
|
|
cg.forceSelect = cg.snap->ps.fd.forcePowerSelected;
|
|
cg.forceSelectTime = cg.time;
|
|
}
|
|
}
|
|
|
|
void CG_NextInventory_f(void)
|
|
{
|
|
if ( !cg.snap )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.pm_flags & PMF_FOLLOW)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.itemSelect != -1)
|
|
{
|
|
cg.snap->ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(cg.itemSelect, IT_HOLDABLE);
|
|
}
|
|
BG_CycleInven(&cg.snap->ps, 1);
|
|
|
|
if (cg.snap->ps.stats[STAT_HOLDABLE_ITEM])
|
|
{
|
|
cg.itemSelect = bg_itemlist[cg.snap->ps.stats[STAT_HOLDABLE_ITEM]].giTag;
|
|
cg.invenSelectTime = cg.time;
|
|
}
|
|
}
|
|
|
|
void CG_PrevInventory_f(void)
|
|
{
|
|
if ( !cg.snap )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.snap->ps.pm_flags & PMF_FOLLOW)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.predictedPlayerState.pm_type == PM_SPECTATOR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (cg.itemSelect != -1)
|
|
{
|
|
cg.snap->ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(cg.itemSelect, IT_HOLDABLE);
|
|
}
|
|
BG_CycleInven(&cg.snap->ps, -1);
|
|
|
|
if (cg.snap->ps.stats[STAT_HOLDABLE_ITEM])
|
|
{
|
|
cg.itemSelect = bg_itemlist[cg.snap->ps.stats[STAT_HOLDABLE_ITEM]].giTag;
|
|
cg.invenSelectTime = cg.time;
|
|
}
|
|
}
|