ExtraSource for takedmg callbacks (the laser!)

Author: ConnorForan

changelog.txt

@@ -117,6 +117,11 @@ Modified:
 * ModCallbacks:
 	- MC_POST_PLAYER_DROP_TRINKET
 		Added DroppedTrinket param.
+	- MC_(POST_)ENTITY_TAKE_DMG
+		Added ExtraSource param. This is an additional EntityRef provided in specific situations where the "Source" of the damage may be indirect.
+		For example, lasers and melee hitboxes provide their parent (ie, the player) instead of themselves as the damage Source. The laser/knife will now be passed as the ExtraSource!
+		Currently supported: lasers, melee hitbox knives, gello, and brimstone balls.
+		Note that ExtraSource is nil if not available.
 /newline/
 Fixes:
 * ModCallbacks:

libzhl/functions/ASM.zhl

@@ -107,6 +107,21 @@ asm SplitTears_PreAngelicPrism "8b06ff50??c785????????00000000";
 asm SplitTears_PostAngelicPrism "0f8c????????8bbd????????8bb5????????8b8d";
 asm SplitTears_AngelicPrismOriginalTearOffset "8bb5????????81ff";
 
+// ExtraSource for TakeDamage
+asm UpdateBoneSwingDamage "6a1e51ffb5????????8b40??ffb5????????518bcff30f110424ffd084c00f84????????6a008bcf";
+asm UpdateBoneSwingDamageFireplace "6a1e516a006a00518bcfc7042400007a44ff50??c685????????01";
+asm LaserDoDamagePushEbxA "0f1083????????5383ec14";  // 0x7
+asm LaserDoDamagePushEbxB "8b57??a1????????83fa3e";  // 0x8
+asm LaserDoDamageA "6a1e526a008b01680808000051c704240000803f";  // 0x14
+asm LaserDoDamageB "8b076a1e51535651f30f1104248bcf";  // 0xF
+asm LaserDoDamageExit "8b4d??5f5e33cd5be8????????8be55dc20400??????????8d81";
+asm LaserDoDamagePlayer "6a1e516a006a08518bc8c704240000803fff52??5f";  // 0x11 + 0x3
+asm GelloDamageEbpOffset "8b85????????8d8d????????ffb0????????e8????????8b068d8d????????6a1e";  // +0x2, int
+asm GelloDamage "6a1e51ffb5????????8b40??ffb5????????518bce";  // 0x1A + 0x2
+asm GelloDamageFireplace "6a1e516a006a00518bcec7042400007a44ff50??0f57c9";  // 0x11 + 0x3
+asm BrimstoneBallDamageEbpOffset "8b8d????????8b91????????528d8d????????e8????????6a1e8d85????????508b8d????????518b95????????5251f30f1085????????f30f1104248b85????????8b108b8d????????8b42??ffd0e9";  // +0x2, int
+asm BrimstoneBallDamage "6a1e8d85????????508b8d????????518b95????????5251f30f1085????????f30f1104248b85????????8b108b8d????????8b42??ffd0e9";  // 0x36 + 0x2
+
 asm InlinedGetStatusEffectTarget_Baited "e8????????84c074??8b8f????????85c974??6690";
 asm InlinedGetStatusEffectTarget_Bleeding "e8????????84c074??8b8f????????85c974??8bf18b8e????????85c975??85d20f84????????8b86????????83e00183c8000f85????????3986????????0f8f????????8b8e????????85d27e??8d04??b978000000";
 asm InlinedGetStatusEffectTarget_BrimstoneMark "e8????????84c074??8b8e????????85c974??660f1f84??00000000";
@@ -143,7 +158,7 @@ asm TryAddToBagOfCraftingBelialEffectEspOffset "c64424??0083fb1e";
 asm TryAddToBagOfCraftingAccessArray "8b54????85d274??83f808";
 asm TryAddToBagOfCraftingArrayLength "83f90272??894424";
 
-asm PostMeleeHitboxInit "8b078bcfff50??8b4d??85c9";
+asm PostMeleeHitboxInit "ffb5????????8bcfe8????????0fb786";
 
 asm PreBombApplyTearFlagEffects "8b43??0b43??75??8b43??0b43??0f84";
 

libzhl/functions/EntityRef.zhl

@@ -4,6 +4,7 @@ __thiscall void EntityRef::constructor(Entity* entity);
 struct EntityRef depends (Vector)
 {
   {{
+    EntityRef() { this->constructor(nullptr); }
     EntityRef(Entity* entity) { this->constructor(entity); }
   }}
   int  _type : 0x0; //TODO: EntityType enum

repentogon/Patches/ASMPatches.cpp

@@ -173,8 +173,7 @@ void PerformASMPatches() {
 	ASMCallbacks::detail::ApplyPatches();
 	PatchPreSampleLaserCollision();
 	PatchPreLaserCollision();
-	PatchPreEntityTakeDamageCallbacks();
-	PatchPostEntityTakeDamageCallbacks();
+	PatchEntityTakeDamageCallbacks();
 	ASMPatchPrePlayerUseBomb();
 	ASMPatchPostPlayerUseBomb();
 	ASMPatchPreMMorphActiveCallback();

repentogon/Patches/ASMPatches/ASMCallbacks.cpp

@@ -183,6 +183,88 @@ void PatchPreLaserCollision() {
 
 // End of PRE_LASER_COLLISION patches
 
+
+// ---------- Beginning of MC_(POST_)ENTITY_TAKE_DMG related patches --------------------------------------------------
+
+// Place to temporarily store "extra sources" to pass to the TakeDamage callbacks.
+// These refs are keyed by the address of the primary EntityRef created for, and passed to, the TakeDamage call.
+// An entry in this map is added right before the TakeDamage call, and removed immediately afterwards,
+// allowing access to the extra source for the duration of the TakeDamage call.
+// Should not be modified outside of `TakeDamageWithExtraSource`.
+static std::unordered_map<uintptr_t, EntityRef> _TakeDamageExtraSources;
+
+// Fetch the extra source for a TakeDamage source, if any exists.
+static EntityRef* GetExtraTakeDamageSource(EntityRef* source) {
+	if (source && _TakeDamageExtraSources.find((uintptr_t)source) != _TakeDamageExtraSources.end()) {
+		EntityRef* extraSource = &_TakeDamageExtraSources[(uintptr_t)source];
+		if (extraSource && extraSource->_entity != source->_entity) {
+			return extraSource;
+		}
+	}
+	return nullptr;
+}
+
+// Call TakeDamage with an "extra source", available via the standard "source" for the TAKE_DMG callbacks.
+// Patches are used to overwrite relevant TakeDamage calls with this one that enables the extra source.
+bool __stdcall TakeDamageWithExtraSource(Entity* damagedEntity, float damage, uint64_t damageFlags, EntityRef* source, int damageCountdown, Entity* extraSourceEntity) {
+	_TakeDamageExtraSources[(uintptr_t)source] = EntityRef(extraSourceEntity);
+	bool result = damagedEntity->TakeDamage(damage, damageFlags, source, damageCountdown);
+	_TakeDamageExtraSources.erase((uintptr_t)source);
+	return result;
+}
+void PatchLaserDoDamageExtraSourcePushEbx(char* asmDef, int overriddenBytes) {
+	void* addr = sASMDefinitionHolder->GetDefinition(asmDef);
+	printf("[REPENTOGON] Patching Entity_Laser::DoDamage at %p\n", addr);
+	ASMPatch patch;
+	patch.Push(ASMPatch::Registers::EBX)
+		.AddBytes(ByteBuffer().AddAny((char*)addr, overriddenBytes))
+		.AddRelativeJump((char*)addr + overriddenBytes);
+	sASMPatcher.PatchAt(addr, &patch);
+}
+void PatchLaserDoDamageExtraSource(char* asmDef, int bytesToCopy) {
+	void* addr = sASMDefinitionHolder->GetDefinition(asmDef);
+	void* exitAddr = sASMDefinitionHolder->GetDefinition(&AsmDefinitions::LaserDoDamageExit);
+
+	printf("[REPENTOGON] Patching Entity::TakeDamage call in Entity_Laser::DoDamage at %p\n", addr);
+
+	ASMPatch::SavedRegisters savedRegisters((ASMPatch::SavedRegisters::Registers::GP_REGISTERS_STACKLESS | ASMPatch::SavedRegisters::Registers::XMM_REGISTERS) & ~ASMPatch::SavedRegisters::Registers::EAX, true);
+	ASMPatch patch;
+	patch.Pop(ASMPatch::Registers::EAX)
+		.PreserveRegisters(savedRegisters)
+		.Push(ASMPatch::Registers::EAX)
+		.AddBytes(ByteBuffer().AddAny((char*)addr, bytesToCopy))
+		.Push(ASMPatch::Registers::ECX)
+		.AddInternalCall(TakeDamageWithExtraSource)
+		.RestoreRegisters(savedRegisters)
+		.AddRelativeJump(exitAddr);
+	sASMPatcher.PatchAt(addr, &patch);
+}
+void PatchTakeDamageWithExtraSource(char* desc, char* asmDef, ASMPatch::Registers extraSourceRegister, char* offsetAsmDef, int bytesToCopy, int addJump) {
+	void* addr = sASMDefinitionHolder->GetDefinition(asmDef);
+
+	int offset = 0;
+	if (offsetAsmDef) {
+		offset = *(int*)((char*)sASMDefinitionHolder->GetDefinition(offsetAsmDef) + 0x2);
+	}
+
+	printf("[REPENTOGON] Patching Entity::TakeDamage call for ExtraSource (%s) at %p\n", desc, addr);
+
+	ASMPatch::SavedRegisters savedRegisters((ASMPatch::SavedRegisters::Registers::GP_REGISTERS_STACKLESS | ASMPatch::SavedRegisters::Registers::XMM_REGISTERS) & ~ASMPatch::SavedRegisters::Registers::EAX, true);
+	ASMPatch patch;
+	patch.PreserveRegisters(savedRegisters);
+	if (offsetAsmDef) {
+		patch.Push(extraSourceRegister, offset);
+	} else {
+		patch.Push(extraSourceRegister);
+	}
+	patch.AddBytes(ByteBuffer().AddAny((char*)addr, bytesToCopy))
+		.Push(ASMPatch::Registers::ECX)
+		.AddInternalCall(TakeDamageWithExtraSource)
+		.RestoreRegisters(savedRegisters)
+		.AddRelativeJump((char*)addr + bytesToCopy + addJump);
+	sASMPatcher.PatchAt(addr, &patch);
+}
+
 /* * MC_ENTITY_TAKE_DMG REIMPLEMENTATION * *
 * This section patches in a new ENTITY_TAKE_DMG callback with table returns for overridding.
 * A patch is used because ENTITY_TAKE_DMG runs in the middle of the TakeDamage functions,
@@ -192,8 +274,9 @@ void PatchPreLaserCollision() {
 * We need to patch into both Entity::TakeDamage AND EntityPlayer::TakeDamage.
 */
 bool __stdcall ProcessPreDamageCallback(Entity* entity, float* damage, int* damageHearts, uint64_t* damageFlags, EntityRef* source, int* damageCountdown, const bool isPlayer) {
-	const int callbackid = 11;
+	EntityRef* extraSource = GetExtraTakeDamageSource(source);
 
+	const int callbackid = 11;
 	if (VanillaCallbackState.test(callbackid)) {
 		lua_State* L = g_LuaEngine->_state;
 		lua::LuaStackProtector protector(L);
@@ -212,7 +295,8 @@ bool __stdcall ProcessPreDamageCallback(Entity* entity, float* damage, int* dama
 		}
 		caller.push(*damageFlags)
 			.push(source, lua::Metatables::ENTITY_REF)
-			.push(*damageCountdown);
+			.push(*damageCountdown)
+			.push(extraSource, lua::Metatables::ENTITY_REF);
 		lua::LuaResults lua_result = caller.call(1);
 
 		if (!lua_result) {
@@ -283,7 +367,6 @@ bool __stdcall ProcessPreDamageCallback(Entity* entity, float* damage, int* dama
 
 	return true;
 }
-
 void InjectPreDamageCallback(void* addr, bool isPlayer) {
 	printf("[REPENTOGON] Patching %s::TakeDamage for MC_ENTITY_TAKE_DMG at %p\n", isPlayer ? "Entity_Player" : "Entity", addr);
 
@@ -337,26 +420,18 @@ void InjectPreDamageCallback(void* addr, bool isPlayer) {
 	sASMPatcher.PatchAt(addr, &patch);
 }
 
-// Patches overtop the existing calls to LuaEngine::Callback::EntityTakeDamage,
-// within the Entity::TakeDamage and EntityPlayer::TakeDamage functions respectively.
-void PatchPreEntityTakeDamageCallbacks() {
-	InjectPreDamageCallback(sASMDefinitionHolder->GetDefinition(&AsmDefinitions::TakeDmg_PreEntityCallback), false);
-	InjectPreDamageCallback(sASMDefinitionHolder->GetDefinition(&AsmDefinitions::TakeDmg_PrePlayerCallback), true);
-}
-
 // Even though I patched overtop the calls to this callback, super kill it for good measure.
 HOOK_METHOD(LuaEngine, EntityTakeDamage, (Entity* entity, float damage, unsigned long long damageFlags, EntityRef* source, int damageCountdown) -> bool) { return true; }
 
-// End of ENTITY_TAKE_DMG patches
-
 /* * MC_POST_ENTITY_TAKE_DMG * *
 * A hook worked just fine for ""POST_TAKE_DMG"" initially, but now that we support overidding
 * values via ENTITY_TAKE_DMG (see above) we need the POST_TAKE_DMG callback to actually show
 * those modified values. That means another patch!!
 * Like before, we need to patch into both Entity::TakeDamage and EntityPlayer::TakeDamage.
 */
-
 void __stdcall ProcessPostDamageCallback(Entity* entity, const float damage, const uint64_t damageFlags, EntityRef* source, const int damageCountdown, const bool isPlayer) {
+	EntityRef* extraSource = GetExtraTakeDamageSource(source);
+
 	const int callbackid = 1006;
 	if (CallbackState.test(callbackid - 1000)) {
 		if (isPlayer && source->_type == 33 && source->_variant == 4) {
@@ -381,10 +456,10 @@ void __stdcall ProcessPostDamageCallback(Entity* entity, const float damage, con
 		caller.push(damageFlags)
 			.push(source, lua::Metatables::ENTITY_REF)
 			.push(damageCountdown)
+			.push(extraSource, lua::Metatables::ENTITY_REF)
 			.call(1);
 	}
 };
-
 void InjectPostDamageCallback(void* addr, bool isPlayer) {
 	printf("[REPENTOGON] Patching %s::TakeDamage for MC_POST_ENTITY_TAKE_DMG at %p\n", isPlayer ? "Entity_Player" : "Entity", addr);
 	const int numOverriddenBytes = (isPlayer ? 10 : 5);
@@ -426,15 +501,32 @@ void InjectPostDamageCallback(void* addr, bool isPlayer) {
 	sASMPatcher.PatchAt(addr, &patch);
 }
 
-// These patches overwrite suitably-sized commands near where the respective TakeDamage functions would return.
-// The overridden bytes are restored by the patch.
-void PatchPostEntityTakeDamageCallbacks() {
-	// Sig is 6 bytes before where we actually want to patch to avoid bleeding past the end of the function.
+void PatchEntityTakeDamageCallbacks() {
+	// Patches overtop the existing calls to LuaEngine::Callback::EntityTakeDamage,
+	// within the Entity::TakeDamage and EntityPlayer::TakeDamage functions respectively.
+	InjectPreDamageCallback(sASMDefinitionHolder->GetDefinition(&AsmDefinitions::TakeDmg_PreEntityCallback), false);
+	InjectPreDamageCallback(sASMDefinitionHolder->GetDefinition(&AsmDefinitions::TakeDmg_PrePlayerCallback), true);
+
+	// These patches overwrite suitably-sized commands near where the respective TakeDamage functions would return.
+	// The overridden bytes are restored by the patch.
+	// First sig is 6 bytes before where we actually want to patch to avoid bleeding past the end of the function.
 	InjectPostDamageCallback((char*)sASMDefinitionHolder->GetDefinition(&AsmDefinitions::TakeDmg_PostEntityCallback) + 0x6, false);
 	InjectPostDamageCallback(sASMDefinitionHolder->GetDefinition(&AsmDefinitions::TakeDmg_PostPlayerCallback), true);
+
+	// Patches over TakeDamage calls to allow providing an ExtraSource.
+	PatchLaserDoDamageExtraSourcePushEbx(&AsmDefinitions::LaserDoDamagePushEbxA, 0x7);
+	PatchLaserDoDamageExtraSourcePushEbx(&AsmDefinitions::LaserDoDamagePushEbxB, 0x8);
+	PatchLaserDoDamageExtraSource(&AsmDefinitions::LaserDoDamageA, 0x14);
+	PatchLaserDoDamageExtraSource(&AsmDefinitions::LaserDoDamageB, 0xF);
+	PatchTakeDamageWithExtraSource("Entity_Laser::do_damage, player", &AsmDefinitions::LaserDoDamagePlayer, ASMPatch::Registers::EBX, nullptr, 0x11, 0x3);
+	PatchTakeDamageWithExtraSource("Entity_Knife::update_bone_swing", &AsmDefinitions::UpdateBoneSwingDamage, ASMPatch::Registers::ESI, nullptr, 0x1A, 0x2);
+	PatchTakeDamageWithExtraSource("Entity_Knife::update_bone_swing, fireplace", &AsmDefinitions::UpdateBoneSwingDamageFireplace, ASMPatch::Registers::ESI, nullptr, 0x11, 0x3);
+	PatchTakeDamageWithExtraSource("Entity_Familiar::ai_umbilical_baby", &AsmDefinitions::GelloDamage, ASMPatch::Registers::EBP, &AsmDefinitions::GelloDamageEbpOffset, 0x1A, 0x2);
+	PatchTakeDamageWithExtraSource("Entity_Familiar::ai_umbilical_baby, fireplace", &AsmDefinitions::GelloDamageFireplace, ASMPatch::Registers::EBP, &AsmDefinitions::GelloDamageEbpOffset, 0x11, 0x3);
+	PatchTakeDamageWithExtraSource("Entity_Effect::Update, Brimstone Ball", &AsmDefinitions::BrimstoneBallDamage, ASMPatch::Registers::EBP, &AsmDefinitions::BrimstoneBallDamageEbpOffset, 0x36, 0x2);
 }
 
-// End of POST_ENTITY_TAKE_DMG patches
+// ---------- End of MC_(POST_)ENTITY_TAKE_DMG related patches --------------------------------------------------
 
 
 // MC_PRE_PLAYER_USE_BOMB

repentogon/Patches/ASMPatches/ASMCallbacks.h

@@ -8,8 +8,7 @@ bool RunCanSelectCharacterCallback(int playerType, bool isBeingSelected);
 
 void PatchPreSampleLaserCollision();
 void PatchPreLaserCollision();
-void PatchPreEntityTakeDamageCallbacks();
-void PatchPostEntityTakeDamageCallbacks();
+void PatchEntityTakeDamageCallbacks();
 void ASMPatchPrePlayerUseBomb();
 void ASMPatchPostPlayerUseBomb();
 void ASMPatchBombPreApplyTearflagEffects();

repentogon/Patches/ASMPatches/ASMEntityKnife.cpp

@@ -12,7 +12,6 @@ void __stdcall RunMeleeHitboxCallback(Entity_Knife* hitboxKnife, Entity_Knife* m
 	if (entityPlus) {
 		entityPlus->hitboxSource.SetReference(mainKnife);
 	}
-	hitboxKnife->Update();  // Patch overwrites an update call.
 }
 void PatchMeleeHitboxInit() {
 	void* addr = sASMDefinitionHolder->GetDefinition(&AsmDefinitions::PostMeleeHitboxInit);
@@ -26,6 +25,7 @@ void PatchMeleeHitboxInit() {
 		.Push(ASMPatch::Registers::EDI)  // "Hitbox" Knife
 		.AddInternalCall(RunMeleeHitboxCallback)
 		.RestoreRegisters(savedRegisters)
-		.AddRelativeJump((char*)addr + 0x7);
+		.AddBytes(ByteBuffer().AddAny((char*)addr, 0x6))  // Restore overwritten bytes
+		.AddRelativeJump((char*)addr + 0x6);
 	sASMPatcher.PatchAt(addr, &patch);
 }

repentogon/resources/scripts/main_ex.lua

@@ -1387,11 +1387,11 @@ end
 
 -- Custom handling for the MC_ENTITY_TAKE_DMG rewrite, so if a mod changes the damage amount etc that doesn't terminate the callback
 -- and the updated values are shown to later callbacks. The callback also now ONLY terminates early if FALSE is returned.
-function _RunEntityTakeDmgCallback(callbackID, param, entity, damage, damageFlags, source, damageCountdown)
+function _RunEntityTakeDmgCallback(callbackID, param, entity, damage, damageFlags, source, damageCountdown, extraSource)
 	local combinedRet
 
 	for callback in GetCallbackIterator(callbackID, param) do
-		local ret = RunCallbackInternal(callbackID, callback, entity, damage, damageFlags, source, damageCountdown)
+		local ret = RunCallbackInternal(callbackID, callback, entity, damage, damageFlags, source, damageCountdown, extraSource)
 		if ret ~= nil then
 			if type(ret) == "boolean" and ret == false then
 				-- Only terminate the callback early if someone returns FALSE.