Fixed weapon commands not working as intended

.gitignore

@@ -1,4 +1,6 @@
 build
+mohaa-re
+out
 Makefile.local
 *.swp
 *tags

LAYOUT.md

@@ -2,22 +2,23 @@
 
 | Path                 | Description                                                      |
 | ---------------------|-------------------------------------------------------------------
-| build/               | Output files                                                     |
 | code/                | OpenMoHAA source code                                            |
 | code/cgame           | Client game code                                                 |
 | code/client          | Client (network stuff, snapshots, etc)                           |
 | code/game            | Server game code (game logic stuff, etc)                         |
 | code/gamespy         | Gamespy SDK                                                      |
-| code/mohui           | MoHAA User Interface                                             |
 | code/null            | Null redirector (used by the OpenMoHAA Dedicated Server)         |
 | code/parser          | Flex/Bison parser                                                |
 | code/qcommon         | Global shared stuff such as maths                                |
 | code/renderer        | OpenMoHAA renderer                                               |
 | code/sdl(12)         | SDL code                                                         |
 | code/script          | Script engine                                                    |
-| code/server          | Server code (networkn snapshots, handling clients etc)           |
+| code/server          | Server code (network, snapshots, handling clients etc)           |
 | code/skeletor        | Skeleton model engine                                            |
 | code/sys             | Main application system                                          |
 | code/tiki            | Complete TIKI engine                                             |
 | code/uilib           | UI library (Ubertools stuff)                                     |
+| code/{win32,unix}    | Platform-specific code                                           |
+| docker               | Docker files, for compiling on various linux versions            |
+| docs                 | Documentation stuff                                              |
 | misc/                | Project stuff, definition files and various resources stuff.     |

README.md

@@ -41,6 +41,8 @@ Here is the current working state for each part of the engine:
 | Server module (fgame)   |      | x      |      |       |     |             | Actor, vehicle, and few gameplay bugs                             |
 | UI                      |      |        |      | x     |     |             | Has core features only (menu, widgets, console, hud, urc loading) |
 
+NOTE: Both client and server version can be compiled to target **Medal of Honor: Spearhead** and **Medal of Honor: Breakthrough**.
+
 ## Running
 
 Backup existing mohaa files, **cgamex86.dll** and **gamex86.dll** (set their extension to **.bak**)
@@ -72,6 +74,8 @@ The installation directory can be set to MOHAA directory.
 
 The client build can be built by adding `-DWITH_CLIENT=1` to the CMake command line. This will compile the cgame module and the full app with rendering, ui and sound suppport, alongside the dedicated server version.
 
+To compile for either Spearhead or Breakthrough, append `-DTARGET_GAME_TYPE=x` where x can be 1 for Team Assault (Spearhead), and 2 for Team Tactics (Breakthrough). 2 is recommended because Team Tactics can connect to both Spearhead and Breakthrough servers.
+
 ### Linux
 
 These are the tools required on Unix :
@@ -87,8 +91,11 @@ Visual Studio (2019 or 2022) is generally preferred.
 
 ## Screenshots
 
-![](docs/images/opm_50b_1.png)
-![](docs/images/opm_50b_2.png)
+|                                                                     |                                                                           |
+|---------------------------------------------------------------------|---------------------------------------------------------------------------|
+| ![](docs/images/opm_53_tt_1.png "Playing on a Breakthrough server") | ![](docs/images/opm_50b_1.png)                                            |
+| ![](docs/images/opm_50b_2.png)                                      | ![](docs/images/opm-arm_53_tt_1.png "OpenMoHAA on Raspberry")             |
+
 
 ## Third party
 

code/cgame/cg_commands.cpp

@@ -4801,7 +4801,7 @@ void ClientGameCommandManager::SpawnTempModel(int mcount, int timeAlive)
 
         // Make sure to not spawn the world model as a tempmodel
         // Of course it would become extremely confusing...
-        if (!(p->cgd.flags & T_DLIGHT) && p->ent.reType == ET_MODELANIM_SKEL && !p->ent.hModel)
+        if (!(p->cgd.flags & T_DLIGHT) && p->ent.reType == RT_MODEL && !p->ent.hModel)
         {
             Com_Printf("^~^~^ not spawning tempmodel because it is using the world as a brush model\n");
             FreeTempModel(p);
@@ -5139,7 +5139,7 @@ void ClientGameCommandManager::LoopSound(Event* ev)
 
     // Get the real sound to play
 
-    if (current_tiki) {
+    if (current_tiki && current_tiki->a->alias_list) {
         name = cgi.Alias_ListFindRandom((AliasList_t*)current_tiki->a->alias_list,
                                         sound_name.c_str(), &soundAlias);
     }
@@ -5168,7 +5168,7 @@ void CacheResource(const char* stuff)
 {
     str real_stuff;
 
-    if (!stuff) {
+    if (!stuff || !stuff[0]) {
         return;
     }
 

code/cgame/cg_commands.h

@@ -273,7 +273,7 @@ enum class vsstypes_t : unsigned char {
     NUM_VSS_TYPES
 };
 
-class cvssource_t : public Class
+class cvssource_t
 {
 public:
     cvssource_t* next;
@@ -309,7 +309,7 @@ public:
     qboolean lastValid;
 };
 
-class cvssourcestate_t : public Class
+class cvssourcestate_t
 {
 public:
     Vector origin;

code/cgame/cg_consolecmds.c

@@ -123,7 +123,7 @@ void CG_ScoresUp_f( void )
     }
 
     cg.showScores = qfalse;
-    cgi.UI_HideScoreBoard(cg.scoresMenuName);
+    cgi.UI_HideScoreBoard();
 }
 
 baseshader_t* CG_GetShaderUnderCrosshair(qboolean bVerbose, trace_t* pRetTrace)
@@ -562,11 +562,12 @@ int CG_WeaponCommandButtonBits(void)
         return 0;
     }
 
+	iShiftedWeaponCommand = cg.iWeaponCommand << 7;
+
     cg.iWeaponCommandSend++;
     if (cg.iWeaponCommandSend > 2) {
         cg.iWeaponCommand = 0;
     }
 
-    iShiftedWeaponCommand = cg.iWeaponCommand << 7;
     return iShiftedWeaponCommand & WEAPON_COMMAND_MASK;
 }

code/cgame/cg_drawtools.cpp

@@ -816,7 +816,7 @@ void CG_DrawPlayerTeam()
         return;
     }
 
-    handle = NULL;
+    handle = 0;
     if (cg.snap->ps.stats[STAT_TEAM] == 3)
     {
         handle = cgi.R_RegisterShader("textures/hud/allies");
@@ -851,7 +851,7 @@ void CG_DrawPlayerEntInfo()
     }
 
     iClientNum = cg.snap->ps.stats[STAT_INFOCLIENT];
-    handle = NULL;
+    handle = 0;
     pszClientInfo = CG_ConfigString(iClientNum + CS_PLAYERS);
     pszName = Info_ValueForKey(pszClientInfo, "name");
 
@@ -982,14 +982,32 @@ void CG_DrawStopwatch()
 {
 	int iFraction;
 
-	if (!cg_hud->integer || !cgi.stopWatch->iStartTime
-		|| cgi.stopWatch->iStartTime >= cgi.stopWatch->iEndTime
-        || cgi.stopWatch->iEndTime <= cg.time
-        // don't draw the stopwatch with the objective menu
-        || cg.ObjectivesCurrentAlpha >= 0.02
-        // the player isn't alive
-		|| cg.snap && cg.snap->ps.stats[STAT_HEALTH] <= 0)
-	{
+	if (!cg_hud->integer) {
+		cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+		return;
+	}
+
+	if (!cgi.stopWatch->iStartTime) {
+		cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+		return;
+	}
+
+	if (cgi.stopWatch->iStartTime >= cgi.stopWatch->iEndTime) {
+		cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+		return;
+	}
+
+	if (cgi.stopWatch->iEndTime <= cg.time) {
+		cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+		return;
+	}
+
+	if (cg.ObjectivesCurrentAlpha >= 0.02) {
+		cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
+		return;
+	}
+
+	if (cg.snap && cg.snap->ps.stats[STAT_HEALTH] <= 0) {
 		cgi.Cmd_Execute(EXEC_NOW, "ui_removehud hud_stopwatch\n");
 		return;
 	}
@@ -1023,6 +1041,118 @@ void CG_DrawInstantMessageMenu()
     cgi.R_DrawStretchPic(x, y, w, h, 0.0, 0.0, 1.0, 1.0, handle);
 }
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+void CG_DrawSpectatorView()
+{
+	const char* pszString;
+	int iKey1, iKey2;
+	int iKey1b, iKey2b;
+	float fX, fY;
+	qboolean bOnTeam;
+
+	if (!(cg.predicted_player_state.pm_flags & PMF_SPECTATING)) {
+		return;
+	}
+
+	bOnTeam = qfalse;
+	if (cg.snap->ps.stats[STAT_TEAM] == TEAM_ALLIES || cg.snap->ps.stats[STAT_TEAM] == TEAM_AXIS) {
+		bOnTeam = 1;
+	}
+
+	if (!bOnTeam)
+	{
+		cgi.Key_GetKeysForCommand("+attackprimary", &iKey1, &iKey2);
+		pszString = cgi.LV_ConvertString(va("Press Fire(%s) to join the battle!", cgi.Key_KeynumToBindString(iKey1)));
+		fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
+		fY = cgs.glconfig.vidHeight - 64.0;
+		cgi.R_SetColor(NULL);
+		cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, qfalse);
+	}
+
+	if (cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW)
+	{
+		cgi.Key_GetKeysForCommand("+moveup", &iKey1, &iKey2);
+		cgi.Key_GetKeysForCommand("+movedown", &iKey1b, &iKey2b);
+
+		pszString = cgi.LV_ConvertString(
+			va(
+                "Press Jump(%s) or Duck(%s) to follow a different player.",
+				cgi.Key_KeynumToBindString(iKey1),
+				cgi.Key_KeynumToBindString(iKey1b)
+			)
+		);
+
+		fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
+		fY = (float)cgs.glconfig.vidHeight - 40.0;
+		cgi.R_SetColor(0);
+		cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+	}
+
+    if (!bOnTeam && (cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW))
+    {
+        cgi.Key_GetKeysForCommand("+use", &iKey1, &iKey2);
+        pszString = cgi.LV_ConvertString(va("Press Use(%s) to enter free spectate mode.", cgi.Key_KeynumToBindString(iKey1)));
+
+		fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
+		fY = (float)cgs.glconfig.vidHeight - 24.0;
+		cgi.R_SetColor(0);
+		cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+	}
+
+	if (!(cg.predicted_player_state.pm_flags & PMF_CAMERA_VIEW)) {
+        cgi.Key_GetKeysForCommand("+use", &iKey1, &iKey2);
+
+		pszString = cgi.LV_ConvertString(
+			va(
+				"Press Use(%s) to enter player following spectate mode.",
+				cgi.Key_KeynumToBindString(iKey1)
+			)
+		);
+
+		fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1)) * 0.5;
+		fY = (float)cgs.glconfig.vidHeight - 24.0;
+		cgi.R_SetColor(0);
+		cgi.R_DrawString(cgs.media.attackerFont, pszString, fX, fY, -1, 0);
+	}
+
+    if ((cg.predicted_player_state.pm_flags & 0x80) != 0 && cg.snap && cg.snap->ps.stats[STAT_INFOCLIENT] != -1)
+    {
+        int iClientNum;
+        qhandle_t hShader;
+        vec4_t color;
+        char buf[128];
+
+        iClientNum = cg.snap->ps.stats[STAT_INFOCLIENT];
+        sprintf(buf, "%s : %i", cg.clientinfo[iClientNum].name, cg.snap->ps.stats[STAT_INFOCLIENT_HEALTH]);
+
+        color[0] = 0.5;
+        color[1] = 1.0;
+        color[2] = 0.5;
+		color[3] = 1.0;
+
+		fX = (float)(cgs.glconfig.vidWidth - cgi.UI_FontStringWidth(cgs.media.attackerFont, pszString, -1) - 16) * 0.5;
+		fY = (float)cgs.glconfig.vidHeight - 80.0;
+		cgi.R_SetColor(color);
+		cgi.R_DrawString(cgs.media.attackerFont, buf, fX, fY, -1, 0);
+
+		if (cg.clientinfo[iClientNum].team == TEAM_ALLIES) {
+			hShader = cgi.R_RegisterShader("textures/hud/allies");
+		} else if (cg.clientinfo[iClientNum].team == TEAM_AXIS) {
+			hShader = cgi.R_RegisterShader("textures/hud/axis");
+		}
+
+		if (hShader)
+		{
+            fX -= 20.0;
+			cgi.R_SetColor(NULL);
+			cgi.R_DrawStretchPic(fX, fY, 16.0, 16.0, 0.0, 0.0, 1.0, 1.0, hShader);
+		}
+    }
+}
+
+#else
+
 void CG_DrawSpectatorView()
 {
 	const char* pszString;
@@ -1083,6 +1213,8 @@ void CG_DrawSpectatorView()
     }
 }
 
+#endif
+
 /*
 ==============
 CG_Draw2D

code/cgame/cg_lightstyles.cpp

@@ -51,7 +51,7 @@ clightstyle_t	cg_lightstyle[ MAX_LIGHTSTYLES * 2 ];
 CG_LightStyleColor
 ================
 */
-qboolean CG_LightStyleColor( int style, int realtime, float color[4], qboolean clamp )
+qboolean CG_LightStyleColor( int style, int realtime, vec4_t color, qboolean clamp )
    {
 	clightstyle_t	*ls;
    int            i, time;

code/cgame/cg_local.h

@@ -160,6 +160,7 @@ typedef struct markPoly_s
 #define	MAX_CUSTOM_SOUNDS	32
 typedef struct {
 	int team;
+    char name[64];
 } clientInfo_t;
 
 typedef struct cobjective_s {
@@ -297,15 +298,21 @@ typedef struct {
     qboolean		testGun;
 
     // farplane parameters
-    float       farplane_distance;
+	float       farplane_distance;
+	float       farplane_bias;
     vec3_t      farplane_color;
-    qboolean    farplane_cull;
+	qboolean    farplane_cull;
+	float       skyboxFarplane;
+	qboolean    renderTerrain;
+	float       farclipOverride;
+	vec3_t      farplaneColorOverride;
 
     // portal sky parameters
     qboolean    sky_portal;
     float       sky_alpha;
     vec3_t      sky_origin;
-    vec3_t		sky_axis[3];			// rotation vectors
+	vec3_t		sky_axis[3];			// rotation vectors
+    float       skyboxSpeed;
 
     // weapon viewkick recoil
     float      viewkick[2];
@@ -371,8 +378,9 @@ typedef struct {
     int				fraglimit;
     int				timelimit;
     int				maxclients;
-    int            cinematic;
-    char			   mapname[MAX_QPATH];
+	int             cinematic;
+	int             mapChecksum;
+    char            mapname[MAX_QPATH];
 
     //
     // locally derived information from gamestate
@@ -475,6 +483,7 @@ int         CG_LastAttacker( void );
 void        CG_Init( clientGameImport_t *imported, int serverMessageNum, int serverCommandSequence, int clientNum );
 void        CG_Shutdown( void );
 void        CG_ServerRestarted( void );
+void        CG_ParseFogInfo(const char* str);
 
 //
 // cg_modelanim.cpp
@@ -801,9 +810,9 @@ void CG_MultiBeam( centity_t *cent );
 // cg_lightstyles.cpp
 void CG_SetLightStyle( int num, const char *s );
 #ifdef __cplusplus
-qboolean CG_LightStyleColor( int style, int realtime, float color[4], qboolean clamp = qfalse );
+qboolean CG_LightStyleColor( int style, int realtime, vec4_t color, qboolean clamp = qfalse );
 #else
-qboolean CG_LightStyleColor( int style, int realtime, float color[4], qboolean clamp );
+qboolean CG_LightStyleColor( int style, int realtime, vec4_t color, qboolean clamp );
 #endif
 void CG_ClearLightStyles( void );
 int  CG_RegisterLightStyle( const char * name );

code/cgame/cg_main.c

@@ -300,16 +300,7 @@ void CG_ProcessConfigString(int num)
 		cg.matchStartTime = atoi(str);
 		return;
     case CS_FOGINFO:
-        sscanf
-        (
-            str,
-            "%d %f %f %f %f",
-            &cg.farplane_cull,
-            &cg.farplane_distance,
-            &cg.farplane_color[0],
-            &cg.farplane_color[1],
-            &cg.farplane_color[2]
-        );
+        CG_ParseFogInfo(str);
 		return;
     case CS_SKYINFO:
         sscanf
@@ -382,6 +373,25 @@ void CG_ProcessConfigString(int num)
     {
         CG_SetLightStyle(num - CS_LIGHTSTYLES, str);
     }
+    else if (num >= CS_PLAYERS && num < CS_PLAYERS + MAX_CLIENTS)
+    {
+		const char* value;
+
+		value = Info_ValueForKey(str, "name");
+		if (value) {
+            strncpy(cg.clientinfo[num - CS_PLAYERS].name, value, sizeof(cg.clientinfo[num - CS_PLAYERS].name));
+		}
+		else {
+			strncpy(cg.clientinfo[num - CS_PLAYERS].name, "UnnamedSoldier", sizeof(cg.clientinfo[num - CS_PLAYERS].name));
+        }
+        
+        value = Info_ValueForKey(str, "team");
+        if (value) {
+            cg.clientinfo[num - CS_PLAYERS].team = atoi(value);
+        } else {
+            cg.clientinfo[num - CS_PLAYERS].team = TEAM_NONE;
+        }
+    }
 }
 
 //===================================================================================
@@ -776,4 +786,45 @@ void Com_Printf( const char *msg, ... ) {
 
 #endif
 
+#if TARGET_GAME_PROTOCOL >= 15
 
+void CG_ParseFogInfo(const char* str) {
+	sscanf(
+        str,
+		"%d %f %f %f %f %f %f %f %d %f %f %f %f",
+		&cg.farplane_cull,
+		&cg.farplane_distance,
+		&cg.farplane_bias,
+		&cg.skyboxFarplane,
+		&cg.skyboxSpeed,
+		&cg.farplane_color[0],
+		&cg.farplane_color[1],
+		&cg.farplane_color[2],
+		&cg.renderTerrain,
+		&cg.farclipOverride,
+		&cg.farplaneColorOverride[0],
+		&cg.farplaneColorOverride[1],
+		&cg.farplaneColorOverride[2]
+    );
+}
+
+#else
+
+void CG_ParseFogInfo(const char* str) {
+	cg.farclipOverride = 0.0;
+	cg.farplaneColorOverride[0] = -1.0;
+	cg.farplaneColorOverride[1] = -1.0;
+	cg.farplaneColorOverride[2] = -1.0;
+	sscanf
+	(
+		str,
+		"%d %f %f %f %f",
+		&cg.farplane_cull,
+		&cg.farplane_distance,
+		&cg.farplane_color[0],
+		&cg.farplane_color[1],
+		&cg.farplane_color[2]
+	);
+}
+
+#endif

code/cgame/cg_modelanim.c

@@ -28,6 +28,183 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 void CG_PlayerTeamUpdate(refEntity_t* pModel, entityState_t* pPlayerState)
 {
+    qboolean bInArtillery, bInTeam, bSpecialIcon;
+
+#if TARGET_GAME_PROTOCOL < 15
+    if (pPlayerState->eFlags & EF_ALLIES)
+    {
+        cg.clientinfo[pPlayerState->number].team = TEAM_ALLIES;
+    } else if (pPlayerState->eFlags & EF_AXIS) {
+        cg.clientinfo[pPlayerState->number].team = TEAM_AXIS;
+    } else {
+		cg.clientinfo[pPlayerState->number].team = TEAM_NONE;
+    }
+#endif
+
+    if (pPlayerState->number == cg.snap->ps.clientNum) {
+        return;
+    }
+
+    bInTeam = qfalse;
+    bSpecialIcon = qfalse;
+	if (cgs.gametype > GT_FFA
+		&& (cg.snap->ps.stats[STAT_TEAM] == TEAM_ALLIES && (pPlayerState->eFlags & EF_ALLIES)
+			|| cg.snap->ps.stats[STAT_TEAM] == TEAM_AXIS && (pPlayerState->eFlags & EF_AXIS)
+			|| cg.snap->ps.stats[STAT_TEAM] != TEAM_AXIS && cg.snap->ps.stats[STAT_TEAM] != TEAM_ALLIES && (pPlayerState->eFlags & EF_ANY_TEAM) != 0))
+	{
+		bInTeam = qtrue;
+	}
+
+    if (cgs.gametype <= GT_FFA) {
+        return;
+    }
+
+    bInArtillery = qfalse;
+    if (pPlayerState->eFlags & EF_PLAYER_ARTILLERY) {
+        bInArtillery = qtrue;
+    }
+
+    if (bInTeam || (pPlayerState->eFlags & (EF_PLAYER_IN_MENU | EF_PLAYER_TALKING)) || bInArtillery)
+    {
+        int i;
+        int iTag;
+        float fAlpha;
+        float fDist;
+        vec3_t vTmp;
+        refEntity_t iconEnt;
+
+		memset(&iconEnt, 0, sizeof(iconEnt));
+		if ((pPlayerState->eFlags & EF_PLAYER_TALKING) != 0 && ((cg.time >> 8) & 1) != 0)
+		{
+			iconEnt.hModel = cgi.R_RegisterModel("textures/hud/talking_headicon.spr");
+			bSpecialIcon = 1;
+		}
+		else if ((pPlayerState->eFlags & EF_PLAYER_IN_MENU) != 0)
+		{
+			iconEnt.hModel = cgi.R_RegisterModel("textures/hud/inmenu_headicon.spr");
+			bSpecialIcon = 1;
+		}
+		else
+		{
+            if (!bInTeam) {
+                return;
+            }
+
+			if (bInArtillery)
+			{
+				iconEnt.hModel = cgi.R_RegisterModel("textures/hud/inmenu_artilleryicon.spr");
+				bSpecialIcon = qtrue;
+			}
+			else if ((pPlayerState->eFlags & 0x80) != 0)
+			{
+				iconEnt.hModel = cgi.R_RegisterModel("textures/hud/allies_headicon.spr");
+			}
+			else
+			{
+				iconEnt.hModel = cgi.R_RegisterModel("textures/hud/axis_headicon.spr");
+			}
+		}
+
+		memset(vTmp, 0, sizeof(vTmp));
+		AnglesToAxis(vTmp, iconEnt.axis);
+
+		iconEnt.scale = 0.5;
+		iconEnt.renderfx = 0;
+		iconEnt.reType = RT_SPRITE;
+		iconEnt.shaderTime = 0.0;
+		iconEnt.frameInfo[0].index = 0;
+		iconEnt.shaderRGBA[0] = -1;
+		iconEnt.shaderRGBA[1] = -1;
+		iconEnt.shaderRGBA[2] = -1;
+        VectorCopy(pModel->origin, iconEnt.origin);
+
+		iTag = cgi.Tag_NumForName(pModel->tiki, "eyes bone");
+		if (iTag == -1)
+		{
+			iconEnt.origin[2] = iconEnt.origin[2] + 96.0;
+		}
+		else
+		{
+            orientation_t oEyes = cgi.TIKI_Orientation(pModel, iTag);
+
+            for (i = 0; i < 3; ++i) {
+                VectorMA(iconEnt.origin, oEyes.origin[i], pModel->axis[i], iconEnt.origin);
+            }
+
+			iconEnt.origin[2] = iconEnt.origin[2] + 20.0;
+		}
+
+        VectorSubtract(iconEnt.origin, cg.refdef.vieworg, vTmp);
+        fDist = VectorLength(vTmp);
+
+        if (fDist >= 256)
+        {
+            if (fDist > 512.0) {
+                iconEnt.scale = (fDist - 512.0) / 2560.0 + 0.5;
+            }
+        }
+        else
+		{
+			iconEnt.scale = fDist / 853.0 + 0.2;
+		}
+
+        if (iconEnt.scale > 1.0) {
+            iconEnt.scale = 1.0;
+        }
+
+        if (fDist > 256.0) {
+            fAlpha = 1.0;
+        }
+        else if (fDist >= 72.0) {
+            fAlpha = (fDist - 72.0) / 184.0;
+        }
+        else {
+            fAlpha = 0.0;
+        }
+
+        if (cg.snap->ps.stats[STAT_TEAM] == 4 || cg.snap->ps.stats[STAT_TEAM] == 3) {
+            fAlpha = fAlpha * 0.65;
+        }
+        else {
+            fAlpha = fAlpha * 0.4;
+        }
+
+		if (bSpecialIcon)
+		{
+			int value = (int)((fAlpha + 0.60000002) * 255.0);
+			if (value > 255) value = 255;
+			iconEnt.shaderRGBA[3] = value;
+		}
+		else
+		{
+			iconEnt.shaderRGBA[3] = (int)(fAlpha * 255.0);
+		}
+
+        if (fAlpha > 0.0 || bSpecialIcon)
+		{
+			if (bSpecialIcon)
+			{
+				VectorMA(iconEnt.origin, -2.0, cg.refdef.viewaxis[0], iconEnt.origin);
+				iconEnt.scale = iconEnt.scale + 0.05;
+			}
+
+            cgi.R_AddRefSpriteToScene(&iconEnt);
+
+            if (bSpecialIcon && bInTeam && fAlpha > 0.0)
+			{
+                if (pPlayerState->eFlags & EF_ALLIES) {
+                    iconEnt.hModel = cgi.R_RegisterModel("textures/hud/allies_headicon.spr");
+                }
+                else {
+                    iconEnt.hModel = cgi.R_RegisterModel("textures/hud/axis_headicon.spr");
+                }
+				VectorMA(iconEnt.origin, 4.0, cg.refdef.viewaxis[0], iconEnt.origin);
+				iconEnt.scale = iconEnt.scale - 0.1;
+				iconEnt.shaderRGBA[3] = (int)(fAlpha * 255.0);
+				cgi.R_AddRefSpriteToScene(&iconEnt);
+            }
+        }
+    }
     // FIXME: unimplemented
 }
 

code/cgame/cg_parsemsg.cpp

@@ -64,7 +64,7 @@ static void CG_MakeBulletHole(vec3_t i_vPos, vec3_t i_vNorm, int iLarge, trace_t
     // FIXME: unimplemented
 }
 
-static void CG_MakeBubbleTrail(vec3_t i_vStart, vec3_t i_vEnd, int iLarge)
+static void CG_MakeBubbleTrail(vec3_t i_vStart, vec3_t i_vEnd, int iLarge, float alpha = 1.0f)
 {
     // FIXME: unimplemented
 }
@@ -79,7 +79,7 @@ static void CG_MakeBulletTracerInternal(vec3_t i_vBarrel, vec3_t i_vStart, vec3_
     // FIXME: unimplemented
 }
 
-static void CG_MakeBulletTracer(vec3_t i_vBarrel, vec3_t i_vStart, vec3_t* i_vEnd, int i_iNumBullets, qboolean iLarge, int iTracerVisible, qboolean bIgnoreEntities) {
+static void CG_MakeBulletTracer(vec3_t i_vBarrel, vec3_t i_vStart, vec3_t* i_vEnd, int i_iNumBullets, qboolean iLarge, int iTracerVisible, qboolean bIgnoreEntities, float alpha = 1.0f) {
     bullet_tracer_t* bullet_tracer;
     int i;
 
@@ -306,6 +306,463 @@ void CG_MakeVehicleEffect(vec3_t i_vStart, vec3_t i_vEnd , vec3_t i_vDir) {
     cgi.R_DebugLine(vFrom, trace.endpos, 1.0, 1.0, 1.0, 1.0);
 }
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+void CG_ParseCGMessage()
+{
+	int i;
+	int iType;
+	int iLarge;
+	int iInfo;
+	int iCount;
+	char* szTmp;
+	vec3_t vStart, vEnd, vTmp;
+	vec3_t vEndArray[MAX_IMPACTS];
+    float alpha;
+    int value;
+
+	qboolean bMoreCGameMessages = qtrue;
+	while (bMoreCGameMessages) {
+		iType = cgi.MSG_ReadBits(6);
+
+		switch (iType)
+		{
+		case 1:
+		case 2:
+		case 5:
+			if (iType == 1)
+			{
+				vTmp[0] = cgi.MSG_ReadCoord();
+				vTmp[1] = cgi.MSG_ReadCoord();
+				vTmp[2] = cgi.MSG_ReadCoord();
+			}
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+
+			if (iType != 1)
+			{
+				vTmp[0] = vStart[0];
+				vTmp[1] = vStart[1];
+				vTmp[2] = vStart[2];
+			}
+
+			vEndArray[0][0] = cgi.MSG_ReadCoord();
+			vEndArray[0][1] = cgi.MSG_ReadCoord();
+			vEndArray[0][2] = cgi.MSG_ReadCoord();
+            iLarge = cgi.MSG_ReadBits(2);
+            if (cgi.MSG_ReadBits(1)) {
+                int iAlpha = cgi.MSG_ReadBits(10);
+                alpha = (float)iAlpha / 512.0;
+                if (alpha < 0.002) {
+                    alpha = 0.002;
+                }
+			} else {
+				alpha = 1.0f;
+			}
+
+			if (iType == 1) {
+				CG_MakeBulletTracer(vTmp, vStart, vEndArray, 1, iLarge, qfalse, qtrue, alpha);
+			}
+			else if (iType == 2) {
+				CG_MakeBulletTracer(vTmp, vStart, vEndArray, 1, iLarge, qfalse, qtrue, alpha);
+			}
+			else {
+				CG_MakeBubbleTrail(vStart, vEndArray[0], iLarge, alpha);
+			}
+
+			break;
+		case 3:
+		case 4:
+			if (iType == 3)
+			{
+				vTmp[0] = cgi.MSG_ReadCoord();
+				vTmp[1] = cgi.MSG_ReadCoord();
+				vTmp[2] = cgi.MSG_ReadCoord();
+				iInfo = cgi.MSG_ReadBits(6);
+			}
+			else
+			{
+				iInfo = 0;
+			}
+
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			iLarge = cgi.MSG_ReadBits(2);
+			if (cgi.MSG_ReadBits(1)) {
+				int iAlpha = cgi.MSG_ReadBits(10);
+				alpha = (float)iAlpha / 512.0;
+				if (alpha < 0.002) {
+					alpha = 0.002;
+				}
+            } else {
+                alpha = 1.0f;
+            }
+
+			iCount = cgi.MSG_ReadBits(6);
+			for (i = 0; i < iCount; ++i)
+			{
+				vEndArray[i][0] = cgi.MSG_ReadCoord();
+				vEndArray[i][1] = cgi.MSG_ReadCoord();
+				vEndArray[i][2] = cgi.MSG_ReadCoord();
+			}
+
+			if (iCount) {
+				CG_MakeBulletTracer(vTmp, vStart, vEndArray, iCount, iLarge, iInfo, qtrue, alpha);
+			}
+			break;
+		case 6:
+		case 7:
+		case 8:
+		case 9:
+		case 10:
+        case 11:
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			cgi.MSG_ReadDir(vEnd);
+			iLarge = cgi.MSG_ReadBits(2);
+
+			switch (iType)
+			{
+			case 6:
+				if (wall_impact_count < MAX_IMPACTS)
+				{
+					VectorCopy(vStart, wall_impact_pos[wall_impact_count]);
+					VectorCopy(vEnd, wall_impact_norm[wall_impact_count]);
+					wall_impact_large[wall_impact_count] = iLarge;
+					wall_impact_type[wall_impact_count] = -1;
+					wall_impact_count++;
+				}
+				break;
+			case 7:
+				if (wall_impact_count < MAX_IMPACTS)
+				{
+					VectorCopy(vStart, wall_impact_pos[wall_impact_count]);
+					VectorCopy(vEnd, wall_impact_norm[wall_impact_count]);
+					wall_impact_large[wall_impact_count] = iLarge;
+					wall_impact_type[wall_impact_count] = 6;
+					wall_impact_count++;
+				}
+				break;
+			case 8:
+				if (flesh_impact_count < MAX_IMPACTS)
+				{
+					// negative
+					VectorNegate(vEnd, vEnd);
+					VectorCopy(vStart, flesh_impact_pos[flesh_impact_count]);
+					VectorCopy(vEnd, flesh_impact_norm[flesh_impact_count]);
+					flesh_impact_large[flesh_impact_count] = iLarge;
+					flesh_impact_count++;
+				}
+				break;
+			case 9:
+				if (flesh_impact_count < MAX_IMPACTS)
+				{
+					// negative
+					VectorNegate(vEnd, vEnd);
+					VectorCopy(vStart, flesh_impact_pos[flesh_impact_count]);
+					VectorCopy(vEnd, flesh_impact_norm[flesh_impact_count]);
+					flesh_impact_large[flesh_impact_count] = iLarge;
+					flesh_impact_count++;
+				}
+				break;
+			case 10:
+				if (wall_impact_count < MAX_IMPACTS)
+				{
+					VectorCopy(vStart, wall_impact_pos[wall_impact_count]);
+					VectorCopy(vEnd, wall_impact_norm[wall_impact_count]);
+					wall_impact_large[wall_impact_count] = iLarge;
+					wall_impact_type[wall_impact_count] = 2;
+					wall_impact_count++;
+				}
+				break;
+			case 11:
+				if (wall_impact_count < MAX_IMPACTS)
+				{
+					VectorCopy(vStart, wall_impact_pos[wall_impact_count]);
+					VectorCopy(vEnd, wall_impact_norm[wall_impact_count]);
+					wall_impact_large[wall_impact_count] = iLarge;
+					wall_impact_type[wall_impact_count] = 4;
+					wall_impact_count++;
+				}
+				break;
+			default:
+				continue;
+			}
+			break;
+
+		case 12:
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			vEnd[0] = cgi.MSG_ReadCoord();
+			vEnd[1] = cgi.MSG_ReadCoord();
+			vEnd[2] = cgi.MSG_ReadCoord();
+			CG_MeleeImpact(vStart, vEnd);
+			break;
+		case 13:
+		case 14:
+		case 15:
+		case 16:
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			CG_MakeExplosionEffect(vStart, iType);
+			break;
+		case 18:
+		case 19:
+		case 20:
+		case 21:
+		case 22:
+		case 23:
+		case 24:
+		case 25:
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			cgi.MSG_ReadDir(vEnd);
+
+			sfxManager.MakeEffect_Normal(iType + 67, vStart, vEnd);
+			break;
+
+		case 26:
+		case 27:
+		{
+			str sEffect;
+			char cTmp[8];
+			vec3_t axis[3];
+
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			iLarge = cgi.MSG_ReadByte();
+			// get the integer as string
+			snprintf(cTmp, sizeof(cTmp), "%d", iLarge);
+
+			if (iType == 26) {
+				sEffect = "models/fx/crates/debris_";
+			}
+			else {
+				sEffect = "models/fx/windows/debris_";
+			}
+
+			sEffect += cTmp;
+			sEffect += ".tik";
+
+			VectorSet(axis[0], 0, 0, 1);
+			VectorSet(axis[1], 0, 1, 0);
+			VectorSet(axis[2], 1, 0, 0);
+
+			cgi.R_SpawnEffectModel(sEffect.c_str(), vStart, axis);
+		}
+		break;
+
+		case 28:
+			vTmp[0] = cgi.MSG_ReadCoord();
+			vTmp[1] = cgi.MSG_ReadCoord();
+			vTmp[2] = cgi.MSG_ReadCoord();
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			vEndArray[0][0] = cgi.MSG_ReadCoord();
+			vEndArray[0][1] = cgi.MSG_ReadCoord();
+			vEndArray[0][2] = cgi.MSG_ReadCoord();
+			iLarge = cgi.MSG_ReadBits(2);
+			if (cgi.MSG_ReadBits(1)) {
+				int iAlpha = cgi.MSG_ReadBits(10);
+				alpha = (float)iAlpha / 512.0;
+				if (alpha < 0.002) {
+					alpha = 0.002;
+				}
+            } else {
+                alpha = 1.0f;
+            }
+
+			CG_MakeBulletTracer(vTmp, vStart, vEndArray, 1, iLarge, qtrue, qtrue, alpha);
+			break;
+
+		case 29:
+			memset(vTmp, 0, sizeof(vTmp));
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			vEndArray[0][0] = cgi.MSG_ReadCoord();
+			vEndArray[0][1] = cgi.MSG_ReadCoord();
+			vEndArray[0][2] = cgi.MSG_ReadCoord();
+			iLarge = cgi.MSG_ReadBits(1);
+			if (cgi.MSG_ReadBits(1)) {
+				int iAlpha = cgi.MSG_ReadBits(10);
+				alpha = (float)iAlpha / 512.0;
+				if (alpha < 0.002) {
+					alpha = 0.002;
+				}
+            } else {
+                alpha = 1.0f;
+            }
+
+			CG_MakeBulletTracer(vTmp, vStart, vEndArray, 1, iLarge, qfalse, qtrue, alpha);
+			break;
+
+		case 30:
+			iInfo = cgi.MSG_ReadByte();
+			strcpy(cgi.HudDrawElements[iInfo].shaderName, cgi.MSG_ReadString());
+			cgi.HudDrawElements[iInfo].string[0] = 0;
+			cgi.HudDrawElements[iInfo].pFont = NULL;
+			cgi.HudDrawElements[iInfo].fontName[0] = 0;
+			// set the shader
+			CG_HudDrawShader(iInfo);
+			break;
+
+		case 31:
+			iInfo = cgi.MSG_ReadByte();
+			cgi.HudDrawElements[iInfo].iHorizontalAlign = cgi.MSG_ReadBits(2);
+			cgi.HudDrawElements[iInfo].iVerticalAlign = cgi.MSG_ReadBits(2);
+			break;
+
+		case 32:
+			iInfo = cgi.MSG_ReadByte();
+			cgi.HudDrawElements[iInfo].iX = cgi.MSG_ReadShort();
+			cgi.HudDrawElements[iInfo].iY = cgi.MSG_ReadShort();
+			cgi.HudDrawElements[iInfo].iWidth = cgi.MSG_ReadShort();
+			cgi.HudDrawElements[iInfo].iHeight = cgi.MSG_ReadShort();
+			break;
+
+		case 33:
+			iInfo = cgi.MSG_ReadByte();
+			cgi.HudDrawElements[iInfo].bVirtualScreen = cgi.MSG_ReadBits(1);
+			break;
+
+		case 34:
+			iInfo = cgi.MSG_ReadByte();
+			cgi.HudDrawElements[iInfo].vColor[0] = cgi.MSG_ReadByte() / 255.0;
+			cgi.HudDrawElements[iInfo].vColor[1] = cgi.MSG_ReadByte() / 255.0;
+			cgi.HudDrawElements[iInfo].vColor[2] = cgi.MSG_ReadByte() / 255.0;
+			break;
+
+		case 35:
+			iInfo = cgi.MSG_ReadByte();
+			cgi.HudDrawElements[iInfo].vColor[3] = cgi.MSG_ReadByte() / 255.0;
+			break;
+
+		case 36:
+			iInfo = cgi.MSG_ReadByte();
+			cgi.HudDrawElements[iInfo].hShader = 0;
+			strcpy(cgi.HudDrawElements[iInfo].string, cgi.MSG_ReadString());
+			break;
+
+		case 37:
+			iInfo = cgi.MSG_ReadByte();
+			strcpy(cgi.HudDrawElements[iInfo].fontName, cgi.MSG_ReadString());
+			cgi.HudDrawElements[iInfo].hShader = 0;
+			cgi.HudDrawElements[iInfo].shaderName[0] = 0;
+			// load the font
+			CG_HudDrawFont(iInfo);
+			break;
+
+		case 38:
+		case 39:
+		{
+			int iOldEnt;
+
+			iOldEnt = current_entity_number;
+			current_entity_number = cg.snap->ps.clientNum;
+			if (iType == 36) {
+				commandManager.PlaySound(
+					"dm_kill_notify",
+					NULL,
+					CHAN_LOCAL,
+					2.0,
+					-1,
+					-1,
+					1
+				);
+			}
+			else {
+				commandManager.PlaySound(
+					"dm_hit_notify",
+					NULL,
+					CHAN_LOCAL,
+					2.0,
+					-1,
+					-1,
+					1
+				);
+			}
+
+			current_entity_number = iOldEnt;
+		}
+		break;
+
+		case 40:
+		{
+			int iOldEnt;
+
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			iLarge = cgi.MSG_ReadBits(1);
+			iInfo = cgi.MSG_ReadBits(6);
+			szTmp = cgi.MSG_ReadString();
+
+			iOldEnt = current_entity_number;
+
+			if (iLarge) {
+				current_entity_number = iInfo;
+
+				commandManager.PlaySound(
+					szTmp,
+					vStart,
+					CHAN_LOCAL,
+					-1,
+					-1,
+					-1,
+					0
+				);
+			}
+			else {
+				current_entity_number = cg.snap->ps.clientNum;
+
+				commandManager.PlaySound(
+					szTmp,
+					vStart,
+					CHAN_AUTO,
+					-1,
+					-1,
+					-1,
+					1
+				);
+			}
+
+			current_entity_number = iOldEnt;
+		}
+		break;
+        case 41:
+			vStart[0] = cgi.MSG_ReadCoord();
+			vStart[1] = cgi.MSG_ReadCoord();
+			vStart[2] = cgi.MSG_ReadCoord();
+			vEnd[0] = cgi.MSG_ReadCoord();
+			vEnd[1] = cgi.MSG_ReadCoord();
+			vEnd[2] = cgi.MSG_ReadCoord();
+            cgi.MSG_ReadByte();
+            cgi.MSG_ReadByte();
+            VectorSubtract(vEnd, vStart, vTmp);
+
+            // FIXME: unimplemented
+            // ?? can't figure out what is this
+			break;
+		default:
+			cgi.Error(ERR_DROP, "CG_ParseCGMessage: Unknown CGM message type");
+			break;
+		}
+
+		bMoreCGameMessages = cgi.MSG_ReadBits(1);
+	}
+}
+
+#else
+
 void CG_ParseCGMessage()
 {
     int i;
@@ -684,10 +1141,12 @@ void CG_ParseCGMessage()
             current_entity_number = iOldEnt;
         }
             break;
+        default:
+            cgi.Error(ERR_DROP, "CG_ParseCGMessage: Unknown CGM message type");
+            break;
         }
 
         bMoreCGameMessages = cgi.MSG_ReadBits(1);
     }
-
-    // FIXME: unimplemented
 }
+#endif

code/cgame/cg_public.h

@@ -404,7 +404,7 @@ typedef struct {
    // FIXME
    //prof_cgame_t* profStruct;
 
-   qboolean (*CG_Command_ProcessFile)(char* name, qboolean quiet, dtiki_t* curTiki);
+   qboolean (*CG_Command_ProcessFile)(const char* name, qboolean quiet, dtiki_t* curTiki);
 
 } clientGameExport_t;
 

code/cgame/cg_scoreboard.cpp

@@ -54,63 +54,419 @@ int CG_GetScoreBoardDrawHeader()
     return 0;
 }
 
-const char* CG_GetColumnName(int iColumnNum, int* iColumnWidth)
-{
-    int iReturnWidth;
-    const char* pszReturnString;
-
-    switch (iColumnNum) {
-    case 0:
-        iReturnWidth = 128;
-        pszReturnString = "Name";
-        break;
-    case 1:
-        iReturnWidth = 64;
-        pszReturnString = "Kills";
-        break;
-    case 2:
-        iReturnWidth = 64;
-        pszReturnString = "Deaths";
-        if (cgs.gametype > GT_TEAM) {
-            pszReturnString = "Total";
-        }
-        break;
-    case 3:
-        iReturnWidth = 64;
-        pszReturnString = "Time";
-        break;
-    case 4:
-        iReturnWidth = 64;
-        pszReturnString = "Ping";
-        break;
-    default:
-        iReturnWidth = 0;
-        pszReturnString = 0;
-        break;
-    }
-
-    if (iColumnWidth) {
-        *iColumnWidth = iReturnWidth;
-    }
-
-    return pszReturnString;
-}
-
 void CG_PrepScoreBoardInfo()
 {
-    switch (cgs.gametype) {
+	switch (cgs.gametype) {
+	case GT_TEAM_ROUNDS:
+		strcpy(cg.scoresMenuName, "DM_Round_Scoreboard");
+		break;
     case GT_OBJECTIVE:
         strcpy(cg.scoresMenuName, "Obj_Scoreboard");
-        break;
-    case GT_TEAM_ROUNDS:
-        strcpy(cg.scoresMenuName, "DM_Round_Scoreboard");
-        break;
+		break;
+	case GT_TOW:
+		strcpy(cg.scoresMenuName, "Tow_Scoreboard");
+		break;
+	case GT_LIBERATION:
+		strcpy(cg.scoresMenuName, "Lib_Scoreboard");
+		break;
     default:
         strcpy(cg.scoresMenuName, "DM_Scoreboard");
         break;
     }
 }
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+const char* CG_GetColumnName(int iColumnNum, int* iColumnWidth)
+{
+	int iReturnWidth;
+	const char* pszReturnString;
+
+	switch (iColumnNum) {
+	case 0:
+		iReturnWidth = 24;
+		pszReturnString = "#";
+		break;
+	case 1:
+		iReturnWidth = 128;
+		pszReturnString = "Name";
+		break;
+	case 2:
+		iReturnWidth = 64;
+		pszReturnString = "Kills";
+		break;
+	case 3:
+		iReturnWidth = 64;
+		pszReturnString = "Deaths";
+		if (cgs.gametype > GT_TEAM) {
+			pszReturnString = "Total";
+		}
+		break;
+	case 4:
+		iReturnWidth = 64;
+		pszReturnString = "Time";
+		break;
+	case 5:
+		iReturnWidth = 64;
+		pszReturnString = "Ping";
+		break;
+	default:
+		iReturnWidth = 0;
+		pszReturnString = 0;
+		break;
+	}
+
+	if (iColumnWidth) {
+		*iColumnWidth = iReturnWidth;
+	}
+
+	return pszReturnString;
+}
+
+void CG_ParseScores()
+{
+	int i;
+	int iEntryCount;
+	int iClientTeam, iClientNum;
+	int iDatumCount;
+	int iMatchTeam;
+	int iCurrentEntry;
+	qboolean bIsDead, bIsHeader;
+	char szString2[MAX_STRING_TOKENS];
+	char szString3[MAX_STRING_TOKENS];
+	char szString4[MAX_STRING_TOKENS];
+	char szString5[MAX_STRING_TOKENS];
+	char szString6[MAX_STRING_TOKENS];
+	char szString7[MAX_STRING_TOKENS];
+	float vSameTeamTextColor[4];
+	float vSameTeamBackColor[4];
+	float vOtherTeamTextColor[4];
+	float vOtherTeamBackColor[4];
+	float vNoTeamTextColor[4];
+	float vNoTeamBackColor[4];
+	float vThisClientTextColor[4];
+	float vThisClientBackColor[4];
+	float vDeadTextColorDead[4];
+	float* pItemTextColor;
+	float* pItemBackColor;
+
+	iMatchTeam = -1;
+	vSameTeamTextColor[0] = 1.0f;
+	vSameTeamTextColor[1] = 1.0f;
+	vSameTeamTextColor[2] = 1.0f;
+	vSameTeamTextColor[3] = 1.0f;
+	vSameTeamBackColor[0] = 0.1f;
+	vSameTeamBackColor[1] = 0.5f;
+	vSameTeamBackColor[2] = 0.1f;
+	vSameTeamBackColor[3] = 0.4f;
+	vOtherTeamTextColor[0] = 1.0f;
+	vOtherTeamTextColor[1] = 1.0f;
+	vOtherTeamTextColor[2] = 1.0f;
+	vOtherTeamTextColor[3] = 1.0f;
+	vOtherTeamBackColor[0] = 0.5f;
+	vOtherTeamBackColor[1] = 0.1f;
+	vOtherTeamBackColor[2] = 0.1f;
+	vOtherTeamBackColor[3] = 0.4f;
+	vNoTeamTextColor[0] = 1.0f;
+	vNoTeamTextColor[1] = 1.0f;
+	vNoTeamTextColor[2] = 1.0f;
+	vNoTeamTextColor[3] = 1.0f;
+	vNoTeamBackColor[0] = 0.1f;
+	vNoTeamBackColor[1] = 0.1f;
+	vNoTeamBackColor[2] = 0.1f;
+	vNoTeamBackColor[3] = 0.4f;
+	vDeadTextColorDead[0] = 1.0f;
+	vDeadTextColorDead[1] = 0.1f;
+	vDeadTextColorDead[2] = 0.1f;
+	vDeadTextColorDead[3] = 1.0f;
+
+	vThisClientTextColor[0] = 0.0f;
+	vThisClientTextColor[1] = 0.0f;
+	vThisClientTextColor[2] = 0.0f;
+	vThisClientTextColor[3] = 1.0f;
+
+	if (cgs.gametype > GT_FFA)
+	{
+		vThisClientBackColor[0] = 0.5f;
+		vThisClientBackColor[1] = 0.75f;
+		vThisClientBackColor[2] = 0.5f;
+	}
+	else
+	{
+		vThisClientBackColor[0] = 0.75f;
+		vThisClientBackColor[1] = 0.75f;
+		vThisClientBackColor[2] = 0.75f;
+	}
+
+	vThisClientBackColor[3] = 0.8f;
+
+	iCurrentEntry = 1;
+	if (cgs.gametype > GT_FFA)
+	{
+		iDatumCount = 6;
+		iMatchTeam = cg.snap->ps.stats[STAT_TEAM];
+		if (iMatchTeam != TEAM_ALLIES && iMatchTeam != TEAM_AXIS)
+		{
+			iMatchTeam = TEAM_ALLIES;
+			vThisClientTextColor[0] = 0.0f;
+			vThisClientTextColor[1] = 0.0f;
+			vThisClientTextColor[2] = 0.0f;
+			vThisClientBackColor[0] = 0.75f;
+			vThisClientBackColor[1] = 0.75f;
+			vThisClientBackColor[2] = 0.75f;
+		}
+	}
+	else
+	{
+		// free-for-all
+		iDatumCount = 5;
+	}
+
+	iEntryCount = atoi(cgi.Argv(iCurrentEntry++));
+	if (iEntryCount > MAX_CLIENTS) {
+		iEntryCount = MAX_CLIENTS;
+	}
+
+	if (cgs.gametype == GT_TOW)
+	{
+		cgi.Cvar_Set("tow_allied_obj1", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_allied_obj2", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_allied_obj3", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_allied_obj4", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_allied_obj5", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_axis_obj1", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_axis_obj2", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_axis_obj3", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_axis_obj4", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("tow_axis_obj5", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+	}
+
+	if (cgs.gametype == GT_LIBERATION)
+	{
+		cgi.Cvar_Set("scoreboard_toggle1", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+		cgi.Cvar_Set("scoreboard_toggle2", va("%i", (int)atof(cgi.Argv(iCurrentEntry++))));
+	}
+
+	for (i = 0; i < iEntryCount; ++i)
+	{
+		bIsHeader = qfalse;
+		if (cgs.gametype > GT_FFA)
+		{
+			iClientNum = atoi(cgi.Argv(iCurrentEntry + iDatumCount * i));
+			iClientTeam = atoi(cgi.Argv(1 + iCurrentEntry + iDatumCount * i));
+			if (iClientTeam >= 0) {
+				bIsDead = qfalse;
+			}
+			else {
+				bIsDead = qtrue;
+				iClientTeam = -iClientTeam;
+			}
+
+			if (iClientNum == -1)
+			{
+				szString2[0] = 0;
+				bIsHeader = qtrue;
+
+				switch (iClientTeam)
+				{
+				case 1:
+					strcpy(szString3, cgi.LV_ConvertString("Spectators"));
+					break;
+				case 2:
+					strcpy(szString3, cgi.LV_ConvertString("Free-For-Allers"));
+					break;
+				case 3:
+                    sprintf(
+                        szString3,
+                        "%s - %d %s",
+						cgi.LV_ConvertString("Allies"),
+						atoi(cgi.Argv(2 + iCurrentEntry + iDatumCount * i)),
+                        cgi.LV_ConvertString("Players")
+                    );
+                    iCurrentEntry++;
+					break;
+				case 4:
+					sprintf(
+                        szString3,
+                        "%s - %d %s",
+						cgi.LV_ConvertString("Axis"),
+						atoi(cgi.Argv(2 + iCurrentEntry + iDatumCount * i)),
+                        cgi.LV_ConvertString("Players")
+					);
+					iCurrentEntry++;
+					break;
+				default:
+					strcpy(szString3, cgi.LV_ConvertString("No Team"));
+					break;
+				}
+			}
+			else if (iClientNum == -2)
+			{
+				// spectating
+				szString2[0] = 0;
+				szString3[0] = 0;
+			}
+			else
+			{
+				strcpy(szString2, va("%i", iClientNum));
+				strcpy(szString3, cg.clientinfo[iClientNum].name);
+			}
+
+			strcpy(szString4, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
+			strcpy(szString5, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
+			strcpy(szString6, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
+			strcpy(szString7, cgi.Argv(5 + iCurrentEntry + iDatumCount * i));
+
+			if (cgs.gametype >= GT_TEAM_ROUNDS && iClientNum == -1 && iClientTeam == TEAM_ALLIES || iClientTeam == TEAM_AXIS)
+			{
+				strcat(szString4, va(" %s", cgi.LV_ConvertString("Wins")));
+				szString5[0] = 0;
+			}
+
+			if (iClientNum == cg.snap->ps.clientNum)
+			{
+				pItemTextColor = vThisClientTextColor;
+				pItemBackColor = vThisClientBackColor;
+			}
+			else if (iClientNum == -2)
+			{
+				pItemTextColor = vNoTeamTextColor;
+				pItemBackColor = vNoTeamBackColor;
+			}
+			else if (iClientTeam == TEAM_ALLIES || iClientTeam == TEAM_AXIS)
+			{
+				if (iClientTeam == iMatchTeam)
+				{
+					pItemTextColor = vSameTeamTextColor;
+					pItemBackColor = vSameTeamBackColor;
+				}
+				else
+				{
+					pItemTextColor = vOtherTeamTextColor;
+					pItemBackColor = vOtherTeamBackColor;
+				}
+			}
+			else
+			{
+				pItemTextColor = vNoTeamTextColor;
+				pItemBackColor = vNoTeamBackColor;
+			}
+
+			if (bIsDead) {
+				pItemTextColor = vDeadTextColorDead;
+			}
+		}
+		else
+		{
+			iClientNum = atoi(cgi.Argv(iDatumCount * i));
+			if (iClientNum >= 0)
+			{
+                strcpy(szString2, va("%i", iClientNum));
+				strcpy(szString3, cg.clientinfo[iClientNum].name);
+				strcpy(szString4, cgi.Argv(1 + iCurrentEntry + iDatumCount * i));
+				strcpy(szString5, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
+				strcpy(szString6, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
+				strcpy(szString7, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
+			}
+			else
+			{
+				szString2[0] = 0;
+				if (iClientNum == -3)
+				{
+					strcpy(szString2, cgi.LV_ConvertString("Players"));
+					bIsHeader = qtrue;
+				}
+				else if (iClientNum == -2)
+				{
+					strcpy(szString2, cgi.LV_ConvertString("Spectators"));
+					bIsHeader = qtrue;
+				}
+				else
+				{
+					// unknown
+					szString3[0] = 0;
+				}
+				szString4[0] = 0;
+				szString5[0] = 0;
+				szString6[0] = 0;
+				szString7[0] = 0;
+			}
+
+			if (iClientNum == cg.snap->ps.clientNum)
+			{
+				pItemTextColor = vThisClientTextColor;
+				pItemBackColor = vThisClientBackColor;
+			}
+			else
+			{
+				pItemTextColor = vNoTeamTextColor;
+				pItemBackColor = vNoTeamBackColor;
+			}
+		}
+
+		cgi.UI_SetScoreBoardItem(
+			i,
+			szString2,
+			szString3,
+			szString4,
+			szString5,
+			szString6,
+			szString7,
+			NULL,
+			NULL,
+			pItemTextColor,
+			pItemBackColor,
+			bIsHeader
+		);
+	}
+
+	cgi.UI_DeleteScoreBoardItems(iEntryCount);
+}
+
+#else
+
+const char* CG_GetColumnName(int iColumnNum, int* iColumnWidth)
+{
+	int iReturnWidth;
+	const char* pszReturnString;
+
+	switch (iColumnNum) {
+	case 0:
+		iReturnWidth = 128;
+		pszReturnString = "Name";
+		break;
+	case 1:
+		iReturnWidth = 64;
+		pszReturnString = "Kills";
+		break;
+	case 2:
+		iReturnWidth = 64;
+		pszReturnString = "Deaths";
+		if (cgs.gametype > GT_TEAM) {
+			pszReturnString = "Total";
+		}
+		break;
+	case 3:
+		iReturnWidth = 64;
+		pszReturnString = "Time";
+		break;
+	case 4:
+		iReturnWidth = 64;
+		pszReturnString = "Ping";
+		break;
+	default:
+		iReturnWidth = 0;
+		pszReturnString = 0;
+		break;
+	}
+
+	if (iColumnWidth) {
+		*iColumnWidth = iReturnWidth;
+	}
+
+	return pszReturnString;
+}
+
 void CG_ParseScores()
 {
     int i;
@@ -118,13 +474,13 @@ void CG_ParseScores()
     int iClientTeam, iClientNum;
     int iDatumCount;
     int iMatchTeam;
+    int iCurrentEntry;
     qboolean bIsDead, bIsHeader;
     char szString2[MAX_STRING_TOKENS];
     char szString3[MAX_STRING_TOKENS];
     char szString4[MAX_STRING_TOKENS];
     char szString5[MAX_STRING_TOKENS];
     char szString6[MAX_STRING_TOKENS];
-    const char* pszClientInfo;
     float vSameTeamTextColor[4];
     float vSameTeamBackColor[4];
     float vOtherTeamTextColor[4];
@@ -187,6 +543,7 @@ void CG_ParseScores()
 
     vThisClientBackColor[3] = 0.8f;
 
+    iCurrentEntry = 1;
     if (cgs.gametype > GT_FFA)
     {
         iDatumCount = 6;
@@ -208,7 +565,7 @@ void CG_ParseScores()
         iDatumCount = 5;
     }
 
-    iEntryCount = atoi(cgi.Argv(1));
+    iEntryCount = atoi(cgi.Argv(iCurrentEntry++));
     if (iEntryCount > MAX_CLIENTS) {
         iEntryCount = MAX_CLIENTS;
     }
@@ -218,8 +575,8 @@ void CG_ParseScores()
         bIsHeader = qfalse;
         if (cgs.gametype > GT_FFA)
         {
-            iClientNum = atoi(cgi.Argv(2 + iDatumCount * i));
-            iClientTeam = atoi(cgi.Argv(3 + iDatumCount * i));
+            iClientNum = atoi(cgi.Argv(iCurrentEntry + iDatumCount * i));
+            iClientTeam = atoi(cgi.Argv(1 + iCurrentEntry + iDatumCount * i));
             if (iClientTeam >= 0) {
                 bIsDead = qfalse;
             }
@@ -235,19 +592,19 @@ void CG_ParseScores()
                 switch (iClientTeam)
                 {
                 case 1:
-                    strcpy(szString2, "Spectators");
+                    strcpy(szString2, cgi.LV_ConvertString("Spectators"));
                     break;
                 case 2:
-                    strcpy(szString2, "Free-For-Allers");
+                    strcpy(szString2, cgi.LV_ConvertString("Free-For-Allers"));
                     break;
                 case 3:
-                    strcpy(szString2, "Allies");
+                    strcpy(szString2, cgi.LV_ConvertString("Allies"));
                     break;
                 case 4:
-                    strcpy(szString2, "Axis");
+                    strcpy(szString2, cgi.LV_ConvertString("Axis"));
                     break;
                 default:
-                    strcpy(szString2, "No Team");
+                    strcpy(szString2, cgi.LV_ConvertString("No Team"));
                     break;
                 }
             }
@@ -257,15 +614,14 @@ void CG_ParseScores()
                 szString2[0] = 0;
             }
             else
-            {
-                pszClientInfo = CG_ConfigString(CS_PLAYERS + iClientNum);
-                strcpy(szString2, Info_ValueForKey(pszClientInfo, "name"));
+			{
+                strcpy(szString2, cg.clientinfo[iClientNum].name);
             }
 
-            strcpy(szString3, cgi.Argv(4 + iDatumCount * i));
-            strcpy(szString4, cgi.Argv(5 + iDatumCount * i));
-            strcpy(szString5, cgi.Argv(6 + iDatumCount * i));
-            strcpy(szString6, cgi.Argv(7 + iDatumCount * i));
+            strcpy(szString3, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
+            strcpy(szString4, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
+            strcpy(szString5, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
+            strcpy(szString6, cgi.Argv(5 + iCurrentEntry + iDatumCount * i));
 
             if (iClientNum == cg.snap->ps.clientNum)
             {
@@ -302,26 +658,25 @@ void CG_ParseScores()
         }
         else
         {
-            iClientNum = atoi(cgi.Argv(2 + iDatumCount * i));
+            iClientNum = atoi(cgi.Argv(iCurrentEntry + iDatumCount * i));
             if (iClientNum >= 0)
             {
-                pszClientInfo = CG_ConfigString(CS_PLAYERS + iClientNum);
-                strcpy(szString2, Info_ValueForKey(pszClientInfo, "name"));
-                strcpy(szString3, cgi.Argv(3 + iDatumCount * i));
-                strcpy(szString4, cgi.Argv(4 + iDatumCount * i));
-                strcpy(szString5, cgi.Argv(5 + iDatumCount * i));
-                strcpy(szString6, cgi.Argv(6 + iDatumCount * i));
+                strcpy(szString2, cg.clientinfo[iClientNum].name);
+                strcpy(szString3, cgi.Argv(1 + iCurrentEntry + iDatumCount * i));
+                strcpy(szString4, cgi.Argv(2 + iCurrentEntry + iDatumCount * i));
+                strcpy(szString5, cgi.Argv(3 + iCurrentEntry + iDatumCount * i));
+                strcpy(szString6, cgi.Argv(4 + iCurrentEntry + iDatumCount * i));
             }
             else
             {
                 if (iClientNum == -3)
                 {
-                    strcpy(szString2, "Players");
+                    strcpy(szString2, cgi.LV_ConvertString("Players"));
                     bIsHeader = qtrue;
                 }
                 else if (iClientNum == -2)
                 {
-                    strcpy(szString2, "Spectators");
+                    strcpy(szString2, cgi.LV_ConvertString("Spectators"));
                     bIsHeader = qtrue;
                 }
                 else
@@ -365,3 +720,4 @@ void CG_ParseScores()
 
     cgi.UI_DeleteScoreBoardItems(iEntryCount);
 }
+#endif

code/cgame/cg_servercmds.c

@@ -25,6 +25,58 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cg_local.h"
 
+static const char* IsWeaponAllowed(int dmFlags, int flags) {
+    return (dmFlags & flags) ? "0" : "1";
+}
+
+static qboolean QueryLandminesAllowed2(const char* mapname, int dmflags) {
+    if (dmflags & DF_WEAPON_NO_LANDMINE) {
+        return qfalse;
+    }
+
+    if (dmflags & DF_WEAPON_LANDMINE_ALWAYS) {
+        return qtrue;
+    }
+
+	if (!Q_stricmpn(mapname, "obj/obj_", 8u))
+		return qfalse;
+	if (!Q_stricmpn(mapname, "dm/mohdm", 8u))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Bahnhof_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "obj/MP_Ardennes_TOW"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Bazaar_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "obj/MP_Berlin_TOW"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Brest_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "obj/MP_Druckkammern_TOW"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Gewitter_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "obj/MP_Flughafen_TOW"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Holland_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Malta_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Stadt_DM"))
+		return qfalse;
+	if (!Q_stricmp(mapname, "DM/MP_Unterseite_DM"))
+		return qfalse;
+    if (!Q_stricmp(mapname, "DM/MP_Verschneit_DM"))
+        return qfalse;
+    if (!Q_stricmp(mapname, "lib/mp_ship_lib"))
+        return qfalse;
+    if (!Q_stricmp(mapname, "DM/MP_Verschneit_DM"))
+        return qfalse;
+    if (!Q_stricmp(mapname, "lib/mp_ship_lib"))
+        return qfalse;
+	return qtrue;
+}
+
 /*
 ================
 CG_ParseServerinfo
@@ -39,6 +91,7 @@ void CG_ParseServerinfo(void)
     const char* mapname;
     char map[MAX_QPATH];
     char* spawnpos;
+    const char* version;
 
     info = CG_ConfigString(CS_SERVERINFO);
     cgs.gametype = atoi(Info_ValueForKey(info, "g_gametype"));
@@ -48,6 +101,13 @@ void CG_ParseServerinfo(void)
     cgs.timelimit = atoi(Info_ValueForKey(info, "timelimit"));
     cgs.maxclients = atoi(Info_ValueForKey(info, "sv_maxclients"));
 
+    version = Info_ValueForKey(info, "version");
+    if (strstr(version, "Spearhead")) {
+        cgi.Cvar_Set("g_servertype", "1");
+    } else {
+		cgi.Cvar_Set("g_servertype", "2");
+    }
+
     cgi.Cvar_Set("cg_gametype", Info_ValueForKey(info, "g_gametype"));
     cgi.Cvar_Set("cg_fraglimit", Info_ValueForKey(info, "fraglimit"));
     cgi.Cvar_Set("cg_timelimit", Info_ValueForKey(info, "timelimit"));
@@ -60,9 +120,18 @@ void CG_ParseServerinfo(void)
     cgi.Cvar_Set("cg_obj_axistext3", Info_ValueForKey(info, "cg_obj_axistext3"));
     cgi.Cvar_Set("cg_scoreboardpic", Info_ValueForKey(info, "g_scoreboardpic"));
     cgi.Cvar_Set("cg_scoreboardpicover", Info_ValueForKey(info, "g_scoreboardpicover"));
+    cgs.mapChecksum = atoi(Info_ValueForKey(info, "sv_mapChecksum"));
 
     mapname = Info_ValueForKey(info, "mapname");
 
+    cgi.Cvar_Set("cg_weapon_rifle", IsWeaponAllowed(cgs.dmflags, DF_WEAPON_NO_RIFLE));
+    cgi.Cvar_Set("cg_weapon_sniper", IsWeaponAllowed(cgs.dmflags, DF_WEAPON_NO_SNIPER));
+    cgi.Cvar_Set("cg_weapon_mg", IsWeaponAllowed(cgs.dmflags, DF_WEAPON_NO_MG));
+    cgi.Cvar_Set("cg_weapon_smg", IsWeaponAllowed(cgs.dmflags, DF_WEAPON_NO_SMG));
+    cgi.Cvar_Set("cg_weapon_rocket", IsWeaponAllowed(cgs.dmflags, DF_WEAPON_NO_ROCKET));
+    cgi.Cvar_Set("cg_weapon_shotgun", IsWeaponAllowed(cgs.dmflags, DF_WEAPON_NO_SHOTGUN));
+    cgi.Cvar_Set("cg_weapon_landmine", QueryLandminesAllowed2(mapname, cgs.dmflags) ? "1" : "0");
+
     spawnpos = strchr(mapname, '$');
     if (spawnpos) {
         Q_strncpyz(map, mapname, spawnpos - mapname + 1);
@@ -150,16 +219,32 @@ CG_Stopwatch_f
 
 ================
 */
+#if TARGET_GAME_PROTOCOL >= 15
+
 static void CG_Stopwatch_f()
 {
-    if (cgi.Argc() != 3) {
-        Com_Error(1, "stopwatch didn't have 2 parameters");
-    }
+	if (cgi.Argc() < 3) {
+		Com_Error(ERR_DROP, "stopwatch didn't have 2 parameters");
+	}
 
-    cgi.stopWatch->iStartTime = 1000 * atoi(cgi.Argv(1));
-    cgi.stopWatch->iEndTime = cgi.stopWatch->iStartTime + 1000 * atoi(cgi.Argv(2));
+	cgi.stopWatch->iStartTime = atoi(cgi.Argv(1));
+	cgi.stopWatch->iEndTime = cgi.stopWatch->iStartTime + 1000 * atoi(cgi.Argv(2));
 }
 
+#else
+
+static void CG_Stopwatch_f()
+{
+	if (cgi.Argc() < 3) {
+		Com_Error(ERR_DROP, "stopwatch didn't have 2 parameters");
+	}
+
+	cgi.stopWatch->iStartTime = 1000 * atoi(cgi.Argv(1));
+	cgi.stopWatch->iEndTime = cgi.stopWatch->iStartTime + 1000 * atoi(cgi.Argv(2));
+}
+
+#endif
+
 /*
 ================
 CG_ServerLag_f
@@ -202,6 +287,50 @@ static void CG_ServerCommand(void)
         }
         return;
     }
+    else if (!strcmp(cmd, "printdeathmsg")) {
+        const char* s1, * s2, * s3, * s4, * s5;
+        const char* result1, * result2;
+        int hudColor;
+
+		result1 = NULL;
+		result2 = NULL;
+		s1 = cgi.Argv(1);
+		s2 = cgi.Argv(2);
+		s3 = cgi.Argv(3);
+		s4 = cgi.Argv(4);
+		s5 = cgi.Argv(5);
+
+        if (*s5 == tolower(*s5)) {
+            hudColor = 4;
+        } else {
+			hudColor = 5;
+        }
+
+		if (*s1 != 'x')
+			result1 = cgi.LV_ConvertString(s1);
+		if (*s2 != 'x')
+			result2 = cgi.LV_ConvertString(s2);
+		if (tolower(*s5) == 's')
+		{
+			cgi.Printf("%c%s %s\n", hudColor, s4, result1);
+		}
+		else if (tolower(*s5) == 'p')
+		{
+			if (*s2 == 'x')
+				cgi.Printf("%c%s %s %s\n", hudColor, s4, result1, s3);
+			else
+				cgi.Printf("%c%s %s %s%s\n", hudColor, s4, result1, s3, result2);
+		}
+		else if (tolower(*s5) == 'w')
+		{
+			cgi.Printf("%c%s %s\n", hudColor, s4, result1);
+		}
+		else
+		{
+			cgi.Printf("%s", cgi.Argv(1));
+		}
+        return;
+    }
     
     if (!strcmp(cmd, "stufftext")) {
         cgi.Cmd_Stuff(cgi.Argv(1));

code/cgame/cg_view.c

@@ -799,7 +799,7 @@ void CG_DrawActiveFrame( int serverTime, int frameTime, stereoFrame_t stereoView
             cgi.SendClientCommand("stats");
         }
 
-        cg.bIntermissionDisplay = qfalse;
+        cg.bIntermissionDisplay = qtrue;
     }
     else if (cg.bIntermissionDisplay)
     {

code/cgame/cg_viewmodelanim.c

@@ -46,7 +46,40 @@ static const char* AnimPrefixList[] =
     "bazooka",
     "panzerschreck",
     "shotgun",
-    "unarmed"
+    "unarmed",
+    //
+    // Team Assault and Team Tactics weapons
+    "mg42portable",
+    "webley",
+    "nagantrev",
+    "beretta",
+    "enfield",
+    "svt",
+    "mosin",
+    "g43",
+    "enfieldl42a1",
+    "carcano",
+    "delisle",
+    "thompson",
+    "sten",
+    "ppsh",
+    "moschetto",
+    "fg42",
+    "vickers",
+    "breda",
+    "f1grenade",
+    "millsgrenade",
+    "nebelhandgranate",
+    "m18smokegrenade",
+    "rdg1smokegrenade",
+    "bomba",
+    "bombabreda",
+    "mine",
+    "minedetector",
+    "minedetectoraxis",
+    "detonator",
+    "kar98mortar",
+    "PIAT"
 };
 
 enum animPrefix_e
@@ -69,7 +102,39 @@ enum animPrefix_e
     WPREFIX_BAZOOKA,
     WPREFIX_PANZERSCHRECK,
     WPREFIX_SHOTGUN,
-    WPREFIX_UNARMED
+	WPREFIX_UNARMED,
+	//
+	// Team Assault and Team Tactics weapons
+	WPREFIX_MG42_PORTABLE,
+	WPREFIX_WEBLEY,
+	WPREFIX_NAGANTREV,
+	WPREFIX_BERETTA,
+	WPREFIX_ENFIELD,
+	WPREFIX_SVT,
+	WPREFIX_MOSIN,
+	WPREFIX_G43,
+	WPREFIX_ENFIELDL42A,
+	WPREFIX_CARCANO,
+	WPREFIX_DELISLE,
+	WPREFIX_STEN,
+	WPREFIX_PPSH,
+	WPREFIX_MOSCHETTO,
+	WPREFIX_FG42,
+	WPREFIX_VICKERS,
+	WPREFIX_BREDA,
+	WPREFIX_F1_GRENADE,
+	WPREFIX_MILLS_GRENADE,
+	WPREFIX_NEBELHANDGRANATE,
+	WPREFIX_M18_SMOKE_GRENADE,
+	WPREFIX_RDG1_SMOKE_GRENADE,
+    WPREFIX_BOMBA,
+	WPREFIX_BOMBA_BREDA,
+	WPREFIX_MINE,
+	WPREFIX_MINE_DETECTOR,
+	WPREFIX_MINE_DETECTOR_AXIS,
+	WPREFIX_DETONATOR,
+	WPREFIX_KAR98_MORTAR,
+	WPREFIX_PIAT
 };
 
 int CG_GetVMAnimPrefixIndex()
@@ -83,7 +148,9 @@ int CG_GetVMAnimPrefixIndex()
     if (iWeaponClass & WEAPON_CLASS_ANY_ITEM)
     {
         if (!Q_stricmp(szWeaponName, "Papers"))
-            return WPREFIX_PAPERS;
+			return WPREFIX_PAPERS;
+		if (!Q_stricmp(szWeaponName, "Packed MG42 Turret"))
+			return WPREFIX_MG42_PORTABLE;
     }
     else if (iWeaponClass & WEAPON_CLASS_PISTOL)
     {
@@ -92,7 +159,19 @@ int CG_GetVMAnimPrefixIndex()
         if (!Q_stricmp(szWeaponName, "Walther P38"))
             return WPREFIX_P38;
         if (!Q_stricmp(szWeaponName, "Hi-Standard Silenced"))
-            return WPREFIX_HISTANDARD;
+			return WPREFIX_HISTANDARD;
+
+		//
+		// Team Assault and Team Tactics
+		//
+		if (!Q_stricmp(szWeaponName, "Webley Revolver"))
+			return WPREFIX_WEBLEY;
+		if (!Q_stricmp(szWeaponName, "Nagant Revolver"))
+			return WPREFIX_NAGANTREV;
+		if (!Q_stricmp(szWeaponName, "Beretta"))
+			return WPREFIX_BERETTA;
+
+        return WPREFIX_COLT45;
     }
     else if (iWeaponClass & WEAPON_CLASS_RIFLE)
     {
@@ -103,28 +182,97 @@ int CG_GetVMAnimPrefixIndex()
         if (!Q_stricmp(szWeaponName, "KAR98 - Sniper"))
             return WPREFIX_KAR98SNIPER;
         if (!Q_stricmp(szWeaponName, "Springfield '03 Sniper"))
-            return WPREFIX_SPRINGFIELD;
+			return WPREFIX_SPRINGFIELD;
+
+        //
+        // Team Assault and Team Tactics
+        //
+		if (!Q_stricmp(szWeaponName, "Lee-Enfield"))
+			return WPREFIX_SPRINGFIELD;
+		if (!Q_stricmp(szWeaponName, "SVT 40"))
+			return WPREFIX_SVT;
+		if (!Q_stricmp(szWeaponName, "Mosin Nagant Rifle"))
+			return WPREFIX_MOSIN;
+		if (!Q_stricmp(szWeaponName, "G 43"))
+			return WPREFIX_G43;
+		if (!Q_stricmp(szWeaponName, "Enfield L42A1"))
+			return WPREFIX_ENFIELD;
+		if (!Q_stricmp(szWeaponName, "Carcano"))
+			return WPREFIX_CARCANO;
+		if (!Q_stricmp(szWeaponName, "DeLisle"))
+			return WPREFIX_DELISLE;
+
+        return WPREFIX_GARAND;
     }
     else if (iWeaponClass & WEAPON_CLASS_SMG)
     {
         if (!Q_stricmp(szWeaponName, "Thompson"))
             return WPREFIX_THOMPSON;
         if (!Q_stricmp(szWeaponName, "MP40"))
-            return WPREFIX_MP40;
+			return WPREFIX_MP40;
+		//
+		// Team Assault and Team Tactics
+		//
+		if (!Q_stricmp(szWeaponName, "Sten Mark II"))
+			return WPREFIX_STEN;
+		if (!Q_stricmp(szWeaponName, "PPSH SMG"))
+			return WPREFIX_PPSH;
+		if (!Q_stricmp(szWeaponName, "Moschetto"))
+			return WPREFIX_MOSCHETTO;
+
+        return WPREFIX_THOMPSON;
     }
     else if (iWeaponClass & WEAPON_CLASS_MG)
     {
         if (!Q_stricmp(szWeaponName, "BAR"))
             return WPREFIX_BAR;
         if (!Q_stricmp(szWeaponName, "StG 44"))
-            return WPREFIX_MP44;
+			return WPREFIX_MP44;
+		//
+		// Team Assault and Team Tactics
+		//
+		if (!Q_stricmp(szWeaponName, "FG 42"))
+			return WPREFIX_MP44;
+		if (!Q_stricmp(szWeaponName, "Vickers-Berthier"))
+			return WPREFIX_MP44;
+		if (!Q_stricmp(szWeaponName, "Breda"))
+			return WPREFIX_MP44;
+
+        return WPREFIX_BAR;
     }
     else if (iWeaponClass & WEAPON_CLASS_GRENADE)
     {
         if (!Q_stricmp(szWeaponName, "Frag Grenade"))
             return WPREFIX_FRAGGRENADE;
         if (!Q_stricmp(szWeaponName, "Stielhandgranate"))
-            return WPREFIX_STIELHANDGRANATE;
+			return WPREFIX_STIELHANDGRANATE;
+		//
+		// Team Assault and Team Tactics
+		//
+		if (!Q_stricmp(szWeaponName, "F1 Grenade"))
+			return WPREFIX_F1_GRENADE;
+		if (!Q_stricmp(szWeaponName, "Mills Grenade"))
+			return WPREFIX_MILLS_GRENADE;
+        if (!Q_stricmp(szWeaponName, "Nebelhandgranate"))
+            return WPREFIX_NEBELHANDGRANATE;
+		if (!Q_stricmp(szWeaponName, "M18 Smoke Grenade"))
+			return WPREFIX_M18_SMOKE_GRENADE;
+		if (!Q_stricmp(szWeaponName, "RDG-1 Smoke Grenade"))
+			return WPREFIX_RDG1_SMOKE_GRENADE;
+        if (!Q_stricmp(szWeaponName, "Bomba A Mano"))
+            return WPREFIX_BOMBA;
+		if (!Q_stricmp(szWeaponName, "Bomba A Mano Breda"))
+			return WPREFIX_BOMBA_BREDA;
+		if (!Q_stricmp(szWeaponName, "LandmineAllies"))
+			return WPREFIX_MINE;
+		if (!Q_stricmp(szWeaponName, "LandmineAxis"))
+			return WPREFIX_MINE;
+		if (!Q_stricmp(szWeaponName, "Minensuchgerat"))
+			return WPREFIX_MINE_DETECTOR_AXIS;
+		if (!Q_stricmp(szWeaponName, "Minedetector"))
+			return WPREFIX_MINE_DETECTOR;
+
+        return WPREFIX_FRAGGRENADE;
     }
     else if (iWeaponClass & WEAPON_CLASS_HEAVY)
     {
@@ -133,7 +281,14 @@ int CG_GetVMAnimPrefixIndex()
         if (!Q_stricmp(szWeaponName, "Panzerschreck"))
             return WPREFIX_PANZERSCHRECK;
         if (!Q_stricmp(szWeaponName, "Shotgun"))
-            return WPREFIX_SHOTGUN;
+			return WPREFIX_SHOTGUN;
+		//
+		// Team Assault and Team Tactics
+		//
+		if (!Q_stricmp(szWeaponName, "PIAT"))
+			return WPREFIX_PIAT;
+
+        return WPREFIX_BAZOOKA;
     }
 
     return WPREFIX_UNARMED;
@@ -226,10 +381,22 @@ void CG_ViewModelAnimation(refEntity_t* pModel)
         case VM_ANIM_LADDERSTEP:
             pszAnimSuffix = "ladderstep";
             break;
-        case VM_ANIM_IDLE:
+		case VM_ANIM_IDLE_0:
+			pszAnimSuffix = "idle0";
+			break;
+		case VM_ANIM_IDLE_1:
+			pszAnimSuffix = "idle1";
+			break;
+		case VM_ANIM_IDLE_2:
+			pszAnimSuffix = "idle2";
+			break;
+		case VM_ANIM_DISABLED:
+			pszAnimSuffix = "disabled";
+			break;
         default:
-            pszAnimSuffix = "idle";
-            break;
+		case VM_ANIM_IDLE:
+			pszAnimSuffix = "idle";
+			break;
         }
 
         sprintf(szAnimName, "%s_%s", AnimPrefixList[iAnimPrefixIndex], pszAnimSuffix);

code/cgame/cg_volumetricsmoke.cpp

@@ -145,18 +145,23 @@ void VSS_AddRepulsion(cvssource_t* pA, cvssource_t* pB)
 
 cvssource_t* ClientGameCommandManager::AllocateVSSSource()
 {
-    m_free_vsssources = m_free_vsssources;
+    cvssource_t* pNew;
 
+    if (!m_free_vsssources) {
+        FreeVSSSource(m_active_vsssources.prev);
+    }
+
+    pNew = m_free_vsssources;
     m_free_vsssources = m_free_vsssources->next;
-    memset(m_free_vsssources, 0, sizeof(cvssource_t));
+    memset(pNew, 0, sizeof(cvssource_t));
 
-    m_free_vsssources->next = m_active_vsssources.next;
-    m_free_vsssources->prev = &m_active_vsssources;
+    pNew->next = m_active_vsssources.next;
+    pNew->prev = &m_active_vsssources;
 
-    m_active_vsssources.next->prev = m_free_vsssources;
-    m_active_vsssources.next = m_free_vsssources;
+    m_active_vsssources.next->prev = pNew;
+    m_active_vsssources.next = pNew;
 
-    return m_free_vsssources;
+    return pNew;
 }
 
 void ClientGameCommandManager::FreeVSSSource(cvssource_t* p)
@@ -201,7 +206,7 @@ void ClientGameCommandManager::ResetVSSSources()
     }
 
     m_vsssources = (cvssource_t*)cgi.Malloc(sizeof(cvssource_t) * m_iAllocatedvsssources);
-    memset(m_vsssources, 0, sizeof(sizeof(cvssource_t) * m_iAllocatedvsssources));
+    memset(m_vsssources, 0, sizeof(cvssource_t) * m_iAllocatedvsssources);
 
     m_active_vsssources.next = &m_active_vsssources;
     m_active_vsssources.prev = &m_active_vsssources;

code/client/cl_input.cpp

@@ -242,6 +242,16 @@ void IN_MoveleftDown(void) {IN_KeyDown(&in_moveleft);}
 void IN_MoveleftUp(void) {IN_KeyUp(&in_moveleft);}
 void IN_MoverightDown(void) {IN_KeyDown(&in_moveright);}
 void IN_MoverightUp(void) {IN_KeyUp(&in_moveright);}
+void IN_AttackPrimaryDown(void) { IN_KeyDown(&in_buttons[0]);}
+void IN_AttackPrimaryUp(void) { IN_KeyUp(&in_buttons[0]); }
+void IN_AttackSecondaryDown(void) { IN_KeyDown(&in_buttons[1]); }
+void IN_AttackSecondaryUp(void) { IN_KeyUp(&in_buttons[1]); }
+void IN_UseDown(void) { IN_KeyDown(&in_buttons[3]); }
+void IN_UseUp(void) { IN_KeyUp(&in_buttons[3]); }
+void IN_LeanLeftDown(void) { IN_KeyDown(&in_buttons[4]); }
+void IN_LeanLeftUp(void) { IN_KeyUp(&in_buttons[4]); }
+void IN_LeanRightDown(void) { IN_KeyDown(&in_buttons[5]); }
+void IN_LeanRightUp(void) { IN_KeyUp(&in_buttons[5]); }
 
 void IN_SpeedDown(void) {IN_KeyDown(&in_speed);}
 void IN_SpeedUp(void) {IN_KeyUp(&in_speed);}
@@ -341,22 +351,10 @@ void CL_KeyMove( usercmd_t *cmd ) {
 	int		movespeed;
 	int		forward, side, up;
 
-	//
-	// adjust for speed key / running
-	// the walking flag is to keep animations consistant
-	// even during acceleration and develeration
-	//
-	if ( in_speed.active ^ cl_run->integer ) {
-		movespeed = 127;
-		cmd->buttons |= BUTTON_RUN;
-	} else {
-		cmd->buttons &= ~BUTTON_RUN;
-		movespeed = 64;
-	}
-
 	forward = 0;
 	side = 0;
 	up = 0;
+	movespeed = 127;
 	if ( in_strafe.active ) {
 		side += movespeed * CL_KeyState (&in_right);
 		side -= movespeed * CL_KeyState (&in_left);
@@ -461,16 +459,8 @@ CL_JoystickMove
 =================
 */
 void CL_JoystickMove( usercmd_t *cmd ) {
-	int		movespeed;
 	float	anglespeed;
 
-	if ( in_speed.active ^ cl_run->integer ) {
-		movespeed = 2;
-	} else {
-		movespeed = 1;
-		cmd->buttons |= BUTTON_RUN;
-	}
-
 	if ( in_speed.active ) {
 		anglespeed = 0.001 * cls.frametime * cl_anglespeedkey->value;
 	} else {
@@ -595,7 +585,7 @@ void CL_CmdButtons( usercmd_t *cmd ) {
 	// allow the game to know if any key at all is
 	// currently pressed, even if it isn't bound to anything
 	if ( anykeydown && Key_GetCatcher() == 0) {
-		cmd->buttons |= BUTTON_ANY2;
+		cmd->buttons |= BUTTON_MOUSE;
 	}
 
 	if (anykeydown) {
@@ -865,7 +855,7 @@ void CL_WritePacket( void ) {
 	for ( i = clc.reliableAcknowledge + 1 ; i <= clc.reliableSequence ; i++ ) {
 		MSG_WriteByte( &buf, clc_clientCommand );
 		MSG_WriteLong( &buf, i );
-		MSG_WriteString( &buf, clc.reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+		MSG_WriteScrambledString( &buf, clc.reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
 	}
 
 	// we want to send all the usercmds that were generated in the last
@@ -934,7 +924,7 @@ void CL_WritePacket( void ) {
 	clc.lastPacketSentTime = cls.realtime;
 
 	if ( cl_showSend->integer ) {
-		Com_Printf( "%i ", buf.cursize );
+		Com_Printf( "%zu ", buf.cursize );
 	}
 
 	CL_Netchan_Transmit (&clc.netchan, &buf);
@@ -988,64 +978,76 @@ CL_InitInput
 ============
 */
 void CL_InitInput( void ) {
-	Cmd_AddCommand ("centerview",IN_CenterView);
+	Cmd_AddCommand("centerview", IN_CenterView);
 
-	Cmd_AddCommand ("+moveup",IN_UpDown);
-	Cmd_AddCommand ("-moveup",IN_UpUp);
-	Cmd_AddCommand ("+movedown",IN_DownDown);
-	Cmd_AddCommand ("-movedown",IN_DownUp);
-	Cmd_AddCommand ("+left",IN_LeftDown);
-	Cmd_AddCommand ("-left",IN_LeftUp);
-	Cmd_AddCommand ("+right",IN_RightDown);
-	Cmd_AddCommand ("-right",IN_RightUp);
-	Cmd_AddCommand ("+forward",IN_ForwardDown);
-	Cmd_AddCommand ("-forward",IN_ForwardUp);
-	Cmd_AddCommand ("+back",IN_BackDown);
-	Cmd_AddCommand ("-back",IN_BackUp);
-	Cmd_AddCommand ("+lookup", IN_LookupDown);
-	Cmd_AddCommand ("-lookup", IN_LookupUp);
-	Cmd_AddCommand ("+lookdown", IN_LookdownDown);
-	Cmd_AddCommand ("-lookdown", IN_LookdownUp);
-	Cmd_AddCommand ("+strafe", IN_StrafeDown);
-	Cmd_AddCommand ("-strafe", IN_StrafeUp);
-	Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
-	Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
-	Cmd_AddCommand ("+moveright", IN_MoverightDown);
-	Cmd_AddCommand ("-moveright", IN_MoverightUp);
-	Cmd_AddCommand ("+speed", IN_SpeedDown);
-	Cmd_AddCommand ("-speed", IN_SpeedUp);
-	Cmd_AddCommand ("+attackprimary", IN_Button0Down);
-	Cmd_AddCommand ("-attackprimary", IN_Button0Up);
-	Cmd_AddCommand ("+attacksecondary", IN_Button1Down);
-	Cmd_AddCommand ("-attacksecondary", IN_Button1Up);
-//	Cmd_AddCommand ("+speed", IN_Button2Down);	
-//	Cmd_AddCommand ("-speed", IN_Button2Up);
-	Cmd_AddCommand ("+use", IN_Button3Down);
-	Cmd_AddCommand ("-use", IN_Button3Up);
-	Cmd_AddCommand ("+leanleft", IN_Button4Down);
-	Cmd_AddCommand ("-leanleft", IN_Button4Up);
-	Cmd_AddCommand ("+leanright", IN_Button5Down);
-	Cmd_AddCommand ("-leanright", IN_Button5Up);
-	Cmd_AddCommand ("+button6", IN_Button6Down);
-	Cmd_AddCommand ("-button6", IN_Button6Up);
-	Cmd_AddCommand ("+button7", IN_Button7Down);
-	Cmd_AddCommand ("-button7", IN_Button7Up);
-	Cmd_AddCommand ("+button8", IN_Button8Down);
-	Cmd_AddCommand ("-button8", IN_Button8Up);
-	Cmd_AddCommand ("+button9", IN_Button9Down);
-	Cmd_AddCommand ("-button9", IN_Button9Up);
-	Cmd_AddCommand ("+button10", IN_Button10Down);
-	Cmd_AddCommand ("-button10", IN_Button10Up);
-	Cmd_AddCommand ("+button11", IN_Button11Down);
-	Cmd_AddCommand ("-button11", IN_Button11Up);
-	Cmd_AddCommand ("+button12", IN_Button12Down);
-	Cmd_AddCommand ("-button12", IN_Button12Up);
-	Cmd_AddCommand ("+button13", IN_Button13Down);
-	Cmd_AddCommand ("-button13", IN_Button13Up);
-	Cmd_AddCommand ("+button14", IN_Button14Down);
-	Cmd_AddCommand ("-button14", IN_Button14Up);
-	Cmd_AddCommand ("+mlook", IN_MLookDown);
-	Cmd_AddCommand ("-mlook", IN_MLookUp);
+	Cmd_AddCommand("+moveup", IN_UpDown);
+	Cmd_AddCommand("-moveup", IN_UpUp);
+	Cmd_AddCommand("+movedown", IN_DownDown);
+	Cmd_AddCommand("-movedown", IN_DownUp);
+	Cmd_AddCommand("+left", IN_LeftDown);
+	Cmd_AddCommand("-left", IN_LeftUp);
+	Cmd_AddCommand("+right", IN_RightDown);
+	Cmd_AddCommand("-right", IN_RightUp);
+	Cmd_AddCommand("+forward", IN_ForwardDown);
+	Cmd_AddCommand("-forward", IN_ForwardUp);
+	Cmd_AddCommand("+back", IN_BackDown);
+	Cmd_AddCommand("-back", IN_BackUp);
+	Cmd_AddCommand("+lookup", IN_LookupDown);
+	Cmd_AddCommand("-lookup", IN_LookupUp);
+	Cmd_AddCommand("+lookdown", IN_LookdownDown);
+	Cmd_AddCommand("-lookdown", IN_LookdownUp);
+	Cmd_AddCommand("+strafe", IN_StrafeDown);
+	Cmd_AddCommand("-strafe", IN_StrafeUp);
+	Cmd_AddCommand("+moveleft", IN_MoveleftDown);
+	Cmd_AddCommand("-moveleft", IN_MoveleftUp);
+	Cmd_AddCommand("+moveright", IN_MoverightDown);
+	Cmd_AddCommand("-moveright", IN_MoverightUp);
+	Cmd_AddCommand("+attack", IN_AttackPrimaryDown);
+	Cmd_AddCommand("-attack", IN_AttackPrimaryUp);
+	Cmd_AddCommand("+attackprimary", IN_AttackPrimaryDown);
+	Cmd_AddCommand("-attackprimary", IN_AttackPrimaryUp);
+	Cmd_AddCommand("+attacksecondary", IN_AttackSecondaryDown);
+	Cmd_AddCommand("-attacksecondary", IN_AttackSecondaryUp);
+	Cmd_AddCommand("+use", IN_Button3Down);
+	Cmd_AddCommand("-use", IN_Button3Up);
+	Cmd_AddCommand("+leanleft", IN_LeanLeftDown);
+	Cmd_AddCommand("-leanleft", IN_LeanLeftUp);
+	Cmd_AddCommand("+leanright", IN_LeanRightDown);
+	Cmd_AddCommand("-leanright", IN_LeanRightUp);
+	Cmd_AddCommand("+speed", IN_SpeedUp);
+	Cmd_AddCommand("-speed", IN_SpeedDown);
+	Cmd_AddCommand("+button0", IN_Button0Down);
+	Cmd_AddCommand("-button0", IN_Button0Up);
+	Cmd_AddCommand("+button1", IN_Button1Down);
+	Cmd_AddCommand("-button1", IN_Button1Up);
+	Cmd_AddCommand("+button2", IN_Button2Down);
+	Cmd_AddCommand("-button2", IN_Button2Up);
+	Cmd_AddCommand("+button3", IN_Button3Down);
+	Cmd_AddCommand("-button3", IN_Button3Up);
+	Cmd_AddCommand("+button4", IN_Button4Down);
+	Cmd_AddCommand("-button4", IN_Button4Up);
+	Cmd_AddCommand("+button5", IN_Button5Down);
+	Cmd_AddCommand("-button5", IN_Button5Up);
+	Cmd_AddCommand("+button6", IN_Button6Down);
+	Cmd_AddCommand("-button6", IN_Button6Up);
+	Cmd_AddCommand("+button7", IN_Button7Down);
+	Cmd_AddCommand("-button7", IN_Button7Up);
+	Cmd_AddCommand("+button8", IN_Button8Down);
+	Cmd_AddCommand("-button8", IN_Button8Up);
+	Cmd_AddCommand("+button9", IN_Button9Down);
+	Cmd_AddCommand("-button9", IN_Button9Up);
+	Cmd_AddCommand("+button10", IN_Button10Down);
+	Cmd_AddCommand("-button10", IN_Button10Up);
+	Cmd_AddCommand("+button11", IN_Button11Down);
+	Cmd_AddCommand("-button11", IN_Button11Up);
+	Cmd_AddCommand("+button12", IN_Button12Down);
+	Cmd_AddCommand("-button12", IN_Button12Up);
+	Cmd_AddCommand("+button13", IN_Button13Down);
+	Cmd_AddCommand("-button13", IN_Button13Up);
+	Cmd_AddCommand("+button14", IN_Button14Down);
+	Cmd_AddCommand("-button14", IN_Button14Up);
+	Cmd_AddCommand("+mlook", IN_MLookDown);
+	Cmd_AddCommand("-mlook", IN_MLookUp);
 
 	cl_nodelta = Cvar_Get ("cl_nodelta", "0", 0);
 	cl_debugMove = Cvar_Get ("cl_debugMove", "0", 0);

code/client/cl_keys.cpp

@@ -51,8 +51,8 @@ qboolean alt_down;
 qboolean ctrl_down;
 
 typedef struct {
-	char	*name;
-	int		keynum;
+	const char	*name;
+	int			keynum;
 } keyname_t;
 
 
@@ -466,7 +466,7 @@ void Key_SetCtrlBinding( int keynum, const char *binding ) {
 Key_GetBinding
 ===================
 */
-char *Key_GetBinding( int keynum ) {
+const char *Key_GetBinding( int keynum ) {
 	if ( keynum < 0 || keynum >= K_LASTKEY ) {
 		return "";
 	}
@@ -521,7 +521,7 @@ Key_GetKeysForCommand
 void Key_GetKeysForCommand( const char *command, int *key1, int *key2 ) {
 	int i;
 
-	*key1 = *key2 = 0;
+	*key1 = *key2 = -1;
 
 	for( i = 0; i < K_LASTKEY; i++ ) {
 		if( !keys[ i ].binding ) {

code/client/cl_main.cpp

@@ -32,6 +32,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "../sys/sys_loadlib.h"
 #endif
 
+#include "gcdkeyc.h"
+
 cvar_t	*cl_nodelta;
 cvar_t	*cl_debugMove;
 
@@ -97,6 +99,7 @@ cvar_t	*wombat;
 cvar_t	*cl_r_fullscreen;
 
 cvar_t	*cl_consoleKeys;
+cvar_t	*name;
 
 cvar_t* j_pitch;
 cvar_t* j_yaw;
@@ -218,7 +221,7 @@ CL_ChangeReliableCommand
 ======================
 */
 void CL_ChangeReliableCommand( void ) {
-	int r, index, l;
+	size_t r, index, l;
 
 	r = clc.reliableSequence - (random() * 5);
 	index = clc.reliableSequence & ( MAX_RELIABLE_COMMANDS - 1 );
@@ -246,7 +249,7 @@ Dumps the current net message, prefixed by the length
 ====================
 */
 void CL_WriteDemoMessage ( msg_t *msg, int headerBytes ) {
-	int		len, swlen;
+	size_t		len, swlen;
 
 	// write the packet sequence
 	len = clc.serverMessageSequence;
@@ -325,7 +328,7 @@ void CL_Record_f( void ) {
 	byte		bufData[MAX_MSGLEN];
 	msg_t	buf;
 	int			i;
-	int			len;
+	size_t			len;
 	entityState_t	*ent;
 	entityState_t	nullstate;
 	char		*s;
@@ -557,7 +560,7 @@ CL_ReadDemoMessage
 =================
 */
 void CL_ReadDemoMessage( void ) {
-	int			r;
+	size_t		r;
 	msg_t		buf;
 	byte		bufData[ MAX_MSGLEN ];
 	int			s;
@@ -1058,7 +1061,8 @@ in anyway.
 */
 void CL_RequestAuthorization( void ) {
 	char	nums[64];
-	int		i, j, l;
+	int		i, j;
+	size_t	l;
 	cvar_t	*fs;
 
 	if ( !cls.authorizeServer.port ) {
@@ -1460,8 +1464,6 @@ void CL_Vid_Restart_f( void ) {
 	UI_ResolutionChange();
 
 	cls.rendererRegistered = qfalse;
-	cls.uiStarted = qfalse;
-	cls.cgameStarted = qfalse;
 
 	// unpause so the cgame definately gets a snapshot and renders a frame
 	Com_Unpause();
@@ -1809,7 +1811,11 @@ void CL_CheckForResend( void ) {
 //		}
 		NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "getchallenge");
 		break;
-
+	case CA_AUTHORIZING:
+		// resend the cd key authorization
+		gcd_compute_response(cl_cdkey, Cmd_Argv(1), cls.gcdResponse, CDResponseMethod_REAUTH);
+		NET_OutOfBandPrint(NS_CLIENT, clc.serverAddress, "authorizeThis %s", cls.gcdResponse);
+		break;
 	case CA_CHALLENGING:
 /*
 wombat: sending conect here: an example connect string from MOHAA looks like this:
@@ -1822,7 +1828,11 @@ wombat: sending conect here: an example connect string from MOHAA looks like thi
 		Q_strncpyz( info, Cvar_InfoString( CVAR_USERINFO ), sizeof( info ) );
 		Info_SetValueForKey( info, "protocol", va("%i", PROTOCOL_VERSION ) );
 		Info_SetValueForKey( info, "qport", va("%i", port ) );
-		Info_SetValueForKey( info, "challenge", va("%i", clc.challenge ) );
+		Info_SetValueForKey(info, "challenge", va("%i", clc.challenge));
+		Info_SetValueForKey(info, "version", TARGET_GAME_VERSION);
+#if TARGET_GAME_PROTOCOL >= 15
+		Info_SetValueForKey(info, "clientType", "Breakthrough");
+#endif
 
 		strcpy(data, "connect ");
     // TTimo adding " " around the userinfo string to avoid truncated userinfo on the server
@@ -2081,7 +2091,7 @@ void CL_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
 
 	// challenge from the server we are connecting to
 	if ( !Q_stricmp(c, "challengeResponse") ) {
-		if ( cls.state != CA_CONNECTING ) {
+		if ( cls.state != CA_CONNECTING && cls.state != CA_AUTHORIZING ) {
 			Com_Printf( "Unwanted challenge response received.  Ignored.\n" );
 		} else {
 			// start sending challenge repsonse instead of challenge request packets
@@ -2146,8 +2156,10 @@ void CL_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
 	}
 
 	// cd check
-	if ( !Q_stricmp(c, "keyAuthorize") ) {
-		// we don't use these now, so dump them on the floor
+	if ( !Q_stricmp(c, "getKey") ) {
+		cls.state = CA_AUTHORIZING;
+		gcd_compute_response(cl_cdkey, Cmd_Argv(1), cls.gcdResponse, CDResponseMethod_NEWAUTH);
+		NET_OutOfBandPrint(NS_CLIENT, from, "authorizeThis %s", cls.gcdResponse);
 		return;
 	}
 
@@ -2279,7 +2291,7 @@ qboolean CL_CheckPaused(void)
 	// if paused->modified is set, the cvar has only been changed in
 	// this frame. Keep paused in this frame to ensure the server doesn't
 	// lag behind.
-	if(paused->integer || paused->modified)
+	if(paused->integer)
 		return qtrue;
 
 	return qfalse;
@@ -2294,6 +2306,8 @@ CL_CheckUserinfo
 ==================
 */
 void CL_CheckUserinfo( void ) {
+	char szSanitizedName[MAX_NAME_LENGTH];
+
 	// don't add reliable commands when not yet connected
 	if(cls.state < CA_CHALLENGING)
 		return;
@@ -2305,6 +2319,10 @@ void CL_CheckUserinfo( void ) {
 	// send a reliable userinfo update if needed
 	if(cvar_modifiedFlags & CVAR_USERINFO)
 	{
+		if (Com_SanitizeName(name->string, szSanitizedName)) {
+			Cvar_Set("name", szSanitizedName);
+		}
+
 		cvar_modifiedFlags &= ~CVAR_USERINFO;
 		CL_AddReliableCommand( va("userinfo \"%s\"", Cvar_InfoString( CVAR_USERINFO ) ) );
 	}
@@ -3106,7 +3124,7 @@ void CL_Init( void ) {
 	cl_consoleKeys = Cvar_Get( "cl_consoleKeys", "~ ` 0x7e 0x60", CVAR_ARCHIVE );
 
 	// userinfo
-	Cvar_Get ("name", "UnnamedSoldier", CVAR_USERINFO | CVAR_ARCHIVE );
+	name = Cvar_Get ("name", "UnnamedSoldier", CVAR_USERINFO | CVAR_ARCHIVE );
 	Cvar_Get ("rate", "5000", CVAR_USERINFO | CVAR_ARCHIVE );
 	Cvar_Get ("snaps", "20", CVAR_USERINFO | CVAR_ARCHIVE );
 	Cvar_Get ("password", "", CVAR_USERINFO);
@@ -3299,7 +3317,7 @@ CL_ServerInfoPacket
 void CL_ServerInfoPacket( netadr_t from, msg_t *msg ) {
 	int		i, type;
 	char	info[MAX_INFO_STRING];
-	char*	str;
+	const char*	str;
 	char	*infoString;
 	int		prot;
 
@@ -3495,10 +3513,10 @@ CL_ServerStatusResponse
 ===================
 */
 void CL_ServerStatusResponse( netadr_t from, msg_t *msg ) {
-	char	*s;
+	const char	*s;
 	char	info[MAX_INFO_STRING];
 	int		i, l, score, ping;
-	int		len;
+	size_t	len;
 	serverStatus_t *serverStatus;
 
 	serverStatus = NULL;
@@ -3588,7 +3606,7 @@ CL_LocalServers_f
 ==================
 */
 void CL_LocalServers_f( void ) {
-	char		*message;
+	const char		*message;
 	int			i, j;
 	netadr_t	to;
 
@@ -4257,7 +4275,8 @@ qboolean CL_CDKeyValidate( const char *key, const char *checksum ) {
 	char	ch;
 	byte	sum;
 	char	chs[3];
-	int i, len;
+	int i;
+	size_t len;
 
 	len = strlen(key);
 	if( len != CDKEY_LEN ) {

code/client/cl_parse.cpp

@@ -24,7 +24,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "client.h"
 #include "cl_ui.h"
 
-char *svc_strings[256] = {
+const char *svc_strings[256] = {
 	"svc_bad",
 
 	"svc_nop",
@@ -41,7 +41,7 @@ char *svc_strings[256] = {
 
 msg_t *cl_currentMSG;
 
-void SHOWNET( msg_t *msg, char *s) {
+void SHOWNET( msg_t *msg, const char *s) {
 	if ( cl_shownet->integer >= 2) {
 		Com_Printf ("%3i:%s\n", msg->readcount-1, s);
 	}
@@ -75,8 +75,7 @@ void CL_DeltaEntity (msg_t *msg, clSnapshot_t *frame, int newnum, entityState_t
 	if ( unchanged ) {
 		*state = *old;
 	} else {
-		// FIXME: frametime
-		MSG_ReadDeltaEntity( msg, old, state, newnum, 0.0);
+		MSG_ReadDeltaEntity( msg, old, state, newnum, cls.serverFrameTime);
 	}
 
 	if ( state->number == (MAX_GENTITIES-1) ) {
@@ -117,7 +116,7 @@ void CL_ParsePacketEntities( msg_t *msg, clSnapshot_t *oldframe, clSnapshot_t *n
 
 	while ( 1 ) {
 		// read the entity index number
-		newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+		newnum = MSG_ReadEntityNum(msg);
 
 		if ( newnum == (MAX_GENTITIES-1) ) {
 			break;
@@ -274,11 +273,10 @@ void CL_ParseSnapshot( msg_t *msg ) {
 
 	// read playerinfo
     SHOWNET(msg, "playerstate");
-    // FIXME: frametime
 	if ( old ) {
-		MSG_ReadDeltaPlayerstate( msg, &old->ps, &newSnap.ps, 0.0 );
+		MSG_ReadDeltaPlayerstate( msg, &old->ps, &newSnap.ps, cls.serverFrameTime );
 	} else {
-		MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.ps, 0.0);
+		MSG_ReadDeltaPlayerstate( msg, NULL, &newSnap.ps, cls.serverFrameTime);
 	}
 
 	// read packet entities
@@ -446,6 +444,28 @@ static void CL_ParseServerInfo(void)
 		sizeof(clc.sv_dlURL));
 }
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+char* MSG_ReadGameStateChar(msg_t* msg) {
+	return MSG_ReadScrambledBigString(msg);
+}
+
+float MSG_ReadServerFrameTime(msg_t* msg) {
+	return MSG_ReadFloat(msg);
+}
+
+#else
+
+char* MSG_ReadGameStateChar(msg_t* msg) {
+	return MSG_ReadString(msg);
+}
+
+float MSG_ReadServerFrameTime(msg_t* msg) {
+	return 1.f / atof(Info_ValueForKey(cl.gameState.stringData + cl.gameState.stringOffsets[CS_SYSTEMINFO], "sv_fps"));
+}
+
+#endif
+
 /*
 ==================
 CL_ParseGamestate
@@ -488,7 +508,7 @@ void CL_ParseGamestate( msg_t *msg ) {
 			if ( i < 0 || i >= MAX_CONFIGSTRINGS ) {
 				Com_Error( ERR_DROP, "configstring > MAX_CONFIGSTRINGS" );
 			}
-			s = MSG_ReadString( msg );
+			s = MSG_ReadGameStateChar( msg );
 			len = strlen( s );
 
 			if ( len + 1 + cl.gameState.dataCount > MAX_GAMESTATE_CHARS ) {
@@ -499,7 +519,7 @@ void CL_ParseGamestate( msg_t *msg ) {
 			Com_Memcpy( cl.gameState.stringData + cl.gameState.dataCount, s, len + 1 );
 			cl.gameState.dataCount += len + 1;
 		} else if ( cmd == svc_baseline ) {
-			newnum = MSG_ReadBits( msg, GENTITYNUM_BITS );
+			newnum = MSG_ReadEntityNum(msg);
 			if ( newnum < 0 || newnum >= MAX_GENTITIES ) {
 				Com_Error( ERR_DROP, "Baseline number out of range: %i", newnum );
 			}
@@ -516,6 +536,7 @@ void CL_ParseGamestate( msg_t *msg ) {
 	clc.clientNum = MSG_ReadLong(msg);
 	// read the checksum feed
 	clc.checksumFeed = MSG_ReadLong( msg );
+	cls.serverFrameTime = MSG_ReadServerFrameTime(msg);
 
 	// parse serverId and other cvars
 	CL_SystemInfoChanged();
@@ -727,7 +748,7 @@ void CL_ParseCommandString( msg_t *msg ) {
 	int		index;
 
 	seq = MSG_ReadLong( msg );
-	s = MSG_ReadString( msg );
+	s = MSG_ReadScrambledString( msg );
 
 	// see if we have already executed stored it off
 	if ( clc.serverCommandSequence >= seq ) {
@@ -764,10 +785,9 @@ void CL_ParseLocationprint( msg_t *msg ) {
 
 	x = MSG_ReadShort( msg );
 	y = MSG_ReadShort( msg );
-	string = MSG_ReadString(msg);
+	string = MSG_ReadScrambledString(msg);
 
-	// FIXME
-	//UI_UpdateLocationPrint( x, y, string, 1.0 );
+	UI_UpdateLocationPrint( x, y, string, 1.0 );
 }
 
 /*
@@ -778,10 +798,10 @@ CL_ParseCenterprint
 void CL_ParseCenterprint( msg_t *msg ) {
 	char *string;
 
-	string = MSG_ReadString( msg );
+	string = MSG_ReadScrambledString( msg );
 
 	// FIXME
-	//UI_UpdateCenterPrintf( string, 1.0 );
+	UI_UpdateCenterPrint( string, 1.0 );
 }
 
 /*
@@ -793,7 +813,7 @@ void CL_ParseServerMessage( msg_t *msg ) {
 	int			cmd;
 //Com_Printf( "ParseServerMessage: %i\n", msg->cursize );
 	if ( cl_shownet->integer == 1 ) {
-		Com_Printf ("%i ",msg->cursize);
+		Com_Printf ("%zu ",msg->cursize);
 	} else if ( cl_shownet->integer >= 2 ) {
 		Com_Printf ("------------------\n");
 	}

code/client/cl_ui.cpp

@@ -29,9 +29,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "cl_ui.h"
 
-#if _MSC_VER
-#include <intrin.h>
-#endif
+#include <ctime>
 
 typedef struct {
 	float fadetime;
@@ -877,7 +875,7 @@ Key_GetBindingBuf
 ====================
 */
 static void Key_GetBindingBuf( int keynum, char *buf, int buflen ) {
-	char	*value;
+	const char	*value;
 
 	value = Key_GetBinding( keynum );
 	if ( value ) {
@@ -1119,7 +1117,7 @@ getNewConsole
 ====================
 */
 UIFloatingConsole* getNewConsole() {
-	static constexpr char CONSOLE_NAME[] = PRODUCT_NAME_FULL " - " PRODUCT_VERSION_FULL;
+	static constexpr char CONSOLE_NAME[] = PRODUCT_NAME " console version " PRODUCT_VERSION;
 
 	UIFloatingConsole* console = new UIFloatingConsole;
 	console->Create(NULL, getDefaultConsoleRectangle(), CONSOLE_NAME, UWindowColor, UHudColor);
@@ -1256,6 +1254,10 @@ void UI_PrintConsole( const char *msg )
 			bDeathMessage = qtrue;
 			pColor = &ULightRed;
 			break;
+		case MESSAGE_CHAT_GREEN:
+			bDeathMessage = qtrue;
+			pColor = &UGreen;
+			break;
 		}
 
 		msg++;
@@ -3638,8 +3640,8 @@ void UI_WantsKeyboard() {
 }
 
 struct widgettrans_s {
-	char *src;
-	char *dst;
+	const char *src;
+	const char *dst;
 };
 
 static widgettrans_s s_widgettrans[ 2 ] =
@@ -4885,7 +4887,7 @@ static void SaveConsoleRectangle( void ) {
 	if( !fakk_console->IsMinimized() ) {
 		r = fakk_console->getFrame();
 
-		Cvar_Set( "ui_consoleposition", va( "%d %d %d %d", r.pos.x, r.pos.y, r.size.width, r.size.height ) );
+		Cvar_Set( "ui_consoleposition", va( "%d %d %d %d", (int)r.pos.x, (int)r.pos.y, (int)r.size.width, (int)r.size.height ) );
 		
 		if( wasMinimized ) {
 			fakk_console->ProcessEvent( UIFloatingWindow::W_MinimizePressed );
@@ -4948,7 +4950,7 @@ void UI_RemoveHud_f( void ) {
 
 	if( hud && hudList.ObjectInList( hud ) )
 	{
-		hud->ShowMenu( NULL );
+		hud->ForceHide();
 		hudList.RemoveObject( hud );
 	}
 }
@@ -5439,7 +5441,7 @@ UI_BeginLoadResource
 ====================
 */
 void UI_BeginLoadResource( void ) {
-	uint64_t time = __rdtsc();
+	clock_t time = clock();
 
 	startCountHigh = time >> 32;
 	startCountLow = time;
@@ -5492,7 +5494,7 @@ qboolean UI_IsResourceLoaded( const char *name ) {
 	case 104:
 		return TIKI_FindTikiAnim( name + 1 ) != NULL;
 	case 103:
-		return SkeletorCacheFindFilename( name + 1, NULL ) != NULL;
+		return SkeletorCacheFindFilename( name + 1, NULL );
 	case 107:
 		return S_IsSoundRegistered( name + 1 );
 	case 110:

code/client/cl_uidmbox.cpp

@@ -189,11 +189,13 @@ void UIDMBox::RemoveTopItem( void )
 {
 	int i;
 
-	for (i = 0; i < m_numitems - 1; i++) {
-		m_items[i] = m_items[i + 1];
-	}
+	if (m_numitems > 0) {
+		for (i = 0; i < m_numitems - 1; i++) {
+			m_items[i] = m_items[i + 1];
+		}
 
-	m_numitems--;
+		m_numitems--;
+	}
 }
 
 str UIDMBox::CalculateBreaks( UIFont *font, str text, float max_width )
@@ -291,19 +293,27 @@ void UIDMBox::Print( const char *text )
 
 	m_items[m_numitems].flags = 0;
 
-	if (*text == 2)
+	if (*text == MESSAGE_CHAT_WHITE)
 	{
 		m_items[m_numitems].color = UGrey;
 		m_items[m_numitems].font = m_fontbold;
-		m_items[m_numitems].flags |= GMBOX_ITEM_FLAG_BOLD;
+		m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_BOLD;
 
 		text1 = text + 1;
 	}
-	else if (*text == 4)
+	else if (*text == MESSAGE_CHAT_RED)
 	{
 		m_items[m_numitems].color = ULightRed;
 		m_items[m_numitems].font = m_fontbold;
-		m_items[m_numitems].flags |= GMBOX_ITEM_FLAG_BOLD;
+		m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_BOLD;
+
+		text1 = text + 1;
+	}
+	else if (*text == MESSAGE_CHAT_GREEN)
+	{
+		m_items[m_numitems].color = UGreen;
+		m_items[m_numitems].font = m_fontbold;
+		m_items[m_numitems].flags |= DMBOX_ITEM_FLAG_BOLD;
 
 		text1 = text + 1;
 	}

code/client/cl_uigmbox.cpp

@@ -186,11 +186,13 @@ void UIGMBox::RemoveTopItem( void )
 {
 	int i;
 
-	for (i = 0; i < m_numitems - 1; i++) {
-		m_items[i] = m_items[i + 1];
-	}
+	if (m_numitems > 0) {
+		for (i = 0; i < m_numitems - 1; i++) {
+			m_items[i] = m_items[i + 1];
+		}
 
-	m_numitems--;
+		m_numitems--;
+	}
 }
 
 str UIGMBox::CalculateBreaks( UIFont *font, str text, float max_width )

code/client/cl_uisoundpicker.h

@@ -29,8 +29,8 @@ public:
 
 	SoundPickerClass();
 
-	void	FileSelected( str &currentDirectory, str &partialName, str &fullname );
-	void	FileChosen( str &currentDirectory, str &partialName, str &fullname );
+	void	FileSelected( str &currentDirectory, str &partialName, str &fullname ) override;
+	void	FileChosen( str &currentDirectory, str &partialName, str &fullname ) override;
 };
 
 #endif /* __CL_UISOUNDPICKER_H__ */

code/client/cl_uistd.cpp

@@ -519,7 +519,8 @@ void UIFakkLabel::DrawStatbar( float frac )
 				}
 				break;
 			}
-
+			default:
+				break;
 			}
 		}
 		else
@@ -574,6 +575,8 @@ void UIFakkLabel::DrawStatbar( float frac )
 				}
 				break;
 			}
+			default:
+				break;
 			}
 		}
 	}
@@ -603,6 +606,8 @@ void UIFakkLabel::DrawStatbar( float frac )
 				1.0
 			);
 			break;
+		default:
+			break;
 		}
 	}
 }

code/client/cl_uiview3d.h

@@ -59,7 +59,7 @@ public:
 	void			UpdateLocationPrint( int x, int y, const char *s, float alpha );
 	qboolean		LetterboxActive( void );
 	void			InitSubtitle( void );
-	void			FrameInitialized( void );
+	void			FrameInitialized( void ) override;
 	virtual void	Pressed( Event *ev );
 };
 

code/client/client.h

@@ -303,6 +303,7 @@ typedef struct {
 
 	int			framecount;
 	int			frametime;			// msec since last frame
+	float		serverFrameTime;
 
 	int			realtime;			// ignores pause
 	int			realFrametime;		// ignoring pause, so console always works
@@ -345,6 +346,11 @@ typedef struct {
 	hdelement_t HudDrawElements[ MAX_HUDDRAW_ELEMENTS ];
 	clientAnim_t anim;
 	stopWatch_t stopwatch;
+	void* savedCgameState;
+	int savedCgameStateSize;
+	char gcdResponse[73];
+	int unknown3_0;
+	int currentRate;
 	qhandle_t	charSetShader;
 	qhandle_t	whiteShader;
 	qhandle_t	consoleShader;

code/client/keys.h

@@ -42,7 +42,7 @@ extern	int			chat_playerNum;
 int Key_StringToKeynum( const char *str );
 void Key_WriteBindings( fileHandle_t f );
 void Key_SetBinding( int keynum, const char *binding );
-char *Key_GetBinding( int keynum );
+const char *Key_GetBinding( int keynum );
 qboolean Key_IsDown( int keynum );
 qboolean Key_GetOverstrikeMode( void );
 void Key_SetOverstrikeMode( qboolean state );

code/game/barrels.cpp

@@ -238,11 +238,11 @@ void BarrelObject::BarrelThink
 
 					if( m_iBarrelType == BARREL_OIL )
 					{
-						gi.MSG_StartCGM( 15 );
+						gi.MSG_StartCGM(CGM_MAKE_EFFECT_1);
 					}
 					else
 					{
-						gi.MSG_StartCGM( 19 );
+						gi.MSG_StartCGM(CGM_MAKE_EFFECT_5);
 					}
 
 					m_fFluidAmount -= 1.0f;
@@ -254,11 +254,11 @@ void BarrelObject::BarrelThink
 
 					if( m_iBarrelType == BARREL_OIL )
 					{
-						gi.MSG_StartCGM( 16 );
+						gi.MSG_StartCGM(CGM_MAKE_EFFECT_2);
 					}
 					else
 					{
-						gi.MSG_StartCGM( 20 );
+						gi.MSG_StartCGM(CGM_MAKE_EFFECT_6);
 					}
 
 					m_fFluidAmount -= 0.75f;
@@ -271,11 +271,11 @@ void BarrelObject::BarrelThink
 
 				if( m_iBarrelType == BARREL_OIL )
 				{
-					gi.MSG_StartCGM( 17 );
+					gi.MSG_StartCGM(CGM_MAKE_EFFECT_3);
 				}
 				else
 				{
-					gi.MSG_StartCGM( 21 );
+					gi.MSG_StartCGM(CGM_MAKE_EFFECT_7);
 				}
 
 				m_fFluidAmount -= 0.5f;
@@ -294,11 +294,11 @@ void BarrelObject::BarrelThink
 
 			if( m_iBarrelType == BARREL_OIL )
 			{
-				gi.MSG_StartCGM( 17 );
+				gi.MSG_StartCGM(CGM_MAKE_EFFECT_3);
 			}
 			else
 			{
-				gi.MSG_StartCGM( 21 );
+				gi.MSG_StartCGM(CGM_MAKE_EFFECT_7);
 			}
 
 			gi.MSG_WriteCoord( m_vLeaks[ i ][ 0 ] );
@@ -506,18 +506,18 @@ void BarrelObject::BarrelDamaged
 			gi.SetBroadcastVisible( vHitPos, vHitPos );
 
 			if( m_iBarrelType == BARREL_OIL )
-				gi.MSG_StartCGM( 18 );
+				gi.MSG_StartCGM(CGM_MAKE_EFFECT_4);
 			else
-				gi.MSG_StartCGM( 22 );
+				gi.MSG_StartCGM(CGM_MAKE_EFFECT_8);
 		}
 		else
 		{
 			gi.SetBroadcastVisible( vHitPos, vHitPos );
 
 			if( m_iBarrelType == BARREL_OIL )
-				gi.MSG_StartCGM( 17 );
+				gi.MSG_StartCGM(CGM_MAKE_EFFECT_3);
 			else
-				gi.MSG_StartCGM( 21 );
+				gi.MSG_StartCGM(CGM_MAKE_EFFECT_7);
 		}
 
 		gi.MSG_WriteCoord( vHitPos[ 0 ] );

code/game/bg_public.h

@@ -66,6 +66,34 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define	CS_MOTD					4		// g_motd string for server message of the day
 #define	CS_WARMUP				5		// server time when the match will be restarted
 
+#if TARGET_GAME_PROTOCOL >= 15
+#define	CS_MUSIC				6		// MUSIC_NewSoundtrack(cs)
+#define CS_FOGINFO				7		// cg.farplane_cull cg.farplane_distance cg.farplane_color[3]
+#define CS_SKYINFO				8		// cg.sky_alpha cg.sky_portal
+
+#define	CS_GAME_VERSION			9
+#define	CS_LEVEL_START_TIME		10		// so the timer only shows the current level cgs.levelStartTime
+
+#define CS_CURRENT_OBJECTIVE	11
+
+#define CS_RAIN_DENSITY			12		// cg.rain
+#define CS_RAIN_SPEED			13
+#define CS_RAIN_SPEEDVARY		14
+#define CS_RAIN_SLANT			15
+#define CS_RAIN_LENGTH			16
+#define CS_RAIN_MINDIST			17
+#define CS_RAIN_WIDTH			18
+#define CS_RAIN_SHADER			19
+#define CS_RAIN_NUMSHADERS		20
+
+#define CS_VOTE_TIME			21
+#define CS_VOTE_STRING			22
+#define CS_VOTE_YES				23
+#define CS_VOTE_NO				24
+#define CS_VOTE_UNDECIDED		25
+
+#else
+
 #define	CS_MUSIC				8		// MUSIC_NewSoundtrack(cs)
 #define CS_FOGINFO				9		// cg.farplane_cull cg.farplane_distance cg.farplane_color[3]
 #define CS_SKYINFO				10		// cg.sky_alpha cg.sky_portal
@@ -85,6 +113,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define CS_RAIN_SHADER			21
 #define CS_RAIN_NUMSHADERS		22
 
+#endif
+
 #define CS_MATCHEND				26		// cgs.matchEndTime
 
 #define	CS_MODELS				32
@@ -98,11 +128,11 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define CS_PLAYERS				(CS_LIGHTSTYLES+MAX_LIGHTSTYLES) // 1684
 
 #define CS_WEAPONS				(CS_PLAYERS+MAX_CLIENTS) // su44 was here
-#define CS_TEAMS				1876
-#define CS_GENERAL_STRINGS		1877
-#define CS_SPECTATORS			1878
-#define CS_ALLIES				1879
-#define CS_AXIS					1880
+#define CS_TEAMS				1892
+#define CS_GENERAL_STRINGS		1893
+#define CS_SPECTATORS			1894
+#define CS_ALLIES				1895
+#define CS_AXIS					1896
 #define CS_SOUNDTRACK			1881
 
 #define CS_TEAMINFO				1
@@ -122,6 +152,10 @@ typedef enum {
 	GT_TEAM,			// team deathmatch
 	GT_TEAM_ROUNDS,
 	GT_OBJECTIVE,
+	// Team Assault game mode
+	GT_TOW,
+	// Team Tactics game mode
+	GT_LIBERATION,
 	GT_MAX_GAME_TYPE
 } gametype_t;
 
@@ -231,6 +265,28 @@ typedef enum {
 #define	PMF_LEVELEXIT			(1<<20)		// use camera view instead of ps view
 #endif
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+// moh pm_flags
+#define	PMF_DUCKED				(1<<0)
+#define	PMF_VIEW_PRONE			(1<<1)
+#define PMF_SPECTATING			(1<<2)
+#define	PMF_RESPAWNED			(1<<3)
+#define	PMF_NO_PREDICTION		(1<<4)
+#define	PMF_FROZEN				(1<<5)
+#define	PMF_INTERMISSION		(1<<6)
+#define PMF_SPECTATE_FOLLOW		(1<<7)
+#define	PMF_CAMERA_VIEW			(1<<7)		// use camera view instead of ps view
+#define	PMF_NO_MOVE				(1<<8)
+#define PMF_VIEW_DUCK_RUN		(1<<9)
+#define	PMF_VIEW_JUMP_START		(1<<10)
+#define	PMF_LEVELEXIT			(1<<11)
+#define	PMF_NO_GRAVITY			(1<<12)
+#define	PMF_NO_HUD				(1<<13)
+#define	PMF_UNKNOWN				(1<<14)
+
+#else
+
 // moh pm_flags
 #define	PMF_DUCKED				(1<<0)
 #define	PMF_VIEW_PRONE			(1<<1)
@@ -249,6 +305,8 @@ typedef enum {
 #define	PMF_NO_HUD				(1<<15)
 #define	PMF_UNKNOWN				(1<<16)
 
+#endif
+
 // moveposflags
 #define MPF_POSITION_STANDING	(1<<0)
 #define MPF_POSITION_CROUCHING	(1<<1)
@@ -395,6 +453,12 @@ typedef enum {
 #define EF_AXIS				0x00000100		// su44: this player is in axis team
 #define EF_ANY_TEAM			(EF_ALLIES | EF_AXIS)
 #define EF_DEAD				0x00000200		// don't draw a foe marker over players with EF_DEAD
+//
+// Team assault flags
+//
+#define EF_PLAYER_IN_MENU		0x00000400		// Player is in menu
+#define EF_PLAYER_TALKING		0x00000800		// Player is talking
+#define EF_PLAYER_ARTILLERY		0x00002000		// Player is using an artillery
 
 
 // su44: q3 remnants
@@ -528,6 +592,15 @@ extern const char *means_of_death_strings[];
 #define DF_NO_DROP_WEAPONS    (1<<16)
 #define DF_NO_FOOTSTEPS			(1<<17)
 
+#define DF_WEAPON_LANDMINE_ALWAYS		(1<<21)
+#define DF_WEAPON_NO_RIFLE				(1<<22)
+#define DF_WEAPON_NO_SNIPER				(1<<23)
+#define DF_WEAPON_NO_SMG				(1<<24)
+#define DF_WEAPON_NO_MG					(1<<25)
+#define DF_WEAPON_NO_ROCKET				(1<<26)
+#define DF_WEAPON_NO_SHOTGUN			(1<<27)
+#define DF_WEAPON_NO_LANDMINE			(1<<28)
+
 #define DM_FLAG( flag ) ( g_gametype->integer && ( ( int )dmflags->integer & ( flag ) ) )
 
 // content masks
@@ -612,7 +685,165 @@ typedef enum {
 void	BG_EvaluateTrajectoryDelta( const trajectory_t *tr, int atTime, vec3_t result );
 
 void	BG_PlayerStateToEntityState( playerState_t *ps, entityState_t *s, qboolean snap );
-void	BG_PlayerStateToEntityStateExtraPolate( playerState_t *ps, entityState_t *s, int time, qboolean snap );
+void	BG_PlayerStateToEntityStateExtraPolate(playerState_t* ps, entityState_t* s, int time, qboolean snap);
+
+#if TARGET_GAME_PROTOCOL >= 15
+
+enum vmAnim_e {
+	VM_ANIM_DISABLED,
+	VM_ANIM_IDLE,
+	VM_ANIM_CHARGE,
+	VM_ANIM_FIRE,
+	VM_ANIM_FIRE_SECONDARY,
+	VM_ANIM_RECHAMBER,
+	VM_ANIM_RELOAD,
+	VM_ANIM_RELOAD_SINGLE,
+	VM_ANIM_RELOAD_END,
+	VM_ANIM_PULLOUT,
+	VM_ANIM_PUTAWAY,
+	VM_ANIM_LADDERSTEP,
+	VM_ANIM_IDLE_0,
+	VM_ANIM_IDLE_1,
+	VM_ANIM_IDLE_2,
+};
+
+enum cg_message_e {
+	CGM_NONE,
+	CGM_BULLET_1,
+	CGM_BULLET_2,
+	CGM_BULLET_3,
+	CGM_BULLET_4,
+	CGM_BULLET_5,
+	CGM_BULLET_6,
+	CGM_BULLET_7,
+	CGM_BULLET_8,
+	CGM_BULLET_9,
+	CGM_BULLET_10,
+	CGM_BULLET_11,
+	CGM_MELEE_IMPACT,
+	CGM_EXPLOSION_EFFECT_1,
+	CGM_EXPLOSION_EFFECT_2,
+	CGM_EXPLOSION_EFFECT_3,
+	CGM_EXPLOSION_EFFECT_4,
+	CGM_PADDING_1,
+	CGM_MAKE_EFFECT_1,
+	CGM_MAKE_EFFECT_2,
+	CGM_MAKE_EFFECT_3,
+	CGM_MAKE_EFFECT_4,
+	CGM_MAKE_EFFECT_5,
+	CGM_MAKE_EFFECT_6,
+	CGM_MAKE_EFFECT_7,
+	CGM_MAKE_EFFECT_8,
+	CGM_MAKE_CRATE_DEBRIS,
+	CGM_MAKE_WINDOW_DEBRIS,
+	CGM_BULLET_NO_BARREL_1,
+	CGM_BULLET_NO_BARREL_2,
+	CGM_HUDDRAW_SHADER,
+	CGM_HUDDRAW_ALIGN,
+	CGM_HUDDRAW_RECT,
+	CGM_HUDDRAW_VIRTUALSIZE,
+	CGM_HUDDRAW_COLOR,
+	CGM_HUDDRAW_ALPHA,
+	CGM_HUDDRAW_STRING,
+	CGM_HUDDRAW_FONT,
+	CGM_NOTIFY_KILL,
+	CGM_NOTIFY_HIT,
+	CGM_VOICE_CHAT,
+	CGM_UNKNOWN_1,
+};
+
+#else
+
+enum vmAnim_e {
+	VM_ANIM_IDLE,
+	VM_ANIM_CHARGE,
+	VM_ANIM_FIRE,
+	VM_ANIM_FIRE_SECONDARY,
+	VM_ANIM_RECHAMBER,
+	VM_ANIM_RELOAD,
+	VM_ANIM_RELOAD_SINGLE,
+	VM_ANIM_RELOAD_END,
+	VM_ANIM_PULLOUT,
+	VM_ANIM_PUTAWAY,
+	VM_ANIM_LADDERSTEP,
+	VM_ANIM_IDLE_0,
+	VM_ANIM_IDLE_1,
+	VM_ANIM_IDLE_2,
+	VM_ANIM_DISABLED,
+};
+
+enum cg_message_e {
+	CGM_NONE,
+	CGM_BULLET_1,
+	CGM_BULLET_2,
+	CGM_BULLET_3,
+	CGM_BULLET_4,
+	CGM_BULLET_5,
+	CGM_BULLET_6,
+	CGM_BULLET_7,
+	CGM_BULLET_8,
+	CGM_BULLET_9,
+	CGM_BULLET_10,
+	CGM_MELEE_IMPACT,
+	CGM_EXPLOSION_EFFECT_1,
+	CGM_EXPLOSION_EFFECT_2,
+	CGM_PADDING_1,
+	CGM_MAKE_EFFECT_1,
+	CGM_MAKE_EFFECT_2,
+	CGM_MAKE_EFFECT_3,
+	CGM_MAKE_EFFECT_4,
+	CGM_MAKE_EFFECT_5,
+	CGM_MAKE_EFFECT_6,
+	CGM_MAKE_EFFECT_7,
+	CGM_MAKE_EFFECT_8,
+	CGM_MAKE_CRATE_DEBRIS,
+	CGM_MAKE_WINDOW_DEBRIS,
+	CGM_BULLET_NO_BARREL_1,
+	CGM_BULLET_NO_BARREL_2,
+	CGM_HUDDRAW_SHADER,
+	CGM_HUDDRAW_ALIGN,
+	CGM_HUDDRAW_RECT,
+	CGM_HUDDRAW_VIRTUALSIZE,
+	CGM_HUDDRAW_COLOR,
+	CGM_HUDDRAW_ALPHA,
+	CGM_HUDDRAW_STRING,
+	CGM_HUDDRAW_FONT,
+	CGM_NOTIFY_KILL,
+	CGM_NOTIFY_HIT,
+	CGM_VOICE_CHAT,
+};
+
+#endif
+
+/*
+#define CGM_HUDDRAW_SHADER			27
+#define CGM_HUDDRAW_ALIGN			28
+#define CGM_HUDDRAW_RECT			29
+#define CGM_HUDDRAW_VIRTUALSIZE		30
+#define CGM_HUDDRAW_COLOR			31
+#define CGM_HUDDRAW_ALPHA			32
+#define CGM_HUDDRAW_STRING			33
+#define CGM_HUDDRAW_FONT			34
+#define CGM_HUDDRAW_TIMER			38
+#define CGM_HUDDRAW_3D				39
+#define CGM_HUDDRAW_BREAK3D			40
+#define CGM_HUDDRAW_FADE			41
+#define CGM_HUDDRAW_MOVE			42
+#define CGM_HUDDRAW_SCALE			43
+#define CGM_VIEWMODELANIM			44
+#define CGM_VIEWMODELPREFIX			45
+#define CGM_MODHEIGHTFLOAT			46
+#define CGM_SETVMASPEED				47
+#define CGM_HINTSTRING				48
+#define CGM_PLAYLOCALSOUND			49
+#define CGM_SETLOCALSOUNDRATE		50
+#define CGM_STOPLOCALSOUND			51
+#define CGM_HUDDRAW_RECTX			52
+#define CGM_HUDDRAW_RECTY			53
+#define CGM_HUDDRAW_RECTWH			54
+#define CGM_REPLICATION				55
+#define CGM_HUDDRAW_DELETE			56
+*/
 
 #ifdef __cplusplus
 }

code/game/characterstate.cpp

@@ -422,7 +422,7 @@ void State::ParseAndProcessCommand
    {
    int      argc;
 	const    char *argv[ MAX_COMMANDS ];
-	char     args[ MAX_COMMANDS ][ MAXTOKEN ];
+	char     args[ MAX_COMMANDS ][ SCRIPT_MAXTOKEN ];
    Script   script;
    Event    *event;
 

code/game/crateobject.cpp

@@ -465,7 +465,7 @@ void CrateObject::CrateKilled
 
 	// Tell clients around that a crate is destroyed
 	gi.SetBroadcastVisible( origin, origin );
-	gi.MSG_StartCGM( 23 );
+	gi.MSG_StartCGM(CGM_MAKE_CRATE_DEBRIS);
 		gi.MSG_WriteCoord( vCenter[ 0 ] );
 		gi.MSG_WriteCoord( vCenter[ 1 ] );
 		gi.MSG_WriteCoord( vCenter[ 2 ] );

code/game/entity.cpp

@@ -6912,12 +6912,15 @@ void Entity::ProcessHint(gentity_t* client, bool bShow)
 		{
 			if (sv_reborn->integer)
 			{
+				// FIXME: delete
+				/*
 				gi.MSG_SetClient(client - g_entities);
 
 				// Send the hint string once
 				gi.MSG_StartCGM(CGM_HINTSTRING);
 					gi.MSG_WriteString(m_HintString);
 				gi.MSG_EndCGM();
+				*/
 			}
 		}
 		else

code/game/g_public.h

@@ -241,7 +241,7 @@ typedef struct gameImport_s
 	void ( *AddCommand )( const char *cmdName, xcommand_t cmdFunction );
 	int ( *FS_ReadFile )( const char *qpath, void **buffer, qboolean quiet );
 	void ( *FS_FreeFile )( void *buffer );
-	size_t( *FS_WriteFile )( const char *qpath, const void *buffer, size_t size );
+	int ( *FS_WriteFile )( const char *qpath, const void *buffer, int size );
 	fileHandle_t ( *FS_FOpenFileWrite )( const char *fileName );
 	fileHandle_t ( *FS_FOpenFileAppend )( const char *fileName );
 	const char *( *FS_PrepFileWrite )( const char *fileName );

code/game/hud.cpp

@@ -503,6 +503,7 @@ Hud::~Hud()
 		SetNon3D();
 	}
 
+	/*
 #ifdef GAME_DLL
 	SetBroadcast();
 
@@ -510,6 +511,7 @@ Hud::~Hud()
 		WriteNumber();
 	gi.MSG_EndCGM();
 #endif
+*/
 
 	hudElements.RemoveObject( this );
 }
@@ -952,7 +954,9 @@ void Hud::FadeOverTime( float time )
 
 	fade_alpha_start = alpha;
 	fade_alpha_target = alpha;
-
+	
+	// FIXME: delete
+	/*
 #ifdef GAME_DLL
 	SetBroadcast();
 
@@ -961,6 +965,7 @@ void Hud::FadeOverTime( float time )
 		gi.MSG_WriteFloat( time );
 	gi.MSG_EndCGM();
 #endif
+*/
 }
 
 void Hud::MoveOverTime( float time )
@@ -982,6 +987,7 @@ void Hud::MoveOverTime( float time )
 	fade_move_x_target = x;
 	fade_move_y_target = y;
 
+	/*
 #ifdef GAME_DLL
 	SetBroadcast();
 
@@ -990,6 +996,7 @@ void Hud::MoveOverTime( float time )
 		gi.MSG_WriteFloat( time );
 	gi.MSG_EndCGM();
 #endif
+*/
 }
 
 void Hud::Refresh( int clientNumber )
@@ -1092,6 +1099,7 @@ void Hud::Refresh( int clientNumber )
 		{
 			SetBroadcast();
 
+			/*
 			gi.MSG_StartCGM( CGM_HUDDRAW_3D );
 				WriteNumber();
 				gi.MSG_WriteCoord( org[ 0 ] );
@@ -1103,16 +1111,19 @@ void Hud::Refresh( int clientNumber )
 				gi.MSG_WriteBits( !!always_show, 1 );
 				gi.MSG_WriteBits( !!depth, 1 );
 			gi.MSG_EndCGM();
+			*/
 		}
 
 		if( fade_alpha )
 		{
 			SetBroadcast();
 
+			/*
 			gi.MSG_StartCGM( CGM_HUDDRAW_FADE );
 				WriteNumber();
 				gi.MSG_WriteFloat( fade_alpha_current );
 			gi.MSG_EndCGM();
+			*/
 
 			SetBroadcast();
 
@@ -1126,6 +1137,7 @@ void Hud::Refresh( int clientNumber )
 		{
 			SetBroadcast();
 
+			/*
 			gi.MSG_StartCGM( CGM_HUDDRAW_MOVE );
 				WriteNumber();
 				gi.MSG_WriteFloat( fade_move_current );
@@ -1138,10 +1150,12 @@ void Hud::Refresh( int clientNumber )
 				gi.MSG_WriteShort( ( short )fade_move_x_target );
 				gi.MSG_WriteShort( ( short )fade_move_y_target );
 			gi.MSG_EndCGM();
+			*/
 		}
 
 		if( fade_timer_flags & TIMER_ACTIVE )
 		{
+			/*
 			SetBroadcast();
 
 			gi.MSG_StartCGM( CGM_HUDDRAW_TIMER );
@@ -1156,6 +1170,7 @@ void Hud::Refresh( int clientNumber )
 				}
 
 			gi.MSG_EndCGM();
+			*/
 		}
 	}
 #endif
@@ -1182,7 +1197,8 @@ void Hud::ScaleOverTime( float time, short w, short h )
 	fade_scale_w_target = w;
 	fade_scale_h_target = h;
 
-#ifdef GAME_DLL
+	// FIXME: delete
+/*
 	width = w;
 	height = h;
 
@@ -1194,7 +1210,7 @@ void Hud::ScaleOverTime( float time, short w, short h )
 		gi.MSG_WriteShort( w );
 		gi.MSG_WriteShort( h );
 	gi.MSG_EndCGM();
-#endif
+*/
 }
 
 #ifdef GAME_DLL
@@ -1235,6 +1251,7 @@ void Hud::Set3D( Vector vector_or_offset, qboolean alwaysOnScreen, qboolean hasD
 
 	isDimensional = true;
 
+	/*
 #ifdef GAME_DLL
 	SetBroadcast();
 
@@ -1250,19 +1267,20 @@ void Hud::Set3D( Vector vector_or_offset, qboolean alwaysOnScreen, qboolean hasD
 		gi.MSG_WriteBits( !!hasDepth, 1 );
 	gi.MSG_EndCGM();
 #endif
+*/
 }
-
 void Hud::SetNon3D()
 {
 	isDimensional = false;
 
-#ifdef GAME_DLL
+	// FIXME?
+/*
 	SetBroadcast();
 
 	gi.MSG_StartCGM( CGM_HUDDRAW_BREAK3D );
 		WriteNumber();
 	gi.MSG_EndCGM();
-#endif
+*/
 }
 
 void Hud::SetAlignX( hudAlign_t align )
@@ -1418,29 +1436,18 @@ void Hud::SetRectX( short value )
 #ifdef GAME_DLL
 	SetBroadcast();
 
-	if( sv_reborn->integer )
-	{
-		gi.MSG_StartCGM( CGM_HUDDRAW_RECTX );
-			WriteNumber();
-			gi.MSG_WriteShort( ( short )value );
-		gi.MSG_EndCGM();
-	}
-	else
-	{
-		gi.MSG_StartCGM( CGM_HUDDRAW_RECT );
-			WriteNumber();
-			gi.MSG_WriteShort( ( short )fade_move_x_target );
-			gi.MSG_WriteShort( ( short )fade_move_y_target );
-			gi.MSG_WriteShort( ( short )width );
-			gi.MSG_WriteShort( ( short )height );
-		gi.MSG_EndCGM();
-	}
+	gi.MSG_StartCGM(CGM_HUDDRAW_RECT);
+		WriteNumber();
+		gi.MSG_WriteShort((short)fade_move_x_target);
+		gi.MSG_WriteShort((short)fade_move_y_target);
+		gi.MSG_WriteShort((short)width);
+		gi.MSG_WriteShort((short)height);
+	gi.MSG_EndCGM();
 #endif
 }
 
 void Hud::SetRectY( short value )
 {
-//#ifdef CGAME_DLL
 	if( fade_move_y_first )
 	{
 		fade_move_y_target = value;
@@ -1451,30 +1458,17 @@ void Hud::SetRectY( short value )
 		y = value;
 		fade_move = false;
 	}
-//#else
-//	y = value;
-//#endif
 
 #ifdef GAME_DLL
 	SetBroadcast();
 
-	if( sv_reborn->integer )
-	{
-		gi.MSG_StartCGM( CGM_HUDDRAW_RECTY );
-			WriteNumber();
-			gi.MSG_WriteShort( ( short )value );
-		gi.MSG_EndCGM();
-	}
-	else
-	{
-		gi.MSG_StartCGM( CGM_HUDDRAW_RECT );
-			WriteNumber();
-			gi.MSG_WriteShort( ( short )fade_move_x_target );
-			gi.MSG_WriteShort( ( short )fade_move_y_target );
-			gi.MSG_WriteShort( ( short )width );
-			gi.MSG_WriteShort( ( short )height );
-		gi.MSG_EndCGM();
-	}
+	gi.MSG_StartCGM(CGM_HUDDRAW_RECT);
+		WriteNumber();
+		gi.MSG_WriteShort((short)fade_move_x_target);
+		gi.MSG_WriteShort((short)fade_move_y_target);
+		gi.MSG_WriteShort((short)width);
+		gi.MSG_WriteShort((short)height);
+	gi.MSG_EndCGM();
 #endif
 }
 
@@ -1519,24 +1513,13 @@ void Hud::SetShader( const char * s, float w, float h )
 #ifdef GAME_DLL
 	SetBroadcast();
 
-	if( sv_reborn->integer )
-	{
-		gi.MSG_StartCGM( CGM_HUDDRAW_RECTWH );
-			WriteNumber();
-			gi.MSG_WriteShort( ( short )width );
-			gi.MSG_WriteShort( ( short )height );
-		gi.MSG_EndCGM();
-	}
-	else
-	{
-		gi.MSG_StartCGM( CGM_HUDDRAW_RECT );
-			WriteNumber();
-			gi.MSG_WriteShort( ( short )x );
-			gi.MSG_WriteShort( ( short )y );
-			gi.MSG_WriteShort( ( short )width );
-			gi.MSG_WriteShort( ( short )height );
-		gi.MSG_EndCGM();
-	}
+	gi.MSG_StartCGM(CGM_HUDDRAW_RECT);
+	WriteNumber();
+	gi.MSG_WriteShort((short)x);
+	gi.MSG_WriteShort((short)y);
+	gi.MSG_WriteShort((short)width);
+	gi.MSG_WriteShort((short)height);
+	gi.MSG_EndCGM();
 
 	SetBroadcast();
 
@@ -1586,7 +1569,8 @@ void Hud::SetTimer( float time, float fade_at_time )
 
 	fade_timer_flags = TIMER_ACTIVE;
 
-#ifdef GAME_DLL
+	// FIXME...
+/*
 	SetBroadcast();
 
 	gi.MSG_StartCGM( CGM_HUDDRAW_TIMER );
@@ -1595,7 +1579,7 @@ void Hud::SetTimer( float time, float fade_at_time )
 		gi.MSG_WriteFloat( fade_at_time );
 		gi.MSG_WriteBits( 0, 1 );
 	gi.MSG_EndCGM();
-#endif
+*/
 }
 
 void Hud::SetTimerUp( float time, float fade_at_time )
@@ -1612,6 +1596,7 @@ void Hud::SetTimerUp( float time, float fade_at_time )
 
 	fade_timer_flags = TIMER_ACTIVE | TIMER_UP;
 
+	/*
 #ifdef GAME_DLL
 	SetBroadcast();
 
@@ -1622,6 +1607,7 @@ void Hud::SetTimerUp( float time, float fade_at_time )
 		gi.MSG_WriteBits( 1, 1 );
 	gi.MSG_EndCGM();
 #endif
+*/
 }
 
 void Hud::SetVirtualSize( qboolean v )

code/game/huddraw.cpp

@@ -38,7 +38,7 @@ void HudWriteNumber( int num )
 void HudDrawShader( int info, const char *name )
 {
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x1B);
+	gi.MSG_StartCGM(CGM_HUDDRAW_SHADER);
 	HudWriteNumber( info );		// c = info
 	gi.MSG_WriteString(name);		// s = name (shader_name)
 	gi.MSG_EndCGM();
@@ -47,7 +47,7 @@ void HudDrawShader( int info, const char *name )
 void HudDrawAlign( int info, int horizontalAlign, int verticalAlign )
 {
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x1C);
+	gi.MSG_StartCGM(CGM_HUDDRAW_ALIGN);
 	HudWriteNumber( info );					// c = probably "info"
 	gi.MSG_WriteBits(horizontalAlign, 2);	// value = 0,1,2	bits = 2
 											// 0 - left		\
@@ -66,7 +66,7 @@ void HudDrawAlign( int info, int horizontalAlign, int verticalAlign )
 void HudDrawRect(int info, int x, int y, int width, int height)
 {
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x1D);
+	gi.MSG_StartCGM(CGM_HUDDRAW_RECT);
 	HudWriteNumber( info );			// c = probably "info"
 	gi.MSG_WriteShort(x);			// c = probably "x"
 	gi.MSG_WriteShort(y);			// c = probably "y"
@@ -79,7 +79,7 @@ void HudDrawRect(int info, int x, int y, int width, int height)
 void HudDrawVirtualSize(int info, int virtualScreen)
 {
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x1E);
+	gi.MSG_StartCGM(CGM_HUDDRAW_VIRTUALSIZE);
 	HudWriteNumber( info );					// c = info
 	
 	/*__asm
@@ -116,7 +116,7 @@ void HudDrawColor(int info, float *color)
 	
 	
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x1F);
+	gi.MSG_StartCGM(CGM_HUDDRAW_COLOR);
 	HudWriteNumber( info );			// c = info
 	gi.MSG_WriteByte(temp[0]);		// c = color[2]		
 	gi.MSG_WriteByte(temp[1]);		// c = color[1]		 - Values can be messed up. To be tested.
@@ -132,7 +132,7 @@ void HudDrawAlpha(int info, float alpha)
 	temp = (long int)(alpha*255.0f);
 	
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x20);
+	gi.MSG_StartCGM(CGM_HUDDRAW_ALPHA);
 	HudWriteNumber( info );		// c = info
 	gi.MSG_WriteByte(temp);		// c = alpha
 	gi.MSG_EndCGM();
@@ -144,7 +144,7 @@ void HudDrawAlpha(int info, float alpha)
 void HudDrawString(int info, const char *string)
 {
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x21);
+	gi.MSG_StartCGM(CGM_HUDDRAW_STRING);
 	HudWriteNumber( info );		// c = info
 	gi.MSG_WriteString(string);	// s = string (to show)
 	gi.MSG_EndCGM();
@@ -154,7 +154,7 @@ void HudDrawString(int info, const char *string)
 void HudDrawFont(int info, const char *fontName)
 {
 	gi.SetBroadcastAll();
-	gi.MSG_StartCGM(0x22);
+	gi.MSG_StartCGM(CGM_HUDDRAW_FONT);
 	HudWriteNumber( info );			// c = info
 	gi.MSG_WriteString(fontName);	// s = fontName (to use)
 	gi.MSG_EndCGM();
@@ -163,6 +163,8 @@ void HudDrawFont(int info, const char *fontName)
 
 void HudDraw3d( int index, vec3_t vector, int ent_num, qboolean bAlwaysShow, qboolean depth )
 {
+	// FIXME...
+	/*
 	gi.SetBroadcastAll();
 
 	gi.MSG_StartCGM( CGM_HUDDRAW_3D );
@@ -176,10 +178,12 @@ void HudDraw3d( int index, vec3_t vector, int ent_num, qboolean bAlwaysShow, qbo
 		gi.MSG_WriteByte( bAlwaysShow );
 		gi.MSG_WriteByte( depth );
 	gi.MSG_EndCGM();
+	*/
 }
 
 void HudDrawTimer( int index, float duration, float fade_out_time )
 {
+/*
 	gi.SetBroadcastAll();
 
 	gi.MSG_StartCGM( CGM_HUDDRAW_TIMER );
@@ -187,12 +191,13 @@ void HudDrawTimer( int index, float duration, float fade_out_time )
 		gi.MSG_WriteFloat( duration );
 		gi.MSG_WriteFloat( fade_out_time );
 	gi.MSG_EndCGM();
+*/
 }
 
 void iHudDrawShader( int cl_num, int info, const char *name )
 {
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x1B);
+	gi.MSG_StartCGM(CGM_HUDDRAW_SHADER);
 	HudWriteNumber( info );		// c = info
 	gi.MSG_WriteString(name);		// s = name (shader_name)
 	gi.MSG_EndCGM();
@@ -202,7 +207,7 @@ void iHudDrawShader( int cl_num, int info, const char *name )
 void iHudDrawAlign(int cl_num, int info, int horizontalAlign, int verticalAlign )
 {
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x1C);
+	gi.MSG_StartCGM(CGM_HUDDRAW_ALIGN);
 	HudWriteNumber( info );					// c = probably "info"
 	gi.MSG_WriteBits(horizontalAlign, 2);	// value = 0,1,2	bits = 2
 											// 0 - left		\
@@ -221,7 +226,7 @@ void iHudDrawAlign(int cl_num, int info, int horizontalAlign, int verticalAlign
 void iHudDrawRect(int cl_num, int info, int x, int y, int width, int height)
 {
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x1D);
+	gi.MSG_StartCGM(CGM_HUDDRAW_RECT);
 	HudWriteNumber( info );		// c = probably "info"
 	gi.MSG_WriteShort(x);			// c = probably "x"
 	gi.MSG_WriteShort(y);			// c = probably "y"
@@ -232,6 +237,7 @@ void iHudDrawRect(int cl_num, int info, int x, int y, int width, int height)
 
 void iHudDraw3d( int cl_num, int index, vec3_t vector, int ent_num, qboolean bAlwaysShow, qboolean depth )
 {
+	/*
 	gi.MSG_SetClient( cl_num );
 
 	gi.MSG_StartCGM( CGM_HUDDRAW_3D );
@@ -245,10 +251,12 @@ void iHudDraw3d( int cl_num, int index, vec3_t vector, int ent_num, qboolean bAl
 		gi.MSG_WriteByte( bAlwaysShow );
 		gi.MSG_WriteByte( depth );
 	gi.MSG_EndCGM();
+	*/
 }
 
 void iHudDrawTimer( int cl_num, int index, float duration, float fade_out_time )
 {
+/*
 	gi.MSG_SetClient( cl_num );
 
 	gi.MSG_StartCGM( CGM_HUDDRAW_TIMER );
@@ -256,12 +264,13 @@ void iHudDrawTimer( int cl_num, int index, float duration, float fade_out_time )
 		gi.MSG_WriteFloat( duration );
 		gi.MSG_WriteFloat( fade_out_time );
 	gi.MSG_EndCGM();
+*/
 }
 
 void iHudDrawVirtualSize(int cl_num, int info, int virtualScreen)
 {
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x1E);
+	gi.MSG_StartCGM(CGM_HUDDRAW_VIRTUALSIZE);
 	HudWriteNumber( info );					// c = info
 
 	gi.MSG_WriteBits(!!virtualScreen, 1);	// value = ?	bits = 1
@@ -285,7 +294,7 @@ void iHudDrawColor(int cl_num, int info, float *color)
 	temp[2] = (long int)(color[2]*255.0f);
 
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x1F);
+	gi.MSG_StartCGM(CGM_HUDDRAW_COLOR);
 	HudWriteNumber( info );			// c = info
 	gi.MSG_WriteByte(temp[0]);		// c = color[2]		
 	gi.MSG_WriteByte(temp[1]);		// c = color[1]		 - Values can be messed up. To be tested.
@@ -301,7 +310,7 @@ void iHudDrawAlpha(int cl_num, int info, float alpha)
 	temp = (long int)(alpha*255.0f);
 
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x20);
+	gi.MSG_StartCGM(CGM_HUDDRAW_ALPHA);
 	HudWriteNumber( info );			// c = info
 	gi.MSG_WriteByte(temp);		// c = alpha
 	gi.MSG_EndCGM();
@@ -313,7 +322,7 @@ void iHudDrawAlpha(int cl_num, int info, float alpha)
 void iHudDrawString( int cl_num, int info, const char *string )
 {
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x21);
+	gi.MSG_StartCGM(CGM_HUDDRAW_STRING);
 	HudWriteNumber( info );		// c = info
 	gi.MSG_WriteString(string);	// s = string (to show)
 	gi.MSG_EndCGM();
@@ -323,7 +332,7 @@ void iHudDrawString( int cl_num, int info, const char *string )
 void iHudDrawFont( int cl_num, int info, const char *fontName )
 {
 	gi.MSG_SetClient(cl_num);
-	gi.MSG_StartCGM(0x22);
+	gi.MSG_StartCGM(CGM_HUDDRAW_FONT);
 	HudWriteNumber( info );			// c = info
 	gi.MSG_WriteString(fontName);	// s = fontName (to use)
 	gi.MSG_EndCGM();

code/game/item.cpp

@@ -1149,6 +1149,8 @@ void Item::updatePrefix
 		return;
 	}
 
+	// FIXME: delete
+	/*
 	Entity *ent = ev->GetEntity( 1 );
 
 	gi.MSG_SetClient( ent->edict - g_entities );
@@ -1157,6 +1159,7 @@ void Item::updatePrefix
 		gi.MSG_WriteString( item_name.c_str() );
 		gi.MSG_WriteString( m_sVMprefix.c_str() );
 	gi.MSG_EndCGM();
+	*/
 }
 
 qboolean Item::IsItemCool

code/game/player.cpp

@@ -2007,15 +2007,6 @@ qboolean Player::checkrun
 	return ( last_ucmd.buttons & BUTTON_RUN ) != 0;
 }
 
-qboolean Player::checkholsterweapon
-   (
-   Conditional &condition
-   )
-
-   {
-	return ( last_ucmd.buttons & BUTTON_HOLSTER ) != 0;
-   }
-
 qboolean Player::checkuse
    (
    Conditional &condition
@@ -3666,6 +3657,49 @@ qboolean Player::checkimmediateswitch( Conditional &condition )
 	return ( g_gametype->integer && g_immediateswitch->integer );
 }
 
+
+qboolean Player::checkmovementspeed(Conditional& condition)
+{
+	int speed = atoi(condition.getParm(1));
+	return client->ps.speed >= speed;
+}
+
+qboolean Player::checkabletodefuse(Conditional& condition)
+{
+	// FIXME: unimplemented
+	return true;
+}
+
+qboolean Player::checkonlandmine(Conditional& condition)
+{
+	// FIXME: unimplemented
+	return false;
+}
+
+qboolean Player::checknearlandmine(Conditional& condition)
+{
+	// FIXME: unimplemented
+	return false;
+}
+
+qboolean Player::CondCanPlaceLandmine(Conditional& condition)
+{
+	// FIXME: unimplemented
+	return false;
+}
+
+qboolean Player::CondWeaponCurrentFireAnim(Conditional& condition)
+{
+	// FIXME: unimplemented
+	return false;
+}
+
+qboolean Player::CondVehicleType(Conditional& condition)
+{
+	// FIXME: unimplemented
+	return false;
+}
+
 qboolean Player::CondAnimDoneVM( Conditional &condition )
 {
 	return animDoneVM;
@@ -3921,7 +3955,6 @@ Condition<Player> Player::Conditions[] =
 	{ "default",							&Player::returntrue },
 	{ "SNEAK",								&Player::checksneak },
 	{ "RUN",								&Player::checkrun },
-	{ "HOLSTERWEAPON",						&Player::checkholsterweapon },
 	{ "USE",								&Player::checkuse },
 	{ "LEFT",								&Player::checkturnleft },
 	{ "RIGHT",								&Player::checkturnright },
@@ -4024,6 +4057,13 @@ Condition<Player> Player::Conditions[] =
 	{ "MIN_CHARGE_TIME_MET",				&Player::checkminchargetimemet },
 	{ "MAX_CHARGE_TIME_MET",				&Player::checkmaxchargetimemet },
 	{ "IMMEDIATE_SWITCH",					&Player::checkimmediateswitch },
+	{ "CHECK_MOVEMENT_SPEED",				&Player::checkmovementspeed },
+	{ "ABLE_TO_DEFUSE",						&Player::checkabletodefuse },
+	{ "ON_LANDMINE",						&Player::checkonlandmine },
+	{ "NEAR_LANDMINE",						&Player::checknearlandmine },
+	{ "CAN_PLACE_LANDMINE",					&Player::CondCanPlaceLandmine },
+	{ "WEAPON_CURRENT_FIRE_ANIM",			&Player::CondWeaponCurrentFireAnim },
+	{ "VEHICLE_TYPE",						&Player::CondVehicleType },
 	{ "ANIMDONE_VM",						&Player::CondAnimDoneVM },
 	{ "CLIENT_COMMAND",						&Player::CondClientCommand },
 	{ "IS_VM_ANIM",							&Player::CondVMAnim },
@@ -5740,9 +5780,9 @@ void Player::Pain
 	{
 		gi.MSG_SetClient( attacker->edict - g_entities );
 		if( IsDead() )
-			gi.MSG_StartCGM( 36 );
+			gi.MSG_StartCGM(CGM_NOTIFY_KILL);
 		else
-			gi.MSG_StartCGM( 35 );
+			gi.MSG_StartCGM(CGM_NOTIFY_HIT);
 		gi.MSG_EndCGM();
 	}
 
@@ -6478,6 +6518,8 @@ void Player::ClientMove
 	{
 		m_bShowingHint = false;
 
+		// FIXME: delete
+		/*
 		if (sv_reborn->integer)
 		{
 			gi.MSG_SetClient(edict - g_entities);
@@ -6487,6 +6529,7 @@ void Player::ClientMove
 				gi.MSG_WriteString("");
 			gi.MSG_EndCGM();
 		}
+		*/
 	}
 
 	oldorigin = origin;
@@ -13171,7 +13214,7 @@ void Player::EventDMMessage
 				if( bInstaMessage )
 				{
 					gi.MSG_SetClient( i );
-					gi.MSG_StartCGM( 37 );
+					gi.MSG_StartCGM(CGM_VOICE_CHAT);
 					gi.MSG_WriteCoord( m_vViewPos[ 0 ] );
 					gi.MSG_WriteCoord( m_vViewPos[ 1 ] );
 					gi.MSG_WriteCoord( m_vViewPos[ 2 ] );
@@ -13263,35 +13306,27 @@ qboolean Player::ViewModelAnim( str anim, qboolean force_restart, qboolean bFull
 	}
 
 	if ( Q_stricmp( anim, "charge" ) == 0 ) {
-		viewModelAnim = VMA_CHARGE;
+		viewModelAnim = VM_ANIM_CHARGE;
 	} else if ( Q_stricmp( anim, "fire" ) == 0 ) {
-		viewModelAnim = VMA_FIRE;
+		viewModelAnim = VM_ANIM_FIRE;
 	} else if ( Q_stricmp( anim, "fire_secondary" ) == 0 ) {
-		viewModelAnim = VMA_FIRE_SECONDARY;
+		viewModelAnim = VM_ANIM_FIRE_SECONDARY;
 	} else if ( Q_stricmp( anim, "rechamber" ) == 0 ) {
-		viewModelAnim = VMA_RECHAMBER;
+		viewModelAnim = VM_ANIM_RECHAMBER;
 	} else if ( Q_stricmp( anim, "reload" ) == 0 ) {
-		viewModelAnim = VMA_RELOAD;
+		viewModelAnim = VM_ANIM_RELOAD;
 	} else if ( Q_stricmp( anim, "reload_single" ) == 0 ) {
-		viewModelAnim = VMA_RELOAD_SINGLE;
+		viewModelAnim = VM_ANIM_RELOAD_SINGLE;
 	} else if ( Q_stricmp( anim, "reload_end" ) == 0 ) {
-		viewModelAnim = VMA_RELOAD_END;
+		viewModelAnim = VM_ANIM_RELOAD_END;
 	} else if ( Q_stricmp( anim, "pullout" ) == 0 ) {
-		viewModelAnim = VMA_PULLOUT;
+		viewModelAnim = VM_ANIM_PULLOUT;
 	} else if ( Q_stricmp( anim, "putaway" ) == 0 ) {
-		viewModelAnim = VMA_PUTAWAY;
+		viewModelAnim = VM_ANIM_PUTAWAY;
 	} else if ( Q_stricmp( anim, "ladderstep" ) == 0 ) {
-		viewModelAnim = VMA_LADDERSTEP;
+		viewModelAnim = VM_ANIM_LADDERSTEP;
 	} else if ( Q_stricmp( anim, "idle" ) == 0 ) {
-		viewModelAnim = VMA_IDLE;
-	}
-	else if ( level.reborn )
-	{
-		if ( !anim.icmp( "enable" ) ) {
-			viewModelAnim = VMA_ENABLE;
-		} else {
-			viewModelAnim = VMA_CUSTOMANIMATION;
-		}
+		viewModelAnim = VM_ANIM_IDLE;
 	}
 	else
 	{
@@ -13319,16 +13354,6 @@ qboolean Player::ViewModelAnim( str anim, qboolean force_restart, qboolean bFull
 
 	m_sVMcurrent = anim;
 
-	if ( level.reborn && viewModelAnim == VMA_CUSTOMANIMATION )
-	{
-		gi.MSG_SetClient( edict - g_entities );
-
-		gi.MSG_StartCGM( CGM_VIEWMODELANIM );
-			gi.MSG_WriteString( anim.c_str() );
-			gi.MSG_WriteByte( bFullAnim );
-		gi.MSG_EndCGM();
-	}
-
 	if ( viewModelAnim != playerState->iViewModelAnim || force_restart ) {
 		playerState->iViewModelAnimChanged = ( playerState->iViewModelAnimChanged + 1 ) & 3;
 	}
@@ -14256,15 +14281,15 @@ void Player::ModifyHeightFloat
 
 	client->ps.pm_flags &= ~( PMF_DUCKED | PMF_VIEW_PRONE | PMF_VIEW_DUCK_RUN | PMF_VIEW_JUMP_START );
 
-	if( sv_reborn->integer )
-	{
-		gi.MSG_SetClient( edict - g_entities);
+	// FIXME...
+	/*
+	gi.MSG_SetClient(edict - g_entities);
 
-		gi.MSG_StartCGM( CGM_MODHEIGHTFLOAT );
-			gi.MSG_WriteLong( height );
-			gi.MSG_WriteFloat( max_z );
-		gi.MSG_EndCGM();
-	}
+	gi.MSG_StartCGM(CGM_MODHEIGHTFLOAT);
+	gi.MSG_WriteLong(height);
+	gi.MSG_WriteFloat(max_z);
+	gi.MSG_EndCGM();
+	*/
 }
 
 void Player::PlayLocalSound
@@ -14298,8 +14323,8 @@ void Player::PlayLocalSound
 		return;
 	}
 
-	if( sv_reborn->integer )
-	{
+	// FIXME...
+	/*
 		gi.MSG_SetClient( client->ps.clientNum );
 
 		gi.MSG_StartCGM( CGM_PLAYLOCALSOUND );
@@ -14310,7 +14335,7 @@ void Player::PlayLocalSound
 		gi.MSG_EndCGM();
 
 		return;
-	}
+	*/
 
 	if( loop )
 	{
@@ -14467,11 +14492,14 @@ void Player::SetLocalSoundRate
 
 	gi.MSG_SetClient( client->ps.clientNum );
 
+	// FIXME...
+	/*
 	gi.MSG_StartCGM( CGM_SETLOCALSOUNDRATE );
 		gi.MSG_WriteString( found );
 		gi.MSG_WriteFloat( rate );
 		gi.MSG_WriteFloat( time );
 	gi.MSG_EndCGM();
+	*/
 }
 
 void Player::SetSpeed
@@ -14556,12 +14584,15 @@ void Player::SetVMASpeed
 	vma->name = name;
 	vma->speed = speed;
 
+	// FIXME...
+	/*
 	gi.MSG_SetClient( edict - g_entities );
 
 	gi.MSG_StartCGM( CGM_SETVMASPEED );
 		gi.MSG_WriteString( name );
 		gi.MSG_WriteFloat( speed );
 	gi.MSG_EndCGM();
+	*/
 }
 
 void Player::StopLocalSound
@@ -14589,20 +14620,8 @@ void Player::StopLocalSound
 		return;
 	}
 
-	if( level.reborn )
-	{
-		gi.MSG_SetClient( client->ps.clientNum );
-
-		gi.MSG_StartCGM( CGM_STOPLOCALSOUND );
-			gi.MSG_WriteString( found );
-			gi.MSG_WriteFloat( time );
-		gi.MSG_EndCGM();
-	}
-	else
-	{
-		edict->s.loopSound = 0;
-		gi.StopSound( entnum, CHAN_LOCAL );
-	}
+	edict->s.loopSound = 0;
+	gi.StopSound(entnum, CHAN_LOCAL);
 }
 
 void Player::UseHeld

code/game/player.h

@@ -354,7 +354,6 @@ public:
 	qboolean			checkattackbuttonright( Conditional &condition );
 	qboolean			checksneak( Conditional &condition );
 	qboolean			checkrun( Conditional &condition );
-	qboolean			checkholsterweapon( Conditional &condition );
 	qboolean			checkuse( Conditional &condition );
 	qboolean			checkcanturn( Conditional &condition );
 	qboolean			checkcanmoveright( Conditional &condition );
@@ -443,6 +442,13 @@ public:
 	qboolean			checkminchargetimemet( Conditional &condition );
 	qboolean			checkmaxchargetimemet( Conditional &condition );
 	qboolean			checkimmediateswitch( Conditional &condition );
+	qboolean			checkmovementspeed( Conditional &condition );
+	qboolean			checkabletodefuse( Conditional &condition );
+	qboolean			checkonlandmine( Conditional &condition );
+	qboolean			checknearlandmine( Conditional &condition );
+	qboolean			CondCanPlaceLandmine( Conditional &condition );
+	qboolean			CondWeaponCurrentFireAnim( Conditional &condition );
+	qboolean			CondVehicleType( Conditional &condition );
 	qboolean			CondAnimDoneVM( Conditional &condition );
 	qboolean			CondClientCommand( Conditional &condition );
 	qboolean			CondVMAnim( Conditional &condition );

code/game/weaputils.cpp

@@ -1785,11 +1785,11 @@ void Explosion::MakeExplosionEffect
 
 	if( !sEffect.icmp( "grenade" ) )
 	{
-		gi.MSG_StartCGM( 12 );
+		gi.MSG_StartCGM(CGM_EXPLOSION_EFFECT_1);
 	}
 	else
 	{
-		gi.MSG_StartCGM( 13 );
+		gi.MSG_StartCGM(CGM_EXPLOSION_EFFECT_2);
 	}
 
 	gi.MSG_WriteCoord( origin[ 0 ] );
@@ -2034,7 +2034,7 @@ float BulletAttack
 						if( ent->edict->solid == 3 && trace.shaderNum >= 0 )
 						{
 							gi.SetBroadcastVisible( trace.endpos, 0 );
-							gi.MSG_StartCGM( 6 );
+							gi.MSG_StartCGM(CGM_BULLET_6);
 							gi.MSG_WriteCoord( trace.endpos[ 0 ] );
 							gi.MSG_WriteCoord( trace.endpos[ 1 ] );
 							gi.MSG_WriteCoord( trace.endpos[ 2 ] );
@@ -2192,7 +2192,7 @@ float BulletAttack
 			if( trace.contents > 0 && trace.surfaceFlags & 0xFFFE000 )
 			{
 				gi.SetBroadcastVisible( trace.endpos, NULL );
-				gi.MSG_StartCGM( 6 );
+				gi.MSG_StartCGM(CGM_BULLET_6);
 				gi.MSG_WriteCoord( trace.endpos[ 0 ] );
 				gi.MSG_WriteCoord( trace.endpos[ 1 ] );
 				gi.MSG_WriteCoord( trace.endpos[ 2 ] );
@@ -2203,7 +2203,7 @@ float BulletAttack
 			else if( trace.location >= 0 && ent->IsSubclassOfPlayer() )
 			{
 				gi.SetBroadcastVisible( trace.endpos, NULL );
-				gi.MSG_StartCGM( 7 );
+				gi.MSG_StartCGM(CGM_BULLET_7);
 				gi.MSG_WriteCoord( trace.endpos[ 0 ] );
 				gi.MSG_WriteCoord( trace.endpos[ 1 ] );
 				gi.MSG_WriteCoord( trace.endpos[ 2 ] );
@@ -2250,7 +2250,7 @@ float BulletAttack
 	{
 		if( iTracerCount )
 		{
-			gi.MSG_StartCGM( 1 );
+			gi.MSG_StartCGM(CGM_BULLET_1);
 
 			gi.MSG_WriteCoord( vBarrel[ 0 ] );
 			gi.MSG_WriteCoord( vBarrel[ 1 ] );
@@ -2258,7 +2258,7 @@ float BulletAttack
 		}
 		else
 		{
-			gi.MSG_StartCGM( 2 );
+			gi.MSG_StartCGM(CGM_BULLET_2);
 		}
 
 		gi.MSG_WriteCoord( start[ 0 ] );
@@ -2273,7 +2273,7 @@ float BulletAttack
 	{
 		if( iTracerCount )
 		{
-			gi.MSG_StartCGM( 3 );
+			gi.MSG_StartCGM(CGM_BULLET_3);
 
 			gi.MSG_WriteCoord( vBarrel[ 0 ] );
 			gi.MSG_WriteCoord( vBarrel[ 1 ] );
@@ -2286,7 +2286,7 @@ float BulletAttack
 		}
 		else
 		{
-			gi.MSG_StartCGM( 4 );
+			gi.MSG_StartCGM(CGM_BULLET_4);
 		}
 
 		gi.MSG_WriteCoord( start[ 0 ] );
@@ -2349,7 +2349,7 @@ void FakeBulletAttack
 			( *piTracerCount )++;
 			if( *piTracerCount == iTracerFrequency )
 			{
-				gi.MSG_StartCGM( 25 );
+				gi.MSG_StartCGM(CGM_BULLET_NO_BARREL_1);
 				gi.MSG_WriteCoord( vBarrel[ 0 ] );
 				gi.MSG_WriteCoord( vBarrel[ 1 ] );
 				gi.MSG_WriteCoord( vBarrel[ 2 ] );
@@ -2357,12 +2357,12 @@ void FakeBulletAttack
 			}
 			else
 			{
-				gi.MSG_StartCGM( 26 );
+				gi.MSG_StartCGM(CGM_BULLET_NO_BARREL_2);
 			}
 		}
 		else
 		{
-			gi.MSG_StartCGM( 26 );
+			gi.MSG_StartCGM(CGM_BULLET_NO_BARREL_2);
 		}
 
 		gi.MSG_WriteCoord( start[ 0 ] );

code/game/windows.cpp

@@ -151,7 +151,7 @@ void WindowObject::WindowKilled( Event *ev )
 	vCenter = origin + mins + maxs;
 
 	gi.SetBroadcastVisible( vCenter, vCenter );
-	gi.MSG_StartCGM( 24 );
+	gi.MSG_StartCGM(CGM_MAKE_WINDOW_DEBRIS);
 		gi.MSG_WriteCoord( vCenter[ 0 ] );
 		gi.MSG_WriteCoord( vCenter[ 1 ] );
 		gi.MSG_WriteCoord( vCenter[ 2 ] );

code/game/world.cpp

@@ -391,9 +391,6 @@ ConSimple *World::GetTargetList( const_str targetname )
 	return &m_targetList.addKeyValue( targetname );
 }
 
-
-#ifdef GAME_DLL
-
 World::World()
 {
 	world = this;
@@ -424,11 +421,30 @@ World::World()
 
 	// set the default farplane parameters
 	farplane_distance = 0;
-	farplane_color = "0 0 0";
+	farplane_bias = 0.0;
+	farplane_color = vec_zero;
 	farplane_cull = qtrue;
+	skybox_farplane = 0.0;
+	render_terrain = qtrue;
+	skybox_speed = 0.0;
+	farclip_override = 0.f;
+	farplane_color_override = Vector(-1, -1, -1);
+	animated_farplane_start = 0.0;
+	animated_farplane_end = 0.0;
+	animated_farplane_start_z = 8192.0;
+	animated_farplane_end_z = 0.0;
+	animated_farplane_bias_start = 0.0;
+	animated_farplane_bias_end = 0.0;
+	animated_farplane_bias_start_z = 8192.0;
+	animated_farplane_bias_end_z = 0.0;
+	animated_farplane_color_start = vec_zero;
+	animated_farplane_color_end = vec_zero;
+	animated_farplane_color_start_z = 8192.0;
+	animated_farplane_color_end_z = 0.0;
 
 	UpdateFog();
 
+	sky_alpha = 1.0f;
 	sky_portal = qtrue;
 	UpdateSky();
 
@@ -472,19 +488,12 @@ void World::UpdateConfigStrings( void )
 	gi.SetConfigstring( CS_MESSAGE, level.level_name.c_str() );
 };
 
-void World::UpdateFog( void )
-{
-	gi.SetFarPlane( farplane_distance );
-	gi.SetConfigstring( CS_FOGINFO, va( "%d %.0f %.4f %.4f %.4f", farplane_cull, farplane_distance, farplane_color.x, farplane_color.y, farplane_color.z ) );
-}
-
 void World::UpdateSky( void )
 {
 	gi.SetSkyPortal( sky_portal );
 	gi.SetConfigstring( CS_SKYINFO, va( "%.4f %d", sky_alpha, sky_portal ) );
 }
 
-
 void World::SetSoundtrack( Event *ev )
 {
 	const char *text;
@@ -566,6 +575,41 @@ void World::SetNorthYaw( Event *ev )
 	m_fNorth = anglemod( ev->GetFloat( 1 ) );
 }
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+void World::UpdateFog(void)
+{
+	gi.SetFarPlane(farplane_distance);
+	gi.SetConfigstring(CS_FOGINFO, va(
+		"%d %.0f %.0f %.0f %.6f %.4f %.4f %.4f %d %.0f %.2f %.2f %.2f",
+		farplane_cull,
+		farplane_distance,
+		farplane_bias,
+		skybox_farplane,
+		skybox_speed,
+		farplane_color.x,
+		farplane_color.y,
+		farplane_color.z,
+		render_terrain,
+		farclip_override,
+		farplane_color_override.x,
+		farplane_color_override.y,
+		farplane_color_override.z
+		)
+	);
+}
+
+#else
+
+void World::UpdateFog(void)
+{
+	gi.SetFarPlane(farplane_distance);
+	gi.SetConfigstring(CS_FOGINFO, va("%d %.0f %.4f %.4f %.4f", farplane_cull, farplane_distance, farplane_color.x, farplane_color.y, farplane_color.z));
+}
+
+#endif
+
+
 CLASS_DECLARATION( Entity, World, "worldspawn" )
 {
 	{ &EV_World_SetSoundtrack,			&World::SetSoundtrack },
@@ -594,18 +638,3 @@ CLASS_DECLARATION( Entity, World, "worldspawn" )
 	{ &EV_World_SetSunDiffuseColor,		NULL },
 	{ NULL,								NULL }
 };
-
-#else
-
-World::World()
-{
-	world = this;
-	world_dying = qfalse;
-}
-
-CLASS_DECLARATION( SimpleEntity, World, "worldspawn" )
-{
-	{ NULL, NULL }
-};
-
-#endif

code/game/world.h

@@ -51,8 +51,26 @@ class World : public SimpleEntity {
 public:
 	// farplane variables
 	float		farplane_distance;
+	float		farplane_bias;
 	Vector		farplane_color;
 	qboolean	farplane_cull;
+	float		skybox_farplane;
+	qboolean	render_terrain;
+	float		skybox_speed;
+	float		farclip_override;
+	Vector		farplane_color_override;
+	float		animated_farplane_start;
+	float		animated_farplane_end;
+	float		animated_farplane_start_z;
+	float		animated_farplane_end_z;
+	float		animated_farplane_bias_start;
+	float		animated_farplane_bias_end;
+	float		animated_farplane_bias_start_z;
+	float		animated_farplane_bias_end_z;
+	Vector		animated_farplane_color_start;
+	Vector		animated_farplane_color_end;
+	float		animated_farplane_color_start_z;
+	float		animated_farplane_color_end_z;
 
 	// sky variables
 	float		sky_alpha;

code/qcommon/cm_load.c

@@ -882,9 +882,9 @@ void CM_LoadMap( const char *name, qboolean clientload, int *checksum ) {
 		((int *)&header)[i] = LittleLong ( ((int *)&header)[i]);
 	}
 
-	if ( header.version != BSP_VERSION ) {
-		Com_Error (ERR_DROP, "CM_LoadMap: %s has wrong version number (%i should be %i)"
-		, name, header.version, BSP_VERSION );
+	if ( header.version < BSP_MIN_VERSION || header.version > BSP_MAX_VERSION ) {
+		Com_Error (ERR_DROP, "CM_LoadMap: %s has wrong version number (%i should be between %i and %i)"
+		, name, header.version, BSP_MIN_VERSION, BSP_MAX_VERSION );
 	}
 
 	cmod_base = ( byte * )&header;

code/qcommon/common.cpp

@@ -284,7 +284,7 @@ void QDECL Com_Error( int code, const char *fmt, ... ) {
 	static int	errorCount;
 	int			currentTime;
 
-#ifdef _DEBUG
+#ifdef COM_ERROR_ASSERT
 	*( int * )0 = 0;
 	assert( 0 );
 #endif

code/qcommon/files.cpp

@@ -3068,7 +3068,7 @@ static void FS_ReorderPurePaks( void )
 FS_Startup
 ================
 */
-static void FS_Startup( const char *gameName )
+static void FS_Startup(const char* gameName, const char* extensionName)
 {
 	const char* homePath;
 
@@ -3087,10 +3087,16 @@ static void FS_Startup( const char *gameName )
 	fs_gamedirvar = Cvar_Get( "fs_game", "", CVAR_INIT | CVAR_SYSTEMINFO );
 	fs_restrict = Cvar_Get( "fs_restrict", "", CVAR_INIT );
 
-	FS_AddGameDirectory( fs_basepath->string, gameName );
+	if (gameName) {
+		FS_AddGameDirectory(fs_basepath->string, gameName);
+	}
 
-	if( *fs_gamedirvar->string && !Q_stricmp( gameName, "main" ) && Q_stricmp( fs_gamedirvar->string, gameName ) ) {
-		FS_AddGameDirectory( fs_basepath->string, fs_gamedirvar->string );
+	if (Q_stricmp(gameName, extensionName)) {
+		FS_AddGameDirectory(fs_basepath->string, extensionName);
+	}
+
+	if (*fs_gamedirvar->string && !Q_stricmp(gameName, GAME_EXTENSION_BASE) && Q_stricmp(fs_gamedirvar->string, gameName)) {
+		FS_AddGameDirectory(fs_basepath->string, fs_gamedirvar->string);
 	}
 
 	fs_mapdir = Cvar_Get( "mapdir", "", 0 );
@@ -3594,7 +3600,7 @@ void FS_InitFilesystem( void ) {
 	Com_StartupVariable( "fs_homepath" );
 
 	// try to start up normally
-	FS_Startup( BASEGAME );
+	FS_Startup( BASEGAME, GAME_EXTENSION_BASE);
 	FS_SetRestrictions();
 
 	if( !silentStart ) {
@@ -3640,7 +3646,7 @@ void FS_Restart( int checksumFeed ) {
 	FS_ClearPakReferences(0);
 
 	// try to start up normally
-	FS_Startup( BASEGAME );
+	FS_Startup(BASEGAME, GAME_EXTENSION_BASE);
 
 	FS_CheckPak0( );
 

code/qcommon/memory.c

@@ -114,7 +114,7 @@ void Z_Free( void *ptr )
 	block->prev = block;
 	block->next = block;
 
-#if !defined(_DEBUG) && !defined(WIN32)
+#if !defined(_DEBUG) || !defined(WIN32)
 	// free the block
 	free( block );
 #else
@@ -172,7 +172,7 @@ void *Z_TagMalloc( size_t size, int tag )
 #endif
 	size = PAD( size, sizeof( intptr_t ) );		// align to 32/64 bit boundary
 
-#if !defined(_DEBUG) && !defined(WIN32)
+#if !defined(_DEBUG) || !defined(WIN32)
 	block = ( memblock_t * )malloc( size );
 #else
 	block = HeapAlloc(GetProcessHeap(), 0, size);

code/qcommon/q_platform.h

@@ -346,6 +346,8 @@ short ShortSwapPtr(const void* l);
 int LongSwapPtr(const void* l);
 short ShortNoSwapPtr(const void* l);
 int LongNoSwapPtr(const void* l);
+float FloatSwapPtr(const void* l);
+float FloatNoSwapPtr(const void* l);
 
 #if defined( Q3_BIG_ENDIAN ) && defined( Q3_LITTLE_ENDIAN )
 #error "Endianness defined as both big and little"
@@ -354,11 +356,16 @@ int LongNoSwapPtr(const void* l);
 #define CopyLittleShort(dest, src) CopyShortSwap(dest, src)
 #define CopyLittleLong(dest, src) CopyLongSwap(dest, src)
 
+//
+// Those Little*Ptr are used to avoid alignment problems
+//
+
 #define LittleShort(x) ShortSwap(x)
 #define LittleLong(x) LongSwap(x)
 #define LittleFloat(x) FloatSwap(&x)
 #define LittleShortPtr(x) ShortSwapPtr(&x)
 #define LittleLongPtr(x) LongSwapPtr(&x)
+#define LittleFloatPtr(x) FloatSwapPtr(&x)
 
 #define BigShort
 #define BigLong
@@ -376,6 +383,7 @@ int LongNoSwapPtr(const void* l);
 #define LittleFloat
 #define LittleShortPtr(x) ShortNoSwapPtr(&x)
 #define LittleLongPtr(x) LongNoSwapPtr(&x)
+#define LittleFloatPtr(x) FloatNoSwapPtr(&x)
 
 #define BigShort(x) ShortSwap(x)
 #define BigLong(x) LongSwap(x)

code/qcommon/q_shared.c

@@ -1552,6 +1552,20 @@ int LongNoSwapPtr(const void* l)
 	return out;
 }
 
+float FloatSwapPtr(const void* l)
+{
+	float out;
+	CopyLittleLong((int*)&out, l);
+	return out;
+}
+
+float FloatNoSwapPtr(const void* l)
+{
+	float out;
+	Com_Memcpy(&out, l, sizeof(float));
+	return out;
+}
+
 void Swap_Init(void)
 {
 	// Endianness is now computed at compile time

code/qcommon/q_shared.h

@@ -29,16 +29,38 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 extern "C" {
 #endif
 
-#define PRODUCT_NAME            "OpenMoHAA"
-#define PRODUCT_VERSION_NUMBER	"0.51"
-#define PRODUCT_VERSION_STAGE	"alpha"
-#define PRODUCT_VERSION			PRODUCT_VERSION_NUMBER "-" PRODUCT_VERSION_STAGE
-#define PRODUCT_DATE			__DATE__
+#define PRODUCT_NAME					"OpenMoHAA"
 
+//
+// Version
+// 
+// These values are the only one that must be set for the version
+#define PRODUCT_VERSION_MAJOR			0
+#define PRODUCT_VERSION_MINOR			53
+#define PRODUCT_VERSION_PATCH			2
+#define PRODUCT_VERSION_STAGE			"alpha"
+
+//
+// Version display
+//
+#define PRODUCT_VERSION_NUMBER_STRING	XSTRING(PRODUCT_VERSION_MAJOR) "." XSTRING(PRODUCT_VERSION_MINOR) "." XSTRING(PRODUCT_VERSION_PATCH)
+#define PRODUCT_VERSION					PRODUCT_VERSION_NUMBER_STRING "-" PRODUCT_VERSION_STAGE
+#define PRODUCT_DATE					__DATE__
+
+#define BASEGAME				"main"
+
+//
+// The target type specifies which content pack the engine targets.
+// 
+// Note: An universal client is not currently possible without refactoring the network and the file system.
+//       Pak files must be reloaded on-the-fly depending on the server the client is connecting to.
+//
 #if TARGET_GAME_TYPE == 1
+	//
 	// Team Assault
-	#define BASEGAME				"mainta"
-	#define PRODUCT_EXTENSION		"Spearhead"
+	//
+	#define GAME_EXTENSION_BASE		"mainta"
+	#define PRODUCT_EXTENSION		"spearhead"
 	// The version string must be equal or above 2.0 to be able to connect to spearhead servers
 	#define TARGET_GAME_VERSION		"2.16"
 	#define TARGET_GAME_PROTOCOL	17
@@ -48,10 +70,12 @@ extern "C" {
 	#define HOMEPATH_NAME_WIN		"mohta"
 	#define HOMEPATH_NAME_MACOSX	HOMEPATH_NAME_WIN
 #elif TARGET_GAME_TYPE == 2
+	//
 	// Team Tactics
-	#define BASEGAME				"maintt"
-	#define PRODUCT_EXTENSION		"Breakthrough"
-		// The version string must be equal or above 2.0 to be able to connect to breakthrough servers
+	//
+	#define GAME_EXTENSION_BASE		"maintt"
+	#define PRODUCT_EXTENSION		"breakthrough"
+	// The version string must be equal or above 2.0 to be able to connect to breakthrough servers
 	#define	TARGET_GAME_VERSION		"2.41"
 	#define TARGET_GAME_PROTOCOL	17
 	#define TARGET_GAME_NAME		"mohaab"
@@ -60,11 +84,13 @@ extern "C" {
 	#define HOMEPATH_NAME_WIN		"mohtt"
 	#define HOMEPATH_NAME_MACOSX	HOMEPATH_NAME_WIN
 #else
-	// The default: the base game (no expansion)
-
-	#define BASEGAME				"main"
-	#define PRODUCT_EXTENSION		"Base"
-	// The version string must be below 1.12, otherwise it's not possible to connect
+	//
+	// Base game
+	//
+	
+	#define GAME_EXTENSION_BASE		"main"
+	#define PRODUCT_EXTENSION		"base"
+	// The version string must be 1.1x or below, otherwise it's not possible to connect
 	#define TARGET_GAME_VERSION		"1.12"
 	#define TARGET_GAME_PROTOCOL	8
 	#define TARGET_GAME_NAME		"mohaa"
@@ -74,11 +100,11 @@ extern "C" {
 	#define HOMEPATH_NAME_MACOSX	HOMEPATH_NAME_WIN
 #endif
 
-#define PRODUCT_NAME_FULL		PRODUCT_NAME ": " PRODUCT_EXTENSION
-#define PRODUCT_VERSION_FULL	PRODUCT_VERSION " (for " TARGET_GAME_VERSION ")"
+#define PRODUCT_NAME_FULL		PRODUCT_NAME " - v" PRODUCT_VERSION " - ext-" PRODUCT_EXTENSION
+#define PRODUCT_VERSION_FULL	PRODUCT_NAME_FULL
 
-#define CLIENT_WINDOW_TITLE     "OpenMoHAA"
-#define CLIENT_WINDOW_MIN_TITLE "OpenMoHAA"
+#define CLIENT_WINDOW_TITLE		PRODUCT_NAME
+#define CLIENT_WINDOW_MIN_TITLE PRODUCT_NAME
 
 #define MAX_TEAMNAME 32
 
@@ -428,6 +454,7 @@ enum {
 	MESSAGE_CHAT_WHITE,
 	MESSAGE_WHITE,
 	MESSAGE_CHAT_RED,
+	MESSAGE_CHAT_GREEN,
 	MESSAGE_MAX
 };
 
@@ -458,34 +485,6 @@ enum {
 #define HUD_MESSAGE_CHAT_WHITE		"\x02"
 #define HUD_MESSAGE_CHAT_RED		"\x04"
 
-#define CGM_HUDDRAW_SHADER			27
-#define CGM_HUDDRAW_ALIGN			28
-#define CGM_HUDDRAW_RECT			29
-#define CGM_HUDDRAW_VIRTUALSIZE		30
-#define CGM_HUDDRAW_COLOR			31
-#define CGM_HUDDRAW_ALPHA			32
-#define CGM_HUDDRAW_STRING			33
-#define CGM_HUDDRAW_FONT			34
-#define CGM_HUDDRAW_TIMER			38
-#define CGM_HUDDRAW_3D				39
-#define CGM_HUDDRAW_BREAK3D			40
-#define CGM_HUDDRAW_FADE			41
-#define CGM_HUDDRAW_MOVE			42
-#define CGM_HUDDRAW_SCALE			43
-#define CGM_VIEWMODELANIM			44
-#define CGM_VIEWMODELPREFIX			45
-#define CGM_MODHEIGHTFLOAT			46
-#define CGM_SETVMASPEED				47
-#define CGM_HINTSTRING				48
-#define CGM_PLAYLOCALSOUND			49
-#define CGM_SETLOCALSOUNDRATE		50
-#define CGM_STOPLOCALSOUND			51
-#define CGM_HUDDRAW_RECTX			52
-#define CGM_HUDDRAW_RECTY			53
-#define CGM_HUDDRAW_RECTWH			54
-#define CGM_REPLICATION				55
-#define CGM_HUDDRAW_DELETE			56
-
 extern vec4_t	g_color_table[8];
 
 #define	MAKERGB( v, r, g, b ) v[0]=r;v[1]=g;v[2]=b
@@ -1599,7 +1598,7 @@ typedef enum
 
 #define	RESERVED_CONFIGSTRINGS	2	// game can't modify below this, only the system can
 
-#define	MAX_GAMESTATE_CHARS	32000
+#define	MAX_GAMESTATE_CHARS	41952
 typedef struct {
 	int			stringOffsets[MAX_CONFIGSTRINGS];
 	char		stringData[MAX_GAMESTATE_CHARS];
@@ -1705,6 +1704,11 @@ typedef struct playerState_s {
 	float		camera_posofs[3];
 	int			camera_flags;
 	float		damage_angles[3];
+	// --
+	// Team Assault
+	int			radarInfo;
+	qboolean	voted;
+	// --
 
 	// not communicated over the net at all
 	int			ping;			// server to game info for scoreboard
@@ -1725,10 +1729,8 @@ typedef struct playerState_s {
 #define BUTTON_LEAN_LEFT_BITINDEX		4
 #define BUTTON_LEAN_RIGHT_BITINDEX		5
 #define BUTTON_TALK_BITINDEX			6			// displays talk balloon and disables actions
-#define BUTTON_ANY_BITINDEX				10			// any key whatsoever
-#define BUTTON_ANY2_BITINDEX			11			// any key whatsoever (regardless of keycatcher)
-#define BUTTON_MOUSE_BITINDEX			14			// mouse move
-#define BUTTON_HOLSTER_BITINDEX			15
+#define BUTTON_ANY_BITINDEX				14			// any key whatsoever
+#define BUTTON_MOUSE_BITINDEX			15			// mouse move
 
 #define	BUTTON_ATTACKLEFT  	   (1 << BUTTON_ATTACKLEFT_BITINDEX)
 #define	BUTTON_ATTACKRIGHT 	   (1 << BUTTON_ATTACKRIGHT_BITINDEX)
@@ -1738,9 +1740,7 @@ typedef struct playerState_s {
 #define BUTTON_LEAN_RIGHT      (1 << BUTTON_LEAN_RIGHT_BITINDEX)
 #define	BUTTON_TALK			   (1 << BUTTON_TALK_BITINDEX)			// displays talk balloon and disables actions
 #define	BUTTON_ANY			   (1 << BUTTON_ANY_BITINDEX)		   // any key whatsoever
-#define	BUTTON_ANY2            (1 << BUTTON_ANY_BITINDEX)		   // any key whatsoever (regardless of keycatcher)
 #define BUTTON_MOUSE           (1 << BUTTON_MOUSE_BITINDEX)
-#define BUTTON_HOLSTER         (1 << BUTTON_HOLSTER_BITINDEX)
 
 #define WEAPON_COMMAND_USE_PISTOL               1
 #define WEAPON_COMMAND_USE_RIFLE                2
@@ -1757,7 +1757,13 @@ typedef struct playerState_s {
 #define WEAPON_COMMAND_USE_LAST_WEAPON          13
 #define WEAPON_COMMAND_HOLSTER                  14
 #define WEAPON_COMMAND_DROP                     15
+
+#if TARGET_GAME_PROTOCOL >= 15
+#define WEAPON_COMMAND_MAX						31
+#else
 #define WEAPON_COMMAND_MAX						15
+#endif
+
 #define WEAPON_COMMAND_MASK						(WEAPON_COMMAND_MAX << 7)
 
 
@@ -2032,20 +2038,6 @@ typedef struct hdelement_s {
 	struct fontheader_s *pFont;
 } hdelement_t;
 
-enum vmAnim_e {
-    VM_ANIM_IDLE,
-    VM_ANIM_CHARGE,
-    VM_ANIM_FIRE,
-    VM_ANIM_FIRE_SECONDARY,
-    VM_ANIM_RECHAMBER,
-    VM_ANIM_RELOAD,
-    VM_ANIM_RELOAD_SINGLE,
-    VM_ANIM_RELOAD_END,
-    VM_ANIM_PULLOUT,
-    VM_ANIM_PUTAWAY,
-    VM_ANIM_LADDERSTEP
-};
-
 typedef struct {
 	frameInfo_t	g_VMFrameInfo[MAX_FRAMEINFOS];
 

code/qcommon/qcommon.h

@@ -83,7 +83,10 @@ void MSG_WriteLong (msg_t *sb, int c);
 void MSG_WriteFloat (msg_t *sb, float f);
 void MSG_WriteString (msg_t *sb, const char *s);
 void MSG_WriteBigString (msg_t *sb, const char *s);
+void MSG_WriteScrambledString(msg_t* sb, const char* s);
+void MSG_WriteScrambledBigString(msg_t* sb, const char* s);
 void MSG_WriteAngle16 (msg_t *sb, float f);
+void MSG_WriteEntityNum(msg_t* sb, short number);
 
 void	MSG_BeginReading (msg_t *sb);
 void	MSG_BeginReadingOOB(msg_t *sb);
@@ -104,9 +107,12 @@ float	MSG_ReadFloat (msg_t *sb);
 char	*MSG_ReadString (msg_t *sb);
 char	*MSG_ReadBigString (msg_t *sb);
 char	*MSG_ReadStringLine( msg_t *sb );
+char* MSG_ReadScrambledString(msg_t* msg);
+char* MSG_ReadScrambledBigString(msg_t* msg);
 float	MSG_ReadAngle8( msg_t *sb );
 float	MSG_ReadAngle16 (msg_t *sb);
 void	MSG_ReadData (msg_t *sb, void *buffer, int size);
+unsigned short MSG_ReadEntityNum(msg_t* sb);
 
 
 void MSG_WriteDeltaUsercmd( msg_t *msg, struct usercmd_s *from, struct usercmd_s *to );
@@ -158,6 +164,7 @@ void MSG_WritePackedSimple(msg_t* msg, int value, int bits);
 
 float MSG_UnpackAngle(int value, int bits);
 float MSG_UnpackAnimTime(int packed);
+float MSG_UnpackAnimWeight(int result, int bits);
 float MSG_UnpackScale(int packed);
 float MSG_UnpackAlpha(int packed, int bits);
 float MSG_UnpackCoord(int packed, int bits);
@@ -181,7 +188,7 @@ NET
 
 #define	PORT_ANY			-1
 
-#define	MAX_RELIABLE_COMMANDS	64			// max string commands buffered for restransmit
+#define	MAX_RELIABLE_COMMANDS	512			// max string commands buffered for restransmit
 
 typedef enum {
 	NA_BOT,

code/qcommon/qfiles.h

@@ -468,8 +468,8 @@ typedef struct {
 		// little-endian "2015"
 
 #define BSP_BETA_VERSION	18	// Beta Allied Assault
-#define BSP_BASE_VERSION	19	// vanilla Allied Assault
-#define BSP_VERSION			19	// current Allied Assault
+#define BSP_MIN_VERSION		18	// Beta Allied Assault
+#define BSP_MAX_VERSION		21	// Breakthrough
 
 
 // there shouldn't be any problem with increasing these values at the

code/qcommon/script.cpp

@@ -582,7 +582,7 @@ const char* Script::GrabNextToken(qboolean crossline)
             *token_p++ = *script_p++;
         }
 
-        if (token_p == &token[MAXTOKEN]) {
+        if (token_p == &token[SCRIPT_MAXTOKEN]) {
             FILE_Error(ERR_DROP, "Token too large on line %i in file %s\n",
                        line, filename.c_str());
         }
@@ -824,7 +824,7 @@ const char* Script::GetLine(qboolean crossline)
     start = script_p;
     SkipToEOL();
     size = script_p - start;
-    if (size < (MAXTOKEN - 1)) {
+    if (size < (SCRIPT_MAXTOKEN - 1)) {
         memcpy(token, start, size);
         token[size] = '\0';
     } else {
@@ -859,7 +859,7 @@ const char* Script::GetRaw(void)
     start = script_p;
     SkipToEOL();
     size = script_p - start;
-    if (size < (MAXTOKEN - 1)) {
+    if (size < (SCRIPT_MAXTOKEN - 1)) {
         memset(token, 0, sizeof(token));
         memcpy(token, start, size);
     } else {
@@ -946,7 +946,7 @@ const char* Script::GetString(qboolean crossline)
                        startline, filename.c_str());
         }
 
-        if (token_p == &token[MAXTOKEN]) {
+        if (token_p == &token[SCRIPT_MAXTOKEN]) {
             FILE_Error(ERR_DROP, "String too large on line %i in file %s\n",
                        line, filename.c_str());
         }
@@ -1075,7 +1075,7 @@ int Script::LinesInFile(void)
     qboolean temp_tokenready;
     const char* temp_script_p;
     int temp_line;
-    char temp_token[MAXTOKEN];
+    char temp_token[SCRIPT_MAXTOKEN];
     int numentries;
 
     temp_tokenready = tokenready;

code/qcommon/script.h

@@ -40,13 +40,13 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define TOKENSPACE   (' ')
 #define TOKENSPECIAL ('$')
 
-#define MAXTOKEN     512
+#define SCRIPT_MAXTOKEN     512
 
 typedef struct {
     qboolean tokenready;
     int offset;
     int line;
-    char token[MAXTOKEN];
+    char token[SCRIPT_MAXTOKEN];
 } scriptmarker_t;
 
 typedef struct {
@@ -67,7 +67,7 @@ protected:
     Container<macro*> macrolist;
 
     int line;
-    char token[MAXTOKEN];
+    char token[SCRIPT_MAXTOKEN];
 
     qboolean releaseBuffer;
     qboolean hasError;

code/qcommon/tiki_script.cpp

@@ -388,7 +388,7 @@ void TikiScript::AddMacro( const char *name, const char *expansion )
 			return;
 	}
 
-	if( nummacros >= MAXMACROS )
+	if( nummacros >= TIKI_MAXMACROS )
 	{
 		TIKI_DPrintf( "Too many %cdefine in file %s\n", TOKENSPECIAL, Filename() );
 	}
@@ -420,7 +420,7 @@ qboolean TikiScript::ProcessCommand( qboolean crossline )
 	char argument1[ 256 ];
 	char argument2[ 256 ];
 
-	sscanf( script_p, "%c%s %s %s\n", &dummy, &command, &argument1, &argument2 );
+	sscanf( script_p, "%c%s %s %s\n", &dummy, command, argument1, argument2 );
 
 	if( !stricmp( command, "define" ) )
 	{
@@ -760,7 +760,7 @@ const char *TikiScript::GetToken( qboolean crossline )
 			*token_p++ = *i->script_p++;
 		}
 
-		if( token_p == &i->token[ MAXTOKEN ] )
+		if( token_p == &i->token[ TIKI_MAXTOKEN ] )
 		{
 			TIKI_DPrintf( "Token too large on line %i in file %s\n", i->line, i->Filename() );
 			break;
@@ -869,7 +869,7 @@ const char *TikiScript::GetLine( qboolean crossline )
 	start = i->script_p;
 	SkipToEOL();
 	size = i->script_p - start;
-	if( size < ( MAXTOKEN - 1 ) )
+	if( size < ( TIKI_MAXTOKEN - 1 ) )
 	{
 		memcpy( i->token, start, size );
 		i->token[ size ] = '\0';
@@ -928,7 +928,7 @@ const char *TikiScript::GetAndIgnoreLine( qboolean crossline )
 	start = script_p;
 	SkipToEOL();
 	size = script_p - start;
-	if( size < ( MAXTOKEN - 1 ) )
+	if( size < ( TIKI_MAXTOKEN - 1 ) )
 	{
 		memcpy( token, start, size );
 		token[ size ] = '\0';
@@ -981,7 +981,7 @@ const char *TikiScript::GetRaw( void )
 	start = script_p;
 	SkipToEOL();
 	size = script_p - start;
-	if( size < ( MAXTOKEN - 1 ) )
+	if( size < ( TIKI_MAXTOKEN - 1 ) )
 	{
 		memset( token, 0, sizeof( token ) );
 		memcpy( token, start, size );
@@ -1086,7 +1086,7 @@ const char *TikiScript::GetString( qboolean crossline )
 				"line %d in file %s\n", startline, i->filename );
 		}
 
-		if( token_p == &i->token[ MAXTOKEN ] )
+		if( token_p == &i->token[ TIKI_MAXTOKEN ] )
 		{
 			TIKI_DPrintf( "String too large on line %i in file %s\n", i->line, i->filename );
 		}
@@ -1192,7 +1192,7 @@ int TikiScript::LinesInFile( void )
 	qboolean		temp_tokenready;
 	const char		*temp_script_p;
 	int				temp_line;
-	char			temp_token[ MAXTOKEN ];
+	char			temp_token[ TIKI_MAXTOKEN ];
 	int				numentries;
 
 	temp_tokenready		= tokenready;
@@ -1232,7 +1232,7 @@ void TikiScript::Parse( char *data, int length, const char *name )
 	Reset();
 	this->length = length;
 	end_p = script_p + length;
-	strncpy( filename, name, MAXTOKEN );
+	strncpy( filename, name, TIKI_MAXTOKEN );
 }
 
 /*

code/qcommon/tiki_script.h

@@ -32,21 +32,19 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define TOKENSPACE			(' ')
 #define TOKENSPECIAL		('$')
 
-#ifndef MAXTOKEN
-#define	MAXTOKEN	256
-#endif
+#define	TIKI_MAXTOKEN	256
 
-#define MAXMACROS	48
+#define TIKI_MAXMACROS	48
 
 typedef struct {
-	char name[ MAXTOKEN ];
-	char macro[ MAXTOKEN ];
+	char name[TIKI_MAXTOKEN];
+	char macro[TIKI_MAXTOKEN];
 } tiki_macro_t;
 
 typedef struct {
 	const char *mark_script_p;
 	qboolean mark_tokenready;
-	char mark_token[ MAXTOKEN ];
+	char mark_token[TIKI_MAXTOKEN];
 } tiki_mark_t;
 
 #ifdef __cplusplus
@@ -57,13 +55,13 @@ protected:
 	qboolean tokenready;
 	class TikiScript *include;
 	class TikiScript *parent;
-	char filename[ MAXTOKEN ];
+	char filename[TIKI_MAXTOKEN];
 	const char *script_p;
 	const char *end_p;
-	tiki_macro_t macros[ MAXMACROS ];
+	tiki_macro_t macros[TIKI_MAXMACROS];
 	int nummacros;
 	int line;
-	char token[ MAXTOKEN ];
+	char token[TIKI_MAXTOKEN];
 	qboolean releaseBuffer;
 	tiki_mark_t mark[ 64 ];
 	int mark_pos;

code/renderer/qgl.h

@@ -528,6 +528,34 @@ extern  void ( APIENTRY * qglVertex4sv )(const GLshort *v);
 extern  void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
 extern  void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);
 
+// GL_ARB_texture_compression
+extern void (APIENTRY* qglCompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data);
+extern void (APIENTRY* qglCompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
+extern void (APIENTRY* qglCompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data);
+extern void (APIENTRY* qglCompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
+extern void (APIENTRY* qglGetCompressedTexImageARB)(GLenum target, GLint lod, void* img);
+#ifndef GL_COMPRESSED_RGB_ARB
+#define GL_COMPRESSED_ALPHA_ARB						0x84E9
+#define GL_COMPRESSED_LUMINANCE_ARB					0x84EA
+#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB			0x84EB
+#define GL_COMPRESSED_INTENSITY_ARB					0x84EC
+#define GL_COMPRESSED_RGB_ARB						0x84ED
+#define GL_COMPRESSED_RGBA_ARB						0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT_ARB				0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB		0x86A0
+#define GL_TEXTURE_COMPRESSED_ARB					0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB		0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS_ARB			0x86A3
+#endif
+
+// GL_EXT_texture_compression_s3tc
+#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT                   0x83F0
+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT                  0x83F1
+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT                  0x83F2
+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT                  0x83F3
+#endif
+
 #if defined( _WIN32 )
 
 extern  int   ( WINAPI * qwglChoosePixelFormat )(HDC, CONST PIXELFORMATDESCRIPTOR *);

code/renderer/qgl_linked.h

@@ -355,3 +355,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define qglVertexPointer glVertexPointer
 #define qglViewport glViewport
 
+#define qglCompressedTexImage3DARB glCompressedTexImage3D
+#define qglCompressedTexImage2DARB glCompressedTexImage2D
+#define qglCompressedTexSubImage3DARB glCompressedTexSubImage3D
+#define qglCompressedTexSubImage2DARB glCompressedTexSubImage2D
+#define qglGetCompressedTexImageARB glGetCompressedTexImage

code/renderer/tr_backend.c

@@ -807,7 +807,7 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
 				if ( depthRange ) {
 					qglDepthRange (0, 0.3);
 				} else {
-					qglDepthRange (0, 1);
+					qglDepthRange (0, 1.875);
 				}
 				oldDepthRange = depthRange;
 			}
@@ -872,6 +872,10 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
 			}
 		}
 
+		if (*drawSurf->surface == SF_SPRITE) {
+			backEnd.shaderStartTime = ((refSprite_t*)drawSurf->surface)->shaderTime;
+		}
+
 		// add the triangles for this surface
 		rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
 	}
@@ -886,7 +890,16 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
 	// go back to the world modelview matrix
 	qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
 	if ( depthRange ) {
-		qglDepthRange (0, 1);
+		qglDepthRange (0, 1.875);
+	}
+
+	RB_ShadowFinish();
+	RB_RenderFlares();
+	R_DrawLensFlares();
+	if (g_bInfoworldtris)
+	{
+		g_bInfoworldtris = 0;
+		R_PrintInfoWorldtris();
 	}
 
 #if 0

code/renderer/tr_bsp.c

@@ -2233,9 +2233,9 @@ void RE_LoadWorldMap( const char *name ) {
 	c_gridVerts = 0;
 
     i = LittleLong(header.version);
-    if (i < BSP_BASE_VERSION || i > BSP_VERSION) {
+    if (i < BSP_MIN_VERSION || i > BSP_MAX_VERSION) {
         ri.Error(ERR_DROP, "RE_LoadWorldMap: %s has wrong version number (%i should be between %i and %i)",
-            name, i, BSP_BASE_VERSION, BSP_VERSION);
+            name, i, BSP_MIN_VERSION, BSP_MAX_VERSION);
     }
 
 	// load into heap

code/renderer/tr_image.c

@@ -552,36 +552,62 @@ static void Upload32(
 		// select proper internal format
 		if ( samples == 3 )
 		{
-			if ( glConfig.textureCompression == TC_S3TC )
+			if (!force32bit)
 			{
-				internalFormat = GL_RGB4_S3TC;
-			}
-			else if ( r_texturebits->integer == 16 )
-			{
-				internalFormat = GL_RGB5;
-			}
-			else if ( r_texturebits->integer == 32 )
-			{
-				internalFormat = GL_RGB8;
+				if (r_texturebits->integer == 16)
+				{
+					internalFormat = GL_RGB5;
+				}
+				else if (r_texturebits->integer == 32)
+				{
+					internalFormat = GL_RGB8;
+				}
+				else if (r_colorbits->integer == 16)
+				{
+					internalFormat = GL_RGBA4;
+				}
+				else if (r_colorbits->integer == 32)
+				{
+					internalFormat = GL_RGBA8;
+				}
+				else
+				{
+					internalFormat = 3;
+				}
 			}
 			else
 			{
-				internalFormat = 3;
+				internalFormat = GL_RGB8;
 			}
 		}
 		else if ( samples == 4 )
 		{
-			if ( r_texturebits->integer == 16 )
+			if (!force32bit)
 			{
-				internalFormat = GL_RGBA4;
-			}
-			else if ( r_texturebits->integer == 32 )
-			{
-				internalFormat = GL_RGBA8;
+				if (r_texturebits->integer == 16)
+				{
+					internalFormat = GL_RGBA4;
+				}
+				else if (r_texturebits->integer == 32)
+				{
+					internalFormat = GL_RGBA8;
+				}
+				else if (r_colorbits->integer == 16)
+				{
+					internalFormat = GL_RGBA4;
+				}
+				else if (r_colorbits->integer == 32)
+				{
+					internalFormat = GL_RGBA8;
+				}
+				else
+				{
+					internalFormat = 4;
+				}
 			}
 			else
 			{
-				internalFormat = 4;
+				internalFormat = GL_RGB8;
 			}
 		}
 	} else {
@@ -670,6 +696,161 @@ done:
 		ri.Hunk_FreeTempMemory( resampledBuffer );
 }
 
+static void UploadCompressed(
+	byte* data,
+	int width,
+	int height,
+	int numMipmaps,
+	int iMipmapsAvailable,
+	qboolean picmip,
+	int glCompressMode,
+	int* format,
+	int* pUploadWidth,
+	int* pUploadHeight,
+	int* pBytesUsed
+) {
+	byte* offset;
+	int i;
+	int iStartImage;
+	int size;
+	int blockSize;
+	int scaled_width, scaled_height;
+
+	offset = data;
+	iStartImage = 0;
+	if (picmip) {
+		iStartImage = r_picmip->integer;
+	}
+
+	if (iStartImage > 0 && iStartImage >= iMipmapsAvailable) {
+		iStartImage = iMipmapsAvailable - 1;
+	}
+
+	scaled_width = width;
+	scaled_height = height;
+	if (iStartImage)
+	{
+		scaled_width = width >> iStartImage;
+		scaled_height = height >> iStartImage;
+	}
+	while (scaled_width > glConfig.maxTextureSize || scaled_height > glConfig.maxTextureSize)
+	{
+		scaled_width >>= 1;
+		scaled_height >>= 1;
+		++iStartImage;
+	}
+	if (iStartImage > 0 && iStartImage >= iMipmapsAvailable)
+	{
+		iStartImage = iMipmapsAvailable - 1;
+		scaled_width = width >> (iMipmapsAvailable - 1);
+		scaled_height = height >> (iMipmapsAvailable - 1);
+	}
+
+	*pUploadWidth = scaled_width;
+	*pUploadHeight = scaled_height;
+	*format = glCompressMode;
+	blockSize = 16;
+
+	if (glCompressMode == GL_COMPRESSED_RGB_S3TC_DXT1_EXT || glCompressMode == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) {
+		blockSize = 8;
+	}
+
+	scaled_width = width;
+	scaled_height = height;
+
+	for (i = iStartImage; i; i--) {
+		int w, h;
+
+		w = scaled_width + 3;
+		if (scaled_width + 3 < 0) {
+			w = scaled_width + 6;
+		}
+		w >>= 2;
+
+		if (w > 1) {
+			h = scaled_height + 3;
+			if (scaled_height + 3 < 0) {
+				h = scaled_height + 6;
+			}
+
+			h >>= 2;
+			if (h > 1) {
+				offset += blockSize * w * h;
+			}
+		}
+
+		scaled_width >>= 1;
+		scaled_height >>= 1;
+		if (!scaled_width) scaled_width = 1;
+		if (!scaled_height) scaled_height = 1;
+	}
+
+	*pBytesUsed = 0;
+
+	for (;;)
+	{
+		while (scaled_width)
+		{
+			int w, h;
+
+			if (!scaled_height) scaled_height = 1;
+			w = scaled_width + 3;
+			if (scaled_width + 3 < 0) w = scaled_width + 6;
+			w >>= 2;
+
+			h = scaled_height + 3;
+			if (scaled_height + 3 < 0) h = scaled_height + 6;
+			h >>= 2;
+
+			size = blockSize * w * h;
+			if (w > 1 && h > 1) *pBytesUsed += size;
+			
+			qglCompressedTexImage2DARB(3553, i - iStartImage, glCompressMode, scaled_width, scaled_height, 0, size, data);
+			GL_CheckErrors();
+
+			if (i < iMipmapsAvailable)
+			{
+				w = scaled_width + 3;
+				if (scaled_width + 3 < 0) {
+					w = scaled_width + 6;
+				}
+
+				if (w >> 2 > 1)
+				{
+					h = scaled_height + 3;
+					if (scaled_height + 3 < 0) {
+						h = scaled_height + 6;
+					}
+
+					if (h >> 2 > 1)
+						data += size;
+				}
+			}
+			scaled_width >>= 1;
+			scaled_height >>= 1;
+			++i;
+		}
+
+		if (!scaled_height) {
+			break;
+		}
+
+		scaled_width = 1;
+	}
+
+	if (numMipmaps > 1) {
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+	}
+	else
+	{
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	}
+
+	GL_CheckErrors();
+}
+
 
 /*
 ================
@@ -733,6 +914,7 @@ image_t* R_CreateImage(
 	image->allowPicmip = allowPicmip;
 	image->dynamicallyUpdated = dynamicallyUpdated;
 	image->force32bit = force32bit;
+	image->UseCount = 0;
 
 	strcpy (image->imgName, name);
 
@@ -754,21 +936,37 @@ image_t* R_CreateImage(
 
 	GL_Bind(image);
 
-	Upload32(
-		(unsigned*)pic,
-		image->width,
-		image->height,
-		image->numMipmaps,
-		allowPicmip,
-		image->dynamicallyUpdated,
-		force32bit,
-		hasAlpha,
-		&image->internalFormat,
-		&image->uploadWidth,
-		&image->uploadHeight,
-		&image->bytesUsed,
-		isLightmap
-	);
+	if (glCompressMode) {
+		UploadCompressed(
+			pic,
+			image->width,
+			image->height,
+			image->numMipmaps,
+			iMipmapsAvailable,
+			allowPicmip,
+			glCompressMode,
+			&image->internalFormat,
+			&image->uploadWidth,
+			&image->uploadHeight,
+			&image->bytesUsed
+		);
+	} else {
+		Upload32(
+			(unsigned*)pic,
+			image->width,
+			image->height,
+			image->numMipmaps,
+			allowPicmip,
+			image->dynamicallyUpdated,
+			force32bit,
+			hasAlpha,
+			&image->internalFormat,
+			&image->uploadWidth,
+			&image->uploadHeight,
+			&image->bytesUsed,
+			isLightmap
+		);
+	}
 
 	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, glWrapClampModeX );
 	qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, glWrapClampModeY );
@@ -783,6 +981,7 @@ image_t* R_CreateImage(
 	hash = generateHashValue(name);
 	image->next = hashTable[hash];
 	hashTable[hash] = image;
+	image->r_sequence = r_sequencenumber;
 
 	return image;
 }
@@ -1101,6 +1300,342 @@ static void LoadPCX32 ( const char *filename, byte **pic, int *width, int *heigh
 	ri.Free (palette);
 }
 
+//==========================
+//
+// DDS Loading
+//
+//==========================
+
+typedef unsigned int   ui32_t;
+
+typedef struct ddsHeader_s
+{
+	ui32_t headerSize;
+	ui32_t flags;
+	ui32_t height;
+	ui32_t width;
+	ui32_t pitchOrFirstMipSize;
+	ui32_t volumeDepth;
+	ui32_t numMips;
+	ui32_t reserved1[11];
+	ui32_t always_0x00000020;
+	ui32_t pixelFormatFlags;
+	ui32_t fourCC;
+	ui32_t rgbBitCount;
+	ui32_t rBitMask;
+	ui32_t gBitMask;
+	ui32_t bBitMask;
+	ui32_t aBitMask;
+	ui32_t caps;
+	ui32_t caps2;
+	ui32_t caps3;
+	ui32_t caps4;
+	ui32_t reserved2;
+}
+ddsHeader_t;
+
+// flags:
+#define _DDSFLAGS_REQUIRED     0x001007
+#define _DDSFLAGS_PITCH        0x8
+#define _DDSFLAGS_MIPMAPCOUNT  0x20000
+#define _DDSFLAGS_FIRSTMIPSIZE 0x80000
+#define _DDSFLAGS_VOLUMEDEPTH  0x800000
+
+// pixelFormatFlags:
+#define DDSPF_ALPHAPIXELS 0x1
+#define DDSPF_ALPHA       0x2
+#define DDSPF_FOURCC      0x4
+#define DDSPF_RGB         0x40
+#define DDSPF_YUV         0x200
+#define DDSPF_LUMINANCE   0x20000
+
+// caps:
+#define DDSCAPS_COMPLEX  0x8
+#define DDSCAPS_MIPMAP   0x400000
+#define DDSCAPS_REQUIRED 0x1000
+
+// caps2:
+#define DDSCAPS2_CUBEMAP 0xFE00
+#define DDSCAPS2_VOLUME  0x200000
+
+typedef struct ddsHeaderDxt10_s
+{
+	ui32_t dxgiFormat;
+	ui32_t dimensions;
+	ui32_t miscFlags;
+	ui32_t arraySize;
+	ui32_t miscFlags2;
+}
+ddsHeaderDxt10_t;
+
+// dxgiFormat
+// from http://msdn.microsoft.com/en-us/library/windows/desktop/bb173059%28v=vs.85%29.aspx
+typedef enum DXGI_FORMAT {
+	DXGI_FORMAT_UNKNOWN = 0,
+	DXGI_FORMAT_R32G32B32A32_TYPELESS = 1,
+	DXGI_FORMAT_R32G32B32A32_FLOAT = 2,
+	DXGI_FORMAT_R32G32B32A32_UINT = 3,
+	DXGI_FORMAT_R32G32B32A32_SINT = 4,
+	DXGI_FORMAT_R32G32B32_TYPELESS = 5,
+	DXGI_FORMAT_R32G32B32_FLOAT = 6,
+	DXGI_FORMAT_R32G32B32_UINT = 7,
+	DXGI_FORMAT_R32G32B32_SINT = 8,
+	DXGI_FORMAT_R16G16B16A16_TYPELESS = 9,
+	DXGI_FORMAT_R16G16B16A16_FLOAT = 10,
+	DXGI_FORMAT_R16G16B16A16_UNORM = 11,
+	DXGI_FORMAT_R16G16B16A16_UINT = 12,
+	DXGI_FORMAT_R16G16B16A16_SNORM = 13,
+	DXGI_FORMAT_R16G16B16A16_SINT = 14,
+	DXGI_FORMAT_R32G32_TYPELESS = 15,
+	DXGI_FORMAT_R32G32_FLOAT = 16,
+	DXGI_FORMAT_R32G32_UINT = 17,
+	DXGI_FORMAT_R32G32_SINT = 18,
+	DXGI_FORMAT_R32G8X24_TYPELESS = 19,
+	DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20,
+	DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21,
+	DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22,
+	DXGI_FORMAT_R10G10B10A2_TYPELESS = 23,
+	DXGI_FORMAT_R10G10B10A2_UNORM = 24,
+	DXGI_FORMAT_R10G10B10A2_UINT = 25,
+	DXGI_FORMAT_R11G11B10_FLOAT = 26,
+	DXGI_FORMAT_R8G8B8A8_TYPELESS = 27,
+	DXGI_FORMAT_R8G8B8A8_UNORM = 28,
+	DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29,
+	DXGI_FORMAT_R8G8B8A8_UINT = 30,
+	DXGI_FORMAT_R8G8B8A8_SNORM = 31,
+	DXGI_FORMAT_R8G8B8A8_SINT = 32,
+	DXGI_FORMAT_R16G16_TYPELESS = 33,
+	DXGI_FORMAT_R16G16_FLOAT = 34,
+	DXGI_FORMAT_R16G16_UNORM = 35,
+	DXGI_FORMAT_R16G16_UINT = 36,
+	DXGI_FORMAT_R16G16_SNORM = 37,
+	DXGI_FORMAT_R16G16_SINT = 38,
+	DXGI_FORMAT_R32_TYPELESS = 39,
+	DXGI_FORMAT_D32_FLOAT = 40,
+	DXGI_FORMAT_R32_FLOAT = 41,
+	DXGI_FORMAT_R32_UINT = 42,
+	DXGI_FORMAT_R32_SINT = 43,
+	DXGI_FORMAT_R24G8_TYPELESS = 44,
+	DXGI_FORMAT_D24_UNORM_S8_UINT = 45,
+	DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46,
+	DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47,
+	DXGI_FORMAT_R8G8_TYPELESS = 48,
+	DXGI_FORMAT_R8G8_UNORM = 49,
+	DXGI_FORMAT_R8G8_UINT = 50,
+	DXGI_FORMAT_R8G8_SNORM = 51,
+	DXGI_FORMAT_R8G8_SINT = 52,
+	DXGI_FORMAT_R16_TYPELESS = 53,
+	DXGI_FORMAT_R16_FLOAT = 54,
+	DXGI_FORMAT_D16_UNORM = 55,
+	DXGI_FORMAT_R16_UNORM = 56,
+	DXGI_FORMAT_R16_UINT = 57,
+	DXGI_FORMAT_R16_SNORM = 58,
+	DXGI_FORMAT_R16_SINT = 59,
+	DXGI_FORMAT_R8_TYPELESS = 60,
+	DXGI_FORMAT_R8_UNORM = 61,
+	DXGI_FORMAT_R8_UINT = 62,
+	DXGI_FORMAT_R8_SNORM = 63,
+	DXGI_FORMAT_R8_SINT = 64,
+	DXGI_FORMAT_A8_UNORM = 65,
+	DXGI_FORMAT_R1_UNORM = 66,
+	DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67,
+	DXGI_FORMAT_R8G8_B8G8_UNORM = 68,
+	DXGI_FORMAT_G8R8_G8B8_UNORM = 69,
+	DXGI_FORMAT_BC1_TYPELESS = 70,
+	DXGI_FORMAT_BC1_UNORM = 71,
+	DXGI_FORMAT_BC1_UNORM_SRGB = 72,
+	DXGI_FORMAT_BC2_TYPELESS = 73,
+	DXGI_FORMAT_BC2_UNORM = 74,
+	DXGI_FORMAT_BC2_UNORM_SRGB = 75,
+	DXGI_FORMAT_BC3_TYPELESS = 76,
+	DXGI_FORMAT_BC3_UNORM = 77,
+	DXGI_FORMAT_BC3_UNORM_SRGB = 78,
+	DXGI_FORMAT_BC4_TYPELESS = 79,
+	DXGI_FORMAT_BC4_UNORM = 80,
+	DXGI_FORMAT_BC4_SNORM = 81,
+	DXGI_FORMAT_BC5_TYPELESS = 82,
+	DXGI_FORMAT_BC5_UNORM = 83,
+	DXGI_FORMAT_BC5_SNORM = 84,
+	DXGI_FORMAT_B5G6R5_UNORM = 85,
+	DXGI_FORMAT_B5G5R5A1_UNORM = 86,
+	DXGI_FORMAT_B8G8R8A8_UNORM = 87,
+	DXGI_FORMAT_B8G8R8X8_UNORM = 88,
+	DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89,
+	DXGI_FORMAT_B8G8R8A8_TYPELESS = 90,
+	DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91,
+	DXGI_FORMAT_B8G8R8X8_TYPELESS = 92,
+	DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93,
+	DXGI_FORMAT_BC6H_TYPELESS = 94,
+	DXGI_FORMAT_BC6H_UF16 = 95,
+	DXGI_FORMAT_BC6H_SF16 = 96,
+	DXGI_FORMAT_BC7_TYPELESS = 97,
+	DXGI_FORMAT_BC7_UNORM = 98,
+	DXGI_FORMAT_BC7_UNORM_SRGB = 99,
+	DXGI_FORMAT_AYUV = 100,
+	DXGI_FORMAT_Y410 = 101,
+	DXGI_FORMAT_Y416 = 102,
+	DXGI_FORMAT_NV12 = 103,
+	DXGI_FORMAT_P010 = 104,
+	DXGI_FORMAT_P016 = 105,
+	DXGI_FORMAT_420_OPAQUE = 106,
+	DXGI_FORMAT_YUY2 = 107,
+	DXGI_FORMAT_Y210 = 108,
+	DXGI_FORMAT_Y216 = 109,
+	DXGI_FORMAT_NV11 = 110,
+	DXGI_FORMAT_AI44 = 111,
+	DXGI_FORMAT_IA44 = 112,
+	DXGI_FORMAT_P8 = 113,
+	DXGI_FORMAT_A8P8 = 114,
+	DXGI_FORMAT_B4G4R4A4_UNORM = 115,
+	DXGI_FORMAT_FORCE_UINT = 0xffffffffUL
+} DXGI_FORMAT;
+
+#define EncodeFourCC(x) ((((ui32_t)((x)[0]))      ) | \
+                         (((ui32_t)((x)[1])) << 8 ) | \
+                         (((ui32_t)((x)[2])) << 16) | \
+                         (((ui32_t)((x)[3])) << 24) )
+
+
+static void LoadDDS(const char* name, byte** pic, int* width, int* height, qboolean* hasAlpha, int* glCompressMode, int* numMipmaps, int* piMipmapsAvailable) {
+	union {
+		byte* b;
+		void* v;
+	} buffer;
+	int len;
+	ddsHeader_t* ddsHeader = NULL;
+	ddsHeaderDxt10_t* ddsHeaderDxt10 = NULL;
+	byte* data;
+
+	*pic = 0;
+	*piMipmapsAvailable = 0;
+
+	if (width)
+		*width = 0;
+	if (height)
+		*height = 0;
+
+	*pic = NULL;
+
+	//
+	// load the file
+	//
+	len = ri.FS_ReadFile((char*)name, &buffer.v);
+	if (!buffer.b || len < 0) {
+		return;
+	}
+
+	//
+	// reject files that are too small to hold even a header
+	//
+	if (len < 4 + sizeof(*ddsHeader))
+	{
+		ri.Printf(PRINT_ALL, "File %s is too small to be a DDS file.\n", name);
+		ri.FS_FreeFile(buffer.v);
+		return;
+	}
+
+	//
+	// reject files that don't start with "DDS "
+	//
+	if (*((ui32_t*)(buffer.b)) != EncodeFourCC("DDS "))
+	{
+		ri.Printf(PRINT_ALL, "File %s is not a DDS file.\n", name);
+		ri.FS_FreeFile(buffer.v);
+		return;
+	}
+
+	//
+	// parse header and dx10 header if available
+	//
+	ddsHeader = (ddsHeader_t*)(buffer.b + 4);
+	if ((ddsHeader->pixelFormatFlags & DDSPF_FOURCC) && ddsHeader->fourCC == EncodeFourCC("DX10"))
+	{
+		if (len < 4 + sizeof(*ddsHeader) + sizeof(*ddsHeaderDxt10))
+		{
+			ri.Printf(PRINT_ALL, "File %s indicates a DX10 header it is too small to contain.\n", name);
+			ri.FS_FreeFile(buffer.v);
+			return;
+		}
+
+		ddsHeaderDxt10 = (ddsHeaderDxt10_t*)(buffer.b + 4 + sizeof(ddsHeader_t));
+		data = buffer.b + 4 + sizeof(*ddsHeader) + sizeof(*ddsHeaderDxt10);
+		len -= 4 + sizeof(*ddsHeader) + sizeof(*ddsHeaderDxt10);
+	}
+	else
+	{
+		data = buffer.b + 4 + sizeof(*ddsHeader);
+		len -= 4 + sizeof(*ddsHeader);
+	}
+
+	if (width)
+		*width = ddsHeader->width;
+	if (height)
+		*height = ddsHeader->height;
+
+	if (piMipmapsAvailable)
+	{
+		if (ddsHeader->flags & _DDSFLAGS_MIPMAPCOUNT)
+			*piMipmapsAvailable = ddsHeader->numMips;
+		else
+			*piMipmapsAvailable = 1;
+	}
+
+	// FIXME: handle cube map
+	//if ((ddsHeader->caps2 & DDSCAPS2_CUBEMAP) == DDSCAPS2_CUBEMAP)
+
+	//
+	// Convert DXGI format/FourCC into OpenGL format
+	//
+	if (ddsHeaderDxt10)
+	{
+		ri.Printf(PRINT_ALL, "DDS File %s has unsupported DXGI format %d.", name, ddsHeaderDxt10->dxgiFormat);
+		ri.FS_FreeFile(buffer.v);
+		return;
+	}
+	else
+	{
+		if (ddsHeader->pixelFormatFlags & DDSPF_FOURCC)
+		{
+			if (ddsHeader->fourCC == EncodeFourCC("DXT1"))
+				*glCompressMode = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+			else if (ddsHeader->fourCC == EncodeFourCC("DXT2"))
+				*glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+			else if (ddsHeader->fourCC == EncodeFourCC("DXT3"))
+				*glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+			else if (ddsHeader->fourCC == EncodeFourCC("DXT4"))
+				*glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+			else if (ddsHeader->fourCC == EncodeFourCC("DXT5"))
+				*glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+			else
+			{
+				ri.Printf(PRINT_ALL, "DDS File %s has unsupported FourCC.", name);
+				ri.FS_FreeFile(buffer.v);
+				return;
+			}
+		}
+		else if (ddsHeader->pixelFormatFlags == (DDSPF_RGB | DDSPF_ALPHAPIXELS)
+			&& ddsHeader->rgbBitCount == 32
+			&& ddsHeader->rBitMask == 0x000000ff
+			&& ddsHeader->gBitMask == 0x0000ff00
+			&& ddsHeader->bBitMask == 0x00ff0000
+			&& ddsHeader->aBitMask == 0xff000000)
+		{
+			*glCompressMode = GL_RGBA8;
+		}
+		else
+		{
+			ri.Printf(PRINT_ALL, "DDS File %s has unsupported RGBA format.", name);
+			ri.FS_FreeFile(buffer.v);
+			return;
+		}
+	}
+
+	*pic = ri.Malloc(len);
+	Com_Memcpy(*pic, data, len);
+
+	ri.FS_FreeFile(buffer.v);
+}
+
 /*
 =========================================================
 
@@ -1886,8 +2421,10 @@ Loads any of the supported image types into a cannonical
 =================
 */
 static void R_LoadImage(const char* name, byte** pic, int* width, int* height, qboolean* hasAlpha, int* glCompressMode, int* numMipmaps, int* piMipmapsAvailable) {
-	int		len;
+	size_t	len;
 	char	tempName[MAX_STRING_TOKENS + 1];
+	char altname[MAX_QPATH];
+
 
 	*hasAlpha = qfalse;
 	*glCompressMode = 0;
@@ -1900,30 +2437,48 @@ static void R_LoadImage(const char* name, byte** pic, int* width, int* height, q
 		return;
 	}
 
-	if (!Q_stricmp(name + len - 4, ".tga")) {
-		LoadTGA(name, pic, width, height);            // try tga first
-		if (!*pic) {                                    //
-			char altname[MAX_QPATH];                      // try jpg in place of tga 
-			strcpy(altname, name);
-			len = strlen(altname);
-			altname[len - 3] = 'j';
-			altname[len - 2] = 'p';
-			altname[len - 1] = 'g';
-			LoadJPG(altname, pic, width, height);
+	strcpy(altname, name);
+	len = strlen(altname);
+	if (glConfig.textureCompression == 1)
+	{
+		len = strlen(altname);
+		altname[len - 3] = 'd';
+		altname[len - 2] = 'd';
+		altname[len - 1] = 's';
+		LoadDDS(altname, pic, width, height, hasAlpha, glCompressMode, numMipmaps, piMipmapsAvailable);
+	}
+
+	if (!*pic)
+	{
+		if (!Q_stricmp(name + len - 4, ".tga") || !Q_stricmp(name + len - 4, ".jpg")) {
+			if (r_loadjpg->integer) {
+				len = strlen(altname);
+				altname[len - 3] = 'j';
+				altname[len - 2] = 'p';
+				altname[len - 1] = 'g';
+				// try jpg first
+				LoadJPG(altname, pic, width, height);
+			}
+			if (!*pic) {
+				altname[len - 3] = 't';
+				altname[len - 2] = 'g';
+				altname[len - 1] = 'a';
+				LoadTGA(altname, pic, width, height);
+			}
+			*piMipmapsAvailable = 1;
+		}
+		else if (!Q_stricmp(name + len - 4, ".pcx")) {
+			LoadPCX32(name, pic, width, height);
+			*piMipmapsAvailable = 1;
+		}
+		else if (!Q_stricmp(name + len - 4, ".bmp")) {
+			LoadBMP(name, pic, width, height);
+			*piMipmapsAvailable = 1;
+		}
+		else if (!Q_stricmp(name + len - 4, ".jpg")) {
+			LoadJPG(name, pic, width, height);
+			*piMipmapsAvailable = 1;
 		}
-		*piMipmapsAvailable = 1;
-	}
-	else if (!Q_stricmp(name + len - 4, ".pcx")) {
-		LoadPCX32(name, pic, width, height);
-		*piMipmapsAvailable = 1;
-	}
-	else if (!Q_stricmp(name + len - 4, ".bmp")) {
-		LoadBMP(name, pic, width, height);
-		*piMipmapsAvailable = 1;
-	}
-	else if (!Q_stricmp(name + len - 4, ".jpg")) {
-		LoadJPG(name, pic, width, height);
-		*piMipmapsAvailable = 1;
 	}
 
 	if (scr_initialized)
@@ -1972,7 +2527,7 @@ image_t* R_FindImageFile(const char* name, qboolean mipmap, qboolean allowPicmip
 				if (image->allowPicmip != allowPicmip) {
 					ri.Printf(PRINT_DEVELOPER, "WARNING: reused image %s with mixed allowPicmip parm\n", name);
 				}
-				if (image->wrapClampModeX != glWrapClampModeX || image != glWrapClampModeY) {
+				if (image->wrapClampModeX != glWrapClampModeX || image->wrapClampModeY != glWrapClampModeY) {
 					ri.Printf(PRINT_ALL, "WARNING: reused image %s with mixed glWrapClampMode parm\n", name);
 				}
 			}

code/renderer/tr_init.c

@@ -1462,6 +1462,7 @@ refexport_t *GetRefAPI ( int apiVersion, refimport_t *rimp ) {
     re.UnregisterServerModel = RE_UnregisterServerModel;
     re.RegisterShader = RE_RegisterShader;
     re.RegisterShaderNoMip = RE_RegisterShaderNoMip;
+	re.RefreshShaderNoMip = RE_RefreshShaderNoMip;
     re.LoadWorld = RE_LoadWorldMap;
     re.PrintBSPFileSizes = RE_PrintBSPFileSizes;
     re.MapVersion = RE_MapVersion;

code/renderer/tr_light.c

@@ -350,7 +350,63 @@ void RB_SetupEntityGridLighting()
 
 void RB_SetupStaticModelGridLighting(trRefdef_t* refdef, cStaticModelUnpacked_t* ent, const vec3_t lightOrigin)
 {
-	// FIXME: unimplemented
+	int iColor;
+	int i;
+	dlight_t* dl;
+	float power;
+	vec3_t vLight;
+	vec3_t dir;
+	float d;
+
+	if (ent->bLightGridCalculated) {
+		return;
+	}
+	ent->bLightGridCalculated = qtrue;
+
+	if (!(refdef->rdflags & RDF_NOWORLDMODEL) && tr.world->lightGridData) {
+		R_GetLightingGridValue(backEnd.currentSphere->traceOrigin, vLight);
+	}
+	else {
+		vLight[0] = vLight[1] = vLight[2] = tr.identityLight * 150.0;
+	}
+
+	for (i = 0; i < refdef->num_dlights; i++) {
+		dl = &refdef->dlights[i];
+		VectorSubtract(dl->origin, lightOrigin, dir);
+		d = VectorLengthSquared(dir);
+
+		power = dl->radius * dl->radius;
+		if (power >= d) {
+			d = dl->radius * 7500.0 / d;
+			VectorMA(vLight, d, dl->color, vLight);
+		}
+	}
+
+	if (tr.overbrightShift)
+	{
+		vLight[0] = tr.overbrightMult * vLight[0];
+		vLight[1] = tr.overbrightMult * vLight[1];
+		vLight[2] = tr.overbrightMult * vLight[2];
+	}
+
+	// normalize
+	if (vLight[0] < 255.0 || vLight[1] < 255.0 || vLight[2] < 255.0) {
+		float scale = 255.0 / fmin(vLight[0], fmin(vLight[1], vLight[2]));
+		VectorScale(vLight, scale, vLight);
+	}
+
+	// clamp ambient
+	for (i = 0; i < 3; i++) {
+		if (vLight[i] > tr.identityLightByte) {
+			vLight[i] = tr.identityLightByte;
+		}
+	}
+
+	// save out the byte packet version
+	((byte*)&ent->iGridLighting)[0] = myftol(vLight[0]);
+	((byte*)&ent->iGridLighting)[1] = myftol(vLight[1]);
+	((byte*)&ent->iGridLighting)[2] = myftol(vLight[2]);
+	((byte*)&ent->iGridLighting)[3] = 0xff;
 }
 
 /*

code/renderer/tr_local.h

@@ -1728,6 +1728,7 @@ skin_t	*R_GetSkinByHandle( qhandle_t hSkin );
 //
 qhandle_t		 RE_RegisterShader( const char *name );
 qhandle_t		 RE_RegisterShaderNoMip( const char *name );
+qhandle_t		RE_RefreshShaderNoMip(const char* name);
 qhandle_t RE_RegisterShaderFromImage(const char *name, int lightmapIndex, image_t *image, qboolean mipRawImage);
 
 shader_t* R_FindShader(const char* name, int lightmapIndex, qboolean mipRawImage, qboolean picmip, qboolean wrapx, qboolean wrapy);
@@ -1878,6 +1879,7 @@ void R_GetLightingForDecal(vec3_t vLight, vec3_t vFacing, vec3_t vOrigin);
 void R_GetLightingForSmoke(vec3_t vLight, vec3_t vOrigin);
 void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent );
 void RB_SetupEntityGridLighting();
+void RB_SetupStaticModelGridLighting(trRefdef_t* refdef, cStaticModelUnpacked_t* ent, const vec3_t lightOrigin);
 void R_TransformDlights( int count, dlight_t *dl, orientationr_t *ori );
 void RB_Light_Real(unsigned char* colors);
 void RB_Sphere_BuildDLights();
@@ -1964,7 +1966,7 @@ void RE_AddRefEntityToScene( const refEntity_t *ent, int parentEntityNumber);
 void RE_AddRefSpriteToScene(const refEntity_t* ent);
 void RE_AddTerrainMarkToScene(int iTerrainIndex, qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx);
 refEntity_t* RE_GetRenderEntity(int entityNumber);
-qboolean RE_AddPolyToScene(qhandle_t hShader, int numVerts, polyVert_t* verts, int renderfx);
+qboolean RE_AddPolyToScene(qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx);
 void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b, int type );
 void RE_AddAdditiveLightToScene( const vec3_t org, float intensity, float r, float g, float b );
 void RE_RenderScene( const refdef_t *fd );
@@ -2036,6 +2038,7 @@ SUN FLARE
 =============================================================
 */
 void R_InitLensFlare();
+void R_DrawLensFlares();
 
 /*
 =============================================================
@@ -2090,6 +2093,7 @@ void R_PrintInfoStaticModels();
 void R_AddSkelSurfaces(trRefEntity_t* ent);
 void R_AddStaticModelSurfaces(void);
 float R_CalcLod(const vec3_t origin, float radius);
+void R_PrintInfoWorldtris(void);
 
 extern int g_nStaticSurfaces;
 extern qboolean g_bInfostaticmodels;

code/renderer/tr_public.h

@@ -126,7 +126,7 @@ typedef struct {
     dtiki_t* (*R_Model_GetHandle)(qhandle_t handle);
     void (*DrawString)(fontheader_t* font, const char* text, float x, float y, int maxLen, qboolean virtualScreen);
     float (*GetFontHeight)(const fontheader_t* font);
-    float (*GetFontStringWidth)(const fontheader_t* font, char* string);
+    float (*GetFontStringWidth)(const fontheader_t* font, const char* string);
     fontheader_t* (*LoadFont)(const char* name);
     void (*SwipeBegin)(float thisTime, float life, qhandle_t hShader);
     void (*SwipePoint)(vec3_t point1, vec3_t point2, float time);

code/renderer/tr_scene.c

@@ -131,7 +131,7 @@ RE_AddPolyToScene
 
 =====================
 */
-qboolean RE_AddPolyToScene(qhandle_t hShader, int numVerts, polyVert_t* verts, int renderfx) {
+qboolean RE_AddPolyToScene(qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx) {
 	srfPoly_t	*poly;
 
 	if ( !tr.registered ) {

code/renderer/tr_shade.c

@@ -306,7 +306,6 @@ to overflow.
 ==============
 */
 void RB_BeginSurface( shader_t *shader ) {
-
 	tess.numIndexes = 0;
 	tess.numVertexes = 0;
 	tess.shader = shader;
@@ -316,12 +315,6 @@ void RB_BeginSurface( shader_t *shader ) {
 	tess.numPasses = shader->numUnfoggedPasses;
 	tess.currentStageIteratorFunc = shader->optimalStageIteratorFunc;
 
-	tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset;
-	if (tess.shader->clampTime && tess.shaderTime >= tess.shader->clampTime) {
-		tess.shaderTime = tess.shader->clampTime;
-	}
-
-
 }
 
 /*
@@ -1394,7 +1387,7 @@ void RB_StageIteratorVertexLitTextureUnfogged( void )
 	// 
 	// now do any dynamic lighting needed
 	//
-	if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE ) {
+	if ( tess.dlightBits && !tess.dlightMap && tess.shader->sort <= SS_OPAQUE ) {
 		ProjectDlightTexture();
 	}
 
@@ -1463,7 +1456,11 @@ void RB_StageIteratorLightmappedMultitextureUnfogged( void ) {
 	} else {
 		GL_TexEnv( GL_MODULATE );
 	}
-	R_BindAnimatedImage( &tess.xstages[0]->bundle[1] );
+	if (tess.dlightMap && tess.xstages[0]->bundle[1].isLightmap) {
+		GL_Bind(&tr.identityLightImage[tess.dlightMap]);
+	} else {
+		R_BindAnimatedImage(&tess.xstages[0]->bundle[1]);
+	}
 	qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
 	qglTexCoordPointer( 2, GL_FLOAT, 16, tess.texCoords[0][1] );
 
@@ -1492,7 +1489,7 @@ void RB_StageIteratorLightmappedMultitextureUnfogged( void ) {
 	// 
 	// now do any dynamic lighting needed
 	//
-	if ( tess.dlightBits && tess.shader->sort <= SS_OPAQUE ) {
+	if ( tess.dlightBits && !tess.dlightMap && tess.shader->sort <= SS_OPAQUE ) {
 		ProjectDlightTexture();
 	}
 

code/renderer/tr_shade_calc.c

@@ -619,7 +619,7 @@ void RB_CalcColorFromOneMinusEntity( unsigned char *dstColors )
 {
 	int	i;
 	int *pColors = ( int * ) dstColors;
-	unsigned char invModulate[3];
+	unsigned char invModulate[4];
 	int c;
 
 	if ( !backEnd.currentEntity )

code/renderer/tr_shader.c

@@ -1680,7 +1680,12 @@ static void ParseSkyParms( char **text ) {
 		for (i=0 ; i<6 ; i++) {
 			Com_sprintf( pathname, sizeof(pathname), "%s_%s.tga"
 				, token, suf[i] );
-			shader.sky.outerbox[i] = R_FindImageFile( ( char * ) pathname, qtrue, qtrue, qfalse, GL_CLAMP, GL_CLAMP );
+			if (!r_forceClampToEdge->integer) {
+				shader.sky.outerbox[i] = R_FindImageFile((char*)pathname, qtrue, qtrue, shader_force32bit, GL_CLAMP, GL_CLAMP);
+			}
+			else {
+				shader.sky.outerbox[i] = R_FindImageFile((char*)pathname, qtrue, qtrue, shader_force32bit, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+			}
 			if ( !shader.sky.outerbox[i] ) {
 				shader.sky.outerbox[i] = tr.defaultImage;
 			}
@@ -1710,7 +1715,7 @@ static void ParseSkyParms( char **text ) {
 		for (i=0 ; i<6 ; i++) {
 			Com_sprintf( pathname, sizeof(pathname), "%s_%s.tga"
 				, token, suf[i] );
-			shader.sky.outerbox[i] = R_FindImageFile( ( char * ) pathname, qtrue, qtrue, qfalse, GL_REPEAT, GL_REPEAT );
+			shader.sky.outerbox[i] = R_FindImageFile( ( char * ) pathname, qtrue, qtrue, shader_force32bit, GL_REPEAT, GL_REPEAT );
 			if ( !shader.sky.innerbox[i] ) {
 				shader.sky.innerbox[i] = tr.defaultImage;
 			}
@@ -3069,6 +3074,11 @@ qhandle_t RE_RegisterShaderNoMip( const char *name ) {
 	return sh->index;
 }
 
+qhandle_t RE_RefreshShaderNoMip(const char* name) {
+	// FIXME: unimplemented
+	// Workaround
+	return RE_RegisterShaderNoMip(name);
+}
 
 /*
 ====================

code/renderer/tr_sky.c

@@ -811,7 +811,7 @@ void RB_StageIteratorSky( void ) {
 	if ( r_showsky->integer ) {
 		qglDepthRange( 0.0, 0.0 );
 	} else {
-		qglDepthRange( 1.0, 1.0 );
+		qglDepthRange( 1.875, 1.875 );
 	}
 
 	// draw the outer skybox

code/renderer/tr_sphere_shade.cpp

@@ -204,7 +204,7 @@ void RB_Grid_SetupEntity()
 
 void RB_Grid_SetupStaticModel()
 {
-	// FIXME: unimplemented
+	RB_SetupStaticModelGridLighting(&tr.refdef, backEnd.currentStaticModel, backEnd.currentStaticModel->origin);
 }
 
 void RB_Light_Fullbright(unsigned char* colors)

code/renderer/tr_staticmodels.cpp

@@ -390,7 +390,34 @@ void R_AddStaticModelSurfaces(void) {
 
 void RB_Static_BuildDLights()
 {
-    // FIXME: unimplemented
+    int i;
+
+	backEnd.currentStaticModel->useSpecialLighting = backEnd.refdef.num_dlights > 0;
+	backEnd.currentStaticModel->numdlights = 0;
+
+    if (!backEnd.currentStaticModel->useSpecialLighting) {
+        return;
+    }
+
+    for (i = 0; i < backEnd.refdef.num_dlights && backEnd.currentStaticModel->numdlights != 32; i++) {
+        vec3_t lightorigin, delta;
+
+        VectorCopy(backEnd.refdef.dlights[i].origin, lightorigin);
+        VectorSubtract(lightorigin, backEnd.currentStaticModel->origin, delta);
+        if (backEnd.refdef.dlights[i].radius * 2.0 >= VectorLength(delta)) {
+            MatrixTransformVectorRight(
+                backEnd.currentStaticModel->axis,
+                delta,
+                backEnd.currentStaticModel->dlights[backEnd.currentStaticModel->numdlights].transformed
+            );
+
+            backEnd.currentStaticModel->dlights[backEnd.currentStaticModel->numdlights++].index = i;
+        }
+    }
+
+    if (!backEnd.currentStaticModel->numdlights) {
+        backEnd.currentStaticModel->useSpecialLighting = qfalse;
+    }
 }
 
 void R_InfoStaticModels_f()
@@ -476,7 +503,9 @@ void RB_StaticMesh(staticSurface_t* staticSurf) {
         Vector4Copy(surf->pStaticXyz[j], tess.xyz[baseVertex + j]);
         Vector4Copy(surf->pStaticNormal[j], tess.normal[baseVertex + j]);
         tess.texCoords[baseVertex + j][0][0] = surf->pStaticTexCoords[j][0][0];
-        tess.texCoords[baseVertex + j][0][1] = surf->pStaticTexCoords[j][0][1];
+		tess.texCoords[baseVertex + j][0][1] = surf->pStaticTexCoords[j][0][1];
+		tess.texCoords[baseVertex + j][1][0] = surf->pStaticTexCoords[j][1][0];
+		tess.texCoords[baseVertex + j][1][1] = surf->pStaticTexCoords[j][1][1];
     }
 
     if (backEndData[backEnd.smpFrame]->staticModelData) {

code/renderer/tr_sun_flare.cpp

@@ -28,3 +28,8 @@ void R_InitLensFlare()
 {
     // FIXME: unimplemented
 }
+
+void R_DrawLensFlares()
+{
+	// FIXME: unimplemented
+}

code/renderer/tr_terrain.c

@@ -1317,8 +1317,8 @@ void R_AddTerrainSurfaces()
 				{
 					Com_DPrintf(
 						"%5d tris / %5d verts / %4d splits / %4d merges\n",
-						g_nTris + ~g_tri.nFree,
-						g_nVerts + ~g_vert.nFree,
+						g_nTris - g_tri.nFree,
+						g_nVerts - g_vert.nFree,
 						g_nSplit,
 						g_nMerge);
 				}

code/server/sv_client.c

@@ -225,7 +225,8 @@ void SV_DirectConnect( netadr_t from ) {
 	char		userinfo[MAX_INFO_STRING];
 	int			i;
 	client_t	*cl, *newcl;
-	client_t	temp;
+	// Make this a temp variable to avoid stack overflow issues
+	static client_t temp;
 	gentity_t	*ent;
 	int			clientNum;
 	int			version;
@@ -439,9 +440,15 @@ gotnewcl:
 	Com_DPrintf( "Going from CS_FREE to CS_CONNECTED for %s\n", newcl->name );
 
 	newcl->state = CS_CONNECTED;
-	newcl->nextSnapshotTime = svs.time;
-	newcl->lastPacketTime = svs.time;
-	newcl->lastConnectTime = svs.time;
+	if (sv_maxclients->integer > 1) {
+		newcl->nextSnapshotTime = svs.time + 800;
+		newcl->lastPacketTime = svs.time + 800;
+		newcl->lastConnectTime = svs.time + 800;
+	} else {
+		newcl->nextSnapshotTime = svs.time + 300;
+		newcl->lastPacketTime = svs.time + 300;
+		newcl->lastConnectTime = svs.time + 300;
+	}
 	
 	// when we receive the first packet from the client, we will
 	// notice that it is from a different serverid and that the
@@ -530,6 +537,19 @@ void SV_DropClient( client_t *drop, const char *reason ) {
 	}
 }
 
+#if TARGET_GAME_PROTOCOL >= 15
+
+void MSG_WriteServerFrameTime(msg_t* msg, float f) {
+	MSG_WriteFloat(msg, f);
+}
+
+#else
+
+void MSG_WriteServerFrameTime(msg_t* msg, float f) {
+}
+
+#endif
+
 /*
 ================
 SV_SendClientGameState
@@ -583,7 +603,7 @@ void SV_SendClientGameState( client_t *client ) {
 		if (sv.configstrings[start][0]) {
 			MSG_WriteSVC( &msg, svc_configstring );
 			MSG_WriteShort( &msg, start );
-			MSG_WriteString( &msg, sv.configstrings[start] );
+			MSG_WriteScrambledBigString( &msg, sv.configstrings[start] );
 		}
 	}
 
@@ -604,7 +624,10 @@ void SV_SendClientGameState( client_t *client ) {
 	MSG_WriteLong( &msg, client - svs.clients);
 
 	// write the checksum feed
-	MSG_WriteLong( &msg, sv.checksumFeed);
+	MSG_WriteLong( &msg, 0);
+
+	// write the server frametime to the client (only on TA/TT)
+	MSG_WriteServerFrameTime(&msg, sv.frameTime);
 
 	// deliver this to the client
 	SV_SendMessageToClient( &msg, client );
@@ -1310,7 +1333,7 @@ static qboolean SV_ClientCommand( client_t *cl, msg_t *msg ) {
 	qboolean clientOk = qtrue;
 
 	seq = MSG_ReadLong( msg );
-	s = MSG_ReadString( msg );
+	s = MSG_ReadScrambledString( msg );
 
 	// see if we have already executed it
 	if ( cl->lastClientCommand >= seq ) {

code/server/sv_init.c

@@ -521,6 +521,7 @@ void SV_ClearServer(void) {
 		}
 	}
 	Com_Memset (&sv, 0, sizeof(sv));
+	sv.frameTime = 1.0 / sv_fps->value;
 }
 
 /*
@@ -1012,7 +1013,7 @@ void SV_Init( void ) {
 	sv_showloss = Cvar_Get ("sv_showloss", "0", 0);
 	sv_padPackets = Cvar_Get ("sv_padPackets", "0", 0);
 	sv_killserver = Cvar_Get ("sv_killserver", "0", 0);
-	sv_mapChecksum = Cvar_Get ("sv_mapChecksum", "", CVAR_ROM);
+	sv_mapChecksum = Cvar_Get ("sv_mapChecksum", "", CVAR_ROM | CVAR_SERVERINFO);
 	sv_drawentities = Cvar_Get( "sv_drawentities", "1", 0 );
 	sv_deeptracedebug = Cvar_Get( "sv_deeptracedebug", "0", 0 );
 	sv_chatter = Cvar_Get( "sv_chatter", "0", 0 );

code/server/sv_snapshot.c

@@ -109,7 +109,7 @@ static void SV_EmitPacketEntities( clientSnapshot_t *from, clientSnapshot_t *to,
 		}
 	}
 
-	MSG_WriteBits( msg, (MAX_GENTITIES-1), GENTITYNUM_BITS );	// end of packetentities
+	MSG_WriteEntityNum(msg, (MAX_GENTITIES - 1));	// end of packetentities
 }
 
 
@@ -217,11 +217,11 @@ static void SV_WriteSnapshotToClient( client_t *client, msg_t *msg ) {
 			MSG_WriteSVC( msg, svc_locprint );
 			MSG_WriteShort( msg, client->XOffset );
 			MSG_WriteShort( msg, client->YOffset );
-			MSG_WriteString( msg, client->centerprint );
+			MSG_WriteScrambledString( msg, client->centerprint );
 		}
 		else {
 			MSG_WriteSVC( msg, svc_centerprint );
-			MSG_WriteString( msg, client->centerprint );
+			MSG_WriteScrambledString( msg, client->centerprint );
 		}
 	}
 
@@ -248,7 +248,7 @@ void SV_UpdateServerCommandsToClient( client_t *client, msg_t *msg ) {
 	for ( i = client->reliableAcknowledge + 1 ; i <= client->reliableSequence ; i++ ) {
 		MSG_WriteSVC( msg, svc_serverCommand );
 		MSG_WriteLong( msg, i );
-		MSG_WriteString( msg, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
+		MSG_WriteScrambledString( msg, client->reliableCommands[ i & (MAX_RELIABLE_COMMANDS-1) ] );
 	}
 	client->reliableSent = client->reliableSequence;
 }

code/tiki/tiki_parse.cpp

@@ -328,13 +328,24 @@ TIKI_ParseIncludes
 */
 qboolean TIKI_ParseIncludes( dloaddef_t *ld )
 {
-	const char *token;
+	const char* token;
 	qboolean b_incl = false;
-	const char *mapname;
+	const char* mapname;
+	const char* servertype;
 	int depth = 0;
 
-	token = ld->tikiFile.GetToken( true );
-	if( sv_mapname )
+	static cvar_t* pServerType = Cvar_Get("g_servertype", "2", 0);
+	static cvar_t* pGameType = Cvar_Get("cg_gametype", "0", CVAR_SERVERINFO | CVAR_LATCH);
+
+	if (pGameType->integer && pServerType->integer == 1) {
+		servertype = "spearheadserver";
+	}
+	else {
+		servertype = "breakthroughserver";
+	}
+
+	token = ld->tikiFile.GetToken(true);
+	if (sv_mapname)
 	{
 		mapname = sv_mapname->string;
 	}
@@ -343,38 +354,37 @@ qboolean TIKI_ParseIncludes( dloaddef_t *ld )
 		mapname = "utils";
 	}
 
-	while( 1 )
+	while (1)
 	{
-		if( !strncmp( token, mapname, strlen( token ) )
-			|| !strncmp( token, "spearheadserver", strlen( token ) )
-			|| !strncmp( token, "breakthroughserver", strlen( token ) ) )
+		if (!strncmp(token, mapname, strlen(token))
+			|| !strncmp(token, servertype, strlen(token)))
 		{
 			b_incl = true;
 		}
-		else if( ( !stricmp( token, "{" ) || !ld->tikiFile.TokenAvailable( true ) ) )
+		else if ((!stricmp(token, "{") || !ld->tikiFile.TokenAvailable(true)))
 		{
 			break;
 		}
 
-		token = ld->tikiFile.GetToken( true );
+		token = ld->tikiFile.GetToken(true);
 	}
 
-	if( b_incl )
+	if (b_incl)
 	{
 		return true;
 	}
 
-	while( ld->tikiFile.TokenAvailable( true ) )
+	while (ld->tikiFile.TokenAvailable(true))
 	{
-		token = ld->tikiFile.GetAndIgnoreLine( false );
-		if( strstr( token, "{" ) )
+		token = ld->tikiFile.GetAndIgnoreLine(false);
+		if (strstr(token, "{"))
 		{
 			depth++;
 		}
 
-		if( strstr( token, "}" ) )
+		if (strstr(token, "}"))
 		{
-			if( !depth )
+			if (!depth)
 			{
 				break;
 			}

code/tiki/tiki_skel.cpp

@@ -371,11 +371,11 @@ void TIKI_CacheFileSkel( skelHeader_t *pHeader, skelcache_t *cache, int length )
 				iOffset += sizeof(skelWeight_t) * numWeights;
 				iOffset += sizeof(skeletorVertex_t);
 
-				skelVert->normal[0] = LittleFloat(pVert->normal[0]);
-				skelVert->normal[1] = LittleFloat(pVert->normal[1]);
-				skelVert->normal[2] = LittleFloat(pVert->normal[2]);
-                skelVert->texCoords[0] = LittleFloat(pVert->texCoords[0]);
-                skelVert->texCoords[1] = LittleFloat(pVert->texCoords[1]);
+				skelVert->normal[0] = LittleFloatPtr(pVert->normal[0]);
+				skelVert->normal[1] = LittleFloatPtr(pVert->normal[1]);
+				skelVert->normal[2] = LittleFloatPtr(pVert->normal[2]);
+                skelVert->texCoords[0] = LittleFloatPtr(pVert->texCoords[0]);
+                skelVert->texCoords[1] = LittleFloatPtr(pVert->texCoords[1]);
 				skelVert->numWeights = numWeights;
                 skelVert->numMorphs = numMorphs;
 
@@ -384,21 +384,21 @@ void TIKI_CacheFileSkel( skelHeader_t *pHeader, skelcache_t *cache, int length )
                 skeletorMorph_t* skelMorph = (skeletorMorph_t*)((byte*)skelVert + sizeof(skeletorVertex_t));
                 for (k = 0; k < pVert->numMorphs; k++, pMorph++, skelMorph++)
                 {
-					skelMorph->morphIndex = pMorph->morphIndex;
-                    skelMorph->offset[0] = LittleFloat(pMorph->offset[0]);
-                    skelMorph->offset[1] = LittleFloat(pMorph->offset[1]);
-                    skelMorph->offset[2] = LittleFloat(pMorph->offset[2]);
+					skelMorph->morphIndex = LittleLongPtr(pMorph->morphIndex);
+					skelMorph->offset[0] = LittleFloatPtr(pMorph->offset[0]);
+					skelMorph->offset[1] = LittleFloatPtr(pMorph->offset[1]);
+					skelMorph->offset[2] = LittleFloatPtr(pMorph->offset[2]);
                 }
 
 				skelWeight_t* pWeight = (skelWeight_t * )((byte*)pMorph);
 				skelWeight_t* skelWeight = (skelWeight_t*)((byte*)skelMorph);
 				for (k = 0; k < pVert->numWeights; k++, skelWeight++, pWeight++)
 				{
-                    skelWeight->boneIndex = LittleLong(pWeight->boneIndex);
-                    skelWeight->boneWeight = LittleLong(pWeight->boneWeight);
-                    skelWeight->offset[0] = LittleFloat(pWeight->offset[0]);
-                    skelWeight->offset[1] = LittleFloat(pWeight->offset[1]);
-                    skelWeight->offset[2] = LittleFloat(pWeight->offset[2]);
+                    skelWeight->boneIndex = LittleLongPtr(pWeight->boneIndex);
+                    skelWeight->boneWeight = LittleFloatPtr(pWeight->boneWeight);
+                    skelWeight->offset[0] = LittleFloatPtr(pWeight->offset[0]);
+                    skelWeight->offset[1] = LittleFloatPtr(pWeight->offset[1]);
+                    skelWeight->offset[2] = LittleFloatPtr(pWeight->offset[2]);
 				}
 
                 pVert = (skeletorVertex_t*)((byte*)pVert + iOffset);

code/uilib/ui_public.h

@@ -98,7 +98,7 @@ typedef struct uiimport_s {
 	const char *( *Client_TranslateWidgetName )( const char *widget );
 	void( *Connect )( const char *server );
 	const char *( *Key_GetKeynameForCommand )( const char *command );
-	char *( *Key_GetCommandForKey )( int keynum );
+	const char *( *Key_GetCommandForKey )( int keynum );
 	void ( *Key_SetBinding )( int keynum, const char *binding );
 	void ( *Key_GetKeysForCommand )( const char *command, int *key1, int *key2 );
 	const char *( *Key_KeynumToString )( int keynum );
@@ -230,5 +230,7 @@ void UI_SetCvarInt( const char *cvar, int value );
 void UI_SetCvarFloat( const char *cvar, float value );
 void UI_ListFiles( const char *filespec );
 const char *UI_ConfigString( int index );
+void UI_UpdateCenterPrint(const char* s, float alpha);
+void UI_UpdateLocationPrint(int x, int y, const char* s, float alpha);
 
 #endif

code/uilib/uibind.h

@@ -44,8 +44,8 @@ public:
 	void		Pressed( void );
 	void		SetCommand( Event *ev );
 	void		SetCommand( str s );
-	void		DrawUnpressed( void );
-	void		DrawPressed( void );
+	void		DrawUnpressed( void ) override;
+	void		DrawPressed( void ) override;
 	void		Clear( void );
 	qboolean	KeyEvent( int key, unsigned int time ) override;
 	void		SetAlternate( qboolean a );

code/uilib/uibutton.cpp

@@ -233,26 +233,13 @@ void UIButton::DrawPressed
 	clientFrame.pos.x += 1;
 	clientFrame.pos.y += 1;
 
-	if (m_bVirtual)
-	{
-		m_font->PrintJustified(
-			clientFrame,
-			m_iFontAlignmentHorizontal,
-			m_iFontAlignmentVertical,
-			Sys_LV_CL_ConvertString(m_title.c_str()),
-			NULL
-		);
-	}
-	else
-	{
-		m_font->PrintJustified(
-			clientFrame,
-			m_iFontAlignmentHorizontal,
-			m_iFontAlignmentVertical,
-			Sys_LV_CL_ConvertString(m_title.c_str()),
-			m_vVirtualScale
-		);
-	}
+	m_font->PrintJustified(
+		clientFrame,
+		m_iFontAlignmentHorizontal,
+		m_iFontAlignmentVertical,
+		Sys_LV_CL_ConvertString(m_title.c_str()),
+		m_bVirtual ? m_vVirtualScale : NULL
+	);
 }
 
 void UIButton::DrawUnpressed
@@ -266,26 +253,13 @@ void UIButton::DrawUnpressed
 
 	UIRect2D clientFrame = getClientFrame();
 
-	if (m_bVirtual)
-	{
-		m_font->PrintJustified(
-			clientFrame,
-			m_iFontAlignmentHorizontal,
-			m_iFontAlignmentVertical,
-			Sys_LV_CL_ConvertString(m_title.c_str()),
-			NULL
-		);
-	}
-	else
-	{
-		m_font->PrintJustified(
-			clientFrame,
-			m_iFontAlignmentHorizontal,
-			m_iFontAlignmentVertical,
-			Sys_LV_CL_ConvertString(m_title.c_str()),
-			m_vVirtualScale
-		);
-	}
+	m_font->PrintJustified(
+		clientFrame,
+		m_iFontAlignmentHorizontal,
+		m_iFontAlignmentVertical,
+		Sys_LV_CL_ConvertString(m_title.c_str()),
+		m_bVirtual ? m_vVirtualScale : NULL
+	);
 }
 
 qboolean UIButton::KeyEvent

code/uilib/uiconsole.cpp

@@ -77,8 +77,6 @@ int UIConsole::getNextItem
 		return -1;
 	}
 
-	m_numitems = m_numitems;
-	m_firstitem = m_firstitem;
 	prev = prev + 1;
 
 	if (m_numitems < MAX_CONSOLE_ITEMS)
@@ -827,16 +825,16 @@ void UIFloatingConsole::FrameInitialized
 	m_status->setTitle(str());
 
 	m_console = new UIConsole();
-	m_console->InitFrame(getChildSpace(), UIRect2D(0, 0, 20.0, 20.0), 0, "verdana-12");
+	m_console->InitFrame(getChildSpace(), UIRect2D(0, 0, 20.0, 20.0), 0, "verdana-14");
 	setConsoleColor(m_consoleColor);
 	setConsoleBackground(m_consoleBackground, m_consoleAlpha);
 	m_console->setConsoleHandler(m_handler);
 
-	Connect(this, W_SizeChanged, W_Console_ChildSizeChanged);
+	getChildSpace()->Connect(this, W_SizeChanged, W_Console_ChildSizeChanged);
 	getChildSpace()->AllowActivate(false);
 	OnChildSizeChanged(NULL);
 
-	m_background_color.a = 1.0;
+	m_background_color.a = 0.0;
 	m_alpha = 1.0;
 
 	getChildSpace()->setBackgroundAlpha(1.0);
@@ -907,6 +905,7 @@ void UIFloatingConsole::setConsoleBackground
 	)
 
 {
+	m_alpha = alpha;
 	m_consoleBackground = color;
 	m_consoleAlpha = alpha;
 

code/uilib/uifloatwnd.cpp

@@ -199,7 +199,7 @@ void UIFloatingWindow::MinimizePressed
 		// so the window can be restored later
 		m_restoredHeight = size.height;
 		size.height = 20.0;
-		m_minimizeButton->setTitle(1);
+		m_minimizeButton->setTitle("1");
 	}
 	else
 	{
@@ -296,9 +296,9 @@ void UIFloatingWindow::SizeChanged
 		return;
 	}
 
-	setFrame(childRect);
-	setFrame(UIRect2D(m_frame.size.width - 18.0, 2.0, 16.0, 16.0));
-	setFrame(UIRect2D(m_frame.size.width - 36.0, 2.0, 16.0, 16.0));
+	m_childspace->setFrame(childRect);
+	m_closeButton->setFrame(UIRect2D(m_frame.size.width - 18.0, 2.0, 16.0, 16.0));
+	m_minimizeButton->setFrame(UIRect2D(m_frame.size.width - 36.0, 2.0, 16.0, 16.0));
 }
 
 void UIFloatingWindow::OnActivated
@@ -368,6 +368,8 @@ void UIFloatingWindow::Draw
 		textColor = m_textColor;
 
 		UColorHSV tmp(titleBar);
+		tmp.s *= 0.75;
+		tmp.v *= 1.333;
 		newColor = tmp;
 
 		titleBorder.dark = newColor;
@@ -379,7 +381,7 @@ void UIFloatingWindow::Draw
 	{
 		UColor newColor(0.1125, 0.147, 0.2085, 1.0);
 
-		titleBar = titleBar;
+		titleBar = newColor;
 		textColor = UBlack;
 
 		titleBorder.CreateSolidBorder(newColor, DARK);

code/uilib/uifloatwnd.h

@@ -30,7 +30,7 @@ public:
 public:
 	UIChildSpaceWidget();
 
-	qboolean	KeyEvent( int key, unsigned int time );
+	qboolean	KeyEvent( int key, unsigned int time ) override;
 };
 
 class UIFloatingWindow : public UIWidget {

code/uilib/uiglobalgamelist.h

@@ -30,7 +30,7 @@ public:
 	CLASS_PROTOTYPE( UIGlobalGameList );
 
 public:
-	virtual void UpdateServers();
+	virtual void UpdateServers() override;
 };
 
 #endif

code/uilib/uilangamelist.h

@@ -69,7 +69,7 @@ public:
 	void		EventConnect( Event *ev );
 	void		PlayEnterSound( void );
 	qboolean	SetActiveRow( UIWidget *w );
-	void		Realign( void );
+	void		Realign( void ) override;
 };
 
 class UILanGameListLabel : public UILabel {

code/uilib/uilayout.cpp

@@ -174,7 +174,6 @@ void UILayout::ProcessCommands
 				cl = "UI";
 				cl += newname;
 				cls = getClass( cl );
-				assert( cls );
 				if( !cls )
 				{
 					Com_Printf( "Failed to find resource type '%s'\n", token );

code/uilib/uilist.h

@@ -48,28 +48,28 @@ public:
 
 protected:
 	void		Draw( void ) override;
-	qboolean	KeyEvent( int key, unsigned int time );
-	void		CharEvent( int ch );
+	qboolean	KeyEvent( int key, unsigned int time ) override;
+	void		CharEvent( int ch ) override;
 	void		Pressed( Event *ev );
 	void		Released( Event *ev );
 	void		ScrollNext( void );
 	void		ScrollPrev( void );
-	void		FrameInitialized( void );
+	void		FrameInitialized( void ) override;
 	void		LayoutAddListItem( Event *ev );
 	void		AddItem( str item, str alias );
 public:
 	UIList();
 	~UIList();
 
-	void	UpdateUIElement( void );
-	void	UpdateData( void );
+	void	UpdateUIElement( void ) override;
+	void	UpdateData( void ) override;
 };
 
 class UIListIndex : public UIList {
 public:
 	CLASS_PROTOTYPE( UIListIndex );
 
-	qboolean	KeyEvent( int key, unsigned int time );
+	qboolean	KeyEvent( int key, unsigned int time ) override;
 };
 
 #endif /* __UILIST_H__ */

code/uilib/uilistbox.h

@@ -35,12 +35,12 @@ public:
 
 protected:
 	virtual void		TrySelectItem( int which );
-	qboolean			KeyEvent( int key, unsigned int time );
+	qboolean			KeyEvent( int key, unsigned int time ) override;
 
 public:
 	UIListBase();
 
-	void			FrameInitialized( void );
+	void			FrameInitialized( void ) override;
 	int				getCurrentItem( void );
 	virtual int		getNumItems( void );
 	virtual void	DeleteAllItems( void );
@@ -78,20 +78,20 @@ protected:
 	void			MouseReleased( Event *ev );
 	void			DeleteAllItems( Event *ev );
 	void			SetListFont( Event *ev );
-	void			TrySelectItem( int which );
+	void			TrySelectItem( int which ) override;
 
 public:
 	UIListBox();
 
 	void			AddItem( const char *item, const char *command );
 	void			AddItem( int index, const char *command );
-	void			FrameInitialized( void );
+	void			FrameInitialized( void ) override;
 	void			LayoutAddListItem( Event *ev );
 	void			LayoutAddConfigstringListItem( Event *ev );
 	str				getItemText( int which );
-	int				getNumItems( void );
-	void			DeleteAllItems( void );
-	void			DeleteItem( int which );
+	int				getNumItems( void ) override;
+	void			DeleteAllItems( void ) override;
+	void			DeleteItem( int which ) override;
 };
 
 #endif /* __UILISTBOX_H__ */

code/uilib/uilistctrl.h

@@ -89,7 +89,7 @@ public:
 	UIListCtrl();
 	~UIListCtrl();
 
-	void				FrameInitialized( void );
+	void				FrameInitialized( void ) override;
 	void				SetDrawHeader( qboolean bDrawHeader );
 	void				AddItem( UIListCtrlItem *item );
 	void				InsertItem( UIListCtrlItem *item, int where );
@@ -97,9 +97,9 @@ public:
 	UIListCtrlItem		*GetItem( int item );
 	void				AddColumn( str title, int name, int width, bool numeric, bool reverse_sort );
 	void				RemoveAllColumns( void );
-	int					getNumItems( void );
-	void				DeleteAllItems( void );
-	void				DeleteItem( int which );
+	int					getNumItems( void ) override;
+	void				DeleteAllItems( void ) override;
+	void				DeleteItem( int which ) override;
 	virtual void		SortByColumn( int column );
 	void				SortByLastSortColumn( void );
 	void				setCompareFunction( int( *func ) ( const UIListCtrlItem *i1, const UIListCtrlItem *i2, int columnname ) );

code/uilib/uimledit.h

@@ -53,7 +53,7 @@ public:
 	CLASS_PROTOTYPE( UIMultiLineEdit );
 
 protected:
-	void	FrameInitialized( void );
+	void	FrameInitialized( void ) override;
 	void	PointToSelectionPoint( UIPoint2D& p, selectionpoint_t& sel );
 	str&	LineFromLineNumber( int num, bool resetpos );
 	void	EnsureSelectionPointVisible( selectionpoint_t& point );
@@ -67,8 +67,8 @@ public:
 	UIMultiLineEdit();
 
 	void		Draw( void ) override;
-	qboolean	KeyEvent( int key, unsigned int time );
-	void		CharEvent( int ch );
+	qboolean	KeyEvent( int key, unsigned int time ) override;
+	void		CharEvent( int ch ) override;
 	UIPoint2D	getEndSelPoint( void );
 	void		MouseDown( Event *ev );
 	void		MouseUp( Event *ev );

code/uilib/uinotepad.h

@@ -35,7 +35,7 @@ public:
 public:
 	UINotepadEdit();
 
-	void		CharEvent( int ch );
+	void		CharEvent( int ch ) override;
 	void		setNotepad( UINotepad *notepad );
 	bool		GotoLine( int line );
 	bool		FindText( const char *text, int offsetFromSel );

code/uilib/uipulldownmenu.h

@@ -98,7 +98,7 @@ public:
 	void	setPopupBGColor( str menu, UColor c );
 	void	setPulldownShader( const char *title, UIReggedMaterial *mat );
 	void	setSelectedPulldownShader( const char *title, UIReggedMaterial *mat );
-	void	Realign( void );
+	void	Realign( void ) override;
 	void	Draw( void ) override;
 };
 

code/uilib/uipulldownmenucontainer.h

@@ -35,10 +35,10 @@ public:
 	UIPulldownMenuContainer();
 
 protected:
-	void	FrameInitialized( void );
-	void	setBackgroundAlpha( float f );
-	void	setBackgroundColor( const UColor& color, bool setbordercolor );
-	void	setForegroundColor( const UColor& color );
+	void	FrameInitialized( void ) override;
+	void	setBackgroundAlpha( float f ) override;
+	void	setBackgroundColor( const UColor& color, bool setbordercolor ) override;
+	void	setForegroundColor( const UColor& color ) override;
 	void	SetPopupHighlightFGColor( Event *ev );
 	void	SetPopupHighlightBGColor( Event *ev );
 	void	SetPopupFGColor( Event *ev );
@@ -47,7 +47,7 @@ protected:
 	void	SetHighlightBGColor( Event *ev );
 	void	SetMenuShader( Event *ev );
 	void	SetSelectedMenuShader( Event *ev );
-	void	Realign( void );
+	void	Realign( void ) override;
 	void	PulldownVirtualRes( Event *ev );
 
 public:

code/uilib/uistatus.cpp

@@ -21,25 +21,40 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #include "ui_local.h"
+#include "localization.h"
 
 CLASS_DECLARATION( UIWidget, UIWindowSizer, NULL )
 {
+	{ &W_LeftMouseDown,			&UIWindowSizer::MouseDown },
+	{ &W_LeftMouseUp,			&UIWindowSizer::MouseUp },
+	{ &W_LeftMouseDragged,		&UIWindowSizer::MouseDragged },
 	{ NULL, NULL }
 };
 
 UIWindowSizer::UIWindowSizer()
 {
-	// FIXME: stub
+	m_draggingwidget = NULL;
+	m_mouseState = M_NONE;
 }
 
 
+UIWindowSizer::UIWindowSizer(UIWidget* w)
+	: UIWindowSizer()
+{
+	m_draggingwidget = w;
+}
+
 void UIWindowSizer::Draw
 	(
 	void
 	)
 
 {
-	// FIXME: stub
+	m_font->setColor(UWhite);
+	m_font->Print(0, 0, "o", -1, m_bVirtual);
+
+	m_font->setColor(UBlack);
+	m_font->Print(0, 0, "p", -1, m_bVirtual);
 }
 
 void UIWindowSizer::FrameInitialized
@@ -48,7 +63,7 @@ void UIWindowSizer::FrameInitialized
 	)
 
 {
-	// FIXME: stub
+	setFont("marlett");
 }
 
 void UIWindowSizer::MouseDown
@@ -57,7 +72,10 @@ void UIWindowSizer::MouseDown
 	)
 
 {
-	// FIXME: stub
+	m_screenDragPoint.x = ev->GetFloat(1);
+	m_screenDragPoint.y = ev->GetFloat(2);
+	m_mouseState = M_DRAGGING;
+	uWinMan.setFirstResponder(this);
 }
 
 void UIWindowSizer::MouseUp
@@ -66,7 +84,11 @@ void UIWindowSizer::MouseUp
 	)
 
 {
-	// FIXME: stub
+	if (uWinMan.getFirstResponder() == this) {
+		uWinMan.setFirstResponder(NULL);
+	}
+
+	m_mouseState = M_NONE;
 }
 
 void UIWindowSizer::MouseDragged
@@ -75,7 +97,29 @@ void UIWindowSizer::MouseDragged
 	)
 
 {
-	// FIXME: stub
+	UIPoint2D newpoint, delta;
+	UISize2D newsize;
+
+	if (m_mouseState != M_DRAGGING) {
+		return;
+	}
+
+	newpoint.x = ev->GetFloat(1);
+	newpoint.y = ev->GetFloat(2);
+	delta = UIPoint2D(newpoint.x - m_screenDragPoint.x, newpoint.y - m_screenDragPoint.y);
+
+	if (delta.x || delta.y)
+	{
+		m_screenDragPoint = newpoint;
+		newsize = m_draggingwidget->getSize();
+		newsize.width += delta.x;
+		newsize.height += delta.y;
+
+		if (newsize.width < 32) newsize.width = 32;
+		if (newsize.height < 16) newsize.height = 16;
+
+		m_draggingwidget->setSize(newsize);
+	}
 }
 
 void UIWindowSizer::setDraggingWidget
@@ -84,7 +128,7 @@ void UIWindowSizer::setDraggingWidget
 	)
 
 {
-	// FIXME: stub
+	m_draggingwidget = w;
 }
 
 UIWidget *UIWindowSizer::getDraggingWidget
@@ -93,18 +137,23 @@ UIWidget *UIWindowSizer::getDraggingWidget
 	)
 
 {
-	// FIXME: stub
-	return NULL;
+	return m_draggingwidget;
 }
 
 CLASS_DECLARATION( UIWidget, UIStatusBar, NULL )
 {
+	{ &W_RealignWidget,	&UIStatusBar::ParentSized },
+	{ &W_SizeChanged,	&UIStatusBar::SelfSized },
 	{ NULL, NULL }
 };
 
 UIStatusBar::UIStatusBar()
 {
-	// FIXME: stub
+	m_sizeenabled = NULL;
+	m_created = false;
+	m_sizer = NULL;
+	m_align.alignment = WND_ALIGN_NONE;
+	m_iFontAlignmentHorizontal = FONT_JUSTHORZ_LEFT;
 }
 
 UIStatusBar::UIStatusBar
@@ -112,9 +161,10 @@ UIStatusBar::UIStatusBar
 	alignment_t align,
 	float height
 	)
+	: UIStatusBar()
 
 {
-	// FIXME: stub
+	AlignBar(align, height);
 }
 
 void UIStatusBar::FrameInitialized
@@ -123,7 +173,14 @@ void UIStatusBar::FrameInitialized
 	)
 
 {
-	// FIXME: stub
+	m_created = true;
+	Connect(this, W_SizeChanged, W_SizeChanged);
+	if (m_parent) {
+		m_parent->Connect(this, W_SizeChanged, W_RealignWidget);
+	}
+
+	SelfSized(NULL);
+	ParentSized(NULL);
 }
 
 void UIStatusBar::Draw
@@ -132,7 +189,25 @@ void UIStatusBar::Draw
 	)
 
 {
-	// FIXME: stub
+	if (m_align.alignment == WND_ALIGN_BOTTOM) {
+		DrawBox(0.0, 0.0, m_frame.size.width, 1.0, m_border_color.dark, 1.0);
+	}
+
+	m_font->setColor(m_foreground_color);
+	m_font->PrintJustified(
+		getClientFrame(),
+		m_iFontAlignmentHorizontal,
+		m_iFontAlignmentVertical,
+		Sys_LV_CL_ConvertString(m_title.c_str()),
+		m_bVirtual ? m_vVirtualScale : NULL
+	);
+
+	if (m_sizer)
+	{
+		m_sizer->setForegroundColor(m_foreground_color);
+		m_sizer->setBackgroundColor(m_background_color, true);
+		m_sizer->setBackgroundAlpha(m_local_alpha);
+	}
 }
 
 void UIStatusBar::AlignBar
@@ -142,7 +217,8 @@ void UIStatusBar::AlignBar
 	)
 
 {
-	// FIXME: stub
+	m_align.alignment = align;
+	m_align.dist = height;
 }
 
 void UIStatusBar::DontAlignBar
@@ -151,7 +227,7 @@ void UIStatusBar::DontAlignBar
 	)
 
 {
-	// FIXME: stub
+	m_align.alignment = WND_ALIGN_NONE;
 }
 
 void UIStatusBar::EnableSizeBox
@@ -160,7 +236,10 @@ void UIStatusBar::EnableSizeBox
 	)
 
 {
-	// FIXME: stub
+	m_sizeenabled = which;
+	if (m_created) {
+		SelfSized(NULL);
+	}
 }
 
 void UIStatusBar::ParentSized
@@ -169,7 +248,12 @@ void UIStatusBar::ParentSized
 	)
 
 {
-	// FIXME: stub
+	if (m_align.alignment == WND_ALIGN_BOTTOM)
+	{
+		UISize2D parentSize = m_parent->getSize();
+
+		setFrame(UIRect2D(0.0, parentSize.height - m_align.dist, parentSize.width, m_align.dist));
+	}
 }
 
 void UIStatusBar::SelfSized
@@ -178,6 +262,30 @@ void UIStatusBar::SelfSized
 	)
 
 {
-	// FIXME: stub
+	if (m_sizeenabled)
+	{
+		if (m_sizer) {
+			if (m_sizer->getDraggingWidget() != m_sizeenabled) {
+				m_sizer->setDraggingWidget(m_sizeenabled);
+			}
+		}
+		else {
+			m_sizer = new UIWindowSizer(m_sizeenabled);
+			m_sizer->InitFrame(this, 0, 0, 16.0, 16.0, 0);
+		}
+
+
+		UISize2D sizerFrame = m_sizer->getSize();
+
+		m_sizer->setFrame(UIRect2D(
+			UIPoint2D(m_frame.size.width - sizerFrame.width, m_frame.size.height - sizerFrame.height),
+			sizerFrame
+		));
+	}
+	else if (m_sizer)
+	{
+		delete m_sizer;
+		m_sizer = NULL;
+	}
 }
 

code/uilib/uistatus.h

@@ -35,6 +35,7 @@ public:
 	CLASS_PROTOTYPE( UIWindowSizer );
 
 	UIWindowSizer();
+	UIWindowSizer(UIWidget* w);
 
 	void			Draw( void ) override;
 	void			FrameInitialized( void ) override;
@@ -60,6 +61,7 @@ protected:
 	bool m_created;
 
 	UIWindowSizer *m_sizer;
+
 public:
 	CLASS_PROTOTYPE( UIStatusBar );