Revise PVP Block and Hit Recovery handling

Source/missiles.cpp

@@ -25,6 +25,7 @@
 #include "levels/trigs.h"
 #include "lighting.h"
 #include "monster.h"
+#include "player.h"
 #include "spells.h"
 #include "utils/str_cat.hpp"
 
@@ -280,9 +281,24 @@ bool MonsterMHit(const Player &player, int monsterId, int mindam, int maxdam, in
 	return true;
 }
 
-bool Plr2PlrMHit(const Player &player, Player &target, int mindam, int maxdam, int dist, MissileID mtype, DamageType damageType, bool shift, bool *blocked)
+int8_t GetTargetResistance(const Player &target, DamageType damageType)
 {
-	if (sgGameInitInfo.bFriendlyFire == 0 && player.friendlyMode)
+	switch (damageType) {
+	case DamageType::Fire:
+		return target._pFireResist;
+	case DamageType::Lightning:
+		return target._pLghtResist;
+	case DamageType::Magic:
+	case DamageType::Acid:
+		return target._pMagResist;
+	default:
+		return 0;
+	}
+}
+
+bool Plr2PlrMHit(const Player &attacker, const Player &target, int mindam, int maxdam, int dist, MissileID mtype, DamageType damageType, bool shift, bool *blocked)
+{
+	if (sgGameInitInfo.bFriendlyFire == 0 && attacker.friendlyMode)
 		return false;
 
 	*blocked = false;
@@ -300,81 +316,64 @@ bool Plr2PlrMHit(const Player &player, Player &target, int mindam, int maxdam, i
 
 	const MissileData &missileData = GetMissileData(mtype);
 
-	if (HasAnyOf(target._pSpellFlags, SpellFlag::Etherealize) && missileData.isArrow()) {
-		return false;
-	}
-
-	int8_t resper;
-	switch (damageType) {
-	case DamageType::Fire:
-		resper = target._pFireResist;
-		break;
-	case DamageType::Lightning:
-		resper = target._pLghtResist;
-		break;
-	case DamageType::Magic:
-	case DamageType::Acid:
-		resper = target._pMagResist;
-		break;
-	default:
-		resper = 0;
-		break;
-	}
+	// Get resistances
+	int8_t resper = GetTargetResistance(target, damageType);
 
-	int hper = GenerateRnd(100);
+	// Hit check
+	int hit = GenerateRnd(100);
 
-	int hit;
+	int hper;
 	if (missileData.isArrow()) {
-		hit = player.GetRangedToHit()
+		hper = attacker.GetRangedToHit()
 		    - (dist * dist / 2)
 		    - target.GetArmor();
 	} else {
-		hit = player.GetMagicToHit()
+		hper = attacker.GetMagicToHit()
 		    - (target.getCharacterLevel() * 2)
 		    - dist;
 	}
 
-	hit = std::clamp(hit, 5, 95);
+	hper = std::clamp(hper, 5, 95);
 
-	if (hper >= hit) {
+	if (hit >= hper) {
 		return false;
 	}
 
-	int blkper = 100;
-	if (!shift && (target._pmode == PM_STAND || target._pmode == PM_ATTACK) && target._pBlockFlag) {
-		blkper = GenerateRnd(100);
-	}
-
-	int blk = target.GetBlockChance() - (player.getCharacterLevel() * 2);
-	blk = std::clamp(blk, 0, 100);
-
+	// Calculate damage
 	int dam;
 	if (mtype == MissileID::BoneSpirit) {
 		dam = target._pHitPoints / 3;
 	} else {
-		dam = mindam + GenerateRnd(maxdam - mindam + 1);
-		if (missileData.isArrow() && damageType == DamageType::Physical)
-			dam += player._pIBonusDamMod + player._pDamageMod + dam * player._pIBonusDam / 100;
+		dam = RandomIntBetween(mindam, maxdam);
+		if (missileData.isArrow() && damageType == DamageType::Physical) {
+			dam += dam * attacker._pIBonusDam / 100;
+			dam += attacker._pIBonusDamMod + attacker._pDamageMod;
+		}
 		if (!shift)
 			dam <<= 6;
 	}
+
+	// Halve arrow damage
 	if (!missileData.isArrow())
 		dam /= 2;
+
+	// Resistance damage reduction
 	if (resper > 0) {
 		dam -= (dam * resper) / 100;
-		if (&player == MyPlayer)
+		if (&attacker == MyPlayer)
 			NetSendCmdDamage(true, target, dam, damageType);
 		target.Say(HeroSpeech::ArghClang);
 		return true;
 	}
 
-	if (blkper < blk) {
-		StartPlrBlock(target, GetDirection(target.position.tile, player.position.tile));
+	// Block check
+	if (TryPlayerBlock(attacker, target, shift)) {
 		*blocked = true;
 	} else {
-		if (&player == MyPlayer)
-			NetSendCmdDamage(true, target, dam, damageType);
-		StartPlrHit(target, dam, false);
+		if (&attacker == MyPlayer) {
+			NetSendCmdDamage(true, target, dam, damageType);                     // Damage target
+			NetSendCmdParam2(true, CMD_PLRINFLICTRECOVERY, target.getId(), dam); // Inflict hit recovery
+		}
 	}
 
 	return true;

Source/msg.cpp

@@ -1867,6 +1867,39 @@ size_t OnPlayerDamage(const TCmd *pCmd, Player &player)
 	return sizeof(message);
 }
 
+size_t OnPlayerInflictBlock(const TCmd *pCmd, Player &player)
+{
+	const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
+	const uint16_t pid = SDL_SwapLE16(message.wParam1);
+
+	Player &target = Players[pid];
+	if (leveltype != DTYPE_TOWN && gbBufferMsgs != 1) {
+		if (player.isOnActiveLevel() && target._pHitPoints >> 6 > 0) {
+			Direction dir = GetDirection(target.position.tile, player.position.tile);
+			StartPlrBlock(target, dir);
+		}
+	}
+
+	return sizeof(message);
+}
+
+size_t OnPlayerInflictRecovery(const TCmd *pCmd, Player &player)
+{
+	const auto &message = *reinterpret_cast<const TCmdParam2 *>(pCmd);
+	const uint16_t pid = SDL_SwapLE16(message.wParam1);
+	const uint16_t dam = SDL_SwapLE16(message.wParam2);
+
+	Player &target = Players[pid];
+	if (leveltype != DTYPE_TOWN && gbBufferMsgs != 1) {
+		if (player.isOnActiveLevel() && target._pHitPoints >> 6 > 0) {
+			Direction dir = GetDirection(target.position.tile, player.position.tile);
+			StartPlrHit(target, dam, false);
+		}
+	}
+
+	return sizeof(message);
+}
+
 size_t OnOperateObject(const TCmd &pCmd, Player &player)
 {
 	const auto &message = reinterpret_cast<const TCmdLoc &>(pCmd);
@@ -3295,6 +3328,10 @@ size_t ParseCmd(uint8_t pnum, const TCmd *pCmd)
 		return OnPlayerDeath(pCmd, player);
 	case CMD_PLRDAMAGE:
 		return OnPlayerDamage(pCmd, player);
+	case CMD_PLRINFLICTBLOCK:
+		return OnPlayerInflictBlock(pCmd, player);
+	case CMD_PLRINFLICTRECOVERY:
+		return OnPlayerInflictRecovery(pCmd, player);
 	case CMD_OPENDOOR:
 	case CMD_CLOSEDOOR:
 	case CMD_OPERATEOBJ:

Source/msg.h

@@ -281,6 +281,14 @@ enum _cmd_id : uint8_t {
 	//
 	// body (TCmdDamage)
 	CMD_PLRDAMAGE,
+	// Make target player block.
+	//
+	// body (TCmdParam1)
+	CMD_PLRINFLICTBLOCK,
+	// Make target player enter hit recovery.
+	//
+	// body (TCmdParam1)
+	CMD_PLRINFLICTRECOVERY,
 	// Set player level.
 	//
 	// body (TCmdParam1):

Source/player.cpp

@@ -697,53 +697,45 @@ bool PlrHitMonst(Player &player, Monster &monster, bool adjacentDamage = false)
 	return true;
 }
 
-bool PlrHitPlr(Player &attacker, Player &target)
+bool PlrHitPlr(Player &attacker, const Player &target)
 {
 	if (target._pInvincible) {
 		return false;
 	}
 
-	if (HasAnyOf(target._pSpellFlags, SpellFlag::Etherealize)) {
-		return false;
-	}
-
+	// Hit check
 	int hit = GenerateRnd(100);
 
 	int hper = attacker.GetMeleeToHit() - target.GetArmor();
 	hper = std::clamp(hper, 5, 95);
 
-	int blk = 100;
-	if ((target._pmode == PM_STAND || target._pmode == PM_ATTACK) && target._pBlockFlag) {
-		blk = GenerateRnd(100);
-	}
-
-	int blkper = target.GetBlockChance() - (attacker.getCharacterLevel() * 2);
-	blkper = std::clamp(blkper, 0, 100);
-
 	if (hit >= hper) {
 		return false;
 	}
 
-	if (blk < blkper) {
-		Direction dir = GetDirection(target.position.tile, attacker.position.tile);
-		StartPlrBlock(target, dir);
-		return true;
+	// Block check
+	if (&attacker == MyPlayer) {
+		if (TryPlayerBlock(attacker, target))
+			return true;
 	}
 
-	int mind = attacker._pIMinDam;
-	int maxd = attacker._pIMaxDam;
-	int dam = GenerateRnd(maxd - mind + 1) + mind;
+	// Calculate damage
+	int dam = RandomIntBetween(attacker._pIMinDam, attacker._pIMaxDam);
 	dam += (dam * attacker._pIBonusDam) / 100;
 	dam += attacker._pIBonusDamMod + attacker._pDamageMod;
 
+	// Critical hit check
 	if (attacker._pClass == HeroClass::Warrior || attacker._pClass == HeroClass::Barbarian) {
 		if (GenerateRnd(100) < attacker.getCharacterLevel()) {
 			dam *= 2;
 		}
 	}
-	int skdam = dam << 6;
+
+	dam <<= 6;
+
+	// Undead Crown life steal check
 	if (HasAnyOf(attacker._pIFlags, ItemSpecialEffect::RandomStealLife)) {
-		int tac = GenerateRnd(skdam / 8);
+		int tac = GenerateRnd(dam / 8);
 		attacker._pHitPoints += tac;
 		if (attacker._pHitPoints > attacker._pMaxHP) {
 			attacker._pHitPoints = attacker._pMaxHP;
@@ -754,10 +746,11 @@ bool PlrHitPlr(Player &attacker, Player &target)
 		}
 		RedrawComponent(PanelDrawComponent::Health);
 	}
+
 	if (&attacker == MyPlayer) {
-		NetSendCmdDamage(true, target, skdam, DamageType::Physical);
+		NetSendCmdDamage(true, target, dam, DamageType::Physical); // Damage target
+		NetSendCmdParam2(true, CMD_PLRINFLICTRECOVERY, target.getId(), dam); // Inflict hit recovery
 	}
-	StartPlrHit(target, skdam, false);
 
 	return true;
 }
@@ -3456,6 +3449,27 @@ void PlayDungMsgs()
 	}
 }
 
+bool TryPlayerBlock(const Player &attacker, const Player &target, bool shift /*= false*/)
+{
+	if (!target._pBlockFlag || IsNoneOf(target._pmode, PM_STAND, PM_ATTACK) || shift)
+		return false;
+
+	int blk = 100;
+
+	if ((target._pmode == PM_STAND || target._pmode == PM_ATTACK) && target._pBlockFlag)
+		blk = GenerateRnd(100);
+
+	int blkper = target.GetBlockChance() - (attacker.getCharacterLevel() * 2);
+
+	blkper = std::clamp(blkper, 0, 100);
+
+	if (blk < blkper) {
+		NetSendCmdParam1(true, CMD_PLRINFLICTBLOCK, target.getId());
+		return true;
+	}
+	return false;
+}
+
 #ifdef BUILD_TESTING
 bool TestPlayerDoGotHit(Player &player)
 {

Source/player.h

@@ -984,5 +984,6 @@ void SetPlrDex(Player &player, int v);
 void SetPlrVit(Player &player, int v);
 void InitDungMsgs(Player &player);
 void PlayDungMsgs();
+bool TryPlayerBlock(const Player &attacker, const Player &target, bool shift = false);
 
 } // namespace devilution