From 7912e510f0cef1a0f00f3e77bd908e92b76de15f Mon Sep 17 00:00:00 2001
From: Anders Jenbo <anders@jenbo.dk>
Date: Sat, 24 Apr 2021 06:23:58 +0200
Subject: [PATCH] :art: Clean up overuse of SDL types

---
 Source/DiabloUI/diabloui.h   |   20 +-
 Source/control.cpp           |   16 +-
 Source/controls/plrctrls.cpp |    2 +-
 Source/debug.cpp             |    2 -
 Source/drlg_l2.h             |   20 +-
 Source/drlg_l3.cpp           |    2 +-
 Source/effects.h             |    2 +-
 Source/encrypt.h             |   12 +-
 Source/gendung.h             |   26 +-
 Source/gmenu.h               |    4 +-
 Source/interfac.cpp          |    6 +-
 Source/inv.h                 |    4 +-
 Source/itemdat.h             |   68 +-
 Source/items.cpp             |    8 +-
 Source/loadsave.cpp          | 1718 +++++++++++++++++-----------------
 Source/loadsave.h            |    2 +-
 Source/minitext.cpp          |   17 +-
 Source/misdat.h              |   26 +-
 Source/missiles.cpp          |  284 +++---
 Source/missiles.h            |  362 +++----
 Source/monstdat.h            |   71 +-
 Source/monster.cpp           |    4 +-
 Source/monster.h             |  138 +--
 Source/mpqapi.h              |   19 +-
 Source/msg.h                 |  294 +++---
 Source/multi.h               |   22 +-
 Source/objdat.h              |   18 +-
 Source/objects.cpp           |    8 +-
 Source/objects.h             |   42 +-
 Source/options.h             |   16 +-
 Source/pack.cpp              |    2 +-
 Source/path.cpp              |    6 +-
 Source/path.h                |    8 +-
 Source/pfile.cpp             |    6 +-
 Source/player.cpp            |    4 +-
 Source/player.h              |    1 -
 Source/plrmsg.h              |    5 +-
 Source/portal.h              |    6 +-
 Source/qol.cpp               |   24 +-
 Source/qol/common.cpp        |    4 +-
 Source/qol/common.h          |    2 +-
 Source/qol/xpbar.cpp         |   12 +-
 Source/quests.h              |   22 +-
 Source/sha.h                 |    6 +-
 Source/spelldat.h            |   20 +-
 Source/spells.cpp            |    2 +-
 Source/spells.h              |    2 +-
 Source/stores.cpp            |    6 +-
 Source/storm/storm.h         |   63 +-
 Source/storm/storm_net.cpp   |    2 +-
 Source/sync.cpp              |   17 +-
 Source/sync.h                |    8 +-
 Source/themes.h              |    4 +-
 Source/tmsg.cpp              |    4 +-
 Source/tmsg.h                |   14 +-
 Source/town.cpp              |   20 +-
 Source/utils/soundsample.cpp |    6 +-
 test/lighting_test.cpp       |    2 +-
 test/writehero_test.cpp      |    7 +-
 59 files changed, 1769 insertions(+), 1749 deletions(-)

diff --git a/Source/DiabloUI/diabloui.h b/Source/DiabloUI/diabloui.h
index a8ec3e93..abe16ccf 100644
--- a/Source/DiabloUI/diabloui.h
+++ b/Source/DiabloUI/diabloui.h
@@ -46,21 +46,21 @@ enum _selhero_selections : uint8_t {
 };
 
 struct _uidefaultstats {
-	Uint16 strength;
-	Uint16 magic;
-	Uint16 dexterity;
-	Uint16 vitality;
+	uint16_t strength;
+	uint16_t magic;
+	uint16_t dexterity;
+	uint16_t vitality;
 };
 
 struct _uiheroinfo {
 	char name[16];
-	Uint16 level;
+	uint16_t level;
 	HeroClass heroclass;
-	Uint8 herorank;
-	Uint16 strength;
-	Uint16 magic;
-	Uint16 dexterity;
-	Uint16 vitality;
+	uint8_t herorank;
+	uint16_t strength;
+	uint16_t magic;
+	uint16_t dexterity;
+	uint16_t vitality;
 	bool hassaved;
 	bool spawned;
 };
diff --git a/Source/control.cpp b/Source/control.cpp
index a9a7b26f..caade883 100644
--- a/Source/control.cpp
+++ b/Source/control.cpp
@@ -373,7 +373,7 @@ void DrawSpellList(const CelOutputBuffer &out)
 {
 	int c;
 	int s;
-	Uint64 mask;
+	uint64_t mask;
 
 	pSpell = SPL_INVALID;
 	infostr[0] = '\0';
@@ -381,7 +381,7 @@ void DrawSpellList(const CelOutputBuffer &out)
 	int y = PANEL_Y - 17;
 	ClearPanel();
 
-	for (Sint32 i = RSPLTYPE_SKILL; i < RSPLTYPE_INVALID; i++) {
+	for (int i = RSPLTYPE_SKILL; i < RSPLTYPE_INVALID; i++) {
 		switch ((spell_type)i) {
 		case RSPLTYPE_SKILL:
 			SetSpellTrans(RSPLTYPE_SKILL);
@@ -405,7 +405,7 @@ void DrawSpellList(const CelOutputBuffer &out)
 		case RSPLTYPE_INVALID:
 			break;
 		}
-		Sint32 j = SPL_FIREBOLT;
+		int8_t j = SPL_FIREBOLT;
 		for (uint64_t spl = 1; j < MAX_SPELLS; spl <<= 1, j++) {
 			if ((mask & spl) == 0)
 				continue;
@@ -527,7 +527,7 @@ void SetSpeedSpell(int slot)
 
 void ToggleSpell(int slot)
 {
-	Uint64 spells;
+	uint64_t spells;
 
 	if (plr[myplr]._pSplHotKey[slot] == SPL_INVALID) {
 		return;
@@ -876,7 +876,7 @@ void DoSpeedBook()
 
 	if (plr[myplr]._pRSpell != SPL_INVALID) {
 		for (int i = RSPLTYPE_SKILL; i <= RSPLTYPE_CHARGES; i++) {
-			Uint64 spells;
+			uint64_t spells;
 			switch (i) {
 			case RSPLTYPE_SKILL:
 				spells = plr[myplr]._pAblSpells;
@@ -891,7 +891,7 @@ void DoSpeedBook()
 				spells = plr[myplr]._pISpells;
 				break;
 			}
-			Uint64 spell = 1;
+			uint64_t spell = 1;
 			for (int j = 1; j < MAX_SPELLS; j++) {
 				if ((spell & spells) != 0) {
 					if (j == plr[myplr]._pRSpell && i == plr[myplr]._pRSplType) {
@@ -1821,7 +1821,7 @@ void DrawSpellBook(const CelOutputBuffer &out)
 		}
 		CelDrawTo(out, sx, 348, pSBkBtnCel, sbooktab + 1, 76);
 	}
-	Uint64 spl = plr[myplr]._pMemSpells | plr[myplr]._pISpells | plr[myplr]._pAblSpells;
+	uint64_t spl = plr[myplr]._pMemSpells | plr[myplr]._pISpells | plr[myplr]._pAblSpells;
 
 	int yp = 55;
 	for (int i = 1; i < 8; i++) {
@@ -1877,7 +1877,7 @@ void CheckSBook()
 {
 	if (MouseX >= RIGHT_PANEL + 11 && MouseX < RIGHT_PANEL + 48 && MouseY >= 18 && MouseY < 314) {
 		spell_id sn = SpellPages[sbooktab][(MouseY - 18) / 43];
-		Uint64 spl = plr[myplr]._pMemSpells | plr[myplr]._pISpells | plr[myplr]._pAblSpells;
+		uint64_t spl = plr[myplr]._pMemSpells | plr[myplr]._pISpells | plr[myplr]._pAblSpells;
 		if (sn != SPL_INVALID && (spl & GetSpellBitmask(sn)) != 0) {
 			spell_type st = RSPLTYPE_SPELL;
 			if ((plr[myplr]._pISpells & GetSpellBitmask(sn)) != 0) {
diff --git a/Source/controls/plrctrls.cpp b/Source/controls/plrctrls.cpp
index bd5de73a..5d457aa0 100644
--- a/Source/controls/plrctrls.cpp
+++ b/Source/controls/plrctrls.cpp
@@ -91,7 +91,7 @@ int GetDistance(int dx, int dy, int maxDistance)
 		return 0;
 	}
 
-	Sint8 walkpath[MAX_PATH_LENGTH];
+	int8_t walkpath[MAX_PATH_LENGTH];
 	int steps = FindPath(PosOkPlayer, myplr, plr[myplr].position.future.x, plr[myplr].position.future.y, dx, dy, walkpath);
 	if (steps > maxDistance)
 		return 0;
diff --git a/Source/debug.cpp b/Source/debug.cpp
index 38c0ea0c..67b01b44 100644
--- a/Source/debug.cpp
+++ b/Source/debug.cpp
@@ -4,8 +4,6 @@
  * Implementation of debug functions.
  */
 
-#include <SDL.h>
-
 #include "cursor.h"
 #include "inv.h"
 #include "spells.h"
diff --git a/Source/drlg_l2.h b/Source/drlg_l2.h
index e5eda086..41065f49 100644
--- a/Source/drlg_l2.h
+++ b/Source/drlg_l2.h
@@ -11,20 +11,20 @@
 namespace devilution {
 
 struct HALLNODE {
-	Sint32 nHallx1;
-	Sint32 nHally1;
-	Sint32 nHallx2;
-	Sint32 nHally2;
-	Sint32 nHalldir;
+	int nHallx1;
+	int nHally1;
+	int nHallx2;
+	int nHally2;
+	int nHalldir;
 	struct HALLNODE *pNext;
 };
 
 struct ROOMNODE {
-	Sint32 nRoomx1;
-	Sint32 nRoomy1;
-	Sint32 nRoomx2;
-	Sint32 nRoomy2;
-	Sint32 nRoomDest;
+	int nRoomx1;
+	int nRoomy1;
+	int nRoomx2;
+	int nRoomy2;
+	int nRoomDest;
 };
 
 extern BYTE predungeon[DMAXX][DMAXY];
diff --git a/Source/drlg_l3.cpp b/Source/drlg_l3.cpp
index 9d6b43f5..d5f43b07 100644
--- a/Source/drlg_l3.cpp
+++ b/Source/drlg_l3.cpp
@@ -19,7 +19,7 @@ namespace devilution {
 namespace {
 
 /** This will be true if a lava pool has been generated for the level */
-Uint8 lavapool;
+uint8_t lavapool;
 int lockoutcnt;
 bool lockout[DMAXX][DMAXY];
 
diff --git a/Source/effects.h b/Source/effects.h
index d28e3186..be41de0e 100644
--- a/Source/effects.h
+++ b/Source/effects.h
@@ -1057,7 +1057,7 @@ enum sfx_flag : uint8_t {
 };
 
 struct TSFX {
-	Uint8 bFlags;
+	uint8_t bFlags;
 	const char *pszName;
 	TSnd *pSnd;
 };
diff --git a/Source/encrypt.h b/Source/encrypt.h
index 049f64e1..f90f5166 100644
--- a/Source/encrypt.h
+++ b/Source/encrypt.h
@@ -5,18 +5,18 @@
  */
 #pragma once
 
-#include <SDL.h>
+#include <stdint.h>
 
 #include "miniwin/miniwin.h"
 
 namespace devilution {
 
 struct TDataInfo {
-	Uint8 *srcData;
-	Uint32 srcOffset;
-	Uint8 *destData;
-	Uint32 destOffset;
-	Uint32 size;
+	BYTE *srcData;
+	uint32_t srcOffset;
+	BYTE *destData;
+	uint32_t destOffset;
+	uint32_t size;
 };
 
 void Decrypt(DWORD *castBlock, DWORD size, DWORD key);
diff --git a/Source/gendung.h b/Source/gendung.h
index 8c386887..e9ab7905 100644
--- a/Source/gendung.h
+++ b/Source/gendung.h
@@ -90,25 +90,25 @@ struct ScrollStruct {
 };
 
 struct THEME_LOC {
-	Sint16 x;
-	Sint16 y;
-	Sint16 ttval;
-	Sint16 width;
-	Sint16 height;
+	int16_t x;
+	int16_t y;
+	int16_t ttval;
+	int16_t width;
+	int16_t height;
 };
 
 struct MICROS {
-	Uint16 mt[16];
+	uint16_t mt[16];
 };
 
 struct ShadowStruct {
-	Uint8 strig;
-	Uint8 s1;
-	Uint8 s2;
-	Uint8 s3;
-	Uint8 nv1;
-	Uint8 nv2;
-	Uint8 nv3;
+	uint8_t strig;
+	uint8_t s1;
+	uint8_t s2;
+	uint8_t s3;
+	uint8_t nv1;
+	uint8_t nv2;
+	uint8_t nv3;
 };
 
 extern BYTE dungeon[DMAXX][DMAXY];
diff --git a/Source/gmenu.h b/Source/gmenu.h
index bb2bf61b..32bef3d3 100644
--- a/Source/gmenu.h
+++ b/Source/gmenu.h
@@ -5,6 +5,8 @@
  */
 #pragma once
 
+#include <stdint.h>
+
 #include "engine.h"
 
 namespace devilution {
@@ -13,7 +15,7 @@ namespace devilution {
 #define GMENU_ENABLED 0x80000000
 
 struct TMenuItem {
-	Uint32 dwFlags;
+	uint32_t dwFlags;
 	const char *pszStr;
 	void (*fnMenu)(bool);
 };
diff --git a/Source/interfac.cpp b/Source/interfac.cpp
index 4d49ee6f..2d377cc3 100644
--- a/Source/interfac.cpp
+++ b/Source/interfac.cpp
@@ -4,6 +4,8 @@
  * Implementation of load screens.
  */
 
+#include <stdint.h>
+
 #include "control.h"
 #include "DiabloUI/art_draw.h"
 #include "dx.h"
@@ -16,7 +18,7 @@
 namespace devilution {
 
 BYTE *sgpBackCel;
-Uint32 sgdwProgress;
+uint32_t sgdwProgress;
 int progress_id;
 
 /** The color used for the progress bar as an index into the palette. */
@@ -173,7 +175,7 @@ static void DrawCutscene()
 	DrawArt(out, PANEL_X - (ArtCutsceneWidescreen.w() - PANEL_WIDTH) / 2, UI_OFFSET_Y, &ArtCutsceneWidescreen);
 	CelDrawTo(out, PANEL_X, 480 - 1 + UI_OFFSET_Y, sgpBackCel, 1, 640);
 
-	for (Uint32 i = 0; i < sgdwProgress; i++) {
+	for (unsigned i = 0; i < sgdwProgress; i++) {
 		DrawProgress(
 		    out,
 		    BarPos[progress_id][0] + i + PANEL_X,
diff --git a/Source/inv.h b/Source/inv.h
index d4f62286..764ec33f 100644
--- a/Source/inv.h
+++ b/Source/inv.h
@@ -70,8 +70,8 @@ enum item_color : uint8_t {
 };
 
 struct InvXY {
-	Sint32 X;
-	Sint32 Y;
+	int X;
+	int Y;
 };
 
 extern bool invflag;
diff --git a/Source/itemdat.h b/Source/itemdat.h
index a5a4a9b5..30fe52ce 100644
--- a/Source/itemdat.h
+++ b/Source/itemdat.h
@@ -420,21 +420,21 @@ struct ItemDataStruct {
 	enum unique_base_item iItemId;
 	const char *iName;
 	const char *iSName;
-	Uint8 iMinMLvl;
-	Uint8 iDurability;
-	Uint8 iMinDam;
-	Uint8 iMaxDam;
-	Uint8 iMinAC;
-	Uint8 iMaxAC;
-	Uint8 iMinStr;
-	Uint8 iMinMag;
-	Uint8 iMinDex;
-	Sint32 iFlags; // item_special_effect as bit flags
+	uint8_t iMinMLvl;
+	uint8_t iDurability;
+	uint8_t iMinDam;
+	uint8_t iMaxDam;
+	uint8_t iMinAC;
+	uint8_t iMaxAC;
+	uint8_t iMinStr;
+	uint8_t iMinMag;
+	uint8_t iMinDex;
+	uint32_t iFlags; // item_special_effect as bit flags
 	enum item_misc_id iMiscId;
 	enum spell_id iSpell;
 	bool iUsable;
-	Uint16 iValue;
-	Uint16 iMaxValue;
+	uint16_t iValue;
+	uint16_t iMaxValue;
 };
 
 enum item_effect_type : int8_t {
@@ -556,42 +556,42 @@ enum affix_item_type : uint8_t {
 struct PLStruct {
 	const char *PLName;
 	enum item_effect_type PLPower;
-	Sint32 PLParam1;
-	Sint32 PLParam2;
-	Sint8 PLMinLvl;
-	Sint32 PLIType; // affix_item_type as bit flags
+	int PLParam1;
+	int PLParam2;
+	int8_t PLMinLvl;
+	int PLIType; // affix_item_type as bit flags
 	enum goodorevil PLGOE;
 	bool PLDouble;
 	bool PLOk;
-	Sint32 PLMinVal;
-	Sint32 PLMaxVal;
-	Sint32 PLMultVal;
+	int PLMinVal;
+	int PLMaxVal;
+	int PLMultVal;
 };
 
 struct UItemStruct {
 	const char *UIName;
 	enum unique_base_item UIItemId;
-	Sint8 UIMinLvl;
-	Sint8 UINumPL;
-	Sint32 UIValue;
+	int8_t UIMinLvl;
+	int8_t UINumPL;
+	int UIValue;
 	enum item_effect_type UIPower1;
-	Sint32 UIParam1;
-	Sint32 UIParam2;
+	int UIParam1;
+	int UIParam2;
 	enum item_effect_type UIPower2;
-	Sint32 UIParam3;
-	Sint32 UIParam4;
+	int UIParam3;
+	int UIParam4;
 	enum item_effect_type UIPower3;
-	Sint32 UIParam5;
-	Sint32 UIParam6;
+	int UIParam5;
+	int UIParam6;
 	enum item_effect_type UIPower4;
-	Sint32 UIParam7;
-	Sint32 UIParam8;
+	int UIParam7;
+	int UIParam8;
 	enum item_effect_type UIPower5;
-	Sint32 UIParam9;
-	Sint32 UIParam10;
+	int UIParam9;
+	int UIParam10;
 	enum item_effect_type UIPower6;
-	Sint32 UIParam11;
-	Sint32 UIParam12;
+	int UIParam11;
+	int UIParam12;
 };
 
 extern ItemDataStruct AllItemsList[];
diff --git a/Source/items.cpp b/Source/items.cpp
index 7eefec76..574cdab7 100644
--- a/Source/items.cpp
+++ b/Source/items.cpp
@@ -559,7 +559,7 @@ void CalcPlrItemVals(int p, bool Loadgfx)
 	int dadd = 0; // added dexterity
 	int vadd = 0; // added vitality
 
-	Uint64 spl = 0; // bitarray for all enabled/active spells
+	uint64_t spl = 0; // bitarray for all enabled/active spells
 
 	int fr = 0; // fire resistance
 	int lr = 0; // lightning resistance
@@ -3882,9 +3882,9 @@ void PrintItemMisc(ItemStruct *x)
 static void PrintItemInfo(ItemStruct *x)
 {
 	PrintItemMisc(x);
-	Uint8 str = x->_iMinStr;
-	Uint8 dex = x->_iMinDex;
-	Uint8 mag = x->_iMinMag;
+	uint8_t str = x->_iMinStr;
+	uint8_t dex = x->_iMinDex;
+	uint8_t mag = x->_iMinMag;
 	if (str != 0 || mag != 0 || dex != 0) {
 		strcpy(tempstr, "Required:");
 		if (str)
diff --git a/Source/loadsave.cpp b/Source/loadsave.cpp
index ffcfb9a3..9961a4d8 100644
--- a/Source/loadsave.cpp
+++ b/Source/loadsave.cpp
@@ -62,9 +62,9 @@ T SwapBE(T in)
 }
 
 class LoadHelper {
-	Uint8 *m_buffer;
-	Uint32 m_cur = 0;
-	Uint32 m_size;
+	uint8_t *m_buffer;
+	uint32_t m_cur = 0;
+	uint32_t m_size;
 
 	template <class T>
 	T next()
@@ -86,13 +86,13 @@ public:
 		m_buffer = pfile_read(szFileName, &m_size);
 	}
 
-	bool isValid(Uint32 size = 1)
+	bool isValid(uint32_t size = 1)
 	{
 		return m_buffer != nullptr
 		    && m_size >= (m_cur + size);
 	}
 
-	void skip(Uint32 size)
+	void skip(uint32_t size)
 	{
 		m_cur += size;
 	}
@@ -120,12 +120,12 @@ public:
 
 	bool nextBool8()
 	{
-		return next<Uint8>() != 0;
+		return next<uint8_t>() != 0;
 	}
 
 	bool nextBool32()
 	{
-		return next<Uint32>() != 0;
+		return next<uint32_t>() != 0;
 	}
 
 	~LoadHelper()
@@ -136,9 +136,9 @@ public:
 
 class SaveHelper {
 	const char *m_szFileName;
-	Uint8 *m_buffer;
-	Uint32 m_cur = 0;
-	Uint32 m_capacity;
+	uint8_t *m_buffer;
+	uint32_t m_cur = 0;
+	uint32_t m_capacity;
 
 public:
 	SaveHelper(const char *szFileName, size_t bufferLen)
@@ -148,13 +148,13 @@ public:
 		m_buffer = DiabloAllocPtr(codec_get_encoded_len(m_capacity));
 	}
 
-	bool isValid(Uint32 len = 1)
+	bool isValid(uint32_t len = 1)
 	{
 		return m_buffer != nullptr
 		    && m_capacity >= (m_cur + len);
 	}
 
-	void skip(Uint32 len)
+	void skip(uint32_t len)
 	{
 		m_cur += len;
 	}
@@ -215,85 +215,85 @@ void RemoveInvalidItem(ItemStruct *pItem)
 
 static void LoadItemData(LoadHelper *file, ItemStruct *pItem)
 {
-	pItem->_iSeed = file->nextLE<Sint32>();
-	pItem->_iCreateInfo = file->nextLE<Uint16>();
+	pItem->_iSeed = file->nextLE<int32_t>();
+	pItem->_iCreateInfo = file->nextLE<uint16_t>();
 	file->skip(2); // Alignment
-	pItem->_itype = static_cast<item_type>(file->nextLE<Uint32>());
-	pItem->_ix = file->nextLE<Sint32>();
-	pItem->_iy = file->nextLE<Sint32>();
+	pItem->_itype = static_cast<item_type>(file->nextLE<uint32_t>());
+	pItem->_ix = file->nextLE<int32_t>();
+	pItem->_iy = file->nextLE<int32_t>();
 	pItem->_iAnimFlag = file->nextBool32();
 	file->skip(4); // Skip pointer _iAnimData
-	pItem->_iAnimLen = file->nextLE<Sint32>();
-	pItem->_iAnimFrame = file->nextLE<Sint32>();
-	pItem->_iAnimWidth = file->nextLE<Sint32>();
-	pItem->_iAnimWidth2 = file->nextLE<Sint32>();
+	pItem->_iAnimLen = file->nextLE<int32_t>();
+	pItem->_iAnimFrame = file->nextLE<int32_t>();
+	pItem->_iAnimWidth = file->nextLE<int32_t>();
+	pItem->_iAnimWidth2 = file->nextLE<int32_t>();
 	file->skip(4); // Unused since 1.02
-	pItem->_iSelFlag = file->nextLE<Uint8>();
+	pItem->_iSelFlag = file->nextLE<uint8_t>();
 	file->skip(3); // Alignment
 	pItem->_iPostDraw = file->nextBool32();
 	pItem->_iIdentified = file->nextBool32();
-	pItem->_iMagical = file->nextLE<Sint8>();
+	pItem->_iMagical = file->nextLE<int8_t>();
 	file->nextBytes(pItem->_iName, 64);
 	file->nextBytes(pItem->_iIName, 64);
-	pItem->_iLoc = static_cast<item_equip_type>(file->nextLE<Sint8>());
-	pItem->_iClass = static_cast<item_class>(file->nextLE<Uint8>());
+	pItem->_iLoc = static_cast<item_equip_type>(file->nextLE<int8_t>());
+	pItem->_iClass = static_cast<item_class>(file->nextLE<uint8_t>());
 	file->skip(1); // Alignment
-	pItem->_iCurs = file->nextLE<Sint32>();
-	pItem->_ivalue = file->nextLE<Sint32>();
-	pItem->_iIvalue = file->nextLE<Sint32>();
-	pItem->_iMinDam = file->nextLE<Sint32>();
-	pItem->_iMaxDam = file->nextLE<Sint32>();
-	pItem->_iAC = file->nextLE<Sint32>();
-	pItem->_iFlags = file->nextLE<Sint32>();
-	pItem->_iMiscId = static_cast<item_misc_id>(file->nextLE<Sint32>());
-	pItem->_iSpell = static_cast<spell_id>(file->nextLE<Sint32>());
-	pItem->_iCharges = file->nextLE<Sint32>();
-	pItem->_iMaxCharges = file->nextLE<Sint32>();
-	pItem->_iDurability = file->nextLE<Sint32>();
-	pItem->_iMaxDur = file->nextLE<Sint32>();
-	pItem->_iPLDam = file->nextLE<Sint32>();
-	pItem->_iPLToHit = file->nextLE<Sint32>();
-	pItem->_iPLAC = file->nextLE<Sint32>();
-	pItem->_iPLStr = file->nextLE<Sint32>();
-	pItem->_iPLMag = file->nextLE<Sint32>();
-	pItem->_iPLDex = file->nextLE<Sint32>();
-	pItem->_iPLVit = file->nextLE<Sint32>();
-	pItem->_iPLFR = file->nextLE<Sint32>();
-	pItem->_iPLLR = file->nextLE<Sint32>();
-	pItem->_iPLMR = file->nextLE<Sint32>();
-	pItem->_iPLMana = file->nextLE<Sint32>();
-	pItem->_iPLHP = file->nextLE<Sint32>();
-	pItem->_iPLDamMod = file->nextLE<Sint32>();
-	pItem->_iPLGetHit = file->nextLE<Sint32>();
-	pItem->_iPLLight = file->nextLE<Sint32>();
-	pItem->_iSplLvlAdd = file->nextLE<Sint8>();
-	pItem->_iRequest = file->nextLE<Sint8>();
+	pItem->_iCurs = file->nextLE<int32_t>();
+	pItem->_ivalue = file->nextLE<int32_t>();
+	pItem->_iIvalue = file->nextLE<int32_t>();
+	pItem->_iMinDam = file->nextLE<int32_t>();
+	pItem->_iMaxDam = file->nextLE<int32_t>();
+	pItem->_iAC = file->nextLE<int32_t>();
+	pItem->_iFlags = file->nextLE<uint32_t>();
+	pItem->_iMiscId = static_cast<item_misc_id>(file->nextLE<int32_t>());
+	pItem->_iSpell = static_cast<spell_id>(file->nextLE<int32_t>());
+	pItem->_iCharges = file->nextLE<int32_t>();
+	pItem->_iMaxCharges = file->nextLE<int32_t>();
+	pItem->_iDurability = file->nextLE<int32_t>();
+	pItem->_iMaxDur = file->nextLE<int32_t>();
+	pItem->_iPLDam = file->nextLE<int32_t>();
+	pItem->_iPLToHit = file->nextLE<int32_t>();
+	pItem->_iPLAC = file->nextLE<int32_t>();
+	pItem->_iPLStr = file->nextLE<int32_t>();
+	pItem->_iPLMag = file->nextLE<int32_t>();
+	pItem->_iPLDex = file->nextLE<int32_t>();
+	pItem->_iPLVit = file->nextLE<int32_t>();
+	pItem->_iPLFR = file->nextLE<int32_t>();
+	pItem->_iPLLR = file->nextLE<int32_t>();
+	pItem->_iPLMR = file->nextLE<int32_t>();
+	pItem->_iPLMana = file->nextLE<int32_t>();
+	pItem->_iPLHP = file->nextLE<int32_t>();
+	pItem->_iPLDamMod = file->nextLE<int32_t>();
+	pItem->_iPLGetHit = file->nextLE<int32_t>();
+	pItem->_iPLLight = file->nextLE<int32_t>();
+	pItem->_iSplLvlAdd = file->nextLE<int8_t>();
+	pItem->_iRequest = file->nextLE<int8_t>();
 	file->skip(2); // Alignment
-	pItem->_iUid = file->nextLE<Sint32>();
-	pItem->_iFMinDam = file->nextLE<Sint32>();
-	pItem->_iFMaxDam = file->nextLE<Sint32>();
-	pItem->_iLMinDam = file->nextLE<Sint32>();
-	pItem->_iLMaxDam = file->nextLE<Sint32>();
-	pItem->_iPLEnAc = file->nextLE<Sint32>();
-	pItem->_iPrePower = static_cast<item_effect_type>(file->nextLE<Sint8>());
-	pItem->_iSufPower = static_cast<item_effect_type>(file->nextLE<Sint8>());
+	pItem->_iUid = file->nextLE<int32_t>();
+	pItem->_iFMinDam = file->nextLE<int32_t>();
+	pItem->_iFMaxDam = file->nextLE<int32_t>();
+	pItem->_iLMinDam = file->nextLE<int32_t>();
+	pItem->_iLMaxDam = file->nextLE<int32_t>();
+	pItem->_iPLEnAc = file->nextLE<int32_t>();
+	pItem->_iPrePower = static_cast<item_effect_type>(file->nextLE<int8_t>());
+	pItem->_iSufPower = static_cast<item_effect_type>(file->nextLE<int8_t>());
 	file->skip(2); // Alignment
-	pItem->_iVAdd1 = file->nextLE<Sint32>();
-	pItem->_iVMult1 = file->nextLE<Sint32>();
-	pItem->_iVAdd2 = file->nextLE<Sint32>();
-	pItem->_iVMult2 = file->nextLE<Sint32>();
-	pItem->_iMinStr = file->nextLE<Sint8>();
-	pItem->_iMinMag = file->nextLE<Uint8>();
-	pItem->_iMinDex = file->nextLE<Sint8>();
+	pItem->_iVAdd1 = file->nextLE<int32_t>();
+	pItem->_iVMult1 = file->nextLE<int32_t>();
+	pItem->_iVAdd2 = file->nextLE<int32_t>();
+	pItem->_iVMult2 = file->nextLE<int32_t>();
+	pItem->_iMinStr = file->nextLE<int8_t>();
+	pItem->_iMinMag = file->nextLE<uint8_t>();
+	pItem->_iMinDex = file->nextLE<int8_t>();
 	file->skip(1); // Alignment
 	pItem->_iStatFlag = file->nextBool32();
-	pItem->IDidx = file->nextLE<Sint32>();
+	pItem->IDidx = file->nextLE<int32_t>();
 	if (!gbIsHellfireSaveGame) {
 		pItem->IDidx = RemapItemIdxFromDiablo(pItem->IDidx);
 	}
-	pItem->dwBuff = file->nextLE<Uint32>();
+	pItem->dwBuff = file->nextLE<uint32_t>();
 	if (gbIsHellfireSaveGame)
-		pItem->_iDamAcFlags = file->nextLE<Uint32>();
+		pItem->_iDamAcFlags = file->nextLE<uint32_t>();
 	else
 		pItem->_iDamAcFlags = 0;
 
@@ -311,124 +311,124 @@ static void LoadPlayer(LoadHelper *file, int p)
 {
 	PlayerStruct *pPlayer = &plr[p];
 
-	pPlayer->_pmode = static_cast<PLR_MODE>(file->nextLE<Sint32>());
+	pPlayer->_pmode = static_cast<PLR_MODE>(file->nextLE<int32_t>());
 
 	for (int8_t &step : pPlayer->walkpath) {
 		step = file->nextLE<int8_t>();
 	}
 	pPlayer->plractive = file->nextBool8();
 	file->skip(2); // Alignment
-	pPlayer->destAction = static_cast<action_id>(file->nextLE<Sint32>());
-	pPlayer->destParam1 = file->nextLE<Sint32>();
-	pPlayer->destParam2 = file->nextLE<Sint32>();
-	pPlayer->destParam3 = static_cast<direction>(file->nextLE<Sint32>());
-	pPlayer->destParam4 = file->nextLE<Sint32>();
-	pPlayer->plrlevel = file->nextLE<Sint32>();
-	pPlayer->position.current.x = file->nextLE<Sint32>();
-	pPlayer->position.current.y = file->nextLE<Sint32>();
-	pPlayer->position.future.x = file->nextLE<Sint32>();
-	pPlayer->position.future.y = file->nextLE<Sint32>();
+	pPlayer->destAction = static_cast<action_id>(file->nextLE<int32_t>());
+	pPlayer->destParam1 = file->nextLE<int32_t>();
+	pPlayer->destParam2 = file->nextLE<int32_t>();
+	pPlayer->destParam3 = static_cast<direction>(file->nextLE<int32_t>());
+	pPlayer->destParam4 = file->nextLE<int32_t>();
+	pPlayer->plrlevel = file->nextLE<int32_t>();
+	pPlayer->position.current.x = file->nextLE<int32_t>();
+	pPlayer->position.current.y = file->nextLE<int32_t>();
+	pPlayer->position.future.x = file->nextLE<int32_t>();
+	pPlayer->position.future.y = file->nextLE<int32_t>();
 	file->skip(8); // Skip _ptargx and _ptargy
-	pPlayer->position.owner.x = file->nextLE<Sint32>();
-	pPlayer->position.owner.y = file->nextLE<Sint32>();
-	pPlayer->position.old.x = file->nextLE<Sint32>();
-	pPlayer->position.old.y = file->nextLE<Sint32>();
-	pPlayer->position.offset.x = file->nextLE<Sint32>();
-	pPlayer->position.offset.y = file->nextLE<Sint32>();
-	pPlayer->position.velocity.x = file->nextLE<Sint32>();
-	pPlayer->position.velocity.y = file->nextLE<Sint32>();
-	pPlayer->_pdir = static_cast<direction>(file->nextLE<Sint32>());
+	pPlayer->position.owner.x = file->nextLE<int32_t>();
+	pPlayer->position.owner.y = file->nextLE<int32_t>();
+	pPlayer->position.old.x = file->nextLE<int32_t>();
+	pPlayer->position.old.y = file->nextLE<int32_t>();
+	pPlayer->position.offset.x = file->nextLE<int32_t>();
+	pPlayer->position.offset.y = file->nextLE<int32_t>();
+	pPlayer->position.velocity.x = file->nextLE<int32_t>();
+	pPlayer->position.velocity.y = file->nextLE<int32_t>();
+	pPlayer->_pdir = static_cast<direction>(file->nextLE<int32_t>());
 	file->skip(4); // Unused
-	pPlayer->_pgfxnum = file->nextLE<Sint32>();
+	pPlayer->_pgfxnum = file->nextLE<int32_t>();
 	file->skip(4); // Skip pointer _pAnimData
-	pPlayer->_pAnimDelay = file->nextLE<Sint32>();
-	pPlayer->_pAnimCnt = file->nextLE<Sint32>();
-	pPlayer->_pAnimLen = file->nextLE<Sint32>();
-	pPlayer->_pAnimFrame = file->nextLE<Sint32>();
-	pPlayer->_pAnimWidth = file->nextLE<Sint32>();
-	pPlayer->_pAnimWidth2 = file->nextLE<Sint32>();
+	pPlayer->_pAnimDelay = file->nextLE<int32_t>();
+	pPlayer->_pAnimCnt = file->nextLE<int32_t>();
+	pPlayer->_pAnimLen = file->nextLE<int32_t>();
+	pPlayer->_pAnimFrame = file->nextLE<int32_t>();
+	pPlayer->_pAnimWidth = file->nextLE<int32_t>();
+	pPlayer->_pAnimWidth2 = file->nextLE<int32_t>();
 	file->skip(4); // Skip _peflag
-	pPlayer->_plid = file->nextLE<Sint32>();
-	pPlayer->_pvid = file->nextLE<Sint32>();
+	pPlayer->_plid = file->nextLE<int32_t>();
+	pPlayer->_pvid = file->nextLE<int32_t>();
 
-	pPlayer->_pSpell = static_cast<spell_id>(file->nextLE<Sint32>());
-	pPlayer->_pSplType = static_cast<spell_type>(file->nextLE<Sint8>());
-	pPlayer->_pSplFrom = file->nextLE<Sint8>();
+	pPlayer->_pSpell = static_cast<spell_id>(file->nextLE<int32_t>());
+	pPlayer->_pSplType = static_cast<spell_type>(file->nextLE<int8_t>());
+	pPlayer->_pSplFrom = file->nextLE<int8_t>();
 	file->skip(2); // Alignment
-	pPlayer->_pTSpell = static_cast<spell_id>(file->nextLE<Sint32>());
-	pPlayer->_pTSplType = static_cast<spell_type>(file->nextLE<Sint8>());
+	pPlayer->_pTSpell = static_cast<spell_id>(file->nextLE<int32_t>());
+	pPlayer->_pTSplType = static_cast<spell_type>(file->nextLE<int8_t>());
 	file->skip(3); // Alignment
-	pPlayer->_pRSpell = static_cast<spell_id>(file->nextLE<Sint32>());
-	pPlayer->_pRSplType = static_cast<spell_type>(file->nextLE<Sint8>());
+	pPlayer->_pRSpell = static_cast<spell_id>(file->nextLE<int32_t>());
+	pPlayer->_pRSplType = static_cast<spell_type>(file->nextLE<int8_t>());
 	file->skip(3); // Alignment
-	pPlayer->_pSBkSpell = static_cast<spell_id>(file->nextLE<Sint32>());
-	pPlayer->_pSBkSplType = static_cast<spell_type>(file->nextLE<Sint8>());
+	pPlayer->_pSBkSpell = static_cast<spell_id>(file->nextLE<int32_t>());
+	pPlayer->_pSBkSplType = static_cast<spell_type>(file->nextLE<int8_t>());
 	for (int8_t &spellLevel : pPlayer->_pSplLvl)
-		spellLevel = file->nextLE<Sint8>();
+		spellLevel = file->nextLE<int8_t>();
 	file->skip(7); // Alignment
-	pPlayer->_pMemSpells = file->nextLE<Uint64>();
-	pPlayer->_pAblSpells = file->nextLE<Uint64>();
-	pPlayer->_pScrlSpells = file->nextLE<Uint64>();
-	pPlayer->_pSpellFlags = file->nextLE<Uint8>();
+	pPlayer->_pMemSpells = file->nextLE<uint64_t>();
+	pPlayer->_pAblSpells = file->nextLE<uint64_t>();
+	pPlayer->_pScrlSpells = file->nextLE<uint64_t>();
+	pPlayer->_pSpellFlags = file->nextLE<uint8_t>();
 	file->skip(3); // Alignment
 	for (auto &spell : pPlayer->_pSplHotKey)
-		spell = static_cast<spell_id>(file->nextLE<Sint32>());
+		spell = static_cast<spell_id>(file->nextLE<int32_t>());
 	for (auto &spellType : pPlayer->_pSplTHotKey)
-		spellType = static_cast<spell_type>(file->nextLE<Sint8>());
+		spellType = static_cast<spell_type>(file->nextLE<int8_t>());
 
-	pPlayer->_pwtype = static_cast<player_weapon_type>(file->nextLE<Sint32>());
+	pPlayer->_pwtype = static_cast<player_weapon_type>(file->nextLE<int32_t>());
 	pPlayer->_pBlockFlag = file->nextBool8();
 	pPlayer->_pInvincible = file->nextBool8();
-	pPlayer->_pLightRad = file->nextLE<Sint8>();
+	pPlayer->_pLightRad = file->nextLE<int8_t>();
 	pPlayer->_pLvlChanging = file->nextBool8();
 
 	file->nextBytes(pPlayer->_pName, PLR_NAME_LEN);
-	pPlayer->_pClass = static_cast<HeroClass>(file->nextLE<Sint8>());
+	pPlayer->_pClass = static_cast<HeroClass>(file->nextLE<int8_t>());
 	file->skip(3); // Alignment
-	pPlayer->_pStrength = file->nextLE<Sint32>();
-	pPlayer->_pBaseStr = file->nextLE<Sint32>();
-	pPlayer->_pMagic = file->nextLE<Sint32>();
-	pPlayer->_pBaseMag = file->nextLE<Sint32>();
-	pPlayer->_pDexterity = file->nextLE<Sint32>();
-	pPlayer->_pBaseDex = file->nextLE<Sint32>();
-	pPlayer->_pVitality = file->nextLE<Sint32>();
-	pPlayer->_pBaseVit = file->nextLE<Sint32>();
-	pPlayer->_pStatPts = file->nextLE<Sint32>();
-	pPlayer->_pDamageMod = file->nextLE<Sint32>();
-	pPlayer->_pBaseToBlk = file->nextLE<Sint32>();
+	pPlayer->_pStrength = file->nextLE<int32_t>();
+	pPlayer->_pBaseStr = file->nextLE<int32_t>();
+	pPlayer->_pMagic = file->nextLE<int32_t>();
+	pPlayer->_pBaseMag = file->nextLE<int32_t>();
+	pPlayer->_pDexterity = file->nextLE<int32_t>();
+	pPlayer->_pBaseDex = file->nextLE<int32_t>();
+	pPlayer->_pVitality = file->nextLE<int32_t>();
+	pPlayer->_pBaseVit = file->nextLE<int32_t>();
+	pPlayer->_pStatPts = file->nextLE<int32_t>();
+	pPlayer->_pDamageMod = file->nextLE<int32_t>();
+	pPlayer->_pBaseToBlk = file->nextLE<int32_t>();
 	if (pPlayer->_pBaseToBlk == 0)
 		pPlayer->_pBaseToBlk = ToBlkTbl[static_cast<std::size_t>(pPlayer->_pClass)];
-	pPlayer->_pHPBase = file->nextLE<Sint32>();
-	pPlayer->_pMaxHPBase = file->nextLE<Sint32>();
-	pPlayer->_pHitPoints = file->nextLE<Sint32>();
-	pPlayer->_pMaxHP = file->nextLE<Sint32>();
-	pPlayer->_pHPPer = file->nextLE<Sint32>();
-	pPlayer->_pManaBase = file->nextLE<Sint32>();
-	pPlayer->_pMaxManaBase = file->nextLE<Sint32>();
-	pPlayer->_pMana = file->nextLE<Sint32>();
-	pPlayer->_pMaxMana = file->nextLE<Sint32>();
-	pPlayer->_pManaPer = file->nextLE<Sint32>();
-	pPlayer->_pLevel = file->nextLE<Sint8>();
-	pPlayer->_pMaxLvl = file->nextLE<Sint8>();
+	pPlayer->_pHPBase = file->nextLE<int32_t>();
+	pPlayer->_pMaxHPBase = file->nextLE<int32_t>();
+	pPlayer->_pHitPoints = file->nextLE<int32_t>();
+	pPlayer->_pMaxHP = file->nextLE<int32_t>();
+	pPlayer->_pHPPer = file->nextLE<int32_t>();
+	pPlayer->_pManaBase = file->nextLE<int32_t>();
+	pPlayer->_pMaxManaBase = file->nextLE<int32_t>();
+	pPlayer->_pMana = file->nextLE<int32_t>();
+	pPlayer->_pMaxMana = file->nextLE<int32_t>();
+	pPlayer->_pManaPer = file->nextLE<int32_t>();
+	pPlayer->_pLevel = file->nextLE<int8_t>();
+	pPlayer->_pMaxLvl = file->nextLE<int8_t>();
 	file->skip(2); // Alignment
-	pPlayer->_pExperience = file->nextLE<Sint32>();
-	pPlayer->_pMaxExp = file->nextLE<Sint32>();
-	pPlayer->_pNextExper = file->nextLE<Sint32>();
-	pPlayer->_pArmorClass = file->nextLE<Sint8>();
-	pPlayer->_pMagResist = file->nextLE<Sint8>();
-	pPlayer->_pFireResist = file->nextLE<Sint8>();
-	pPlayer->_pLghtResist = file->nextLE<Sint8>();
-	pPlayer->_pGold = file->nextLE<Sint32>();
+	pPlayer->_pExperience = file->nextLE<int32_t>();
+	pPlayer->_pMaxExp = file->nextLE<int32_t>();
+	pPlayer->_pNextExper = file->nextLE<int32_t>();
+	pPlayer->_pArmorClass = file->nextLE<int8_t>();
+	pPlayer->_pMagResist = file->nextLE<int8_t>();
+	pPlayer->_pFireResist = file->nextLE<int8_t>();
+	pPlayer->_pLghtResist = file->nextLE<int8_t>();
+	pPlayer->_pGold = file->nextLE<int32_t>();
 
 	pPlayer->_pInfraFlag = file->nextBool32();
-	pPlayer->tempPoint.x = file->nextLE<Sint32>();
-	pPlayer->tempPoint.y = file->nextLE<Sint32>();
-	pPlayer->tempDirection = static_cast<direction>(file->nextLE<Sint32>());
-	pPlayer->_pVar4 = file->nextLE<Sint32>();
-	pPlayer->_pVar5 = file->nextLE<Sint32>();
-	pPlayer->position.offset2.x = file->nextLE<Sint32>();
-	pPlayer->position.offset2.y = file->nextLE<Sint32>();
-	pPlayer->actionFrame = file->nextLE<Sint32>();
+	pPlayer->tempPoint.x = file->nextLE<int32_t>();
+	pPlayer->tempPoint.y = file->nextLE<int32_t>();
+	pPlayer->tempDirection = static_cast<direction>(file->nextLE<int32_t>());
+	pPlayer->_pVar4 = file->nextLE<int32_t>();
+	pPlayer->_pVar5 = file->nextLE<int32_t>();
+	pPlayer->position.offset2.x = file->nextLE<int32_t>();
+	pPlayer->position.offset2.y = file->nextLE<int32_t>();
+	pPlayer->actionFrame = file->nextLE<int32_t>();
 	for (uint8_t i = 0; i < giNumberOfLevels; i++)
 		pPlayer->_pLvlVisited[i] = file->nextBool8();
 	for (uint8_t i = 0; i < giNumberOfLevels; i++)
@@ -436,69 +436,69 @@ static void LoadPlayer(LoadHelper *file, int p)
 
 	file->skip(2); // Alignment
 
-	pPlayer->_pGFXLoad = file->nextLE<Sint32>();
+	pPlayer->_pGFXLoad = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pNAnim
-	pPlayer->_pNFrames = file->nextLE<Sint32>();
-	pPlayer->_pNWidth = file->nextLE<Sint32>();
+	pPlayer->_pNFrames = file->nextLE<int32_t>();
+	pPlayer->_pNWidth = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pWAnim
-	pPlayer->_pWFrames = file->nextLE<Sint32>();
-	pPlayer->_pWWidth = file->nextLE<Sint32>();
+	pPlayer->_pWFrames = file->nextLE<int32_t>();
+	pPlayer->_pWWidth = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pAAnim
-	pPlayer->_pAFrames = file->nextLE<Sint32>();
-	pPlayer->_pAWidth = file->nextLE<Sint32>();
-	pPlayer->_pAFNum = file->nextLE<Sint32>();
+	pPlayer->_pAFrames = file->nextLE<int32_t>();
+	pPlayer->_pAWidth = file->nextLE<int32_t>();
+	pPlayer->_pAFNum = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pLAnim
 	file->skip(4 * 8); // Skip pointers _pFAnim
 	file->skip(4 * 8); // Skip pointers _pTAnim
-	pPlayer->_pSFrames = file->nextLE<Sint32>();
-	pPlayer->_pSWidth = file->nextLE<Sint32>();
-	pPlayer->_pSFNum = file->nextLE<Sint32>();
+	pPlayer->_pSFrames = file->nextLE<int32_t>();
+	pPlayer->_pSWidth = file->nextLE<int32_t>();
+	pPlayer->_pSFNum = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pHAnim
-	pPlayer->_pHFrames = file->nextLE<Sint32>();
-	pPlayer->_pHWidth = file->nextLE<Sint32>();
+	pPlayer->_pHFrames = file->nextLE<int32_t>();
+	pPlayer->_pHWidth = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pDAnim
-	pPlayer->_pDFrames = file->nextLE<Sint32>();
-	pPlayer->_pDWidth = file->nextLE<Sint32>();
+	pPlayer->_pDFrames = file->nextLE<int32_t>();
+	pPlayer->_pDWidth = file->nextLE<int32_t>();
 	file->skip(4 * 8); // Skip pointers _pBAnim
-	pPlayer->_pBFrames = file->nextLE<Sint32>();
-	pPlayer->_pBWidth = file->nextLE<Sint32>();
+	pPlayer->_pBFrames = file->nextLE<int32_t>();
+	pPlayer->_pBWidth = file->nextLE<int32_t>();
 
 	LoadItems(file, NUM_INVLOC, pPlayer->InvBody);
 	LoadItems(file, NUM_INV_GRID_ELEM, pPlayer->InvList);
-	pPlayer->_pNumInv = file->nextLE<Sint32>();
+	pPlayer->_pNumInv = file->nextLE<int32_t>();
 	for (int8_t &cell : pPlayer->InvGrid)
 		cell = file->nextLE<int8_t>();
 	LoadItems(file, MAXBELTITEMS, pPlayer->SpdList);
 	LoadItemData(file, &pPlayer->HoldItem);
 
-	pPlayer->_pIMinDam = file->nextLE<Sint32>();
-	pPlayer->_pIMaxDam = file->nextLE<Sint32>();
-	pPlayer->_pIAC = file->nextLE<Sint32>();
-	pPlayer->_pIBonusDam = file->nextLE<Sint32>();
-	pPlayer->_pIBonusToHit = file->nextLE<Sint32>();
-	pPlayer->_pIBonusAC = file->nextLE<Sint32>();
-	pPlayer->_pIBonusDamMod = file->nextLE<Sint32>();
+	pPlayer->_pIMinDam = file->nextLE<int32_t>();
+	pPlayer->_pIMaxDam = file->nextLE<int32_t>();
+	pPlayer->_pIAC = file->nextLE<int32_t>();
+	pPlayer->_pIBonusDam = file->nextLE<int32_t>();
+	pPlayer->_pIBonusToHit = file->nextLE<int32_t>();
+	pPlayer->_pIBonusAC = file->nextLE<int32_t>();
+	pPlayer->_pIBonusDamMod = file->nextLE<int32_t>();
 	file->skip(4); // Alignment
 
-	pPlayer->_pISpells = file->nextLE<Uint64>();
-	pPlayer->_pIFlags = file->nextLE<Sint32>();
-	pPlayer->_pIGetHit = file->nextLE<Sint32>();
-	pPlayer->_pISplLvlAdd = file->nextLE<Sint8>();
+	pPlayer->_pISpells = file->nextLE<uint64_t>();
+	pPlayer->_pIFlags = file->nextLE<int32_t>();
+	pPlayer->_pIGetHit = file->nextLE<int32_t>();
+	pPlayer->_pISplLvlAdd = file->nextLE<int8_t>();
 	file->skip(1); // Unused
 	file->skip(2); // Alignment
-	pPlayer->_pISplDur = file->nextLE<Sint32>();
-	pPlayer->_pIEnAc = file->nextLE<Sint32>();
-	pPlayer->_pIFMinDam = file->nextLE<Sint32>();
-	pPlayer->_pIFMaxDam = file->nextLE<Sint32>();
-	pPlayer->_pILMinDam = file->nextLE<Sint32>();
-	pPlayer->_pILMaxDam = file->nextLE<Sint32>();
-	pPlayer->_pOilType = static_cast<item_misc_id>(file->nextLE<Sint32>());
-	pPlayer->pTownWarps = file->nextLE<Uint8>();
-	pPlayer->pDungMsgs = file->nextLE<Uint8>();
-	pPlayer->pLvlLoad = file->nextLE<Uint8>();
+	pPlayer->_pISplDur = file->nextLE<int32_t>();
+	pPlayer->_pIEnAc = file->nextLE<int32_t>();
+	pPlayer->_pIFMinDam = file->nextLE<int32_t>();
+	pPlayer->_pIFMaxDam = file->nextLE<int32_t>();
+	pPlayer->_pILMinDam = file->nextLE<int32_t>();
+	pPlayer->_pILMaxDam = file->nextLE<int32_t>();
+	pPlayer->_pOilType = static_cast<item_misc_id>(file->nextLE<int32_t>());
+	pPlayer->pTownWarps = file->nextLE<uint8_t>();
+	pPlayer->pDungMsgs = file->nextLE<uint8_t>();
+	pPlayer->pLvlLoad = file->nextLE<uint8_t>();
 
 	if (gbIsHellfireSaveGame) {
-		pPlayer->pDungMsgs2 = file->nextLE<Uint8>();
+		pPlayer->pDungMsgs2 = file->nextLE<uint8_t>();
 		pPlayer->pBattleNet = false;
 	} else {
 		pPlayer->pDungMsgs2 = 0;
@@ -512,12 +512,12 @@ static void LoadPlayer(LoadHelper *file, int p)
 		pPlayer->pOriginalCathedral = true;
 	}
 	file->skip(2); // Available bytes
-	pPlayer->wReflections = file->nextLE<Uint16>();
+	pPlayer->wReflections = file->nextLE<uint16_t>();
 	file->skip(14); // Available bytes
 
-	pPlayer->pDiabloKillLevel = file->nextLE<Uint32>();
-	pPlayer->pDifficulty = static_cast<_difficulty>(file->nextLE<Uint32>());
-	pPlayer->pDamAcFlags = file->nextLE<Uint32>();
+	pPlayer->pDiabloKillLevel = file->nextLE<uint32_t>();
+	pPlayer->pDifficulty = static_cast<_difficulty>(file->nextLE<uint32_t>());
+	pPlayer->pDamAcFlags = file->nextLE<uint32_t>();
 	file->skip(20); // Available bytes
 	CalcPlrItemVals(p, false);
 
@@ -539,91 +539,91 @@ static void LoadMonster(LoadHelper *file, int i)
 {
 	MonsterStruct *pMonster = &monster[i];
 
-	pMonster->_mMTidx = file->nextLE<Sint32>();
-	pMonster->_mmode = static_cast<MON_MODE>(file->nextLE<Sint32>());
-	pMonster->_mgoal = static_cast<monster_goal>(file->nextLE<Uint8>());
+	pMonster->_mMTidx = file->nextLE<int32_t>();
+	pMonster->_mmode = static_cast<MON_MODE>(file->nextLE<int32_t>());
+	pMonster->_mgoal = static_cast<monster_goal>(file->nextLE<uint8_t>());
 	file->skip(3); // Alignment
-	pMonster->_mgoalvar1 = file->nextLE<Sint32>();
-	pMonster->_mgoalvar2 = file->nextLE<Sint32>();
-	pMonster->_mgoalvar3 = file->nextLE<Sint32>();
+	pMonster->_mgoalvar1 = file->nextLE<int32_t>();
+	pMonster->_mgoalvar2 = file->nextLE<int32_t>();
+	pMonster->_mgoalvar3 = file->nextLE<int32_t>();
 	file->skip(4); // Unused
-	pMonster->_pathcount = file->nextLE<Uint8>();
+	pMonster->_pathcount = file->nextLE<uint8_t>();
 	file->skip(3); // Alignment
-	pMonster->_mx = file->nextLE<Sint32>();
-	pMonster->_my = file->nextLE<Sint32>();
-	pMonster->_mfutx = file->nextLE<Sint32>();
-	pMonster->_mfuty = file->nextLE<Sint32>();
-	pMonster->_moldx = file->nextLE<Sint32>();
-	pMonster->_moldy = file->nextLE<Sint32>();
-	pMonster->_mxoff = file->nextLE<Sint32>();
-	pMonster->_myoff = file->nextLE<Sint32>();
-	pMonster->_mxvel = file->nextLE<Sint32>();
-	pMonster->_myvel = file->nextLE<Sint32>();
-	pMonster->_mdir = static_cast<direction>(file->nextLE<Sint32>());
-	pMonster->_menemy = file->nextLE<Sint32>();
-	pMonster->_menemyx = file->nextLE<Uint8>();
-	pMonster->_menemyy = file->nextLE<Uint8>();
+	pMonster->_mx = file->nextLE<int32_t>();
+	pMonster->_my = file->nextLE<int32_t>();
+	pMonster->_mfutx = file->nextLE<int32_t>();
+	pMonster->_mfuty = file->nextLE<int32_t>();
+	pMonster->_moldx = file->nextLE<int32_t>();
+	pMonster->_moldy = file->nextLE<int32_t>();
+	pMonster->_mxoff = file->nextLE<int32_t>();
+	pMonster->_myoff = file->nextLE<int32_t>();
+	pMonster->_mxvel = file->nextLE<int32_t>();
+	pMonster->_myvel = file->nextLE<int32_t>();
+	pMonster->_mdir = static_cast<direction>(file->nextLE<int32_t>());
+	pMonster->_menemy = file->nextLE<int32_t>();
+	pMonster->_menemyx = file->nextLE<uint8_t>();
+	pMonster->_menemyy = file->nextLE<uint8_t>();
 	file->skip(2); // Unused
 
 	file->skip(4); // Skip pointer _mAnimData
-	pMonster->_mAnimDelay = file->nextLE<Sint32>();
-	pMonster->_mAnimCnt = file->nextLE<Sint32>();
-	pMonster->_mAnimLen = file->nextLE<Sint32>();
-	pMonster->_mAnimFrame = file->nextLE<Sint32>();
+	pMonster->_mAnimDelay = file->nextLE<int32_t>();
+	pMonster->_mAnimCnt = file->nextLE<int32_t>();
+	pMonster->_mAnimLen = file->nextLE<int32_t>();
+	pMonster->_mAnimFrame = file->nextLE<int32_t>();
 	file->skip(4); // Skip _meflag
 	pMonster->_mDelFlag = file->nextBool32();
-	pMonster->_mVar1 = file->nextLE<Sint32>();
-	pMonster->_mVar2 = file->nextLE<Sint32>();
-	pMonster->_mVar3 = file->nextLE<Sint32>();
-	pMonster->_mVar4 = file->nextLE<Sint32>();
-	pMonster->_mVar5 = file->nextLE<Sint32>();
-	pMonster->_mVar6 = file->nextLE<Sint32>();
-	pMonster->_mVar7 = file->nextLE<Sint32>();
-	pMonster->_mVar8 = file->nextLE<Sint32>();
-	pMonster->_mmaxhp = file->nextLE<Sint32>();
-	pMonster->_mhitpoints = file->nextLE<Sint32>();
+	pMonster->_mVar1 = file->nextLE<int32_t>();
+	pMonster->_mVar2 = file->nextLE<int32_t>();
+	pMonster->_mVar3 = file->nextLE<int32_t>();
+	pMonster->_mVar4 = file->nextLE<int32_t>();
+	pMonster->_mVar5 = file->nextLE<int32_t>();
+	pMonster->_mVar6 = file->nextLE<int32_t>();
+	pMonster->_mVar7 = file->nextLE<int32_t>();
+	pMonster->_mVar8 = file->nextLE<int32_t>();
+	pMonster->_mmaxhp = file->nextLE<int32_t>();
+	pMonster->_mhitpoints = file->nextLE<int32_t>();
 
-	pMonster->_mAi = static_cast<_mai_id>(file->nextLE<Uint8>());
-	pMonster->_mint = file->nextLE<Uint8>();
+	pMonster->_mAi = static_cast<_mai_id>(file->nextLE<uint8_t>());
+	pMonster->_mint = file->nextLE<uint8_t>();
 	file->skip(2); // Alignment
-	pMonster->_mFlags = file->nextLE<Uint32>();
-	pMonster->_msquelch = file->nextLE<Uint8>();
+	pMonster->_mFlags = file->nextLE<uint32_t>();
+	pMonster->_msquelch = file->nextLE<uint8_t>();
 	file->skip(3); // Alignment
 	file->skip(4); // Unused
-	pMonster->_lastx = file->nextLE<Sint32>();
-	pMonster->_lasty = file->nextLE<Sint32>();
-	pMonster->_mRndSeed = file->nextLE<Sint32>();
-	pMonster->_mAISeed = file->nextLE<Sint32>();
+	pMonster->_lastx = file->nextLE<int32_t>();
+	pMonster->_lasty = file->nextLE<int32_t>();
+	pMonster->_mRndSeed = file->nextLE<int32_t>();
+	pMonster->_mAISeed = file->nextLE<int32_t>();
 	file->skip(4); // Unused
 
-	pMonster->_uniqtype = file->nextLE<Uint8>();
-	pMonster->_uniqtrans = file->nextLE<Uint8>();
-	pMonster->_udeadval = file->nextLE<Sint8>();
+	pMonster->_uniqtype = file->nextLE<uint8_t>();
+	pMonster->_uniqtrans = file->nextLE<uint8_t>();
+	pMonster->_udeadval = file->nextLE<int8_t>();
 
-	pMonster->mWhoHit = file->nextLE<Sint8>();
-	pMonster->mLevel = file->nextLE<Sint8>();
+	pMonster->mWhoHit = file->nextLE<int8_t>();
+	pMonster->mLevel = file->nextLE<int8_t>();
 	file->skip(1); // Alignment
-	pMonster->mExp = file->nextLE<Uint16>();
+	pMonster->mExp = file->nextLE<uint16_t>();
 
 	if (i < MAX_PLRS) // Don't skip for golems
-		pMonster->mHit = file->nextLE<Uint8>();
+		pMonster->mHit = file->nextLE<uint8_t>();
 	else
 		file->skip(1); // Skip mHit as it's already initialized
-	pMonster->mMinDamage = file->nextLE<Uint8>();
-	pMonster->mMaxDamage = file->nextLE<Uint8>();
+	pMonster->mMinDamage = file->nextLE<uint8_t>();
+	pMonster->mMaxDamage = file->nextLE<uint8_t>();
 	file->skip(1); // Skip mHit2 as it's already initialized
-	pMonster->mMinDamage2 = file->nextLE<Uint8>();
-	pMonster->mMaxDamage2 = file->nextLE<Uint8>();
-	pMonster->mArmorClass = file->nextLE<Uint8>();
+	pMonster->mMinDamage2 = file->nextLE<uint8_t>();
+	pMonster->mMaxDamage2 = file->nextLE<uint8_t>();
+	pMonster->mArmorClass = file->nextLE<uint8_t>();
 	file->skip(1); // Alignment
-	pMonster->mMagicRes = file->nextLE<Uint16>();
+	pMonster->mMagicRes = file->nextLE<uint16_t>();
 	file->skip(2); // Alignment
 
-	pMonster->mtalkmsg = file->nextLE<Sint32>();
-	pMonster->leader = file->nextLE<Uint8>();
-	pMonster->leaderflag = file->nextLE<Uint8>();
-	pMonster->packsize = file->nextLE<Uint8>();
-	pMonster->mlid = file->nextLE<Sint8>();
+	pMonster->mtalkmsg = file->nextLE<int32_t>();
+	pMonster->leader = file->nextLE<uint8_t>();
+	pMonster->leaderflag = file->nextLE<uint8_t>();
+	pMonster->packsize = file->nextLE<uint8_t>();
+	pMonster->mlid = file->nextLE<int8_t>();
 	if (pMonster->mlid == plr[myplr]._plid)
 		pMonster->mlid = NO_LIGHT; // Correct incorect values in old saves
 
@@ -641,90 +641,90 @@ static void LoadMissile(LoadHelper *file, int i)
 {
 	MissileStruct *pMissile = &missile[i];
 
-	pMissile->_mitype = file->nextLE<Sint32>();
-	pMissile->_mix = file->nextLE<Sint32>();
-	pMissile->_miy = file->nextLE<Sint32>();
-	pMissile->_mixoff = file->nextLE<Sint32>();
-	pMissile->_miyoff = file->nextLE<Sint32>();
-	pMissile->_mixvel = file->nextLE<Sint32>();
-	pMissile->_miyvel = file->nextLE<Sint32>();
-	pMissile->_misx = file->nextLE<Sint32>();
-	pMissile->_misy = file->nextLE<Sint32>();
-	pMissile->_mitxoff = file->nextLE<Sint32>();
-	pMissile->_mityoff = file->nextLE<Sint32>();
-	pMissile->_mimfnum = file->nextLE<Sint32>();
-	pMissile->_mispllvl = file->nextLE<Sint32>();
+	pMissile->_mitype = file->nextLE<int32_t>();
+	pMissile->_mix = file->nextLE<int32_t>();
+	pMissile->_miy = file->nextLE<int32_t>();
+	pMissile->_mixoff = file->nextLE<int32_t>();
+	pMissile->_miyoff = file->nextLE<int32_t>();
+	pMissile->_mixvel = file->nextLE<int32_t>();
+	pMissile->_miyvel = file->nextLE<int32_t>();
+	pMissile->_misx = file->nextLE<int32_t>();
+	pMissile->_misy = file->nextLE<int32_t>();
+	pMissile->_mitxoff = file->nextLE<int32_t>();
+	pMissile->_mityoff = file->nextLE<int32_t>();
+	pMissile->_mimfnum = file->nextLE<int32_t>();
+	pMissile->_mispllvl = file->nextLE<int32_t>();
 	pMissile->_miDelFlag = file->nextBool32();
-	pMissile->_miAnimType = file->nextLE<Uint8>();
+	pMissile->_miAnimType = file->nextLE<uint8_t>();
 	file->skip(3); // Alignment
-	pMissile->_miAnimFlags = file->nextLE<Sint32>();
+	pMissile->_miAnimFlags = file->nextLE<int32_t>();
 	file->skip(4); // Skip pointer _miAnimData
-	pMissile->_miAnimDelay = file->nextLE<Sint32>();
-	pMissile->_miAnimLen = file->nextLE<Sint32>();
-	pMissile->_miAnimWidth = file->nextLE<Sint32>();
-	pMissile->_miAnimWidth2 = file->nextLE<Sint32>();
-	pMissile->_miAnimCnt = file->nextLE<Sint32>();
-	pMissile->_miAnimAdd = file->nextLE<Sint32>();
-	pMissile->_miAnimFrame = file->nextLE<Sint32>();
+	pMissile->_miAnimDelay = file->nextLE<int32_t>();
+	pMissile->_miAnimLen = file->nextLE<int32_t>();
+	pMissile->_miAnimWidth = file->nextLE<int32_t>();
+	pMissile->_miAnimWidth2 = file->nextLE<int32_t>();
+	pMissile->_miAnimCnt = file->nextLE<int32_t>();
+	pMissile->_miAnimAdd = file->nextLE<int32_t>();
+	pMissile->_miAnimFrame = file->nextLE<int32_t>();
 	pMissile->_miDrawFlag = file->nextBool32();
 	pMissile->_miLightFlag = file->nextBool32();
 	pMissile->_miPreFlag = file->nextBool32();
-	pMissile->_miUniqTrans = file->nextLE<Uint32>();
-	pMissile->_mirange = file->nextLE<Sint32>();
-	pMissile->_misource = file->nextLE<Sint32>();
-	pMissile->_micaster = file->nextLE<Sint32>();
-	pMissile->_midam = file->nextLE<Sint32>();
+	pMissile->_miUniqTrans = file->nextLE<uint32_t>();
+	pMissile->_mirange = file->nextLE<int32_t>();
+	pMissile->_misource = file->nextLE<int32_t>();
+	pMissile->_micaster = file->nextLE<int32_t>();
+	pMissile->_midam = file->nextLE<int32_t>();
 	pMissile->_miHitFlag = file->nextBool32();
-	pMissile->_midist = file->nextLE<Sint32>();
-	pMissile->_mlid = file->nextLE<Sint32>();
-	pMissile->_mirnd = file->nextLE<Sint32>();
-	pMissile->_miVar1 = file->nextLE<Sint32>();
-	pMissile->_miVar2 = file->nextLE<Sint32>();
-	pMissile->_miVar3 = file->nextLE<Sint32>();
-	pMissile->_miVar4 = file->nextLE<Sint32>();
-	pMissile->_miVar5 = file->nextLE<Sint32>();
-	pMissile->_miVar6 = file->nextLE<Sint32>();
-	pMissile->_miVar7 = file->nextLE<Sint32>();
-	pMissile->_miVar8 = file->nextLE<Sint32>();
+	pMissile->_midist = file->nextLE<int32_t>();
+	pMissile->_mlid = file->nextLE<int32_t>();
+	pMissile->_mirnd = file->nextLE<int32_t>();
+	pMissile->_miVar1 = file->nextLE<int32_t>();
+	pMissile->_miVar2 = file->nextLE<int32_t>();
+	pMissile->_miVar3 = file->nextLE<int32_t>();
+	pMissile->_miVar4 = file->nextLE<int32_t>();
+	pMissile->_miVar5 = file->nextLE<int32_t>();
+	pMissile->_miVar6 = file->nextLE<int32_t>();
+	pMissile->_miVar7 = file->nextLE<int32_t>();
+	pMissile->_miVar8 = file->nextLE<int32_t>();
 }
 
 static void LoadObject(LoadHelper *file, int i)
 {
 	ObjectStruct *pObject = &object[i];
 
-	pObject->_otype = static_cast<_object_id>(file->nextLE<Sint32>());
-	pObject->_ox = file->nextLE<Sint32>();
-	pObject->_oy = file->nextLE<Sint32>();
+	pObject->_otype = static_cast<_object_id>(file->nextLE<int32_t>());
+	pObject->_ox = file->nextLE<int32_t>();
+	pObject->_oy = file->nextLE<int32_t>();
 	pObject->_oLight = file->nextBool32();
-	pObject->_oAnimFlag = file->nextLE<Uint32>();
+	pObject->_oAnimFlag = file->nextLE<uint32_t>();
 	file->skip(4); // Skip pointer _oAnimData
-	pObject->_oAnimDelay = file->nextLE<Sint32>();
-	pObject->_oAnimCnt = file->nextLE<Sint32>();
-	pObject->_oAnimLen = file->nextLE<Sint32>();
-	pObject->_oAnimFrame = file->nextLE<Sint32>();
-	pObject->_oAnimWidth = file->nextLE<Sint32>();
-	pObject->_oAnimWidth2 = file->nextLE<Sint32>();
+	pObject->_oAnimDelay = file->nextLE<int32_t>();
+	pObject->_oAnimCnt = file->nextLE<int32_t>();
+	pObject->_oAnimLen = file->nextLE<int32_t>();
+	pObject->_oAnimFrame = file->nextLE<int32_t>();
+	pObject->_oAnimWidth = file->nextLE<int32_t>();
+	pObject->_oAnimWidth2 = file->nextLE<int32_t>();
 	pObject->_oDelFlag = file->nextBool32();
-	pObject->_oBreak = file->nextLE<Sint8>();
+	pObject->_oBreak = file->nextLE<int8_t>();
 	file->skip(3); // Alignment
 	pObject->_oSolidFlag = file->nextBool32();
 	pObject->_oMissFlag = file->nextBool32();
 
-	pObject->_oSelFlag = file->nextLE<Sint8>();
+	pObject->_oSelFlag = file->nextLE<int8_t>();
 	file->skip(3); // Alignment
 	pObject->_oPreFlag = file->nextBool32();
 	pObject->_oTrapFlag = file->nextBool32();
 	pObject->_oDoorFlag = file->nextBool32();
-	pObject->_olid = file->nextLE<Sint32>();
-	pObject->_oRndSeed = file->nextLE<Sint32>();
-	pObject->_oVar1 = file->nextLE<Sint32>();
-	pObject->_oVar2 = file->nextLE<Sint32>();
-	pObject->_oVar3 = file->nextLE<Sint32>();
-	pObject->_oVar4 = file->nextLE<Sint32>();
-	pObject->_oVar5 = file->nextLE<Sint32>();
-	pObject->_oVar6 = file->nextLE<Sint32>();
-	pObject->_oVar7 = static_cast<_speech_id>(file->nextLE<Sint32>());
-	pObject->_oVar8 = file->nextLE<Sint32>();
+	pObject->_olid = file->nextLE<int32_t>();
+	pObject->_oRndSeed = file->nextLE<int32_t>();
+	pObject->_oVar1 = file->nextLE<int32_t>();
+	pObject->_oVar2 = file->nextLE<int32_t>();
+	pObject->_oVar3 = file->nextLE<int32_t>();
+	pObject->_oVar4 = file->nextLE<int32_t>();
+	pObject->_oVar5 = file->nextLE<int32_t>();
+	pObject->_oVar6 = file->nextLE<int32_t>();
+	pObject->_oVar7 = static_cast<_speech_id>(file->nextLE<int32_t>());
+	pObject->_oVar8 = file->nextLE<int32_t>();
 }
 
 static void LoadItem(LoadHelper *file, int i)
@@ -742,48 +742,48 @@ static void LoadQuest(LoadHelper *file, int i)
 {
 	QuestStruct *pQuest = &quests[i];
 
-	pQuest->_qlevel = file->nextLE<Uint8>();
-	pQuest->_qtype = file->nextLE<Uint8>();
-	pQuest->_qactive = static_cast<quest_state>(file->nextLE<Uint8>());
-	pQuest->_qlvltype = static_cast<dungeon_type>(file->nextLE<Uint8>());
-	pQuest->_qtx = file->nextLE<Sint32>();
-	pQuest->_qty = file->nextLE<Sint32>();
-	pQuest->_qslvl = static_cast<_setlevels>(file->nextLE<Uint8>());
-	pQuest->_qidx = file->nextLE<Uint8>();
+	pQuest->_qlevel = file->nextLE<uint8_t>();
+	pQuest->_qtype = file->nextLE<uint8_t>();
+	pQuest->_qactive = static_cast<quest_state>(file->nextLE<uint8_t>());
+	pQuest->_qlvltype = static_cast<dungeon_type>(file->nextLE<uint8_t>());
+	pQuest->_qtx = file->nextLE<int32_t>();
+	pQuest->_qty = file->nextLE<int32_t>();
+	pQuest->_qslvl = static_cast<_setlevels>(file->nextLE<uint8_t>());
+	pQuest->_qidx = file->nextLE<uint8_t>();
 	if (gbIsHellfireSaveGame) {
 		file->skip(2); // Alignment
-		pQuest->_qmsg = static_cast<_speech_id>(file->nextLE<Sint32>());
+		pQuest->_qmsg = static_cast<_speech_id>(file->nextLE<int32_t>());
 	} else {
-		pQuest->_qmsg = static_cast<_speech_id>(file->nextLE<Uint8>());
+		pQuest->_qmsg = static_cast<_speech_id>(file->nextLE<uint8_t>());
 	}
-	pQuest->_qvar1 = file->nextLE<Uint8>();
-	pQuest->_qvar2 = file->nextLE<Uint8>();
+	pQuest->_qvar1 = file->nextLE<uint8_t>();
+	pQuest->_qvar2 = file->nextLE<uint8_t>();
 	file->skip(2); // Alignment
 	if (!gbIsHellfireSaveGame)
 		file->skip(1); // Alignment
 	pQuest->_qlog = file->nextBool32();
 
-	ReturnLvlX = file->nextBE<Sint32>();
-	ReturnLvlY = file->nextBE<Sint32>();
-	ReturnLvl = file->nextBE<Sint32>();
-	ReturnLvlT = static_cast<dungeon_type>(file->nextBE<Sint32>());
-	DoomQuestState = file->nextBE<Sint32>();
+	ReturnLvlX = file->nextBE<int32_t>();
+	ReturnLvlY = file->nextBE<int32_t>();
+	ReturnLvl = file->nextBE<int32_t>();
+	ReturnLvlT = static_cast<dungeon_type>(file->nextBE<int32_t>());
+	DoomQuestState = file->nextBE<int32_t>();
 }
 
 static void LoadLighting(LoadHelper *file, LightListStruct *pLight)
 {
-	pLight->_lx = file->nextLE<Sint32>();
-	pLight->_ly = file->nextLE<Sint32>();
-	pLight->_lradius = file->nextLE<Sint32>();
-	pLight->_lid = file->nextLE<Sint32>();
+	pLight->_lx = file->nextLE<int32_t>();
+	pLight->_ly = file->nextLE<int32_t>();
+	pLight->_lradius = file->nextLE<int32_t>();
+	pLight->_lid = file->nextLE<int32_t>();
 	pLight->_ldel = file->nextBool32();
 	pLight->_lunflag = file->nextBool32();
 	file->skip(4); // Unused
-	pLight->_lunx = file->nextLE<Sint32>();
-	pLight->_luny = file->nextLE<Sint32>();
-	pLight->_lunr = file->nextLE<Sint32>();
-	pLight->_xoff = file->nextLE<Sint32>();
-	pLight->_yoff = file->nextLE<Sint32>();
+	pLight->_lunx = file->nextLE<int32_t>();
+	pLight->_luny = file->nextLE<int32_t>();
+	pLight->_lunr = file->nextLE<int32_t>();
+	pLight->_xoff = file->nextLE<int32_t>();
+	pLight->_yoff = file->nextLE<int32_t>();
 	pLight->_lflags = file->nextBool32();
 }
 
@@ -792,10 +792,10 @@ static void LoadPortal(LoadHelper *file, int i)
 	PortalStruct *pPortal = &portal[i];
 
 	pPortal->open = file->nextBool32();
-	pPortal->x = file->nextLE<Sint32>();
-	pPortal->y = file->nextLE<Sint32>();
-	pPortal->level = file->nextLE<Sint32>();
-	pPortal->ltype = static_cast<dungeon_type>(file->nextLE<Sint32>());
+	pPortal->x = file->nextLE<int32_t>();
+	pPortal->y = file->nextLE<int32_t>();
+	pPortal->level = file->nextLE<int32_t>();
+	pPortal->ltype = static_cast<dungeon_type>(file->nextLE<int32_t>());
 	pPortal->setlvl = file->nextBool32();
 }
 
@@ -835,7 +835,7 @@ int RemapItemIdxToDiablo(int i)
 	return i;
 }
 
-bool IsHeaderValid(Uint32 magicNumber)
+bool IsHeaderValid(uint32_t magicNumber)
 {
 	gbIsHellfireSaveGame = false;
 	if (magicNumber == LOAD_LE32("SHAR")) {
@@ -911,13 +911,13 @@ void LoadHotkeys()
 		return;
 
 	for (auto &spellId : plr[myplr]._pSplHotKey) {
-		spellId = static_cast<spell_id>(file.nextLE<Sint32>());
+		spellId = static_cast<spell_id>(file.nextLE<int32_t>());
 	}
 	for (auto &spellType : plr[myplr]._pSplTHotKey) {
-		spellType = static_cast<spell_type>(file.nextLE<Sint8>());
+		spellType = static_cast<spell_type>(file.nextLE<int8_t>());
 	}
-	plr[myplr]._pRSpell = static_cast<spell_id>(file.nextLE<Sint32>());
-	plr[myplr]._pRSplType = static_cast<spell_type>(file.nextLE<Sint8>());
+	plr[myplr]._pRSpell = static_cast<spell_id>(file.nextLE<int32_t>());
+	plr[myplr]._pRSplType = static_cast<spell_type>(file.nextLE<int8_t>());
 }
 
 void SaveHotkeys()
@@ -928,13 +928,13 @@ void SaveHotkeys()
 	SaveHelper file("hotkeys", (nHotkeyTypes * 4) + nHotkeySpells + 4 + 1);
 
 	for (auto &spellId : plr[myplr]._pSplHotKey) {
-		file.writeLE<Sint32>(spellId);
+		file.writeLE<int32_t>(spellId);
 	}
 	for (auto &spellType : plr[myplr]._pSplTHotKey) {
-		file.writeLE<Uint8>(spellType);
+		file.writeLE<uint8_t>(spellType);
 	}
-	file.writeLE<Sint32>(plr[myplr]._pRSpell);
-	file.writeLE<Uint8>(plr[myplr]._pRSplType);
+	file.writeLE<int32_t>(plr[myplr]._pRSpell);
+	file.writeLE<uint8_t>(plr[myplr]._pRSplType);
 }
 
 static void LoadMatchingItems(LoadHelper *file, const int n, ItemStruct *pItem)
@@ -1000,7 +1000,7 @@ void LoadGame(bool firstflag)
 	if (!file.isValid())
 		app_fatal("Unable to open save file archive");
 
-	if (!IsHeaderValid(file.nextLE<Uint32>()))
+	if (!IsHeaderValid(file.nextLE<uint32_t>()))
 		app_fatal("Invalid save file");
 
 	if (gbIsHellfireSaveGame) {
@@ -1015,25 +1015,25 @@ void LoadGame(bool firstflag)
 	}
 
 	setlevel = file.nextBool8();
-	setlvlnum = static_cast<_setlevels>(file.nextBE<Uint32>());
-	currlevel = file.nextBE<Uint32>();
-	leveltype = static_cast<dungeon_type>(file.nextBE<Uint32>());
+	setlvlnum = static_cast<_setlevels>(file.nextBE<uint32_t>());
+	currlevel = file.nextBE<uint32_t>();
+	leveltype = static_cast<dungeon_type>(file.nextBE<uint32_t>());
 	if (!setlevel)
 		leveltype = gnLevelTypeTbl[currlevel];
-	int _ViewX = file.nextBE<Sint32>();
-	int _ViewY = file.nextBE<Sint32>();
+	int _ViewX = file.nextBE<int32_t>();
+	int _ViewY = file.nextBE<int32_t>();
 	invflag = file.nextBool8();
 	chrflag = file.nextBool8();
-	int _nummonsters = file.nextBE<Sint32>();
-	int _numitems = file.nextBE<Sint32>();
-	int _nummissiles = file.nextBE<Sint32>();
-	int _nobjects = file.nextBE<Sint32>();
+	int _nummonsters = file.nextBE<int32_t>();
+	int _numitems = file.nextBE<int32_t>();
+	int _nummissiles = file.nextBE<int32_t>();
+	int _nobjects = file.nextBE<int32_t>();
 
 	if (!gbIsHellfire && currlevel > 17)
 		app_fatal("Player is on a Hellfire only level");
 
 	for (uint8_t i = 0; i < giNumberOfLevels; i++) {
-		glSeedTbl[i] = file.nextBE<Uint32>();
+		glSeedTbl[i] = file.nextBE<uint32_t>();
 		file.skip(4); // Skip loading gnLevelTypeTbl
 	}
 
@@ -1065,46 +1065,46 @@ void LoadGame(bool firstflag)
 	nobjects = _nobjects;
 
 	for (int &monstkill : monstkills)
-		monstkill = file.nextBE<Sint32>();
+		monstkill = file.nextBE<int32_t>();
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int &monsterId : monstactive)
-			monsterId = file.nextBE<Sint32>();
+			monsterId = file.nextBE<int32_t>();
 		for (int i = 0; i < nummonsters; i++)
 			LoadMonster(&file, monstactive[i]);
 		for (int &missileId : missileactive)
-			missileId = file.nextLE<Sint8>();
+			missileId = file.nextLE<int8_t>();
 		for (int &missileId : missileavail)
-			missileId = file.nextLE<Sint8>();
+			missileId = file.nextLE<int8_t>();
 		for (int i = 0; i < nummissiles; i++)
 			LoadMissile(&file, missileactive[i]);
 		for (int &objectId : objectactive)
-			objectId = file.nextLE<Sint8>();
+			objectId = file.nextLE<int8_t>();
 		for (int &objectId : objectavail)
-			objectId = file.nextLE<Sint8>();
+			objectId = file.nextLE<int8_t>();
 		for (int i = 0; i < nobjects; i++)
 			LoadObject(&file, objectactive[i]);
 		for (int i = 0; i < nobjects; i++)
 			SyncObjectAnim(objectactive[i]);
 
-		numlights = file.nextBE<Sint32>();
+		numlights = file.nextBE<int32_t>();
 
 		for (uint8_t &lightId : lightactive)
-			lightId = file.nextLE<Uint8>();
+			lightId = file.nextLE<uint8_t>();
 		for (int i = 0; i < numlights; i++)
 			LoadLighting(&file, &LightList[lightactive[i]]);
 
-		visionid = file.nextBE<Sint32>();
-		numvision = file.nextBE<Sint32>();
+		visionid = file.nextBE<int32_t>();
+		numvision = file.nextBE<int32_t>();
 
 		for (int i = 0; i < numvision; i++)
 			LoadLighting(&file, &VisionList[i]);
 	}
 
 	for (int &itemId : itemactive)
-		itemId = file.nextLE<Sint8>();
+		itemId = file.nextLE<int8_t>();
 	for (int &itemId : itemavail)
-		itemId = file.nextLE<Sint8>();
+		itemId = file.nextLE<int8_t>();
 	for (int i = 0; i < numitems; i++)
 		LoadItem(&file, itemactive[i]);
 	for (bool &UniqueItemFlag : UniqueItemFlags)
@@ -1112,41 +1112,41 @@ void LoadGame(bool firstflag)
 
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			dLight[i][j] = file.nextLE<Sint8>();
+			dLight[i][j] = file.nextLE<int8_t>();
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			dFlags[i][j] = file.nextLE<Sint8>();
+			dFlags[i][j] = file.nextLE<int8_t>();
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			dPlayer[i][j] = file.nextLE<Sint8>();
+			dPlayer[i][j] = file.nextLE<int8_t>();
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			dItem[i][j] = file.nextLE<Sint8>();
+			dItem[i][j] = file.nextLE<int8_t>();
 	}
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dMonster[i][j] = file.nextBE<Sint32>();
+				dMonster[i][j] = file.nextBE<int32_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dDead[i][j] = file.nextLE<Sint8>();
+				dDead[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dObject[i][j] = file.nextLE<Sint8>();
+				dObject[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dLight[i][j] = file.nextLE<Sint8>();
+				dLight[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dPreLight[i][j] = file.nextLE<Sint8>();
+				dPreLight[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < DMAXY; j++) {
 			for (int i = 0; i < DMAXX; i++)
@@ -1154,12 +1154,12 @@ void LoadGame(bool firstflag)
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dMissile[i][j] = file.nextLE<Sint8>();
+				dMissile[i][j] = file.nextLE<int8_t>();
 		}
 	}
 
-	numpremium = file.nextBE<Sint32>();
-	premiumlevel = file.nextBE<Sint32>();
+	numpremium = file.nextBE<int32_t>();
+	premiumlevel = file.nextBE<int32_t>();
 
 	for (int i = 0; i < giNumberOfSmithPremiumItems; i++)
 		LoadPremium(&file, i);
@@ -1167,7 +1167,7 @@ void LoadGame(bool firstflag)
 		SpawnPremium(myplr);
 
 	automapflag = file.nextBool8();
-	AutoMapScale = file.nextBE<Sint32>();
+	AutoMapScale = file.nextBE<int32_t>();
 	AutomapZoomReset();
 	ResyncQuests();
 
@@ -1200,82 +1200,82 @@ static void SaveItem(SaveHelper *file, ItemStruct *pItem)
 		iType = ITYPE_NONE;
 	}
 
-	file->writeLE<Sint32>(pItem->_iSeed);
-	file->writeLE<Sint16>(pItem->_iCreateInfo);
+	file->writeLE<int32_t>(pItem->_iSeed);
+	file->writeLE<int16_t>(pItem->_iCreateInfo);
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(iType);
-	file->writeLE<Sint32>(pItem->_ix);
-	file->writeLE<Sint32>(pItem->_iy);
-	file->writeLE<Uint32>(pItem->_iAnimFlag);
+	file->writeLE<int32_t>(iType);
+	file->writeLE<int32_t>(pItem->_ix);
+	file->writeLE<int32_t>(pItem->_iy);
+	file->writeLE<uint32_t>(pItem->_iAnimFlag);
 	file->skip(4); // Skip pointer _iAnimData
-	file->writeLE<Sint32>(pItem->_iAnimLen);
-	file->writeLE<Sint32>(pItem->_iAnimFrame);
-	file->writeLE<Sint32>(pItem->_iAnimWidth);
-	file->writeLE<Sint32>(pItem->_iAnimWidth2);
+	file->writeLE<int32_t>(pItem->_iAnimLen);
+	file->writeLE<int32_t>(pItem->_iAnimFrame);
+	file->writeLE<int32_t>(pItem->_iAnimWidth);
+	file->writeLE<int32_t>(pItem->_iAnimWidth2);
 	file->skip(4); // Unused since 1.02
-	file->writeLE<Uint8>(pItem->_iSelFlag);
+	file->writeLE<uint8_t>(pItem->_iSelFlag);
 	file->skip(3); // Alignment
-	file->writeLE<Uint32>(pItem->_iPostDraw);
-	file->writeLE<Uint32>(pItem->_iIdentified);
-	file->writeLE<Sint8>(pItem->_iMagical);
+	file->writeLE<uint32_t>(pItem->_iPostDraw);
+	file->writeLE<uint32_t>(pItem->_iIdentified);
+	file->writeLE<int8_t>(pItem->_iMagical);
 	file->writeBytes(pItem->_iName, 64);
 	file->writeBytes(pItem->_iIName, 64);
-	file->writeLE<Sint8>(pItem->_iLoc);
-	file->writeLE<Uint8>(pItem->_iClass);
+	file->writeLE<int8_t>(pItem->_iLoc);
+	file->writeLE<uint8_t>(pItem->_iClass);
 	file->skip(1); // Alignment
-	file->writeLE<Sint32>(pItem->_iCurs);
-	file->writeLE<Sint32>(pItem->_ivalue);
-	file->writeLE<Sint32>(pItem->_iIvalue);
-	file->writeLE<Sint32>(pItem->_iMinDam);
-	file->writeLE<Sint32>(pItem->_iMaxDam);
-	file->writeLE<Sint32>(pItem->_iAC);
-	file->writeLE<Sint32>(pItem->_iFlags);
-	file->writeLE<Sint32>(pItem->_iMiscId);
-	file->writeLE<Sint32>(pItem->_iSpell);
-	file->writeLE<Sint32>(pItem->_iCharges);
-	file->writeLE<Sint32>(pItem->_iMaxCharges);
-	file->writeLE<Sint32>(pItem->_iDurability);
-	file->writeLE<Sint32>(pItem->_iMaxDur);
-	file->writeLE<Sint32>(pItem->_iPLDam);
-	file->writeLE<Sint32>(pItem->_iPLToHit);
-	file->writeLE<Sint32>(pItem->_iPLAC);
-	file->writeLE<Sint32>(pItem->_iPLStr);
-	file->writeLE<Sint32>(pItem->_iPLMag);
-	file->writeLE<Sint32>(pItem->_iPLDex);
-	file->writeLE<Sint32>(pItem->_iPLVit);
-	file->writeLE<Sint32>(pItem->_iPLFR);
-	file->writeLE<Sint32>(pItem->_iPLLR);
-	file->writeLE<Sint32>(pItem->_iPLMR);
-	file->writeLE<Sint32>(pItem->_iPLMana);
-	file->writeLE<Sint32>(pItem->_iPLHP);
-	file->writeLE<Sint32>(pItem->_iPLDamMod);
-	file->writeLE<Sint32>(pItem->_iPLGetHit);
-	file->writeLE<Sint32>(pItem->_iPLLight);
-	file->writeLE<Sint8>(pItem->_iSplLvlAdd);
-	file->writeLE<Sint8>(pItem->_iRequest);
+	file->writeLE<int32_t>(pItem->_iCurs);
+	file->writeLE<int32_t>(pItem->_ivalue);
+	file->writeLE<int32_t>(pItem->_iIvalue);
+	file->writeLE<int32_t>(pItem->_iMinDam);
+	file->writeLE<int32_t>(pItem->_iMaxDam);
+	file->writeLE<int32_t>(pItem->_iAC);
+	file->writeLE<uint32_t>(pItem->_iFlags);
+	file->writeLE<int32_t>(pItem->_iMiscId);
+	file->writeLE<int32_t>(pItem->_iSpell);
+	file->writeLE<int32_t>(pItem->_iCharges);
+	file->writeLE<int32_t>(pItem->_iMaxCharges);
+	file->writeLE<int32_t>(pItem->_iDurability);
+	file->writeLE<int32_t>(pItem->_iMaxDur);
+	file->writeLE<int32_t>(pItem->_iPLDam);
+	file->writeLE<int32_t>(pItem->_iPLToHit);
+	file->writeLE<int32_t>(pItem->_iPLAC);
+	file->writeLE<int32_t>(pItem->_iPLStr);
+	file->writeLE<int32_t>(pItem->_iPLMag);
+	file->writeLE<int32_t>(pItem->_iPLDex);
+	file->writeLE<int32_t>(pItem->_iPLVit);
+	file->writeLE<int32_t>(pItem->_iPLFR);
+	file->writeLE<int32_t>(pItem->_iPLLR);
+	file->writeLE<int32_t>(pItem->_iPLMR);
+	file->writeLE<int32_t>(pItem->_iPLMana);
+	file->writeLE<int32_t>(pItem->_iPLHP);
+	file->writeLE<int32_t>(pItem->_iPLDamMod);
+	file->writeLE<int32_t>(pItem->_iPLGetHit);
+	file->writeLE<int32_t>(pItem->_iPLLight);
+	file->writeLE<int8_t>(pItem->_iSplLvlAdd);
+	file->writeLE<int8_t>(pItem->_iRequest);
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(pItem->_iUid);
-	file->writeLE<Sint32>(pItem->_iFMinDam);
-	file->writeLE<Sint32>(pItem->_iFMaxDam);
-	file->writeLE<Sint32>(pItem->_iLMinDam);
-	file->writeLE<Sint32>(pItem->_iLMaxDam);
-	file->writeLE<Sint32>(pItem->_iPLEnAc);
-	file->writeLE<Sint8>(pItem->_iPrePower);
-	file->writeLE<Sint8>(pItem->_iSufPower);
+	file->writeLE<int32_t>(pItem->_iUid);
+	file->writeLE<int32_t>(pItem->_iFMinDam);
+	file->writeLE<int32_t>(pItem->_iFMaxDam);
+	file->writeLE<int32_t>(pItem->_iLMinDam);
+	file->writeLE<int32_t>(pItem->_iLMaxDam);
+	file->writeLE<int32_t>(pItem->_iPLEnAc);
+	file->writeLE<int8_t>(pItem->_iPrePower);
+	file->writeLE<int8_t>(pItem->_iSufPower);
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(pItem->_iVAdd1);
-	file->writeLE<Sint32>(pItem->_iVMult1);
-	file->writeLE<Sint32>(pItem->_iVAdd2);
-	file->writeLE<Sint32>(pItem->_iVMult2);
-	file->writeLE<Sint8>(pItem->_iMinStr);
-	file->writeLE<Uint8>(pItem->_iMinMag);
-	file->writeLE<Sint8>(pItem->_iMinDex);
+	file->writeLE<int32_t>(pItem->_iVAdd1);
+	file->writeLE<int32_t>(pItem->_iVMult1);
+	file->writeLE<int32_t>(pItem->_iVAdd2);
+	file->writeLE<int32_t>(pItem->_iVMult2);
+	file->writeLE<int8_t>(pItem->_iMinStr);
+	file->writeLE<uint8_t>(pItem->_iMinMag);
+	file->writeLE<int8_t>(pItem->_iMinDex);
 	file->skip(1); // Alignment
-	file->writeLE<Uint32>(pItem->_iStatFlag);
-	file->writeLE<Sint32>(idx);
-	file->writeLE<Uint32>(pItem->dwBuff);
+	file->writeLE<uint32_t>(pItem->_iStatFlag);
+	file->writeLE<int32_t>(idx);
+	file->writeLE<uint32_t>(pItem->dwBuff);
 	if (gbIsHellfire)
-		file->writeLE<Uint32>(pItem->_iDamAcFlags);
+		file->writeLE<uint32_t>(pItem->_iDamAcFlags);
 }
 
 static void SaveItems(SaveHelper *file, ItemStruct *pItem, const int n)
@@ -1289,207 +1289,207 @@ static void SavePlayer(SaveHelper *file, int p)
 {
 	PlayerStruct *pPlayer = &plr[p];
 
-	file->writeLE<Sint32>(pPlayer->_pmode);
+	file->writeLE<int32_t>(pPlayer->_pmode);
 	for (int8_t step : pPlayer->walkpath)
 		file->writeLE<int8_t>(step);
-	file->writeLE<Uint8>(pPlayer->plractive);
+	file->writeLE<uint8_t>(pPlayer->plractive);
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(pPlayer->destAction);
-	file->writeLE<Sint32>(pPlayer->destParam1);
-	file->writeLE<Sint32>(pPlayer->destParam2);
-	file->writeLE<Sint32>(pPlayer->destParam3);
-	file->writeLE<Sint32>(pPlayer->destParam4);
-	file->writeLE<Sint32>(pPlayer->plrlevel);
-	file->writeLE<Sint32>(pPlayer->position.current.x);
-	file->writeLE<Sint32>(pPlayer->position.current.y);
-	file->writeLE<Sint32>(pPlayer->position.future.x);
-	file->writeLE<Sint32>(pPlayer->position.future.y);
+	file->writeLE<int32_t>(pPlayer->destAction);
+	file->writeLE<int32_t>(pPlayer->destParam1);
+	file->writeLE<int32_t>(pPlayer->destParam2);
+	file->writeLE<int32_t>(pPlayer->destParam3);
+	file->writeLE<int32_t>(pPlayer->destParam4);
+	file->writeLE<int32_t>(pPlayer->plrlevel);
+	file->writeLE<int32_t>(pPlayer->position.current.x);
+	file->writeLE<int32_t>(pPlayer->position.current.y);
+	file->writeLE<int32_t>(pPlayer->position.future.x);
+	file->writeLE<int32_t>(pPlayer->position.future.y);
 
 	// For backwards compatibility
 	const Point target = pPlayer->GetTargetPosition();
-	file->writeLE<Sint32>(target.x);
-	file->writeLE<Sint32>(target.y);
+	file->writeLE<int32_t>(target.x);
+	file->writeLE<int32_t>(target.y);
 
-	file->writeLE<Sint32>(pPlayer->position.owner.x);
-	file->writeLE<Sint32>(pPlayer->position.owner.y);
-	file->writeLE<Sint32>(pPlayer->position.old.x);
-	file->writeLE<Sint32>(pPlayer->position.old.y);
-	file->writeLE<Sint32>(pPlayer->position.offset.x);
-	file->writeLE<Sint32>(pPlayer->position.offset.y);
-	file->writeLE<Sint32>(pPlayer->position.velocity.x);
-	file->writeLE<Sint32>(pPlayer->position.velocity.y);
-	file->writeLE<Sint32>(pPlayer->_pdir);
+	file->writeLE<int32_t>(pPlayer->position.owner.x);
+	file->writeLE<int32_t>(pPlayer->position.owner.y);
+	file->writeLE<int32_t>(pPlayer->position.old.x);
+	file->writeLE<int32_t>(pPlayer->position.old.y);
+	file->writeLE<int32_t>(pPlayer->position.offset.x);
+	file->writeLE<int32_t>(pPlayer->position.offset.y);
+	file->writeLE<int32_t>(pPlayer->position.velocity.x);
+	file->writeLE<int32_t>(pPlayer->position.velocity.y);
+	file->writeLE<int32_t>(pPlayer->_pdir);
 	file->skip(4); // Unused
-	file->writeLE<Sint32>(pPlayer->_pgfxnum);
+	file->writeLE<int32_t>(pPlayer->_pgfxnum);
 	file->skip(4); // Skip pointer _pAnimData
-	file->writeLE<Sint32>(pPlayer->_pAnimDelay);
-	file->writeLE<Sint32>(pPlayer->_pAnimCnt);
-	file->writeLE<Sint32>(pPlayer->_pAnimLen);
-	file->writeLE<Sint32>(pPlayer->_pAnimFrame);
-	file->writeLE<Sint32>(pPlayer->_pAnimWidth);
-	file->writeLE<Sint32>(pPlayer->_pAnimWidth2);
+	file->writeLE<int32_t>(pPlayer->_pAnimDelay);
+	file->writeLE<int32_t>(pPlayer->_pAnimCnt);
+	file->writeLE<int32_t>(pPlayer->_pAnimLen);
+	file->writeLE<int32_t>(pPlayer->_pAnimFrame);
+	file->writeLE<int32_t>(pPlayer->_pAnimWidth);
+	file->writeLE<int32_t>(pPlayer->_pAnimWidth2);
 	file->skip(4); // Skip _peflag
-	file->writeLE<Sint32>(pPlayer->_plid);
-	file->writeLE<Sint32>(pPlayer->_pvid);
+	file->writeLE<int32_t>(pPlayer->_plid);
+	file->writeLE<int32_t>(pPlayer->_pvid);
 
-	file->writeLE<Sint32>(pPlayer->_pSpell);
-	file->writeLE<Sint8>(pPlayer->_pSplType);
-	file->writeLE<Sint8>(pPlayer->_pSplFrom);
+	file->writeLE<int32_t>(pPlayer->_pSpell);
+	file->writeLE<int8_t>(pPlayer->_pSplType);
+	file->writeLE<int8_t>(pPlayer->_pSplFrom);
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(pPlayer->_pTSpell);
-	file->writeLE<Sint8>(pPlayer->_pTSplType);
+	file->writeLE<int32_t>(pPlayer->_pTSpell);
+	file->writeLE<int8_t>(pPlayer->_pTSplType);
 	file->skip(3); // Alignment
-	file->writeLE<Sint32>(pPlayer->_pRSpell);
-	file->writeLE<Sint8>(pPlayer->_pRSplType);
+	file->writeLE<int32_t>(pPlayer->_pRSpell);
+	file->writeLE<int8_t>(pPlayer->_pRSplType);
 	file->skip(3); // Alignment
-	file->writeLE<Sint32>(pPlayer->_pSBkSpell);
-	file->writeLE<Sint8>(pPlayer->_pSBkSplType);
+	file->writeLE<int32_t>(pPlayer->_pSBkSpell);
+	file->writeLE<int8_t>(pPlayer->_pSBkSplType);
 	for (int8_t spellLevel : pPlayer->_pSplLvl)
-		file->writeLE<Sint8>(spellLevel);
+		file->writeLE<int8_t>(spellLevel);
 	file->skip(7); // Alignment
-	file->writeLE<Uint64>(pPlayer->_pMemSpells);
-	file->writeLE<Uint64>(pPlayer->_pAblSpells);
-	file->writeLE<Uint64>(pPlayer->_pScrlSpells);
-	file->writeLE<Uint8>(pPlayer->_pSpellFlags);
+	file->writeLE<uint64_t>(pPlayer->_pMemSpells);
+	file->writeLE<uint64_t>(pPlayer->_pAblSpells);
+	file->writeLE<uint64_t>(pPlayer->_pScrlSpells);
+	file->writeLE<uint8_t>(pPlayer->_pSpellFlags);
 	file->skip(3); // Alignment
 	for (auto &spellId : pPlayer->_pSplHotKey)
-		file->writeLE<Sint32>(spellId);
+		file->writeLE<int32_t>(spellId);
 	for (auto &spellType : pPlayer->_pSplTHotKey)
-		file->writeLE<Sint8>(spellType);
+		file->writeLE<int8_t>(spellType);
 
-	file->writeLE<Sint32>(pPlayer->_pwtype);
-	file->writeLE<Uint8>(pPlayer->_pBlockFlag);
-	file->writeLE<Uint8>(pPlayer->_pInvincible);
-	file->writeLE<Sint8>(pPlayer->_pLightRad);
-	file->writeLE<Uint8>(pPlayer->_pLvlChanging);
+	file->writeLE<int32_t>(pPlayer->_pwtype);
+	file->writeLE<uint8_t>(pPlayer->_pBlockFlag);
+	file->writeLE<uint8_t>(pPlayer->_pInvincible);
+	file->writeLE<int8_t>(pPlayer->_pLightRad);
+	file->writeLE<uint8_t>(pPlayer->_pLvlChanging);
 
 	file->writeBytes(pPlayer->_pName, PLR_NAME_LEN);
-	file->writeLE<Sint8>(static_cast<Sint8>(pPlayer->_pClass));
+	file->writeLE<int8_t>(static_cast<int8_t>(pPlayer->_pClass));
 	file->skip(3); // Alignment
-	file->writeLE<Sint32>(pPlayer->_pStrength);
-	file->writeLE<Sint32>(pPlayer->_pBaseStr);
-	file->writeLE<Sint32>(pPlayer->_pMagic);
-	file->writeLE<Sint32>(pPlayer->_pBaseMag);
-	file->writeLE<Sint32>(pPlayer->_pDexterity);
-	file->writeLE<Sint32>(pPlayer->_pBaseDex);
-	file->writeLE<Sint32>(pPlayer->_pVitality);
-	file->writeLE<Sint32>(pPlayer->_pBaseVit);
-	file->writeLE<Sint32>(pPlayer->_pStatPts);
-	file->writeLE<Sint32>(pPlayer->_pDamageMod);
+	file->writeLE<int32_t>(pPlayer->_pStrength);
+	file->writeLE<int32_t>(pPlayer->_pBaseStr);
+	file->writeLE<int32_t>(pPlayer->_pMagic);
+	file->writeLE<int32_t>(pPlayer->_pBaseMag);
+	file->writeLE<int32_t>(pPlayer->_pDexterity);
+	file->writeLE<int32_t>(pPlayer->_pBaseDex);
+	file->writeLE<int32_t>(pPlayer->_pVitality);
+	file->writeLE<int32_t>(pPlayer->_pBaseVit);
+	file->writeLE<int32_t>(pPlayer->_pStatPts);
+	file->writeLE<int32_t>(pPlayer->_pDamageMod);
 
-	file->writeLE<Sint32>(pPlayer->_pBaseToBlk);
-	file->writeLE<Sint32>(pPlayer->_pHPBase);
-	file->writeLE<Sint32>(pPlayer->_pMaxHPBase);
-	file->writeLE<Sint32>(pPlayer->_pHitPoints);
-	file->writeLE<Sint32>(pPlayer->_pMaxHP);
-	file->writeLE<Sint32>(pPlayer->_pHPPer);
-	file->writeLE<Sint32>(pPlayer->_pManaBase);
-	file->writeLE<Sint32>(pPlayer->_pMaxManaBase);
-	file->writeLE<Sint32>(pPlayer->_pMana);
-	file->writeLE<Sint32>(pPlayer->_pMaxMana);
-	file->writeLE<Sint32>(pPlayer->_pManaPer);
-	file->writeLE<Sint8>(pPlayer->_pLevel);
-	file->writeLE<Sint8>(pPlayer->_pMaxLvl);
+	file->writeLE<int32_t>(pPlayer->_pBaseToBlk);
+	file->writeLE<int32_t>(pPlayer->_pHPBase);
+	file->writeLE<int32_t>(pPlayer->_pMaxHPBase);
+	file->writeLE<int32_t>(pPlayer->_pHitPoints);
+	file->writeLE<int32_t>(pPlayer->_pMaxHP);
+	file->writeLE<int32_t>(pPlayer->_pHPPer);
+	file->writeLE<int32_t>(pPlayer->_pManaBase);
+	file->writeLE<int32_t>(pPlayer->_pMaxManaBase);
+	file->writeLE<int32_t>(pPlayer->_pMana);
+	file->writeLE<int32_t>(pPlayer->_pMaxMana);
+	file->writeLE<int32_t>(pPlayer->_pManaPer);
+	file->writeLE<int8_t>(pPlayer->_pLevel);
+	file->writeLE<int8_t>(pPlayer->_pMaxLvl);
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(pPlayer->_pExperience);
-	file->writeLE<Sint32>(pPlayer->_pMaxExp);
-	file->writeLE<Sint32>(pPlayer->_pNextExper);
-	file->writeLE<Sint8>(pPlayer->_pArmorClass);
-	file->writeLE<Sint8>(pPlayer->_pMagResist);
-	file->writeLE<Sint8>(pPlayer->_pFireResist);
-	file->writeLE<Sint8>(pPlayer->_pLghtResist);
-	file->writeLE<Sint32>(pPlayer->_pGold);
+	file->writeLE<int32_t>(pPlayer->_pExperience);
+	file->writeLE<int32_t>(pPlayer->_pMaxExp);
+	file->writeLE<int32_t>(pPlayer->_pNextExper);
+	file->writeLE<int8_t>(pPlayer->_pArmorClass);
+	file->writeLE<int8_t>(pPlayer->_pMagResist);
+	file->writeLE<int8_t>(pPlayer->_pFireResist);
+	file->writeLE<int8_t>(pPlayer->_pLghtResist);
+	file->writeLE<int32_t>(pPlayer->_pGold);
 
-	file->writeLE<Uint32>(pPlayer->_pInfraFlag);
-	file->writeLE<Sint32>(pPlayer->tempPoint.x);
-	file->writeLE<Sint32>(pPlayer->tempPoint.y);
-	file->writeLE<Sint32>(pPlayer->tempDirection);
-	file->writeLE<Sint32>(pPlayer->_pVar4);
-	file->writeLE<Sint32>(pPlayer->_pVar5);
-	file->writeLE<Sint32>(pPlayer->position.offset2.x);
-	file->writeLE<Sint32>(pPlayer->position.offset2.y);
-	file->writeLE<Sint32>(pPlayer->actionFrame);
+	file->writeLE<uint32_t>(pPlayer->_pInfraFlag);
+	file->writeLE<int32_t>(pPlayer->tempPoint.x);
+	file->writeLE<int32_t>(pPlayer->tempPoint.y);
+	file->writeLE<int32_t>(pPlayer->tempDirection);
+	file->writeLE<int32_t>(pPlayer->_pVar4);
+	file->writeLE<int32_t>(pPlayer->_pVar5);
+	file->writeLE<int32_t>(pPlayer->position.offset2.x);
+	file->writeLE<int32_t>(pPlayer->position.offset2.y);
+	file->writeLE<int32_t>(pPlayer->actionFrame);
 	for (uint8_t i = 0; i < giNumberOfLevels; i++)
-		file->writeLE<Uint8>(pPlayer->_pLvlVisited[i]);
+		file->writeLE<uint8_t>(pPlayer->_pLvlVisited[i]);
 	for (uint8_t i = 0; i < giNumberOfLevels; i++)
-		file->writeLE<Uint8>(pPlayer->_pSLvlVisited[i]); // only 10 used
+		file->writeLE<uint8_t>(pPlayer->_pSLvlVisited[i]); // only 10 used
 
 	file->skip(2); // Alignment
 
-	file->writeLE<Sint32>(pPlayer->_pGFXLoad);
+	file->writeLE<int32_t>(pPlayer->_pGFXLoad);
 	file->skip(4 * 8); // Skip pointers _pNAnim
-	file->writeLE<Sint32>(pPlayer->_pNFrames);
-	file->writeLE<Sint32>(pPlayer->_pNWidth);
+	file->writeLE<int32_t>(pPlayer->_pNFrames);
+	file->writeLE<int32_t>(pPlayer->_pNWidth);
 	file->skip(4 * 8); // Skip pointers _pWAnim
-	file->writeLE<Sint32>(pPlayer->_pWFrames);
-	file->writeLE<Sint32>(pPlayer->_pWWidth);
+	file->writeLE<int32_t>(pPlayer->_pWFrames);
+	file->writeLE<int32_t>(pPlayer->_pWWidth);
 	file->skip(4 * 8); // Skip pointers _pAAnim
-	file->writeLE<Sint32>(pPlayer->_pAFrames);
-	file->writeLE<Sint32>(pPlayer->_pAWidth);
-	file->writeLE<Sint32>(pPlayer->_pAFNum);
+	file->writeLE<int32_t>(pPlayer->_pAFrames);
+	file->writeLE<int32_t>(pPlayer->_pAWidth);
+	file->writeLE<int32_t>(pPlayer->_pAFNum);
 	file->skip(4 * 8); // Skip pointers _pLAnim
 	file->skip(4 * 8); // Skip pointers _pFAnim
 	file->skip(4 * 8); // Skip pointers _pTAnim
-	file->writeLE<Sint32>(pPlayer->_pSFrames);
-	file->writeLE<Sint32>(pPlayer->_pSWidth);
-	file->writeLE<Sint32>(pPlayer->_pSFNum);
+	file->writeLE<int32_t>(pPlayer->_pSFrames);
+	file->writeLE<int32_t>(pPlayer->_pSWidth);
+	file->writeLE<int32_t>(pPlayer->_pSFNum);
 	file->skip(4 * 8); // Skip pointers _pHAnim
-	file->writeLE<Sint32>(pPlayer->_pHFrames);
-	file->writeLE<Sint32>(pPlayer->_pHWidth);
+	file->writeLE<int32_t>(pPlayer->_pHFrames);
+	file->writeLE<int32_t>(pPlayer->_pHWidth);
 	file->skip(4 * 8); // Skip pointers _pDAnim
-	file->writeLE<Sint32>(pPlayer->_pDFrames);
-	file->writeLE<Sint32>(pPlayer->_pDWidth);
+	file->writeLE<int32_t>(pPlayer->_pDFrames);
+	file->writeLE<int32_t>(pPlayer->_pDWidth);
 	file->skip(4 * 8); // Skip pointers _pBAnim
-	file->writeLE<Sint32>(pPlayer->_pBFrames);
-	file->writeLE<Sint32>(pPlayer->_pBWidth);
+	file->writeLE<int32_t>(pPlayer->_pBFrames);
+	file->writeLE<int32_t>(pPlayer->_pBWidth);
 
 	SaveItems(file, pPlayer->InvBody, NUM_INVLOC);
 	SaveItems(file, pPlayer->InvList, NUM_INV_GRID_ELEM);
-	file->writeLE<Sint32>(pPlayer->_pNumInv);
+	file->writeLE<int32_t>(pPlayer->_pNumInv);
 	for (int8_t cell : pPlayer->InvGrid)
 		file->writeLE<int8_t>(cell);
 	SaveItems(file, pPlayer->SpdList, MAXBELTITEMS);
 	SaveItem(file, &pPlayer->HoldItem);
 
-	file->writeLE<Sint32>(pPlayer->_pIMinDam);
-	file->writeLE<Sint32>(pPlayer->_pIMaxDam);
-	file->writeLE<Sint32>(pPlayer->_pIAC);
-	file->writeLE<Sint32>(pPlayer->_pIBonusDam);
-	file->writeLE<Sint32>(pPlayer->_pIBonusToHit);
-	file->writeLE<Sint32>(pPlayer->_pIBonusAC);
-	file->writeLE<Sint32>(pPlayer->_pIBonusDamMod);
+	file->writeLE<int32_t>(pPlayer->_pIMinDam);
+	file->writeLE<int32_t>(pPlayer->_pIMaxDam);
+	file->writeLE<int32_t>(pPlayer->_pIAC);
+	file->writeLE<int32_t>(pPlayer->_pIBonusDam);
+	file->writeLE<int32_t>(pPlayer->_pIBonusToHit);
+	file->writeLE<int32_t>(pPlayer->_pIBonusAC);
+	file->writeLE<int32_t>(pPlayer->_pIBonusDamMod);
 	file->skip(4); // Alignment
 
-	file->writeLE<Uint64>(pPlayer->_pISpells);
-	file->writeLE<Sint32>(pPlayer->_pIFlags);
-	file->writeLE<Sint32>(pPlayer->_pIGetHit);
+	file->writeLE<uint64_t>(pPlayer->_pISpells);
+	file->writeLE<int32_t>(pPlayer->_pIFlags);
+	file->writeLE<int32_t>(pPlayer->_pIGetHit);
 
-	file->writeLE<Sint8>(pPlayer->_pISplLvlAdd);
+	file->writeLE<int8_t>(pPlayer->_pISplLvlAdd);
 	file->skip(1); // Unused
 	file->skip(2); // Alignment
-	file->writeLE<Sint32>(pPlayer->_pISplDur);
-	file->writeLE<Sint32>(pPlayer->_pIEnAc);
-	file->writeLE<Sint32>(pPlayer->_pIFMinDam);
-	file->writeLE<Sint32>(pPlayer->_pIFMaxDam);
-	file->writeLE<Sint32>(pPlayer->_pILMinDam);
-	file->writeLE<Sint32>(pPlayer->_pILMaxDam);
-	file->writeLE<Sint32>(pPlayer->_pOilType);
-	file->writeLE<Uint8>(pPlayer->pTownWarps);
-	file->writeLE<Uint8>(pPlayer->pDungMsgs);
-	file->writeLE<Uint8>(pPlayer->pLvlLoad);
+	file->writeLE<int32_t>(pPlayer->_pISplDur);
+	file->writeLE<int32_t>(pPlayer->_pIEnAc);
+	file->writeLE<int32_t>(pPlayer->_pIFMinDam);
+	file->writeLE<int32_t>(pPlayer->_pIFMaxDam);
+	file->writeLE<int32_t>(pPlayer->_pILMinDam);
+	file->writeLE<int32_t>(pPlayer->_pILMaxDam);
+	file->writeLE<int32_t>(pPlayer->_pOilType);
+	file->writeLE<uint8_t>(pPlayer->pTownWarps);
+	file->writeLE<uint8_t>(pPlayer->pDungMsgs);
+	file->writeLE<uint8_t>(pPlayer->pLvlLoad);
 	if (gbIsHellfire)
-		file->writeLE<Uint8>(pPlayer->pDungMsgs2);
+		file->writeLE<uint8_t>(pPlayer->pDungMsgs2);
 	else
-		file->writeLE<Uint8>(pPlayer->pBattleNet);
-	file->writeLE<Uint8>(pPlayer->pManaShield);
-	file->writeLE<Uint8>(pPlayer->pOriginalCathedral);
+		file->writeLE<uint8_t>(pPlayer->pBattleNet);
+	file->writeLE<uint8_t>(pPlayer->pManaShield);
+	file->writeLE<uint8_t>(pPlayer->pOriginalCathedral);
 	file->skip(2); // Available bytes
-	file->writeLE<Uint16>(pPlayer->wReflections);
+	file->writeLE<uint16_t>(pPlayer->wReflections);
 	file->skip(14); // Available bytes
 
-	file->writeLE<Uint32>(pPlayer->pDiabloKillLevel);
-	file->writeLE<Uint32>(pPlayer->pDifficulty);
-	file->writeLE<Uint32>(pPlayer->pDamAcFlags);
+	file->writeLE<uint32_t>(pPlayer->pDiabloKillLevel);
+	file->writeLE<uint32_t>(pPlayer->pDifficulty);
+	file->writeLE<uint32_t>(pPlayer->pDamAcFlags);
 	file->skip(20); // Available bytes
 
 	// Omit pointer _pNData
@@ -1508,88 +1508,88 @@ static void SaveMonster(SaveHelper *file, int i)
 {
 	MonsterStruct *pMonster = &monster[i];
 
-	file->writeLE<Sint32>(pMonster->_mMTidx);
-	file->writeLE<Sint32>(pMonster->_mmode);
-	file->writeLE<Uint8>(pMonster->_mgoal);
+	file->writeLE<int32_t>(pMonster->_mMTidx);
+	file->writeLE<int32_t>(pMonster->_mmode);
+	file->writeLE<uint8_t>(pMonster->_mgoal);
 	file->skip(3); // Alignment
-	file->writeLE<Sint32>(pMonster->_mgoalvar1);
-	file->writeLE<Sint32>(pMonster->_mgoalvar2);
-	file->writeLE<Sint32>(pMonster->_mgoalvar3);
+	file->writeLE<int32_t>(pMonster->_mgoalvar1);
+	file->writeLE<int32_t>(pMonster->_mgoalvar2);
+	file->writeLE<int32_t>(pMonster->_mgoalvar3);
 	file->skip(4); // Unused
-	file->writeLE<Uint8>(pMonster->_pathcount);
+	file->writeLE<uint8_t>(pMonster->_pathcount);
 	file->skip(3); // Alignment
-	file->writeLE<Sint32>(pMonster->_mx);
-	file->writeLE<Sint32>(pMonster->_my);
-	file->writeLE<Sint32>(pMonster->_mfutx);
-	file->writeLE<Sint32>(pMonster->_mfuty);
-	file->writeLE<Sint32>(pMonster->_moldx);
-	file->writeLE<Sint32>(pMonster->_moldy);
-	file->writeLE<Sint32>(pMonster->_mxoff);
-	file->writeLE<Sint32>(pMonster->_myoff);
-	file->writeLE<Sint32>(pMonster->_mxvel);
-	file->writeLE<Sint32>(pMonster->_myvel);
-	file->writeLE<Sint32>(pMonster->_mdir);
-	file->writeLE<Sint32>(pMonster->_menemy);
-	file->writeLE<Uint8>(pMonster->_menemyx);
-	file->writeLE<Uint8>(pMonster->_menemyy);
+	file->writeLE<int32_t>(pMonster->_mx);
+	file->writeLE<int32_t>(pMonster->_my);
+	file->writeLE<int32_t>(pMonster->_mfutx);
+	file->writeLE<int32_t>(pMonster->_mfuty);
+	file->writeLE<int32_t>(pMonster->_moldx);
+	file->writeLE<int32_t>(pMonster->_moldy);
+	file->writeLE<int32_t>(pMonster->_mxoff);
+	file->writeLE<int32_t>(pMonster->_myoff);
+	file->writeLE<int32_t>(pMonster->_mxvel);
+	file->writeLE<int32_t>(pMonster->_myvel);
+	file->writeLE<int32_t>(pMonster->_mdir);
+	file->writeLE<int32_t>(pMonster->_menemy);
+	file->writeLE<uint8_t>(pMonster->_menemyx);
+	file->writeLE<uint8_t>(pMonster->_menemyy);
 	file->skip(2); // Unused
 
 	file->skip(4); // Skip pointer _mAnimData
-	file->writeLE<Sint32>(pMonster->_mAnimDelay);
-	file->writeLE<Sint32>(pMonster->_mAnimCnt);
-	file->writeLE<Sint32>(pMonster->_mAnimLen);
-	file->writeLE<Sint32>(pMonster->_mAnimFrame);
+	file->writeLE<int32_t>(pMonster->_mAnimDelay);
+	file->writeLE<int32_t>(pMonster->_mAnimCnt);
+	file->writeLE<int32_t>(pMonster->_mAnimLen);
+	file->writeLE<int32_t>(pMonster->_mAnimFrame);
 	file->skip(4); // Skip _meflag
-	file->writeLE<Uint32>(pMonster->_mDelFlag);
-	file->writeLE<Sint32>(pMonster->_mVar1);
-	file->writeLE<Sint32>(pMonster->_mVar2);
-	file->writeLE<Sint32>(pMonster->_mVar3);
-	file->writeLE<Sint32>(pMonster->_mVar4);
-	file->writeLE<Sint32>(pMonster->_mVar5);
-	file->writeLE<Sint32>(pMonster->_mVar6);
-	file->writeLE<Sint32>(pMonster->_mVar7);
-	file->writeLE<Sint32>(pMonster->_mVar8);
-	file->writeLE<Sint32>(pMonster->_mmaxhp);
-	file->writeLE<Sint32>(pMonster->_mhitpoints);
+	file->writeLE<uint32_t>(pMonster->_mDelFlag);
+	file->writeLE<int32_t>(pMonster->_mVar1);
+	file->writeLE<int32_t>(pMonster->_mVar2);
+	file->writeLE<int32_t>(pMonster->_mVar3);
+	file->writeLE<int32_t>(pMonster->_mVar4);
+	file->writeLE<int32_t>(pMonster->_mVar5);
+	file->writeLE<int32_t>(pMonster->_mVar6);
+	file->writeLE<int32_t>(pMonster->_mVar7);
+	file->writeLE<int32_t>(pMonster->_mVar8);
+	file->writeLE<int32_t>(pMonster->_mmaxhp);
+	file->writeLE<int32_t>(pMonster->_mhitpoints);
 
-	file->writeLE<Uint8>(pMonster->_mAi);
-	file->writeLE<Uint8>(pMonster->_mint);
+	file->writeLE<uint8_t>(pMonster->_mAi);
+	file->writeLE<uint8_t>(pMonster->_mint);
 	file->skip(2); // Alignment
-	file->writeLE<Uint32>(pMonster->_mFlags);
-	file->writeLE<Uint8>(pMonster->_msquelch);
+	file->writeLE<uint32_t>(pMonster->_mFlags);
+	file->writeLE<uint8_t>(pMonster->_msquelch);
 	file->skip(3); // Alignment
 	file->skip(4); // Unused
-	file->writeLE<Sint32>(pMonster->_lastx);
-	file->writeLE<Sint32>(pMonster->_lasty);
-	file->writeLE<Sint32>(pMonster->_mRndSeed);
-	file->writeLE<Sint32>(pMonster->_mAISeed);
+	file->writeLE<int32_t>(pMonster->_lastx);
+	file->writeLE<int32_t>(pMonster->_lasty);
+	file->writeLE<int32_t>(pMonster->_mRndSeed);
+	file->writeLE<int32_t>(pMonster->_mAISeed);
 	file->skip(4); // Unused
 
-	file->writeLE<Uint8>(pMonster->_uniqtype);
-	file->writeLE<Uint8>(pMonster->_uniqtrans);
-	file->writeLE<Sint8>(pMonster->_udeadval);
+	file->writeLE<uint8_t>(pMonster->_uniqtype);
+	file->writeLE<uint8_t>(pMonster->_uniqtrans);
+	file->writeLE<int8_t>(pMonster->_udeadval);
 
-	file->writeLE<Sint8>(pMonster->mWhoHit);
-	file->writeLE<Sint8>(pMonster->mLevel);
+	file->writeLE<int8_t>(pMonster->mWhoHit);
+	file->writeLE<int8_t>(pMonster->mLevel);
 	file->skip(1); // Alignment
-	file->writeLE<Uint16>(pMonster->mExp);
+	file->writeLE<uint16_t>(pMonster->mExp);
 
-	file->writeLE<Uint8>(pMonster->mHit < UCHAR_MAX ? pMonster->mHit : UCHAR_MAX); // For backwards compatibility
-	file->writeLE<Uint8>(pMonster->mMinDamage);
-	file->writeLE<Uint8>(pMonster->mMaxDamage);
-	file->writeLE<Uint8>(pMonster->mHit2 < UCHAR_MAX ? pMonster->mHit2 : UCHAR_MAX); // For backwards compatibility
-	file->writeLE<Uint8>(pMonster->mMinDamage2);
-	file->writeLE<Uint8>(pMonster->mMaxDamage2);
-	file->writeLE<Uint8>(pMonster->mArmorClass);
+	file->writeLE<uint8_t>(pMonster->mHit < UCHAR_MAX ? pMonster->mHit : UCHAR_MAX); // For backwards compatibility
+	file->writeLE<uint8_t>(pMonster->mMinDamage);
+	file->writeLE<uint8_t>(pMonster->mMaxDamage);
+	file->writeLE<uint8_t>(pMonster->mHit2 < UCHAR_MAX ? pMonster->mHit2 : UCHAR_MAX); // For backwards compatibility
+	file->writeLE<uint8_t>(pMonster->mMinDamage2);
+	file->writeLE<uint8_t>(pMonster->mMaxDamage2);
+	file->writeLE<uint8_t>(pMonster->mArmorClass);
 	file->skip(1); // Alignment
-	file->writeLE<Uint16>(pMonster->mMagicRes);
+	file->writeLE<uint16_t>(pMonster->mMagicRes);
 	file->skip(2); // Alignment
 
-	file->writeLE<Sint32>(pMonster->mtalkmsg);
-	file->writeLE<Uint8>(pMonster->leader);
-	file->writeLE<Uint8>(pMonster->leaderflag);
-	file->writeLE<Uint8>(pMonster->packsize);
-	file->writeLE<Sint8>(pMonster->mlid);
+	file->writeLE<int32_t>(pMonster->mtalkmsg);
+	file->writeLE<uint8_t>(pMonster->leader);
+	file->writeLE<uint8_t>(pMonster->leaderflag);
+	file->writeLE<uint8_t>(pMonster->packsize);
+	file->writeLE<int8_t>(pMonster->mlid);
 
 	// Omit pointer mName;
 	// Omit pointer MType;
@@ -1600,90 +1600,90 @@ static void SaveMissile(SaveHelper *file, int i)
 {
 	MissileStruct *pMissile = &missile[i];
 
-	file->writeLE<Sint32>(pMissile->_mitype);
-	file->writeLE<Sint32>(pMissile->_mix);
-	file->writeLE<Sint32>(pMissile->_miy);
-	file->writeLE<Sint32>(pMissile->_mixoff);
-	file->writeLE<Sint32>(pMissile->_miyoff);
-	file->writeLE<Sint32>(pMissile->_mixvel);
-	file->writeLE<Sint32>(pMissile->_miyvel);
-	file->writeLE<Sint32>(pMissile->_misx);
-	file->writeLE<Sint32>(pMissile->_misy);
-	file->writeLE<Sint32>(pMissile->_mitxoff);
-	file->writeLE<Sint32>(pMissile->_mityoff);
-	file->writeLE<Sint32>(pMissile->_mimfnum);
-	file->writeLE<Sint32>(pMissile->_mispllvl);
-	file->writeLE<Uint32>(pMissile->_miDelFlag);
-	file->writeLE<Uint8>(pMissile->_miAnimType);
+	file->writeLE<int32_t>(pMissile->_mitype);
+	file->writeLE<int32_t>(pMissile->_mix);
+	file->writeLE<int32_t>(pMissile->_miy);
+	file->writeLE<int32_t>(pMissile->_mixoff);
+	file->writeLE<int32_t>(pMissile->_miyoff);
+	file->writeLE<int32_t>(pMissile->_mixvel);
+	file->writeLE<int32_t>(pMissile->_miyvel);
+	file->writeLE<int32_t>(pMissile->_misx);
+	file->writeLE<int32_t>(pMissile->_misy);
+	file->writeLE<int32_t>(pMissile->_mitxoff);
+	file->writeLE<int32_t>(pMissile->_mityoff);
+	file->writeLE<int32_t>(pMissile->_mimfnum);
+	file->writeLE<int32_t>(pMissile->_mispllvl);
+	file->writeLE<uint32_t>(pMissile->_miDelFlag);
+	file->writeLE<uint8_t>(pMissile->_miAnimType);
 	file->skip(3); // Alignment
-	file->writeLE<Sint32>(pMissile->_miAnimFlags);
+	file->writeLE<int32_t>(pMissile->_miAnimFlags);
 	file->skip(4); // Skip pointer _miAnimData
-	file->writeLE<Sint32>(pMissile->_miAnimDelay);
-	file->writeLE<Sint32>(pMissile->_miAnimLen);
-	file->writeLE<Sint32>(pMissile->_miAnimWidth);
-	file->writeLE<Sint32>(pMissile->_miAnimWidth2);
-	file->writeLE<Sint32>(pMissile->_miAnimCnt);
-	file->writeLE<Sint32>(pMissile->_miAnimAdd);
-	file->writeLE<Sint32>(pMissile->_miAnimFrame);
-	file->writeLE<Uint32>(pMissile->_miDrawFlag);
-	file->writeLE<Uint32>(pMissile->_miLightFlag);
-	file->writeLE<Uint32>(pMissile->_miPreFlag);
-	file->writeLE<Uint32>(pMissile->_miUniqTrans);
-	file->writeLE<Sint32>(pMissile->_mirange);
-	file->writeLE<Sint32>(pMissile->_misource);
-	file->writeLE<Sint32>(pMissile->_micaster);
-	file->writeLE<Sint32>(pMissile->_midam);
-	file->writeLE<Uint32>(pMissile->_miHitFlag);
-	file->writeLE<Sint32>(pMissile->_midist);
-	file->writeLE<Sint32>(pMissile->_mlid);
-	file->writeLE<Sint32>(pMissile->_mirnd);
-	file->writeLE<Sint32>(pMissile->_miVar1);
-	file->writeLE<Sint32>(pMissile->_miVar2);
-	file->writeLE<Sint32>(pMissile->_miVar3);
-	file->writeLE<Sint32>(pMissile->_miVar4);
-	file->writeLE<Sint32>(pMissile->_miVar5);
-	file->writeLE<Sint32>(pMissile->_miVar6);
-	file->writeLE<Sint32>(pMissile->_miVar7);
-	file->writeLE<Sint32>(pMissile->_miVar8);
+	file->writeLE<int32_t>(pMissile->_miAnimDelay);
+	file->writeLE<int32_t>(pMissile->_miAnimLen);
+	file->writeLE<int32_t>(pMissile->_miAnimWidth);
+	file->writeLE<int32_t>(pMissile->_miAnimWidth2);
+	file->writeLE<int32_t>(pMissile->_miAnimCnt);
+	file->writeLE<int32_t>(pMissile->_miAnimAdd);
+	file->writeLE<int32_t>(pMissile->_miAnimFrame);
+	file->writeLE<uint32_t>(pMissile->_miDrawFlag);
+	file->writeLE<uint32_t>(pMissile->_miLightFlag);
+	file->writeLE<uint32_t>(pMissile->_miPreFlag);
+	file->writeLE<uint32_t>(pMissile->_miUniqTrans);
+	file->writeLE<int32_t>(pMissile->_mirange);
+	file->writeLE<int32_t>(pMissile->_misource);
+	file->writeLE<int32_t>(pMissile->_micaster);
+	file->writeLE<int32_t>(pMissile->_midam);
+	file->writeLE<uint32_t>(pMissile->_miHitFlag);
+	file->writeLE<int32_t>(pMissile->_midist);
+	file->writeLE<int32_t>(pMissile->_mlid);
+	file->writeLE<int32_t>(pMissile->_mirnd);
+	file->writeLE<int32_t>(pMissile->_miVar1);
+	file->writeLE<int32_t>(pMissile->_miVar2);
+	file->writeLE<int32_t>(pMissile->_miVar3);
+	file->writeLE<int32_t>(pMissile->_miVar4);
+	file->writeLE<int32_t>(pMissile->_miVar5);
+	file->writeLE<int32_t>(pMissile->_miVar6);
+	file->writeLE<int32_t>(pMissile->_miVar7);
+	file->writeLE<int32_t>(pMissile->_miVar8);
 }
 
 static void SaveObject(SaveHelper *file, int i)
 {
 	ObjectStruct *pObject = &object[i];
 
-	file->writeLE<Sint32>(pObject->_otype);
-	file->writeLE<Sint32>(pObject->_ox);
-	file->writeLE<Sint32>(pObject->_oy);
-	file->writeLE<Uint32>(pObject->_oLight);
-	file->writeLE<Uint32>(pObject->_oAnimFlag);
+	file->writeLE<int32_t>(pObject->_otype);
+	file->writeLE<int32_t>(pObject->_ox);
+	file->writeLE<int32_t>(pObject->_oy);
+	file->writeLE<uint32_t>(pObject->_oLight);
+	file->writeLE<uint32_t>(pObject->_oAnimFlag);
 	file->skip(4); // Skip pointer _oAnimData
-	file->writeLE<Sint32>(pObject->_oAnimDelay);
-	file->writeLE<Sint32>(pObject->_oAnimCnt);
-	file->writeLE<Sint32>(pObject->_oAnimLen);
-	file->writeLE<Sint32>(pObject->_oAnimFrame);
-	file->writeLE<Sint32>(pObject->_oAnimWidth);
-	file->writeLE<Sint32>(pObject->_oAnimWidth2);
-	file->writeLE<Uint32>(pObject->_oDelFlag);
-	file->writeLE<Sint8>(pObject->_oBreak);
+	file->writeLE<int32_t>(pObject->_oAnimDelay);
+	file->writeLE<int32_t>(pObject->_oAnimCnt);
+	file->writeLE<int32_t>(pObject->_oAnimLen);
+	file->writeLE<int32_t>(pObject->_oAnimFrame);
+	file->writeLE<int32_t>(pObject->_oAnimWidth);
+	file->writeLE<int32_t>(pObject->_oAnimWidth2);
+	file->writeLE<uint32_t>(pObject->_oDelFlag);
+	file->writeLE<int8_t>(pObject->_oBreak);
 	file->skip(3); // Alignment
-	file->writeLE<Uint32>(pObject->_oSolidFlag);
-	file->writeLE<Uint32>(pObject->_oMissFlag);
+	file->writeLE<uint32_t>(pObject->_oSolidFlag);
+	file->writeLE<uint32_t>(pObject->_oMissFlag);
 
-	file->writeLE<Sint8>(pObject->_oSelFlag);
+	file->writeLE<int8_t>(pObject->_oSelFlag);
 	file->skip(3); // Alignment
-	file->writeLE<Uint32>(pObject->_oPreFlag);
-	file->writeLE<Uint32>(pObject->_oTrapFlag);
-	file->writeLE<Uint32>(pObject->_oDoorFlag);
-	file->writeLE<Sint32>(pObject->_olid);
-	file->writeLE<Sint32>(pObject->_oRndSeed);
-	file->writeLE<Sint32>(pObject->_oVar1);
-	file->writeLE<Sint32>(pObject->_oVar2);
-	file->writeLE<Sint32>(pObject->_oVar3);
-	file->writeLE<Sint32>(pObject->_oVar4);
-	file->writeLE<Sint32>(pObject->_oVar5);
-	file->writeLE<Sint32>(pObject->_oVar6);
-	file->writeLE<Sint32>(pObject->_oVar7);
-	file->writeLE<Sint32>(pObject->_oVar8);
+	file->writeLE<uint32_t>(pObject->_oPreFlag);
+	file->writeLE<uint32_t>(pObject->_oTrapFlag);
+	file->writeLE<uint32_t>(pObject->_oDoorFlag);
+	file->writeLE<int32_t>(pObject->_olid);
+	file->writeLE<int32_t>(pObject->_oRndSeed);
+	file->writeLE<int32_t>(pObject->_oVar1);
+	file->writeLE<int32_t>(pObject->_oVar2);
+	file->writeLE<int32_t>(pObject->_oVar3);
+	file->writeLE<int32_t>(pObject->_oVar4);
+	file->writeLE<int32_t>(pObject->_oVar5);
+	file->writeLE<int32_t>(pObject->_oVar6);
+	file->writeLE<int32_t>(pObject->_oVar7);
+	file->writeLE<int32_t>(pObject->_oVar8);
 }
 
 static void SavePremium(SaveHelper *file, int i)
@@ -1695,61 +1695,61 @@ static void SaveQuest(SaveHelper *file, int i)
 {
 	QuestStruct *pQuest = &quests[i];
 
-	file->writeLE<Uint8>(pQuest->_qlevel);
-	file->writeLE<Uint8>(pQuest->_qtype);
-	file->writeLE<Uint8>(pQuest->_qactive);
-	file->writeLE<Uint8>(pQuest->_qlvltype);
-	file->writeLE<Sint32>(pQuest->_qtx);
-	file->writeLE<Sint32>(pQuest->_qty);
-	file->writeLE<Uint8>(pQuest->_qslvl);
-	file->writeLE<Uint8>(pQuest->_qidx);
+	file->writeLE<uint8_t>(pQuest->_qlevel);
+	file->writeLE<uint8_t>(pQuest->_qtype);
+	file->writeLE<uint8_t>(pQuest->_qactive);
+	file->writeLE<uint8_t>(pQuest->_qlvltype);
+	file->writeLE<int32_t>(pQuest->_qtx);
+	file->writeLE<int32_t>(pQuest->_qty);
+	file->writeLE<uint8_t>(pQuest->_qslvl);
+	file->writeLE<uint8_t>(pQuest->_qidx);
 	if (gbIsHellfire) {
 		file->skip(2); // Alignment
-		file->writeLE<Sint32>(pQuest->_qmsg);
+		file->writeLE<int32_t>(pQuest->_qmsg);
 	} else {
-		file->writeLE<Uint8>(pQuest->_qmsg);
+		file->writeLE<uint8_t>(pQuest->_qmsg);
 	}
-	file->writeLE<Uint8>(pQuest->_qvar1);
-	file->writeLE<Uint8>(pQuest->_qvar2);
+	file->writeLE<uint8_t>(pQuest->_qvar1);
+	file->writeLE<uint8_t>(pQuest->_qvar2);
 	file->skip(2); // Alignment
 	if (!gbIsHellfire)
 		file->skip(1); // Alignment
-	file->writeLE<Uint32>(pQuest->_qlog);
+	file->writeLE<uint32_t>(pQuest->_qlog);
 
-	file->writeBE<Sint32>(ReturnLvlX);
-	file->writeBE<Sint32>(ReturnLvlY);
-	file->writeBE<Sint32>(ReturnLvl);
-	file->writeBE<Sint32>(ReturnLvlT);
-	file->writeBE<Sint32>(DoomQuestState);
+	file->writeBE<int32_t>(ReturnLvlX);
+	file->writeBE<int32_t>(ReturnLvlY);
+	file->writeBE<int32_t>(ReturnLvl);
+	file->writeBE<int32_t>(ReturnLvlT);
+	file->writeBE<int32_t>(DoomQuestState);
 }
 
 static void SaveLighting(SaveHelper *file, LightListStruct *pLight)
 {
-	file->writeLE<Sint32>(pLight->_lx);
-	file->writeLE<Sint32>(pLight->_ly);
-	file->writeLE<Sint32>(pLight->_lradius);
-	file->writeLE<Sint32>(pLight->_lid);
-	file->writeLE<Uint32>(pLight->_ldel);
-	file->writeLE<Uint32>(pLight->_lunflag);
+	file->writeLE<int32_t>(pLight->_lx);
+	file->writeLE<int32_t>(pLight->_ly);
+	file->writeLE<int32_t>(pLight->_lradius);
+	file->writeLE<int32_t>(pLight->_lid);
+	file->writeLE<uint32_t>(pLight->_ldel);
+	file->writeLE<uint32_t>(pLight->_lunflag);
 	file->skip(4); // Unused
-	file->writeLE<Sint32>(pLight->_lunx);
-	file->writeLE<Sint32>(pLight->_luny);
-	file->writeLE<Sint32>(pLight->_lunr);
-	file->writeLE<Sint32>(pLight->_xoff);
-	file->writeLE<Sint32>(pLight->_yoff);
-	file->writeLE<Uint32>(pLight->_lflags);
+	file->writeLE<int32_t>(pLight->_lunx);
+	file->writeLE<int32_t>(pLight->_luny);
+	file->writeLE<int32_t>(pLight->_lunr);
+	file->writeLE<int32_t>(pLight->_xoff);
+	file->writeLE<int32_t>(pLight->_yoff);
+	file->writeLE<uint32_t>(pLight->_lflags);
 }
 
 static void SavePortal(SaveHelper *file, int i)
 {
 	PortalStruct *pPortal = &portal[i];
 
-	file->writeLE<Uint32>(pPortal->open);
-	file->writeLE<Sint32>(pPortal->x);
-	file->writeLE<Sint32>(pPortal->y);
-	file->writeLE<Sint32>(pPortal->level);
-	file->writeLE<Sint32>(pPortal->ltype);
-	file->writeLE<Uint32>(pPortal->setlvl);
+	file->writeLE<uint32_t>(pPortal->open);
+	file->writeLE<int32_t>(pPortal->x);
+	file->writeLE<int32_t>(pPortal->y);
+	file->writeLE<int32_t>(pPortal->level);
+	file->writeLE<int32_t>(pPortal->ltype);
+	file->writeLE<uint32_t>(pPortal->setlvl);
 }
 
 const int DiabloItemSaveSize = 368;
@@ -1758,9 +1758,9 @@ const int HellfireItemSaveSize = 372;
 void SaveHeroItems(PlayerStruct *pPlayer)
 {
 	size_t items = NUM_INVLOC + NUM_INV_GRID_ELEM + MAXBELTITEMS;
-	SaveHelper file("heroitems", items * (gbIsHellfire ? HellfireItemSaveSize : DiabloItemSaveSize) + sizeof(Uint8));
+	SaveHelper file("heroitems", items * (gbIsHellfire ? HellfireItemSaveSize : DiabloItemSaveSize) + sizeof(uint8_t));
 
-	file.writeLE<Uint8>(gbIsHellfire);
+	file.writeLE<uint8_t>(gbIsHellfire);
 
 	SaveItems(&file, pPlayer->InvBody, NUM_INVLOC);
 	SaveItems(&file, pPlayer->InvList, NUM_INV_GRID_ELEM);
@@ -1776,13 +1776,13 @@ void SaveGameData()
 	SaveHelper file("game", FILEBUFF);
 
 	if (gbIsSpawn && !gbIsHellfire)
-		file.writeLE<Uint32>(LOAD_LE32("SHAR"));
+		file.writeLE<uint32_t>(LOAD_LE32("SHAR"));
 	else if (gbIsSpawn && gbIsHellfire)
-		file.writeLE<Uint32>(LOAD_LE32("SHLF"));
+		file.writeLE<uint32_t>(LOAD_LE32("SHLF"));
 	else if (!gbIsSpawn && gbIsHellfire)
-		file.writeLE<Uint32>(LOAD_LE32("HELF"));
+		file.writeLE<uint32_t>(LOAD_LE32("HELF"));
 	else if (!gbIsSpawn && !gbIsHellfire)
-		file.writeLE<Uint32>(LOAD_LE32("RETL"));
+		file.writeLE<uint32_t>(LOAD_LE32("RETL"));
 	else
 		app_fatal("Invalid game state");
 
@@ -1796,22 +1796,22 @@ void SaveGameData()
 		giNumberOfSmithPremiumItems = 6;
 	}
 
-	file.writeLE<Uint8>(setlevel);
-	file.writeBE<Uint32>(setlvlnum);
-	file.writeBE<Uint32>(currlevel);
-	file.writeBE<Uint32>(leveltype);
-	file.writeBE<Sint32>(ViewX);
-	file.writeBE<Sint32>(ViewY);
-	file.writeLE<Uint8>(invflag);
-	file.writeLE<Uint8>(chrflag);
-	file.writeBE<Sint32>(nummonsters);
-	file.writeBE<Sint32>(numitems);
-	file.writeBE<Sint32>(nummissiles);
-	file.writeBE<Sint32>(nobjects);
+	file.writeLE<uint8_t>(setlevel);
+	file.writeBE<uint32_t>(setlvlnum);
+	file.writeBE<uint32_t>(currlevel);
+	file.writeBE<uint32_t>(leveltype);
+	file.writeBE<int32_t>(ViewX);
+	file.writeBE<int32_t>(ViewY);
+	file.writeLE<uint8_t>(invflag);
+	file.writeLE<uint8_t>(chrflag);
+	file.writeBE<int32_t>(nummonsters);
+	file.writeBE<int32_t>(numitems);
+	file.writeBE<int32_t>(nummissiles);
+	file.writeBE<int32_t>(nobjects);
 
 	for (uint8_t i = 0; i < giNumberOfLevels; i++) {
-		file.writeBE<Uint32>(glSeedTbl[i]);
-		file.writeBE<Sint32>(gnLevelTypeTbl[i]);
+		file.writeBE<uint32_t>(glSeedTbl[i]);
+		file.writeBE<int32_t>(gnLevelTypeTbl[i]);
 	}
 
 	plr[myplr].pDifficulty = sgGameInitInfo.nDifficulty;
@@ -1822,105 +1822,105 @@ void SaveGameData()
 	for (int i = 0; i < MAXPORTAL; i++)
 		SavePortal(&file, i);
 	for (int monstkill : monstkills)
-		file.writeBE<Sint32>(monstkill);
+		file.writeBE<int32_t>(monstkill);
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int monsterId : monstactive)
-			file.writeBE<Sint32>(monsterId);
+			file.writeBE<int32_t>(monsterId);
 		for (int i = 0; i < nummonsters; i++)
 			SaveMonster(&file, monstactive[i]);
 		for (int missileId : missileactive)
-			file.writeLE<Sint8>(missileId);
+			file.writeLE<int8_t>(missileId);
 		for (int missileId : missileavail)
-			file.writeLE<Sint8>(missileId);
+			file.writeLE<int8_t>(missileId);
 		for (int i = 0; i < nummissiles; i++)
 			SaveMissile(&file, missileactive[i]);
 		for (int objectId : objectactive)
-			file.writeLE<Sint8>(objectId);
+			file.writeLE<int8_t>(objectId);
 		for (int objectId : objectavail)
-			file.writeLE<Sint8>(objectId);
+			file.writeLE<int8_t>(objectId);
 		for (int i = 0; i < nobjects; i++)
 			SaveObject(&file, objectactive[i]);
 
-		file.writeBE<Sint32>(numlights);
+		file.writeBE<int32_t>(numlights);
 
 		for (uint8_t lightId : lightactive)
 			file.writeLE<uint8_t>(lightId);
 		for (int i = 0; i < numlights; i++)
 			SaveLighting(&file, &LightList[lightactive[i]]);
 
-		file.writeBE<Sint32>(visionid);
-		file.writeBE<Sint32>(numvision);
+		file.writeBE<int32_t>(visionid);
+		file.writeBE<int32_t>(numvision);
 
 		for (int i = 0; i < numvision; i++)
 			SaveLighting(&file, &VisionList[i]);
 	}
 
 	for (int itemId : itemactive)
-		file.writeLE<Sint8>(itemId);
+		file.writeLE<int8_t>(itemId);
 	for (int itemId : itemavail)
-		file.writeLE<Sint8>(itemId);
+		file.writeLE<int8_t>(itemId);
 	for (int i = 0; i < numitems; i++)
 		SaveItem(&file, &items[itemactive[i]]);
 	for (bool UniqueItemFlag : UniqueItemFlags)
-		file.writeLE<Sint8>(UniqueItemFlag);
+		file.writeLE<int8_t>(UniqueItemFlag);
 
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			file.writeLE<Sint8>(dLight[i][j]);
+			file.writeLE<int8_t>(dLight[i][j]);
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			file.writeLE<Sint8>(dFlags[i][j] & ~(BFLAG_MISSILE | BFLAG_VISIBLE | BFLAG_DEAD_PLAYER));
+			file.writeLE<int8_t>(dFlags[i][j] & ~(BFLAG_MISSILE | BFLAG_VISIBLE | BFLAG_DEAD_PLAYER));
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			file.writeLE<Sint8>(dPlayer[i][j]);
+			file.writeLE<int8_t>(dPlayer[i][j]);
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			file.writeLE<Sint8>(dItem[i][j]);
+			file.writeLE<int8_t>(dItem[i][j]);
 	}
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeBE<Sint32>(dMonster[i][j]);
+				file.writeBE<int32_t>(dMonster[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dDead[i][j]);
+				file.writeLE<int8_t>(dDead[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dObject[i][j]);
+				file.writeLE<int8_t>(dObject[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dLight[i][j]);
+				file.writeLE<int8_t>(dLight[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dPreLight[i][j]);
+				file.writeLE<int8_t>(dPreLight[i][j]);
 		}
 		for (int j = 0; j < DMAXY; j++) {
 			for (int i = 0; i < DMAXX; i++)
-				file.writeLE<Uint8>(automapview[i][j]);
+				file.writeLE<uint8_t>(automapview[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dMissile[i][j]);
+				file.writeLE<int8_t>(dMissile[i][j]);
 		}
 	}
 
-	file.writeBE<Sint32>(numpremium);
-	file.writeBE<Sint32>(premiumlevel);
+	file.writeBE<int32_t>(numpremium);
+	file.writeBE<int32_t>(premiumlevel);
 
 	for (int i = 0; i < giNumberOfSmithPremiumItems; i++)
 		SavePremium(&file, i);
 
-	file.writeLE<Uint8>(automapflag);
-	file.writeBE<Sint32>(AutoMapScale);
+	file.writeLE<uint8_t>(automapflag);
+	file.writeBE<int32_t>(AutoMapScale);
 }
 
 void SaveGame()
@@ -1945,68 +1945,68 @@ void SaveLevel()
 	if (leveltype != DTYPE_TOWN) {
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dDead[i][j]);
+				file.writeLE<int8_t>(dDead[i][j]);
 		}
 	}
 
-	file.writeBE<Sint32>(nummonsters);
-	file.writeBE<Sint32>(numitems);
-	file.writeBE<Sint32>(nobjects);
+	file.writeBE<int32_t>(nummonsters);
+	file.writeBE<int32_t>(numitems);
+	file.writeBE<int32_t>(nobjects);
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int monsterId : monstactive)
-			file.writeBE<Sint32>(monsterId);
+			file.writeBE<int32_t>(monsterId);
 		for (int i = 0; i < nummonsters; i++)
 			SaveMonster(&file, monstactive[i]);
 		for (int objectId : objectactive)
-			file.writeLE<Sint8>(objectId);
+			file.writeLE<int8_t>(objectId);
 		for (int objectId : objectavail)
-			file.writeLE<Sint8>(objectId);
+			file.writeLE<int8_t>(objectId);
 		for (int i = 0; i < nobjects; i++)
 			SaveObject(&file, objectactive[i]);
 	}
 
 	for (int itemId : itemactive)
-		file.writeLE<Sint8>(itemId);
+		file.writeLE<int8_t>(itemId);
 	for (int itemId : itemavail)
-		file.writeLE<Sint8>(itemId);
+		file.writeLE<int8_t>(itemId);
 
 	for (int i = 0; i < numitems; i++)
 		SaveItem(&file, &items[itemactive[i]]);
 
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			file.writeLE<Sint8>(dFlags[i][j] & ~(BFLAG_MISSILE | BFLAG_VISIBLE | BFLAG_DEAD_PLAYER));
+			file.writeLE<int8_t>(dFlags[i][j] & ~(BFLAG_MISSILE | BFLAG_VISIBLE | BFLAG_DEAD_PLAYER));
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			file.writeLE<Sint8>(dItem[i][j]);
+			file.writeLE<int8_t>(dItem[i][j]);
 	}
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeBE<Sint32>(dMonster[i][j]);
+				file.writeBE<int32_t>(dMonster[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dObject[i][j]);
+				file.writeLE<int8_t>(dObject[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dLight[i][j]);
+				file.writeLE<int8_t>(dLight[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dPreLight[i][j]);
+				file.writeLE<int8_t>(dPreLight[i][j]);
 		}
 		for (int j = 0; j < DMAXY; j++) {
 			for (int i = 0; i < DMAXX; i++)
-				file.writeLE<Uint8>(automapview[i][j]);
+				file.writeLE<uint8_t>(automapview[i][j]);
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				file.writeLE<Sint8>(dMissile[i][j]);
+				file.writeLE<int8_t>(dMissile[i][j]);
 		}
 	}
 
@@ -2027,24 +2027,24 @@ void LoadLevel()
 	if (leveltype != DTYPE_TOWN) {
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dDead[i][j] = file.nextLE<Sint8>();
+				dDead[i][j] = file.nextLE<int8_t>();
 		}
 		SetDead();
 	}
 
-	nummonsters = file.nextBE<Sint32>();
-	numitems = file.nextBE<Sint32>();
-	nobjects = file.nextBE<Sint32>();
+	nummonsters = file.nextBE<int32_t>();
+	numitems = file.nextBE<int32_t>();
+	nobjects = file.nextBE<int32_t>();
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int &monsterId : monstactive)
-			monsterId = file.nextBE<Sint32>();
+			monsterId = file.nextBE<int32_t>();
 		for (int i = 0; i < nummonsters; i++)
 			LoadMonster(&file, monstactive[i]);
 		for (int &objectId : objectactive)
-			objectId = file.nextLE<Sint8>();
+			objectId = file.nextLE<int8_t>();
 		for (int &objectId : objectavail)
-			objectId = file.nextLE<Sint8>();
+			objectId = file.nextLE<int8_t>();
 		for (int i = 0; i < nobjects; i++)
 			LoadObject(&file, objectactive[i]);
 		if (!gbSkipSync) {
@@ -2054,37 +2054,37 @@ void LoadLevel()
 	}
 
 	for (int &itemId : itemactive)
-		itemId = file.nextLE<Sint8>();
+		itemId = file.nextLE<int8_t>();
 	for (int &itemId : itemavail)
-		itemId = file.nextLE<Sint8>();
+		itemId = file.nextLE<int8_t>();
 	for (int i = 0; i < numitems; i++)
 		LoadItem(&file, itemactive[i]);
 
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			dFlags[i][j] = file.nextLE<Sint8>();
+			dFlags[i][j] = file.nextLE<int8_t>();
 	}
 	for (int j = 0; j < MAXDUNY; j++) {
 		for (int i = 0; i < MAXDUNX; i++)
-			dItem[i][j] = file.nextLE<Sint8>();
+			dItem[i][j] = file.nextLE<int8_t>();
 	}
 
 	if (leveltype != DTYPE_TOWN) {
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dMonster[i][j] = file.nextBE<Sint32>();
+				dMonster[i][j] = file.nextBE<int32_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dObject[i][j] = file.nextLE<Sint8>();
+				dObject[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dLight[i][j] = file.nextLE<Sint8>();
+				dLight[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dPreLight[i][j] = file.nextLE<Sint8>();
+				dPreLight[i][j] = file.nextLE<int8_t>();
 		}
 		for (int j = 0; j < DMAXY; j++) {
 			for (int i = 0; i < DMAXX; i++)
@@ -2092,7 +2092,7 @@ void LoadLevel()
 		}
 		for (int j = 0; j < MAXDUNY; j++) {
 			for (int i = 0; i < MAXDUNX; i++)
-				dMissile[i][j] = 0; /// BUGFIX: supposed to load saved missiles with "file.nextLE<Sint8>()"?
+				dMissile[i][j] = 0; /// BUGFIX: supposed to load saved missiles with "file.nextLE<int8_t>()"?
 		}
 	}
 
diff --git a/Source/loadsave.h b/Source/loadsave.h
index 9d0f53f3..8207b819 100644
--- a/Source/loadsave.h
+++ b/Source/loadsave.h
@@ -15,7 +15,7 @@ extern uint8_t giNumberOfLevels;
 void RemoveInvalidItem(ItemStruct *pItem);
 int RemapItemIdxFromDiablo(int i);
 int RemapItemIdxToDiablo(int i);
-bool IsHeaderValid(Uint32 magicNumber);
+bool IsHeaderValid(uint32_t magicNumber);
 void LoadHotkeys();
 void LoadHeroItems(PlayerStruct *pPlayer);
 /**
diff --git a/Source/minitext.cpp b/Source/minitext.cpp
index 94dd11dc..3e83be05 100644
--- a/Source/minitext.cpp
+++ b/Source/minitext.cpp
@@ -23,12 +23,12 @@ int qtextSpd;
 /** Time of last rendering of the text */
 Uint32 sgLastScroll;
 /** Graphics for the medium size font */
-Uint8 *pMedTextCels;
+BYTE *pMedTextCels;
 /** Graphics for the window border */
-Uint8 *pTextBoxCels;
+BYTE *pTextBoxCels;
 
 /** Maps from font index to medtexts.cel frame number. */
-const Uint8 mfontframe[128] = {
+const uint8_t mfontframe[128] = {
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -48,7 +48,7 @@ const Uint8 mfontframe[128] = {
  * character width may be distinct from the frame width, which is 22 for every
  * medtexts.cel frame.
  */
-const Uint8 mfontkern[56] = {
+const uint8_t mfontkern[56] = {
 	5, 15, 10, 13, 14, 10, 9, 13, 11, 5,
 	5, 11, 10, 16, 13, 16, 10, 15, 12, 10,
 	14, 17, 17, 22, 17, 16, 11, 5, 11, 11,
@@ -72,7 +72,7 @@ bool BuildLine(const char *text, char line[128])
 	int l = 0;
 
 	while (*text != '\n' && *text != '|' && lineWidth < 543) {
-		Uint8 c = gbFontTransTbl[(Uint8)*text];
+		uint8_t c = gbFontTransTbl[(uint8_t)*text];
 		text++;
 		if (c != '\0') {
 			line[l] = c;
@@ -126,7 +126,8 @@ int GetLinesInText(const char *text)
  */
 int CalcTextSpeed(int nSFX)
 {
-	Uint32 SfxFrames, TextHeight;
+	int TextHeight;
+	Uint32 SfxFrames;
 
 	SfxFrames = GetSFXLength(nSFX);
 	assert(SfxFrames != 0);
@@ -144,7 +145,7 @@ int CalcTextSpeed(int nSFX)
  * @param pCelBuff Cel data
  * @param nCel CEL frame number
  */
-void PrintQTextChr(int sx, int sy, Uint8 *pCelBuff, int nCel)
+void PrintQTextChr(int sx, int sy, BYTE *pCelBuff, int nCel)
 {
 	CelOutputBuffer buf = GlobalBackBuffer();
 	const int start_y = 49 + UI_OFFSET_Y;
@@ -190,7 +191,7 @@ static void DrawQTextContent()
 		doneflag = BuildLine(text, line);
 		for (int i = 0; line[i]; i++) {
 			text++;
-			Uint8 c = mfontframe[gbFontTransTbl[(Uint8)line[i]]];
+			uint8_t c = mfontframe[gbFontTransTbl[(uint8_t)line[i]]];
 			if (*text == '\n') {
 				text++;
 			}
diff --git a/Source/misdat.h b/Source/misdat.h
index 9ef7d89b..f51b2b69 100644
--- a/Source/misdat.h
+++ b/Source/misdat.h
@@ -89,27 +89,27 @@ typedef enum missile_graphic_id : uint8_t {
 } missile_graphic_id;
 
 typedef struct MissileData {
-	void (*mAddProc)(Sint32, Sint32, Sint32, Sint32, Sint32, Sint32, Sint8, Sint32, Sint32);
-	void (*mProc)(Sint32);
-	Uint8 mName;
+	void (*mAddProc)(int, int, int, int, int, int, int8_t, int, int);
+	void (*mProc)(int);
+	uint8_t mName;
 	bool mDraw;
-	Uint8 mType;
+	uint8_t mType;
 	missile_resistance mResist;
-	Uint8 mFileNum;
+	uint8_t mFileNum;
 	_sfx_id mlSFX;
 	_sfx_id miSFX;
 } MissileData;
 
 typedef struct MisFileData {
 	const char *mName;
-	Uint8 mAnimName;
-	Uint8 mAnimFAmt;
-	Sint32 mFlags;
-	Uint8 *mAnimData[16];
-	Uint8 mAnimDelay[16];
-	Uint8 mAnimLen[16];
-	Sint16 mAnimWidth[16];
-	Sint16 mAnimWidth2[16];
+	uint8_t mAnimName;
+	uint8_t mAnimFAmt;
+	uint32_t mFlags;
+	BYTE *mAnimData[16];
+	uint8_t mAnimDelay[16];
+	uint8_t mAnimLen[16];
+	int16_t mAnimWidth[16];
+	int16_t mAnimWidth2[16];
 } MisFileData;
 
 extern MissileData missiledata[];
diff --git a/Source/missiles.cpp b/Source/missiles.cpp
index 2738037c..a20eae8e 100644
--- a/Source/missiles.cpp
+++ b/Source/missiles.cpp
@@ -1262,7 +1262,7 @@ void InitMissiles()
 	plr[myplr].wReflections = 0;
 }
 
-void AddHiveExplosion(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddHiveExplosion(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	AddMissile(80, 62, 80, 62, midir, MIS_HIVEEXP, mienemy, id, dam, 0);
 	AddMissile(80, 63, 80, 62, midir, MIS_HIVEEXP, mienemy, id, dam, 0);
@@ -1271,7 +1271,7 @@ void AddHiveExplosion(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sin
 	missile[mi]._miDelFlag = true;
 }
 
-static bool missiles_found_target(Sint32 mi, Sint32 *x, Sint32 *y, Sint32 rad)
+static bool missiles_found_target(int mi, int *x, int *y, int rad)
 {
 	int i, j, k, tx, ty, dp;
 
@@ -1304,7 +1304,7 @@ static bool missiles_found_target(Sint32 mi, Sint32 *x, Sint32 *y, Sint32 rad)
 	return found;
 }
 
-void AddFireRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFireRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (LineClearMissile(sx, sy, dx, dy)) {
 		if (id >= 0)
@@ -1321,7 +1321,7 @@ void AddFireRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	}
 }
 
-void AddLightningRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLightningRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (LineClearMissile(sx, sy, dx, dy)) {
 		if (id >= 0)
@@ -1338,7 +1338,7 @@ void AddLightningRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sin
 	}
 }
 
-void AddGreatLightningRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddGreatLightningRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (LineClearMissile(sx, sy, dx, dy)) {
 		if (id >= 0)
@@ -1355,7 +1355,7 @@ void AddGreatLightningRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy
 	}
 }
 
-void AddImmolationRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddImmolationRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (LineClearMissile(sx, sy, dx, dy)) {
 		if (id >= 0)
@@ -1372,7 +1372,7 @@ void AddImmolationRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Si
 	}
 }
 
-void AddStoneRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddStoneRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (LineClearMissile(sx, sy, dx, dy)) {
 		if (id >= 0)
@@ -1389,7 +1389,7 @@ void AddStoneRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	}
 }
 
-void AddReflection(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddReflection(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int lvl;
 
@@ -1405,7 +1405,7 @@ void AddReflection(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._miDelFlag = false;
 }
 
-void AddBerserk(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBerserk(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, j, k, tx, ty, dm, r;
 
@@ -1451,7 +1451,7 @@ void AddBerserk(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 	missile[mi]._miDelFlag = true;
 }
 
-void AddHorkSpawn(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddHorkSpawn(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	GetMissileVel(mi, sx, sy, dx, dy, 8);
 	missile[mi]._mirange = 9;
@@ -1459,7 +1459,7 @@ void AddHorkSpawn(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	PutMissile(mi);
 }
 
-void AddJester(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddJester(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int spell;
 
@@ -1500,7 +1500,7 @@ void AddJester(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	missile[mi]._mirange = 0;
 }
 
-void AddStealPotions(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddStealPotions(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, l, k, j, tx, ty, si, ii, pnum;
 	bool hasPlayedSFX;
@@ -1579,7 +1579,7 @@ void AddStealPotions(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint
 	missile[mi]._miDelFlag = true;
 }
 
-void AddManaTrap(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddManaTrap(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, pn, k, j, tx, ty, pid;
 
@@ -1611,7 +1611,7 @@ void AddManaTrap(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	missile[mi]._miDelFlag = true;
 }
 
-void AddSpecArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddSpecArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int av;
 
@@ -1637,7 +1637,7 @@ void AddSpecArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._miVar3 = av;
 }
 
-void AddWarp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddWarp(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int tx, ty, fx, fy, i, dist;
 	TriggerStruct *trg;
@@ -1678,7 +1678,7 @@ void AddWarp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 		UseMana(id, SPL_WARP);
 }
 
-void AddLightningWall(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLightningWall(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	GetMissileVel(mi, sx, sy, dx, dy, 16);
 	missile[mi]._midam = dam;
@@ -1693,7 +1693,7 @@ void AddLightningWall(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sin
 	}
 }
 
-void AddRuneExplosion(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRuneExplosion(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, dmg;
 
@@ -1720,7 +1720,7 @@ void AddRuneExplosion(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sin
 	missile[mi]._mirange = missile[mi]._miAnimLen - 1;
 }
 
-void AddImmolation(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddImmolation(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -1753,7 +1753,7 @@ void AddImmolation(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._mlid = AddLight(sx, sy, 8);
 }
 
-void AddFireNova(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFireNova(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -1780,7 +1780,7 @@ void AddFireNova(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	missile[mi]._mlid = AddLight(sx, sy, 8);
 }
 
-void AddLightningArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLightningArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (sx == dx && sy == dy) {
 		dx += XDirAdd[midir];
@@ -1799,7 +1799,7 @@ void AddLightningArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Si
 	missile[mi]._midam <<= 6;
 }
 
-void AddMana(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddMana(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, ManaAmount;
 
@@ -1825,7 +1825,7 @@ void AddMana(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	drawmanaflag = true;
 }
 
-void AddMagi(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddMagi(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	plr[id]._pMana = plr[id]._pMaxMana;
 	plr[id]._pManaBase = plr[id]._pMaxManaBase;
@@ -1834,7 +1834,7 @@ void AddMagi(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	drawmanaflag = true;
 }
 
-void AddRing(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRing(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	if (mienemy == TARGET_MONSTERS)
@@ -1851,7 +1851,7 @@ void AddRing(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	missile[mi]._mirange = 7;
 }
 
-void AddSearch(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddSearch(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, mx, r1, r2;
 	MissileStruct *mis;
@@ -1889,7 +1889,7 @@ void AddSearch(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	}
 }
 
-void AddCboltArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddCboltArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (mienemy == TARGET_MONSTERS) {
 		if (id == myplr) {
@@ -1914,7 +1914,7 @@ void AddCboltArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._mirange = 256;
 }
 
-void AddLArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (sx == dx && sy == dy) {
 		dx += XDirAdd[midir];
@@ -1953,7 +1953,7 @@ void AddLArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	missile[mi]._mlid = AddLight(sx, sy, 5);
 }
 
-void AddArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int av;
 
@@ -2009,7 +2009,7 @@ void GetVileMissPos(int mi, int dx, int dy)
 	missile[mi]._miy = dy;
 }
 
-void AddRndTeleport(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRndTeleport(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int pn, r1, r2, nTries;
 
@@ -2054,7 +2054,7 @@ void AddRndTeleport(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint3
 	}
 }
 
-void AddFirebolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 micaster, Sint32 id, Sint32 dam)
+void AddFirebolt(int mi, int sx, int sy, int dx, int dy, int midir, int8_t micaster, int id, int dam)
 {
 	int i, mx, sp;
 
@@ -2088,7 +2088,7 @@ void AddFirebolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	missile[mi]._mlid = AddLight(sx, sy, 8);
 }
 
-void AddMagmaball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddMagmaball(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	GetMissileVel(mi, sx, sy, dx, dy, 16);
 	missile[mi]._mitxoff += 3 * missile[mi]._mixvel;
@@ -2103,7 +2103,7 @@ void AddMagmaball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._mlid = AddLight(sx, sy, 8);
 }
 
-void AddKrull(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddKrull(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	GetMissileVel(mi, sx, sy, dx, dy, 16);
 	missile[mi]._mirange = 256;
@@ -2112,7 +2112,7 @@ void AddKrull(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	PutMissile(mi);
 }
 
-void AddTeleport(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddTeleport(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, pn, k, j, tx, ty;
 
@@ -2144,7 +2144,7 @@ void AddTeleport(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	}
 }
 
-void AddLightball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLightball(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	GetMissileVel(mi, sx, sy, dx, dy, 16);
 	missile[mi]._midam = dam;
@@ -2159,7 +2159,7 @@ void AddLightball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	}
 }
 
-void AddFirewall(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFirewall(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2180,7 +2180,7 @@ void AddFirewall(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	missile[mi]._miVar2 = 0;
 }
 
-void AddFireball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFireball(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2211,7 +2211,7 @@ void AddFireball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	missile[mi]._mlid = AddLight(sx, sy, 8);
 }
 
-void AddLightctrl(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLightctrl(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (!dam && mienemy == TARGET_MONSTERS)
 		UseMana(id, SPL_LIGHTNING);
@@ -2222,7 +2222,7 @@ void AddLightctrl(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._mirange = 256;
 }
 
-void AddLightning(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddLightning(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._misx = dx;
 	missile[mi]._misy = dy;
@@ -2245,7 +2245,7 @@ void AddLightning(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._mlid = AddLight(missile[mi]._mix, missile[mi]._miy, 4);
 }
 
-void AddMisexp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddMisexp(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (mienemy && id > 0) {
 		switch (monster[id].MType->mtype) {
@@ -2280,7 +2280,7 @@ void AddMisexp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	missile[mi]._miVar1 = 0;
 }
 
-void AddWeapexp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddWeapexp(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._mix = sx;
 	missile[mi]._miy = sy;
@@ -2309,7 +2309,7 @@ bool CheckIfTrig(int x, int y)
 	return false;
 }
 
-void AddTown(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddTown(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, j, k, mx, tx, ty, dp;
 
@@ -2364,7 +2364,7 @@ void AddTown(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	}
 }
 
-void AddFlash(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFlash(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2388,7 +2388,7 @@ void AddFlash(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	missile[mi]._mirange = 19;
 }
 
-void AddFlash2(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFlash2(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2410,7 +2410,7 @@ void AddFlash2(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	missile[mi]._mirange = 19;
 }
 
-void AddManashield(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddManashield(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._mirange = 48 * plr[id]._pLevel;
 	if (mienemy == TARGET_MONSTERS)
@@ -2420,7 +2420,7 @@ void AddManashield(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	plr[id].pManaShield = true;
 }
 
-void AddFiremove(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFiremove(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._midam = GenerateRnd(10) + plr[id]._pLevel + 1;
 	GetMissileVel(mi, sx, sy, dx, dy, 16);
@@ -2432,7 +2432,7 @@ void AddFiremove(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	missile[mi]._miyoff -= 32;
 }
 
-void AddGuardian(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddGuardian(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, pn, k, j, tx, ty;
 
@@ -2485,7 +2485,7 @@ void AddGuardian(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	}
 }
 
-void AddChain(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddChain(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miVar1 = dx;
 	missile[mi]._miVar2 = dy;
@@ -2493,7 +2493,7 @@ void AddChain(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	UseMana(id, SPL_CHAIN);
 }
 
-void AddBloodStar(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBloodStar(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	SetMissDir(mi, dx);
 	missile[mi]._midam = 0;
@@ -2501,7 +2501,7 @@ void AddBloodStar(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._mirange = 250;
 }
 
-void AddBone(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBone(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (dx > 3)
 		dx = 2;
@@ -2511,7 +2511,7 @@ void AddBone(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	missile[mi]._mirange = 250;
 }
 
-void AddMetlHit(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddMetlHit(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (dx > 3)
 		dx = 2;
@@ -2521,7 +2521,7 @@ void AddMetlHit(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 	missile[mi]._mirange = missile[mi]._miAnimLen;
 }
 
-void AddRhino(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRhino(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	AnimStruct *anim;
 
@@ -2556,7 +2556,7 @@ void AddRhino(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	PutMissile(mi);
 }
 
-void AddFireman(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFireman(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	AnimStruct *anim;
 	MonsterStruct *mon;
@@ -2582,7 +2582,7 @@ void AddFireman(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 	PutMissile(mi);
 }
 
-void AddFlare(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFlare(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (sx == dx && sy == dy) {
 		dx += XDirAdd[midir];
@@ -2614,7 +2614,7 @@ void AddFlare(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	}
 }
 
-void AddAcid(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddAcid(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	GetMissileVel(mi, sx, sy, dx, dy, 16);
 	SetMissDir(mi, GetDirection16(sx, sy, dx, dy));
@@ -2628,7 +2628,7 @@ void AddAcid(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	PutMissile(mi);
 }
 
-void AddFireWallA(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFireWallA(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._midam = dam;
 	missile[mi]._mixvel = 0;
@@ -2638,7 +2638,7 @@ void AddFireWallA(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._miVar2 = 0;
 }
 
-void AddAcidpud(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddAcidpud(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int monst;
 
@@ -2652,7 +2652,7 @@ void AddAcidpud(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 	missile[mi]._miPreFlag = true;
 }
 
-void AddStone(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddStone(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, j, k, l, tx, ty, mid;
 
@@ -2698,7 +2698,7 @@ void AddStone(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	}
 }
 
-void AddGolem(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddGolem(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 	int mx;
@@ -2722,7 +2722,7 @@ void AddGolem(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	UseMana(id, SPL_GOLEM);
 }
 
-void AddEtherealize(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddEtherealize(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2737,12 +2737,12 @@ void AddEtherealize(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint3
 		UseMana(id, SPL_ETHEREALIZE);
 }
 
-void AddDummy(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddDummy(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 }
 
-void AddBlodbur(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBlodbur(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._midam = dam;
 	missile[mi]._mix = sx;
@@ -2758,7 +2758,7 @@ void AddBlodbur(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 	missile[mi]._mirange = missile[mi]._miAnimLen;
 }
 
-void AddBoom(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBoom(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._mix = dx;
 	missile[mi]._miy = dy;
@@ -2771,7 +2771,7 @@ void AddBoom(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	missile[mi]._miVar1 = 0;
 }
 
-void AddHeal(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddHeal(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 	int HealAmount;
@@ -2802,7 +2802,7 @@ void AddHeal(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	drawhpflag = true;
 }
 
-void AddHealOther(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddHealOther(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	UseMana(id, SPL_HEALOTHER);
@@ -2813,7 +2813,7 @@ void AddHealOther(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	}
 }
 
-void AddElement(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddElement(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2840,7 +2840,7 @@ void AddElement(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 
 extern void FocusOnInventory();
 
-void AddIdentify(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddIdentify(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	UseMana(id, SPL_IDENTIFY);
@@ -2856,7 +2856,7 @@ void AddIdentify(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	}
 }
 
-void AddFirewallC(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFirewallC(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i, j, k, tx, ty, pn;
 
@@ -2895,7 +2895,7 @@ void AddFirewallC(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	}
 }
 
-void AddInfra(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddInfra(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -2908,7 +2908,7 @@ void AddInfra(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 		UseMana(id, SPL_INFRA);
 }
 
-void AddWave(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddWave(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miVar1 = dx;
 	missile[mi]._miVar2 = dy;
@@ -2919,7 +2919,7 @@ void AddWave(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	UseMana(id, SPL_WAVE);
 }
 
-void AddNova(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddNova(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int k;
 
@@ -2940,7 +2940,7 @@ void AddNova(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir
 	missile[mi]._mirange = 1;
 }
 
-void AddBlodboil(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBlodboil(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (id == -1 || plr[id]._pSpellFlags & 6 || plr[id]._pHitPoints <= plr[id]._pLevel << 6) {
 		missile[mi]._miDelFlag = true;
@@ -2961,7 +2961,7 @@ void AddBlodboil(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	}
 }
 
-void AddRepair(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRepair(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	UseMana(id, SPL_REPAIR);
@@ -2977,7 +2977,7 @@ void AddRepair(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	}
 }
 
-void AddRecharge(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRecharge(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	UseMana(id, SPL_RECHARGE);
@@ -2993,7 +2993,7 @@ void AddRecharge(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 m
 	}
 }
 
-void AddDisarm(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddDisarm(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	UseMana(id, SPL_DISARM);
@@ -3008,7 +3008,7 @@ void AddDisarm(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	}
 }
 
-void AddApoca(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddApoca(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -3034,7 +3034,7 @@ void AddApoca(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	UseMana(id, SPL_APOCA);
 }
 
-void AddFlame(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFlame(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int i;
 
@@ -3058,7 +3058,7 @@ void AddFlame(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	}
 }
 
-void AddFlamec(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddFlamec(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (sx == dx && sy == dy) {
 		dx += XDirAdd[midir];
@@ -3073,7 +3073,7 @@ void AddFlamec(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mid
 	missile[mi]._mirange = 256;
 }
 
-void AddCbolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 micaster, Sint32 id, Sint32 dam)
+void AddCbolt(int mi, int sx, int sy, int dx, int dy, int midir, int8_t micaster, int id, int dam)
 {
 	assert((DWORD)mi < MAXMISSILES);
 
@@ -3105,7 +3105,7 @@ void AddCbolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	missile[mi]._mirange = 256;
 }
 
-void AddHbolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 micaster, Sint32 id, Sint32 dam)
+void AddHbolt(int mi, int sx, int sy, int dx, int dy, int midir, int8_t micaster, int id, int dam)
 {
 	int sp;
 
@@ -3131,7 +3131,7 @@ void AddHbolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midi
 	UseMana(id, SPL_HBOLT);
 }
 
-void AddResurrect(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddResurrect(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	UseMana(id, SPL_RESURRECT);
 	if (id == myplr) {
@@ -3142,7 +3142,7 @@ void AddResurrect(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	missile[mi]._miDelFlag = true;
 }
 
-void AddResurrectBeam(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddResurrectBeam(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._mix = dx;
 	missile[mi]._miy = dy;
@@ -3153,7 +3153,7 @@ void AddResurrectBeam(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sin
 	missile[mi]._mirange = misfiledata[MFILE_RESSUR1].mAnimLen[0];
 }
 
-void AddTelekinesis(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddTelekinesis(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._miDelFlag = true;
 	UseMana(id, SPL_TELEKINESIS);
@@ -3161,7 +3161,7 @@ void AddTelekinesis(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint3
 		NewCursor(CURSOR_TELEKINESIS);
 }
 
-void AddBoneSpirit(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddBoneSpirit(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	if (sx == dx && sy == dy) {
 		dx = XDirAdd[midir] + dx;
@@ -3183,7 +3183,7 @@ void AddBoneSpirit(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32
 	}
 }
 
-void AddRportal(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddRportal(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	missile[mi]._mix = sx;
 	missile[mi]._miy = sy;
@@ -3195,7 +3195,7 @@ void AddRportal(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 mi
 	PutMissile(mi);
 }
 
-void AddDiabApoca(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam)
+void AddDiabApoca(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam)
 {
 	int pnum;
 
@@ -3296,12 +3296,12 @@ int Sentfire(int i, int sx, int sy)
 	return ex;
 }
 
-void MI_Dummy(Sint32 i)
+void MI_Dummy(int i)
 {
 	return;
 }
 
-void MI_Golem(Sint32 i)
+void MI_Golem(int i)
 {
 	int tx, ty, dp, l, m, src, k, tid;
 	const char *ct;
@@ -3332,7 +3332,7 @@ void MI_Golem(Sint32 i)
 	missile[i]._miDelFlag = true;
 }
 
-void MI_LArrow(Sint32 i)
+void MI_LArrow(int i)
 {
 	int p, mind, maxd;
 
@@ -3414,7 +3414,7 @@ void MI_LArrow(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Arrow(Sint32 i)
+void MI_Arrow(int i)
 {
 	int p, mind, maxd;
 
@@ -3443,7 +3443,7 @@ void MI_Arrow(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Firebolt(Sint32 i)
+void MI_Firebolt(int i)
 {
 	int omx, omy;
 	int d, p;
@@ -3538,7 +3538,7 @@ void MI_Firebolt(Sint32 i)
 		PutMissile(i);
 }
 
-void MI_Lightball(Sint32 i)
+void MI_Lightball(int i)
 {
 	int tx, ty, j, oi;
 	char obj;
@@ -3568,7 +3568,7 @@ void MI_Lightball(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Krull(Sint32 i)
+void MI_Krull(int i)
 {
 	missile[i]._mirange--;
 	missile[i]._mitxoff += missile[i]._mixvel;
@@ -3580,7 +3580,7 @@ void MI_Krull(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Acidpud(Sint32 i)
+void MI_Acidpud(int i)
 {
 	int range;
 
@@ -3599,7 +3599,7 @@ void MI_Acidpud(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Firewall(Sint32 i)
+void MI_Firewall(int i)
 {
 	int ExpLight[14] = { 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 12 };
 
@@ -3706,12 +3706,12 @@ void FireballUpdate(int i, int xof, int yof, bool alwaysDelete)
 	PutMissile(i);
 }
 
-void MI_Fireball(Sint32 i)
+void MI_Fireball(int i)
 {
 	FireballUpdate(i, missile[i]._mixvel, missile[i]._miyvel, false);
 }
 
-void MI_HorkSpawn(Sint32 i)
+void MI_HorkSpawn(int i)
 {
 	int t, j, k, tx, ty, dp;
 
@@ -3745,7 +3745,7 @@ void MI_HorkSpawn(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Rune(Sint32 i)
+void MI_Rune(int i)
 {
 	int mid, pid, mx, my;
 	direction dir;
@@ -3775,7 +3775,7 @@ void MI_Rune(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_LightningWall(Sint32 i)
+void MI_LightningWall(int i)
 {
 	int range;
 
@@ -3789,7 +3789,7 @@ void MI_LightningWall(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_HiveExplode(Sint32 i)
+void MI_HiveExplode(int i)
 {
 	missile[i]._mirange--;
 	if (missile[i]._mirange <= 0) {
@@ -3799,7 +3799,7 @@ void MI_HiveExplode(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Immolation(Sint32 i)
+void MI_Immolation(int i)
 {
 	if (missile[i]._miVar7 < 0) {
 		int v = 2 * missile[i]._miVar6;
@@ -3829,7 +3829,7 @@ void MI_Immolation(Sint32 i)
 	FireballUpdate(i, xof, yof, true);
 }
 
-void MI_LightningArrow(Sint32 i)
+void MI_LightningArrow(int i)
 {
 	int pn, mx, my;
 
@@ -3906,7 +3906,7 @@ void MI_LightningArrow(Sint32 i)
 	}
 }
 
-void MI_FlashFront(Sint32 i)
+void MI_FlashFront(int i)
 {
 	int src;
 
@@ -3929,7 +3929,7 @@ void MI_FlashFront(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_FlashBack(Sint32 i)
+void MI_FlashBack(int i)
 {
 	if (missile[i]._micaster == TARGET_MONSTERS) {
 		if (missile[i]._misource != -1) {
@@ -3943,7 +3943,7 @@ void MI_FlashBack(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Reflect(Sint32 i)
+void MI_Reflect(int i)
 {
 	int src;
 
@@ -3973,7 +3973,7 @@ void MI_Reflect(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_FireRing(Sint32 i)
+void MI_FireRing(int i)
 {
 	int src, tx, ty, dmg, k, j, dp, b;
 	BYTE lvl;
@@ -4004,7 +4004,7 @@ void MI_FireRing(Sint32 i)
 	}
 }
 
-void MI_LightningRing(Sint32 i)
+void MI_LightningRing(int i)
 {
 	int src, tx, ty, dmg, k, j, dp, b;
 	BYTE lvl;
@@ -4035,7 +4035,7 @@ void MI_LightningRing(Sint32 i)
 	}
 }
 
-void MI_Search(Sint32 i)
+void MI_Search(int i)
 {
 	missile[i]._mirange--;
 	if (missile[i]._mirange == 0) {
@@ -4045,7 +4045,7 @@ void MI_Search(Sint32 i)
 	}
 }
 
-void MI_LightningWallC(Sint32 i)
+void MI_LightningWallC(int i)
 {
 	missile[i]._mirange--;
 	int id = missile[i]._misource;
@@ -4081,7 +4081,7 @@ void MI_LightningWallC(Sint32 i)
 	}
 }
 
-void MI_FireNova(Sint32 i)
+void MI_FireNova(int i)
 {
 	int sx1 = 0;
 	int sy1 = 0;
@@ -4110,7 +4110,7 @@ void MI_FireNova(Sint32 i)
 		missile[i]._miDelFlag = true;
 }
 
-void MI_SpecArrow(Sint32 i)
+void MI_SpecArrow(int i)
 {
 	int src = missile[i]._misource;
 	int dam = missile[i]._midam;
@@ -4151,7 +4151,7 @@ void MI_SpecArrow(Sint32 i)
 		missile[i]._miDelFlag = true;
 }
 
-void MI_Lightctrl(Sint32 i)
+void MI_Lightctrl(int i)
 {
 	int pn, dam, p, mx, my;
 
@@ -4239,7 +4239,7 @@ void MI_Lightctrl(Sint32 i)
 	}
 }
 
-void MI_Lightning(Sint32 i)
+void MI_Lightning(int i)
 {
 	int j;
 
@@ -4256,7 +4256,7 @@ void MI_Lightning(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Town(Sint32 i)
+void MI_Town(int i)
 {
 	int ExpLight[17] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 15, 15 };
 	int p;
@@ -4289,7 +4289,7 @@ void MI_Town(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Flash(Sint32 i)
+void MI_Flash(int i)
 {
 	if (missile[i]._micaster == TARGET_MONSTERS) {
 		if (missile[i]._misource != -1)
@@ -4312,7 +4312,7 @@ void MI_Flash(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Flash2(Sint32 i)
+void MI_Flash2(int i)
 {
 	if (missile[i]._micaster == TARGET_MONSTERS) {
 		if (missile[i]._misource != -1)
@@ -4332,7 +4332,7 @@ void MI_Flash2(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Manashield(Sint32 i)
+void MI_Manashield(int i)
 {
 	int id;
 
@@ -4370,7 +4370,7 @@ void MI_Manashield(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Etherealize(Sint32 i)
+void MI_Etherealize(int i)
 {
 	int src;
 
@@ -4402,7 +4402,7 @@ void MI_Etherealize(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Firemove(Sint32 i)
+void MI_Firemove(int i)
 {
 	int j;
 	int ExpLight[14] = { 2, 3, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 12 };
@@ -4444,7 +4444,7 @@ void MI_Firemove(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Guardian(Sint32 i)
+void MI_Guardian(int i)
 {
 	int j, k, sx, sy, sx1, sy1, ex;
 
@@ -4520,7 +4520,7 @@ void MI_Guardian(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Chain(Sint32 i)
+void MI_Chain(int i)
 {
 	int sx, sy, id, l, n, m, k, rad, tx, ty;
 
@@ -4550,7 +4550,7 @@ void MI_Chain(Sint32 i)
 		missile[i]._miDelFlag = true;
 }
 
-void MI_Blood(Sint32 i)
+void MI_Blood(int i)
 {
 	missile[i]._mirange--;
 	if (missile[i]._mirange == 0)
@@ -4560,7 +4560,7 @@ void MI_Blood(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Weapexp(Sint32 i)
+void MI_Weapexp(int i)
 {
 	int id, mind, maxd;
 	int ExpLight[10] = { 9, 10, 11, 12, 11, 10, 8, 6, 4, 2 };
@@ -4592,7 +4592,7 @@ void MI_Weapexp(Sint32 i)
 	}
 }
 
-void MI_Misexp(Sint32 i)
+void MI_Misexp(int i)
 {
 	int ExpLight[] = { 9, 10, 11, 12, 11, 10, 8, 6, 4, 2, 1, 0, 0, 0, 0 };
 
@@ -4610,7 +4610,7 @@ void MI_Misexp(Sint32 i)
 	}
 }
 
-void MI_Acidsplat(Sint32 i)
+void MI_Acidsplat(int i)
 {
 	int monst, dam;
 
@@ -4630,7 +4630,7 @@ void MI_Acidsplat(Sint32 i)
 	}
 }
 
-void MI_Teleport(Sint32 i)
+void MI_Teleport(int i)
 {
 	int id;
 
@@ -4658,7 +4658,7 @@ void MI_Teleport(Sint32 i)
 	}
 }
 
-void MI_Stone(Sint32 i)
+void MI_Stone(int i)
 {
 	int m;
 
@@ -4686,7 +4686,7 @@ void MI_Stone(Sint32 i)
 		PutMissile(i);
 }
 
-void MI_Boom(Sint32 i)
+void MI_Boom(int i)
 {
 	missile[i]._mirange--;
 	if (missile[i]._miVar1 == 0)
@@ -4698,7 +4698,7 @@ void MI_Boom(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Rhino(Sint32 i)
+void MI_Rhino(int i)
 {
 	int mix, miy, mix2, miy2, omx, omy, monst;
 
@@ -4744,7 +4744,7 @@ void MI_Rhino(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Fireman(Sint32 i)
+void MI_Fireman(int i)
 {
 	int src, enemy, ax, ay, bx, by, cx, cy, j;
 
@@ -4786,7 +4786,7 @@ void MI_Fireman(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_FirewallC(Sint32 i)
+void MI_FirewallC(int i)
 {
 	missile[i]._mirange--;
 	int id = missile[i]._misource;
@@ -4818,7 +4818,7 @@ void MI_FirewallC(Sint32 i)
 	}
 }
 
-void MI_Infra(Sint32 i)
+void MI_Infra(int i)
 {
 	missile[i]._mirange--;
 	plr[missile[i]._misource]._pInfraFlag = true;
@@ -4828,7 +4828,7 @@ void MI_Infra(Sint32 i)
 	}
 }
 
-void MI_Apoca(Sint32 i)
+void MI_Apoca(int i)
 {
 	int j, k;
 
@@ -4856,7 +4856,7 @@ void MI_Apoca(Sint32 i)
 	}
 }
 
-void MI_Wave(Sint32 i)
+void MI_Wave(int i)
 {
 	int sx, sy, nxa, nxb, nya, nyb;
 	int j, id, pn;
@@ -4911,7 +4911,7 @@ void MI_Wave(Sint32 i)
 		missile[i]._miDelFlag = true;
 }
 
-void MI_Nova(Sint32 i)
+void MI_Nova(int i)
 {
 	int sx1 = 0;
 	int sy1 = 0;
@@ -4940,7 +4940,7 @@ void MI_Nova(Sint32 i)
 		missile[i]._miDelFlag = true;
 }
 
-void MI_Blodboil(Sint32 i)
+void MI_Blodboil(int i)
 {
 	int id, hpdif;
 
@@ -4971,7 +4971,7 @@ void MI_Blodboil(Sint32 i)
 	}
 }
 
-void MI_Flame(Sint32 i)
+void MI_Flame(int i)
 {
 	int k;
 
@@ -4997,7 +4997,7 @@ void MI_Flame(Sint32 i)
 		PutMissile(i);
 }
 
-void MI_Flamec(Sint32 i)
+void MI_Flamec(int i)
 {
 	int id, src;
 
@@ -5031,7 +5031,7 @@ void MI_Flamec(Sint32 i)
 		missile[i]._miDelFlag = true;
 }
 
-void MI_Cbolt(Sint32 i)
+void MI_Cbolt(int i)
 {
 	int md;
 	int bpath[16] = { -1, 0, 1, -1, 0, 1, -1, -1, 0, 0, 1, 1, 0, 1, -1, 0 };
@@ -5068,7 +5068,7 @@ void MI_Cbolt(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Hbolt(Sint32 i)
+void MI_Hbolt(int i)
 {
 	int dam;
 
@@ -5105,7 +5105,7 @@ void MI_Hbolt(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Element(Sint32 i)
+void MI_Element(int i)
 {
 	int mid, dam, cx, cy, px, py, id;
 
@@ -5177,7 +5177,7 @@ void MI_Element(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Bonespirit(Sint32 i)
+void MI_Bonespirit(int i)
 {
 	int id, mid, dam;
 	int cx, cy;
@@ -5228,7 +5228,7 @@ void MI_Bonespirit(Sint32 i)
 	}
 }
 
-void MI_ResurrectBeam(Sint32 i)
+void MI_ResurrectBeam(int i)
 {
 	missile[i]._mirange--;
 	if (missile[i]._mirange == 0)
@@ -5236,7 +5236,7 @@ void MI_ResurrectBeam(Sint32 i)
 	PutMissile(i);
 }
 
-void MI_Rportal(Sint32 i)
+void MI_Rportal(int i)
 {
 	int ExpLight[17] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 15, 15 };
 
diff --git a/Source/missiles.h b/Source/missiles.h
index 3b204e12..46098092 100644
--- a/Source/missiles.h
+++ b/Source/missiles.h
@@ -17,57 +17,57 @@ namespace devilution {
 #define MAXMISSILES 125
 
 struct ChainStruct {
-	Sint32 idx;
-	Sint32 _mitype;
-	Sint32 _mirange;
+	int idx;
+	int _mitype;
+	int _mirange;
 };
 
 struct MissileStruct {
-	Sint32 _mitype;  // Type of projectile (missile_id)
-	Sint32 _mix;     // Tile X-position of the missile
-	Sint32 _miy;     // Tile Y-position of the missile
-	Sint32 _mixoff;  // Sprite pixel X-offset for the missile
-	Sint32 _miyoff;  // Sprite pixel Y-offset for the missile
-	Sint32 _mixvel;  // Missile tile X-velocity while walking. This gets added onto _mitxoff each game tick
-	Sint32 _miyvel;  // Missile tile Y-velocity while walking. This gets added onto _mitxoff each game tick
-	Sint32 _misx;    // Initial tile X-position for missile
-	Sint32 _misy;    // Initial tile Y-position for missile
-	Sint32 _mitxoff; // How far the missile has travelled in its lifespan along the X-axis. mix/miy/mxoff/myoff get updated every game tick based on this
-	Sint32 _mityoff; // How far the missile has travelled in its lifespan along the Y-axis. mix/miy/mxoff/myoff get updated every game tick based on this
-	Sint32 _mimfnum; // The direction of the missile (direction enum)
-	Sint32 _mispllvl;
+	int _mitype;  // Type of projectile (missile_id)
+	int _mix;     // Tile X-position of the missile
+	int _miy;     // Tile Y-position of the missile
+	int _mixoff;  // Sprite pixel X-offset for the missile
+	int _miyoff;  // Sprite pixel Y-offset for the missile
+	int _mixvel;  // Missile tile X-velocity while walking. This gets added onto _mitxoff each game tick
+	int _miyvel;  // Missile tile Y-velocity while walking. This gets added onto _mitxoff each game tick
+	int _misx;    // Initial tile X-position for missile
+	int _misy;    // Initial tile Y-position for missile
+	int _mitxoff; // How far the missile has travelled in its lifespan along the X-axis. mix/miy/mxoff/myoff get updated every game tick based on this
+	int _mityoff; // How far the missile has travelled in its lifespan along the Y-axis. mix/miy/mxoff/myoff get updated every game tick based on this
+	int _mimfnum; // The direction of the missile (direction enum)
+	int _mispllvl;
 	bool _miDelFlag; // Indicate whether the missile should be deleted
-	Uint8 _miAnimType;
-	Sint32 _miAnimFlags;
-	Uint8 *_miAnimData;
-	Sint32 _miAnimDelay; // Tick length of each frame in the current animation
-	Sint32 _miAnimLen;   // Number of frames in current animation
-	Sint32 _miAnimWidth;
-	Sint32 _miAnimWidth2;
-	Sint32 _miAnimCnt; // Increases by one each game tick, counting how close we are to _pAnimDelay
-	Sint32 _miAnimAdd;
-	Sint32 _miAnimFrame; // Current frame of animation.
+	uint8_t _miAnimType;
+	int _miAnimFlags;
+	BYTE *_miAnimData;
+	int _miAnimDelay; // Tick length of each frame in the current animation
+	int _miAnimLen;   // Number of frames in current animation
+	int _miAnimWidth;
+	int _miAnimWidth2;
+	int _miAnimCnt; // Increases by one each game tick, counting how close we are to _pAnimDelay
+	int _miAnimAdd;
+	int _miAnimFrame; // Current frame of animation.
 	bool _miDrawFlag;
 	bool _miLightFlag;
 	bool _miPreFlag;
-	Uint32 _miUniqTrans;
-	Sint32 _mirange; // Time to live for the missile in game ticks, oncs 0 the missile will be marked for deletion via _miDelFlag
-	Sint32 _misource;
+	uint32_t _miUniqTrans;
+	int _mirange; // Time to live for the missile in game ticks, oncs 0 the missile will be marked for deletion via _miDelFlag
+	int _misource;
 	/** mienemy_type or player id*/
-	Sint8 _micaster;
-	Sint32 _midam;
+	int8_t _micaster;
+	int _midam;
 	bool _miHitFlag;
-	Sint32 _midist; // Used for arrows to measure distance travelled (increases by 1 each game tick). Higher value is a penalty for accuracy calculation when hitting enemy
-	Sint32 _mlid;
-	Sint32 _mirnd;
-	Sint32 _miVar1;
-	Sint32 _miVar2;
-	Sint32 _miVar3;
-	Sint32 _miVar4;
-	Sint32 _miVar5;
-	Sint32 _miVar6;
-	Sint32 _miVar7;
-	Sint32 _miVar8;
+	int _midist; // Used for arrows to measure distance travelled (increases by 1 each game tick). Higher value is a penalty for accuracy calculation when hitting enemy
+	int _mlid;
+	int _mirnd;
+	int _miVar1;
+	int _miVar2;
+	int _miVar3;
+	int _miVar4;
+	int _miVar5;
+	int _miVar6;
+	int _miVar7;
+	int _miVar8;
 };
 
 extern int missileactive[MAXMISSILES];
@@ -89,146 +89,146 @@ void InitMissileGFX();
 void FreeMissiles();
 void FreeMissiles2();
 void InitMissiles();
-void AddHiveExplosion(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFireRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLightningRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddGreatLightningRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddImmolationRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddStoneRune(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddReflection(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBerserk(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddHorkSpawn(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddJester(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddStealPotions(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddManaTrap(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddSpecArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddWarp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLightningWall(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRuneExplosion(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddImmolation(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFireNova(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLightningArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddMana(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddMagi(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRing(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddSearch(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddCboltArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddArrow(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRndTeleport(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFirebolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 micaster, Sint32 id, Sint32 dam);
-void AddMagmaball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddKrull(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddTeleport(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLightball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFirewall(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFireball(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLightctrl(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddLightning(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddMisexp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddWeapexp(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddTown(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFlash(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFlash2(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddManashield(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFiremove(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddGuardian(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddChain(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBloodStar(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBone(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddMetlHit(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRhino(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFireman(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFlare(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddAcid(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFireWallA(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddAcidpud(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddStone(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddGolem(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddEtherealize(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddDummy(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBlodbur(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBoom(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddHeal(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddHealOther(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddElement(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddIdentify(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFirewallC(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddInfra(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddWave(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddNova(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBlodboil(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRepair(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRecharge(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddDisarm(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddApoca(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFlame(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddFlamec(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddCbolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 micaster, Sint32 id, Sint32 dam);
-void AddHbolt(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 micaster, Sint32 id, Sint32 dam);
-void AddResurrect(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddResurrectBeam(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddTelekinesis(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddBoneSpirit(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddRportal(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
-void AddDiabApoca(Sint32 mi, Sint32 sx, Sint32 sy, Sint32 dx, Sint32 dy, Sint32 midir, Sint8 mienemy, Sint32 id, Sint32 dam);
+void AddHiveExplosion(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFireRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLightningRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddGreatLightningRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddImmolationRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddStoneRune(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddReflection(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBerserk(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddHorkSpawn(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddJester(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddStealPotions(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddManaTrap(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddSpecArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddWarp(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLightningWall(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRuneExplosion(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddImmolation(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFireNova(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLightningArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddMana(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddMagi(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRing(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddSearch(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddCboltArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddArrow(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRndTeleport(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFirebolt(int mi, int sx, int sy, int dx, int dy, int midir, int8_t micaster, int id, int dam);
+void AddMagmaball(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddKrull(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddTeleport(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLightball(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFirewall(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFireball(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLightctrl(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddLightning(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddMisexp(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddWeapexp(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddTown(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFlash(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFlash2(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddManashield(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFiremove(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddGuardian(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddChain(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBloodStar(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBone(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddMetlHit(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRhino(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFireman(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFlare(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddAcid(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFireWallA(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddAcidpud(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddStone(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddGolem(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddEtherealize(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddDummy(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBlodbur(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBoom(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddHeal(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddHealOther(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddElement(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddIdentify(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFirewallC(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddInfra(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddWave(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddNova(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBlodboil(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRepair(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRecharge(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddDisarm(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddApoca(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFlame(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddFlamec(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddCbolt(int mi, int sx, int sy, int dx, int dy, int midir, int8_t micaster, int id, int dam);
+void AddHbolt(int mi, int sx, int sy, int dx, int dy, int midir, int8_t micaster, int id, int dam);
+void AddResurrect(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddResurrectBeam(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddTelekinesis(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddBoneSpirit(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddRportal(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
+void AddDiabApoca(int mi, int sx, int sy, int dx, int dy, int midir, int8_t mienemy, int id, int dam);
 int AddMissile(int sx, int sy, int dx, int dy, int midir, int mitype, int8_t micaster, int id, int midam, int spllvl);
-void MI_Dummy(Sint32 i);
-void MI_Golem(Sint32 i);
-void MI_Manashield(Sint32 i);
-void MI_LArrow(Sint32 i);
-void MI_Arrow(Sint32 i);
-void MI_Firebolt(Sint32 i);
-void MI_Lightball(Sint32 i);
-void MI_Krull(Sint32 i);
-void MI_Acidpud(Sint32 i);
-void MI_Firewall(Sint32 i);
-void MI_Fireball(Sint32 i);
-void MI_HorkSpawn(Sint32 i);
-void MI_Rune(Sint32 i);
-void MI_LightningWall(Sint32 i);
-void MI_HiveExplode(Sint32 i);
-void MI_Immolation(Sint32 i);
-void MI_LightningArrow(Sint32 i);
-void MI_Reflect(Sint32 i);
-void MI_FireRing(Sint32 i);
-void MI_LightningRing(Sint32 i);
-void MI_Search(Sint32 i);
-void MI_LightningWallC(Sint32 i);
-void MI_FireNova(Sint32 i);
-void MI_SpecArrow(Sint32 i);
-void MI_Lightctrl(Sint32 i);
-void MI_Lightning(Sint32 i);
-void MI_Town(Sint32 i);
-void MI_Flash(Sint32 i);
-void MI_Flash2(Sint32 i);
-void MI_Etherealize(Sint32 i);
-void MI_Firemove(Sint32 i);
-void MI_Guardian(Sint32 i);
-void MI_Chain(Sint32 i);
-void MI_Blood(Sint32 i);
-void MI_Weapexp(Sint32 i);
-void MI_Misexp(Sint32 i);
-void MI_Acidsplat(Sint32 i);
-void MI_Teleport(Sint32 i);
-void MI_Stone(Sint32 i);
-void MI_Boom(Sint32 i);
-void MI_Rhino(Sint32 i);
-void MI_Fireman(Sint32 i);
-void MI_FirewallC(Sint32 i);
-void MI_Infra(Sint32 i);
-void MI_Apoca(Sint32 i);
-void MI_Wave(Sint32 i);
-void MI_Nova(Sint32 i);
-void MI_Blodboil(Sint32 i);
-void MI_Flame(Sint32 i);
-void MI_Flamec(Sint32 i);
-void MI_Cbolt(Sint32 i);
-void MI_Hbolt(Sint32 i);
-void MI_Element(Sint32 i);
-void MI_Bonespirit(Sint32 i);
-void MI_ResurrectBeam(Sint32 i);
-void MI_Rportal(Sint32 i);
+void MI_Dummy(int i);
+void MI_Golem(int i);
+void MI_Manashield(int i);
+void MI_LArrow(int i);
+void MI_Arrow(int i);
+void MI_Firebolt(int i);
+void MI_Lightball(int i);
+void MI_Krull(int i);
+void MI_Acidpud(int i);
+void MI_Firewall(int i);
+void MI_Fireball(int i);
+void MI_HorkSpawn(int i);
+void MI_Rune(int i);
+void MI_LightningWall(int i);
+void MI_HiveExplode(int i);
+void MI_Immolation(int i);
+void MI_LightningArrow(int i);
+void MI_Reflect(int i);
+void MI_FireRing(int i);
+void MI_LightningRing(int i);
+void MI_Search(int i);
+void MI_LightningWallC(int i);
+void MI_FireNova(int i);
+void MI_SpecArrow(int i);
+void MI_Lightctrl(int i);
+void MI_Lightning(int i);
+void MI_Town(int i);
+void MI_Flash(int i);
+void MI_Flash2(int i);
+void MI_Etherealize(int i);
+void MI_Firemove(int i);
+void MI_Guardian(int i);
+void MI_Chain(int i);
+void MI_Blood(int i);
+void MI_Weapexp(int i);
+void MI_Misexp(int i);
+void MI_Acidsplat(int i);
+void MI_Teleport(int i);
+void MI_Stone(int i);
+void MI_Boom(int i);
+void MI_Rhino(int i);
+void MI_Fireman(int i);
+void MI_FirewallC(int i);
+void MI_Infra(int i);
+void MI_Apoca(int i);
+void MI_Wave(int i);
+void MI_Nova(int i);
+void MI_Blodboil(int i);
+void MI_Flame(int i);
+void MI_Flamec(int i);
+void MI_Cbolt(int i);
+void MI_Hbolt(int i);
+void MI_Element(int i);
+void MI_Bonespirit(int i);
+void MI_ResurrectBeam(int i);
+void MI_Rportal(int i);
 void ProcessMissiles();
 void missiles_process_charge();
 void ClearMissileSpot(int mi);
diff --git a/Source/monstdat.h b/Source/monstdat.h
index 291ec407..bdad2e17 100644
--- a/Source/monstdat.h
+++ b/Source/monstdat.h
@@ -5,7 +5,6 @@
  */
 #pragma once
 
-#include <SDL.h>
 #include <stdint.h>
 
 namespace devilution {
@@ -78,39 +77,39 @@ struct MonsterData {
 	const char *GraphicType;
 	const char *sndfile;
 	const char *TransFile;
-	Uint16 width;
-	Uint16 mImage;
+	uint16_t width;
+	uint16_t mImage;
 	bool has_special;
 	bool snd_special;
 	bool has_trans;
-	Uint8 Frames[6];
-	Uint8 Rate[6];
-	Sint8 mMinDLvl;
-	Sint8 mMaxDLvl;
-	Sint8 mLevel;
-	Uint16 mMinHP;
-	Uint16 mMaxHP;
+	uint8_t Frames[6];
+	uint8_t Rate[6];
+	int8_t mMinDLvl;
+	int8_t mMaxDLvl;
+	int8_t mLevel;
+	uint16_t mMinHP;
+	uint16_t mMaxHP;
 	_mai_id mAi;
 	/** Usign monster_flag as bitflags */
-	Uint16 mFlags;
-	Uint8 mInt;
-	Uint8 mHit;
-	Uint8 mAFNum;
-	Uint8 mMinDamage;
-	Uint8 mMaxDamage;
-	Uint8 mHit2;
-	Uint8 mAFNum2;
-	Uint8 mMinDamage2;
-	Uint8 mMaxDamage2;
-	Uint8 mArmorClass;
+	uint16_t mFlags;
+	uint8_t mInt;
+	uint8_t mHit;
+	uint8_t mAFNum;
+	uint8_t mMinDamage;
+	uint8_t mMaxDamage;
+	uint8_t mHit2;
+	uint8_t mAFNum2;
+	uint8_t mMinDamage2;
+	uint8_t mMaxDamage2;
+	uint8_t mArmorClass;
 	_mc_id mMonstClass;
 	/** Using monster_resistance as bitflags */
-	Uint8 mMagicRes;
+	uint8_t mMagicRes;
 	/** Using monster_resistance as bitflags */
-	Uint8 mMagicRes2;
-	Sint8 mSelFlag;   // TODO Create enum
-	Uint16 mTreasure; // TODO Create enum
-	Uint16 mExp;
+	uint8_t mMagicRes2;
+	int8_t mSelFlag;    // TODO Create enum
+	uint16_t mTreasure; // TODO Create enum
+	uint16_t mExp;
 };
 
 enum _monster_id : int16_t {
@@ -266,18 +265,18 @@ struct UniqMonstStruct {
 	_monster_id mtype;
 	const char *mName;
 	const char *mTrnName;
-	Uint8 mlevel;
-	Uint16 mmaxhp;
+	uint8_t mlevel;
+	uint16_t mmaxhp;
 	_mai_id mAi;
-	Uint8 mint;
-	Uint8 mMinDamage;
-	Uint8 mMaxDamage;
+	uint8_t mint;
+	uint8_t mMinDamage;
+	uint8_t mMaxDamage;
 	/** Using monster_resistance as bitflags */
-	Uint16 mMagicRes;
-	Uint16 mUnqAttr; // TODO create enum
-	Uint8 mUnqVar1;
-	Uint8 mUnqVar2;
-	Sint32 mtalkmsg;
+	uint16_t mMagicRes;
+	uint16_t mUnqAttr; // TODO create enum
+	uint8_t mUnqVar1;
+	uint8_t mUnqVar2;
+	int mtalkmsg;
 };
 
 extern const MonsterData monsterdata[];
diff --git a/Source/monster.cpp b/Source/monster.cpp
index c2c30fb8..b780ba48 100644
--- a/Source/monster.cpp
+++ b/Source/monster.cpp
@@ -2896,7 +2896,7 @@ bool M_CallWalk(int i, direction md)
 
 bool M_PathWalk(int i)
 {
-	Sint8 path[MAX_PATH_LENGTH];
+	int8_t path[MAX_PATH_LENGTH];
 	bool (*Check)(int, int, int);
 
 	/** Maps from walking path step to facing direction. */
@@ -2941,7 +2941,7 @@ bool M_DumbWalk(int i, direction md)
 	return ok;
 }
 
-bool M_RoundWalk(int i, direction md, Sint32 *dir)
+bool M_RoundWalk(int i, direction md, int *dir)
 {
 	if (*dir)
 		md = left[left[md]];
diff --git a/Source/monster.h b/Source/monster.h
index 8cc8334d..aa31fa76 100644
--- a/Source/monster.h
+++ b/Source/monster.h
@@ -105,119 +105,119 @@ enum placeflag : uint8_t {
 };
 
 struct AnimStruct {
-	Uint8 *CMem;
-	Uint8 *Data[8];
-	Sint32 Frames;
-	Sint32 Rate;
+	uint8_t *CMem;
+	uint8_t *Data[8];
+	int Frames;
+	int Rate;
 };
 
 struct CMonster {
 	_monster_id mtype;
 	/** placeflag enum as a flags*/
-	Uint8 mPlaceFlags;
+	uint8_t mPlaceFlags;
 	AnimStruct Anims[6];
 	TSnd *Snds[4][2];
-	Sint32 width;
-	Sint32 width2;
+	int width;
+	int width2;
 	uint16_t mMinHP;
 	uint16_t mMaxHP;
 	bool has_special;
-	Uint8 mAFNum;
-	Sint8 mdeadval;
+	uint8_t mAFNum;
+	int8_t mdeadval;
 	const MonsterData *MData;
 	/**
 	 * A TRN file contains a sequence of color transitions, represented
 	 * as indexes into a palette. (a 256 byte array of palette indices)
 	 */
-	Uint8 *trans_file;
+	uint8_t *trans_file;
 };
 
 struct MonsterStruct { // note: missing field _mAFNum
-	Sint32 _mMTidx;
+	int _mMTidx;
 	MON_MODE _mmode;
 	monster_goal _mgoal;
-	Sint32 _mgoalvar1;
-	Sint32 _mgoalvar2;
-	Sint32 _mgoalvar3;
-	Uint8 _pathcount;
+	int _mgoalvar1;
+	int _mgoalvar2;
+	int _mgoalvar3;
+	uint8_t _pathcount;
 	/** Tile X-position of monster */
-	Sint32 _mx;
+	int _mx;
 	/** Tile Y-position of monster */
-	Sint32 _my;
+	int _my;
 	/** Future tile X-position of monster. Set at start of walking animation */
-	Sint32 _mfutx;
+	int _mfutx;
 	/** Future tile Y-position of monster. Set at start of walking animation */
-	Sint32 _mfuty;
+	int _mfuty;
 	/** Most recent X-position in dMonster. */
-	Sint32 _moldx;
+	int _moldx;
 	/** Most recent Y-position in dMonster. */
-	Sint32 _moldy;
+	int _moldy;
 	/** Monster sprite's pixel X-offset from tile. */
-	Sint32 _mxoff;
+	int _mxoff;
 	/** Monster sprite's pixel Y-offset from tile. */
-	Sint32 _myoff;
+	int _myoff;
 	/** Pixel X-velocity while walking. Applied to _mxoff */
-	Sint32 _mxvel;
+	int _mxvel;
 	/** Pixel Y-velocity while walking. Applied to _myoff */
-	Sint32 _myvel;
+	int _myvel;
 	/** Direction faced by monster (direction enum) */
 	direction _mdir;
 	/** The current target of the mosnter. An index in to either the plr or monster array based on the _meflag value. */
-	Sint32 _menemy;
+	int _menemy;
 	/** X-coordinate of enemy (usually correspond's to the enemy's futx value) */
-	Uint8 _menemyx;
+	uint8_t _menemyx;
 	/** Y-coordinate of enemy (usually correspond's to the enemy's futy value) */
-	Uint8 _menemyy;
-	Uint8 *_mAnimData;
+	uint8_t _menemyy;
+	uint8_t *_mAnimData;
 	/** Tick length of each frame in the current animation */
-	Sint32 _mAnimDelay;
+	int _mAnimDelay;
 	/** Increases by one each game tick, counting how close we are to _pAnimDelay */
-	Sint32 _mAnimCnt;
+	int _mAnimCnt;
 	/** Number of frames in current animation */
-	Sint32 _mAnimLen;
+	int _mAnimLen;
 	/** Current frame of animation. */
-	Sint32 _mAnimFrame;
+	int _mAnimFrame;
 	bool _mDelFlag;
-	Sint32 _mVar1;
-	Sint32 _mVar2;
-	Sint32 _mVar3;
-	Sint32 _mVar4;
-	Sint32 _mVar5;
+	int _mVar1;
+	int _mVar2;
+	int _mVar3;
+	int _mVar4;
+	int _mVar5;
 	/** Used as _mxoff but with a higher range so that we can correctly apply velocities of a smaller number */
-	Sint32 _mVar6;
+	int _mVar6;
 	/** Used as _myoff but with a higher range so that we can correctly apply velocities of a smaller number */
-	Sint32 _mVar7;
+	int _mVar7;
 	/** Value used to measure progress for moving from one tile to another */
-	Sint32 _mVar8;
-	Sint32 _mmaxhp;
-	Sint32 _mhitpoints;
+	int _mVar8;
+	int _mmaxhp;
+	int _mhitpoints;
 	_mai_id _mAi;
-	Uint8 _mint;
-	Uint32 _mFlags;
-	Uint8 _msquelch;
-	Sint32 _lastx;
-	Sint32 _lasty;
-	Sint32 _mRndSeed;
-	Sint32 _mAISeed;
-	Uint8 _uniqtype;
-	Uint8 _uniqtrans;
-	Sint8 _udeadval;
-	Sint8 mWhoHit;
-	Sint8 mLevel;
-	Uint16 mExp;
-	Uint16 mHit;
-	Uint8 mMinDamage;
-	Uint8 mMaxDamage;
-	Uint16 mHit2;
-	Uint8 mMinDamage2;
-	Uint8 mMaxDamage2;
-	Uint8 mArmorClass;
-	Uint16 mMagicRes;
-	Sint32 mtalkmsg;
-	Uint8 leader;
-	Uint8 leaderflag;
-	Uint8 packsize;
-	Sint8 mlid; // BUGFIX -1 is used when not emitting light this should be signed (fixed)
+	uint8_t _mint;
+	uint32_t _mFlags;
+	uint8_t _msquelch;
+	int _lastx;
+	int _lasty;
+	int _mRndSeed;
+	int _mAISeed;
+	uint8_t _uniqtype;
+	uint8_t _uniqtrans;
+	int8_t _udeadval;
+	int8_t mWhoHit;
+	int8_t mLevel;
+	uint16_t mExp;
+	uint16_t mHit;
+	uint8_t mMinDamage;
+	uint8_t mMaxDamage;
+	uint16_t mHit2;
+	uint8_t mMinDamage2;
+	uint8_t mMaxDamage2;
+	uint8_t mArmorClass;
+	uint16_t mMagicRes;
+	int mtalkmsg;
+	uint8_t leader;
+	uint8_t leaderflag;
+	uint8_t packsize;
+	int8_t mlid; // BUGFIX -1 is used when not emitting light this should be signed (fixed)
 	const char *mName;
 	CMonster *MType;
 	const MonsterData *MData;
diff --git a/Source/mpqapi.h b/Source/mpqapi.h
index 26d63f6b..42957856 100644
--- a/Source/mpqapi.h
+++ b/Source/mpqapi.h
@@ -5,7 +5,6 @@
  */
 #pragma once
 
-#include <SDL.h>
 #include <stdint.h>
 
 #include "miniwin/miniwin.h"
@@ -16,26 +15,26 @@ struct _FILEHEADER {
 	int signature;
 	int headersize;
 	uint32_t filesize;
-	Uint16 version;
-	Sint16 sectorsizeid;
+	uint16_t version;
+	int16_t sectorsizeid;
 	int hashoffset;
 	int blockoffset;
 	int hashcount;
 	int blockcount;
-	Uint8 pad[72];
+	uint8_t pad[72];
 };
 
 struct _HASHENTRY {
-	Uint32 hashcheck[2];
-	Uint32 lcid;
+	uint32_t hashcheck[2];
+	uint32_t lcid;
 	int32_t block;
 };
 
 struct _BLOCKENTRY {
-	Uint32 offset;
-	Uint32 sizealloc;
-	Uint32 sizefile;
-	Uint32 flags;
+	uint32_t offset;
+	uint32_t sizealloc;
+	uint32_t sizefile;
+	uint32_t flags;
 };
 
 void mpqapi_remove_hash_entry(const char *pszName);
diff --git a/Source/msg.h b/Source/msg.h
index 34462c78..33f384d3 100644
--- a/Source/msg.h
+++ b/Source/msg.h
@@ -138,150 +138,150 @@ struct TCmd {
 
 struct TCmdLoc {
 	_cmd_id bCmd;
-	Uint8 x;
-	Uint8 y;
+	uint8_t x;
+	uint8_t y;
 };
 
 struct TCmdLocParam1 {
 	_cmd_id bCmd;
-	Uint8 x;
-	Uint8 y;
-	Uint16 wParam1;
+	uint8_t x;
+	uint8_t y;
+	uint16_t wParam1;
 };
 
 struct TCmdLocParam2 {
 	_cmd_id bCmd;
-	Uint8 x;
-	Uint8 y;
-	Uint16 wParam1;
-	Uint16 wParam2;
+	uint8_t x;
+	uint8_t y;
+	uint16_t wParam1;
+	uint16_t wParam2;
 };
 
 struct TCmdLocParam3 {
 	_cmd_id bCmd;
-	Uint8 x;
-	Uint8 y;
-	Uint16 wParam1;
-	Uint16 wParam2;
-	Uint16 wParam3;
+	uint8_t x;
+	uint8_t y;
+	uint16_t wParam1;
+	uint16_t wParam2;
+	uint16_t wParam3;
 };
 
 struct TCmdParam1 {
 	_cmd_id bCmd;
-	Uint16 wParam1;
+	uint16_t wParam1;
 };
 
 struct TCmdParam2 {
 	_cmd_id bCmd;
-	Uint16 wParam1;
-	Uint16 wParam2;
+	uint16_t wParam1;
+	uint16_t wParam2;
 };
 
 struct TCmdParam3 {
 	_cmd_id bCmd;
-	Uint16 wParam1;
-	Uint16 wParam2;
-	Uint16 wParam3;
+	uint16_t wParam1;
+	uint16_t wParam2;
+	uint16_t wParam3;
 };
 
 struct TCmdGolem {
 	_cmd_id bCmd;
-	Uint8 _mx;
-	Uint8 _my;
+	uint8_t _mx;
+	uint8_t _my;
 	direction _mdir;
-	Sint8 _menemy;
-	Sint32 _mhitpoints;
-	Uint8 _currlevel;
+	int8_t _menemy;
+	int32_t _mhitpoints;
+	uint8_t _currlevel;
 };
 
 struct TCmdQuest {
 	_cmd_id bCmd;
-	Uint8 q;
+	uint8_t q;
 	quest_state qstate;
-	Uint8 qlog;
-	Uint8 qvar1;
+	uint8_t qlog;
+	uint8_t qvar1;
 };
 
 struct TCmdGItem {
 	_cmd_id bCmd;
-	Uint8 bMaster;
-	Uint8 bPnum;
-	Uint8 bCursitem;
-	Uint8 bLevel;
-	Uint8 x;
-	Uint8 y;
-	Uint16 wIndx;
-	Uint16 wCI;
-	Sint32 dwSeed;
-	Uint8 bId;
-	Uint8 bDur;
-	Uint8 bMDur;
-	Uint8 bCh;
-	Uint8 bMCh;
-	Uint16 wValue;
-	Uint32 dwBuff;
-	Sint32 dwTime;
-	Uint16 wToHit;
-	Uint16 wMaxDam;
-	Uint8 bMinStr;
-	Uint8 bMinMag;
-	Uint8 bMinDex;
-	Sint16 bAC;
+	uint8_t bMaster;
+	uint8_t bPnum;
+	uint8_t bCursitem;
+	uint8_t bLevel;
+	uint8_t x;
+	uint8_t y;
+	uint16_t wIndx;
+	uint16_t wCI;
+	int32_t dwSeed;
+	uint8_t bId;
+	uint8_t bDur;
+	uint8_t bMDur;
+	uint8_t bCh;
+	uint8_t bMCh;
+	uint16_t wValue;
+	uint32_t dwBuff;
+	int32_t dwTime;
+	uint16_t wToHit;
+	uint16_t wMaxDam;
+	uint8_t bMinStr;
+	uint8_t bMinMag;
+	uint8_t bMinDex;
+	int16_t bAC;
 };
 
 struct TCmdPItem {
 	_cmd_id bCmd;
-	Uint8 x;
-	Uint8 y;
-	Uint16 wIndx;
-	Uint16 wCI;
-	Sint32 dwSeed;
-	Uint8 bId;
-	Uint8 bDur;
-	Uint8 bMDur;
-	Uint8 bCh;
-	Uint8 bMCh;
-	Uint16 wValue;
-	Uint32 dwBuff;
-	Uint16 wToHit;
-	Uint16 wMaxDam;
-	Uint8 bMinStr;
-	Uint8 bMinMag;
-	Uint8 bMinDex;
-	Sint16 bAC;
+	uint8_t x;
+	uint8_t y;
+	uint16_t wIndx;
+	uint16_t wCI;
+	int32_t dwSeed;
+	uint8_t bId;
+	uint8_t bDur;
+	uint8_t bMDur;
+	uint8_t bCh;
+	uint8_t bMCh;
+	uint16_t wValue;
+	uint32_t dwBuff;
+	uint16_t wToHit;
+	uint16_t wMaxDam;
+	uint8_t bMinStr;
+	uint8_t bMinMag;
+	uint8_t bMinDex;
+	int16_t bAC;
 };
 
 struct TCmdChItem {
 	_cmd_id bCmd;
-	Uint8 bLoc;
-	Uint16 wIndx;
-	Uint16 wCI;
-	Sint32 dwSeed;
-	Uint8 bId;
-	Uint32 dwBuff;
+	uint8_t bLoc;
+	uint16_t wIndx;
+	uint16_t wCI;
+	int32_t dwSeed;
+	uint8_t bId;
+	uint32_t dwBuff;
 };
 
 struct TCmdDelItem {
 	_cmd_id bCmd;
-	Uint8 bLoc;
+	uint8_t bLoc;
 };
 
 struct TCmdDamage {
 	_cmd_id bCmd;
-	Uint8 bPlr;
-	Uint32 dwDam;
+	uint8_t bPlr;
+	uint32_t dwDam;
 };
 
 struct TCmdMonDamage {
 	_cmd_id bCmd;
-	Uint16 wMon;
-	Uint32 dwDam;
+	uint16_t wMon;
+	uint32_t dwDam;
 };
 
 struct TCmdPlrInfoHdr {
 	_cmd_id bCmd;
-	Uint16 wOffset;
-	Uint16 wBytes;
+	uint16_t wOffset;
+	uint16_t wBytes;
 };
 
 struct TCmdString {
@@ -291,81 +291,81 @@ struct TCmdString {
 
 struct TFakeCmdPlr {
 	_cmd_id bCmd;
-	Uint8 bPlr;
+	uint8_t bPlr;
 };
 
 struct TFakeDropPlr {
 	_cmd_id bCmd;
-	Uint8 bPlr;
-	Uint32 dwReason;
+	uint8_t bPlr;
+	uint32_t dwReason;
 };
 
 struct TSyncHeader {
 	_cmd_id bCmd;
-	Uint8 bLevel;
-	Uint16 wLen;
-	Uint8 bObjId;
-	Uint8 bObjCmd;
-	Uint8 bItemI;
-	Uint8 bItemX;
-	Uint8 bItemY;
-	Uint16 wItemIndx;
-	Uint16 wItemCI;
-	Uint32 dwItemSeed;
-	Uint8 bItemId;
-	Uint8 bItemDur;
-	Uint8 bItemMDur;
-	Uint8 bItemCh;
-	Uint8 bItemMCh;
-	Uint16 wItemVal;
-	Uint32 dwItemBuff;
-	Uint8 bPInvLoc;
-	Uint16 wPInvIndx;
-	Uint16 wPInvCI;
-	Uint32 dwPInvSeed;
-	Uint8 bPInvId;
-	Uint16 wToHit;
-	Uint16 wMaxDam;
-	Uint8 bMinStr;
-	Uint8 bMinMag;
-	Uint8 bMinDex;
-	Uint8 bAC;
+	uint8_t bLevel;
+	uint16_t wLen;
+	uint8_t bObjId;
+	uint8_t bObjCmd;
+	uint8_t bItemI;
+	uint8_t bItemX;
+	uint8_t bItemY;
+	uint16_t wItemIndx;
+	uint16_t wItemCI;
+	uint32_t dwItemSeed;
+	uint8_t bItemId;
+	uint8_t bItemDur;
+	uint8_t bItemMDur;
+	uint8_t bItemCh;
+	uint8_t bItemMCh;
+	uint16_t wItemVal;
+	uint32_t dwItemBuff;
+	uint8_t bPInvLoc;
+	uint16_t wPInvIndx;
+	uint16_t wPInvCI;
+	uint32_t dwPInvSeed;
+	uint8_t bPInvId;
+	uint16_t wToHit;
+	uint16_t wMaxDam;
+	uint8_t bMinStr;
+	uint8_t bMinMag;
+	uint8_t bMinDex;
+	uint8_t bAC;
 };
 
 struct TSyncMonster {
-	Uint8 _mndx;
-	Uint8 _mx;
-	Uint8 _my;
-	Uint8 _menemy;
-	Uint8 _mdelta;
+	uint8_t _mndx;
+	uint8_t _mx;
+	uint8_t _my;
+	uint8_t _menemy;
+	uint8_t _mdelta;
 };
 
 struct TPktHdr {
-	Uint8 px;
-	Uint8 py;
-	Uint8 targx;
-	Uint8 targy;
-	Sint32 php;
-	Sint32 pmhp;
-	Uint8 bstr;
-	Uint8 bmag;
-	Uint8 bdex;
-	Uint16 wCheck;
-	Uint16 wLen;
+	uint8_t px;
+	uint8_t py;
+	uint8_t targx;
+	uint8_t targy;
+	int32_t php;
+	int32_t pmhp;
+	uint8_t bstr;
+	uint8_t bmag;
+	uint8_t bdex;
+	uint16_t wCheck;
+	uint16_t wLen;
 };
 
 struct TPkt {
 	TPktHdr hdr;
-	Uint8 body[493];
+	uint8_t body[493];
 };
 
 struct DMonsterStr {
-	Uint8 _mx;
-	Uint8 _my;
+	uint8_t _mx;
+	uint8_t _my;
 	direction _mdir;
-	Uint8 _menemy;
-	Uint8 _mactive;
-	Sint32 _mhitpoints;
+	uint8_t _menemy;
+	uint8_t _mactive;
+	int32_t _mhitpoints;
 };
 
 struct DObjectStr {
@@ -379,21 +379,21 @@ struct DLevel {
 };
 
 struct LocalLevel {
-	Uint8 automapsv[DMAXX][DMAXY];
+	uint8_t automapsv[DMAXX][DMAXY];
 };
 
 struct DPortal {
-	Uint8 x;
-	Uint8 y;
-	Uint8 level;
-	Uint8 ltype;
-	Uint8 setlvl;
+	uint8_t x;
+	uint8_t y;
+	uint8_t level;
+	uint8_t ltype;
+	uint8_t setlvl;
 };
 
 struct MultiQuests {
 	quest_state qstate;
-	Uint8 qlog;
-	Uint8 qvar1;
+	uint8_t qlog;
+	uint8_t qvar1;
 };
 
 struct DJunk {
@@ -405,14 +405,14 @@ struct DJunk {
 #pragma pack(push, 1)
 struct TMegaPkt {
 	struct TMegaPkt *pNext;
-	Uint32 dwSpaceLeft;
-	Uint8 data[32000];
+	uint32_t dwSpaceLeft;
+	uint8_t data[32000];
 };
 #pragma pack(pop)
 
 struct TBuffer {
-	Uint32 dwNextWriteOffset;
-	Uint8 bData[4096];
+	uint32_t dwNextWriteOffset;
+	uint8_t bData[4096];
 };
 
 extern bool deltaload;
diff --git a/Source/multi.h b/Source/multi.h
index 5b9a6571..5c217f21 100644
--- a/Source/multi.h
+++ b/Source/multi.h
@@ -21,18 +21,18 @@ enum event_type : uint8_t {
 };
 
 struct GameData {
-	Sint32 size;
-	Sint32 dwSeed;
-	Uint32 programid;
-	Uint8 versionMajor;
-	Uint8 versionMinor;
-	Uint8 versionPatch;
+	int32_t size;
+	int32_t dwSeed;
+	uint32_t programid;
+	uint8_t versionMajor;
+	uint8_t versionMinor;
+	uint8_t versionPatch;
 	_difficulty nDifficulty;
-	Uint8 nTickRate;
-	Uint8 bRunInTown;
-	Uint8 bTheoQuest;
-	Uint8 bCowQuest;
-	Uint8 bFriendlyFire;
+	uint8_t nTickRate;
+	uint8_t bRunInTown;
+	uint8_t bTheoQuest;
+	uint8_t bCowQuest;
+	uint8_t bFriendlyFire;
 };
 
 extern bool gbSomebodyWonGameKludge;
diff --git a/Source/objdat.h b/Source/objdat.h
index 9eceb86c..d992e8e7 100644
--- a/Source/objdat.h
+++ b/Source/objdat.h
@@ -224,22 +224,22 @@ enum quest_id : int8_t {
 };
 
 struct ObjDataStruct {
-	Sint8 oload; // Todo create enum
+	int oload; // Todo create enum
 	object_graphic_id ofindex;
-	Sint8 ominlvl;
-	Sint8 omaxlvl;
+	int8_t ominlvl;
+	int8_t omaxlvl;
 	dungeon_type olvltype;
 	theme_id otheme;
 	quest_id oquest;
-	Sint32 oAnimFlag;  // TODO Create enum
-	Sint32 oAnimDelay; // Tick length of each frame in the current animation
-	Sint32 oAnimLen;   // Number of frames in current animation
-	Sint32 oAnimWidth;
+	int oAnimFlag;  // TODO Create enum
+	int oAnimDelay; // Tick length of each frame in the current animation
+	int oAnimLen;   // Number of frames in current animation
+	int oAnimWidth;
 	bool oSolidFlag;
 	bool oMissFlag;
 	bool oLightFlag;
-	Sint8 oBreak;   // TODO Create enum
-	Sint8 oSelFlag; // TODO Create enum
+	int8_t oBreak;   // TODO Create enum
+	int8_t oSelFlag; // TODO Create enum
 	bool oTrapFlag;
 };
 
diff --git a/Source/objects.cpp b/Source/objects.cpp
index d6356981..d2904eb3 100644
--- a/Source/objects.cpp
+++ b/Source/objects.cpp
@@ -3648,9 +3648,9 @@ bool OperateShrineEnchanted(int pnum)
 		return false;
 
 	int cnt = 0;
-	Uint64 spell = 1;
+	uint64_t spell = 1;
 	int maxSpells = gbIsHellfire ? MAX_SPELLS : 37;
-	Uint64 spells = plr[pnum]._pMemSpells;
+	uint64_t spells = plr[pnum]._pMemSpells;
 	for (int j = 0; j < maxSpells; j++) {
 		if ((spell & spells) != 0)
 			cnt++;
@@ -4178,8 +4178,8 @@ bool OperateShrineGlowing(int pnum)
 		return false;
 
 	int playerXP = plr[myplr]._pExperience;
-	Sint32 magicGain = playerXP / 1000;
-	Sint32 xpLoss = 0;
+	int magicGain = playerXP / 1000;
+	int xpLoss = 0;
 	if (playerXP > 5000) {
 		magicGain = 5;
 		xpLoss = ((double)playerXP * 0.95);
diff --git a/Source/objects.h b/Source/objects.h
index f8837c64..fd169944 100644
--- a/Source/objects.h
+++ b/Source/objects.h
@@ -5,6 +5,8 @@
  */
 #pragma once
 
+#include <stdint.h>
+
 #include "objdat.h"
 #include "textdat.h"
 #include "itemdat.h"
@@ -15,35 +17,35 @@ namespace devilution {
 
 struct ObjectStruct {
 	_object_id _otype;
-	Sint32 _ox;
-	Sint32 _oy;
+	int _ox;
+	int _oy;
 	bool _oLight;
-	Uint32 _oAnimFlag;
+	uint32_t _oAnimFlag;
 	unsigned char *_oAnimData;
-	Sint32 _oAnimDelay; // Tick length of each frame in the current animation
-	Sint32 _oAnimCnt;   // Increases by one each game tick, counting how close we are to _pAnimDelay
-	Sint32 _oAnimLen;   // Number of frames in current animation
-	Sint32 _oAnimFrame; // Current frame of animation.
-	Sint32 _oAnimWidth;
-	Sint32 _oAnimWidth2;
+	int _oAnimDelay; // Tick length of each frame in the current animation
+	int _oAnimCnt;   // Increases by one each game tick, counting how close we are to _pAnimDelay
+	int _oAnimLen;   // Number of frames in current animation
+	int _oAnimFrame; // Current frame of animation.
+	int _oAnimWidth;
+	int _oAnimWidth2;
 	bool _oDelFlag;
-	Sint8 _oBreak;
+	int8_t _oBreak;
 	bool _oSolidFlag;
 	bool _oMissFlag;
-	Uint8 _oSelFlag;
+	uint8_t _oSelFlag;
 	bool _oPreFlag;
 	bool _oTrapFlag;
 	bool _oDoorFlag;
-	Sint32 _olid;
-	Sint32 _oRndSeed;
-	Sint32 _oVar1;
-	Sint32 _oVar2;
-	Sint32 _oVar3;
-	Sint32 _oVar4;
-	Sint32 _oVar5;
-	Sint32 _oVar6;
+	int _olid;
+	int _oRndSeed;
+	int _oVar1;
+	int _oVar2;
+	int _oVar3;
+	int _oVar4;
+	int _oVar5;
+	int _oVar6;
 	_speech_id _oVar7;
-	Sint32 _oVar8;
+	int _oVar8;
 };
 
 extern int objectactive[MAXOBJECTS];
diff --git a/Source/options.h b/Source/options.h
index 1f1d4070..35c68bfd 100644
--- a/Source/options.h
+++ b/Source/options.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <stdint.h>
+
 #include "pack.h"
 
 namespace devilution {
@@ -18,9 +20,9 @@ struct HellfireOptions {
 
 struct AudioOptions {
 	/** @brief Movie and SFX volume. */
-	Sint32 nSoundVolume;
+	int nSoundVolume;
 	/** @brief Music volume. */
-	Sint32 nMusicVolume;
+	int nMusicVolume;
 	/** @brief Player emits sound when walking. */
 	bool bWalkingSound;
 	/** @brief Automatically equipping items on pickup emits the equipment sound. */
@@ -29,9 +31,9 @@ struct AudioOptions {
 
 struct GraphicsOptions {
 	/** @brief Render width. */
-	Sint32 nWidth;
+	int nWidth;
 	/** @brief Render height. */
-	Sint32 nHeight;
+	int nHeight;
 	/** @brief Run in fullscreen or windowed mode. */
 	bool bFullscreen;
 	/** @brief Scale the image after rendering. */
@@ -47,7 +49,7 @@ struct GraphicsOptions {
 	/** @brief Use blended transparency rather than stippled. */
 	bool bBlendedTransparancy;
 	/** @brief Gamma correction level. */
-	Sint32 nGammaCorrection;
+	int nGammaCorrection;
 	/** @brief Enable color cycling animations. */
 	bool bColorCycling;
 	/** @brief Enable FPS Limit. */
@@ -56,7 +58,7 @@ struct GraphicsOptions {
 
 struct GameplayOptions {
 	/** @brief Gameplay ticks per second. */
-	Sint32 nTickRate;
+	int nTickRate;
 	/** @brief Enable double walk speed when in town. */
 	bool bRunInTown;
 	/** @brief Do not let the mouse leave the application window. */
@@ -118,7 +120,7 @@ struct NetworkOptions {
 	/** @brief Most recently entered Hostname in join dialog. */
 	char szPreviousHost[129];
 	/** @brief What network port to use. */
-	Uint16 nPort;
+	uint16_t nPort;
 };
 
 struct ChatOptions {
diff --git a/Source/pack.cpp b/Source/pack.cpp
index 0308ef9d..44e83f3a 100644
--- a/Source/pack.cpp
+++ b/Source/pack.cpp
@@ -67,7 +67,7 @@ void PackPlayer(PkPlayerStruct *pPack, int pnum, bool manashield)
 		pPack->targy = pPlayer->position.current.y;
 	}
 	strcpy(pPack->pName, pPlayer->_pName);
-	pPack->pClass = static_cast<Sint8>(pPlayer->_pClass);
+	pPack->pClass = static_cast<int8_t>(pPlayer->_pClass);
 	pPack->pBaseStr = pPlayer->_pBaseStr;
 	pPack->pBaseMag = pPlayer->_pBaseMag;
 	pPack->pBaseDex = pPlayer->_pBaseDex;
diff --git a/Source/path.cpp b/Source/path.cpp
index 2a45dafa..0c4efd0c 100644
--- a/Source/path.cpp
+++ b/Source/path.cpp
@@ -21,7 +21,7 @@ int gdwCurNodes;
  * for reconstructing the path after the A* search is done. The longest
  * possible path is actually 24 steps, even though we can fit 25
  */
-Sint8 pnode_vals[MAX_PATH_LENGTH];
+int8_t pnode_vals[MAX_PATH_LENGTH];
 /** A linked list of all visited nodes */
 PATHNODE *pnode_ptr;
 /** A stack for recursively searching nodes */
@@ -44,14 +44,14 @@ const char pathydir[8] = { -1, 1, -1, 1, 0, -1, 0, 1 };
  * dy 0|2 0 3
  *    1|8 4 7
  */
-Sint8 path_directions[9] = { 5, 1, 6, 2, 0, 3, 8, 4, 7 };
+int8_t path_directions[9] = { 5, 1, 6, 2, 0, 3, 8, 4, 7 };
 
 /**
  * find the shortest path from (sx,sy) to (dx,dy), using PosOk(PosOkArg,x,y) to
  * check that each step is a valid position. Store the step directions (see
  * path_directions) in path, which must have room for 24 steps
  */
-int FindPath(bool (*PosOk)(int, int, int), int PosOkArg, int sx, int sy, int dx, int dy, Sint8 path[MAX_PATH_LENGTH])
+int FindPath(bool (*PosOk)(int, int, int), int PosOkArg, int sx, int sy, int dx, int dy, int8_t path[MAX_PATH_LENGTH])
 {
 	PATHNODE *path_start, *next_node, *current;
 	int path_length, i;
diff --git a/Source/path.h b/Source/path.h
index 2cb7be26..78700668 100644
--- a/Source/path.h
+++ b/Source/path.h
@@ -12,9 +12,9 @@ namespace devilution {
 #define MAX_PATH_LENGTH 25
 
 struct PATHNODE {
-	Uint8 f;
-	Uint8 h;
-	Uint8 g;
+	uint8_t f;
+	uint8_t h;
+	uint8_t g;
 	int x;
 	int y;
 	struct PATHNODE *Parent;
@@ -22,7 +22,7 @@ struct PATHNODE {
 	struct PATHNODE *NextNode;
 };
 
-int FindPath(bool (*PosOk)(int, int, int), int PosOkArg, int sx, int sy, int dx, int dy, Sint8 path[MAX_PATH_LENGTH]);
+int FindPath(bool (*PosOk)(int, int, int), int PosOkArg, int sx, int sy, int dx, int dy, int8_t path[MAX_PATH_LENGTH]);
 int path_get_h_cost(int sx, int sy, int dx, int dy);
 PATHNODE *GetNextPath();
 bool path_solid_pieces(PATHNODE *pPath, int dx, int dy);
diff --git a/Source/pfile.cpp b/Source/pfile.cpp
index 2be53f58..99859609 100644
--- a/Source/pfile.cpp
+++ b/Source/pfile.cpp
@@ -131,7 +131,7 @@ static DWORD pfile_get_save_num_from_name(const char *name)
 	return i;
 }
 
-static BYTE *pfile_read_archive(HANDLE archive, const char *pszName, DWORD *pdwLen)
+static BYTE *pfile_read_archive(HANDLE archive, const char *pszName, uint32_t *pdwLen)
 {
 	DWORD nread;
 	HANDLE file;
@@ -296,12 +296,12 @@ bool pfile_archive_contains_game(HANDLE hsArchive)
 	if (gbIsMultiplayer)
 		return false;
 
-	DWORD dwLen;
+	uint32_t dwLen;
 	BYTE *gameData = pfile_read_archive(hsArchive, "game", &dwLen);
 	if (gameData == nullptr)
 		return false;
 
-	Uint32 hdr = LOAD_LE32(gameData);
+	uint32_t hdr = LOAD_LE32(gameData);
 	mem_free_dbg(gameData);
 
 	return IsHeaderValid(hdr);
diff --git a/Source/player.cpp b/Source/player.cpp
index a4753a69..1cdb53f0 100644
--- a/Source/player.cpp
+++ b/Source/player.cpp
@@ -3,8 +3,8 @@
  *
  * Implementation of player functionality, leveling, actions, creation, loading, etc.
  */
-#include <SDL.h>
 #include <algorithm>
+#include <stdint.h>
 
 #include "control.h"
 #include "cursor.h"
@@ -3615,7 +3615,7 @@ void ValidatePlayer()
 		plr[myplr]._pBaseVit = plr[myplr].GetMaximumAttributeValue(CharacterAttribute::Vitality);
 	}
 
-	Uint64 msk = 0;
+	uint64_t msk = 0;
 	for (b = SPL_FIREBOLT; b < MAX_SPELLS; b++) {
 		if (GetSpellBookLevel((spell_id)b) != -1) {
 			msk |= GetSpellBitmask(b);
diff --git a/Source/player.h b/Source/player.h
index 0f7440af..497d91b0 100644
--- a/Source/player.h
+++ b/Source/player.h
@@ -5,7 +5,6 @@
  */
 #pragma once
 
-#include <SDL.h>
 #include <stdint.h>
 
 #include "diablo.h"
diff --git a/Source/plrmsg.h b/Source/plrmsg.h
index dd76a513..4bbdb24f 100644
--- a/Source/plrmsg.h
+++ b/Source/plrmsg.h
@@ -5,13 +5,16 @@
  */
 #pragma once
 
+#include "SDL.h"
+#include <stdint.h>
+
 #include "engine.h"
 
 namespace devilution {
 
 struct _plrmsg {
 	Uint32 time;
-	Uint8 player;
+	uint8_t player;
 	char str[144];
 };
 
diff --git a/Source/portal.h b/Source/portal.h
index 073c348f..435de9b8 100644
--- a/Source/portal.h
+++ b/Source/portal.h
@@ -13,9 +13,9 @@ namespace devilution {
 
 struct PortalStruct {
 	bool open;
-	Sint32 x;
-	Sint32 y;
-	Sint32 level;
+	int x;
+	int y;
+	int level;
 	dungeon_type ltype;
 	bool setlvl;
 };
diff --git a/Source/qol.cpp b/Source/qol.cpp
index 06e9e01b..6e83b469 100644
--- a/Source/qol.cpp
+++ b/Source/qol.cpp
@@ -85,9 +85,9 @@ void DrawMonsterHealthBar(const CelOutputBuffer &out)
 
 	MonsterStruct *mon = &monster[pcursmonst];
 
-	Sint32 width = qolArt->healthBox.w();
-	Sint32 height = qolArt->healthBox.h();
-	Sint32 xPos = (gnScreenWidth - width) / 2;
+	int width = qolArt->healthBox.w();
+	int height = qolArt->healthBox.h();
+	int xPos = (gnScreenWidth - width) / 2;
 
 	if (PANELS_COVER) {
 		if (invflag || sbookflag)
@@ -96,10 +96,10 @@ void DrawMonsterHealthBar(const CelOutputBuffer &out)
 			xPos += SPANEL_WIDTH / 2;
 	}
 
-	Sint32 yPos = 18;
-	Sint32 border = 3;
+	int yPos = 18;
+	int border = 3;
 
-	const Sint32 maxLife = std::max(mon->_mmaxhp, mon->_mhitpoints);
+	const int maxLife = std::max(mon->_mmaxhp, mon->_mhitpoints);
 
 	DrawArt(out, xPos, yPos, &qolArt->healthBox);
 	DrawHalfTransparentRectTo(out, xPos + border, yPos + border, width - (border * 2), height - (border * 2));
@@ -111,16 +111,16 @@ void DrawMonsterHealthBar(const CelOutputBuffer &out)
 	if (sgOptions.Gameplay.bShowMonsterType) {
 		Uint8 borderColors[] = { 248 /*undead*/, 232 /*demon*/, 150 /*beast*/ };
 		Uint8 borderColor = borderColors[mon->MData->mMonstClass];
-		Sint32 borderWidth = width - (border * 2);
+		int borderWidth = width - (border * 2);
 		FastDrawHorizLine(out, xPos + border, yPos + border, borderWidth, borderColor);
 		FastDrawHorizLine(out, xPos + border, yPos + height - border - 1, borderWidth, borderColor);
-		Sint32 borderHeight = height - (border * 2) - 2;
+		int borderHeight = height - (border * 2) - 2;
 		FastDrawVertLine(out, xPos + border, yPos + border + 1, borderHeight, borderColor);
 		FastDrawVertLine(out, xPos + width - border - 1, yPos + border + 1, borderHeight, borderColor);
 	}
 
-	Sint32 barLableX = xPos + width / 2 - GetTextWidth(mon->mName) / 2;
-	Sint32 barLableY = yPos + 10 + (height - 11) / 2;
+	int barLableX = xPos + width / 2 - GetTextWidth(mon->mName) / 2;
+	int barLableY = yPos + 10 + (height - 11) / 2;
 	PrintGameStr(out, barLableX - 1, barLableY + 1, mon->mName, COL_BLACK);
 	text_color color = COL_WHITE;
 	if (mon->_uniqtype != 0)
@@ -133,8 +133,8 @@ void DrawMonsterHealthBar(const CelOutputBuffer &out)
 		monster_resistance immunes[] = { IMMUNE_MAGIC, IMMUNE_FIRE, IMMUNE_LIGHTNING };
 		monster_resistance resists[] = { RESIST_MAGIC, RESIST_FIRE, RESIST_LIGHTNING };
 
-		Sint32 resOffset = 5;
-		for (Sint32 i = 0; i < 3; i++) {
+		int resOffset = 5;
+		for (int i = 0; i < 3; i++) {
 			if (mon->mMagicRes & immunes[i]) {
 				DrawArt(out, xPos + resOffset, yPos + height - 6, &qolArt->resistance, i * 2 + 1);
 				resOffset += qolArt->resistance.w() + 2;
diff --git a/Source/qol/common.cpp b/Source/qol/common.cpp
index 62e35cf3..ca8c12f2 100644
--- a/Source/qol/common.cpp
+++ b/Source/qol/common.cpp
@@ -4,12 +4,14 @@
 * Common functions for QoL features
 */
 
+#include <SDL.h>
+
 #include "common.h"
 #include "engine.h"
 
 namespace devilution {
 
-void FastDrawHorizLine(const CelOutputBuffer &out, int x, int y, int width, BYTE col)
+void FastDrawHorizLine(const CelOutputBuffer &out, int x, int y, int width, Uint8 col)
 {
 	memset(out.at(x, y), col, width);
 }
diff --git a/Source/qol/common.h b/Source/qol/common.h
index 4e4dde4d..65b6763d 100644
--- a/Source/qol/common.h
+++ b/Source/qol/common.h
@@ -5,7 +5,7 @@
 */
 #pragma once
 
-#include "SDL_stdinc.h" // for Uint8
+#include <SDL.h>
 
 namespace devilution {
 
diff --git a/Source/qol/xpbar.cpp b/Source/qol/xpbar.cpp
index e931f59f..84d1f4ac 100644
--- a/Source/qol/xpbar.cpp
+++ b/Source/qol/xpbar.cpp
@@ -86,15 +86,15 @@ void DrawXPBar(const CelOutputBuffer &out)
 	if (player._pExperience < prevXp)
 		return;
 
-	Uint64 prevXpDelta_1 = player._pExperience - prevXp;
-	Uint64 prevXpDelta = ExpLvlsTbl[charLevel] - prevXp;
-	Uint64 fullBar = BAR_WIDTH * prevXpDelta_1 / prevXpDelta;
+	uint64_t prevXpDelta_1 = player._pExperience - prevXp;
+	uint64_t prevXpDelta = ExpLvlsTbl[charLevel] - prevXp;
+	uint64_t fullBar = BAR_WIDTH * prevXpDelta_1 / prevXpDelta;
 
 	// Figure out how much to fill the last pixel of the XP bar, to make it gradually appear with gained XP
-	Uint64 onePx = prevXpDelta / BAR_WIDTH + 1;
-	Uint64 lastFullPx = fullBar * prevXpDelta / BAR_WIDTH;
+	uint64_t onePx = prevXpDelta / BAR_WIDTH + 1;
+	uint64_t lastFullPx = fullBar * prevXpDelta / BAR_WIDTH;
 
-	const Uint64 fade = (prevXpDelta_1 - lastFullPx) * (SILVER_GRADIENT.size() - 1) / onePx;
+	const uint64_t fade = (prevXpDelta_1 - lastFullPx) * (SILVER_GRADIENT.size() - 1) / onePx;
 
 	// Draw beginning of bar full brightness
 	DrawBar(out, xPos, yPos, fullBar, SILVER_GRADIENT);
diff --git a/Source/quests.h b/Source/quests.h
index 2258f1f1..88e940c3 100644
--- a/Source/quests.h
+++ b/Source/quests.h
@@ -40,26 +40,26 @@ enum quest_state : uint8_t {
 };
 
 struct QuestStruct {
-	Uint8 _qlevel;
-	Uint8 _qtype;
+	uint8_t _qlevel;
+	uint8_t _qtype;
 	quest_state _qactive;
 	dungeon_type _qlvltype;
-	Sint32 _qtx;
-	Sint32 _qty;
+	int _qtx;
+	int _qty;
 	_setlevels _qslvl;
-	Uint8 _qidx;
+	uint8_t _qidx;
 	_speech_id _qmsg;
-	Uint8 _qvar1;
-	Uint8 _qvar2;
+	uint8_t _qvar1;
+	uint8_t _qvar2;
 	bool _qlog;
 };
 
 struct QuestData {
-	Uint8 _qdlvl;
-	Sint8 _qdmultlvl;
+	uint8_t _qdlvl;
+	int8_t _qdmultlvl;
 	dungeon_type _qlvlt;
-	Uint8 _qdtype;
-	Uint8 _qdrnd;
+	uint8_t _qdtype;
+	uint8_t _qdrnd;
 	_setlevels _qslvl;
 	bool isSinglePlayerOnly;
 	_speech_id _qdmsg;
diff --git a/Source/sha.h b/Source/sha.h
index e417e495..93344752 100644
--- a/Source/sha.h
+++ b/Source/sha.h
@@ -5,15 +5,15 @@
  */
 #pragma once
 
-#include <SDL.h>
+#include <stdint.h>
 
 namespace devilution {
 
 #define SHA1HashSize 20
 
 struct SHA1Context {
-	Uint32 state[5];
-	Uint32 count[2];
+	uint32_t state[5];
+	uint32_t count[2];
 	char buffer[64];
 };
 
diff --git a/Source/spelldat.h b/Source/spelldat.h
index c86b38e5..50dc17db 100644
--- a/Source/spelldat.h
+++ b/Source/spelldat.h
@@ -198,23 +198,23 @@ enum missile_id : int8_t {
 
 struct SpellData {
 	spell_id sName;
-	Uint8 sManaCost;
+	uint8_t sManaCost;
 	magic_type sType;
 	const char *sNameText;
 	const char *sSkillText;
-	Sint32 sBookLvl;
-	Sint32 sStaffLvl;
+	int sBookLvl;
+	int sStaffLvl;
 	bool sTargeted;
 	bool sTownSpell;
-	Sint32 sMinInt;
+	int sMinInt;
 	_sfx_id sSFX;
 	missile_id sMissiles[3];
-	Uint8 sManaAdj;
-	Uint8 sMinMana;
-	Sint32 sStaffMin;
-	Sint32 sStaffMax;
-	Sint32 sBookCost;
-	Sint32 sStaffCost;
+	uint8_t sManaAdj;
+	uint8_t sMinMana;
+	int sStaffMin;
+	int sStaffMax;
+	int sBookCost;
+	int sStaffCost;
 };
 
 extern SpellData spelldata[];
diff --git a/Source/spells.cpp b/Source/spells.cpp
index 0eefa704..70395c92 100644
--- a/Source/spells.cpp
+++ b/Source/spells.cpp
@@ -100,7 +100,7 @@ void UseMana(int id, spell_id sn)
  * @param spellId The id of the spell to get a bitmask for.
  * @return A 64bit bitmask representation for the specified spell.
  */
-Uint64 GetSpellBitmask(int spellId)
+uint64_t GetSpellBitmask(int spellId)
 {
 	return 1ULL << (spellId - 1);
 }
diff --git a/Source/spells.h b/Source/spells.h
index 6374b238..0488c57d 100644
--- a/Source/spells.h
+++ b/Source/spells.h
@@ -11,7 +11,7 @@ namespace devilution {
 
 int GetManaAmount(int id, spell_id sn);
 void UseMana(int id, spell_id sn);
-Uint64 GetSpellBitmask(int spellId);
+uint64_t GetSpellBitmask(int spellId);
 bool CheckSpell(int id, spell_id sn, spell_type st, bool manaonly);
 void EnsureValidReadiedSpell(PlayerStruct &player);
 void CastSpell(int id, int spl, int sx, int sy, int dx, int dy, int spllvl);
diff --git a/Source/stores.cpp b/Source/stores.cpp
index 6e63ba3e..0bbd46b5 100644
--- a/Source/stores.cpp
+++ b/Source/stores.cpp
@@ -2057,9 +2057,9 @@ void S_DrunkEnter()
 
 ItemStruct golditem;
 
-Uint8 *pSTextBoxCels;
-Uint8 *pSPentSpn2Cels;
-Uint8 *pSTextSlidCels;
+BYTE *pSTextBoxCels;
+BYTE *pSPentSpn2Cels;
+BYTE *pSTextSlidCels;
 
 talk_id stextflag;
 
diff --git a/Source/storm/storm.h b/Source/storm/storm.h
index 850f15ed..c539d01d 100644
--- a/Source/storm/storm.h
+++ b/Source/storm/storm.h
@@ -4,6 +4,7 @@
 #include <cstdint>
 #include <limits>
 #include <string>
+#include <stdint.h>
 
 #include "appfat.h"
 #include "multi.h"
@@ -22,43 +23,43 @@ enum conn_type : uint8_t {
 };
 
 struct PCXHeader {
-	Uint8 Manufacturer;
-	Uint8 Version;
-	Uint8 Encoding;
-	Uint8 BitsPerPixel;
-	Uint16 Xmin;
-	Uint16 Ymin;
-	Uint16 Xmax;
-	Uint16 Ymax;
-	Uint16 HDpi;
-	Uint16 VDpi;
-	Uint8 Colormap[48];
-	Uint8 Reserved;
-	Uint8 NPlanes;
-	Uint16 BytesPerLine;
-	Uint16 PaletteInfo;
-	Uint16 HscreenSize;
-	Uint16 VscreenSize;
-	Uint8 Filler[54];
+	uint8_t Manufacturer;
+	uint8_t Version;
+	uint8_t Encoding;
+	uint8_t BitsPerPixel;
+	uint16_t Xmin;
+	uint16_t Ymin;
+	uint16_t Xmax;
+	uint16_t Ymax;
+	uint16_t HDpi;
+	uint16_t VDpi;
+	uint8_t Colormap[48];
+	uint8_t Reserved;
+	uint8_t NPlanes;
+	uint16_t BytesPerLine;
+	uint16_t PaletteInfo;
+	uint16_t HscreenSize;
+	uint16_t VscreenSize;
+	uint8_t Filler[54];
 };
 
 struct _SNETCAPS {
-	Uint32 size;
-	Uint32 flags;
-	Uint32 maxmessagesize;
-	Uint32 maxqueuesize;
-	Uint32 maxplayers;
-	Uint32 bytessec;
-	Uint32 latencyms;
-	Uint32 defaultturnssec;
-	Uint32 defaultturnsintransit;
+	uint32_t size;
+	uint32_t flags;
+	uint32_t maxmessagesize;
+	uint32_t maxqueuesize;
+	uint32_t maxplayers;
+	uint32_t bytessec;
+	uint32_t latencyms;
+	uint32_t defaultturnssec;
+	uint32_t defaultturnsintransit;
 };
 
 struct _SNETEVENT {
-	Uint32 eventid;
-	Uint32 playerid;
+	uint32_t eventid;
+	uint32_t playerid;
 	void *data;
-	Uint32 databytes;
+	uint32_t databytes;
 };
 
 // Note to self: Linker error => forgot a return value in cpp
@@ -334,7 +335,7 @@ bool SNetGetOwnerTurnsWaiting(DWORD *);
 bool SNetUnregisterEventHandler(event_type, SEVTHANDLER);
 bool SNetRegisterEventHandler(event_type, SEVTHANDLER);
 bool SNetSetBasePlayer(int);
-bool SNetInitializeProvider(Uint32 provider, struct GameData *gameData);
+bool SNetInitializeProvider(uint32_t provider, struct GameData *gameData);
 int SNetGetProviderCaps(struct _SNETCAPS *);
 bool SFileEnableDirectAccess(bool enable);
 
diff --git a/Source/storm/storm_net.cpp b/Source/storm/storm_net.cpp
index 8777f889..101edd04 100644
--- a/Source/storm/storm_net.cpp
+++ b/Source/storm/storm_net.cpp
@@ -137,7 +137,7 @@ bool SNetLeaveGame(int type)
  * @brief Called by engine for single, called by ui for multi
  * @param provider BNET, IPXN, MODM, SCBL or UDPN
  */
-bool SNetInitializeProvider(Uint32 provider, struct GameData *gameData)
+bool SNetInitializeProvider(uint32_t provider, struct GameData *gameData)
 {
 #ifndef NONET
 	std::lock_guard<std::mutex> lg(storm_net_mutex);
diff --git a/Source/sync.cpp b/Source/sync.cpp
index 65c6f33c..f46b65df 100644
--- a/Source/sync.cpp
+++ b/Source/sync.cpp
@@ -6,6 +6,7 @@
 #include <climits>
 
 #include "gendung.h"
+#include "miniwin/miniwin.h"
 #include "monster.h"
 #include "player.h"
 
@@ -13,9 +14,9 @@ namespace devilution {
 
 namespace {
 
-Uint16 sgnMonsterPriority[MAXMONSTERS];
+uint16_t sgnMonsterPriority[MAXMONSTERS];
 int sgnMonsters;
-Uint16 sgwLRU[MAXMONSTERS];
+uint16_t sgwLRU[MAXMONSTERS];
 int sgnSyncItem;
 int sgnSyncPInv;
 
@@ -49,7 +50,7 @@ static void sync_monster_pos(TSyncMonster *p, int ndx)
 static bool sync_monster_active(TSyncMonster *p)
 {
 	int i, m, ndx;
-	Uint32 lru;
+	uint32_t lru;
 
 	ndx = -1;
 	lru = 0xFFFFFFFF;
@@ -73,7 +74,7 @@ static bool sync_monster_active(TSyncMonster *p)
 static bool sync_monster_active2(TSyncMonster *p)
 {
 	int i, m, ndx;
-	Uint32 lru;
+	uint32_t lru;
 
 	ndx = -1;
 	lru = 0xFFFE;
@@ -158,7 +159,7 @@ static void SyncPlrInv(TSyncHeader *pHdr)
 
 } // namespace
 
-Uint32 sync_all_monsters(const Uint8 *pbBuf, Uint32 dwMaxLen)
+uint32_t sync_all_monsters(const BYTE *pbBuf, uint32_t dwMaxLen)
 {
 	TSyncHeader *pHdr;
 	int i;
@@ -204,7 +205,7 @@ Uint32 sync_all_monsters(const Uint8 *pbBuf, Uint32 dwMaxLen)
 static void sync_monster(int pnum, const TSyncMonster *p)
 {
 	int ndx, mdx, mdy;
-	Uint32 delta;
+	uint32_t delta;
 
 	ndx = p->_mndx;
 
@@ -253,10 +254,10 @@ static void sync_monster(int pnum, const TSyncMonster *p)
 	decode_enemy(ndx, p->_menemy);
 }
 
-Uint32 sync_update(int pnum, const Uint8 *pbBuf)
+uint32_t sync_update(int pnum, const BYTE *pbBuf)
 {
 	TSyncHeader *pHdr;
-	Uint16 wLen;
+	uint16_t wLen;
 
 	pHdr = (TSyncHeader *)pbBuf;
 	pbBuf += sizeof(*pHdr);
diff --git a/Source/sync.h b/Source/sync.h
index 709992fa..80b6501f 100644
--- a/Source/sync.h
+++ b/Source/sync.h
@@ -5,10 +5,14 @@
  */
 #pragma once
 
+#include <stdint.h>
+
+#include "miniwin/miniwin.h"
+
 namespace devilution {
 
-Uint32 sync_all_monsters(const Uint8 *pbBuf, Uint32 dwMaxLen);
-Uint32 sync_update(int pnum, const Uint8 *pbBuf);
+uint32_t sync_all_monsters(const BYTE *pbBuf, uint32_t dwMaxLen);
+uint32_t sync_update(int pnum, const BYTE *pbBuf);
 void sync_init();
 
 } // namespace devilution
diff --git a/Source/themes.h b/Source/themes.h
index bf52d6dd..da7977f8 100644
--- a/Source/themes.h
+++ b/Source/themes.h
@@ -5,6 +5,8 @@
  */
 #pragma once
 
+#include <stdint.h>
+
 #include "gendung.h"
 #include "objdat.h"
 
@@ -12,7 +14,7 @@ namespace devilution {
 
 struct ThemeStruct {
 	theme_id ttype;
-	Sint16 ttval;
+	int16_t ttval;
 };
 
 extern int numthemes;
diff --git a/Source/tmsg.cpp b/Source/tmsg.cpp
index 02061098..1621d009 100644
--- a/Source/tmsg.cpp
+++ b/Source/tmsg.cpp
@@ -15,7 +15,7 @@ TMsg *sgpTimedMsgHead;
 
 } // namespace
 
-int tmsg_get(Uint8 *pbMsg)
+int tmsg_get(BYTE *pbMsg)
 {
 	int len;
 	TMsg *head;
@@ -34,7 +34,7 @@ int tmsg_get(Uint8 *pbMsg)
 	return len;
 }
 
-void tmsg_add(Uint8 *pbMsg, Uint8 bLen)
+void tmsg_add(BYTE *pbMsg, uint8_t bLen)
 {
 	TMsg **tail;
 
diff --git a/Source/tmsg.h b/Source/tmsg.h
index 22bbf296..133ae8a2 100644
--- a/Source/tmsg.h
+++ b/Source/tmsg.h
@@ -5,27 +5,29 @@
  */
 #pragma once
 
-#include <SDL.h>
+#include <stdint.h>
+
+#include "miniwin/miniwin.h"
 
 namespace devilution {
 
 #pragma pack(push, 1)
 struct TMsgHdr {
 	struct TMsg *pNext;
-	Sint32 dwTime;
-	Uint8 bLen;
+	int32_t dwTime;
+	uint8_t bLen;
 };
 
 struct TMsg {
 	TMsgHdr hdr;
 	// this is actually alignment padding, but the message body is appended to the struct
 	// so it's convenient to use byte-alignment and name it "body"
-	Uint8 body[3];
+	uint8_t body[3];
 };
 #pragma pack(pop)
 
-int tmsg_get(Uint8 *pbMsg);
-void tmsg_add(Uint8 *pbMsg, Uint8 bLen);
+int tmsg_get(BYTE *pbMsg);
+void tmsg_add(BYTE *pbMsg, uint8_t bLen);
 void tmsg_start();
 void tmsg_cleanup();
 
diff --git a/Source/town.cpp b/Source/town.cpp
index ee0ae7c8..aebc0348 100644
--- a/Source/town.cpp
+++ b/Source/town.cpp
@@ -24,23 +24,23 @@ namespace {
  * @param w width of sector
  * @param h height of sector
  */
-void T_FillSector(Uint8 *P3Tiles, Uint8 *pSector, int xi, int yi, int w, int h)
+void T_FillSector(BYTE *P3Tiles, BYTE *pSector, int xi, int yi, int w, int h)
 {
 	int i, j, xx, yy, nMap;
-	Sint16 v1, v2, v3, v4, ii;
-	Uint16 *Sector;
+	int16_t v1, v2, v3, v4, ii;
+	uint16_t *Sector;
 
 	ii = 4;
 	yy = yi;
 	for (j = 0; j < h; j++) {
 		xx = xi;
 		for (i = 0; i < w; i++) {
-			Uint16 *Map;
+			uint16_t *Map;
 
-			Map = (Uint16 *)&pSector[ii];
+			Map = (uint16_t *)&pSector[ii];
 			nMap = SDL_SwapLE16(*Map);
 			if (nMap) {
-				Sector = (((Uint16 *)&P3Tiles[(nMap - 1) * 8]));
+				Sector = (((uint16_t *)&P3Tiles[(nMap - 1) * 8]));
 				v1 = SDL_SwapLE16(*(Sector + 0)) + 1;
 				v2 = SDL_SwapLE16(*(Sector + 1)) + 1;
 				v3 = SDL_SwapLE16(*(Sector + 2)) + 1;
@@ -70,12 +70,12 @@ void T_FillSector(Uint8 *P3Tiles, Uint8 *pSector, int xi, int yi, int w, int h)
  * @param yy upper left destination
  * @param t tile id
  */
-void T_FillTile(Uint8 *P3Tiles, int xx, int yy, int t)
+void T_FillTile(BYTE *P3Tiles, int xx, int yy, int t)
 {
 	long v1, v2, v3, v4;
-	Uint16 *Tiles;
+	uint16_t *Tiles;
 
-	Tiles = ((Uint16 *)&P3Tiles[(t - 1) * 8]);
+	Tiles = ((uint16_t *)&P3Tiles[(t - 1) * 8]);
 	v1 = SDL_SwapLE16(*(Tiles + 0)) + 1;
 	v2 = SDL_SwapLE16(*(Tiles + 1)) + 1;
 	v3 = SDL_SwapLE16(*(Tiles + 2)) + 1;
@@ -165,7 +165,7 @@ void TownCloseGrave()
 void T_Pass3()
 {
 	int xx, yy, x;
-	Uint8 *P3Tiles, *pSector;
+	BYTE *P3Tiles, *pSector;
 
 	for (yy = 0; yy < MAXDUNY; yy += 2) {
 		for (xx = 0; xx < MAXDUNX; xx += 2) {
diff --git a/Source/utils/soundsample.cpp b/Source/utils/soundsample.cpp
index 203e9868..1f566e41 100644
--- a/Source/utils/soundsample.cpp
+++ b/Source/utils/soundsample.cpp
@@ -123,9 +123,9 @@ int SoundSample::GetLength()
 		bytePerSample = 1;
 	}
 
-	Uint64 ms = 1000;                                  // milliseconds, 64bit to avoid overflow when multiplied by alen
-	Uint32 bps = frequency * channels * bytePerSample; // bytes per second
-	return (Uint32)(chunk->alen * ms / bps);
+	uint64_t ms = 1000;                             // milliseconds, 64bit to avoid overflow when multiplied by alen
+	int bps = frequency * channels * bytePerSample; // bytes per second
+	return (int)(chunk->alen * ms / bps);
 };
 
 } // namespace devilution
diff --git a/test/lighting_test.cpp b/test/lighting_test.cpp
index 962cb3e2..fa3ed0b4 100644
--- a/test/lighting_test.cpp
+++ b/test/lighting_test.cpp
@@ -16,7 +16,7 @@ TEST(Lighting, CrawlTables)
 		int x = 20;
 		int y = 20;
 		int cr = CrawlNum[j] + 1;
-		for (int i = (Uint8)CrawlTable[cr - 1]; i > 0; i--, cr += 2) {
+		for (unsigned i = (uint8_t)CrawlTable[cr - 1]; i > 0; i--, cr += 2) {
 			int dx = x + CrawlTable[cr];
 			int dy = y + CrawlTable[cr + 1];
 			sprintf(tempstr, "location %d:%d added twice.", dx - 20, dy - 20);
diff --git a/test/writehero_test.cpp b/test/writehero_test.cpp
index 5c0dc4c5..2380b10a 100644
--- a/test/writehero_test.cpp
+++ b/test/writehero_test.cpp
@@ -2,6 +2,7 @@
 #include <fstream>
 #include <gtest/gtest.h>
 #include <vector>
+#include <stdint.h>
 
 #include "loadsave.h"
 #include "pack.h"
@@ -116,7 +117,7 @@ static void PackItemArmor(PkItemStruct *id)
 
 static void PackItemFullRejuv(PkItemStruct *id, int i)
 {
-	const Uint32 seeds[] = { 0x7C253335, 0x3EEFBFF8, 0x76AFB1A9, 0x38EB45FE, 0x1154E197, 0x5964B644, 0x76B58BEB, 0x002A6E5A };
+	const uint32_t seeds[] = { 0x7C253335, 0x3EEFBFF8, 0x76AFB1A9, 0x38EB45FE, 0x1154E197, 0x5964B644, 0x76B58BEB, 0x002A6E5A };
 	id->idx = ItemMiscIdIdx(IMISC_FULLREJUV);
 	id->iSeed = seeds[i];
 	id->iCreateInfo = 0;
@@ -188,7 +189,7 @@ static void PackPlayerTest(PkPlayerStruct *pPack)
 	for (auto i = 0; i < 7; i++)
 		pPack->InvBody[i].idx = -1;
 	strcpy(pPack->pName, "TestPlayer");
-	pPack->pClass = static_cast<Sint8>(HeroClass::Rogue);
+	pPack->pClass = static_cast<int8_t>(HeroClass::Rogue);
 	pPack->pBaseStr = 20 + 35;
 	pPack->pBaseMag = 15 + 55;
 	pPack->pBaseDex = 30 + 220;
@@ -221,7 +222,7 @@ static int CountItems(ItemStruct *items, int n)
 	return count;
 }
 
-static int Count8(Sint8 *ints, int n)
+static int Count8(int8_t *ints, int n)
 {
 	int count = n;
 	for (int i = 0; i < n; i++)