diff options
Diffstat (limited to 'src/cgame/cg_main.c')
| -rw-r--r-- | src/cgame/cg_main.c | 1897 |
1 files changed, 1897 insertions, 0 deletions
diff --git a/src/cgame/cg_main.c b/src/cgame/cg_main.c new file mode 100644 index 0000000..a3f9963 --- /dev/null +++ b/src/cgame/cg_main.c @@ -0,0 +1,1897 @@ +/*
+===========================================================================
+Copyright (C) 1999-2005 Id Software, Inc.
+Copyright (C) 2000-2006 Tim Angus
+
+This file is part of Tremulous.
+
+Tremulous is free software; you can redistribute it
+and/or modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the License,
+or (at your option) any later version.
+
+Tremulous is distributed in the hope that it will be
+useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Tremulous; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+===========================================================================
+*/
+
+// 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;
+
+int forceModelModificationCount = -1;
+
+void CG_Init( int serverMessageNum, int serverCommandSequence, int clientNum );
+void CG_Shutdown( void );
+
+/*
+================
+vmMain
+
+This is the only way control passes into the module.
+This must be the very first function compiled into the .q3vm file
+================
+*/
+intptr_t 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_CONSOLE_TEXT:
+ CG_AddNotifyText( );
+ return 0;
+
+ 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;
+
+ default:
+ CG_Error( "vmMain: unknown command %i", command );
+ break;
+ }
+
+ return -1;
+}
+
+
+cg_t cg;
+cgs_t cgs;
+centity_t cg_entities[ MAX_GENTITIES ];
+
+//TA: weapons limit expanded:
+//weaponInfo_t cg_weapons[MAX_WEAPONS];
+weaponInfo_t cg_weapons[ 32 ];
+upgradeInfo_t cg_upgrades[ 32 ];
+
+buildableInfo_t cg_buildables[ BA_NUM_BUILDABLES ];
+
+vmCvar_t cg_teslaTrailTime;
+vmCvar_t cg_railTrailTime;
+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_gibs;
+vmCvar_t cg_drawTimer;
+vmCvar_t cg_drawClock;
+vmCvar_t cg_drawFPS;
+vmCvar_t cg_drawDemoState;
+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_drawRewards;
+vmCvar_t cg_crosshairX;
+vmCvar_t cg_crosshairY;
+vmCvar_t cg_draw2D;
+vmCvar_t cg_drawStatus;
+vmCvar_t cg_animSpeed;
+vmCvar_t cg_debugAnim;
+vmCvar_t cg_debugPosition;
+vmCvar_t cg_debugEvents;
+vmCvar_t cg_errorDecay;
+vmCvar_t cg_nopredict;
+vmCvar_t cg_debugMove;
+vmCvar_t cg_noPlayerAnims;
+vmCvar_t cg_showmiss;
+vmCvar_t cg_footsteps;
+vmCvar_t cg_addMarks;
+vmCvar_t cg_brassTime;
+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_tracerChance;
+vmCvar_t cg_tracerWidth;
+vmCvar_t cg_tracerLength;
+vmCvar_t cg_autoswitch;
+vmCvar_t cg_ignore;
+vmCvar_t cg_simpleItems;
+vmCvar_t cg_fov;
+vmCvar_t cg_zoomFov;
+vmCvar_t cg_thirdPerson;
+vmCvar_t cg_thirdPersonRange;
+vmCvar_t cg_thirdPersonAngle;
+vmCvar_t cg_stereoSeparation;
+vmCvar_t cg_lagometer;
+vmCvar_t cg_drawAttacker;
+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_noVoiceChats;
+vmCvar_t cg_noVoiceText;
+vmCvar_t cg_hudFiles;
+vmCvar_t cg_scorePlum;
+vmCvar_t cg_smoothClients;
+vmCvar_t pmove_fixed;
+//vmCvar_t cg_pmove_fixed;
+vmCvar_t pmove_msec;
+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_smallFont;
+vmCvar_t cg_bigFont;
+vmCvar_t cg_noTaunt;
+vmCvar_t cg_noProjectileTrail;
+vmCvar_t cg_oldRail;
+vmCvar_t cg_oldRocket;
+vmCvar_t cg_oldPlasma;
+vmCvar_t cg_trueLightning;
+vmCvar_t cg_creepRes;
+vmCvar_t cg_drawSurfNormal;
+vmCvar_t cg_drawBBOX;
+vmCvar_t cg_debugAlloc;
+vmCvar_t cg_wwSmoothTime;
+vmCvar_t cg_wwFollow;
+vmCvar_t cg_wwToggle;
+vmCvar_t cg_depthSortParticles;
+vmCvar_t cg_bounceParticles;
+vmCvar_t cg_consoleLatency;
+vmCvar_t cg_lightFlare;
+vmCvar_t cg_debugParticles;
+vmCvar_t cg_debugTrails;
+vmCvar_t cg_debugPVS;
+vmCvar_t cg_disableWarningDialogs;
+vmCvar_t cg_disableScannerPlane;
+vmCvar_t cg_tutorial;
+
+vmCvar_t cg_painBlendUpRate;
+vmCvar_t cg_painBlendDownRate;
+vmCvar_t cg_painBlendMax;
+vmCvar_t cg_painBlendScale;
+vmCvar_t cg_painBlendZoom;
+
+//TA: hack to get class and carriage through to UI module
+vmCvar_t ui_currentClass;
+vmCvar_t ui_carriage;
+vmCvar_t ui_stages;
+vmCvar_t ui_dialog;
+vmCvar_t ui_loading;
+vmCvar_t ui_voteActive;
+vmCvar_t ui_alienTeamVoteActive;
+vmCvar_t ui_humanTeamVoteActive;
+
+vmCvar_t cg_debugRandom;
+
+vmCvar_t cg_optimizePrediction;
+vmCvar_t cg_projectileNudge;
+vmCvar_t cg_unlagged;
+
+//rotaxfun
+vmCvar_t cg_drawBubblle;
+vmCvar_t cg_BubblleZoom;
+vmCvar_t cg_rotaxFPS_BOOST;
+
+typedef struct
+{
+ vmCvar_t *vmCvar;
+ char *cvarName;
+ char *defaultString;
+ int cvarFlags;
+} cvarTable_t;
+
+static cvarTable_t cvarTable[ ] =
+{
+ { &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", "22.5", CVAR_ARCHIVE },
+ { &cg_fov, "cg_fov", "90", 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_gibs, "cg_gibs", "1", CVAR_ARCHIVE },
+ { &cg_draw2D, "cg_draw2D", "1", CVAR_ARCHIVE },
+ { &cg_drawStatus, "cg_drawStatus", "1", CVAR_ARCHIVE },
+ { &cg_drawTimer, "cg_drawTimer", "1", CVAR_ARCHIVE },
+ { &cg_drawClock, "cg_drawClock", "0", CVAR_ARCHIVE },
+ { &cg_drawFPS, "cg_drawFPS", "1", CVAR_ARCHIVE },
+ { &cg_drawDemoState, "cg_drawDemoState", "1", 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", "1", CVAR_ARCHIVE },
+ { &cg_drawAttacker, "cg_drawAttacker", "1", CVAR_ARCHIVE },
+ { &cg_drawCrosshair, "cg_drawCrosshair", "1", CVAR_ARCHIVE },
+ { &cg_drawCrosshairNames, "cg_drawCrosshairNames", "1", CVAR_ARCHIVE },
+ { &cg_drawRewards, "cg_drawRewards", "1", CVAR_ARCHIVE },
+ { &cg_crosshairX, "cg_crosshairX", "0", CVAR_ARCHIVE },
+ { &cg_crosshairY, "cg_crosshairY", "0", CVAR_ARCHIVE },
+ { &cg_brassTime, "cg_brassTime", "2500", CVAR_ARCHIVE },
+ { &cg_simpleItems, "cg_simpleItems", "0", CVAR_ARCHIVE },
+ { &cg_addMarks, "cg_marks", "1", CVAR_ARCHIVE },
+ { &cg_lagometer, "cg_lagometer", "0", CVAR_ARCHIVE },
+ { &cg_teslaTrailTime, "cg_teslaTrailTime", "250", CVAR_ARCHIVE },
+ { &cg_railTrailTime, "cg_railTrailTime", "400", 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_CHEAT },
+ { &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_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_debugMove, "cg_debugMove", "0", 0 },
+ { &cg_noPlayerAnims, "cg_noplayeranims", "0", CVAR_CHEAT },
+ { &cg_showmiss, "cg_showmiss", "0", 0 },
+ { &cg_footsteps, "cg_footsteps", "1", CVAR_CHEAT },
+ { &cg_tracerChance, "cg_tracerchance", "0.4", CVAR_CHEAT },
+ { &cg_tracerWidth, "cg_tracerwidth", "1", CVAR_CHEAT },
+ { &cg_tracerLength, "cg_tracerlength", "100", CVAR_CHEAT },
+ { &cg_thirdPersonRange, "cg_thirdPersonRange", "40", CVAR_CHEAT },
+ { &cg_thirdPersonAngle, "cg_thirdPersonAngle", "0", CVAR_CHEAT },
+ { &cg_thirdPerson, "cg_thirdPerson", "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 },
+ { &cg_noVoiceChats, "cg_noVoiceChats", "0", CVAR_ARCHIVE },
+ { &cg_noVoiceText, "cg_noVoiceText", "0", CVAR_ARCHIVE },
+ { &cg_creepRes, "cg_creepRes", "16", CVAR_ARCHIVE },
+ { &cg_drawSurfNormal, "cg_drawSurfNormal", "0", CVAR_CHEAT },
+ { &cg_drawBBOX, "cg_drawBBOX", "0", CVAR_CHEAT },
+ { &cg_debugAlloc, "cg_debugAlloc", "0", 0 },
+ { &cg_wwSmoothTime, "cg_wwSmoothTime", "300", CVAR_ARCHIVE },
+ { &cg_wwFollow, "cg_wwFollow", "1", CVAR_ARCHIVE|CVAR_USERINFO },
+ { &cg_wwToggle, "cg_wwToggle", "1", CVAR_ARCHIVE|CVAR_USERINFO },
+ { &cg_unlagged, "cg_unlagged", "1", CVAR_ARCHIVE|CVAR_USERINFO },
+
+ //rotaxfun
+ { &cg_drawBubblle, "cg_drawBubblle", "1", CVAR_ARCHIVE|CVAR_USERINFO },
+ { &cg_BubblleZoom, "cg_BubblleZoom", "1", CVAR_ARCHIVE|CVAR_USERINFO },
+ { &cg_rotaxFPS_BOOST, "cg_rotaxFPS_BOOST", "0", CVAR_ARCHIVE|CVAR_USERINFO },
+
+ { &cg_depthSortParticles, "cg_depthSortParticles", "1", CVAR_ARCHIVE },
+ { &cg_bounceParticles, "cg_bounceParticles", "0", CVAR_ARCHIVE },
+ { &cg_consoleLatency, "cg_consoleLatency", "3000", CVAR_ARCHIVE },
+ { &cg_lightFlare, "cg_lightFlare", "3", CVAR_ARCHIVE },
+ { &cg_debugParticles, "cg_debugParticles", "0", CVAR_CHEAT },
+ { &cg_debugTrails, "cg_debugTrails", "0", CVAR_CHEAT },
+ { &cg_debugPVS, "cg_debugPVS", "0", CVAR_CHEAT },
+ { &cg_disableWarningDialogs, "cg_disableWarningDialogs", "0", CVAR_ARCHIVE },
+ { &cg_disableScannerPlane, "cg_disableScannerPlane", "0", CVAR_ARCHIVE },
+ { &cg_tutorial, "cg_tutorial", "1", CVAR_ARCHIVE },
+ { &cg_hudFiles, "cg_hudFiles", "ui/hud.txt", CVAR_ARCHIVE},
+
+ { &cg_painBlendUpRate, "cg_painBlendUpRate", "10.0", 0 },
+ { &cg_painBlendDownRate, "cg_painBlendDownRate", "0.5", 0 },
+ { &cg_painBlendMax, "cg_painBlendMax", "0.7", 0 },
+ { &cg_painBlendScale, "cg_painBlendScale", "7.0", 0 },
+ { &cg_painBlendZoom, "cg_painBlendZoom", "0.65", 0 },
+
+ { &ui_currentClass, "ui_currentClass", "0", 0 },
+ { &ui_carriage, "ui_carriage", "", 0 },
+ { &ui_stages, "ui_stages", "0 0", 0 },
+ { &ui_dialog, "ui_dialog", "Text not set", 0 },
+ { &ui_loading, "ui_loading", "0", 0 },
+ { &ui_voteActive, "ui_voteActive", "0", 0 },
+ { &ui_humanTeamVoteActive, "ui_humanTeamVoteActive", "0", 0 },
+ { &ui_alienTeamVoteActive, "ui_alienTeamVoteActive", "0", 0 },
+
+ { &cg_debugRandom, "cg_debugRandom", "0", 0 },
+
+ { &cg_optimizePrediction, "cg_optimizePrediction", "1", CVAR_ARCHIVE },
+ { &cg_projectileNudge, "cg_projectileNudge", "1", 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_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_USERINFO | CVAR_ARCHIVE},
+ { &cg_smoothClients, "cg_smoothClients", "0", CVAR_USERINFO | 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_smallFont, "ui_smallFont", "0.2", CVAR_ARCHIVE},
+ { &cg_bigFont, "ui_bigFont", "0.5", CVAR_ARCHIVE},
+ { &cg_oldRail, "cg_oldRail", "1", CVAR_ARCHIVE},
+ { &cg_oldRocket, "cg_oldRocket", "1", CVAR_ARCHIVE},
+ { &cg_oldPlasma, "cg_oldPlasma", "1", CVAR_ARCHIVE},
+ { &cg_trueLightning, "cg_trueLightning", "0.0", CVAR_ARCHIVE}
+// { &cg_pmove_fixed, "cg_pmove_fixed", "0", CVAR_USERINFO | CVAR_ARCHIVE }
+};
+
+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 );
+ }
+
+ //repress standard Q3 console
+ trap_Cvar_Set( "con_notifytime", "-2" );
+
+ // 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, "headmodel", DEFAULT_MODEL, CVAR_USERINFO | CVAR_ARCHIVE );
+ trap_Cvar_Register( NULL, "team_model", DEFAULT_TEAM_MODEL, CVAR_USERINFO | CVAR_ARCHIVE );
+ trap_Cvar_Register( NULL, "team_headmodel", DEFAULT_TEAM_HEAD, CVAR_USERINFO | CVAR_ARCHIVE );
+}
+
+
+/*
+===================
+CG_ForceModelChange
+===================
+*/
+static void CG_ForceModelChange( void )
+{
+ int i;
+
+ for( i = 0; i < MAX_CLIENTS; i++ )
+ {
+ const char *clientInfo;
+
+ clientInfo = CG_ConfigString( CS_PLAYERS + i );
+
+ if( !clientInfo[ 0 ] )
+ continue;
+
+ CG_NewClientInfo( i );
+ }
+}
+
+
+/*
+=================
+CG_UpdateCvars
+=================
+*/
+void CG_UpdateCvars( void )
+{
+ int i;
+ cvarTable_t *cv;
+
+ for( i = 0, cv = cvarTable; i < cvarTableSize; i++, cv++ )
+ trap_Cvar_Update( cv->vmCvar );
+
+ // check for modications here
+
+ // 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;
+
+ return cg.crosshairClientNum;
+}
+
+
+int CG_LastAttacker( void )
+{
+ if( !cg.attackerTime )
+ return -1;
+
+ return cg.snap->ps.persistant[ PERS_ATTACKER ];
+}
+
+/*
+=================
+CG_RemoveNotifyLine
+=================
+*/
+void CG_RemoveNotifyLine( void )
+{
+ int i, offset, totalLength;
+
+ if( cg.numConsoleLines == 0 )
+ return;
+
+ offset = cg.consoleLines[ 0 ].length;
+ totalLength = strlen( cg.consoleText ) - offset;
+
+ //slide up consoleText
+ for( i = 0; i <= totalLength; i++ )
+ cg.consoleText[ i ] = cg.consoleText[ i + offset ];
+
+ //pop up the first consoleLine
+ for( i = 0; i < cg.numConsoleLines; i++ )
+ cg.consoleLines[ i ] = cg.consoleLines[ i + 1 ];
+
+ cg.numConsoleLines--;
+}
+
+/*
+=================
+CG_AddNotifyText
+=================
+*/
+void CG_AddNotifyText( void )
+{
+ char buffer[ BIG_INFO_STRING ];
+
+ trap_LiteralArgs( buffer, BIG_INFO_STRING );
+
+ if( !buffer[ 0 ] )
+ {
+ cg.consoleText[ 0 ] = '\0';
+ cg.numConsoleLines = 0;
+ return;
+ }
+
+ if( cg.numConsoleLines == MAX_CONSOLE_LINES )
+ CG_RemoveNotifyLine( );
+
+ Q_strcat( cg.consoleText, MAX_CONSOLE_TEXT, buffer );
+ cg.consoleLines[ cg.numConsoleLines ].time = cg.time;
+ cg.consoleLines[ cg.numConsoleLines ].length = strlen( buffer );
+ cg.numConsoleLines++;
+}
+
+void QDECL CG_Printf( const char *msg, ... )
+{
+ va_list argptr;
+ char text[ 1024 ];
+
+ va_start( argptr, msg );
+ vsprintf( 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 );
+ vsprintf( text, msg, argptr );
+ va_end( argptr );
+
+ trap_Error( text );
+}
+
+void QDECL Com_Error( int level, const char *error, ... )
+{
+ va_list argptr;
+ char text[1024];
+
+ va_start( argptr, error );
+ vsprintf( 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);
+ vsprintf (text, msg, argptr);
+ va_end (argptr);
+
+ CG_Printf ("%s", text);
+}
+
+
+
+/*
+================
+CG_Argv
+================
+*/
+const char *CG_Argv( int arg )
+{
+ static char buffer[ MAX_STRING_CHARS ];
+
+ trap_Argv( arg, buffer, sizeof( buffer ) );
+
+ return buffer;
+}
+
+
+//========================================================================
+
+/*
+=================
+CG_FileExists
+
+Test if a specific file exists or not
+=================
+*/
+qboolean CG_FileExists( char *filename )
+{
+ fileHandle_t f;
+
+ if( trap_FS_FOpenFile( filename, &f, FS_READ ) > 0 )
+ {
+ //file exists so close it
+ trap_FS_FCloseFile( f );
+
+ return qtrue;
+ }
+ else
+ return qfalse;
+}
+
+/*
+=================
+CG_RegisterSounds
+
+called during a precache command
+=================
+*/
+static void CG_RegisterSounds( void )
+{
+ int i;
+ char name[ MAX_QPATH ];
+ const char *soundName;
+
+ cgs.media.alienStageTransition = trap_S_RegisterSound( "sound/announcements/overmindevolved.wav", qtrue );
+ cgs.media.humanStageTransition = trap_S_RegisterSound( "sound/announcements/reinforcement.wav", qtrue );
+
+ cgs.media.alienOvermindAttack = trap_S_RegisterSound( "sound/announcements/overmindattack.wav", qtrue );
+ cgs.media.alienOvermindDying = trap_S_RegisterSound( "sound/announcements/overminddying.wav", qtrue );
+ cgs.media.alienOvermindSpawns = trap_S_RegisterSound( "sound/announcements/overmindspawns.wav", qtrue );
+
+ cgs.media.alienL1Grab = trap_S_RegisterSound( "sound/player/level1/grab.wav", qtrue );
+ cgs.media.alienL4ChargePrepare = trap_S_RegisterSound( "sound/player/level4/charge_prepare.wav", qtrue );
+ cgs.media.alienL4ChargeStart = trap_S_RegisterSound( "sound/player/level4/charge_start.wav", qtrue );
+
+ cgs.media.tracerSound = trap_S_RegisterSound( "sound/weapons/tracer.wav", qfalse );
+ cgs.media.selectSound = trap_S_RegisterSound( "sound/weapons/change.wav", qfalse );
+
+ cgs.media.talkSound = trap_S_RegisterSound( "sound/misc/talk.wav", qfalse );
+ cgs.media.alienTalkSound = trap_S_RegisterSound( "sound/misc/alien_talk.wav", qfalse );
+ cgs.media.humanTalkSound = trap_S_RegisterSound( "sound/misc/human_talk.wav", qfalse );
+ cgs.media.landSound = trap_S_RegisterSound( "sound/player/land1.wav", qfalse );
+
+ cgs.media.watrInSound = trap_S_RegisterSound( "sound/player/watr_in.wav", qfalse );
+ cgs.media.watrOutSound = trap_S_RegisterSound( "sound/player/watr_out.wav", qfalse );
+ cgs.media.watrUnSound = trap_S_RegisterSound( "sound/player/watr_un.wav", qfalse );
+
+ cgs.media.disconnectSound = trap_S_RegisterSound( "sound/misc/disconnect.wav", qfalse );
+
+ for( i = 0; i < 4; i++ )
+ {
+ Com_sprintf( name, sizeof( name ), "sound/player/footsteps/step%i.wav", i + 1 );
+ cgs.media.footsteps[ FOOTSTEP_NORMAL ][ i ] = trap_S_RegisterSound( name, qfalse );
+
+ Com_sprintf( name, sizeof( name ), "sound/player/footsteps/flesh%i.wav", i + 1 );
+ cgs.media.footsteps[ FOOTSTEP_FLESH ][ i ] = trap_S_RegisterSound( name, qfalse );
+
+ Com_sprintf( name, sizeof( name ), "sound/player/footsteps/splash%i.wav", i + 1 );
+ cgs.media.footsteps[ FOOTSTEP_SPLASH ][ i ] = trap_S_RegisterSound( name, qfalse );
+
+ Com_sprintf( name, sizeof( name ), "sound/player/footsteps/clank%i.wav", i + 1 );
+ cgs.media.footsteps[ FOOTSTEP_METAL ][ i ] = trap_S_RegisterSound( name, qfalse );
+ }
+
+ for( i = 1 ; i < MAX_SOUNDS ; i++ )
+ {
+ soundName = CG_ConfigString( CS_SOUNDS + i );
+
+ if( !soundName[ 0 ] )
+ break;
+
+ if( soundName[ 0 ] == '*' )
+ continue; // custom sound
+
+ cgs.gameSounds[ i ] = trap_S_RegisterSound( soundName, qfalse );
+ }
+
+ cgs.media.jetpackDescendSound = trap_S_RegisterSound( "sound/upgrades/jetpack/low.wav", qfalse );
+ cgs.media.jetpackIdleSound = trap_S_RegisterSound( "sound/upgrades/jetpack/idle.wav", qfalse );
+ cgs.media.jetpackAscendSound = trap_S_RegisterSound( "sound/upgrades/jetpack/hi.wav", qfalse );
+
+ cgs.media.medkitUseSound = trap_S_RegisterSound( "sound/upgrades/medkit/medkit.wav", qfalse );
+
+ cgs.media.alienEvolveSound = trap_S_RegisterSound( "sound/player/alienevolve.wav", qfalse );
+
+ cgs.media.alienBuildableExplosion = trap_S_RegisterSound( "sound/buildables/alien/explosion.wav", qfalse );
+ cgs.media.alienBuildableDamage = trap_S_RegisterSound( "sound/buildables/alien/damage.wav", qfalse );
+ cgs.media.alienBuildablePrebuild = trap_S_RegisterSound( "sound/buildables/alien/prebuild.wav", qfalse );
+
+ cgs.media.humanBuildableExplosion = trap_S_RegisterSound( "sound/buildables/human/explosion.wav", qfalse );
+ cgs.media.humanBuildablePrebuild = trap_S_RegisterSound( "sound/buildables/human/prebuild.wav", qfalse );
+
+ for( i = 0; i < 4; i++ )
+ cgs.media.humanBuildableDamage[ i ] = trap_S_RegisterSound(
+ va( "sound/buildables/human/damage%d.wav", i ), qfalse );
+
+ cgs.media.hardBounceSound1 = trap_S_RegisterSound( "sound/misc/hard_bounce1.wav", qfalse );
+ cgs.media.hardBounceSound2 = trap_S_RegisterSound( "sound/misc/hard_bounce2.wav", qfalse );
+
+ //ROTAXfun
+ cgs.media.acidBombBounceSound1 = trap_S_RegisterSound( "sound/misc/abomb_bounce1.wav", qfalse );
+ cgs.media.acidBombBounceSound2 = trap_S_RegisterSound( "sound/misc/abomb_bounce2.wav", qfalse );
+
+ cgs.media.repeaterUseSound = trap_S_RegisterSound( "sound/buildables/repeater/use.wav", qfalse );
+
+ cgs.media.buildableRepairSound = trap_S_RegisterSound( "sound/buildables/human/repair.wav", qfalse );
+ cgs.media.buildableRepairedSound = trap_S_RegisterSound( "sound/buildables/human/repaired.wav", qfalse );
+
+ cgs.media.lCannonWarningSound = trap_S_RegisterSound( "models/weapons/lcannon/warning.wav", qfalse );
+}
+
+
+//===================================================================================
+
+
+/*
+=================
+CG_RegisterGraphics
+
+This function may execute for a couple of minutes with a slow disk.
+=================
+*/
+static void CG_RegisterGraphics( void )
+{
+ int i;
+ static char *sb_nums[ 11 ] =
+ {
+ "gfx/2d/numbers/zero_32b",
+ "gfx/2d/numbers/one_32b",
+ "gfx/2d/numbers/two_32b",
+ "gfx/2d/numbers/three_32b",
+ "gfx/2d/numbers/four_32b",
+ "gfx/2d/numbers/five_32b",
+ "gfx/2d/numbers/six_32b",
+ "gfx/2d/numbers/seven_32b",
+ "gfx/2d/numbers/eight_32b",
+ "gfx/2d/numbers/nine_32b",
+ "gfx/2d/numbers/minus_32b",
+ };
+ static char *buildWeaponTimerPieShaders[ 8 ] =
+ {
+ "ui/assets/neutral/1_5pie",
+ "ui/assets/neutral/3_0pie",
+ "ui/assets/neutral/4_5pie",
+ "ui/assets/neutral/6_0pie",
+ "ui/assets/neutral/7_5pie",
+ "ui/assets/neutral/9_0pie",
+ "ui/assets/neutral/10_5pie",
+ "ui/assets/neutral/12_0pie",
+ };
+
+ // clear any references to old media
+ memset( &cg.refdef, 0, sizeof( cg.refdef ) );
+ trap_R_ClearScene( );
+
+ trap_R_LoadWorldMap( cgs.mapname );
+ CG_UpdateMediaFraction( 0.66f );
+
+ for( i = 0; i < 11; i++ )
+ cgs.media.numberShaders[ i ] = trap_R_RegisterShader( sb_nums[ i ] );
+
+ cgs.media.viewBloodShader = trap_R_RegisterShader( "gfx/damage/fullscreen_painblend" );
+
+ cgs.media.connectionShader = trap_R_RegisterShader( "gfx/2d/net" );
+
+ cgs.media.creepShader = trap_R_RegisterShader( "creep" );
+
+ cgs.media.scannerBlipShader = trap_R_RegisterShader( "gfx/2d/blip" );
+ cgs.media.scannerLineShader = trap_R_RegisterShader( "gfx/2d/stalk" );
+
+ cgs.media.tracerShader = trap_R_RegisterShader( "gfx/misc/tracer" );
+
+ cgs.media.backTileShader = trap_R_RegisterShader( "console" );
+
+
+ //TA: building shaders
+ cgs.media.greenBuildShader = trap_R_RegisterShader("gfx/misc/greenbuild" );
+ cgs.media.redBuildShader = trap_R_RegisterShader("gfx/misc/redbuild" );
+ cgs.media.humanSpawningShader = trap_R_RegisterShader("models/buildables/telenode/rep_cyl" );
+
+ for( i = 0; i < 8; i++ )
+ cgs.media.buildWeaponTimerPie[ i ] = trap_R_RegisterShader( buildWeaponTimerPieShaders[ i ] );
+
+ cgs.media.upgradeClassIconShader = trap_R_RegisterShader( "icons/icona_upgrade.tga" );
+
+ cgs.media.balloonShader = trap_R_RegisterShader( "gfx/sprites/chatballoon" );
+
+ //rotaxfun
+ cgs.media.chatBubblle = trap_R_RegisterShader( "gfx/sprites/chatbubblle" );
+ cgs.media.chatBubblle_h = trap_R_RegisterShader( "gfx/sprites/chatbubblle_h" );
+ cgs.media.chatBubblle_a = trap_R_RegisterShader( "gfx/sprites/chatbubblle_a" );
+
+ cgs.media.disconnectPS = CG_RegisterParticleSystem( "disconnectPS" );
+
+ CG_UpdateMediaFraction( 0.7f );
+
+ memset( cg_weapons, 0, sizeof( cg_weapons ) );
+ memset( cg_upgrades, 0, sizeof( cg_upgrades ) );
+
+ cgs.media.shadowMarkShader = trap_R_RegisterShader( "gfx/marks/shadow" );
+ cgs.media.wakeMarkShader = trap_R_RegisterShader( "gfx/marks/wake" );
+
+ cgs.media.poisonCloudPS = CG_RegisterParticleSystem( "firstPersonPoisonCloudPS" );
+ cgs.media.alienEvolvePS = CG_RegisterParticleSystem( "alienEvolvePS" );
+ cgs.media.alienAcidTubePS = CG_RegisterParticleSystem( "alienAcidTubePS" );
+
+ cgs.media.jetPackDescendPS = CG_RegisterParticleSystem( "jetPackDescendPS" );
+ cgs.media.jetPackHoverPS = CG_RegisterParticleSystem( "jetPackHoverPS" );
+ cgs.media.jetPackAscendPS = CG_RegisterParticleSystem( "jetPackAscendPS" );
+
+ cgs.media.humanBuildableDamagedPS = CG_RegisterParticleSystem( "humanBuildableDamagedPS" );
+ cgs.media.alienBuildableDamagedPS = CG_RegisterParticleSystem( "alienBuildableDamagedPS" );
+ cgs.media.humanBuildableDestroyedPS = CG_RegisterParticleSystem( "humanBuildableDestroyedPS" );
+ cgs.media.alienBuildableDestroyedPS = CG_RegisterParticleSystem( "alienBuildableDestroyedPS" );
+
+ cgs.media.alienBleedPS = CG_RegisterParticleSystem( "alienBleedPS" );
+ cgs.media.humanBleedPS = CG_RegisterParticleSystem( "humanBleedPS" );
+
+ //ROTAXfun
+ cgs.media.alienOvermindDestroyedPS = CG_RegisterParticleSystem( "alienOvermindDestroyedPS" );
+ cgs.media.alienBushDestroyedPS = CG_RegisterParticleSystem( "alienBushDestroyedPS" );
+ cgs.media.alienEggDestroyedPS = CG_RegisterParticleSystem( "alienEggDestroyedPS" );
+ cgs.media.alienBarricadeDestroyedPS = CG_RegisterParticleSystem( "alienBarricadeDestroyedPS" );
+ cgs.media.alienAcidtubeDestroyedPS = CG_RegisterParticleSystem( "alienAcidtubeDestroyedPS" );
+ cgs.media.alienTrapperDestroyedPS = CG_RegisterParticleSystem( "alienTrapperDestroyedPS" );
+ cgs.media.alienBoosterDestroyedPS = CG_RegisterParticleSystem( "alienBoosterDestroyedPS" );
+ cgs.media.alienHiveDestroyedPS = CG_RegisterParticleSystem( "alienHiveDestroyedPS" );
+ cgs.media.alienHovelDestroyedPS = CG_RegisterParticleSystem( "alienHovelDestroyedPS" );
+ cgs.media.alienBambooDestroyedPS = CG_RegisterParticleSystem( "alienBambooDestroyedPS" );
+ cgs.media.alienBrickaDestroyedPS = CG_RegisterParticleSystem( "alienBrickaDestroyedPS" );
+ cgs.media.alienBridgeDestroyedPS = CG_RegisterParticleSystem( "alienBridgeDestroyedPS" );
+ cgs.media.alienRockDestroyedPS = CG_RegisterParticleSystem( "alienRockDestroyedPS" );
+ cgs.media.alienFlowerDestroyedPS = CG_RegisterParticleSystem( "alienFlowerDestroyedPS" );
+ cgs.media.alienGrassDestroyedPS = CG_RegisterParticleSystem( "alienGrassDestroyedPS" );
+ cgs.media.alienFlagaDestroyedPS = CG_RegisterParticleSystem( "alienFlagaDestroyedPS" );
+ cgs.media.alienJumppadDestroyedPS = CG_RegisterParticleSystem( "alienJumppadDestroyedPS" );
+
+ cgs.media.humanReactorDestroyedPS = CG_RegisterParticleSystem( "humanReactorDestroyedPS" );
+ cgs.media.humanTelenodeDestroyedPS = CG_RegisterParticleSystem( "humanTelenodeDestroyedPS" );
+ cgs.media.humanTurretDestroyedPS = CG_RegisterParticleSystem( "humanTurretDestroyedPS" );
+ cgs.media.humanTeslaDestroyedPS = CG_RegisterParticleSystem( "humanTeslaDestroyedPS" );
+ cgs.media.humanDcDestroyedPS = CG_RegisterParticleSystem( "humanDcDestroyedPS" );
+ cgs.media.humanMedistationDestroyedPS = CG_RegisterParticleSystem( "humanMedistationDestroyedPS" );
+ cgs.media.humanRepeaterDestroyedPS = CG_RegisterParticleSystem( "humanRepeaterDestroyedPS" );
+ cgs.media.humanPlankDestroyedPS = CG_RegisterParticleSystem( "humanPlankDestroyedPS" );
+ cgs.media.humanCrateDestroyedPS = CG_RegisterParticleSystem( "humanCrateDestroyedPS" );
+ cgs.media.humanPillarDestroyedPS = CG_RegisterParticleSystem( "humanPillarDestroyedPS" );
+ cgs.media.humanBrickhDestroyedPS = CG_RegisterParticleSystem( "humanBrickhDestroyedPS" );
+ cgs.media.humanContainerDestroyedPS = CG_RegisterParticleSystem( "humanContainerDestroyedPS" );
+ cgs.media.humanFlaghDestroyedPS = CG_RegisterParticleSystem( "humanFlaghDestroyedPS" );
+
+ cgs.media.humanPoisonedPS = CG_RegisterParticleSystem( "humanPoisonedPS" );
+
+
+ CG_BuildableStatusParse( "ui/assets/human/buildstat.cfg", &cgs.humanBuildStat );
+ CG_BuildableStatusParse( "ui/assets/alien/buildstat.cfg", &cgs.alienBuildStat );
+
+ // register the inline models
+ 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 );
+ 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 ] );
+ }
+
+ // register all the server specified models
+ for( i = 1; i < MAX_MODELS; i++ )
+ {
+ const char *modelName;
+
+ modelName = CG_ConfigString( CS_MODELS + i );
+
+ if( !modelName[ 0 ] )
+ break;
+
+ cgs.gameModels[ i ] = trap_R_RegisterModel( modelName );
+ }
+
+ CG_UpdateMediaFraction( 0.8f );
+
+ // register all the server specified shaders
+ for( i = 1; i < MAX_GAME_SHADERS; i++ )
+ {
+ const char *shaderName;
+
+ shaderName = CG_ConfigString( CS_SHADERS + i );
+
+ if( !shaderName[ 0 ] )
+ break;
+
+ cgs.gameShaders[ i ] = trap_R_RegisterShader( shaderName );
+ }
+
+ CG_UpdateMediaFraction( 0.9f );
+
+ // register all the server specified particle systems
+ for( i = 1; i < MAX_GAME_PARTICLE_SYSTEMS; i++ )
+ {
+ const char *psName;
+
+ psName = CG_ConfigString( CS_PARTICLE_SYSTEMS + i );
+
+ if( !psName[ 0 ] )
+ break;
+
+ cgs.gameParticleSystems[ i ] = CG_RegisterParticleSystem( (char *)psName );
+ }
+}
+
+
+/*
+=======================
+CG_BuildSpectatorString
+
+=======================
+*/
+void CG_BuildSpectatorString( void )
+{
+ int i;
+
+ cg.spectatorList[ 0 ] = 0;
+
+ for( i = 0; i < MAX_CLIENTS; i++ )
+ {
+ if( cgs.clientinfo[ i ].infoValid && cgs.clientinfo[ i ].team == PTE_NONE )
+ Q_strcat( cg.spectatorList, sizeof( cg.spectatorList ), va( "%s " S_COLOR_WHITE, 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.charModelFraction = 0.0f;
+
+ //precache all the models/sounds/etc
+ for( i = PCL_NONE + 1; i < PCL_NUM_CLASSES; i++ )
+ {
+ CG_PrecacheClientInfo( i, BG_FindModelNameForClass( i ),
+ BG_FindSkinNameForClass( i ) );
+
+ cg.charModelFraction = (float)i / (float)PCL_NUM_CLASSES;
+ trap_UpdateScreen( );
+ }
+
+ cgs.media.larmourHeadSkin = trap_R_RegisterSkin( "models/players/human_base/head_light.skin" );
+ cgs.media.larmourLegsSkin = trap_R_RegisterSkin( "models/players/human_base/lower_light.skin" );
+ cgs.media.larmourTorsoSkin = trap_R_RegisterSkin( "models/players/human_base/upper_light.skin" );
+
+ cgs.media.jetpackModel = trap_R_RegisterModel( "models/players/human_base/jetpack.md3" );
+ cgs.media.jetpackFlashModel = trap_R_RegisterModel( "models/players/human_base/jetpack_flash.md3" );
+ cgs.media.battpackModel = trap_R_RegisterModel( "models/players/human_base/battpack.md3" );
+
+ cg.charModelFraction = 1.0f;
+ trap_UpdateScreen( );
+
+ //load all the clientinfos of clients already connected to the server
+ for( i = 0; i < MAX_CLIENTS; i++ )
+ {
+ const char *clientInfo;
+
+ clientInfo = CG_ConfigString( CS_PLAYERS + i );
+ if( !clientInfo[ 0 ] )
+ continue;
+
+ CG_NewClientInfo( i );
+ }
+
+ 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( void )
+{
+ char *s;
+ char parm1[ MAX_QPATH ], parm2[ MAX_QPATH ];
+
+ // start the background music
+ s = (char *)CG_ConfigString( CS_MUSIC );
+ Q_strncpyz( parm1, COM_Parse( &s ), sizeof( parm1 ) );
+ Q_strncpyz( parm2, COM_Parse( &s ), sizeof( parm2 ) );
+
+ trap_S_StartBackgroundTrack( parm1, parm2 );
+}
+
+/*
+======================
+CG_PlayerCount
+======================
+*/
+int CG_PlayerCount( void )
+{
+ int i, count = 0;
+
+ CG_RequestScores( );
+
+ for( i = 0; i < cg.numScores; i++ )
+ {
+ if( cg.scores[ i ].team == PTE_ALIENS ||
+ cg.scores[ i ].team == PTE_HUMANS )
+ count++;
+ }
+
+ return count;
+}
+
+//
+// ==============================
+// new hud stuff ( mission pack )
+// ==============================
+//
+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;
+}
+
+qboolean CG_Asset_Parse( int handle )
+{
+ pc_token_t token;
+ const char *tempStr;
+
+ if( !trap_Parse_ReadToken( handle, &token ) )
+ return qfalse;
+
+ if( Q_stricmp( token.string, "{" ) != 0 )
+ return qfalse;
+
+ while( 1 )
+ {
+ if( !trap_Parse_ReadToken( handle, &token ) )
+ return qfalse;
+
+ if( Q_stricmp( token.string, "}" ) == 0 )
+ return qtrue;
+
+ // font
+ if( Q_stricmp( token.string, "font" ) == 0 )
+ {
+ int pointSize;
+
+ if( !PC_String_Parse( handle, &tempStr ) || !PC_Int_Parse( handle, &pointSize ) )
+ return qfalse;
+
+ cgDC.registerFont( tempStr, pointSize, &cgDC.Assets.textFont );
+ continue;
+ }
+
+ // smallFont
+ if( Q_stricmp( token.string, "smallFont" ) == 0 )
+ {
+ int pointSize;
+
+ if( !PC_String_Parse( handle, &tempStr ) || !PC_Int_Parse( handle, &pointSize ) )
+ return qfalse;
+
+ cgDC.registerFont( tempStr, pointSize, &cgDC.Assets.smallFont );
+ continue;
+ }
+
+ // font
+ if( Q_stricmp( token.string, "bigfont" ) == 0 )
+ {
+ int pointSize;
+
+ if( !PC_String_Parse( handle, &tempStr ) || !PC_Int_Parse( handle, &pointSize ) )
+ return qfalse;
+
+ cgDC.registerFont( tempStr, pointSize, &cgDC.Assets.bigFont );
+ continue;
+ }
+
+ // gradientbar
+ if( Q_stricmp( token.string, "gradientbar" ) == 0 )
+ {
+ if( !PC_String_Parse( handle, &tempStr ) )
+ return qfalse;
+
+ cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( tempStr );
+ continue;
+ }
+
+ // enterMenuSound
+ if( Q_stricmp( token.string, "menuEnterSound" ) == 0 )
+ {
+ if( !PC_String_Parse( handle, &tempStr ) )
+ return qfalse;
+
+ cgDC.Assets.menuEnterSound = trap_S_RegisterSound( tempStr, qfalse );
+ continue;
+ }
+
+ // exitMenuSound
+ if( Q_stricmp( token.string, "menuExitSound" ) == 0 )
+ {
+ if( !PC_String_Parse( handle, &tempStr ) )
+ return qfalse;
+
+ cgDC.Assets.menuExitSound = trap_S_RegisterSound( tempStr, qfalse );
+ continue;
+ }
+
+ // itemFocusSound
+ if( Q_stricmp( token.string, "itemFocusSound" ) == 0 )
+ {
+ if( !PC_String_Parse( handle, &tempStr ) )
+ return qfalse;
+
+ cgDC.Assets.itemFocusSound = trap_S_RegisterSound( tempStr, qfalse );
+ continue;
+ }
+
+ // menuBuzzSound
+ if( Q_stricmp( token.string, "menuBuzzSound" ) == 0 )
+ {
+ if( !PC_String_Parse( handle, &tempStr ) )
+ return qfalse;
+
+ cgDC.Assets.menuBuzzSound = trap_S_RegisterSound( tempStr, qfalse );
+ 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_Parse_LoadSource( menuFile );
+
+ if( !handle )
+ handle = trap_Parse_LoadSource( "ui/testhud.menu" );
+
+ if( !handle )
+ return;
+
+ while( 1 )
+ {
+ if( !trap_Parse_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_Parse_FreeSource( handle );
+}
+
+qboolean CG_Load_Menu( char **p )
+{
+ char *token;
+
+ token = COM_ParseExt( p, qtrue );
+
+ if( token[ 0 ] != '{' )
+ return qfalse;
+
+ while( 1 )
+ {
+ token = COM_ParseExt( p, qtrue );
+
+ if( Q_stricmp( token, "}" ) == 0 )
+ return qtrue;
+
+ if( !token || token[ 0 ] == 0 )
+ return qfalse;
+
+ CG_ParseMenu( token );
+ }
+ return qfalse;
+}
+
+
+
+void CG_LoadMenus( const char *menuFile )
+{
+ char *token;
+ char *p;
+ int len, start;
+ fileHandle_t f;
+ static char buf[ MAX_MENUDEFFILE ];
+
+ start = trap_Milliseconds( );
+
+ len = trap_FS_FOpenFile( menuFile, &f, FS_READ );
+
+ if( !f )
+ {
+ trap_Error( va( S_COLOR_YELLOW "menu file not found: %s, using default\n", menuFile ) );
+ len = trap_FS_FOpenFile( "ui/hud.txt", &f, FS_READ );
+
+ if( !f )
+ trap_Error( va( S_COLOR_RED "default menu file not found: ui/hud.txt, unable to continue!\n" ) );
+ }
+
+ if( len >= MAX_MENUDEFFILE )
+ {
+ trap_Error( 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 );
+
+ COM_Compress( buf );
+
+ Menu_Reset( );
+
+ 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", trap_Milliseconds( ) - start );
+}
+
+
+
+static qboolean CG_OwnerDrawHandleKey( int ownerDraw, int flags, float *special, int key )
+{
+ return qfalse;
+}
+
+
+static int CG_FeederCount( float feederID )
+{
+ int i, count = 0;
+
+ if( feederID == FEEDER_ALIENTEAM_LIST )
+ {
+ for( i = 0; i < cg.numScores; i++ )
+ {
+ if( cg.scores[ i ].team == PTE_ALIENS )
+ count++;
+ }
+ }
+ else if( feederID == FEEDER_HUMANTEAM_LIST )
+ {
+ for( i = 0; i < cg.numScores; i++ )
+ {
+ if( cg.scores[ i ].team == PTE_HUMANS )
+ count++;
+ }
+ }
+
+ return count;
+}
+
+
+void CG_SetScoreSelection( void *p )
+{
+ menuDef_t *menu = (menuDef_t*)p;
+ playerState_t *ps = &cg.snap->ps;
+ int i, alien, human;
+ int feeder;
+
+ alien = human = 0;
+
+ for( i = 0; i < cg.numScores; i++ )
+ {
+ if( cg.scores[ i ].team == PTE_ALIENS )
+ alien++;
+ else if( cg.scores[ i ].team == PTE_HUMANS )
+ human++;
+
+ if( ps->clientNum == cg.scores[ i ].client )
+ cg.selectedScore = i;
+ }
+
+ if( menu == NULL )
+ // just interested in setting the selected score
+ return;
+
+ feeder = FEEDER_ALIENTEAM_LIST;
+ i = alien;
+
+ if( cg.scores[ cg.selectedScore ].team == PTE_HUMANS )
+ {
+ feeder = FEEDER_HUMANTEAM_LIST;
+ i = human;
+ }
+
+ Menu_SetFeederSelection(menu, feeder, i, NULL);
+}
+
+// FIXME: might need to cache this info
+static clientInfo_t * CG_InfoFromScoreIndex( int index, int team, int *scoreIndex )
+{
+ int i, count;
+ 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 *handle )
+{
+ int scoreIndex = 0;
+ clientInfo_t *info = NULL;
+ int team = -1;
+ score_t *sp = NULL;
+ qboolean showIcons = qfalse;
+
+ *handle = -1;
+
+ if( feederID == FEEDER_ALIENTEAM_LIST )
+ team = PTE_ALIENS;
+ else if( feederID == FEEDER_HUMANTEAM_LIST )
+ team = PTE_HUMANS;
+
+ info = CG_InfoFromScoreIndex( index, team, &scoreIndex );
+ sp = &cg.scores[ scoreIndex ];
+
+ if( ( atoi( CG_ConfigString( CS_CLIENTS_READY ) ) & ( 1 << sp->client ) ) &&
+ cg.intermissionStarted )
+ showIcons = qfalse;
+ else if( cg.snap->ps.pm_type == PM_SPECTATOR || cg.snap->ps.pm_flags & PMF_FOLLOW ||
+ team == cg.snap->ps.stats[ STAT_PTEAM ] || cg.intermissionStarted )
+ showIcons = qtrue;
+
+ if( info && info->infoValid )
+ {
+ switch( column )
+ {
+ case 0:
+ if( showIcons )
+ {
+ if( sp->weapon != WP_NONE )
+ *handle = cg_weapons[ sp->weapon ].weaponIcon;
+ }
+ break;
+
+ case 1:
+ if( showIcons )
+ {
+ if( sp->team == PTE_HUMANS && sp->upgrade != UP_NONE )
+ *handle = cg_upgrades[ sp->upgrade ].upgradeIcon;
+ else if( sp->team == PTE_ALIENS )
+ {
+ switch( sp->weapon )
+ {
+ case WP_ABUILD2:
+ case WP_ALEVEL1_UPG:
+ case WP_ALEVEL2_UPG:
+ case WP_ALEVEL3_UPG:
+ *handle = cgs.media.upgradeClassIconShader;
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ break;
+
+ case 2:
+ if( ( atoi( CG_ConfigString( CS_CLIENTS_READY ) ) & ( 1 << sp->client ) ) &&
+ cg.intermissionStarted )
+ return "Ready";
+ break;
+
+ case 3:
+ return info->name;
+ break;
+
+ case 4:
+ return va( "%d", info->score );
+ break;
+
+ case 5:
+ return va( "%4d", sp->time );
+ break;
+
+ case 6:
+ if( sp->ping == -1 )
+ return "connecting";
+
+ return va( "%4d", sp->ping );
+ break;
+ }
+ }
+
+ return "";
+}
+
+static qhandle_t CG_FeederItemImage( float feederID, int index )
+{
+ return 0;
+}
+
+static void CG_FeederSelection( float feederID, int index )
+{
+ int i, count;
+ int team = ( feederID == FEEDER_ALIENTEAM_LIST ) ? PTE_ALIENS : PTE_HUMANS;
+ count = 0;
+
+ for( i = 0; i < cg.numScores; i++ )
+ {
+ if( cg.scores[ i ].team == team )
+ {
+ if( index == count )
+ cg.selectedScore = i;
+
+ count++;
+ }
+ }
+}
+
+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 )
+{
+ CG_Text_Paint( x, y, scale, color, text, 0, limit, style );
+}
+
+static int CG_OwnerDrawWidth( int ownerDraw, float scale )
+{
+ switch( ownerDraw )
+ {
+ case CG_KILLER:
+ return CG_Text_Width( CG_GetKillerText( ), scale, 0 );
+ 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 );
+}
+
+//TA: hack to prevent warning
+static qboolean CG_OwnerDrawVisible( int parameter )
+{
+ return qfalse;
+}
+
+/*
+=================
+CG_LoadHudMenu
+=================
+*/
+void CG_LoadHudMenu( void )
+{
+ char buff[ 1024 ];
+ 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.ownerDrawItem = &CG_OwnerDraw;
+ cgDC.getValue = &CG_GetValue;
+ cgDC.ownerDrawVisible = &CG_OwnerDrawVisible;
+ cgDC.runScript = &CG_RunMenuScript;
+ 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( );
+
+ trap_Cvar_VariableStringBuffer( "cg_hudFiles", buff, sizeof( buff ) );
+ hudSet = buff;
+
+ if( hudSet[ 0 ] == '\0' )
+ hudSet = "ui/hud.txt";
+
+ CG_LoadMenus( hudSet );
+}
+
+void CG_AssetCache( void )
+{
+ cgDC.Assets.gradientBar = trap_R_RegisterShaderNoMip( ASSET_GRADIENTBAR );
+ 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 );
+}
+
+/*
+=================
+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 )
+{
+ const char *s;
+
+ // clear everything
+ memset( &cgs, 0, sizeof( cgs ) );
+ memset( &cg, 0, sizeof( cg ) );
+ memset( &cg.pmext, 0, sizeof( cg.pmext ) );
+ memset( cg_entities, 0, sizeof( cg_entities ) );
+
+ cg.clientNum = clientNum;
+
+ cgs.processedSnapshotNum = serverMessageNum;
+ cgs.serverCommandSequence = serverCommandSequence;
+
+ // load a few needed things before we do any screen updates
+ cgs.media.whiteShader = trap_R_RegisterShader( "white" );
+ cgs.media.charsetShader = trap_R_RegisterShader( "gfx/2d/bigchars" );
+ cgs.media.outlineShader = trap_R_RegisterShader( "outline" );
+
+ //inform UI to repress cursor whilst loading
+ trap_Cvar_Set( "ui_loading", "1" );
+
+ //TA: load overrides
+ BG_InitClassOverrides( );
+ BG_InitBuildableOverrides( );
+ BG_InitAllowedGameElements( );
+
+ //TA: dyn memory
+ CG_InitMemory( );
+
+ CG_RegisterCvars( );
+
+ CG_InitConsoleCommands( );
+
+ //TA: moved up for LoadHudMenu
+ String_Init( );
+
+ //TA: TA UI
+ CG_AssetCache( );
+ CG_LoadHudMenu( ); // load new hud stuff
+
+ cg.weaponSelect = WP_NONE;
+
+ // 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 );
+
+ // 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
+ trap_CM_LoadMap( cgs.mapname );
+
+ cg.loading = qtrue; // force players to load instead of defer
+
+ CG_LoadTrailSystems( );
+ CG_UpdateMediaFraction( 0.05f );
+
+ CG_LoadParticleSystems( );
+ CG_UpdateMediaFraction( 0.05f );
+
+ CG_RegisterSounds( );
+ CG_UpdateMediaFraction( 0.60f );
+
+ CG_RegisterGraphics( );
+ CG_UpdateMediaFraction( 0.90f );
+
+ CG_InitWeapons( );
+ CG_UpdateMediaFraction( 0.95f );
+
+ CG_InitUpgrades( );
+ CG_UpdateMediaFraction( 1.0f );
+
+ //TA:
+ CG_InitBuildables( );
+
+ CG_RegisterClients( ); // if low on memory, some clients will be deferred
+
+ cg.loading = qfalse; // future players will be deferred
+
+ CG_InitMarkPolys( );
+
+ // remove the last loading update
+ cg.infoScreenText[ 0 ] = 0;
+
+ // Make sure we have update values (scores)
+ CG_SetConfigValues( );
+
+ CG_StartMusic( );
+
+ CG_ShaderStateChanged( );
+
+ trap_S_ClearLoopingSounds( qtrue );
+
+ trap_Cvar_Set( "ui_loading", "0" );
+}
+
+/*
+=================
+CG_Shutdown
+
+Called before every level change or subsystem restart
+=================
+*/
+void CG_Shutdown( void )
+{
+ // some mods may need to do cleanup work here,
+ // like closing files or archiving session data
+}
|