Merge pull request #2 from spumer/feature/2200-last-stand

feat(*): The Last Stand-update support

Author: spumer

gamedata/left4fix.sig.txt

@@ -6,8 +6,8 @@
 		{
 			"VersusCompletionScore"
 			{
-				"linux"		"976"
-				"windows"	"984"
+				"linux"		"996"
+				"windows"	"1000"
 			}
 
 			"MarkerDivisor"
@@ -190,22 +190,22 @@
 			"DIV_CODE_UpdateMarkersReached"
 			{
 				"library"	"server"
-				"linux"		"\xE8\x2A\x2A\x2A\x2A\xF3\x0F\x2A\x2A\x2A\xC1\xF8\x02"
-				"windows"	"\xF3\x0F\x10\x45\xFC\xC1\xF8\x02"
+				"linux"		"\x89\x04\x24\xE8\x2A\x2A\x2A\x2A\xF3\x0F\x2A\x45\xE4\xC1\xF8\x02"
+				//"windows"	"\xF3\x0F\x10\x45\xFC\xC1\xF8\x02"
 			}
 
 			"DIV_CODE_AddSurvivorStats"
 			{
 				"library"	"server"
-				"linux"		"\xE8\x2A\x2A\x2A\x2A\xC1\xF8\x02"
-				"windows"	"\x0F\x57\xC0\xC1\xF8\x02"
+				"linux"		"\x89\x04\x24\xE8\x2A\x2A\x2A\x2A\xC1\xF8\x02"
+				//"windows"	"\x0F\x57\xC0\xC1\xF8\x02"
 			}
 
 			"DIV_CODE_GetVersusCompletion"
 			{
 				"library"	"server"
-				"linux"		"\x8B\x55\x2A\xA1\x2A\x2A\x2A\x2A\x8B\xBA\xE8\x0D\x00\x00\x89\x2A\x2A\xC1\xFF\x02"
-				"windows"	"\x33\xC9\xC1\xF8\x02"
+				"linux"		"\xB8\x00\x00\x00\x00\xC1\xFB\x02\x85\xDB\x0F\x48\xD8"
+				//"windows"	"\x33\xC9\xC1\xF8\x02"
 			}
 		}
 	}

src/Makefile

@@ -5,10 +5,12 @@
 ### EDIT THESE PATHS FOR YOUR OWN SETUP ###
 ###########################################
 
-SMSDK ?= ../../_SDK_PLATFORM/sourcemod
-SRCDS_BASE ?= ../../_SDK_PLATFORM/srcds
-HL2SDK_L4D2 ?= ../../_SDK_PLATFORM/hl2sdk-l4d2
-MMSOURCE ?= ../../_SDK_PLATFORM/mmsource
+SDK_PLATFORM ?= ../../../_SDK_PLATFORM
+
+SMSDK = $(SDK_PLATFORM)/sourcemod
+SRCDS_BASE ?= $(SDK_PLATFORM)/srcds
+HL2SDK_L4D2 ?= $(SDK_PLATFORM)/hl2sdk-l4d2
+MMSOURCE ?= $(SDK_PLATFORM)/mmsource
 
 #####################################
 ### EDIT BELOW FOR OTHER PROJECTS ###
@@ -40,7 +42,7 @@ C_OPT_FLAGS = -DNDEBUG -Ofast -flto -funroll-loops -pipe -fno-strict-aliasing -f
 C_DEBUG_FLAGS = -D_DEBUG -DDEBUG -g -ggdb3
 C_GCC4_FLAGS = -fvisibility=hidden
 CPP_GCC4_FLAGS = -fvisibility-inlines-hidden -std=c++11
-CPP = gcc
+CPP = gcc-4.8
 
 ##########################
 ### SDK CONFIGURATIONS ###
@@ -96,7 +98,9 @@ endif
 BINARY = $(PROJECT).ext.$(LIB_EXT)
 
 GCC_VERSION := $(shell $(CPP) -dumpversion >&1 | cut -b1)
-ifeq "$(GCC_VERSION)" "4"
+
+# apply flags for GCC 4, 5 and 6 versions
+ifneq (,$(filter $(GCC_VERSION),4 5 6))
 	CFLAGS += $(C_GCC4_FLAGS)
 	CPPFLAGS += $(CPP_GCC4_FLAGS)
 endif

src/codepatch/patch_description.txt

@@ -1,44 +1,44 @@
 
-UpdateMarkersReached: E8 ? ? ? ? F3 0F 2A ? ? C1 F8 02 (EAX, EBX, EDX)
-AddSurvivorStats: E8 ? ? ? ? C1 F8 02 (EAX, ECX, EDX)
-GetVersusCompletion: 8B 55 ? A1 ? ? ? ? 8B BA E8 0D 00 00 89 ? ? C1 FF 02 (EAX, EDI, EDX)
+UpdateMarkersReached: 89 04 24 E8 ? ? ? ? F3 0F 2A 45 E4 C1 F8 02 (EAX, EDX)
+AddSurvivorStats: 89 04 24 E8 ? ? ? ? C1 F8 02(EAX, ECX, EDX)
+GetVersusCompletion: B8 00 00 00 00 C1 FB 02 85 DB 0F 48 D8 (EAX, EDX, EBX)
 
 
 UpdateMarkersReached_patch:
 
 E9 ? ? ? ?			/* JMP [address] */
-8B 80 E8 0D 00 00   /* mov eax, [eax+3560] */
+8B 80 FC 0D 00 00   /* mov eax, [eax+3580] */
 31 D2				/* xor edx, edx */
 BB 0A 00 00 00		/* mov ebx, 10 */
 F7 F3				/* div ebx */
+F3 0F 2A 45 E4		/* Preserve xmm0 value for original funcion: cvtsi2ss xmm0, [ebp-0x1c] */
 E9 ? ? ? ?			/* JMP [address] ;jump to next instruction */
 					/* NOP 3 bytes (sar eax, 2) */
 
 Result:
-{ 0x8B, 0x80, 0xE8, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xBB, 0x0A, 0x00, 0x00, 0x00, 0xF7, 0xF3 }
+{ 0x8B, 0x80, 0xFC, 0x0D, 0x00, 0x00, 0xBA, 0x0A, 0x00, 0x00, 0x00, 0xF7, 0xF2, 0xF3, 0x0F, 0x2A, 0x45, 0xE4 }
 
 AddSurvivorStats_patch:
-E9 ? ? ? ?			/* JMP [address] */
-8B 80 E8 0D 00 00	/* mov eax, [eax+3560] */
-31 D2				/* xor edx, edx */
-B9 0A 00 00 00		/* mov ecx, 10 */
-F7 F1				/* div ecx */
-E9 ? ? ? ?			/* JMP [address] ;jump to next instruction */
+8b 80 fc 0d 00 00			/* mov eax, [eax+3580] */
+31 D2						/* xor edx, edx */
+b9 0a 00 00 00				/* mov ecx, 10 */
+F7 F1						/* div ecx */
+85 C0 						/* test eax, eax */
+89 45 AC 					/* mov [ebp+var_54], eax
+/* our patch smaller than original, nop other */
+90 90 90 90 90 90 90		/* nop(s) */
+
 Result:
-{ 0x8B, 0x80, 0xE8, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xB9, 0x0A, 0x00, 0x00, 0x00, 0xF7, 0xF1 }
+{ 0x8B, 0x80, 0xFC, 0x0D, 0x00, 0x00, 0xB9, 0x0A, 0x00, 0x00, 0x00, 0xF7, 0xF1, 0x85, 0xC0, 0x89, 0x45, 0xAC, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90 }
 
 GetVersusCompletion_patch:
 
-E9 ? ? ? ?			/* JMP [address] */
-8B 45 08			/* mov eax, [ebp+arg_0] */
-					/* copy A1 ? ? ? ? to trampoline end */
-8B 80 E8 0D 00 00	/* mov eax, [eax+3560] */
-					/* copy 89 ? ? to trampoline end */
-31 D2				/* xor edx, edx */
-BF 0A 00 00 00		/* mov edi, 10 */
-F7 F7				/* div edi */
-89 C7				/* mov edi, eax */
-E9 ? ? ? ?			/* JMP [address] ;jump to next instruction */
+89 d8			/* mov eax,ebx */
+31 D2			/* xor edx, edx */
+bb 0a 00 00 00	/* mov ebx, 10 */
+f7 f3			/* div ebx */
+89 c3			/* mov ebx, eax */
+
 Result:
-{ 0x8B, 0x45, 0x08, 0x8B, 0x80, 0xE8, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xBF, 0x0A, 0x00, 0x00, 0x00, 0xF7, 0xF7, 0x89, 0xC7 }
+{ 0x89, 0xD8, 0xBB, 0x0A, 0x00, 0x00, 0x00, 0xF7, 0xF3, 0x89, 0xC3, 0x90, 0x90 }
 

src/codepatch/score_code_linux.cpp

@@ -33,20 +33,21 @@
 #include "extension.h"
 #include "asm/asm.h"
 #include "CDetour/detourhelpers.h"
+#include "codepatch/patch_utils.hpp"
 
 #define OP_MOV 0xA1
 #define OP_MOV_SIZE 5
 
 // TODO: Create CUT/PASTE masks functions for wrap instructions inside my patch
 
-unsigned char UpdateMarkersReached_orig[]  = { 0xE8, 0x2A, 0x2A, 0x2A, 0x2A, 0xF3, 0x0F, 0x2A, 0x2A, 0x2A, 0xC1, 0xF8, 0x02 };
-unsigned char UpdateMarkersReached_patch[] = { 0x8B, 0x80, 0xE8, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xBB, TEAM_SIZE, 0x00, 0x00, 0x00, 0xF7, 0xF3 };
+unsigned char UpdateMarkersReached_orig[]  = { 0x89, 0x04, 0x24, 0xE8, 0x07, 0x9E, 0xC6, 0xFF, 0xF3, 0x0F, 0x2A, 0x45, 0xE4, 0xC1, 0xF8, 0x02 };
+unsigned char UpdateMarkersReached_patch[] = { 0x8B, 0x80, 0xFC, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xBB, TEAM_SIZE, 0x00, 0x00, 0x00, 0xF7, 0xF3, 0xF3, 0x0F, 0x2A, 0x45, 0xE4 };
 
-unsigned char AddSurvivorStats_orig[]  = { 0xE8, 0x2A, 0x2A, 0x2A, 0x2A, 0xC1, 0xF8, 0x02 };
-unsigned char AddSurvivorStats_patch[] = { 0x8B, 0x80, 0xE8, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xB9, TEAM_SIZE, 0x00, 0x00, 0x00, 0xF7, 0xF1 };
+unsigned char AddSurvivorStats_orig[]  = { 0x89, 0x04, 0x24, 0xE8, 0x89, 0xCB, 0xC4, 0xFF, 0xC1, 0xF8, 0x02, 0xF3, 0x0F, 0x2A, 0xC0, 0x0F, 0x2F, 0x05, 0x90, 0x95, 0xBA, 0x00, 0xF3, 0x0F, 0x11, 0x45, 0xAC };
+unsigned char AddSurvivorStats_patch[] = { 0x8B, 0x80, 0xFC, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xB9, TEAM_SIZE, 0x00, 0x00, 0x00, 0xF7, 0xF1, 0x85, 0xC0, 0x89, 0x45, 0xAC, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
 
-unsigned char GetVersusCompletion_orig[]  = { 0x8B, 0x55, 0x2A, 0xA1, 0x2A, 0x2A, 0x2A, 0x2A, 0x8B, 0xBA, 0xE8, 0x0D, 0x00, 0x00, 0x89, 0x2A, 0x2A, 0xC1, 0xFF, 0x02 };
-unsigned char GetVersusCompletion_patch[] = { 0x8B, 0x45, 0x08, 0x8B, 0x80, 0xE8, 0x0D, 0x00, 0x00, 0x31, 0xD2, 0xBF, TEAM_SIZE, 0x00, 0x00, 0x00, 0xF7, 0xF7, 0x89, 0xC7 };
+unsigned char GetVersusCompletion_orig[]  = { 0xB8, 0x00, 0x00, 0x00, 0x00, 0xC1, 0xFB, 0x02, 0x85, 0xDB, 0x0F, 0x48, 0xD8 };
+unsigned char GetVersusCompletion_patch[] = { 0x89, 0xD8, 0x31, 0xD2, 0xBB, TEAM_SIZE, 0x00, 0x00, 0x00, 0xF7, 0xF3, 0x89, 0xC3 };
 
 
 void ScoreCode::Patch() {
@@ -65,40 +66,24 @@ void ScoreCode::Patch() {
 	// prepare the trampoline
 	m_injectMarker = (unsigned char *)sengine->AllocatePageMemory(sizeof(UpdateMarkersReached_patch) + OP_JMP_SIZE);
 	copy_bytes(UpdateMarkersReached_patch, m_injectMarker, sizeof(UpdateMarkersReached_patch));
-	inject_jmp(m_injectMarker + sizeof(UpdateMarkersReached_patch), m_pMarkers + OP_JMP_SIZE);
+	inject_jmp(m_injectMarker + sizeof(UpdateMarkersReached_patch), m_pMarkers + OP_JMP_SIZE); // inject jump to position afterward JMP which brought us here
+
 	// copy original code to our buffer
 	SetMemPatchable(m_pMarkers, sizeof(UpdateMarkersReached_orig));
 	copy_bytes(m_pMarkers, UpdateMarkersReached_orig, sizeof(UpdateMarkersReached_orig));
 	// inject jmp to trampoline and nop some bytes after target instruction
 	inject_jmp(m_pMarkers, m_injectMarker);
-	fill_nop(m_pMarkers + sizeof(UpdateMarkersReached_orig) - 3, 3);
+	fill_nop(m_pMarkers + OP_JMP_SIZE, sizeof(UpdateMarkersReached_orig) - OP_JMP_SIZE);
 
-	// prepare the trampoline
-	m_injectStats = (unsigned char *)sengine->AllocatePageMemory(sizeof(AddSurvivorStats_patch) + OP_JMP_SIZE);
-	copy_bytes(AddSurvivorStats_patch, m_injectStats, sizeof(AddSurvivorStats_patch));
-	inject_jmp(m_injectStats + sizeof(AddSurvivorStats_patch), m_pL4DStats + sizeof(AddSurvivorStats_orig));
-	// copy original code to our buffer
+	// // before patch copy original code to our buffer
 	SetMemPatchable(m_pL4DStats, sizeof(AddSurvivorStats_orig));
 	copy_bytes(m_pL4DStats, AddSurvivorStats_orig, sizeof(AddSurvivorStats_orig));
-	// inject jmp to trampoline
-	inject_jmp(m_pL4DStats, m_injectStats);
-	fill_nop(m_pL4DStats + OP_JMP_SIZE, sizeof(AddSurvivorStats_orig) - OP_JMP_SIZE);
+	copy_bytes(AddSurvivorStats_patch, m_pL4DStats, sizeof(AddSurvivorStats_patch));
 
-	// prepare the trampoline
-	// patch size: (division code size) + (original MOV (A1) to EAX) + (original short MOV (89)) + (JMP back)
-	size_t compl_patch_size = sizeof(GetVersusCompletion_patch) + OP_MOV_SIZE + 3 + OP_JMP_SIZE;
-	m_injectCompl = (unsigned char *)sengine->AllocatePageMemory(compl_patch_size);
-	unsigned char *pInjectEnd = m_injectCompl;
-	copy_bytes(GetVersusCompletion_patch, m_injectCompl, sizeof(GetVersusCompletion_patch)); pInjectEnd += sizeof(GetVersusCompletion_patch);
-	copy_bytes(m_pCompletion + 3, pInjectEnd, OP_MOV_SIZE); pInjectEnd += OP_MOV_SIZE;
-	copy_bytes(m_pCompletion + sizeof(GetVersusCompletion_orig) - 6, pInjectEnd, 3); pInjectEnd += 3;
-	inject_jmp(pInjectEnd, m_pCompletion + sizeof(GetVersusCompletion_orig));
-	// copy original code to our buffer
+	// // before patch copy original code to our buffer
 	SetMemPatchable(m_pCompletion, sizeof(GetVersusCompletion_orig));
 	copy_bytes(m_pCompletion, GetVersusCompletion_orig, sizeof(GetVersusCompletion_orig));
-	// inject jmp to trampoline
-	inject_jmp(m_pCompletion, m_injectCompl);
-	fill_nop(m_pCompletion + OP_JMP_SIZE, sizeof(GetVersusCompletion_orig) - OP_JMP_SIZE);
+	copy_bytes(GetVersusCompletion_patch, m_pCompletion, sizeof(GetVersusCompletion_patch));
 
 	m_isPatched = true;
 }
@@ -108,8 +93,8 @@ void ScoreCode::Unpatch() {
 
 	ISourcePawnEngine *sengine = g_pSM->GetScriptingEngine();
 	if(m_injectMarker) { copy_bytes(m_pMarkers, UpdateMarkersReached_orig, sizeof(UpdateMarkersReached_orig)); sengine->FreePageMemory(m_injectMarker); }
-	if(m_injectStats) { copy_bytes(m_pL4DStats, AddSurvivorStats_orig, sizeof(AddSurvivorStats_orig)); sengine->FreePageMemory(m_injectStats); }
-	if(m_injectCompl) { copy_bytes(m_pCompletion, GetVersusCompletion_orig, sizeof(GetVersusCompletion_orig)); sengine->FreePageMemory(m_injectCompl); }
+	copy_bytes(m_pL4DStats, AddSurvivorStats_orig, sizeof(AddSurvivorStats_orig));
+	copy_bytes(m_pCompletion, GetVersusCompletion_orig, sizeof(GetVersusCompletion_orig));
 
 	m_isPatched = false;
 }

src/detours/on_recompute_versus_completion.cpp

@@ -41,46 +41,46 @@
 
 /*
 typedef struct {
-	uint8_t unknownData[888];					// 0 bytes
-	uint32_t versus_score_bonus[2];				// 888 bytes	// temp buffer to store chapter score for second team
-	uint32_t versus_campaign_score[2];			// 896 bytes
-	uint32_t chapter_score[2];					// 904 bytes	// full filled only after EndVersusRoundEnd
-	uint8_t unknownData1[72];					// 912 bytes
-	uint32_t survivors_completion_score[2][4];	// 976 bytes
-	uint32_t survivors_death_score[2][4];		// 1008 bytes
-	uint8_t survivors_escaped[4];				// 1040 bytes	// in-game buffer
-	uint32_t versus_completion_score;			// 1044 bytes	// in-game buffer
-	uint32_t versus_survival_multiplier[2];		// 1048 bytes	// user count who survived
-	uint8_t unknownData2[92];			      	// 1056 bytes
-	uint8_t areTeamsFlipped						// 1148 bytes
-	uint8_t roundFirstHalf						// 1149 bytes
-	uint8_t isTransitionToNextMap;		      	// 1150 bytes
-	uint8_t unknownData3[5];				    // 1151 bytes
-	uint32_t sacrafice_escaped_mask;			// 1156 bytes	// e.g. 1000 0110 0000 0001 1000 0110 0000 0001 where bit position is a client index
+	uint8_t unknownData[908];					// 0 bytes
+	uint32_t versus_score_bonus[2];				// 908 bytes	// temp buffer to store chapter score for second team
+	uint32_t versus_campaign_score[2];			// 916 bytes
+	uint32_t chapter_score[2];					// 924 bytes	// full filled only after EndVersusRoundEnd
+	uint8_t unknownData1[72];					// 932 bytes
+	uint32_t survivors_completion_score[2][4];	// 996 bytes
+	uint32_t survivors_death_score[2][4];		// 1028 bytes
+	uint8_t survivors_escaped[4];				// 1060 bytes	// in-game buffer
+	uint32_t versus_completion_score;			// 1064 bytes	// in-game buffer
+	uint32_t versus_survival_multiplier[2];		// 1068 bytes	// user count who survived
+	uint8_t unknownData2[92];			      	// 1076 bytes
+	uint8_t areTeamsFlipped						// 1168 bytes
+	uint8_t roundFirstHalf						// 1169 bytes
+	uint8_t isTransitionToNextMap;		      	// 1170 bytes
+	uint8_t unknownData3[5];				    // 1171 bytes
+	uint32_t sacrafice_escaped_mask;			// 1176 bytes	// e.g. 1000 0110 0000 0001 1000 0110 0000 0001 where bit position is a client index
 } CTerrorGameRules_t;
 */
 
 namespace Detours
 {
-#ifdef WIN32
 	int cmp_uint_desc(const void* p1, const void* p2) {
 		return static_cast<int>(*(uint32_t*)p2 - *(uint32_t*)p1);
 	}
-#endif
 
 	int __thiscall RecomputeVersusCompletion::OnRecompute(bool arg) {
-		int i;
-		bool team = AreTeamsFlipped(*g_pDirector);
+		int newTotalResult = myRecompute(this);
+		if(newTotalResult <= g_totalResult) {
+			return g_totalResult;
+		}
 
-		i = myRecompute(this);
-		if(i > g_totalResult) g_totalResult = i;
+		g_totalResult = newTotalResult;
 
 		uint32_t (*piVersusSurvivorCompletion)[4] = reinterpret_cast<uint32_t(*)[4]>((unsigned char *)(this) + g_versusSurvivorCompletionOffset);
 
 		/**
 		* Fix score shows by pressing TAB
 		*/
-		NotifyNetworkStateChanged();
+
+		bool team = AreTeamsFlipped(*g_pDirector);
 
 		piVersusSurvivorCompletion[team][0] =
 			piVersusSurvivorCompletion[team][1] =
@@ -89,6 +89,8 @@ namespace Detours
 
 		piVersusSurvivorCompletion[team][0] += g_totalResult % 4;
 
+		NotifyNetworkStateChanged();
+
 		L4D_DEBUG_LOG("Recompute return: %d.", g_totalResult);
 
 		return g_totalResult;
@@ -149,15 +151,7 @@ namespace Detours
 
 		result += r_appendScores(pNextScore, TEAM_SIZE - (pNextScore - g_iHighestVersusSurvivorCompletion), g_dead_players, arraysize(g_dead_players));
 
-		qsort(g_iHighestVersusSurvivorCompletion, TEAM_SIZE, sizeof(uint32_t),
-#ifdef WIN32
-			cmp_uint_desc
-#else
-			[] (const void* p1, const void* p2) {
-				 return static_cast<int>(*(uint32_t*)p2 - *(uint32_t*)p1);
-			  }
-#endif
-		);
+		qsort(g_iHighestVersusSurvivorCompletion, TEAM_SIZE, sizeof(uint32_t), cmp_uint_desc);
 		return result;
 	}
 }

src/sdk/smsdk_config.h

@@ -43,7 +43,7 @@
 /* Basic information exposed publicly */
 #define SMEXT_CONF_NAME			"Left4Fix"
 #define SMEXT_CONF_DESCRIPTION	"Fix score completion on servers have 8+ players"
-#define SMEXT_CONF_VERSION		QUOTE(2.0.2 (TEAM_SIZE players))
+#define SMEXT_CONF_VERSION		QUOTE(2.0.3 (TEAM_SIZE players))
 #define SMEXT_CONF_AUTHOR		"spumer"
 #define SMEXT_CONF_URL			"https://forums.alliedmods.net/member.php?u=151387"
 #define SMEXT_CONF_LOGTAG		"L4FIX"