devilutionX/Source/player.cpp

//HEADER_GOES_HERE

#include "../types.h"

#ifndef NO_GLOBALS
int plr_lframe_size; // idb
int plr_wframe_size; // idb
UCHAR plr_gfx_flag = 0;
int player_cpp_init_value; // weak
int plr_aframe_size;	   // idb
int myplr;
PlayerStruct plr[MAX_PLRS];
int plr_fframe_size; // idb
int plr_qframe_size; // idb
int deathflag;		 // idb
int plr_hframe_size; // idb
int plr_bframe_size; // idb
UCHAR plr_gfx_bflag = 0;
int plr_sframe_size; // idb
int deathdelay;		 // weak
int plr_dframe_size; // idb
#endif

const int player_inf = 0x7F800000; // weak
const char ArmourChar[4] = {'L', 'M', 'H', 0};
const char WepChar[10] = {'N', 'U', 'S', 'D', 'B', 'A', 'M', 'H', 'T', 0};
const char CharChar[4] = {'W', 'R', 'S', 0};

/* data */

int plrxoff[9] = {0, 2, 0, 2, 1, 0, 1, 2, 1};
int plryoff[9] = {0, 2, 2, 0, 1, 1, 0, 1, 2};
int plrxoff2[9] = {0, 1, 0, 1, 2, 0, 1, 2, 2};
int plryoff2[9] = {0, 0, 1, 1, 0, 2, 2, 1, 2};
char PlrGFXAnimLens[3][11] =
	{
		{10, 16, 8, 2, 20, 20, 6, 20, 8, 9, 14},
		{8, 18, 8, 4, 20, 16, 7, 20, 8, 10, 12},
		{8, 16, 8, 6, 20, 12, 8, 20, 8, 12, 8}};
int PWVel[4][3] = {{2048, 1024, 512}, {2048, 1024, 512}, {2048, 1024, 512}, {8, 8, 8}};
int StrengthTbl[3] = {30, 20, 15};
int MagicTbl[3] = {10, 15, 35};
int DexterityTbl[3] = {20, 30, 15};
int VitalityTbl[3] = {25, 20, 20};
int ToBlkTbl[3] = {30, 20, 10};
char *ClassStrTblOld[3] = {"Warrior", "Rogue", "Sorceror"}; // unused
int MaxStats[3][4] = {{250, 50, 60, 100}, {55, 70, 250, 80}, {45, 250, 85, 80}};
int ExpLvlsTbl[51] =
	{
		0,
		2000,
		4620,
		8040,
		12489,
		18258,
		25712,
		35309,
		47622,
		63364,
		83419,
		108879,
		141086,
		181683,
		231075,
		313656,
		424067,
		571190,
		766569,
		1025154,
		1366227,
		1814568,
		2401895,
		3168651,
		4166200,
		5459523,
		7130496,
		9281874,
		12042092,
		15571031,
		20066900,
		25774405,
		32994399,
		42095202,
		53525811,
		67831218,
		85670061,
		107834823,
		135274799,
		169122009,
		210720231,
		261657253,
		323800420,
		399335440,
		490808349,
		601170414,
		733825617,
		892680222,
		1082908612,
		1310707109,
		1583495809};
char *ClassStrTbl[3] = {"Warrior", "Rogue", "Sorceror"};
unsigned char fix[9] = {0u, 0u, 3u, 3u, 3u, 6u, 6u, 6u, 8u}; /* PM_ChangeLightOff local type */

struct player_cpp_init
{
	player_cpp_init()
	{
		player_cpp_init_value = player_inf;
	}
} _player_cpp_init;
// 47F204: using guessed type int player_inf;
// 68643C: using guessed type int player_cpp_init_value;

void __fastcall SetPlayerGPtrs(UCHAR *pData, UCHAR **pAnim)
{
	for (int i = 0; i < 8; i++)
	{
		pAnim[i] = pData + ((DWORD *)pData)[i];
	}
}

void __fastcall LoadPlrGFX(int pnum, player_graphic gfxflag)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("LoadPlrGFX: illegal player %d", pnum);
	}

	char prefix[16];
	char pszName[256];
	char *szCel;
	PlayerStruct *p = &plr[pnum];
	sprintf(prefix, "%c%c%c", CharChar[p->_pClass], ArmourChar[p->_pgfxnum >> 4], WepChar[p->_pgfxnum & 0xF]);
	char *cs = ClassStrTbl[p->_pClass];
	UCHAR *pData;
	UCHAR *pAnim;

	for (DWORD i = 1; i <= PFILE_NONDEATH; i <<= 1)
	{
		if (!(i & gfxflag))
		{
			continue;
		}

		switch (i)
		{
		case PFILE_STAND:
			szCel = "AS";
			if (leveltype == DTYPE_TOWN)
			{
				szCel = "ST";
			}
			pData = p->_pNData;
			pAnim = (UCHAR *)p->_pNAnim;
			break;
		case PFILE_WALK:
			szCel = "AW";
			if (leveltype == DTYPE_TOWN)
			{
				szCel = "WL";
			}
			pData = p->_pWData;
			pAnim = (UCHAR *)p->_pWAnim;
			break;
		case PFILE_ATTACK:
			if (leveltype == DTYPE_TOWN)
			{
				continue;
			}
			szCel = "AT";
			pData = p->_pAData;
			pAnim = (UCHAR *)p->_pAAnim;
			break;
		case PFILE_HIT:
			if (leveltype == DTYPE_TOWN)
			{
				continue;
			}
			szCel = "HT";
			pData = p->_pHData;
			pAnim = (UCHAR *)p->_pHAnim;
			break;
		case PFILE_LIGHTNING:
			if (leveltype == DTYPE_TOWN)
			{
				continue;
			}
			szCel = "LM";
			pData = p->_pLData;
			pAnim = (UCHAR *)p->_pLAnim;
			break;
		case PFILE_FIRE:
			if (leveltype == DTYPE_TOWN)
			{
				continue;
			}
			szCel = "FM";
			pData = p->_pFData;
			pAnim = (UCHAR *)p->_pFAnim;
			break;
		case PFILE_MAGIC:
			if (leveltype == DTYPE_TOWN)
			{
				continue;
			}
			szCel = "QM";
			pData = p->_pTData;
			pAnim = (UCHAR *)p->_pTAnim;
			break;
		case PFILE_DEATH:
			if (p->_pgfxnum & 0xF)
			{
				continue;
			}
			szCel = "DT";
			pData = p->_pDData;
			pAnim = (UCHAR *)p->_pDAnim;
			break;
		case PFILE_BLOCK:
			if (leveltype == DTYPE_TOWN)
			{
				continue;
			}
			if (!p->_pBlockFlag)
			{
				continue;
			}

			szCel = "BL";
			pData = p->_pBData;
			pAnim = (UCHAR *)p->_pBAnim;
			break;
		default:
			TermMsg("PLR:2");
			break;
		}

		sprintf(pszName, "PlrGFX\\%s\\%s\\%s%s.CL2", cs, prefix, prefix, szCel);
		LoadFileWithMem(pszName, pData);
		SetPlayerGPtrs((UCHAR *)pData, (UCHAR **)pAnim);
		p->_pGFXLoad |= i;
	}
}
// 5BB1ED: using guessed type char leveltype;

void __fastcall InitPlayerGFX(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("InitPlayerGFX: illegal player %d", pnum);
	}

	if (plr[pnum]._pHitPoints >> 6 == 0)
	{
		plr[pnum]._pgfxnum = 0;
		LoadPlrGFX(pnum, PFILE_DEATH);
	}
	else
	{
		LoadPlrGFX(pnum, PFILE_NONDEATH);
	}
}

void __fastcall InitPlrGFXMem(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("InitPlrGFXMem: illegal player %d", pnum);
	}

	if (!(plr_gfx_flag & 0x1))
	{ //STAND
		plr_gfx_flag |= 0x1;
		if (GetPlrGFXSize("ST") > GetPlrGFXSize("AS"))
		{
			plr_sframe_size = GetPlrGFXSize("ST"); //TOWN
		}
		else
		{
			plr_sframe_size = GetPlrGFXSize("AS"); //DUNGION
		}
	}
	plr[pnum]._pNData = DiabloAllocPtr(plr_sframe_size);

	if (!(plr_gfx_flag & 0x2))
	{ //WALK
		plr_gfx_flag |= 0x2;
		if (GetPlrGFXSize("WL") > GetPlrGFXSize("AW"))
		{
			plr_wframe_size = GetPlrGFXSize("WL"); //TOWN
		}
		else
		{
			plr_wframe_size = GetPlrGFXSize("AW"); //DUNGION
		}
	}
	plr[pnum]._pWData = DiabloAllocPtr(plr_wframe_size);

	if (!(plr_gfx_flag & 0x4))
	{ //ATTACK
		plr_gfx_flag |= 0x4;
		plr_aframe_size = GetPlrGFXSize("AT");
	}
	plr[pnum]._pAData = DiabloAllocPtr(plr_aframe_size);

	if (!(plr_gfx_flag & 0x8))
	{ //HIT
		plr_gfx_flag |= 0x8;
		plr_hframe_size = GetPlrGFXSize("HT");
	}
	plr[pnum]._pHData = DiabloAllocPtr(plr_hframe_size);

	if (!(plr_gfx_flag & 0x10))
	{ //LIGHTNING
		plr_gfx_flag |= 0x10;
		plr_lframe_size = GetPlrGFXSize("LM");
	}
	plr[pnum]._pLData = DiabloAllocPtr(plr_lframe_size);

	if (!(plr_gfx_flag & 0x20))
	{ //FIRE
		plr_gfx_flag |= 0x20;
		plr_fframe_size = GetPlrGFXSize("FM");
	}
	plr[pnum]._pFData = DiabloAllocPtr(plr_fframe_size);

	if (!(plr_gfx_flag & 0x40))
	{ //MAGIC
		plr_gfx_flag |= 0x40;
		plr_qframe_size = GetPlrGFXSize("QM");
	}
	plr[pnum]._pTData = DiabloAllocPtr(plr_qframe_size);

	if (!(plr_gfx_flag & 0x80))
	{ //DEATH
		plr_gfx_flag |= 0x80;
		plr_dframe_size = GetPlrGFXSize("DT");
	}
	plr[pnum]._pDData = DiabloAllocPtr(plr_dframe_size);

	if (!(plr_gfx_bflag & 0x1))
	{ //BLOCK
		plr_gfx_bflag |= 0x1;
		plr_bframe_size = GetPlrGFXSize("BL");
	}
	plr[pnum]._pBData = DiabloAllocPtr(plr_bframe_size);

	plr[pnum]._pGFXLoad = 0;
}
// 686438: using guessed type char plr_gfx_flag;
// 69B7BC: using guessed type char plr_gfx_bflag;

DWORD __fastcall GetPlrGFXSize(char *szCel)
{
	char prefix[16];   // [esp+10Ch] [ebp-24h]
	char pszName[256]; // [esp+Ch] [ebp-124h]
	void *file;		   // [esp+124h] [ebp-Ch]
	DWORD size = 0;	// [esp+11Ch] [ebp-14h]
	DWORD result = 0;
	int a = 0;
	int w = 0;

	for (int c = 0; c < sizeof(ClassStrTbl) / sizeof(ClassStrTbl[0]); c++)
	{
		for (a = 0; ArmourChar[a]; a++)
		{
			for (w = 0; WepChar[w]; w++)
			{
				sprintf(prefix, "%c%c%c", CharChar[c], ArmourChar[a], WepChar[w]);
				sprintf(pszName, "PlrGFX\\%s\\%s\\%s%s.CL2", ClassStrTbl[c], prefix, prefix, szCel);
				if (WOpenFile(pszName, &file, TRUE))
				{
					size = WGetFileSize(file, 0);
					WCloseFile(file);
					if (result <= size)
					{
						result = size;
					}
				}
			}
		}
	}

	return result;
}

void __fastcall FreePlayerGFX(int pnum)
{
	void *ptr;

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("FreePlayerGFX: illegal player %d", pnum);
	}

	ptr = plr[pnum]._pNData;
	plr[pnum]._pNData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pWData;
	plr[pnum]._pWData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pAData;
	plr[pnum]._pAData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pHData;
	plr[pnum]._pHData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pLData;
	plr[pnum]._pLData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pFData;
	plr[pnum]._pFData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pTData;
	plr[pnum]._pTData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pDData;
	plr[pnum]._pDData = NULL;
	mem_free_dbg(ptr);
	ptr = plr[pnum]._pBData;
	plr[pnum]._pBData = NULL;
	mem_free_dbg(ptr);
	plr[pnum]._pGFXLoad = 0;
}

void __fastcall NewPlrAnim(int pnum, unsigned char *Peq, int numFrames, int Delay, int width)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("NewPlrAnim: illegal player %d", pnum);
	}

	plr[pnum]._pAnimData = Peq;
	plr[pnum]._pAnimLen = numFrames;
	plr[pnum]._pAnimFrame = 1;
	plr[pnum]._pAnimCnt = 0;
	plr[pnum]._pAnimDelay = Delay;
	plr[pnum]._pAnimWidth = width;
	plr[pnum]._pAnimWidth2 = (width - 64) >> 1;
}

void __fastcall ClearPlrPVars(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ClearPlrPVars: illegal player %d", pnum);
	}

	plr[pnum]._pVar1 = 0;
	plr[pnum]._pVar2 = 0;
	plr[pnum]._pVar3 = 0;
	plr[pnum]._pVar4 = 0;
	plr[pnum]._pVar5 = 0;
	plr[pnum]._pVar6 = 0;
	plr[pnum]._pVar7 = 0;
	plr[pnum]._pVar8 = 0;
}

void __fastcall SetPlrAnims(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlrAnims: illegal player %d", pnum);
	}

	int pc = plr[pnum]._pClass;

	plr[pnum]._pNWidth = 96;
	plr[pnum]._pWWidth = 96;
	plr[pnum]._pAWidth = 128;
	plr[pnum]._pHWidth = 96;
	plr[pnum]._pSWidth = 96;
	plr[pnum]._pDWidth = 128;
	plr[pnum]._pBWidth = 96;

	if (leveltype == DTYPE_TOWN)
	{
		plr[pnum]._pNFrames = PlrGFXAnimLens[pc][7];
		plr[pnum]._pWFrames = PlrGFXAnimLens[pc][8];
		plr[pnum]._pDFrames = PlrGFXAnimLens[pc][4];
		plr[pnum]._pSFrames = PlrGFXAnimLens[pc][5];
	}
	else
	{
		plr[pnum]._pNFrames = PlrGFXAnimLens[pc][0];
		plr[pnum]._pWFrames = PlrGFXAnimLens[pc][2];
		plr[pnum]._pAFrames = PlrGFXAnimLens[pc][1];
		plr[pnum]._pHFrames = PlrGFXAnimLens[pc][6];
		plr[pnum]._pSFrames = PlrGFXAnimLens[pc][5];
		plr[pnum]._pDFrames = PlrGFXAnimLens[pc][4];
		plr[pnum]._pBFrames = PlrGFXAnimLens[pc][3];
		plr[pnum]._pAFNum = PlrGFXAnimLens[pc][9];
	}
	plr[pnum]._pSFNum = PlrGFXAnimLens[pc][10];

	int gn = plr[pnum]._pgfxnum & 0xF;
	if (pc == PC_WARRIOR)
	{
		if (gn == 4)
		{
			if (leveltype != DTYPE_TOWN)
			{
				plr[pnum]._pNFrames = 8;
			}
			plr[pnum]._pAWidth = 96;
			plr[pnum]._pAFNum = 11;
		}
		else if (gn == 5)
		{
			plr[pnum]._pAFrames = 20;
			plr[pnum]._pAFNum = 10;
		}
		else if (gn == 8)
		{
			plr[pnum]._pAFrames = 16;
			plr[pnum]._pAFNum = 11;
		}
	}
	else if (pc == PC_ROGUE)
	{
		if (gn == 5)
		{
			plr[pnum]._pAFrames = 22;
			plr[pnum]._pAFNum = 13;
		}
		else if (gn == 4)
		{
			plr[pnum]._pAFrames = 12;
			plr[pnum]._pAFNum = 7;
		}
		else if (gn == 8)
		{
			plr[pnum]._pAFrames = 16;
			plr[pnum]._pAFNum = 11;
		}
	}
	else if (pc == PC_SORCERER)
	{
		plr[pnum]._pSWidth = 128;
		if (gn == 0)
		{
			plr[pnum]._pAFrames = 20;
		}
		else if (gn == 1)
		{
			plr[pnum]._pAFNum = 9;
		}
		else if (gn == 4)
		{
			plr[pnum]._pAFrames = 20;
			plr[pnum]._pAFNum = 16;
		}
		else if (gn == 5)
		{
			plr[pnum]._pAFrames = 24;
			plr[pnum]._pAFNum = 16;
		}
	}
}
// 5BB1ED: using guessed type char leveltype;

void __fastcall ClearPlrRVars(PlayerStruct *p)
{
	// TODO: Missing debug assert p != NULL
	p->bReserved[0] = 0;
	p->bReserved[1] = 0;
	p->bReserved[2] = 0;
	p->wReserved[0] = 0;
	p->wReserved[1] = 0;
	p->wReserved[2] = 0;
	p->wReserved[3] = 0;
	p->wReserved[4] = 0;
	p->wReserved[5] = 0;
	p->wReserved[6] = 0;
	p->wReserved[7] = 0;
	p->dwReserved[0] = 0;
	p->dwReserved[1] = 0;
	p->dwReserved[2] = 0;
	p->dwReserved[3] = 0;
	p->dwReserved[4] = 0;
	p->dwReserved[5] = 0;
	p->dwReserved[6] = 0;
}

// c: plr_classes value
void __fastcall CreatePlayer(int pnum, char c)
{
	ClearPlrRVars(&plr[pnum]);
	SetRndSeed(GetTickCount());

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("CreatePlayer: illegal player %d", pnum);
	}
	plr[pnum]._pClass = c;

	char val = StrengthTbl[c];
	if (val < 0)
	{
		val = 0;
	}
	plr[pnum]._pStrength = val;
	plr[pnum]._pBaseStr = val;

	val = MagicTbl[c];
	if (val < 0)
	{
		val = 0;
	}
	plr[pnum]._pMagic = val;
	plr[pnum]._pBaseMag = val;

	val = DexterityTbl[c];
	if (val < 0)
	{
		val = 0;
	}
	plr[pnum]._pDexterity = val;
	plr[pnum]._pBaseDex = val;

	val = VitalityTbl[c];
	if (val < 0)
	{
		val = 0;
	}
	plr[pnum]._pVitality = val;
	plr[pnum]._pBaseVit = val;

	plr[pnum]._pStatPts = 0;
	plr[pnum].pTownWarps = 0;
	plr[pnum].pDungMsgs = 0;
	plr[pnum].pLvlLoad = 0;
	plr[pnum].pDiabloKillLevel = 0;

	if (c == PC_ROGUE)
	{
		plr[pnum]._pDamageMod = plr[pnum]._pLevel * (plr[pnum]._pStrength + plr[pnum]._pDexterity) / 200;
	}
	else
	{
		plr[pnum]._pDamageMod = plr[pnum]._pStrength * plr[pnum]._pLevel / 100;
	}

	plr[pnum]._pBaseToBlk = ToBlkTbl[c];

	plr[pnum]._pHitPoints = (val + 10) << 6;
	if (c == PC_WARRIOR)
	{
		plr[pnum]._pHitPoints *= 2;
	}
	if (c == PC_ROGUE)
	{
		plr[pnum]._pHitPoints += plr[pnum]._pHitPoints >> 1;
	}

	int hp = plr[pnum]._pHitPoints;
	plr[pnum]._pMaxHP = hp;
	plr[pnum]._pHPBase = hp;
	plr[pnum]._pMaxHPBase = hp;

	plr[pnum]._pMana = plr[pnum]._pMagic << 6;
	if (c == PC_SORCERER)
	{
		plr[pnum]._pMana *= 2;
	}
	if (c == PC_ROGUE)
	{
		plr[pnum]._pMana += plr[pnum]._pMana >> 1;
	}

	int mana = plr[pnum]._pMana;
	plr[pnum]._pMaxMana = mana;
	plr[pnum]._pManaBase = mana;
	plr[pnum]._pMaxManaBase = mana;

	plr[pnum]._pLevel = 1;
	plr[pnum]._pMaxLvl = 1;
	plr[pnum]._pExperience = 0;
	plr[pnum]._pMaxExp = 0;
	plr[pnum]._pNextExper = ExpLvlsTbl[1];
	plr[pnum]._pArmorClass = 0;
	plr[pnum]._pMagResist = 0;
	plr[pnum]._pFireResist = 0;
	plr[pnum]._pLghtResist = 0;
	plr[pnum]._pLightRad = 10;
	plr[pnum]._pInfraFlag = 0;

	if (c == PC_WARRIOR)
	{
		plr[pnum]._pAblSpells64 = (__int64)1 << (SPL_REPAIR - 1);
	}
	else if (c == PC_ROGUE)
	{
		plr[pnum]._pAblSpells64 = (__int64)1 << (SPL_DISARM - 1);
	}
	else if (c == PC_SORCERER)
	{
		plr[pnum]._pAblSpells64 = (__int64)1 << (SPL_RECHARGE - 1);
	}

	if (c == PC_SORCERER)
	{
		plr[pnum]._pMemSpells64 = 1;
	}
	else
	{
		plr[pnum]._pMemSpells64 = 0;
	}

	int i;
	for (i = 0; i < sizeof(plr[pnum]._pSplLvl); i++)
	{
		plr[pnum]._pSplLvl[i] = 0;
	}

	plr[pnum]._pSpellFlags = 0;

	if (plr[pnum]._pClass == PC_SORCERER)
	{
		plr[pnum]._pSplLvl[1] = 2;
	}

	// interestingly, only the first three hotkeys are reset
	// TODO: BUGFIX: clear all 4 hotkeys instead of 3 (demo leftover)
	for (i = 0; i < 3; i++)
	{
		plr[pnum]._pSplHotKey[i] = -1;
	}

	if (c == PC_WARRIOR)
	{
		plr[pnum]._pgfxnum = 3;
	}
	else if (c == PC_ROGUE)
	{
		plr[pnum]._pgfxnum = 4;
	}
	else if (c == PC_SORCERER)
	{
		plr[pnum]._pgfxnum = 8;
	}

	for (i = 0; i < sizeof(plr[pnum]._pLvlVisited); i++)
	{
		plr[pnum]._pLvlVisited[i] = 0;
	}

	for (i = 0; i < 10; i++)
	{
		plr[pnum]._pSLvlVisited[i] = 0; // TODO double check size of _pSLvlVisited
	}

	plr[pnum]._pLvlChanging = 0;
	plr[pnum].pTownWarps = 0;
	plr[pnum].pLvlLoad = 0;
	plr[pnum].pBattleNet = 0;
	plr[pnum].pManaShield = 0;

	InitDungMsgs(pnum);
	CreatePlrItems(pnum);
	SetRndSeed(0);
}

int __fastcall CalcStatDiff(int pnum)
{
	int c = plr[pnum]._pClass;
	return MaxStats[c][ATTRIB_STR] - plr[pnum]._pBaseStr + MaxStats[c][ATTRIB_MAG] - plr[pnum]._pBaseMag + MaxStats[c][ATTRIB_DEX] - plr[pnum]._pBaseDex + MaxStats[c][ATTRIB_VIT] - plr[pnum]._pBaseVit;
}

void __fastcall NextPlrLevel(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("NextPlrLevel: illegal player %d", pnum);
	}

	plr[pnum]._pLevel++;
	char l = plr[pnum]._pLevel;

	plr[pnum]._pMaxLvl++;

	if (CalcStatDiff(pnum) < 5)
	{
		plr[pnum]._pStatPts = CalcStatDiff(pnum);
	}
	else
	{
		plr[pnum]._pStatPts += 5;
	}

	plr[pnum]._pNextExper = ExpLvlsTbl[l];

	char c = plr[pnum]._pClass;

	int hp = c == PC_SORCERER ? 64 : 128;
	if (gbMaxPlayers == 1)
	{
		hp++;
	}
	plr[pnum]._pMaxHP += hp;
	plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
	plr[pnum]._pMaxHPBase += hp;
	plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;

	if (pnum == myplr)
	{
		drawhpflag = TRUE;
	}

	int mana = c != PC_WARRIOR ? 128 : 64;
	if (gbMaxPlayers == 1)
	{
		mana++;
	}
	plr[pnum]._pMaxMana += mana;
	plr[pnum]._pMaxManaBase += mana;

	if (!(plr[pnum]._pIFlags & ISPL_NOMANA))
	{
		plr[pnum]._pMana = plr[pnum]._pMaxMana;
		plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase;
	}

	if (pnum == myplr)
	{
		drawmanaflag = TRUE;
	}
}
// 679660: using guessed type char gbMaxPlayers;

void __fastcall AddPlrExperience(int pnum, int lvl, int exp)
{
	if (pnum != myplr)
	{
		return;
	}

	if ((DWORD)myplr >= MAX_PLRS)
	{
		TermMsg("AddPlrExperience: illegal player %d", myplr);
	}

	if (plr[myplr]._pHitPoints <= 0)
	{
		return;
	}

	// Adjust xp based on difference in level between player and monster
	exp *= 1 + ((double)lvl - plr[pnum]._pLevel) / 10;
	if (exp < 0)
	{
		exp = 0;
	}

	// Prevent power leveling
	if (gbMaxPlayers > 1)
	{
		int powerLvlCap = plr[pnum]._pLevel < 0 ? 0 : plr[pnum]._pLevel;
		if (powerLvlCap >= 50)
		{
			powerLvlCap = 50;
		}
		// cap to 1/20 of current levels xp
		if (exp >= ExpLvlsTbl[powerLvlCap] / 20)
		{
			exp = ExpLvlsTbl[powerLvlCap] / 20;
		}
		// cap to 200 * current level
		int expCap = 200 * powerLvlCap;
		if (exp >= expCap)
		{
			exp = expCap;
		}
	}

	plr[pnum]._pExperience += exp;
	if ((DWORD)plr[pnum]._pExperience > MAXEXP)
	{
		plr[pnum]._pExperience = MAXEXP;
	}

	if (plr[pnum]._pExperience >= ExpLvlsTbl[49])
	{
		plr[pnum]._pLevel = 50;
		return;
	}

	// Increase player level if applicable
	int newLvl = 0;
	while (plr[pnum]._pExperience >= ExpLvlsTbl[newLvl])
	{
		newLvl++;
	}
	if (newLvl != plr[pnum]._pLevel)
	{
		for (int i = newLvl - plr[pnum]._pLevel; i > 0; i--)
		{
			NextPlrLevel(pnum);
		}
	}

	NetSendCmdParam1(FALSE, CMD_PLRLEVEL, plr[myplr]._pLevel);
}
// 679660: using guessed type char gbMaxPlayers;

void __fastcall AddPlrMonstExper(int lvl, int exp, char pmask)
{
	int totplrs = 0;
	for (int i = 0; i < MAX_PLRS; i++)
	{
		if ((1 << i) & pmask)
		{
			totplrs++;
		}
	}

	if (totplrs && (1 << myplr) & pmask)
	{
		AddPlrExperience(myplr, lvl, exp / totplrs);
	}
}

void __fastcall InitPlayer(int pnum, BOOL FirstTime)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("InitPlayer: illegal player %d", pnum);
	}

	ClearPlrRVars(&plr[pnum]);

	if (FirstTime)
	{
		plr[pnum]._pRSpell = SPL_INVALID;
		plr[pnum]._pSBkSpell = SPL_INVALID;
		plr[pnum]._pSpell = SPL_INVALID;
		plr[pnum]._pRSplType = RSPLTYPE_INVALID;
		plr[pnum]._pSplType = RSPLTYPE_INVALID;
		if ((plr[pnum]._pgfxnum & 0xF) == 4)
		{
			plr[pnum]._pwtype = TRUE;
		}
		else
		{
			plr[pnum]._pwtype = FALSE;
		}
		plr[pnum].pManaShield = 0;
	}

	if (plr[pnum].plrlevel == currlevel || leveldebug)
	{

		SetPlrAnims(pnum);

		plr[pnum]._pxoff = 0;
		plr[pnum]._pyoff = 0;
		plr[pnum]._pxvel = 0;
		plr[pnum]._pyvel = 0;

		ClearPlrPVars(pnum);

		if (plr[pnum]._pHitPoints >> 6 > 0)
		{
			plr[pnum]._pmode = PM_STAND;
			NewPlrAnim(pnum, plr[pnum]._pNAnim[0], plr[pnum]._pNFrames, 3, plr[pnum]._pNWidth);
			plr[pnum]._pAnimFrame = random(2, plr[pnum]._pNFrames - 1) + 1;
			plr[pnum]._pAnimCnt = random(2, 3);
		}
		else
		{
			plr[pnum]._pmode = PM_DEATH;
			NewPlrAnim(pnum, plr[pnum]._pDAnim[0], plr[pnum]._pDFrames, 1, plr[pnum]._pDWidth);
			plr[pnum]._pAnimFrame = plr[pnum]._pAnimLen - 1;
			plr[pnum]._pVar8 = 2 * plr[pnum]._pAnimLen;
		}

		plr[pnum]._pdir = 0;
		plr[pnum]._peflag = 0;

		if (pnum == myplr)
		{
			if (!FirstTime || currlevel)
			{
				plr[pnum].WorldX = ViewX;
				plr[pnum].WorldY = ViewY;
			}
			plr[pnum]._ptargx = plr[pnum].WorldX;
			plr[pnum]._ptargy = plr[pnum].WorldY;
		}
		else
		{
			plr[pnum]._ptargx = plr[pnum].WorldX;
			plr[pnum]._ptargy = plr[pnum].WorldY;
			DWORD i;
			for (i = 0; i < 8 && !PosOkPlayer(pnum, plrxoff2[i] + plr[pnum].WorldX, plryoff2[i] + plr[pnum].WorldY); ++i)
				;
			plr[pnum].WorldX += plrxoff2[i];
			plr[pnum].WorldY += plryoff2[i];
		}

		plr[pnum]._px = plr[pnum].WorldX;
		plr[pnum]._py = plr[pnum].WorldY;
		plr[pnum].walkpath[0] = WALK_NONE;
		plr[pnum].destAction = ACTION_NONE;

		if (pnum == myplr)
		{
			plr[pnum]._plid = AddLight(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum]._pLightRad);
		}
		else
		{
			plr[pnum]._plid = WALK_NONE;
		}
		plr[pnum]._pvid = AddVision(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum]._pLightRad, pnum == myplr);
	}

	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		plr[pnum]._pAblSpells64 = 1 << (SPL_REPAIR - 1);
	}
	else if (plr[pnum]._pClass == PC_ROGUE)
	{
		plr[pnum]._pAblSpells64 = 1 << (SPL_DISARM - 1);
	}
	else if (plr[pnum]._pClass == PC_SORCERER)
	{
		plr[pnum]._pAblSpells64 = 1 << (SPL_RECHARGE - 1);
	}

#ifdef _DEBUG
	if (debug_mode_dollar_sign && FirstTime)
	{
		plr[pnum]._pMemSpells64 |= 1 << (SPL_TELEPORT - 1);
		if (!plr[myplr]._pSplLvl[SPL_TELEPORT])
		{
			plr[myplr]._pSplLvl[SPL_TELEPORT] = 1;
		}
	}
	if (debug_mode_key_inverted_v && FirstTime)
	{
		plr[pnum]._pMemSpells64 = SPL_INVALID;
	}
#endif

	plr[pnum]._pNextExper = ExpLvlsTbl[plr[pnum]._pLevel];
	plr[pnum]._pInvincible = FALSE;

	if (pnum == myplr)
	{
		deathdelay = 0;
		deathflag = 0;
		ScrollInfo._sxoff = 0;
		ScrollInfo._syoff = 0;
		ScrollInfo._sdir = 0;
	}
}
// 44B83C: could not find valid save-restore pair for edi
// 52572C: using guessed type int leveldebug;
// 69B7C4: using guessed type int deathdelay;

void __cdecl InitMultiView()
{
	if ((DWORD)myplr >= MAX_PLRS)
	{
		TermMsg("InitPlayer: illegal player %d", myplr);
	}

	ViewX = plr[myplr].WorldX;
	ViewY = plr[myplr].WorldY;
}

void __fastcall InitPlayerLoc(int pnum, BOOL flag)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("InitPlayer: illegal player %d", pnum);
	}

	int x = plr[pnum].WorldX - 1;
	int y = plr[pnum].WorldY + 1;
	int bitflags = 0;
	USHORT *pieces = (USHORT *)dpiece_defs_map_1 + 16 * gendung_get_dpiece_num_from_coord(x, y);

	int i;
	for (i = 2; i < 10; i++)
	{
		bitflags |= pieces[i];
	}

	if (bitflags | nSolidTable[dPiece[x][y]] | dArch[x][y])
	{
		plr[pnum]._peflag = 1;
	}
	else
	{
		plr[pnum]._peflag = 0;
	}

	if (flag != 1 || plr[pnum]._peflag != 1)
	{
		return;
	}

	x = plr[pnum].WorldX;
	y = plr[pnum].WorldY + 2;
	bitflags = 0;
	pieces = (USHORT *)dpiece_defs_map_1 + 16 * gendung_get_dpiece_num_from_coord(x, y);

	for (i = 2; i < 10; i++)
	{
		bitflags |= pieces[i];
	}

	if (bitflags | dArch[x][y])
	{
		return;
	}

	x = plr[pnum].WorldX - 2;
	y = plr[pnum].WorldY + 1;
	bitflags = 0;
	pieces = (USHORT *)dpiece_defs_map_1 + 16 * gendung_get_dpiece_num_from_coord(x, y);

	for (i = 2; i < 10; i++)
	{
		bitflags |= pieces[i];
	}

	if (bitflags | dArch[x][y])
	{
		plr[pnum]._peflag = 2;
	}
}

BOOL __fastcall SolidLoc(int x, int y)
{
	if (x < 0 || y < 0 || x >= MAXDUNX || y >= MAXDUNY)
	{
		return FALSE;
	}

	return nSolidTable[dPiece[x][y]];
}

BOOL __fastcall PlrDirOK(int pnum, int dir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PlrDirOK: illegal player %d", pnum);
	}

	int px = plr[pnum].WorldX + offset_x[dir];
	int py = plr[pnum].WorldY + offset_y[dir];

	if (px < 0 || !dPiece[px][py] || !PosOkPlayer(pnum, px, py))
	{
		return FALSE;
	}

	BOOL isOk = TRUE;
	if (dir == DIR_E)
	{
		isOk = !SolidLoc(px, py + 1) && !(dFlags[px][py + 1] & DFLAG_PLAYER);
	}

	if (isOk && dir == DIR_W)
	{
		isOk = !SolidLoc(px + 1, py) && !(dFlags[px + 1][py] & DFLAG_PLAYER);
	}

	return isOk;
}

void __fastcall PlrClrTrans(int x, int y)
{
	for (int i = y - 1; i <= y + 1; i++)
	{
		for (int j = x - 1; j <= x + 1; j++)
		{
			TransList[dung_map[j][i]] = 0;
		}
	}
}

void __fastcall PlrDoTrans(int x, int y)
{
	if (leveltype != DTYPE_CATHEDRAL && leveltype != DTYPE_CATACOMBS)
	{
		TransList[1] = 1;
	}
	else
	{
		for (int i = y - 1; i <= y + 1; i++)
		{
			for (int j = x - 1; j <= x + 1; j++)
			{
				if (!nSolidTable[dPiece[j][i]] && dung_map[j][i])
				{
					TransList[dung_map[j][i]] = 1;
				}
			}
		}
	}
}
// 5BB1ED: using guessed type char leveltype;

void __fastcall SetPlayerOld(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlayerOld: illegal player %d", pnum);
	}

	plr[pnum]._poldx = plr[pnum].WorldX;
	plr[pnum]._poldy = plr[pnum].WorldY;
}

void __fastcall FixPlayerLocation(int pnum, int dir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("FixPlayerLocation: illegal player %d", pnum);
	}

	plr[pnum]._px = plr[pnum].WorldX;
	plr[pnum]._py = plr[pnum].WorldY;
	plr[pnum]._ptargx = plr[pnum].WorldX;
	plr[pnum]._ptargy = plr[pnum].WorldY;
	plr[pnum]._pxoff = 0;
	plr[pnum]._pyoff = 0;
	InitPlayerLoc(pnum, FALSE);
	plr[pnum]._pdir = dir;
	if (pnum == myplr)
	{
		ScrollInfo._sxoff = 0;
		ScrollInfo._syoff = 0;
		ScrollInfo._sdir = 0;
		ViewX = plr[pnum].WorldX;
		ViewY = plr[pnum].WorldY;
	}
}

void __fastcall StartStand(int pnum, int dir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartStand: illegal player %d", pnum);
	}

	if (!plr[pnum]._pInvincible || plr[pnum]._pHitPoints || pnum != myplr)
	{
		if (!(plr[pnum]._pGFXLoad & PFILE_STAND))
		{
			LoadPlrGFX(pnum, PFILE_STAND);
		}

		NewPlrAnim(pnum, plr[pnum]._pNAnim[dir], plr[pnum]._pNFrames, 3, plr[pnum]._pNWidth);
		plr[pnum]._pmode = PM_STAND;
		FixPlayerLocation(pnum, dir);
		FixPlrWalkTags(pnum);
		dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = pnum + 1;
		SetPlayerOld(pnum);
	}
	else
	{
		SyncPlrKill(pnum, -1);
	}
}

void __fastcall StartWalkStand(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartWalkStand: illegal player %d", pnum);
	}

	plr[pnum]._pmode = 0;
	plr[pnum]._px = plr[pnum].WorldX;
	plr[pnum]._py = plr[pnum].WorldY;
	plr[pnum]._pxoff = 0;
	plr[pnum]._pyoff = 0;

	InitPlayerLoc(pnum, 0);

	if (pnum == myplr)
	{
		ScrollInfo._sxoff = 0;
		ScrollInfo._syoff = 0;
		ScrollInfo._sdir = 0;
		ViewX = plr[pnum].WorldX;
		ViewY = plr[pnum].WorldY;
	}
}

void __fastcall PM_ChangeLightOff(int pnum)
{
	int v1;				 // esi
	int v2;				 // esi
	signed int v3;		 // ebx
	int v4;				 // edi
	int v5;				 // edx
	LightListStruct *v6; // eax
	int v7;				 // ecx
	int v8;				 // edx
	signed int v9;		 // edi
	int v10;			 // ebx
	int v11;			 // edx
	int v12;			 // ecx
	int v13;			 // ebp
	int ly;				 // [esp+10h] [ebp-Ch]
	int lx;				 // [esp+18h] [ebp-4h]

	v1 = pnum;
	if ((unsigned int)pnum >= MAX_PLRS)
		TermMsg("PM_ChangeLightOff: illegal player %d", pnum);
	v2 = v1;
	v3 = -1;
	v4 = plr[v2]._pxoff;
	v5 = 2 * plr[v2]._pyoff;
	v6 = &LightList[plr[v2]._plid];
	v7 = v4 + v5;
	v8 = v5 - v4;
	if (v7 >= 0)
	{
		v9 = 1;
	}
	else
	{
		v9 = -1;
		v7 = -v7;
	}
	if (v8 >= 0)
		v3 = 1;
	else
		v8 = -v8;
	v10 = v3 * (v8 >> 3);
	v11 = 8 * v6->_ly;
	ly = v11 + v10;
	lx = v9 * (v7 >> 3);
	v12 = 8 * v6->_lx;
	v13 = v11 + v6->_yoff;
	if (abs(lx - v6->_xoff) >= 3 || abs(ly - v13) >= 3)
		ChangeLightOff(plr[v2]._plid, lx, v10);
}

void __fastcall PM_ChangeOffset(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_ChangeOffset: illegal player %d", pnum);
	}

	plr[pnum]._pVar8++;
	int px = plr[pnum]._pVar6 >> 8;
	int py = plr[pnum]._pVar7 >> 8;

	plr[pnum]._pVar6 += plr[pnum]._pxvel;
	plr[pnum]._pVar7 += plr[pnum]._pyvel;
	plr[pnum]._pxoff = plr[pnum]._pVar6 >> 8;
	plr[pnum]._pyoff = plr[pnum]._pVar7 >> 8;

	if (pnum == myplr && ScrollInfo._sdir)
	{
		ScrollInfo._sxoff += px - plr[pnum]._pxoff;
		ScrollInfo._syoff += py - plr[pnum]._pyoff;
	}
	PM_ChangeLightOff(pnum);
}

void __fastcall StartWalk(int pnum, int xvel, int yvel, int xadd, int yadd, int EndDir, int sdir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartWalk: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	SetPlayerOld(pnum);

	int px = xadd + plr[pnum].WorldX;
	int py = yadd + plr[pnum].WorldY;

	if (!PlrDirOK(pnum, EndDir))
	{
		return;
	}

	plr[pnum]._px = px;
	plr[pnum]._py = py;

	if (pnum == myplr)
	{
		ScrollInfo._sdx = plr[pnum].WorldX - ViewX;
		ScrollInfo._sdy = plr[pnum].WorldY - ViewY;
	}

	dPlayer[px][py] = -(pnum + 1);
	plr[pnum]._pmode = PM_WALK;
	plr[pnum]._pxvel = xvel;
	plr[pnum]._pyvel = yvel;
	plr[pnum]._pxoff = 0;
	plr[pnum]._pyoff = 0;
	plr[pnum]._pVar1 = xadd;
	plr[pnum]._pVar2 = yadd;
	plr[pnum]._pVar3 = EndDir;

	if (!(plr[pnum]._pGFXLoad & PFILE_WALK))
	{
		LoadPlrGFX(pnum, PFILE_WALK);
	}
	NewPlrAnim(pnum, plr[pnum]._pWAnim[EndDir], plr[pnum]._pWFrames, 0, plr[pnum]._pWWidth);

	plr[pnum]._pdir = EndDir;
	plr[pnum]._pVar6 = 0;
	plr[pnum]._pVar7 = 0;
	plr[pnum]._pVar8 = 0;

	InitPlayerLoc(pnum, FALSE);

	if (pnum != myplr)
	{
		return;
	}

	if (zoomflag)
	{
		if (abs(ScrollInfo._sdx) >= 3 || abs(ScrollInfo._sdy) >= 3)
		{
			ScrollInfo._sdir = 0;
		}
		else
		{
			ScrollInfo._sdir = sdir;
		}
	}
	else if (abs(ScrollInfo._sdx) >= 2 || abs(ScrollInfo._sdy) >= 2)
	{
		ScrollInfo._sdir = 0;
	}
	else
	{
		ScrollInfo._sdir = sdir;
	}
}
// 52569C: using guessed type int zoomflag;

void __fastcall StartWalk2(int pnum, int xvel, int yvel, int xoff, int yoff, int xadd, int yadd, int EndDir, int sdir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartWalk2: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	SetPlayerOld(pnum);
	int px = xadd + plr[pnum].WorldX;
	int py = yadd + plr[pnum].WorldY;

	if (!PlrDirOK(pnum, EndDir))
	{
		return;
	}

	plr[pnum]._px = px;
	plr[pnum]._py = py;

	if (pnum == myplr)
	{
		ScrollInfo._sdx = plr[pnum].WorldX - ViewX;
		ScrollInfo._sdy = plr[pnum].WorldY - ViewY;
	}

	dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = -1 - pnum;
	plr[pnum]._pVar1 = plr[pnum].WorldX;
	plr[pnum]._pVar2 = plr[pnum].WorldY;
	plr[pnum].WorldX = px;
	plr[pnum].WorldY = py;
	dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = pnum + 1;
	plr[pnum]._pxoff = xoff;
	plr[pnum]._pyoff = yoff;

	ChangeLightXY(plr[pnum]._plid, plr[pnum].WorldX, plr[pnum].WorldY);
	PM_ChangeLightOff(pnum);

	plr[pnum]._pmode = PM_WALK2;
	plr[pnum]._pxvel = xvel;
	plr[pnum]._pyvel = yvel;
	plr[pnum]._pVar6 = xoff << 8;
	plr[pnum]._pVar7 = yoff << 8;
	plr[pnum]._pVar3 = EndDir;

	if (!(plr[pnum]._pGFXLoad & PFILE_WALK))
	{
		LoadPlrGFX(pnum, PFILE_WALK);
	}
	NewPlrAnim(pnum, plr[pnum]._pWAnim[EndDir], plr[pnum]._pWFrames, 0, plr[pnum]._pWWidth);

	plr[pnum]._pdir = EndDir;
	plr[pnum]._pVar8 = 0;

	if (EndDir == DIR_SE)
	{
		InitPlayerLoc(pnum, TRUE);
	}
	else
	{
		InitPlayerLoc(pnum, FALSE);
	}

	if (pnum != myplr)
	{
		return;
	}

	if (zoomflag)
	{
		if (abs(ScrollInfo._sdx) >= 3 || abs(ScrollInfo._sdy) >= 3)
		{
			ScrollInfo._sdir = 0;
		}
		else
		{
			ScrollInfo._sdir = sdir;
		}
	}
	else if (abs(ScrollInfo._sdx) >= 2 || abs(ScrollInfo._sdy) >= 2)
	{
		ScrollInfo._sdir = 0;
	}
	else
	{
		ScrollInfo._sdir = sdir;
	}
}
// 52569C: using guessed type int zoomflag;

void __fastcall StartWalk3(int pnum, int xvel, int yvel, int xoff, int yoff, int xadd, int yadd, int mapx, int mapy, int EndDir, int sdir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartWalk3: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	SetPlayerOld(pnum);
	int px = xadd + plr[pnum].WorldX;
	int py = yadd + plr[pnum].WorldY;
	int x = mapx + plr[pnum].WorldX;
	int y = mapy + plr[pnum].WorldY;

	if (!PlrDirOK(pnum, EndDir))
	{
		return;
	}

	plr[pnum]._px = px;
	plr[pnum]._py = py;

	if (pnum == myplr)
	{
		ScrollInfo._sdx = plr[pnum].WorldX - ViewX;
		ScrollInfo._sdy = plr[pnum].WorldY - ViewY;
	}

	dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = -1 - pnum;
	dPlayer[px][py] = -1 - pnum;
	plr[pnum]._pVar4 = x;
	plr[pnum]._pVar5 = y;
	dFlags[x][y] |= DFLAG_PLAYER;
	plr[pnum]._pxoff = xoff;
	plr[pnum]._pyoff = yoff;

	if (leveltype)
	{
		ChangeLightXY(plr[pnum]._plid, x, y);
		PM_ChangeLightOff(pnum);
	}

	plr[pnum]._pmode = PM_WALK3;
	plr[pnum]._pxvel = xvel;
	plr[pnum]._pyvel = yvel;
	plr[pnum]._pVar1 = px;
	plr[pnum]._pVar2 = py;
	plr[pnum]._pVar6 = xoff << 8;
	plr[pnum]._pVar7 = yoff << 8;
	plr[pnum]._pVar3 = EndDir;

	if (!(plr[pnum]._pGFXLoad & PFILE_WALK))
	{
		LoadPlrGFX(pnum, PFILE_WALK);
	}
	NewPlrAnim(pnum, plr[pnum]._pWAnim[EndDir], plr[pnum]._pWFrames, 0, plr[pnum]._pWWidth);

	plr[pnum]._pdir = EndDir;
	plr[pnum]._pVar8 = 0;

	InitPlayerLoc(pnum, 0);

	if (pnum != myplr)
	{
		return;
	}

	if (zoomflag)
	{
		if (abs(ScrollInfo._sdx) >= 3 || abs(ScrollInfo._sdy) >= 3)
		{
			ScrollInfo._sdir = 0;
		}
		else
		{
			ScrollInfo._sdir = sdir;
		}
	}
	else if (abs(ScrollInfo._sdx) >= 2 || abs(ScrollInfo._sdy) >= 2)
	{
		ScrollInfo._sdir = 0;
	}
	else
	{
		ScrollInfo._sdir = sdir;
	}
}
// 52569C: using guessed type int zoomflag;
// 5BB1ED: using guessed type char leveltype;

void __fastcall StartAttack(int pnum, int d)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartAttack: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	if (!(plr[pnum]._pGFXLoad & PFILE_ATTACK))
	{
		LoadPlrGFX(pnum, PFILE_ATTACK);
	}

	NewPlrAnim(pnum, plr[pnum]._pAAnim[d], plr[pnum]._pAFrames, 0, plr[pnum]._pAWidth);
	plr[pnum]._pmode = PM_ATTACK;
	FixPlayerLocation(pnum, d);
	SetPlayerOld(pnum);
}

void __fastcall StartRangeAttack(int pnum, int d, int cx, int cy)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartRangeAttack: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	if (!(plr[pnum]._pGFXLoad & PFILE_ATTACK))
	{
		LoadPlrGFX(pnum, PFILE_ATTACK);
	}
	NewPlrAnim(pnum, plr[pnum]._pAAnim[d], plr[pnum]._pAFrames, 0, plr[pnum]._pAWidth);

	plr[pnum]._pmode = PM_RATTACK;
	FixPlayerLocation(pnum, d);
	SetPlayerOld(pnum);
	plr[pnum]._pVar1 = cx;
	plr[pnum]._pVar2 = cy;
}

void __fastcall StartPlrBlock(int pnum, int dir)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartPlrBlock: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	PlaySfxLoc(IS_ISWORD, plr[pnum].WorldX, plr[pnum].WorldY);

	if (!(plr[pnum]._pGFXLoad & PFILE_BLOCK))
	{
		LoadPlrGFX(pnum, PFILE_BLOCK);
	}
	NewPlrAnim(pnum, plr[pnum]._pBAnim[dir], plr[pnum]._pBFrames, 2, plr[pnum]._pBWidth);

	plr[pnum]._pmode = PM_BLOCK;
	FixPlayerLocation(pnum, dir);
	SetPlayerOld(pnum);
}

void __fastcall StartSpell(int pnum, int d, int cx, int cy)
{
	if ((DWORD)pnum >= MAX_PLRS)
		TermMsg("StartSpell: illegal player %d", pnum);

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	if (leveltype != DTYPE_TOWN)
	{
		switch (spelldata[plr[pnum]._pSpell].sType)
		{
		case STYPE_FIRE:
			if (!(plr[pnum]._pGFXLoad & PFILE_FIRE))
			{
				LoadPlrGFX(pnum, PFILE_FIRE);
			}
			NewPlrAnim(pnum, plr[pnum]._pFAnim[d], plr[pnum]._pSFrames, 0, plr[pnum]._pSWidth);
			break;
		case STYPE_LIGHTNING:
			if (!(plr[pnum]._pGFXLoad & PFILE_LIGHTNING))
			{
				LoadPlrGFX(pnum, PFILE_LIGHTNING);
			}
			NewPlrAnim(pnum, plr[pnum]._pLAnim[d], plr[pnum]._pSFrames, 0, plr[pnum]._pSWidth);
			break;
		case STYPE_MAGIC:
			if (!(plr[pnum]._pGFXLoad & PFILE_MAGIC))
			{
				LoadPlrGFX(pnum, PFILE_MAGIC);
			}
			NewPlrAnim(pnum, plr[pnum]._pTAnim[d], plr[pnum]._pSFrames, 0, plr[pnum]._pSWidth);
			break;
		}
	}

	PlaySfxLoc(spelldata[plr[pnum]._pSpell].sSFX, plr[pnum].WorldX, plr[pnum].WorldY);

	plr[pnum]._pmode = PM_SPELL;

	FixPlayerLocation(pnum, d);
	SetPlayerOld(pnum);

	plr[pnum]._pVar1 = cx;
	plr[pnum]._pVar2 = cy;
	plr[pnum]._pVar4 = GetSpellLevel(pnum, plr[pnum]._pSpell);
	plr[pnum]._pVar8 = 1;
}
// 5BB1ED: using guessed type char leveltype;

void __fastcall FixPlrWalkTags(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("FixPlrWalkTags: illegal player %d", pnum);
	}

	int pp = pnum + 1;
	int pn = -(pnum + 1);
	int dx = plr[pnum]._poldx;
	int dy = plr[pnum]._poldy;
	for (int y = dy - 1; y <= dy + 1; y++)
	{
		for (int x = dx - 1; x <= dx + 1; x++)
		{
			if (x >= 0 && x < MAXDUNX && y >= 0 && y < MAXDUNY && (dPlayer[x][y] == pp || dPlayer[x][y] == pn))
			{
				dPlayer[x][y] = 0;
			}
		}
	}

	if (dx >= 0 && dx < MAXDUNX - 1 && dy >= 0 && dy < MAXDUNY - 1)
	{
		dFlags[dx + 1][dy] &= ~DFLAG_PLAYER;
		dFlags[dx][dy + 1] &= ~DFLAG_PLAYER;
	}
}

void __fastcall RemovePlrFromMap(int pnum)
{
	int x, y;
	int pp = pnum + 1;
	int pn = -(pnum + 1);

	for (y = 1; y < MAXDUNY; y++)
		for (x = 1; x < MAXDUNX; x++)
			if (dPlayer[x][y - 1] == pn || dPlayer[x - 1][y] == pn)
				if (dFlags[x][y] & DFLAG_PLAYER)
					dFlags[x][y] &= ~DFLAG_PLAYER;

	for (y = 0; y < MAXDUNY; y++)
		for (x = 0; x < MAXDUNX; x++)
			if (dPlayer[x][y] == pp || dPlayer[x][y] == pn)
				dPlayer[x][y] = 0;
}

void __fastcall StartPlrHit(int pnum, int dam, BOOL forcehit)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartPlrHit: illegal player %d", pnum);
	}

	if (plr[pnum]._pInvincible && !plr[pnum]._pHitPoints && pnum == myplr)
	{
		SyncPlrKill(pnum, -1);
		return;
	}

	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		PlaySfxLoc(PS_WARR69, plr[pnum].WorldX, plr[pnum].WorldY);
	}
	else if (plr[pnum]._pClass == PC_ROGUE)
	{
		PlaySfxLoc(PS_ROGUE69, plr[pnum].WorldX, plr[pnum].WorldY);
	}
	else if (plr[pnum]._pClass == PC_SORCERER)
	{
		PlaySfxLoc(PS_MAGE69, plr[pnum].WorldX, plr[pnum].WorldY);
	}

	drawhpflag = TRUE;
	if (dam >> 6 >= plr[pnum]._pLevel || forcehit)
	{
		int dir = plr[pnum]._pdir;

		if (!(plr[pnum]._pGFXLoad & PFILE_HIT))
		{
			LoadPlrGFX(pnum, PFILE_HIT);
		}
		NewPlrAnim(pnum, plr[pnum]._pHAnim[dir], plr[pnum]._pHFrames, 0, plr[pnum]._pHWidth);

		plr[pnum]._pmode = PM_GOTHIT;
		FixPlayerLocation(pnum, dir);
		plr[pnum]._pVar8 = 1;
		FixPlrWalkTags(pnum);
		dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = pnum + 1;
		SetPlayerOld(pnum);
	}
}

void __fastcall RespawnDeadItem(ItemStruct *itm, int x, int y)
{
	ItemStruct *v3; // ebx
	int v4;			// eax
	int i;			// ST10_4
	//unsigned int v6; // ecx

	v3 = itm;
	if (numitems < MAXITEMS)
	{
		if (FindGetItem(itm->IDidx, itm->_iCreateInfo, itm->_iSeed) >= 0)
		{
			DrawInvMsg("A duplicate item has been detected.  Destroying duplicate...");
			SyncGetItem(x, y, v3->IDidx, v3->_iCreateInfo, v3->_iSeed);
		}
		v4 = itemavail[0];
		i = itemavail[0];
		dItem[x][y] = _LOBYTE(itemavail[0]) + 1;
		//v6 = 4 * numitems;
		itemactive[numitems] = v4;
		v4 *= 368;
		itemavail[0] = itemavail[MAXITEMS - numitems - 1];
		qmemcpy((char *)item + v4, v3, sizeof(ItemStruct));
		*(int *)((char *)&item[0]._ix + v4) = x;
		*(int *)((char *)&item[0]._iy + v4) = y;
		RespawnItem(i, 1);
		++numitems;
		v3->_itype = -1;
	}
}

void __fastcall StartPlayerKill(int pnum, int earflag)
{
	if (plr[pnum]._pHitPoints <= 0 && plr[pnum]._pmode == PM_DEATH)
	{
		return;
	}

	if (myplr == pnum)
	{
		NetSendCmdParam1(TRUE, CMD_PLRDEAD, earflag);
	}

	BOOL diablolevel = gbMaxPlayers > 1 && plr[pnum].plrlevel == 16;

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartPlayerKill: illegal player %d", pnum);
	}

	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		PlaySfxLoc(PS_DEAD, plr[pnum].WorldX, plr[pnum].WorldY); // BUGFIX: should use `PS_WARR71` like other classes
	}
	else if (plr[pnum]._pClass == PC_ROGUE)
	{
		PlaySfxLoc(PS_ROGUE71, plr[pnum].WorldX, plr[pnum].WorldY);
	}
	else if (plr[pnum]._pClass == PC_SORCERER)
	{
		PlaySfxLoc(PS_MAGE71, plr[pnum].WorldX, plr[pnum].WorldY);
	}

	if (plr[pnum]._pgfxnum)
	{
		plr[pnum]._pgfxnum = 0;
		plr[pnum]._pGFXLoad = 0;
		SetPlrAnims(pnum);
	}

	if (!(plr[pnum]._pGFXLoad & PFILE_DEATH))
	{
		LoadPlrGFX(pnum, PFILE_DEATH);
	}

	PlayerStruct *p = &plr[pnum];
	NewPlrAnim(pnum, p->_pDAnim[plr[pnum]._pdir], p->_pDFrames, 1, p->_pDWidth);

	plr[pnum]._pBlockFlag = FALSE;
	plr[pnum]._pmode = PM_DEATH;
	plr[pnum]._pInvincible = TRUE;
	SetPlayerHitPoints(pnum, 0);
	plr[pnum]._pVar8 = 1;

	int i;
	if (pnum != myplr && !earflag && !diablolevel)
	{
		for (i = 0; i < NUM_INVLOC; i++)
		{
			plr[pnum].InvBody[i]._itype = ITYPE_NONE;
		}
		CalcPlrInv(pnum, 0);
	}

	if (plr[pnum].plrlevel == currlevel)
	{
		FixPlayerLocation(pnum, plr[pnum]._pdir);
		RemovePlrFromMap(pnum);
		dFlags[plr[pnum].WorldX][plr[pnum].WorldY] |= DFLAG_DEAD_PLAYER;
		SetPlayerOld(pnum);

		if (pnum == myplr)
		{
			drawhpflag = TRUE;
			deathdelay = 30;

			if (pcurs >= CURSOR_FIRSTITEM)
			{
				PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
				SetCursor(CURSOR_HAND);
			}

			if (!diablolevel)
			{
				DropHalfPlayersGold(pnum);
				if (earflag != -1)
				{
					if (earflag != 0)
					{
						ItemStruct ear;
						SetPlrHandItem(&ear, IDI_EAR);
						sprintf(ear._iName, "Ear of %s", plr[pnum]._pName);
						if (plr[pnum]._pClass == PC_SORCERER)
						{
							ear._iCurs = ICURS_EAR_SORCEROR;
						}
						else if (plr[pnum]._pClass == PC_WARRIOR)
						{
							ear._iCurs = ICURS_EAR_WARRIOR;
						}
						else if (plr[pnum]._pClass == PC_ROGUE)
						{
							ear._iCurs = ICURS_EAR_ROGUE;
						}

						ear._iCreateInfo = plr[pnum]._pName[0] << 8 | plr[pnum]._pName[1];
						ear._iSeed = plr[pnum]._pName[2] << 24 | plr[pnum]._pName[3] << 16 | plr[pnum]._pName[4] << 8 | plr[pnum]._pName[5];
						ear._ivalue = plr[pnum]._pLevel;

						if (FindGetItem(IDI_EAR, ear._iCreateInfo, ear._iSeed) == -1)
						{
							PlrDeadItem(pnum, &ear, 0, 0);
						}
					}
					else
					{
						ItemStruct *pi = &plr[pnum].InvBody[0];
						i = NUM_INVLOC;
						while (i != 0)
						{
							i--;
							int pdd = (i + plr[pnum]._pdir) & 7;
							PlrDeadItem(pnum, pi, offset_x[pdd], offset_y[pdd]);
							pi++;
						}

						CalcPlrInv(pnum, 0);
					}
				}
			}
		}
	}
	SetPlayerHitPoints(pnum, 0);
}
// 679660: using guessed type char gbMaxPlayers;
// 69B7C4: using guessed type int deathdelay;

void __fastcall PlrDeadItem(int pnum, struct ItemStruct *itm, int xx, int yy)
{
	int v4;			 // edi
	int v5;			 // edi
	int v6;			 // esi
	int v7;			 // ebx
	int v8;			 // eax
	int v9;			 // ST04_4
	ItemStruct *v10; // esi
	int v11;		 // eax
	int v12;		 // ebx
	int v13;		 // esi
	//int v14; // eax
	int v15;		   // edx
	unsigned char v16; // [esp-8h] [ebp-24h]
	unsigned char v17; // [esp-4h] [ebp-20h]
	int x;			   // [esp+Ch] [ebp-10h]
	ItemStruct *pItem; // [esp+10h] [ebp-Ch]
	int v20;		   // [esp+14h] [ebp-8h]
	int v21;		   // [esp+14h] [ebp-8h]
	int v22;		   // [esp+18h] [ebp-4h]
	int xxa;		   // [esp+24h] [ebp+8h]
	int yya;		   // [esp+28h] [ebp+Ch]

	pItem = itm;
	v4 = pnum;
	if (itm->_itype != -1)
	{
		if ((unsigned int)pnum >= MAX_PLRS)
			TermMsg("PlrDeadItem: illegal player %d", pnum);
		v5 = v4;
		v6 = yy + plr[v5].WorldY;
		v7 = xx + plr[v5].WorldX;
		v20 = yy + plr[v5].WorldY;
		if ((xx || yy) && (v8 = ItemSpaceOk(v7, v6), v8))
		{
			v9 = v6;
			v10 = pItem;
			RespawnDeadItem(pItem, v7, v9);
			v17 = v20;
			v16 = v7;
		}
		else
		{
			yya = -1;
			xxa = 1;
			while (1)
			{
				v11 = yya;
				v21 = yya;
			LABEL_14:
				if (v11 <= xxa)
					break;
				++xxa;
				if (--yya <= -50)
					return;
			}
			v12 = v21 + plr[v5].WorldY;
			v22 = yya;
			while (1)
			{
				v13 = v22 + plr[v5].WorldX;
				x = v22 + plr[v5].WorldX;
				//_LOBYTE(v14) = ItemSpaceOk(v13, v12);
				if (ItemSpaceOk(v13, v12))
					break;
				if (++v22 > xxa)
				{
					v11 = ++v21;
					goto LABEL_14;
				}
			}
			v15 = v13;
			v10 = pItem;
			RespawnDeadItem(pItem, v15, v12);
			v17 = v12;
			v16 = x;
		}
		qmemcpy(&plr[v5].HoldItem, v10, sizeof(plr[v5].HoldItem));
		NetSendCmdPItem(0, CMD_RESPAWNITEM, v16, v17);
	}
}

void __fastcall DropHalfPlayersGold(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("DropHalfPlayersGold: illegal player %d", pnum);
	}

	int i;
	int hGold = plr[pnum]._pGold >> 1;
	for (i = 0; i < MAXBELTITEMS && hGold > 0; i++)
	{
		if (plr[pnum].SpdList[i]._itype == ITYPE_GOLD && plr[pnum].SpdList[i]._ivalue != 5000)
		{
			if (hGold < plr[pnum].SpdList[i]._ivalue)
			{
				plr[pnum].SpdList[i]._ivalue -= hGold;
				SetSpdbarGoldCurs(pnum, i);
				SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
				GetGoldSeed(pnum, &plr[pnum].HoldItem);
				SetPlrHandGoldCurs(&plr[pnum].HoldItem);
				plr[pnum].HoldItem._ivalue = hGold;
				PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
				hGold = 0;
			}
			else
			{
				hGold -= plr[pnum].SpdList[i]._ivalue;
				RemoveSpdBarItem(pnum, i);
				SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
				GetGoldSeed(pnum, &plr[pnum].HoldItem);
				SetPlrHandGoldCurs(&plr[pnum].HoldItem);
				plr[pnum].HoldItem._ivalue = plr[pnum].SpdList[i]._ivalue;
				PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
				i = -1;
			}
		}
	}
	if (hGold > 0)
	{
		for (i = 0; i < MAXBELTITEMS && hGold > 0; i++)
		{
			if (plr[pnum].SpdList[i]._itype == ITYPE_GOLD)
			{
				if (hGold < plr[pnum].SpdList[i]._ivalue)
				{
					plr[pnum].SpdList[i]._ivalue -= hGold;
					SetSpdbarGoldCurs(pnum, i);
					SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
					GetGoldSeed(pnum, &plr[pnum].HoldItem);
					SetPlrHandGoldCurs(&plr[pnum].HoldItem);
					plr[pnum].HoldItem._ivalue = hGold;
					PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
					hGold = 0;
				}
				else
				{
					hGold -= plr[pnum].SpdList[i]._ivalue;
					RemoveSpdBarItem(pnum, i);
					SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
					GetGoldSeed(pnum, &plr[pnum].HoldItem);
					SetPlrHandGoldCurs(&plr[pnum].HoldItem);
					plr[pnum].HoldItem._ivalue = plr[pnum].SpdList[i]._ivalue;
					PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
					i = -1;
				}
			}
		}
	}
	drawpanflag = 255;
	if (hGold > 0)
	{
		for (i = 0; i < plr[pnum]._pNumInv && hGold > 0; i++)
		{
			if (plr[pnum].InvList[i]._itype == ITYPE_GOLD && plr[pnum].InvList[i]._ivalue != 5000)
			{
				if (hGold < plr[pnum].InvList[i]._ivalue)
				{
					plr[pnum].InvList[i]._ivalue -= hGold;
					SetGoldCurs(pnum, i);
					SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
					GetGoldSeed(pnum, &plr[pnum].HoldItem);
					SetPlrHandGoldCurs(&plr[pnum].HoldItem);
					plr[pnum].HoldItem._ivalue = hGold;
					PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
					hGold = 0;
				}
				else
				{
					hGold -= plr[pnum].InvList[i]._ivalue;
					RemoveInvItem(pnum, i);
					SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
					GetGoldSeed(pnum, &plr[pnum].HoldItem);
					SetPlrHandGoldCurs(&plr[pnum].HoldItem);
					plr[pnum].HoldItem._ivalue = plr[pnum].InvList[i]._ivalue;
					PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
					i = -1;
				}
			}
		}
	}
	if (hGold > 0)
	{
		for (i = 0; i < plr[pnum]._pNumInv && hGold > 0; i++)
		{
			if (plr[pnum].InvList[i]._itype == ITYPE_GOLD)
			{
				if (hGold < plr[pnum].InvList[i]._ivalue)
				{
					plr[pnum].InvList[i]._ivalue -= hGold;
					SetGoldCurs(pnum, i);
					SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
					GetGoldSeed(pnum, &plr[pnum].HoldItem);
					SetPlrHandGoldCurs(&plr[pnum].HoldItem);
					plr[pnum].HoldItem._ivalue = hGold;
					PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
					hGold = 0;
				}
				else
				{
					hGold -= plr[pnum].InvList[i]._ivalue;
					RemoveInvItem(pnum, i);
					SetPlrHandItem(&plr[pnum].HoldItem, IDI_GOLD);
					GetGoldSeed(pnum, &plr[pnum].HoldItem);
					SetPlrHandGoldCurs(&plr[pnum].HoldItem);
					plr[pnum].HoldItem._ivalue = plr[pnum].InvList[i]._ivalue;
					PlrDeadItem(pnum, &plr[pnum].HoldItem, 0, 0);
					i = -1;
				}
			}
		}
	}
	plr[pnum]._pGold = CalculateGold(pnum);
}
// 52571C: using guessed type int drawpanflag;

void __fastcall SyncPlrKill(int pnum, int earflag)
{
	if (plr[pnum]._pHitPoints == 0 && currlevel == 0)
	{
		SetPlayerHitPoints(pnum, 64);
		return;
	}

	for (int i = 0; i < nummissiles; i++)
	{
		int ma = missileactive[i];
		if (missile[ma]._mitype == MIS_MANASHIELD && missile[ma]._misource == pnum && missile[ma]._miDelFlag == 0)
		{
			if (earflag != -1)
			{
				missile[ma]._miVar8 = earflag;
			}

			return;
		}
	}

	SetPlayerHitPoints(pnum, 0);
	StartPlayerKill(pnum, earflag);
}

void __fastcall RemovePlrMissiles(int pnum)
{
	if (currlevel != 0 && pnum == myplr && (monster[myplr]._mx != 1 || monster[myplr]._my != 0))
	{
		M_StartKill(myplr, myplr);
		AddDead(monster[myplr]._mx, monster[myplr]._my, monster[myplr].MType->mdeadval, (direction)monster[myplr]._mdir);
		dMonster[monster[myplr]._mx][monster[myplr]._my] = 0;
		monster[myplr]._mDelFlag = 1;
		DeleteMonsterList();
	}

	for (int mi = 0; mi < nummissiles; mi++)
	{
		int am = missileactive[mi];
		if (missile[am]._mitype == MIS_STONE && missile[am]._misource == pnum)
		{
			monster[missile[am]._miVar2]._mmode = missile[am]._miVar1;
		}
		if (missile[am]._mitype == MIS_MANASHIELD && missile[am]._misource == pnum)
		{
			ClearMissileSpot(am);
			DeleteMissile(am, mi);
		}
		if (missile[am]._mitype == MIS_ETHEREALIZE && missile[am]._misource == pnum)
		{
			ClearMissileSpot(am);
			DeleteMissile(am, mi);
		}
	}
}

void __fastcall InitLevelChange(int pnum)
{
	RemovePlrMissiles(pnum);
	if (pnum == myplr && qtextflag)
	{
		qtextflag = 0;
		sfx_stop();
	}

	RemovePlrFromMap(pnum);
	SetPlayerOld(pnum);
	if (pnum == myplr)
	{
		dPlayer[plr[myplr].WorldX][plr[myplr].WorldY] = myplr + 1;
	}
	else
	{
		plr[pnum]._pLvlVisited[plr[pnum].plrlevel] = 1;
	}

	ClrPlrPath(pnum);
	plr[pnum].destAction = ACTION_NONE;
	plr[pnum]._pLvlChanging = 1;

	if (pnum == myplr)
	{
		plr[pnum].pLvlLoad = 10;
	}
}
// 646D00: using guessed type char qtextflag;

void __fastcall StartNewLvl(int pnum, int fom, int lvl)
{
	InitLevelChange(pnum);

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("StartNewLvl: illegal player %d", pnum);
	}

	switch (fom)
	{
	case WM_DIABNEXTLVL:
	case WM_DIABPREVLVL:
		plr[pnum].plrlevel = lvl;
		break;
	case WM_DIABRTNLVL:
	case WM_DIABTOWNWARP:
		plr[pnum].plrlevel = lvl;
		break;
	case WM_DIABSETLVL:
		setlvlnum = lvl;
		break;
	case WM_DIABTWARPUP:
		plr[myplr].pTownWarps |= 1 << (leveltype - 2);
		plr[pnum].plrlevel = lvl;
		break;
	case WM_DIABRETOWN:
		break;
	default:
		TermMsg("StartNewLvl");
		break;
	}

	if (pnum == myplr)
	{
		plr[pnum]._pmode = PM_NEWLVL;
		plr[pnum]._pInvincible = TRUE;
		PostMessage(ghMainWnd, fom, 0, 0);
		if (gbMaxPlayers > 1)
		{
			NetSendCmdParam2(TRUE, CMD_NEWLVL, fom, lvl);
		}
	}
}
// 5BB1ED: using guessed type char leveltype;
// 5CCB10: using guessed type char setlvlnum;
// 679660: using guessed type char gbMaxPlayers;

void __fastcall RestartTownLvl(int pnum)
{
	InitLevelChange(pnum);
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("RestartTownLvl: illegal player %d", pnum);
	}

	plr[pnum].plrlevel = 0;
	plr[pnum]._pInvincible = FALSE;

	SetPlayerHitPoints(pnum, 64);

	plr[pnum]._pMana = 0;
	plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase - plr[pnum]._pMaxMana;

	CalcPlrInv(pnum, FALSE);

	if (pnum == myplr)
	{
		plr[pnum]._pmode = PM_NEWLVL;
		plr[pnum]._pInvincible = TRUE;
		PostMessage(ghMainWnd, WM_DIABRETOWN, 0, 0);
	}
}

void __fastcall StartWarpLvl(int pnum, int pidx)
{
	InitLevelChange(pnum);

	if (gbMaxPlayers != 1)
	{
		if (plr[pnum].plrlevel != 0)
		{
			plr[pnum].plrlevel = 0;
		}
		else
		{
			plr[pnum].plrlevel = portal[pidx].level;
		}
	}

	if (pnum == myplr)
	{
		SetCurrentPortal(pidx);
		plr[pnum]._pmode = PM_NEWLVL;
		plr[pnum]._pInvincible = TRUE;
		PostMessage(ghMainWnd, WM_DIABWARPLVL, 0, 0);
	}
}
// 679660: using guessed type char gbMaxPlayers;

BOOL __fastcall PM_DoStand(int pnum)
{
	return FALSE;
}

BOOL __fastcall PM_DoWalk(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoWalk: illegal player %d", pnum);
	}

	if (plr[pnum]._pAnimFrame == 3 || (plr[pnum]._pWFrames == 8 && plr[pnum]._pAnimFrame == 7) || (plr[pnum]._pWFrames != 8 && plr[pnum]._pAnimFrame == 4))
	{
		PlaySfxLoc(PS_WALK1, plr[pnum].WorldX, plr[pnum].WorldY);
	}

	int vel = 8;
	if (currlevel)
	{
		vel = PWVel[3][plr[pnum]._pClass];
	}

	if (plr[pnum]._pVar8 == vel)
	{
		dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = 0;
		plr[pnum].WorldX += plr[pnum]._pVar1;
		plr[pnum].WorldY += plr[pnum]._pVar2;
		dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = pnum + 1;

		if (leveltype != DTYPE_TOWN)
		{
			ChangeLightXY(plr[pnum]._plid, plr[pnum].WorldX, plr[pnum].WorldY);
			ChangeVisionXY(plr[pnum]._pvid, plr[pnum].WorldX, plr[pnum].WorldY);
		}

		if (pnum == myplr && ScrollInfo._sdir)
		{
			ViewX = plr[pnum].WorldX - ScrollInfo._sdx;
			ViewY = plr[pnum].WorldY - ScrollInfo._sdy;
		}

		if (plr[pnum].walkpath[0] != WALK_NONE)
		{
			StartWalkStand(pnum);
		}
		else
		{
			StartStand(pnum, plr[pnum]._pVar3);
		}

		ClearPlrPVars(pnum);
		if (leveltype != DTYPE_TOWN)
		{
			ChangeLightOff(plr[pnum]._plid, 0, 0);
		}

		return TRUE;
	}

	PM_ChangeOffset(pnum);
	return FALSE;
}
// 5BB1ED: using guessed type char leveltype;

BOOL __fastcall PM_DoWalk2(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoWalk2: illegal player %d", pnum);
	}

	if (plr[pnum]._pAnimFrame == 3 || (plr[pnum]._pWFrames == 8 && plr[pnum]._pAnimFrame == 7) || (plr[pnum]._pWFrames != 8 && plr[pnum]._pAnimFrame == 4))
	{
		PlaySfxLoc(PS_WALK1, plr[pnum].WorldX, plr[pnum].WorldY);
	}

	int vel = 8;
	if (currlevel)
	{
		vel = PWVel[3][plr[pnum]._pClass];
	}

	if (plr[pnum]._pVar8 == vel)
	{
		dPlayer[plr[pnum]._pVar1][plr[pnum]._pVar2] = 0;
		if (leveltype != DTYPE_TOWN)
		{
			ChangeLightXY(plr[pnum]._plid, plr[pnum].WorldX, plr[pnum].WorldY);
			ChangeVisionXY(plr[pnum]._pvid, plr[pnum].WorldX, plr[pnum].WorldY);
		}

		if (pnum == myplr && ScrollInfo._sdir)
		{
			ViewX = plr[pnum].WorldX - ScrollInfo._sdx;
			ViewY = plr[pnum].WorldY - ScrollInfo._sdy;
		}

		if (plr[pnum].walkpath[0] != WALK_NONE)
		{
			StartWalkStand(pnum);
		}
		else
		{
			StartStand(pnum, plr[pnum]._pVar3);
		}

		ClearPlrPVars(pnum);

		if (leveltype != DTYPE_TOWN)
		{
			ChangeLightOff(plr[pnum]._plid, 0, 0);
		}

		return TRUE;
	}

	PM_ChangeOffset(pnum);
	return FALSE;
}
// 5BB1ED: using guessed type char leveltype;

BOOL __fastcall PM_DoWalk3(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoWalk3: illegal player %d", pnum);
	}

	if (plr[pnum]._pAnimFrame == 3 || (plr[pnum]._pWFrames == 8 && plr[pnum]._pAnimFrame == 7) || (plr[pnum]._pWFrames != 8 && plr[pnum]._pAnimFrame == 4))
	{
		PlaySfxLoc(PS_WALK1, plr[pnum].WorldX, plr[pnum].WorldY);
	}

	int vel = 8;
	if (currlevel)
	{
		vel = PWVel[3][plr[pnum]._pClass];
	}

	if (plr[pnum]._pVar8 == vel)
	{
		dPlayer[plr[pnum].WorldX][plr[pnum].WorldY] = 0;
		dFlags[plr[pnum]._pVar4][plr[pnum]._pVar5] &= ~DFLAG_PLAYER;
		plr[pnum].WorldX = plr[pnum]._pVar1;
		plr[pnum].WorldY = plr[pnum]._pVar2;
		dPlayer[plr[pnum]._pVar1][plr[pnum]._pVar2] = pnum + 1;

		if (leveltype != DTYPE_TOWN)
		{
			ChangeLightXY(plr[pnum]._plid, plr[pnum]._pVar1, plr[pnum]._pVar2);
			ChangeVisionXY(plr[pnum]._pvid, plr[pnum].WorldX, plr[pnum].WorldY);
		}

		if (pnum == myplr && ScrollInfo._sdir)
		{
			ViewX = plr[pnum].WorldX - ScrollInfo._sdx;
			ViewY = plr[pnum].WorldY - ScrollInfo._sdy;
		}

		if (plr[pnum].walkpath[0] != WALK_NONE)
		{
			StartWalkStand(pnum);
		}
		else
		{
			StartStand(pnum, plr[pnum]._pVar3);
		}

		ClearPlrPVars(pnum);

		if (leveltype != DTYPE_TOWN)
		{
			ChangeLightOff(plr[pnum]._plid, 0, 0);
		}

		return TRUE;
	}

	PM_ChangeOffset(pnum);
	return FALSE;
}
// 5BB1ED: using guessed type char leveltype;

BOOL __fastcall WeaponDur(int pnum, int durrnd)
{
	if (pnum != myplr)
	{
		return FALSE;
	}

	if (random(3, durrnd) != 0)
	{
		return FALSE;
	}

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("WeaponDur: illegal player %d", pnum);
	}

	if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype != ITYPE_NONE && plr[pnum].InvBody[INVLOC_HAND_LEFT]._iClass == ICLASS_WEAPON)
	{
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability == DUR_INDESTRUCTIBLE)
		{
			return FALSE;
		}

		plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability--;
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability == 0)
		{
			NetSendCmdDelItem(TRUE, INVLOC_HAND_LEFT);
			plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype = ITYPE_NONE;
			CalcPlrInv(pnum, TRUE);
			return TRUE;
		}
	}

	if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype != ITYPE_NONE && plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iClass == ICLASS_WEAPON)
	{
		if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability == DUR_INDESTRUCTIBLE)
		{
			return FALSE;
		}

		plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability--;
		if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability == 0)
		{
			NetSendCmdDelItem(TRUE, INVLOC_HAND_RIGHT);
			plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype = ITYPE_NONE;
			CalcPlrInv(pnum, TRUE);
			return TRUE;
		}
	}

	if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype == ITYPE_NONE && plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype == ITYPE_SHIELD)
	{
		if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability == DUR_INDESTRUCTIBLE)
		{
			return FALSE;
		}

		plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability--;
		if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability == 0)
		{
			NetSendCmdDelItem(TRUE, INVLOC_HAND_RIGHT);
			plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype = ITYPE_NONE;
			CalcPlrInv(pnum, TRUE);
			return TRUE;
		}
	}

	if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype == ITYPE_NONE && plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype == ITYPE_SHIELD)
	{
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability == DUR_INDESTRUCTIBLE)
		{
			return FALSE;
		}

		plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability--;
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability == 0)
		{
			NetSendCmdDelItem(TRUE, INVLOC_HAND_LEFT);
			plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype = ITYPE_NONE;
			CalcPlrInv(pnum, TRUE);
			return TRUE;
		}
	}

	return FALSE;
}

BOOL __fastcall PlrHitMonst(int pnum, int m)
{
	if ((DWORD)m >= MAXMONSTERS)
	{
		TermMsg("PlrHitMonst: illegal monster %d", m);
	}

	if ((monster[m]._mhitpoints >> 6) <= 0)
	{
		return FALSE;
	}

	if (monster[m].MType->mtype == MT_ILLWEAV && monster[m]._mgoal == 2)
	{
		return FALSE;
	}

	if (monster[m]._mmode == MM_CHARGE)
	{
		return FALSE;
	}

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PlrHitMonst: illegal player %d", pnum);
	}

	BOOL rv = FALSE;

	int hit = random(4, 100);
	if (monster[m]._mmode == MM_STONE)
	{
		hit = 0;
	}

	int hper = (plr[pnum]._pDexterity >> 1) + plr[pnum]._pLevel + 50 - (monster[m].mArmorClass - plr[pnum]._pIEnAc);
	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		hper += 20;
	}
	hper += plr[pnum]._pIBonusToHit;
	if (hper < 5)
	{
		hper = 5;
	}
	if (hper > 95)
	{
		hper = 95;
	}

	BOOL ret;
	if (CheckMonsterHit(m, &ret))
	{
		return ret;
	}
#ifdef _DEBUG
	if (hit < hper || debug_mode_key_inverted_v || debug_mode_dollar_sign)
	{
#else
	if (hit < hper)
	{
#endif
		int mind = plr[pnum]._pIMinDam;
		int maxd = random(5, plr[pnum]._pIMaxDam - mind + 1);
		int dam = maxd + mind;
		dam += plr[pnum]._pDamageMod + plr[pnum]._pIBonusDamMod + dam * plr[pnum]._pIBonusDam / 100;
		if (plr[pnum]._pClass == PC_WARRIOR)
		{
			int lvl = plr[pnum]._pLevel;
			if (random(6, 100) < lvl)
			{
				dam *= 2;
			}
		}

		int phanditype = ITYPE_NONE;
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype == ITYPE_SWORD || plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype == ITYPE_SWORD)
		{
			phanditype = ITYPE_SWORD;
		}
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype == ITYPE_MACE || plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype == ITYPE_MACE)
		{
			phanditype = ITYPE_MACE;
		}

		int mClass = monster[m].MData->mMonstClass;
		switch (mClass)
		{
		case MC_UNDEAD:
			if (phanditype == ITYPE_SWORD)
			{
				dam -= dam >> 1;
			}
			if (phanditype == ITYPE_MACE)
			{
				dam += dam >> 1;
			}
			break;
		case MC_ANIMAL:
			if (phanditype == ITYPE_MACE)
			{
				dam -= dam >> 1;
			}
			if (phanditype == ITYPE_SWORD)
			{
				dam += dam >> 1;
			}
			break;
		}

		if (plr[pnum]._pIFlags & ISPL_3XDAMVDEM && monster[m].MData->mMonstClass == MC_DEMON)
		{
			dam *= 3;
		}

		int skdam = dam << 6;
		if (pnum == myplr)
		{
			monster[m]._mhitpoints -= skdam;
		}

		int tac;
		if (plr[pnum]._pIFlags & ISPL_RNDSTEALLIFE)
		{
			tac = random(7, skdam >> 3);
			plr[pnum]._pHitPoints += tac;
			if (plr[pnum]._pHitPoints > plr[pnum]._pMaxHP)
			{
				plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
			}
			plr[pnum]._pHPBase += tac;
			if (plr[pnum]._pHPBase > plr[pnum]._pMaxHPBase)
			{
				plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
			}
			drawhpflag = TRUE;
		}
		if (plr[pnum]._pIFlags & (ISPL_STEALMANA_3 | ISPL_STEALMANA_5) && !(plr[pnum]._pIFlags & ISPL_NOMANA))
		{
			if (plr[pnum]._pIFlags & ISPL_STEALMANA_3)
			{
				tac = 3 * skdam / 100;
			}
			if (plr[pnum]._pIFlags & ISPL_STEALMANA_5)
			{
				tac = 5 * skdam / 100;
			}
			plr[pnum]._pMana += tac;
			if (plr[pnum]._pMana > plr[pnum]._pMaxMana)
			{
				plr[pnum]._pMana = plr[pnum]._pMaxMana;
			}
			plr[pnum]._pManaBase += tac;
			if (plr[pnum]._pManaBase > plr[pnum]._pMaxManaBase)
			{
				plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase;
			}
			drawmanaflag = 1;
		}
		if (plr[pnum]._pIFlags & (ISPL_STEALLIFE_3 | ISPL_STEALLIFE_5))
		{
			if (plr[pnum]._pIFlags & ISPL_STEALLIFE_3)
			{
				tac = 3 * skdam / 100;
			}
			if (plr[pnum]._pIFlags & ISPL_STEALLIFE_5)
			{
				tac = 5 * skdam / 100;
			}
			plr[pnum]._pHitPoints += tac;
			if (plr[pnum]._pHitPoints > plr[pnum]._pMaxHP)
			{
				plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
			}
			plr[pnum]._pHPBase += tac;
			if (plr[pnum]._pHPBase > plr[pnum]._pMaxHPBase)
			{
				plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
			}
			drawhpflag = TRUE;
		}
		if (plr[pnum]._pIFlags & ISPL_NOHEALPLR)
		{
			monster[m]._mFlags |= 8;
		}
#ifdef _DEBUG
		if (debug_mode_dollar_sign || debug_mode_key_inverted_v)
		{
			monster[m]._mhitpoints = 0; /* double check */
		}
#endif
		if ((monster[m]._mhitpoints >> 6) <= 0)
		{
			if (monster[m]._mmode == MM_STONE)
			{
				M_StartKill(m, pnum);
				monster[m]._mmode = MM_STONE;
			}
			else
			{
				M_StartKill(m, pnum);
			}
		}
		else
		{
			if (monster[m]._mmode == MM_STONE)
			{
				M_StartHit(m, pnum, skdam);
				monster[m]._mmode = MM_STONE;
			}
			else
			{
				if (plr[pnum]._pIFlags & ISPL_KNOCKBACK)
				{
					M_GetKnockback(m);
				}
				M_StartHit(m, pnum, skdam);
			}
		}
		rv = TRUE;
	}

	return rv;
}

BOOL __fastcall PlrHitPlr(int pnum, char p)
{
	if ((DWORD)p >= MAX_PLRS)
	{
		TermMsg("PlrHitPlr: illegal target player %d", p);
	}

	BOOL rv = FALSE;

	if (plr[p]._pInvincible)
	{
		return rv;
	}

	if (plr[p]._pSpellFlags & 1)
	{
		return rv;
	}

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PlrHitPlr: illegal attacking player %d", pnum);
	}

	int hit = random(4, 100);

	int hper = (plr[pnum]._pDexterity >> 1) + plr[pnum]._pLevel + 50 - (plr[p]._pIBonusAC + plr[p]._pIAC + plr[p]._pDexterity / 5);

	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		hper += 20;
	}
	hper += plr[pnum]._pIBonusToHit;
	if (hper < 5)
	{
		hper = 5;
	}
	if (hper > 95)
	{
		hper = 95;
	}

	int blk;
	if ((plr[p]._pmode == PM_STAND || plr[p]._pmode == PM_ATTACK) && plr[p]._pBlockFlag)
	{
		blk = random(5, 100);
	}
	else
	{
		blk = 100;
	}

	int blkper = plr[p]._pDexterity + plr[p]._pBaseToBlk + (plr[p]._pLevel << 1) - (plr[pnum]._pLevel << 1);
	if (blkper < 0)
	{
		blkper = 0;
	}
	if (blkper > 100)
	{
		blkper = 100;
	}

	if (hit < hper)
	{
		if (blk < blkper)
		{
			int dir = GetDirection(plr[p].WorldX, plr[p].WorldY, plr[pnum].WorldX, plr[pnum].WorldY);
			StartPlrBlock(p, dir);
		}
		else
		{
			int mind = plr[pnum]._pIMinDam;
			int maxd = random(5, plr[pnum]._pIMaxDam - mind + 1);
			int dam = maxd + mind;
			dam += plr[pnum]._pDamageMod + plr[pnum]._pIBonusDamMod + dam * plr[pnum]._pIBonusDam / 100;

			if (plr[pnum]._pClass == PC_WARRIOR)
			{
				int lvl = plr[pnum]._pLevel;
				if (random(6, 100) < lvl)
				{
					dam *= 2;
				}
			}
			int skdam = dam << 6;
			if (plr[pnum]._pIFlags & ISPL_RNDSTEALLIFE)
			{
				int tac = random(7, skdam >> 3);
				plr[pnum]._pHitPoints += tac;
				if (plr[pnum]._pHitPoints > plr[pnum]._pMaxHP)
				{
					plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
				}
				plr[pnum]._pHPBase += tac;
				if (plr[pnum]._pHPBase > plr[pnum]._pMaxHPBase)
				{
					plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
				}
				drawhpflag = TRUE;
			}
			if (pnum == myplr)
			{
				NetSendCmdDamage(TRUE, p, skdam);
			}
			StartPlrHit(p, skdam, FALSE);
		}

		rv = TRUE;
	}

	return rv;
}

BOOL __fastcall PlrHitObj(int pnum, int mx, int my)
{
	int oi;

	if (dObject[mx][my] > 0)
	{
		oi = dObject[mx][my] - 1;
	}
	else
	{
		oi = -dObject[mx][my] - 1;
	}

	if (object[oi]._oBreak == 1)
	{
		BreakObject(pnum, oi);
		return TRUE;
	}

	return FALSE;
}

BOOL __fastcall PM_DoAttack(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoAttack: illegal player %d", pnum);
	}

	int frame = plr[pnum]._pAnimFrame;
	if (plr[pnum]._pIFlags & ISPL_QUICKATTACK && frame == 1)
	{
		plr[pnum]._pAnimFrame++;
	}
	if (plr[pnum]._pIFlags & ISPL_FASTATTACK && (frame == 1 || frame == 3))
	{
		plr[pnum]._pAnimFrame++;
	}
	if (plr[pnum]._pIFlags & ISPL_FASTERATTACK && (frame == 1 || frame == 3 || frame == 5))
	{
		plr[pnum]._pAnimFrame++;
	}
	if (plr[pnum]._pIFlags & ISPL_FASTESTATTACK && (frame == 1 || frame == 4))
	{
		plr[pnum]._pAnimFrame += 2;
	}
	if (plr[pnum]._pAnimFrame == plr[pnum]._pAFNum - 1)
	{
		PlaySfxLoc(PS_SWING, plr[pnum].WorldX, plr[pnum].WorldY);
	}

	if (plr[pnum]._pAnimFrame == plr[pnum]._pAFNum)
	{
		int dir = plr[pnum]._pdir;
		int dx = plr[pnum].WorldX + offset_x[dir];
		int dy = plr[pnum].WorldY + offset_y[dir];

		int m;
		if (dMonster[dx][dy])
		{
			if (dMonster[dx][dy] > 0)
			{
				m = dMonster[dx][dy] - 1;
			}
			else
			{
				m = -(dMonster[dx][dy] + 1);
			}
			if (CanTalkToMonst(m))
			{
				plr[pnum]._pVar1 = 0;
				return FALSE;
			}
		}

		if (plr[pnum]._pIFlags & ISPL_FIREDAM)
		{
			AddMissile(dx, dy, 1, 0, 0, MIS_WEAPEXP, 0, pnum, 0, 0);
		}
		if (plr[pnum]._pIFlags & ISPL_LIGHTDAM)
		{
			AddMissile(dx, dy, 2, 0, 0, MIS_WEAPEXP, 0, pnum, 0, 0);
		}

		BOOL didhit = FALSE;
		if (dMonster[dx][dy])
		{
			m = dMonster[dx][dy];
			if (dMonster[dx][dy] > 0)
			{
				m = dMonster[dx][dy] - 1;
			}
			else
			{
				m = -(dMonster[dx][dy] + 1);
			}
			didhit = PlrHitMonst(pnum, m);
		}
		else if (dPlayer[dx][dy] && !FriendlyMode)
		{
			UCHAR p = dPlayer[dx][dy];
			if (dPlayer[dx][dy] > 0)
			{
				p = dPlayer[dx][dy] - 1;
			}
			else
			{
				p = -(dPlayer[dx][dy] + 1);
			}
			didhit = PlrHitPlr(pnum, p);
		}
		else if (dObject[dx][dy] > 0)
		{
			didhit = PlrHitObj(pnum, dx, dy);
		}

		if (didhit && WeaponDur(pnum, 30))
		{
			StartStand(pnum, plr[pnum]._pdir);
			ClearPlrPVars(pnum);
			return TRUE;
		}
	}

	if (plr[pnum]._pAnimFrame == plr[pnum]._pAFrames)
	{
		StartStand(pnum, plr[pnum]._pdir);
		ClearPlrPVars(pnum);
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
// 484368: using guessed type int FriendlyMode;

BOOL __fastcall PM_DoRangeAttack(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoRangeAttack: illegal player %d", pnum);
	}

	int origFrame = plr[pnum]._pAnimFrame;
	if (plr[pnum]._pIFlags & ISPL_QUICKATTACK && origFrame == 1)
	{
		plr[pnum]._pAnimFrame++;
	}
	if (plr[pnum]._pIFlags & ISPL_FASTATTACK && (origFrame == 1 || origFrame == 3))
	{
		plr[pnum]._pAnimFrame++;
	}

	if (plr[pnum]._pAnimFrame == plr[pnum]._pAFNum)
	{
		int mistype = MIS_ARROW;
		if (plr[pnum]._pIFlags & ISPL_FIRE_ARROWS)
		{
			mistype = MIS_FARROW;
		}
		if (plr[pnum]._pIFlags & ISPL_LIGHT_ARROWS)
		{
			mistype = MIS_LARROW;
		}
		AddMissile(
			plr[pnum].WorldX,
			plr[pnum].WorldY,
			plr[pnum]._pVar1,
			plr[pnum]._pVar2,
			plr[pnum]._pdir,
			mistype,
			0,
			pnum,
			4,
			0);

		PlaySfxLoc(PS_BFIRE, plr[pnum].WorldX, plr[pnum].WorldY);

		if (WeaponDur(pnum, 40))
		{
			StartStand(pnum, plr[pnum]._pdir);
			ClearPlrPVars(pnum);
			return TRUE;
		}
	}

	if (plr[pnum]._pAnimFrame >= plr[pnum]._pAFrames)
	{
		StartStand(pnum, plr[pnum]._pdir);
		ClearPlrPVars(pnum);
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

void __fastcall ShieldDur(int pnum)
{
	if (pnum != myplr)
	{
		return;
	}

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ShieldDur: illegal player %d", pnum);
	}

	if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype == ITYPE_SHIELD)
	{
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability == DUR_INDESTRUCTIBLE)
		{
			return;
		}

		plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability--;
		if (plr[pnum].InvBody[INVLOC_HAND_LEFT]._iDurability == 0)
		{
			NetSendCmdDelItem(TRUE, INVLOC_HAND_LEFT);
			plr[pnum].InvBody[INVLOC_HAND_LEFT]._itype = ITYPE_NONE;
			CalcPlrInv(pnum, TRUE);
		}
	}

	if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype == ITYPE_SHIELD)
	{
		if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability != DUR_INDESTRUCTIBLE)
		{
			plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability--;
			if (plr[pnum].InvBody[INVLOC_HAND_RIGHT]._iDurability == 0)
			{
				NetSendCmdDelItem(TRUE, INVLOC_HAND_RIGHT);
				plr[pnum].InvBody[INVLOC_HAND_RIGHT]._itype = ITYPE_NONE;
				CalcPlrInv(pnum, TRUE);
			}
		}
	}
}

BOOL __fastcall PM_DoBlock(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoBlock: illegal player %d", pnum);
	}

	if (plr[pnum]._pIFlags & ISPL_FASTBLOCK && plr[pnum]._pAnimFrame != 1)
	{
		plr[pnum]._pAnimFrame = plr[pnum]._pBFrames;
	}

	if (plr[pnum]._pAnimFrame >= plr[pnum]._pBFrames)
	{
		StartStand(pnum, plr[pnum]._pdir);
		ClearPlrPVars(pnum);

		if (!random(3, 10))
		{
			ShieldDur(pnum);
		}
		return TRUE;
	}

	return FALSE;
}

BOOL __fastcall PM_DoSpell(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoSpell: illegal player %d", pnum);
	}

	if (plr[pnum]._pVar8 == plr[pnum]._pSFNum)
	{
		CastSpell(
			pnum,
			plr[pnum]._pSpell,
			plr[pnum].WorldX,
			plr[pnum].WorldY,
			plr[pnum]._pVar1,
			plr[pnum]._pVar2,
			FALSE,
			plr[pnum]._pVar4);

		if (!plr[pnum]._pSplFrom)
		{
			if (plr[pnum]._pRSplType == RSPLTYPE_SCROLL)
			{
				if (!(plr[pnum]._pScrlSpells64 & (unsigned __int64)1 << (plr[pnum]._pRSpell - 1)))
				{
					plr[pnum]._pRSpell = SPL_INVALID;
					plr[pnum]._pRSplType = RSPLTYPE_INVALID;
					drawpanflag = 255;
				}
			}

			if (plr[pnum]._pRSplType == RSPLTYPE_CHARGES)
			{
				if (!(plr[pnum]._pISpells64 & (unsigned __int64)1 << (plr[pnum]._pRSpell - 1)))
				{
					plr[pnum]._pRSpell = SPL_INVALID;
					plr[pnum]._pRSplType = RSPLTYPE_INVALID;
					drawpanflag = 255;
				}
			}
		}
	}

	plr[pnum]._pVar8++;

	if (leveltype == DTYPE_TOWN)
	{
		if (plr[pnum]._pVar8 > plr[pnum]._pSFrames)
		{
			StartWalkStand(pnum);
			ClearPlrPVars(pnum);
			return TRUE;
		}
	}
	else if (plr[pnum]._pAnimFrame == plr[pnum]._pSFrames)
	{
		StartStand(pnum, plr[pnum]._pdir);
		ClearPlrPVars(pnum);
		return TRUE;
	}

	return FALSE;
}
// 52571C: using guessed type int drawpanflag;
// 5BB1ED: using guessed type char leveltype;

BOOL __fastcall PM_DoGotHit(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoGotHit: illegal player %d", pnum);
	}

	int frame = plr[pnum]._pAnimFrame;
	if (plr[pnum]._pIFlags & ISPL_FASTRECOVER && frame == 3)
	{
		plr[pnum]._pAnimFrame++;
	}
	if (plr[pnum]._pIFlags & ISPL_FASTERRECOVER && (frame == 3 || frame == 5))
	{
		plr[pnum]._pAnimFrame++;
	}
	if (plr[pnum]._pIFlags & ISPL_FASTESTRECOVER && (frame == 1 || frame == 3 || frame == 5))
	{
		plr[pnum]._pAnimFrame++;
	}

	if (plr[pnum]._pAnimFrame >= plr[pnum]._pHFrames)
	{
		StartStand(pnum, plr[pnum]._pdir);
		ClearPlrPVars(pnum);
		if (random(3, 4))
		{
			ArmorDur(pnum);
		}

		return TRUE;
	}

	return FALSE;
}

void __fastcall ArmorDur(int pnum)
{
	if (pnum != myplr)
	{
		return;
	}

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ArmorDur: illegal player %d", pnum);
	}

	PlayerStruct *p = &plr[pnum];
	if (p->InvBody[INVLOC_CHEST]._itype == ITYPE_NONE && p->InvBody[INVLOC_HEAD]._itype == ITYPE_NONE)
	{
		return;
	}

	int a = random(8, 3);
	if (p->InvBody[INVLOC_CHEST]._itype != ITYPE_NONE && p->InvBody[INVLOC_HEAD]._itype == ITYPE_NONE)
	{
		a = 1;
	}
	if (p->InvBody[INVLOC_CHEST]._itype == ITYPE_NONE && p->InvBody[INVLOC_HEAD]._itype != ITYPE_NONE)
	{
		a = 0;
	}

	ItemStruct *pi;
	if (a != 0)
	{
		pi = &p->InvBody[INVLOC_CHEST];
	}
	else
	{
		pi = &p->InvBody[INVLOC_HEAD];
	}
	if (pi->_iDurability == DUR_INDESTRUCTIBLE)
	{
		return;
	}

	pi->_iDurability--;
	if (pi->_iDurability != 0)
	{
		return;
	}

	if (a != 0)
	{
		NetSendCmdDelItem(TRUE, INVLOC_CHEST);
	}
	else
	{
		NetSendCmdDelItem(TRUE, INVLOC_HEAD);
	}
	pi->_itype = ITYPE_NONE;
	CalcPlrInv(pnum, TRUE);
}

BOOL __fastcall PM_DoDeath(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PM_DoDeath: illegal player %d", pnum);
	}

	if (plr[pnum]._pVar8 >= 2 * plr[pnum]._pDFrames)
	{
		if (deathdelay > 1 && pnum == myplr)
		{
			deathdelay--;
			if (deathdelay == 1)
			{
				deathflag = 1;
				if (gbMaxPlayers == 1)
				{
					gamemenu_previous();
				}
			}
		}

		plr[pnum]._pAnimFrame = plr[pnum]._pAnimLen;
		plr[pnum]._pAnimDelay = 10000;
		dFlags[plr[pnum].WorldX][plr[pnum].WorldY] |= DFLAG_DEAD_PLAYER;
	}

	if (plr[pnum]._pVar8 < 100)
	{
		plr[pnum]._pVar8++;
	}

	return FALSE;
}
// 679660: using guessed type char gbMaxPlayers;
// 69B7C4: using guessed type int deathdelay;

BOOL __fastcall PM_DoNewLvl(int pnum)
{
	return FALSE;
}

void __fastcall CheckNewPath(int pnum)
{
	int i;
	int x;
	int y;
	int d;
	int xvel3;
	int xvel;
	int yvel;

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("CheckNewPath: illegal player %d", pnum);
	}

	if (plr[pnum].destAction == ACTION_ATTACKMON)
	{
		MakePlrPath(pnum, monster[plr[pnum].destParam1]._mfutx, monster[plr[pnum].destParam1]._mfuty, FALSE);
	}

	if (plr[pnum].destAction == ACTION_ATTACKPLR)
	{
		MakePlrPath(pnum, plr[plr[pnum].destParam1]._px, plr[plr[pnum].destParam1]._py, FALSE);
	}

	if (plr[pnum].walkpath[0] != WALK_NONE)
	{
		if (plr[pnum]._pmode == PM_STAND)
		{
			if (pnum == myplr)
			{
				if (plr[pnum].destAction == ACTION_ATTACKMON || plr[pnum].destAction == ACTION_ATTACKPLR)
				{
					i = plr[pnum].destParam1;

					if (plr[pnum].destAction == ACTION_ATTACKMON)
					{
						x = abs(plr[pnum]._px - monster[i]._mfutx);
						y = abs(plr[pnum]._py - monster[i]._mfuty);
						d = GetDirection(plr[pnum]._px, plr[pnum]._py, monster[i]._mfutx, monster[i]._mfuty);
					}
					else
					{
						x = abs(plr[pnum]._px - plr[i]._px);
						y = abs(plr[pnum]._py - plr[i]._py);
						d = GetDirection(plr[pnum]._px, plr[pnum]._py, plr[i]._px, plr[i]._py);
					}

					if (x < 2 && y < 2)
					{
						ClrPlrPath(pnum);
						if (monster[i].mtalkmsg && monster[i].mtalkmsg != QUEST_VILE14)
						{
							TalktoMonster(i);
						}
						else
						{
							StartAttack(pnum, d);
						}
						plr[pnum].destAction = ACTION_NONE;
					}
				}
			}

			if (currlevel != 0)
			{
				xvel3 = PWVel[plr[pnum]._pClass][0];
				xvel = PWVel[plr[pnum]._pClass][1];
				yvel = PWVel[plr[pnum]._pClass][2];
			}
			else
			{
				xvel3 = 2048;
				xvel = 1024;
				yvel = 512;
			}

			switch (plr[pnum].walkpath[0])
			{
			case WALK_N:
				StartWalk(pnum, 0, -xvel, -1, -1, DIR_N, SDIR_N);
				break;
			case WALK_NE:
				StartWalk(pnum, xvel, -yvel, 0, -1, DIR_NE, SDIR_NE);
				break;
			case WALK_E:
				StartWalk3(pnum, xvel3, 0, -32, -16, 1, -1, 1, 0, DIR_E, SDIR_E);
				break;
			case WALK_SE:
				StartWalk2(pnum, xvel, yvel, -32, -16, 1, 0, DIR_SE, SDIR_SE);
				break;
			case WALK_S:
				StartWalk2(pnum, 0, xvel, 0, -32, 1, 1, DIR_S, SDIR_S);
				break;
			case WALK_SW:
				StartWalk2(pnum, -xvel, yvel, 32, -16, 0, 1, DIR_SW, SDIR_SW);
				break;
			case WALK_W:
				StartWalk3(pnum, -xvel3, 0, 32, -16, -1, 1, 0, 1, DIR_W, SDIR_W);
				break;
			case WALK_NW:
				StartWalk(pnum, -xvel, -yvel, -1, 0, DIR_NW, SDIR_NW);
				break;
			}

			for (i = 1; i < 25; i++)
			{
				plr[pnum].walkpath[i - 1] = plr[pnum].walkpath[i];
			}

			plr[pnum].walkpath[24] = WALK_NONE;

			if (plr[pnum]._pmode == PM_STAND)
			{
				StartStand(pnum, plr[pnum]._pdir);
				plr[pnum].destAction = ACTION_NONE;
			}
		}

		return;
	}
	if (plr[pnum].destAction == ACTION_NONE)
	{
		return;
	}

	if (plr[pnum]._pmode == PM_STAND)
	{
		switch (plr[pnum].destAction)
		{
		case ACTION_ATTACK:
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum].destParam1, plr[pnum].destParam2);
			StartAttack(pnum, d);
			break;
		case ACTION_ATTACKMON:
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - monster[i]._mfutx);
			y = abs(plr[pnum].WorldY - monster[i]._mfuty);
			if (x <= 1 && y <= 1)
			{
				d = GetDirection(plr[pnum]._px, plr[pnum]._py, monster[i]._mfutx, monster[i]._mfuty);
				if (monster[i].mtalkmsg && monster[i].mtalkmsg != QUEST_VILE14)
				{
					TalktoMonster(i);
				}
				else
				{
					StartAttack(pnum, d);
				}
			}
			break;
		case ACTION_ATTACKPLR:
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - plr[i]._px);
			y = abs(plr[pnum].WorldY - plr[i]._py);
			if (x <= 1 && y <= 1)
			{
				d = GetDirection(plr[pnum]._px, plr[pnum]._py, plr[i]._px, plr[i]._py);
				StartAttack(pnum, d);
			}
			break;
		case ACTION_RATTACK:
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum].destParam1, plr[pnum].destParam2);
			StartRangeAttack(pnum, d, plr[pnum].destParam1, plr[pnum].destParam2);
			break;
		case ACTION_RATTACKMON:
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum]._px, plr[pnum]._py, monster[i]._mfutx, monster[i]._mfuty);
			if (monster[i].mtalkmsg && monster[i].mtalkmsg != QUEST_VILE14)
			{
				TalktoMonster(i);
			}
			else
			{
				StartRangeAttack(pnum, d, monster[i]._mfutx, monster[i]._mfuty);
			}
			break;
		case ACTION_RATTACKPLR:
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum]._px, plr[pnum]._py, plr[i]._px, plr[i]._py);
			StartRangeAttack(pnum, d, plr[i]._px, plr[i]._py);
			break;
		case ACTION_SPELL:
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum].destParam1, plr[pnum].destParam2);
			StartSpell(pnum, d, plr[pnum].destParam1, plr[pnum].destParam2);
			plr[pnum]._pVar4 = plr[pnum].destParam3;
			break;
		case ACTION_SPELLWALL:
			StartSpell(pnum, plr[pnum].destParam3, plr[pnum].destParam1, plr[pnum].destParam2);
			plr[pnum]._pVar3 = plr[pnum].destParam3;
			plr[pnum]._pVar4 = plr[pnum].destParam4;
			break;
		case ACTION_SPELLMON:
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, monster[i]._mfutx, monster[i]._mfuty);
			StartSpell(pnum, d, monster[i]._mfutx, monster[i]._mfuty);
			plr[pnum]._pVar4 = plr[pnum].destParam2;
			break;
		case ACTION_SPELLPLR:
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[i]._px, plr[i]._py);
			StartSpell(pnum, d, plr[i]._px, plr[i]._py);
			plr[pnum]._pVar4 = plr[pnum].destParam2;
			break;
		case ACTION_OPERATE:
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - object[i]._ox);
			y = abs(plr[pnum].WorldY - object[i]._oy);
			if (y > 1 && dObject[object[i]._ox][object[i]._oy - 1] == -1 - i)
			{
				y = abs(plr[pnum].WorldY - object[i]._oy + 1);
			}
			if (x <= 1 && y <= 1)
			{
				if (object[i]._oBreak == 1)
				{
					d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, object[i]._ox, object[i]._oy);
					StartAttack(pnum, d);
				}
				else
				{
					OperateObject(pnum, i, FALSE);
				}
			}
			break;
		case ACTION_DISARM:
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - object[i]._ox);
			y = abs(plr[pnum].WorldY - object[i]._oy);
			if (y > 1 && dObject[object[i]._ox][object[i]._oy - 1] == -1 - i)
			{
				y = abs(plr[pnum].WorldY - object[i]._oy + 1);
			}
			if (x <= 1 && y <= 1)
			{
				if (object[i]._oBreak == 1)
				{
					d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, object[i]._ox, object[i]._oy);
					StartAttack(pnum, d);
				}
				else
				{
					TryDisarm(pnum, i);
					OperateObject(pnum, i, FALSE);
				}
			}
			break;
		case ACTION_OPERATETK:
			i = plr[pnum].destParam1;
			if (object[i]._oBreak != 1)
			{
				OperateObject(pnum, i, TRUE);
			}
			break;
		case ACTION_PICKUPITEM:
			if (pnum == myplr)
			{
				i = plr[pnum].destParam1;
				x = abs(plr[pnum].WorldX - item[i]._ix);
				y = abs(plr[pnum].WorldY - item[i]._iy);
				if (x <= 1 && y <= 1 && pcurs == 1 && !item[i]._iRequest)
				{
					NetSendCmdGItem(TRUE, CMD_REQUESTGITEM, myplr, myplr, i);
					item[i]._iRequest = TRUE;
				}
			}
			break;
		case ACTION_PICKUPAITEM:
			if (pnum == myplr)
			{
				i = plr[pnum].destParam1;
				x = abs(plr[pnum].WorldX - item[i]._ix);
				y = abs(plr[pnum].WorldY - item[i]._iy);
				if (x <= 1 && y <= 1 && pcurs == 1)
				{
					NetSendCmdGItem(TRUE, CMD_REQUESTAGITEM, myplr, myplr, i);
				}
			}
			break;
		case ACTION_TALK:
			if (pnum == myplr)
			{
				TalkToTowner(pnum, plr[pnum].destParam1);
			}
			break;
		}

		FixPlayerLocation(pnum, plr[pnum]._pdir);
		plr[pnum].destAction = ACTION_NONE;

		return;
	}

	if (plr[pnum]._pmode == PM_ATTACK && plr[pnum]._pAnimFrame > plr[myplr]._pAFNum)
	{
		if (plr[pnum].destAction == ACTION_ATTACK)
		{
			d = GetDirection(plr[pnum]._px, plr[pnum]._py, plr[pnum].destParam1, plr[pnum].destParam2);
			StartAttack(pnum, d);
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_ATTACKMON)
		{
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - monster[i]._mfutx);
			y = abs(plr[pnum].WorldY - monster[i]._mfuty);
			if (x <= 1 && y <= 1)
			{
				d = GetDirection(plr[pnum]._px, plr[pnum]._py, monster[i]._mfutx, monster[i]._mfuty);
				StartAttack(pnum, d);
			}
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_ATTACKPLR)
		{
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - plr[i]._px);
			y = abs(plr[pnum].WorldY - plr[i]._py);
			if (x <= 1 && y <= 1)
			{
				d = GetDirection(plr[pnum]._px, plr[pnum]._py, plr[i]._px, plr[i]._py);
				StartAttack(pnum, d);
			}
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_OPERATE)
		{
			i = plr[pnum].destParam1;
			x = abs(plr[pnum].WorldX - object[i]._ox);
			y = abs(plr[pnum].WorldY - object[i]._oy);
			if (y > 1 && dObject[object[i]._ox][object[i]._oy - 1] == -1 - i)
			{
				y = abs(plr[pnum].WorldY - object[i]._oy + 1);
			}
			if (x <= 1 && y <= 1)
			{
				if (object[i]._oBreak == 1)
				{
					d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, object[i]._ox, object[i]._oy);
					StartAttack(pnum, d);
				}
				else
				{
					OperateObject(pnum, i, FALSE);
				}
			}
		}
	}

	if (plr[pnum]._pmode == PM_RATTACK && plr[pnum]._pAnimFrame > plr[myplr]._pAFNum)
	{
		if (plr[pnum].destAction == ACTION_RATTACK)
		{
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum].destParam1, plr[pnum].destParam2);
			StartRangeAttack(pnum, d, plr[pnum].destParam1, plr[pnum].destParam2);
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_RATTACKMON)
		{
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, monster[i]._mfutx, monster[i]._mfuty);
			StartRangeAttack(pnum, d, monster[i]._mfutx, monster[i]._mfuty);
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_RATTACKPLR)
		{
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[i]._px, plr[i]._py);
			StartRangeAttack(pnum, d, plr[i]._px, plr[i]._py);
			plr[pnum].destAction = ACTION_NONE;
		}
	}

	if (plr[pnum]._pmode == PM_SPELL && plr[pnum]._pAnimFrame > plr[pnum]._pSFNum)
	{
		if (plr[pnum].destAction == ACTION_SPELL)
		{
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[pnum].destParam1, plr[pnum].destParam2);
			StartSpell(pnum, d, plr[pnum].destParam1, plr[pnum].destParam2);
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_SPELLMON)
		{
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, monster[i]._mfutx, monster[i]._mfuty);
			StartSpell(pnum, d, monster[i]._mfutx, monster[i]._mfuty);
			plr[pnum].destAction = ACTION_NONE;
		}
		else if (plr[pnum].destAction == ACTION_SPELLPLR)
		{
			i = plr[pnum].destParam1;
			d = GetDirection(plr[pnum].WorldX, plr[pnum].WorldY, plr[i]._px, plr[i]._py);
			StartSpell(pnum, d, plr[i]._px, plr[i]._py);
			plr[pnum].destAction = ACTION_NONE;
		}
	}
}

BOOL __fastcall PlrDeathModeOK(int pnum)
{
	if (pnum != myplr)
	{
		return TRUE;
	}

	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("PlrDeathModeOK: illegal player %d", pnum);
	}

	if (plr[pnum]._pmode == PM_DEATH)
	{
		return TRUE;
	}
	else if (plr[pnum]._pmode == PM_QUIT)
	{
		return TRUE;
	}
	else if (plr[pnum]._pmode == PM_NEWLVL)
	{
		return TRUE;
	}

	return FALSE;
}

void __cdecl ValidatePlayer()
{
	__int64 msk = 0;

	if ((DWORD)myplr >= MAX_PLRS)
	{
		TermMsg("ValidatePlayer: illegal player %d", myplr);
	}
	if (plr[myplr]._pLevel > 50)
		plr[myplr]._pLevel = 50;
	if (plr[myplr]._pExperience > plr[myplr]._pNextExper)
		plr[myplr]._pExperience = plr[myplr]._pNextExper;

	int gt = 0;
	for (int i = 0; i < plr[myplr]._pNumInv; i++)
	{
		if (plr[myplr].InvList[i]._itype == ITYPE_GOLD)
		{
			if (plr[myplr].InvList[i]._ivalue > 5000)
			{
				plr[myplr].InvList[i]._ivalue = 5000;
			}
			gt += plr[myplr].InvList[i]._ivalue;
		}
	}
	if (gt != plr[myplr]._pGold)
		plr[myplr]._pGold = gt;

	int pc = plr[myplr]._pClass;
	if (plr[myplr]._pBaseStr > MaxStats[pc][ATTRIB_STR])
	{
		plr[myplr]._pBaseStr = MaxStats[pc][ATTRIB_STR];
	}
	if (plr[myplr]._pBaseMag > MaxStats[pc][ATTRIB_MAG])
	{
		plr[myplr]._pBaseMag = MaxStats[pc][ATTRIB_MAG];
	}
	if (plr[myplr]._pBaseDex > MaxStats[pc][ATTRIB_DEX])
	{
		plr[myplr]._pBaseDex = MaxStats[pc][ATTRIB_DEX];
	}
	if (plr[myplr]._pBaseVit > MaxStats[pc][ATTRIB_VIT])
	{
		plr[myplr]._pBaseVit = MaxStats[pc][ATTRIB_VIT];
	}

	for (int b = 1; b < MAX_SPELLS; b++)
	{
		if (spelldata[b].sBookLvl != -1)
		{
			msk |= (__int64)1 << (b - 1);
			if (plr[myplr]._pSplLvl[b] > 15)
				plr[myplr]._pSplLvl[b] = 15;
		}
	}

	plr[myplr]._pMemSpells64 &= msk;
}

void __cdecl ProcessPlayers()
{
	if ((DWORD)myplr >= MAX_PLRS)
	{
		TermMsg("ProcessPlayers: illegal player %d", myplr);
	}

	if (plr[myplr].pLvlLoad > 0)
	{
		plr[myplr].pLvlLoad--;
	}

	if (sfxdelay > 0)
	{
		sfxdelay--;
		if (sfxdelay == 0)
		{
			PlaySFX(sfxdnum);
		}
	}

	ValidatePlayer();

	for (int pnum = 0; pnum < MAX_PLRS; pnum++)
	{
		if (plr[pnum].plractive && currlevel == plr[pnum].plrlevel && (pnum == myplr || !plr[pnum]._pLvlChanging))
		{
			CheckCheatStats(pnum);

			if (!PlrDeathModeOK(pnum) && (plr[pnum]._pHitPoints >> 6) <= 0)
			{
				SyncPlrKill(pnum, -1);
			}

			if (pnum == myplr)
			{
				if ((plr[pnum]._pIFlags & ISPL_DRAINLIFE) && currlevel)
				{
					plr[pnum]._pHitPoints -= 4;
					plr[pnum]._pHPBase -= 4;
					if ((plr[pnum]._pHitPoints >> 6) <= 0)
					{
						SyncPlrKill(pnum, 0);
					}
					drawhpflag = TRUE;
				}
				if (plr[pnum]._pIFlags & ISPL_NOMANA && plr[pnum]._pManaBase > 0)
				{
					plr[pnum]._pManaBase -= plr[pnum]._pMana;
					plr[pnum]._pMana = 0;
					drawmanaflag = TRUE;
				}
			}

			BOOL tplayer = FALSE;
			do
			{
				switch (plr[pnum]._pmode)
				{
				case PM_STAND:
					tplayer = PM_DoStand(pnum);
					break;
				case PM_WALK:
					tplayer = PM_DoWalk(pnum);
					break;
				case PM_WALK2:
					tplayer = PM_DoWalk2(pnum);
					break;
				case PM_WALK3:
					tplayer = PM_DoWalk3(pnum);
					break;
				case PM_ATTACK:
					tplayer = PM_DoAttack(pnum);
					break;
				case PM_RATTACK:
					tplayer = PM_DoRangeAttack(pnum);
					break;
				case PM_BLOCK:
					tplayer = PM_DoBlock(pnum);
					break;
				case PM_SPELL:
					tplayer = PM_DoSpell(pnum);
					break;
				case PM_GOTHIT:
					tplayer = PM_DoGotHit(pnum);
					break;
				case PM_DEATH:
					tplayer = PM_DoDeath(pnum);
					break;
				case PM_NEWLVL:
					tplayer = PM_DoNewLvl(pnum);
					break;
				}
				CheckNewPath(pnum);
			} while (tplayer);

			plr[pnum]._pAnimCnt++;
			if (plr[pnum]._pAnimCnt > plr[pnum]._pAnimDelay)
			{
				plr[pnum]._pAnimCnt = 0;
				plr[pnum]._pAnimFrame++;
				if (plr[pnum]._pAnimFrame > plr[pnum]._pAnimLen)
				{
					plr[pnum]._pAnimFrame = 1;
				}
			}
		}
	}
}
// 52A554: using guessed type int sfxdelay;

void __fastcall CheckCheatStats(int pnum)
{
	if (plr[pnum]._pStrength > 750)
	{
		plr[pnum]._pStrength = 750;
	}

	if (plr[pnum]._pDexterity > 750)
	{
		plr[pnum]._pDexterity = 750;
	}

	if (plr[pnum]._pMagic > 750)
	{
		plr[pnum]._pMagic = 750;
	}

	if (plr[pnum]._pVitality > 750)
	{
		plr[pnum]._pVitality = 750;
	}

	if (plr[pnum]._pHitPoints > 128000)
	{
		plr[pnum]._pHitPoints = 128000;
	}

	if (plr[pnum]._pMana > 128000)
	{
		plr[pnum]._pMana = 128000;
	}
}

void __fastcall ClrPlrPath(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ClrPlrPath: illegal player %d", pnum);
	}

	memset(plr[pnum].walkpath, WALK_NONE, sizeof(plr[pnum].walkpath));
}

BOOL __fastcall PosOkPlayer(int pnum, int px, int py)
{
	BOOL PosOK = FALSE;
	if (px >= 0 && px < MAXDUNX && py >= 0 && py < MAXDUNY &&
		!SolidLoc(px, py) && dPiece[px][py])
	{

		if (dPlayer[px][py])
		{
			DWORD p;
			if (dPlayer[px][py] > 0)
			{
				p = dPlayer[px][py] - 1;
			}
			else
			{
				p = -(dPlayer[px][py] + 1);
			}
			if (p != pnum && p < MAX_PLRS && plr[p]._pHitPoints)
			{
				return FALSE;
			}
		}

		if (dMonster[px][py])
		{
			if (!currlevel)
			{
				return FALSE;
			}
			if (dMonster[px][py] <= 0)
			{
				return FALSE;
			}
			if ((monster[dMonster[px][py] - 1]._mhitpoints >> 6) > 0)
			{
				return FALSE;
			}
		}

		if (dObject[px][py])
		{
			char bv;
			if (dObject[px][py] > 0)
			{
				bv = dObject[px][py] - 1;
			}
			else
			{
				bv = -(dObject[px][py] + 1);
			}
			if (object[bv]._oSolidFlag)
			{
				return FALSE;
			}
		}

		PosOK = TRUE;
	}

	if (!PosOK)
		return FALSE;
	return TRUE;
}

void __fastcall MakePlrPath(int pnum, int xx, int yy, BOOL endspace)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("MakePlrPath: illegal player %d", pnum);
	}

	plr[pnum]._ptargx = xx;
	plr[pnum]._ptargy = yy;
	if (plr[pnum]._px == xx && plr[pnum]._py == yy)
	{
		return;
	}

	int path = FindPath(PosOkPlayer, pnum, plr[pnum]._px, plr[pnum]._py, xx, yy, plr[pnum].walkpath);
	if (!path)
	{
		return;
	}

	if (!endspace)
	{
		path--;

		switch (plr[pnum].walkpath[path])
		{
		case WALK_NE:
			yy++;
			break;
		case WALK_NW:
			xx++;
			break;
		case WALK_SE:
			xx--;
			break;
		case WALK_SW:
			yy--;
			break;
		case WALK_N:
			xx++;
			yy++;
			break;
		case WALK_E:
			xx--;
			yy++;
			break;
		case WALK_S:
			xx--;
			yy--;
			break;
		case WALK_W:
			xx++;
			yy--;
			break;
		}

		plr[pnum]._ptargx = xx;
		plr[pnum]._ptargy = yy;
	}

	plr[pnum].walkpath[path] = WALK_NONE;
}

void __fastcall CheckPlrSpell()
{
	if ((DWORD)myplr >= MAX_PLRS)
	{
		TermMsg("CheckPlrSpell: illegal player %d", myplr);
	}

	int rspell = plr[myplr]._pRSpell;
	if (rspell == SPL_INVALID)
	{
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			PlaySFX(PS_WARR34);
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			PlaySFX(PS_ROGUE34);
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			PlaySFX(PS_MAGE34);
		}
		return;
	}

	if (leveltype == DTYPE_TOWN && !spelldata[rspell].sTownSpell)
	{
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			PlaySFX(PS_WARR27);
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			PlaySFX(PS_ROGUE27);
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			PlaySFX(PS_MAGE27);
		}
		return;
	}

	if (pcurs != CURSOR_HAND || MouseY >= 352 || (chrflag && MouseX < 320 || invflag && MouseX > 320) && rspell != SPL_HEAL && rspell != SPL_IDENTIFY && rspell != SPL_REPAIR && rspell != SPL_INFRA && rspell != SPL_RECHARGE)
	{
		return;
	}

	BOOL addflag = FALSE;
	switch (plr[myplr]._pRSplType)
	{
	case RSPLTYPE_SKILL:
	case RSPLTYPE_SPELL:
		addflag = CheckSpell(myplr, rspell, plr[myplr]._pRSplType, FALSE);
		break;
	case RSPLTYPE_SCROLL:
		addflag = UseScroll();
		break;
	case RSPLTYPE_CHARGES:
		addflag = UseStaff();
		break;
	}

	if (addflag)
	{
		if (plr[myplr]._pRSpell == SPL_FIREWALL)
		{
			int sd = GetDirection(plr[myplr].WorldX, plr[myplr].WorldY, cursmx, cursmy);
			int sl = GetSpellLevel(myplr, plr[myplr]._pRSpell);
			NetSendCmdLocParam3(TRUE, CMD_SPELLXYD, cursmx, cursmy, plr[myplr]._pRSpell, sd, sl);
		}
		else if (pcursmonst != -1)
		{
			int sl = GetSpellLevel(myplr, plr[myplr]._pRSpell);
			NetSendCmdParam3(TRUE, CMD_SPELLID, pcursmonst, plr[myplr]._pRSpell, sl);
		}
		else if (pcursplr != -1)
		{
			int sl = GetSpellLevel(myplr, plr[myplr]._pRSpell);
			NetSendCmdParam3(TRUE, CMD_SPELLPID, pcursplr, plr[myplr]._pRSpell, sl);
		}
		else
		{ //145
			int sl = GetSpellLevel(myplr, plr[myplr]._pRSpell);
			NetSendCmdLocParam2(TRUE, CMD_SPELLXY, cursmx, cursmy, plr[myplr]._pRSpell, sl);
		}
		return;
	}

	if (plr[myplr]._pRSplType == RSPLTYPE_SPELL)
	{
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			PlaySFX(PS_WARR35);
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			PlaySFX(PS_ROGUE35);
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			PlaySFX(PS_MAGE35);
		}
	}
}
// 4B8CC2: using guessed type char pcursplr;
// 5BB1ED: using guessed type char leveltype;

void __fastcall SyncPlrAnim(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SyncPlrAnim: illegal player %d", pnum);
	}

	int dir = plr[pnum]._pdir;
	switch (plr[pnum]._pmode)
	{
	case PM_BLOCK:
		plr[pnum]._pAnimData = plr[pnum]._pBAnim[dir];
		break;
	case PM_GOTHIT:
		plr[pnum]._pAnimData = plr[pnum]._pHAnim[dir];
		break;
	case PM_DEATH:
		plr[pnum]._pAnimData = plr[pnum]._pDAnim[dir];
		break;
	case PM_SPELL:
		int sType;
		if (pnum == myplr)
		{
			sType = spelldata[plr[pnum]._pSpell].sType;
		}
		else
		{
			sType = STYPE_FIRE;
		}
		if (sType == STYPE_FIRE)
			plr[pnum]._pAnimData = plr[pnum]._pFAnim[dir];
		if (sType == STYPE_LIGHTNING)
			plr[pnum]._pAnimData = plr[pnum]._pLAnim[dir];
		if (sType == STYPE_MAGIC)
		{
			plr[pnum]._pAnimData = plr[pnum]._pTAnim[dir];
		}
		break;
	case PM_STAND:
	case PM_NEWLVL:
	case PM_QUIT:
		plr[pnum]._pAnimData = plr[pnum]._pNAnim[dir];
		break;
	case PM_WALK:
	case PM_WALK2:
	case PM_WALK3:
		plr[pnum]._pAnimData = plr[pnum]._pWAnim[dir];
		break;
	case PM_ATTACK:
	case PM_RATTACK:
		plr[pnum]._pAnimData = plr[pnum]._pAAnim[dir];
		break;
	default:
		TermMsg("SyncPlrAnim");
		break;
	}
}

void __fastcall SyncInitPlrPos(int pnum)
{
	plr[pnum]._ptargx = plr[pnum].WorldX;
	plr[pnum]._ptargy = plr[pnum].WorldY;

	if (gbMaxPlayers == 1 || plr[pnum].plrlevel != currlevel)
	{
		return;
	}

	int x;
	int y;
	for (DWORD i = 0; i < 8; i++)
	{
		x = plr[pnum].WorldX + plrxoff2[i];
		y = plr[pnum].WorldY + plryoff2[i];
		if (PosOkPlayer(pnum, x, y))
		{
			break;
		}
	}

	if (!PosOkPlayer(pnum, x, y))
	{
		BOOL posOk = FALSE;
		int xx;
		int yy;
		for (int range = 1; range < 50 && !posOk; range++)
		{
			for (yy = -range; yy <= range && !posOk; yy++)
			{
				y = yy + plr[pnum].WorldY;
				for (xx = -range; xx <= range && !posOk; xx++)
				{
					x = xx + plr[pnum].WorldX;
					if (PosOkPlayer(pnum, x, y) && !PosOkPortal(currlevel, x, y))
					{
						posOk = TRUE;
					}
				}
			}
		}
	}

	plr[pnum].WorldX = x;
	plr[pnum].WorldY = y;
	dPlayer[x][y] = pnum + 1;

	if (pnum == myplr)
	{
		plr[pnum]._px = x;
		plr[pnum]._py = y;
		plr[pnum]._ptargx = x;
		plr[pnum]._ptargy = y;
		ViewX = x;
		ViewY = y;
	}
}
// 679660: using guessed type char gbMaxPlayers;

void __fastcall SyncInitPlr(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SyncInitPlr: illegal player %d", pnum);
	}

	SetPlrAnims(pnum);
	SyncInitPlrPos(pnum);
}

void __fastcall CheckStats(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("CheckStats: illegal player %d", pnum);
	}

	int c;
	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		c = PC_WARRIOR;
	}
	else if (plr[pnum]._pClass == PC_ROGUE)
	{
		c = PC_ROGUE;
	}
	else if (plr[pnum]._pClass == PC_SORCERER)
	{
		c = PC_SORCERER;
	}

	for (int i = 0; i < 4; i++)
	{
		switch (i)
		{
		case ATTRIB_STR:
			if (plr[pnum]._pBaseStr > MaxStats[c][ATTRIB_STR])
			{
				plr[pnum]._pBaseStr = MaxStats[c][ATTRIB_STR];
			}
			else if (plr[pnum]._pBaseStr < 0)
			{
				plr[pnum]._pBaseStr = 0;
			}
			break;
		case ATTRIB_MAG:
			if (plr[pnum]._pBaseMag > MaxStats[c][ATTRIB_MAG])
			{
				plr[pnum]._pBaseMag = MaxStats[c][ATTRIB_MAG];
			}
			else if (plr[pnum]._pBaseMag < 0)
			{
				plr[pnum]._pBaseMag = 0;
			}
			break;
		case ATTRIB_DEX:
			if (plr[pnum]._pBaseDex > MaxStats[c][ATTRIB_DEX])
			{
				plr[pnum]._pBaseDex = MaxStats[c][ATTRIB_DEX];
			}
			else if (plr[pnum]._pBaseDex < 0)
			{
				plr[pnum]._pBaseDex = 0;
			}
			break;
		case ATTRIB_VIT:
			if (plr[pnum]._pBaseVit > MaxStats[c][ATTRIB_VIT])
			{
				plr[pnum]._pBaseVit = MaxStats[c][ATTRIB_VIT];
			}
			else if (plr[pnum]._pBaseVit < 0)
			{
				plr[pnum]._pBaseVit = 0;
			}
			break;
		}
	}
}

void __fastcall ModifyPlrStr(int pnum, int l)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ModifyPlrStr: illegal player %d", pnum);
	}

	int max = MaxStats[plr[pnum]._pClass][ATTRIB_STR];
	if (plr[pnum]._pBaseStr + l > max)
	{
		l = max - plr[pnum]._pBaseStr;
	}

	plr[pnum]._pStrength += l;
	plr[pnum]._pBaseStr += l;

	if (plr[pnum]._pClass == PC_ROGUE)
	{
		plr[pnum]._pDamageMod = plr[pnum]._pLevel * (plr[pnum]._pStrength + plr[pnum]._pDexterity) / 200;
	}
	else
	{
		plr[pnum]._pDamageMod = plr[pnum]._pLevel * plr[pnum]._pStrength / 100;
	}

	CalcPlrInv(pnum, TRUE);

	if (pnum == myplr)
	{
		NetSendCmdParam1(FALSE, CMD_SETSTR, plr[pnum]._pBaseStr); //60
	}
}

void __fastcall ModifyPlrMag(int pnum, int l)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ModifyPlrMag: illegal player %d", pnum);
	}

	int max = MaxStats[plr[pnum]._pClass][ATTRIB_MAG];
	if (plr[pnum]._pBaseMag + l > max)
	{
		l = max - plr[pnum]._pBaseMag;
	}

	plr[pnum]._pMagic += l;
	plr[pnum]._pBaseMag += l;

	int ms = l << 6;
	if (plr[pnum]._pClass == PC_SORCERER)
	{
		ms *= 2;
	}

	plr[pnum]._pMaxManaBase += ms;
	plr[pnum]._pMaxMana += ms;
	if (!(plr[pnum]._pIFlags & ISPL_NOMANA))
	{
		plr[pnum]._pManaBase += ms;
		plr[pnum]._pMana += ms;
	}

	CalcPlrInv(pnum, TRUE);

	if (pnum == myplr)
	{
		NetSendCmdParam1(FALSE, CMD_SETMAG, plr[pnum]._pBaseMag);
	}
}

void __fastcall ModifyPlrDex(int pnum, int l)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ModifyPlrDex: illegal player %d", pnum);
	}

	int max = MaxStats[plr[pnum]._pClass][ATTRIB_DEX];
	if (plr[pnum]._pBaseDex + l > max)
	{
		l = max - plr[pnum]._pBaseDex;
	}

	plr[pnum]._pDexterity += l;
	plr[pnum]._pBaseDex += l;
	CalcPlrInv(pnum, TRUE);

	if (plr[pnum]._pClass == PC_ROGUE)
	{
		plr[pnum]._pDamageMod = plr[pnum]._pLevel * (plr[pnum]._pDexterity + plr[pnum]._pStrength) / 200;
	}

	if (pnum == myplr)
	{
		NetSendCmdParam1(FALSE, CMD_SETDEX, plr[pnum]._pBaseDex);
	}
}

void __fastcall ModifyPlrVit(int pnum, int l)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("ModifyPlrVit: illegal player %d", pnum);
	}

	int max = MaxStats[plr[pnum]._pClass][ATTRIB_VIT];
	if (plr[pnum]._pBaseVit + l > max)
	{
		l = max - plr[pnum]._pBaseVit;
	}

	plr[pnum]._pVitality += l;
	plr[pnum]._pBaseVit += l;

	int ms = l << 6;
	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		ms *= 2;
	}

	plr[pnum]._pHPBase += ms;
	plr[pnum]._pMaxHPBase += ms;
	plr[pnum]._pHitPoints += ms;
	plr[pnum]._pMaxHP += ms;

	CalcPlrInv(pnum, TRUE);

	if (pnum == myplr)
	{
		NetSendCmdParam1(FALSE, CMD_SETVIT, plr[pnum]._pBaseVit);
	}
}

void __fastcall SetPlayerHitPoints(int pnum, int newhp)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlayerHitPoints: illegal player %d", pnum);
	}

	plr[pnum]._pHitPoints = newhp;
	plr[pnum]._pHPBase = newhp + plr[pnum]._pMaxHPBase - plr[pnum]._pMaxHP;

	if (pnum == myplr)
	{
		drawhpflag = TRUE;
	}
}

void __fastcall SetPlrStr(int pnum, int v)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlrStr: illegal player %d", pnum);
	}

	plr[pnum]._pBaseStr = v;
	CalcPlrInv(pnum, TRUE);

	int dm;
	if (plr[pnum]._pClass == PC_ROGUE)
	{
		dm = plr[pnum]._pLevel * (plr[pnum]._pStrength + plr[pnum]._pDexterity) / 200;
	}
	else
	{
		dm = plr[pnum]._pLevel * plr[pnum]._pStrength / 100;
	}

	plr[pnum]._pDamageMod = dm;
}

void __fastcall SetPlrMag(int pnum, int v)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlrMag: illegal player %d", pnum);
	}

	plr[pnum]._pBaseMag = v;

	int m = v << 6;
	if (plr[pnum]._pClass == PC_SORCERER)
	{
		m *= 2;
	}

	plr[pnum]._pMaxManaBase = m;
	plr[pnum]._pMaxMana = m;
	CalcPlrInv(pnum, TRUE);
}

void __fastcall SetPlrDex(int pnum, int v)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlrDex: illegal player %d", pnum);
	}

	plr[pnum]._pBaseDex = v;
	CalcPlrInv(pnum, TRUE);

	int dm;
	if (plr[pnum]._pClass == PC_ROGUE)
	{
		dm = plr[pnum]._pLevel * (plr[pnum]._pStrength + plr[pnum]._pDexterity) / 200;
	}
	else
	{
		dm = plr[pnum]._pStrength * plr[pnum]._pLevel / 100;
	}

	plr[pnum]._pDamageMod = dm;
}

void __fastcall SetPlrVit(int pnum, int v)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("SetPlrVit: illegal player %d", pnum);
	}

	plr[pnum]._pBaseVit = v;

	int hp = v << 6;
	if (plr[pnum]._pClass == PC_WARRIOR)
	{
		hp *= 2;
	}

	plr[pnum]._pHPBase = hp;
	plr[pnum]._pMaxHPBase = hp;
	CalcPlrInv(pnum, TRUE);
}

void __fastcall InitDungMsgs(int pnum)
{
	if ((DWORD)pnum >= MAX_PLRS)
	{
		TermMsg("InitDungMsgs: illegal player %d", pnum);
	}

	plr[pnum].pDungMsgs = 0;
}

void __cdecl PlayDungMsgs()
{
	if ((DWORD)myplr >= MAX_PLRS)
	{
		TermMsg("PlayDungMsgs: illegal player %d", myplr);
	}

	if (currlevel == 1 && !plr[myplr]._pLvlVisited[1] && gbMaxPlayers == 1 && !(plr[myplr].pDungMsgs & DMSG_CATHEDRAL))
	{
		sfxdelay = 40;
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			sfxdnum = PS_WARR97;
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			sfxdnum = PS_ROGUE97;
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			sfxdnum = PS_MAGE97;
		}
		plr[myplr].pDungMsgs = plr[myplr].pDungMsgs | DMSG_CATHEDRAL;
	}
	else if (currlevel == 5 && !plr[myplr]._pLvlVisited[5] && gbMaxPlayers == 1 && !(plr[myplr].pDungMsgs & DMSG_CATACOMBS))
	{
		sfxdelay = 40;
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			sfxdnum = PS_WARR96B;
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			sfxdnum = PS_ROGUE96;
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			sfxdnum = PS_MAGE96;
		}
		plr[myplr].pDungMsgs |= DMSG_CATACOMBS;
	}
	else if (currlevel == 9 && !plr[myplr]._pLvlVisited[9] && gbMaxPlayers == 1 && !(plr[myplr].pDungMsgs & DMSG_CAVES))
	{
		sfxdelay = 40;
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			sfxdnum = PS_WARR98;
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			sfxdnum = PS_ROGUE98;
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			sfxdnum = PS_MAGE98;
		}
		plr[myplr].pDungMsgs |= DMSG_CAVES;
	}
	else if (currlevel == 13 && !plr[myplr]._pLvlVisited[13] && gbMaxPlayers == 1 && !(plr[myplr].pDungMsgs & DMSG_HELL))
	{
		sfxdelay = 40;
		if (plr[myplr]._pClass == PC_WARRIOR)
		{
			sfxdnum = PS_WARR99;
		}
		else if (plr[myplr]._pClass == PC_ROGUE)
		{
			sfxdnum = PS_ROGUE99;
		}
		else if (plr[myplr]._pClass == PC_SORCERER)
		{
			sfxdnum = PS_MAGE99;
		}
		plr[myplr].pDungMsgs |= DMSG_HELL;
	}
	else if (currlevel == 16 && !plr[myplr]._pLvlVisited[15] && gbMaxPlayers == 1 && !(plr[myplr].pDungMsgs & DMSG_DIABLO))
	{
		sfxdelay = 40;
		if (plr[myplr]._pClass == PC_WARRIOR || plr[myplr]._pClass == PC_ROGUE || plr[myplr]._pClass == PC_SORCERER)
		{
			sfxdnum = PS_DIABLVLINT;
		}
		plr[myplr].pDungMsgs |= DMSG_DIABLO;
	}
	else
	{
		sfxdelay = 0;
	}
}
// 52A554: using guessed type int sfxdelay;
// 679660: using guessed type char gbMaxPlayers;