From 6a777afc079c2a8d3af3ecd2145fe8dd50567a39 Mon Sep 17 00:00:00 2001 From: Paweł Redman Date: Wed, 22 Mar 2017 17:56:34 +0100 Subject: Funko sources as released by Rotacak. --- src/cgame/cg_main.c | 1897 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1897 insertions(+) create mode 100644 src/cgame/cg_main.c (limited to 'src/cgame/cg_main.c') 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 +} -- cgit