sgGameInitInfo options sync and Active Block

Author: wkdgmr

Source/DiabloUI/multi/selgame.cpp

@@ -669,6 +669,7 @@ void selgame_Password_Select(size_t /*value*/)
 	m_game_data->bSharedExperience = *GetOptions().Gameplay.sharedXP ? 1 : 0;
 	m_game_data->bRemoveCripplingEffects = *GetOptions().Gameplay.removeCripplingEffects ? 1 : 0;
 	m_game_data->bDisableSearch = *GetOptions().Gameplay.disableSearch ? 1 : 0;
+	m_game_data->bActiveBlock = *GetOptions().Gameplay.activeBlock ? 1 : 0;
 
 	GameData gameInitInfo = *m_game_data;
 	gameInitInfo.swapLE();

Source/control.cpp

@@ -22,9 +22,11 @@
 #include "controls/plrctrls.h"
 #include "cursor.h"
 #include "diablo_msg.hpp"
+#include "effects.h"
 #include "engine/backbuffer_state.hpp"
 #include "engine/clx_sprite.hpp"
 #include "engine/load_cel.hpp"
+#include "engine/palette.h"
 #include "engine/render/clx_render.hpp"
 #include "engine/render/text_render.hpp"
 #include "engine/trn.hpp"
@@ -337,54 +339,82 @@ int DrawDurIcon4Item(const Surface &out, Item &pItem, int x, int c)
 	const int durabilityThresholdGold = 5;
 	const int durabilityThresholdRed = 2;
 
-	if (pItem.isEmpty())
-		return x;
-	if (pItem._iDurability > durabilityThresholdGold)
-		return x;
+	bool isMonk = MyPlayer->_pClass == HeroClass::Monk;
+	bool isShield = pItem._itype == ItemType::Shield;
+	bool isStaff = pItem._itype == ItemType::Staff;
+	bool isBareHandedMonk = pItem.isEmpty() && isMonk && MyPlayer->disableBlock;
+
+	bool drawRedX = MyPlayer->disableBlock && (isShield || (isMonk && (isStaff || isBareHandedMonk)));
+
 	if (c == 0) {
-		switch (pItem._itype) {
-		case ItemType::Sword:
-			c = 1;
-			break;
-		case ItemType::Axe:
-			c = 5;
-			break;
-		case ItemType::Bow:
-			c = 6;
-			break;
-		case ItemType::Mace:
-			c = 4;
-			break;
-		case ItemType::Staff:
+		if (isShield)
+			c = 0;
+		else if (isStaff)
 			c = 7;
-			break;
-		case ItemType::Shield:
-		default:
+		else if (isBareHandedMonk)
 			c = 0;
-			break;
-		}
+		else
+			return x;
 	}
 
-	// Calculate how much of the icon should be gold and red
-	int height = (*pDurIcons)[c].height(); // Height of durability icon CEL
+	int height = (*pDurIcons)[c].height();
+	int width = (*pDurIcons)[c].width();
 	int partition = 0;
-	if (pItem._iDurability > durabilityThresholdRed) {
+	int y = -17 + GetMainPanel().position.y;
+
+	bool hasDurability = !pItem.isEmpty();
+	if (hasDurability && pItem._iDurability > durabilityThresholdRed) {
 		int current = pItem._iDurability - durabilityThresholdRed;
 		partition = (height * current) / (durabilityThresholdGold - durabilityThresholdRed);
 	}
 
-	// Draw icon
-	int y = -17 + GetMainPanel().position.y;
-	if (partition > 0) {
-		const Surface stenciledBuffer = out.subregionY(y - partition, partition);
-		ClxDraw(stenciledBuffer, { x, partition }, (*pDurIcons)[c + 8]); // Gold icon
+	bool renderBlendedDurability = hasDurability && pItem._iDurability <= durabilityThresholdGold;
+	bool renderForcedGold = drawRedX && ((isShield || isStaff) && pItem._iDurability > durabilityThresholdGold || isBareHandedMonk);
+
+	if (renderBlendedDurability) {
+		if (partition > 0) {
+			const Surface stenciledBuffer = out.subregionY(y - partition, partition);
+			ClxDraw(stenciledBuffer, { x, partition }, (*pDurIcons)[c + 8]);
+		}
+		if (partition != height) {
+			const Surface stenciledBuffer = out.subregionY(y - height, height - partition);
+			ClxDraw(stenciledBuffer, { x, height }, (*pDurIcons)[c]);
+		}
+	} else if (renderForcedGold) {
+		ClxDraw(out, { x, y }, (*pDurIcons)[c + 8]);
+	} else if (!drawRedX) {
+		return x;
 	}
-	if (partition != height) {
-		const Surface stenciledBuffer = out.subregionY(y - height, height - partition);
-		ClxDraw(stenciledBuffer, { x, height }, (*pDurIcons)[c]); // Red icon
+
+	if (drawRedX) {
+		uint8_t redColor = PAL8_RED + 5;
+		uint8_t blackColor = 0;
+		int crossSize = std::min(width, height) / 2;
+		int offsetX = x + (width - crossSize) / 2;
+		int offsetY = y + (height - crossSize) / 2 - 32;
+
+		for (int i = 0; i < crossSize; ++i) {
+			int dx1 = offsetX + i;
+			int dx2 = offsetX + (crossSize - 1 - i);
+			int dy = offsetY + i;
+
+			for (int ox = -1; ox <= 1; ++ox) {
+				for (int oy = -1; oy <= 1; ++oy) {
+					if (ox != 0 || oy != 0) {
+						out.SetPixel({ dx1 + ox, dy + oy }, blackColor); // ↘ outline
+						out.SetPixel({ dx2 + ox, dy + oy }, blackColor); // ↙ outline
+					}
+				}
+			}
+
+			for (int t = -1; t <= 1; ++t) {
+				out.SetPixel({ dx1, dy + t }, redColor); // ↘
+				out.SetPixel({ dx2, dy + t }, redColor); // ↙
+			}
+		}
 	}
 
-	return x - (*pDurIcons)[c].height() - 8; // Add in spacing for the next durability icon
+	return x - height - 8;
 }
 
 struct TextCmdItem {
@@ -1067,6 +1097,37 @@ void CycleAutomapType()
 	}
 }
 
+void ToggleActiveBlock()
+{
+	if (MyPlayer == nullptr || !MyPlayer->plractive)
+		return;
+
+	if (sgGameInitInfo.bActiveBlock != 1)
+		return;
+
+	const Item &left = MyPlayer->InvBody[INVLOC_HAND_LEFT];
+	const Item &right = MyPlayer->InvBody[INVLOC_HAND_RIGHT];
+
+	const bool isMonk = MyPlayer->_pClass == HeroClass::Monk;
+	const bool hasShield = left._itype == ItemType::Shield || right._itype == ItemType::Shield;
+	const bool hasStaff = left._itype == ItemType::Staff;
+	const bool isBareHanded = left.isEmpty() && right.isEmpty();
+
+	const bool canBlock =
+		(isMonk && (hasShield || hasStaff || isBareHanded)) ||
+		(!isMonk && hasShield);
+
+	if (!canBlock)
+		return;
+
+	MyPlayer->disableBlock = !MyPlayer->disableBlock;
+
+	if (MyPlayer->disableBlock)
+		PlaySFX(SfxID::ItemShieldFlip);
+	else
+		PlaySFX(SfxID::ItemShield);
+}
+
 void CheckPanelInfo()
 {
 	MainPanelFlag = false;
@@ -1409,10 +1470,38 @@ void DrawDurIcon(const Surface &out)
 	}
 
 	Player &myPlayer = *MyPlayer;
-	x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HEAD], x, 3);
-	x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_CHEST], x, 2);
-	x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HAND_LEFT], x, 0);
-	DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HAND_RIGHT], x, 0);
+
+	if (!myPlayer.InvBody[INVLOC_HEAD].isEmpty())
+		x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HEAD], x, 3);
+	if (!myPlayer.InvBody[INVLOC_CHEST].isEmpty())
+		x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_CHEST], x, 2);
+
+	const Item &left = myPlayer.InvBody[INVLOC_HAND_LEFT];
+	const Item &right = myPlayer.InvBody[INVLOC_HAND_RIGHT];
+
+	// Show staff if it's in the left hand and Monk
+	if (left._itype == ItemType::Staff && myPlayer._pClass == HeroClass::Monk)
+		x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HAND_LEFT], x, 0);
+
+	// Show shield if present in either hand
+	if (left._itype == ItemType::Shield)
+		x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HAND_LEFT], x, 0);
+	if (right._itype == ItemType::Shield)
+		x = DrawDurIcon4Item(out, myPlayer.InvBody[INVLOC_HAND_RIGHT], x, 0);
+
+	// Barehanded Monk (both hands empty, no staff)
+	if (myPlayer._pClass == HeroClass::Monk
+	    && left.isEmpty()
+	    && right.isEmpty()
+	    && myPlayer.disableBlock) {
+
+		Item dummy;
+		dummy._itype = ItemType::None;
+		dummy._iDurability = 0;
+		dummy._iMaxDur = 0;
+
+		x = DrawDurIcon4Item(out, dummy, x, 0);
+	}
 }
 
 void RedBack(const Surface &out)

Source/control.h

@@ -150,6 +150,7 @@ void CheckMainPanelButton();
 void CheckMainPanelButtonDead();
 void DoAutoMap();
 void CycleAutomapType();
+void ToggleActiveBlock();
 
 /**
  * Checks the mouse cursor position within the control panel and sets information

Source/diablo.cpp

@@ -151,11 +151,11 @@ uint32_t GetGameId()
 {
 	const auto &options = GetOptions();
 	if (gbIsHellfire) {
-		if (*options.Gameplay.disableSearch || *options.Gameplay.removeCripplingEffects || *options.Gameplay.sharedXP)
+		if (*options.Gameplay.disableSearch || *options.Gameplay.removeCripplingEffects || *options.Gameplay.sharedXP || *options.Gameplay.activeBlock)
 			return GameIdHellfireEnhanced;
 		return gbIsSpawn ? GameIdHellfireSpawn : GameIdHellfireFull;
 	}
-	if (*options.Gameplay.removeCripplingEffects || *options.Gameplay.sharedXP)
+	if (*options.Gameplay.removeCripplingEffects || *options.Gameplay.sharedXP || *options.Gameplay.activeBlock)
 		return GameIdDiabloEnhanced;
 	return gbIsSpawn ? GameIdDiabloSpawn : GameIdDiabloFull;
 }
@@ -1707,6 +1707,11 @@ bool CanAutomapBeToggledOff()
 	return false;
 }
 
+bool CanUseToggleActiveBlock()
+{
+	return CanPlayerTakeAction() && sgGameInitInfo.bActiveBlock == 1;
+}
+
 } // namespace
 
 void InitKeymapActions()
@@ -1850,6 +1855,14 @@ void InitKeymapActions()
 	    CycleAutomapType,
 	    nullptr,
 	    IsGameRunning);
+	options.Keymapper.AddAction(
+	    "ToggleBlock",
+	    N_("Toggle Active Block"),
+	    N_("Toggle Active Block on/off.  Active Block sets block chance to zero."),
+	    SDLK_UNKNOWN,
+	    ToggleActiveBlock,
+	    nullptr,
+	    CanUseToggleActiveBlock);
 
 	options.Keymapper.AddAction(
 	    "Inventory",
@@ -2423,6 +2436,14 @@ void InitPadmapActions()
 	    },
 	    nullptr,
 	    CanPlayerTakeAction);
+	options.Padmapper.AddAction(
+	    "ToggleBlock",
+	    N_("Toggle Active Block"),
+	    N_("Toggle Active Block on/off.  Active Block sets block chance to zero."),
+	    ControllerButton_NONE,
+	    ToggleActiveBlock,
+	    nullptr,
+	    CanUseToggleActiveBlock);
 	options.Padmapper.AddAction(
 	    "Pause Game",
 	    N_("Pause Game"),

Source/diablo.h

@@ -100,6 +100,7 @@ void DisableInputEventHandler(const SDL_Event &event, uint16_t modState);
 tl::expected<void, std::string> LoadGameLevel(bool firstflag, lvl_entry lvldir);
 bool IsDiabloAlive(bool playSFX);
 void PrintScreen(SDL_Keycode vkey);
+void DrawActiveBlockIcon(const Surface &out);
 
 /**
  * @param bStartup Process additional ticks before returning

Source/multi.cpp

@@ -14,6 +14,8 @@
 #include <fmt/format.h>
 
 #include "DiabloUI/diabloui.h"
+#include "controls/keymapper.hpp"
+#include "controls/padmapper.hpp"
 #include "diablo.h"
 #include "engine/demomode.h"
 #include "engine/point.hpp"
@@ -506,10 +508,22 @@ bool InitMulti(GameData *gameData)
 
 } // namespace
 
+bool CheckActiveBlock()
+{
+	auto &options = GetOptions();
+	const bool toggleBlockMapped = options.Keymapper.KeyForAction("ToggleBlock") != SDLK_UNKNOWN
+	    || options.Padmapper.ButtonComboForAction("ToggleBlock").button != ControllerButton_NONE;
+
+	options.Gameplay.activeBlock.SetValue(toggleBlockMapped);
+
+	return toggleBlockMapped;
+}
+
 void InitGameInfo()
 {
 	xoshiro128plusplus gameGenerator = ReserveSeedSequence();
 	gameGenerator.save(sgGameInitInfo.gameSeed);
+	const bool toggleBlockMapped = CheckActiveBlock();
 
 	sgGameInitInfo.size = sizeof(sgGameInitInfo);
 	sgGameInitInfo.programid = GetGameId();
@@ -526,6 +540,7 @@ void InitGameInfo()
 	sgGameInitInfo.bSharedExperience = *options.Gameplay.sharedXP ? 1 : 0;
 	sgGameInitInfo.bRemoveCripplingEffects = *options.Gameplay.removeCripplingEffects ? 1 : 0;
 	sgGameInitInfo.bDisableSearch = *options.Gameplay.disableSearch ? 1 : 0;
+	sgGameInitInfo.bActiveBlock = toggleBlockMapped ? 1 : 0;
 }
 
 void NetSendLoPri(uint8_t playerId, const std::byte *data, size_t size)

Source/multi.h

@@ -37,6 +37,7 @@ struct GameData {
 	uint8_t bSharedExperience;
 	uint8_t bRemoveCripplingEffects;
 	uint8_t bDisableSearch;
+	uint8_t bActiveBlock;
 	/** Used to initialise the seed table for dungeon levels so players in multiplayer games generate the same layout */
 	uint32_t gameSeed[4];
 

Source/options.cpp

@@ -75,6 +75,9 @@ void DisableEnhancedOptionsIfShareware()
 
 	gameplay.removeCripplingEffects.SetValue(false);
 	gameplay.removeCripplingEffects.flags |= OptionEntryFlags::Invisible;
+
+	gameplay.activeBlock.SetValue(false);
+	gameplay.activeBlock.flags |= OptionEntryFlags::Invisible;
 }
 
 namespace {
@@ -822,6 +825,7 @@ GameplayOptions::GameplayOptions()
     , autoRefillBelt("Auto Refill Belt", OptionEntryFlags::None, N_("Auto Refill Belt"), N_("Refill belt from inventory when belt item is consumed."), false)
     , removeCripplingEffects("Remove Crippling Effects", OptionEntryFlags::CantChangeInMultiPlayer, N_("Remove Crippling Effects"), N_("Fascinating, Ornate, Sacred, Murphy's and Tainted will not spawn and will not be selected for Cauldrons and Goat Shrines.  Black Deaths will not reduce max life."), true)
     , disableCripplingShrines("Disable Crippling Shrines", OptionEntryFlags::None, N_("Disable Crippling Shrines"), N_("When enabled Cauldrons, Fascinating Shrines, Goat Shrines, Ornate Shrines, Sacred Shrines and Murphy's Shrines are not able to be clicked on and labeled as disabled."), false)
+    , activeBlock("Toggle Active Block", OptionEntryFlags::Invisible, N_("Toggle Active Block"), N_("Allows players to manually set their shield block chance to 0."), false)
     , quickCast("Quick Cast", OptionEntryFlags::None, N_("Quick Cast"), N_("Spell hotkeys instantly cast the spell, rather than switching the readied spell."), false)
     , numHealPotionPickup("Heal Potion Pickup", OptionEntryFlags::None, N_("Heal Potion Pickup"), N_("Number of Healing potions to pick up automatically."), 0, { 0, 1, 2, 4, 8, 16 })
     , numFullHealPotionPickup("Full Heal Potion Pickup", OptionEntryFlags::None, N_("Full Heal Potion Pickup"), N_("Number of Full Healing potions to pick up automatically."), 0, { 0, 1, 2, 4, 8, 16 })
@@ -850,6 +854,7 @@ std::vector<OptionEntryBase *> GameplayOptions::GetEntries()
 		&cowQuest,
 		&runInTown,
 		&quickCast,
+		&activeBlock,
 		&testBard,
 		&testBarbarian,
 		&experienceBar,

Source/options.h

@@ -618,6 +618,8 @@ struct GameplayOptions : OptionCategoryBase {
 	OptionEntryBoolean removeCripplingEffects;
 	/** @brief Locally disable clicking on shrines which permanently cripple character. */
 	OptionEntryBoolean disableCripplingShrines;
+	/** @brief Allows players to manually set their shield block chance to 0. */
+	OptionEntryBoolean activeBlock;
 	/** @brief Spell hotkeys instantly cast the spell. */
 	OptionEntryBoolean quickCast;
 	/** @brief Number of Healing potions to pick up automatically */

Source/player.h

@@ -274,6 +274,7 @@ struct Player {
 	int destParam3;
 	int destParam4;
 	int _pGold;
+	bool disableBlock = false;
 
 	/**
 	 * @brief Contains Information for current Animation
@@ -626,6 +627,9 @@ struct Player {
 	 */
 	int GetBlockChance(bool useLevel = true) const
 	{
+		if (sgGameInitInfo.bActiveBlock == 1 && disableBlock)
+			return 0;
+	
 		int blkper = _pDexterity + getBaseToBlock();
 		if (useLevel)
 			blkper += getCharacterLevel() * 2;