Browse Source

asd

dyn-players-param
Anders Jenbo 4 years ago
parent
commit
a0949b98fc
  1. 6
      Source/dthread.cpp
  2. 2
      Source/dthread.h
  3. 2
      Source/dvlnet/abstract_net.h
  4. 6
      Source/dvlnet/base.cpp
  5. 2
      Source/dvlnet/base.h
  6. 4
      Source/dvlnet/cdwrap.h
  7. 2
      Source/dvlnet/loopback.cpp
  8. 2
      Source/dvlnet/loopback.h
  9. 8
      Source/engine/render/scrollrt.cpp
  10. 11
      Source/inv.cpp
  11. 2
      Source/inv.h
  12. 20
      Source/items.cpp
  13. 2
      Source/items.h
  14. 1
      Source/minitext.cpp
  15. 1
      Source/minitext.h
  16. 62
      Source/missiles.cpp
  17. 4
      Source/missiles.h
  18. 40
      Source/monster.cpp
  19. 10
      Source/monster.h
  20. 118
      Source/msg.cpp
  21. 6
      Source/msg.h
  22. 32
      Source/multi.cpp
  23. 4
      Source/multi.h
  24. 98
      Source/objects.cpp
  25. 6
      Source/objects.h
  26. 222
      Source/player.cpp
  27. 28
      Source/player.h
  28. 8
      Source/portal.cpp
  29. 2
      Source/portal.h
  30. 4
      Source/qol/autopickup.cpp
  31. 2
      Source/qol/autopickup.h
  32. 12
      Source/spells.cpp
  33. 4
      Source/spells.h
  34. 2
      Source/storm/storm_net.cpp
  35. 2
      Source/storm/storm_net.hpp
  36. 6
      Source/sync.cpp
  37. 2
      Source/sync.h
  38. 8
      test/player_test.cpp

6
Source/dthread.cpp

@ -14,12 +14,12 @@
namespace devilution { namespace devilution {
struct DThreadPkt { struct DThreadPkt {
int pnum; size_t pnum;
_cmd_id cmd; _cmd_id cmd;
std::unique_ptr<byte[]> data; std::unique_ptr<byte[]> data;
uint32_t len; uint32_t len;
DThreadPkt(int pnum, _cmd_id(cmd), std::unique_ptr<byte[]> data, uint32_t len) DThreadPkt(size_t pnum, _cmd_id(cmd), std::unique_ptr<byte[]> data, uint32_t len)
: pnum(pnum) : pnum(pnum)
, cmd(cmd) , cmd(cmd)
, data(std::move(data)) , data(std::move(data))
@ -69,7 +69,7 @@ void dthread_remove_player(uint8_t pnum)
}); });
} }
void dthread_send_delta(int pnum, _cmd_id cmd, std::unique_ptr<byte[]> data, uint32_t len) void dthread_send_delta(size_t pnum, _cmd_id cmd, std::unique_ptr<byte[]> data, uint32_t len)
{ {
if (!gbIsMultiplayer || !DthreadRunning) if (!gbIsMultiplayer || !DthreadRunning)
return; return;

2
Source/dthread.h

@ -12,7 +12,7 @@
namespace devilution { namespace devilution {
void dthread_remove_player(uint8_t pnum); void dthread_remove_player(uint8_t pnum);
void dthread_send_delta(int pnum, _cmd_id cmd, std::unique_ptr<byte[]> data, uint32_t len); void dthread_send_delta(size_t pnum, _cmd_id cmd, std::unique_ptr<byte[]> data, uint32_t len);
void dthread_start(); void dthread_start();
void DThreadCleanup(); void DThreadCleanup();

2
Source/dvlnet/abstract_net.h

@ -25,7 +25,7 @@ class abstract_net {
public: public:
virtual int create(std::string addrstr) = 0; virtual int create(std::string addrstr) = 0;
virtual int join(std::string addrstr) = 0; virtual int join(std::string addrstr) = 0;
virtual bool SNetReceiveMessage(int *sender, void **data, uint32_t *size) = 0; virtual bool SNetReceiveMessage(size_t *sender, void **data, uint32_t *size) = 0;
virtual bool SNetSendMessage(int dest, void *data, unsigned int size) = 0; virtual bool SNetSendMessage(int dest, void *data, unsigned int size) = 0;
virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status) = 0; virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status) = 0;
virtual bool SNetSendTurn(char *data, unsigned int size) = 0; virtual bool SNetSendTurn(char *data, unsigned int size) = 0;

6
Source/dvlnet/base.cpp

@ -184,7 +184,7 @@ void base::RecvLocal(packet &pkt)
} }
} }
bool base::SNetReceiveMessage(int *sender, void **data, uint32_t *size) bool base::SNetReceiveMessage(size_t *sender, void **data, uint32_t *size)
{ {
poll(); poll();
if (message_queue.empty()) if (message_queue.empty())
@ -275,9 +275,9 @@ bool base::SNetReceiveTurns(char **data, size_t *size, uint32_t *status)
playerState.lastTurnValue = turn.Value; playerState.lastTurnValue = turn.Value;
turnQueue.pop_front(); turnQueue.pop_front();
size[i] = sizeof(int32_t);
status[i] |= PS_ACTIVE; status[i] |= PS_ACTIVE;
status[i] |= PS_TURN_ARRIVED; status[i] |= PS_TURN_ARRIVED;
size[i] = sizeof(int32_t);
data[i] = reinterpret_cast<char *>(&playerState.lastTurnValue); data[i] = reinterpret_cast<char *>(&playerState.lastTurnValue);
} }
@ -303,7 +303,7 @@ bool base::SNetReceiveTurns(char **data, size_t *size, uint32_t *status)
bool base::SNetSendTurn(char *data, unsigned int size) bool base::SNetSendTurn(char *data, unsigned int size)
{ {
if (size != sizeof(int32_t)) if (size != sizeof(uint32_t))
ABORT(); ABORT();
turn_t turn; turn_t turn;

2
Source/dvlnet/base.h

@ -19,7 +19,7 @@ public:
virtual int create(std::string addrstr) = 0; virtual int create(std::string addrstr) = 0;
virtual int join(std::string addrstr) = 0; virtual int join(std::string addrstr) = 0;
virtual bool SNetReceiveMessage(int *sender, void **data, uint32_t *size); virtual bool SNetReceiveMessage(size_t *sender, void **data, uint32_t *size);
virtual bool SNetSendMessage(int playerId, void *data, unsigned int size); virtual bool SNetSendMessage(int playerId, void *data, unsigned int size);
virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status); virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status);
virtual bool SNetSendTurn(char *data, unsigned int size); virtual bool SNetSendTurn(char *data, unsigned int size);

4
Source/dvlnet/cdwrap.h

@ -26,7 +26,7 @@ private:
public: public:
virtual int create(std::string addrstr); virtual int create(std::string addrstr);
virtual int join(std::string addrstr); virtual int join(std::string addrstr);
virtual bool SNetReceiveMessage(int *sender, void **data, uint32_t *size); virtual bool SNetReceiveMessage(size_t *sender, void **data, uint32_t *size);
virtual bool SNetSendMessage(int dest, void *data, unsigned int size); virtual bool SNetSendMessage(int dest, void *data, unsigned int size);
virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status); virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status);
virtual bool SNetSendTurn(char *data, unsigned int size); virtual bool SNetSendTurn(char *data, unsigned int size);
@ -95,7 +95,7 @@ void cdwrap<T>::setup_gameinfo(buffer_t info)
} }
template <class T> template <class T>
bool cdwrap<T>::SNetReceiveMessage(int *sender, void **data, uint32_t *size) bool cdwrap<T>::SNetReceiveMessage(size_t *sender, void **data, uint32_t *size)
{ {
return dvlnet_wrap->SNetReceiveMessage(sender, data, size); return dvlnet_wrap->SNetReceiveMessage(sender, data, size);
} }

2
Source/dvlnet/loopback.cpp

@ -18,7 +18,7 @@ int loopback::join(std::string /*addrstr*/)
ABORT(); ABORT();
} }
bool loopback::SNetReceiveMessage(int *sender, void **data, uint32_t *size) bool loopback::SNetReceiveMessage(size_t *sender, void **data, uint32_t *size)
{ {
if (message_queue.empty()) if (message_queue.empty())
return false; return false;

2
Source/dvlnet/loopback.h

@ -22,7 +22,7 @@ public:
virtual int create(std::string addrstr); virtual int create(std::string addrstr);
virtual int join(std::string addrstr); virtual int join(std::string addrstr);
virtual bool SNetReceiveMessage(int *sender, void **data, uint32_t *size); virtual bool SNetReceiveMessage(size_t *sender, void **data, uint32_t *size);
virtual bool SNetSendMessage(int dest, void *data, unsigned int size); virtual bool SNetSendMessage(int dest, void *data, unsigned int size);
virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status); virtual bool SNetReceiveTurns(char **data, size_t *size, uint32_t *status);
virtual bool SNetSendTurn(char *data, unsigned int size); virtual bool SNetSendTurn(char *data, unsigned int size);

8
Source/engine/render/scrollrt.cpp

@ -506,7 +506,7 @@ void DrawPlayerIcons(const Surface &out, Player &player, Point position, bool in
* @param nCel frame * @param nCel frame
* @param nWidth width * @param nWidth width
*/ */
void DrawPlayer(const Surface &out, int pnum, Point tilePosition, Point targetBufferPosition) void DrawPlayer(const Surface &out, size_t pnum, Point tilePosition, Point targetBufferPosition)
{ {
if (!IsTileLit(tilePosition) && !MyPlayer->_pInfraFlag && leveltype != DTYPE_TOWN) { if (!IsTileLit(tilePosition) && !MyPlayer->_pInfraFlag && leveltype != DTYPE_TOWN) {
return; return;
@ -545,10 +545,10 @@ void DrawPlayer(const Surface &out, int pnum, Point tilePosition, Point targetBu
return; return;
} }
if (pnum == pcursplr) if (pnum == static_cast<size_t>(pcursplr))
Cl2DrawOutline(out, 165, spriteBufferPosition.x, spriteBufferPosition.y, *sprite, nCel); Cl2DrawOutline(out, 165, spriteBufferPosition.x, spriteBufferPosition.y, *sprite, nCel);
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
Cl2Draw(out, spriteBufferPosition.x, spriteBufferPosition.y, *sprite, nCel); Cl2Draw(out, spriteBufferPosition.x, spriteBufferPosition.y, *sprite, nCel);
DrawPlayerIcons(out, player, targetBufferPosition, false); DrawPlayerIcons(out, player, targetBufferPosition, false);
return; return;
@ -802,7 +802,7 @@ void DrawMonsterHelper(const Surface &out, Point tilePosition, Point targetBuffe
* @param tilePosition dPiece coordinates * @param tilePosition dPiece coordinates
* @param targetBufferPosition Output buffer coordinates * @param targetBufferPosition Output buffer coordinates
*/ */
void DrawPlayerHelper(const Surface &out, int p, Point tilePosition, Point targetBufferPosition) void DrawPlayerHelper(const Surface &out, size_t p, Point tilePosition, Point targetBufferPosition)
{ {
Player &player = Players[p]; Player &player = Players[p];

11
Source/inv.cpp

@ -1944,14 +1944,11 @@ Item &GetInventoryItem(Player &player, int location)
return player.SpdList[location - INVITEM_BELT_FIRST]; return player.SpdList[location - INVITEM_BELT_FIRST];
} }
bool UseInvItem(int pnum, int cii) bool UseInvItem(size_t pnum, int cii)
{ {
int c;
Item *item;
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId)
return true; return true;
if (pcurs != CURSOR_HAND) if (pcurs != CURSOR_HAND)
return true; return true;
@ -1961,6 +1958,8 @@ bool UseInvItem(int pnum, int cii)
return false; return false;
bool speedlist = false; bool speedlist = false;
int c;
Item *item;
if (cii <= INVITEM_INV_LAST) { if (cii <= INVITEM_INV_LAST) {
c = cii - INVITEM_INV_FIRST; c = cii - INVITEM_INV_FIRST;
item = &player.InvList[c]; item = &player.InvList[c];
@ -2050,7 +2049,7 @@ bool UseInvItem(int pnum, int cii)
int idata = ItemCAnimTbl[item->_iCurs]; int idata = ItemCAnimTbl[item->_iCurs];
if (item->_iMiscId == IMISC_BOOK) if (item->_iMiscId == IMISC_BOOK)
PlaySFX(IS_RBOOK); PlaySFX(IS_RBOOK);
else if (pnum == static_cast<int>(MyPlayerId)) else if (pnum == MyPlayerId)
PlaySFX(ItemInvSnds[idata]); PlaySFX(ItemInvSnds[idata]);
UseItem(pnum, item->_iMiscId, item->_iSpell); UseItem(pnum, item->_iMiscId, item->_iSpell);

2
Source/inv.h

@ -227,7 +227,7 @@ bool UseScroll(spell_id spell);
void UseStaffCharge(Player &player); void UseStaffCharge(Player &player);
bool UseStaff(spell_id spell); bool UseStaff(spell_id spell);
Item &GetInventoryItem(Player &player, int location); Item &GetInventoryItem(Player &player, int location);
bool UseInvItem(int pnum, int cii); bool UseInvItem(size_t pnum, int cii);
void DoTelekinesis(); void DoTelekinesis();
int CalculateGold(Player &player); int CalculateGold(Player &player);

20
Source/items.cpp

@ -3837,7 +3837,7 @@ void PrintItemDur(const Item &item)
PrintItemInfo(item); PrintItemInfo(item);
} }
void UseItem(int pnum, item_misc_id mid, spell_id spl) void UseItem(size_t pnum, item_misc_id mid, spell_id spl)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3910,7 +3910,7 @@ void UseItem(int pnum, item_misc_id mid, spell_id spl)
case IMISC_SCROLL: case IMISC_SCROLL:
if (ControlMode == ControlTypes::KeyboardAndMouse && spelldata[spl].sTargeted) { if (ControlMode == ControlTypes::KeyboardAndMouse && spelldata[spl].sTargeted) {
player._pTSpell = spl; player._pTSpell = spl;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
} else { } else {
ClrPlrPath(player); ClrPlrPath(player);
@ -3920,14 +3920,14 @@ void UseItem(int pnum, item_misc_id mid, spell_id spl)
player.destAction = ACTION_SPELL; player.destAction = ACTION_SPELL;
player.destParam1 = cursPosition.x; player.destParam1 = cursPosition.x;
player.destParam2 = cursPosition.y; player.destParam2 = cursPosition.y;
if (pnum == static_cast<int>(MyPlayerId) && spl == SPL_NOVA) if (pnum == MyPlayerId && spl == SPL_NOVA)
NetSendCmdLoc(pnum, true, CMD_NOVA, cursPosition); NetSendCmdLoc(pnum, true, CMD_NOVA, cursPosition);
} }
break; break;
case IMISC_SCROLLT: case IMISC_SCROLLT:
if (ControlMode == ControlTypes::KeyboardAndMouse && spelldata[spl].sTargeted) { if (ControlMode == ControlTypes::KeyboardAndMouse && spelldata[spl].sTargeted) {
player._pTSpell = spl; player._pTSpell = spl;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
} else { } else {
ClrPlrPath(player); ClrPlrPath(player);
@ -3973,7 +3973,7 @@ void UseItem(int pnum, item_misc_id mid, spell_id spl)
case IMISC_OILHARD: case IMISC_OILHARD:
case IMISC_OILIMP: case IMISC_OILIMP:
player._pOilType = mid; player._pOilType = mid;
if (pnum != static_cast<int>(MyPlayerId)) { if (pnum != MyPlayerId) {
return; return;
} }
if (sbookflag) { if (sbookflag) {
@ -3992,27 +3992,27 @@ void UseItem(int pnum, item_misc_id mid, spell_id spl)
break; break;
case IMISC_RUNEF: case IMISC_RUNEF:
player._pTSpell = SPL_RUNEFIRE; player._pTSpell = SPL_RUNEFIRE;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
break; break;
case IMISC_RUNEL: case IMISC_RUNEL:
player._pTSpell = SPL_RUNELIGHT; player._pTSpell = SPL_RUNELIGHT;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
break; break;
case IMISC_GR_RUNEL: case IMISC_GR_RUNEL:
player._pTSpell = SPL_RUNENOVA; player._pTSpell = SPL_RUNENOVA;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
break; break;
case IMISC_GR_RUNEF: case IMISC_GR_RUNEF:
player._pTSpell = SPL_RUNEIMMOLAT; player._pTSpell = SPL_RUNEIMMOLAT;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
break; break;
case IMISC_RUNES: case IMISC_RUNES:
player._pTSpell = SPL_RUNESTONE; player._pTSpell = SPL_RUNESTONE;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_TELEPORT); NewCursor(CURSOR_TELEPORT);
break; break;
default: default:

2
Source/items.h

@ -500,7 +500,7 @@ bool DoOil(Player &player, int cii);
void DrawUniqueInfo(const Surface &out); void DrawUniqueInfo(const Surface &out);
void PrintItemDetails(const Item &item); void PrintItemDetails(const Item &item);
void PrintItemDur(const Item &item); void PrintItemDur(const Item &item);
void UseItem(int p, item_misc_id Mid, spell_id spl); void UseItem(size_t pnum, item_misc_id Mid, spell_id spl);
bool UseItemOpensHive(const Item &item, Point position); bool UseItemOpensHive(const Item &item, Point position);
bool UseItemOpensCrypt(const Item &item, Point position); bool UseItemOpensCrypt(const Item &item, Point position);
void SpawnSmith(int lvl); void SpawnSmith(int lvl);

1
Source/minitext.cpp

@ -21,7 +21,6 @@
namespace devilution { namespace devilution {
/** Specify if the quest dialog window is being shown */
bool qtextflag; bool qtextflag;
namespace { namespace {

1
Source/minitext.h

@ -10,6 +10,7 @@
namespace devilution { namespace devilution {
/** Specify if the quest dialog window is being shown */
extern bool qtextflag; extern bool qtextflag;
/** /**

62
Source/missiles.cpp

@ -182,7 +182,7 @@ void MoveMissilePos(Missile &missile)
} }
} }
bool MonsterMHit(int pnum, int m, int mindam, int maxdam, int dist, missile_id t, bool shift) bool MonsterMHit(size_t pnum, int m, int mindam, int maxdam, int dist, missile_id t, bool shift)
{ {
auto &monster = Monsters[m]; auto &monster = Monsters[m];
@ -237,7 +237,7 @@ bool MonsterMHit(int pnum, int m, int mindam, int maxdam, int dist, missile_id t
if (resist) if (resist)
dam >>= 2; dam >>= 2;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
monster._mhitpoints -= dam; monster._mhitpoints -= dam;
if ((gbIsHellfire && HasAnyOf(player._pIFlags, ItemSpecialEffect::NoHealOnMonsters)) || (!gbIsHellfire && HasAnyOf(player._pIFlags, ItemSpecialEffect::FireArrows))) if ((gbIsHellfire && HasAnyOf(player._pIFlags, ItemSpecialEffect::NoHealOnMonsters)) || (!gbIsHellfire && HasAnyOf(player._pIFlags, ItemSpecialEffect::FireArrows)))
@ -262,7 +262,7 @@ bool MonsterMHit(int pnum, int m, int mindam, int maxdam, int dist, missile_id t
return true; return true;
} }
bool Plr2PlrMHit(int pnum, int p, int mindam, int maxdam, int dist, missile_id mtype, bool shift, bool *blocked) bool Plr2PlrMHit(size_t pnum, int p, int mindam, int maxdam, int dist, missile_id mtype, bool shift, bool *blocked)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
auto &target = Players[p]; auto &target = Players[p];
@ -342,7 +342,7 @@ bool Plr2PlrMHit(int pnum, int p, int mindam, int maxdam, int dist, missile_id m
dam /= 2; dam /= 2;
if (resper > 0) { if (resper > 0) {
dam -= (dam * resper) / 100; dam -= (dam * resper) / 100;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdDamage(true, p, dam); NetSendCmdDamage(true, p, dam);
target.Say(HeroSpeech::ArghClang); target.Say(HeroSpeech::ArghClang);
return true; return true;
@ -352,7 +352,7 @@ bool Plr2PlrMHit(int pnum, int p, int mindam, int maxdam, int dist, missile_id m
StartPlrBlock(p, GetDirection(target.position.tile, player.position.tile)); StartPlrBlock(p, GetDirection(target.position.tile, player.position.tile));
*blocked = true; *blocked = true;
} else { } else {
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdDamage(true, p, dam); NetSendCmdDamage(true, p, dam);
StartPlrHit(p, dam, false); StartPlrHit(p, dam, false);
} }
@ -800,9 +800,9 @@ void GetDamageAmt(int i, int *mind, int *maxd)
} }
} }
int GetSpellLevel(int playerId, spell_id sn) int GetSpellLevel(size_t playerId, spell_id sn)
{ {
if (playerId != static_cast<int>(MyPlayerId)) if (playerId != MyPlayerId)
return 1; // BUGFIX spell level will be wrong in multiplayer return 1; // BUGFIX spell level will be wrong in multiplayer
Player &player = Players[playerId]; Player &player = Players[playerId];
@ -888,7 +888,7 @@ bool MonsterTrapHit(int m, int mindam, int maxdam, int dist, missile_id t, bool
return true; return true;
} }
bool PlayerMHit(int pnum, Monster *monster, int dist, int mind, int maxd, missile_id mtype, bool shift, int earflag, bool *blocked) bool PlayerMHit(size_t pnum, Monster *monster, int dist, int mind, int maxd, missile_id mtype, bool shift, int earflag, bool *blocked)
{ {
*blocked = false; *blocked = false;
@ -1004,7 +1004,7 @@ bool PlayerMHit(int pnum, Monster *monster, int dist, int mind, int maxd, missil
if (resper > 0) { if (resper > 0) {
dam -= dam * resper / 100; dam -= dam * resper / 100;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
ApplyPlrDamage(pnum, 0, 0, dam, earflag); ApplyPlrDamage(pnum, 0, 0, dam, earflag);
} }
@ -1014,7 +1014,7 @@ bool PlayerMHit(int pnum, Monster *monster, int dist, int mind, int maxd, missil
return true; return true;
} }
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
ApplyPlrDamage(pnum, 0, 0, dam, earflag); ApplyPlrDamage(pnum, 0, 0, dam, earflag);
} }
@ -1040,8 +1040,7 @@ void InitMissiles()
if (myPlayer._pInfraFlag) { if (myPlayer._pInfraFlag) {
for (auto &missile : Missiles) { for (auto &missile : Missiles) {
if (missile._mitype == MIS_INFRA) { if (missile._mitype == MIS_INFRA) {
int src = missile._misource; if (static_cast<size_t>(missile._misource) == MyPlayerId)
if (src == static_cast<int>(MyPlayerId))
CalcPlrItemVals(myPlayer, true); CalcPlrItemVals(myPlayer, true);
} }
} }
@ -1052,7 +1051,7 @@ void InitMissiles()
myPlayer._pSpellFlags &= ~SpellFlag::RageCooldown; myPlayer._pSpellFlags &= ~SpellFlag::RageCooldown;
for (auto &missile : Missiles) { for (auto &missile : Missiles) {
if (missile._mitype == MIS_BLODBOIL) { if (missile._mitype == MIS_BLODBOIL) {
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
int missingHP = myPlayer._pMaxHP - myPlayer._pHitPoints; int missingHP = myPlayer._pMaxHP - myPlayer._pHitPoints;
CalcPlrItemVals(myPlayer, true); CalcPlrItemVals(myPlayer, true);
ApplyPlrDamage(MyPlayerId, 0, 1, missingHP + missile.var2); ApplyPlrDamage(MyPlayerId, 0, 1, missingHP + missile.var2);
@ -1121,7 +1120,7 @@ void AddReflection(Missile &missile, const AddMissileParameter & /*parameter*/)
if (player.wReflections + add >= std::numeric_limits<uint16_t>::max()) if (player.wReflections + add >= std::numeric_limits<uint16_t>::max())
add = 0; add = 0;
player.wReflections += add; player.wReflections += add;
if (missile._misource == static_cast<int>(MyPlayerId)) if (static_cast<size_t>(missile._misource) == MyPlayerId)
NetSendCmdParam1(true, CMD_SETREFLECT, player.wReflections); NetSendCmdParam1(true, CMD_SETREFLECT, player.wReflections);
UseMana(missile._misource, SPL_REFLECT); UseMana(missile._misource, SPL_REFLECT);
@ -1487,7 +1486,7 @@ void AddRing(Missile &missile, const AddMissileParameter & /*parameter*/)
void AddSearch(Missile &missile, const AddMissileParameter & /*parameter*/) void AddSearch(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
if (missile._misource == static_cast<int>(MyPlayerId)) if (static_cast<size_t>(missile._misource) == MyPlayerId)
AutoMapShowItems = true; AutoMapShowItems = true;
int lvl = 2; int lvl = 2;
if (missile._misource >= 0) if (missile._misource >= 0)
@ -1876,7 +1875,7 @@ void AddTown(Missile &missile, const AddMissileParameter &parameter)
other._mirange = 0; other._mirange = 0;
} }
PutMissile(missile); PutMissile(missile);
if (missile._misource == static_cast<int>(MyPlayerId) && !missile._miDelFlag && leveltype != DTYPE_TOWN) { if (static_cast<size_t>(missile._misource) == MyPlayerId && !missile._miDelFlag && leveltype != DTYPE_TOWN) {
if (!setlevel) { if (!setlevel) {
NetSendCmdLocParam3(true, CMD_ACTIVATEPORTAL, missile.position.tile, currlevel, leveltype, 0); NetSendCmdLocParam3(true, CMD_ACTIVATEPORTAL, missile.position.tile, currlevel, leveltype, 0);
} else { } else {
@ -1931,7 +1930,7 @@ void AddManashield(Missile &missile, const AddMissileParameter & /*parameter*/)
return; return;
player.pManaShield = true; player.pManaShield = true;
if (missile._misource == static_cast<int>(MyPlayerId)) if (static_cast<size_t>(missile._misource) == MyPlayerId)
NetSendCmd(true, CMD_SETSHIELD); NetSendCmd(true, CMD_SETSHIELD);
if (missile._micaster == TARGET_MONSTERS) if (missile._micaster == TARGET_MONSTERS)
@ -2157,14 +2156,9 @@ void AddGolem(Missile &missile, const AddMissileParameter &parameter)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
int playerId = missile._misource; size_t playerId = static_cast<size_t>(missile._misource);
for (auto &other : Missiles) { if (Monsters[playerId].position.tile != GolemHoldingCell && playerId == MyPlayerId)
if (other._mitype == MIS_GOLEM && &other != &missile && other._misource == playerId) {
return;
}
}
if (Monsters[playerId].position.tile != GolemHoldingCell && playerId == static_cast<int>(MyPlayerId))
M_StartKill(playerId, playerId); M_StartKill(playerId, playerId);
UseMana(playerId, SPL_GOLEM); UseMana(playerId, SPL_GOLEM);
@ -2216,7 +2210,7 @@ void AddHealOther(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
UseMana(missile._misource, SPL_HEALOTHER); UseMana(missile._misource, SPL_HEALOTHER);
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
NewCursor(CURSOR_HEALOTHER); NewCursor(CURSOR_HEALOTHER);
if (ControlMode != ControlTypes::KeyboardAndMouse) if (ControlMode != ControlTypes::KeyboardAndMouse)
TryIconCurs(); TryIconCurs();
@ -2250,7 +2244,7 @@ void AddIdentify(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
UseMana(missile._misource, SPL_IDENTIFY); UseMana(missile._misource, SPL_IDENTIFY);
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
if (sbookflag) if (sbookflag)
sbookflag = false; sbookflag = false;
if (!invflag) { if (!invflag) {
@ -2347,7 +2341,7 @@ void AddRepair(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
UseMana(missile._misource, SPL_REPAIR); UseMana(missile._misource, SPL_REPAIR);
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
if (sbookflag) if (sbookflag)
sbookflag = false; sbookflag = false;
if (!invflag) { if (!invflag) {
@ -2363,7 +2357,7 @@ void AddRecharge(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
UseMana(missile._misource, SPL_RECHARGE); UseMana(missile._misource, SPL_RECHARGE);
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
if (sbookflag) if (sbookflag)
sbookflag = false; sbookflag = false;
if (!invflag) { if (!invflag) {
@ -2379,7 +2373,7 @@ void AddDisarm(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
UseMana(missile._misource, SPL_DISARM); UseMana(missile._misource, SPL_DISARM);
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
NewCursor(CURSOR_DISARM); NewCursor(CURSOR_DISARM);
if (ControlMode != ControlTypes::KeyboardAndMouse) { if (ControlMode != ControlTypes::KeyboardAndMouse) {
if (pcursobj != -1) if (pcursobj != -1)
@ -2477,7 +2471,7 @@ void AddHbolt(Missile &missile, const AddMissileParameter &parameter)
void AddResurrect(Missile &missile, const AddMissileParameter & /*parameter*/) void AddResurrect(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
UseMana(missile._misource, SPL_RESURRECT); UseMana(missile._misource, SPL_RESURRECT);
if (missile._misource == static_cast<int>(MyPlayerId)) { if (static_cast<size_t>(missile._misource) == MyPlayerId) {
NewCursor(CURSOR_RESURRECT); NewCursor(CURSOR_RESURRECT);
if (ControlMode != ControlTypes::KeyboardAndMouse) if (ControlMode != ControlTypes::KeyboardAndMouse)
TryIconCurs(); TryIconCurs();
@ -2496,7 +2490,7 @@ void AddTelekinesis(Missile &missile, const AddMissileParameter & /*parameter*/)
{ {
missile._miDelFlag = true; missile._miDelFlag = true;
UseMana(missile._misource, SPL_TELEKINESIS); UseMana(missile._misource, SPL_TELEKINESIS);
if (missile._misource == static_cast<int>(MyPlayerId)) if (static_cast<size_t>(missile._misource) == MyPlayerId)
NewCursor(CURSOR_TELEKINESIS); NewCursor(CURSOR_TELEKINESIS);
} }
@ -3028,7 +3022,7 @@ void MI_Search(Missile &missile)
missile._miDelFlag = true; missile._miDelFlag = true;
PlaySfxLoc(IS_CAST7, Players[missile._misource].position.tile); PlaySfxLoc(IS_CAST7, Players[missile._misource].position.tile);
if (missile._misource == static_cast<int>(MyPlayerId)) if (static_cast<size_t>(missile._misource) == MyPlayerId)
AutoMapShowItems = false; AutoMapShowItems = false;
} }
@ -3440,7 +3434,7 @@ void MI_Teleport(Missile &missile)
return; return;
} }
int id = missile._misource; size_t id = static_cast<size_t>(missile._misource);
Player &player = Players[id]; Player &player = Players[id];
dPlayer[player.position.tile.x][player.position.tile.y] = 0; dPlayer[player.position.tile.x][player.position.tile.y] = 0;
@ -3455,7 +3449,7 @@ void MI_Teleport(Missile &missile)
ChangeLightXY(player._plid, player.position.tile); ChangeLightXY(player._plid, player.position.tile);
ChangeVisionXY(player._pvid, player.position.tile); ChangeVisionXY(player._pvid, player.position.tile);
} }
if (id == static_cast<int>(MyPlayerId)) { if (id == MyPlayerId) {
ViewPosition = Point { 0, 0 } + (player.position.tile - ScrollInfo.tile); ViewPosition = Point { 0, 0 } + (player.position.tile - ScrollInfo.tile);
} }
} }

4
Source/missiles.h

@ -138,7 +138,7 @@ extern std::list<Missile> Missiles;
extern bool MissilePreFlag; extern bool MissilePreFlag;
void GetDamageAmt(int i, int *mind, int *maxd); void GetDamageAmt(int i, int *mind, int *maxd);
int GetSpellLevel(int playerId, spell_id sn); int GetSpellLevel(size_t playerId, spell_id sn);
/** /**
* @brief Returns the direction a vector from p1(x1, y1) to p2(x2, y2) is pointing to. * @brief Returns the direction a vector from p1(x1, y1) to p2(x2, y2) is pointing to.
@ -161,7 +161,7 @@ int GetSpellLevel(int playerId, spell_id sn);
*/ */
Direction16 GetDirection16(Point p1, Point p2); Direction16 GetDirection16(Point p1, Point p2);
bool MonsterTrapHit(int m, int mindam, int maxdam, int dist, missile_id t, bool shift); bool MonsterTrapHit(int m, int mindam, int maxdam, int dist, missile_id t, bool shift);
bool PlayerMHit(int pnum, Monster *monster, int dist, int mind, int maxd, missile_id mtype, bool shift, int earflag, bool *blocked); bool PlayerMHit(size_t pnum, Monster *monster, int dist, int mind, int maxd, missile_id mtype, bool shift, int earflag, bool *blocked);
/** /**
* @brief Could the missile collide with solid objects? (like walls or closed doors) * @brief Could the missile collide with solid objects? (like walls or closed doors)

40
Source/monster.cpp

@ -1293,7 +1293,7 @@ void MonsterAttackMonster(int i, int mid, int hper, int mind, int maxd)
} }
} }
void CheckReflect(int mon, int pnum, int dam) void CheckReflect(size_t mon, size_t pnum, int dam)
{ {
auto &monster = Monsters[mon]; auto &monster = Monsters[mon];
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1311,9 +1311,9 @@ void CheckReflect(int mon, int pnum, int dam)
M_StartHit(mon, pnum, mdam); M_StartHit(mon, pnum, mdam);
} }
void MonsterAttackPlayer(int i, int pnum, int hit, int minDam, int maxDam) void MonsterAttackPlayer(size_t i, size_t pnum, int hit, int minDam, int maxDam)
{ {
assert(i >= 0 && i < MAXMONSTERS); assert(i < MAXMONSTERS);
auto &monster = Monsters[i]; auto &monster = Monsters[i];
assert(monster.MType != nullptr); assert(monster.MType != nullptr);
@ -1361,14 +1361,14 @@ void MonsterAttackPlayer(int i, int pnum, int hit, int minDam, int maxDam)
if (blkper < blk) { if (blkper < blk) {
Direction dir = GetDirection(player.position.tile, monster.position.tile); Direction dir = GetDirection(player.position.tile, monster.position.tile);
StartPlrBlock(pnum, dir); StartPlrBlock(pnum, dir);
if (pnum == static_cast<int>(MyPlayerId) && player.wReflections > 0) { if (pnum == MyPlayerId && player.wReflections > 0) {
int dam = GenerateRnd(((maxDam - minDam) << 6) + 1) + (minDam << 6); int dam = GenerateRnd(((maxDam - minDam) << 6) + 1) + (minDam << 6);
dam = std::max(dam + (player._pIGetHit << 6), 64); dam = std::max(dam + (player._pIGetHit << 6), 64);
CheckReflect(i, pnum, dam); CheckReflect(i, pnum, dam);
} }
return; return;
} }
if (monster.MType->mtype == MT_YZOMBIE && pnum == static_cast<int>(MyPlayerId)) { if (monster.MType->mtype == MT_YZOMBIE && pnum == MyPlayerId) {
if (player._pMaxHP > 64) { if (player._pMaxHP > 64) {
if (player._pMaxHPBase > 64) { if (player._pMaxHPBase > 64) {
player._pMaxHP -= 64; player._pMaxHP -= 64;
@ -1384,7 +1384,7 @@ void MonsterAttackPlayer(int i, int pnum, int hit, int minDam, int maxDam)
} }
int dam = (minDam << 6) + GenerateRnd(((maxDam - minDam) << 6) + 1); int dam = (minDam << 6) + GenerateRnd(((maxDam - minDam) << 6) + 1);
dam = std::max(dam + (player._pIGetHit << 6), 64); dam = std::max(dam + (player._pIGetHit << 6), 64);
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
if (player.wReflections > 0) if (player.wReflections > 0)
CheckReflect(i, pnum, dam); CheckReflect(i, pnum, dam);
ApplyPlrDamage(pnum, 0, 0, dam); ApplyPlrDamage(pnum, 0, 0, dam);
@ -3720,7 +3720,7 @@ void InitMonsterGFX(int monst)
MissileSpriteData[MFILE_FIREPLAR].LoadGFX(); MissileSpriteData[MFILE_FIREPLAR].LoadGFX();
} }
void monster_some_crypt() void WeakenNaKrul()
{ {
if (currlevel != 24 || UberDiabloMonsterIndex < 0 || UberDiabloMonsterIndex >= ActiveMonsterCount) if (currlevel != 24 || UberDiabloMonsterIndex < 0 || UberDiabloMonsterIndex >= ActiveMonsterCount)
return; return;
@ -3949,12 +3949,12 @@ void M_StartHit(int i, int dam)
} }
} }
void M_StartHit(int i, int pnum, int dam) void M_StartHit(int i, size_t pnum, int dam)
{ {
Monster &monster = Monsters[i]; Monster &monster = Monsters[i];
monster.mWhoHit |= 1 << pnum; monster.mWhoHit |= 1 << pnum;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
delta_monster_hp(i, monster._mhitpoints, *MyPlayer); delta_monster_hp(i, monster._mhitpoints, *MyPlayer);
NetSendCmdMonDmg(false, i, dam); NetSendCmdMonDmg(false, i, dam);
} }
@ -3968,21 +3968,21 @@ void M_StartHit(int i, int pnum, int dam)
M_StartHit(i, dam); M_StartHit(i, dam);
} }
void StartMonsterDeath(int mid, int pnum, bool sendmsg) void StartMonsterDeath(size_t mid, int pnum, bool sendmsg)
{ {
assert(mid >= 0 && mid < MAXMONSTERS); assert(mid < MAXMONSTERS);
Monster &monster = Monsters[mid]; Monster &monster = Monsters[mid];
Direction md = pnum >= 0 ? GetDirection(monster.position.tile, Players[pnum].position.tile) : monster._mdir; Direction md = pnum >= 0 ? GetDirection(monster.position.tile, Players[pnum].position.tile) : monster._mdir;
MonsterDeath(mid, pnum, md, sendmsg); MonsterDeath(mid, pnum, md, sendmsg);
} }
void M_StartKill(int i, int pnum) void M_StartKill(size_t i, size_t pnum)
{ {
assert(i >= 0 && i < MAXMONSTERS); assert(i < MAXMONSTERS);
auto &monster = Monsters[i]; auto &monster = Monsters[i];
if (static_cast<int>(MyPlayerId) == pnum) { if (pnum == MyPlayerId) {
delta_kill_monster(i, monster.position.tile, *MyPlayer); delta_kill_monster(i, monster.position.tile, *MyPlayer);
if (i != pnum) { if (i != pnum) {
NetSendCmdLocParam1(false, CMD_MONSTDEATH, monster.position.tile, i); NetSendCmdLocParam1(false, CMD_MONSTDEATH, monster.position.tile, i);
@ -4829,13 +4829,13 @@ void TalktoMonster(Monster &monster)
} }
} }
void SpawnGolem(int i, Point position, Missile &missile) void SpawnGolem(size_t pnum, Point position, Missile &missile)
{ {
assert(i >= 0 && static_cast<size_t>(i) < Players.size()); assert(pnum < Players.size());
Player &player = Players[i]; Player &player = Players[pnum];
auto &golem = Monsters[i]; auto &golem = Monsters[pnum];
dMonster[position.x][position.y] = i + 1; dMonster[position.x][position.y] = pnum + 1;
golem.position.tile = position; golem.position.tile = position;
golem.position.future = position; golem.position.future = position;
golem.position.old = position; golem.position.old = position;
@ -4849,7 +4849,7 @@ void SpawnGolem(int i, Point position, Missile &missile)
golem._mFlags |= MFLAG_GOLEM; golem._mFlags |= MFLAG_GOLEM;
StartSpecialStand(golem, Direction::South); StartSpecialStand(golem, Direction::South);
UpdateEnemy(golem); UpdateEnemy(golem);
if (i == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
NetSendCmdGolem( NetSendCmdGolem(
golem.position.tile.x, golem.position.tile.x,
golem.position.tile.y, golem.position.tile.y,

10
Source/monster.h

@ -276,7 +276,7 @@ void PrepareUniqueMonst(Monster &monster, int uniqindex, int miniontype, int bos
void InitLevelMonsters(); void InitLevelMonsters();
void GetLevelMTypes(); void GetLevelMTypes();
void InitMonsterGFX(int monst); void InitMonsterGFX(int monst);
void monster_some_crypt(); void WeakenNaKrul();
void InitGolems(); void InitGolems();
void InitMonsters(); void InitMonsters();
void SetMapMonsters(const uint16_t *dunData, Point startPosition); void SetMapMonsters(const uint16_t *dunData, Point startPosition);
@ -287,9 +287,9 @@ void M_StartStand(Monster &monster, Direction md);
void M_ClearSquares(int i); void M_ClearSquares(int i);
void M_GetKnockback(int i); void M_GetKnockback(int i);
void M_StartHit(int i, int dam); void M_StartHit(int i, int dam);
void M_StartHit(int i, int pnum, int dam); void M_StartHit(int i, size_t pnum, int dam);
void StartMonsterDeath(int mid, int pnum, bool sendmsg); void StartMonsterDeath(size_t mid, int pnum, bool sendmsg);
void M_StartKill(int i, int pnum); void M_StartKill(size_t i, size_t pnum);
void M_SyncStartKill(int i, Point position, int pnum); void M_SyncStartKill(int i, Point position, int pnum);
void M_UpdateLeader(int i); void M_UpdateLeader(int i);
void DoEnding(); void DoEnding();
@ -319,7 +319,7 @@ bool IsGoat(_monster_id mt);
bool SpawnSkeleton(int ii, Point position); bool SpawnSkeleton(int ii, Point position);
int PreSpawnSkeleton(); int PreSpawnSkeleton();
void TalktoMonster(Monster &monster); void TalktoMonster(Monster &monster);
void SpawnGolem(int i, Point position, Missile &missile); void SpawnGolem(size_t pnum, Point position, Missile &missile);
bool CanTalkToMonst(const Monster &monster); bool CanTalkToMonst(const Monster &monster);
int encode_enemy(Monster &monster); int encode_enemy(Monster &monster);
void decode_enemy(Monster &monster, int enemyId); void decode_enemy(Monster &monster, int enemyId);

118
Source/msg.cpp

@ -667,9 +667,9 @@ void DeltaOpenPortal(int pnum, Point position, uint8_t bLevel, dungeon_type bLTy
sgJunk.portal[pnum].setlvl = bSetLvl ? 1 : 0; sgJunk.portal[pnum].setlvl = bSetLvl ? 1 : 0;
} }
void CheckUpdatePlayer(int pnum) void CheckUpdatePlayer(size_t pnum)
{ {
if (gbIsMultiplayer && pnum == static_cast<int>(MyPlayerId)) if (gbIsMultiplayer && pnum == MyPlayerId)
pfile_update(true); pfile_update(true);
} }
@ -742,7 +742,7 @@ DWORD OnWalk(const TCmd *pCmd, Player &player)
return sizeof(message); return sizeof(message);
} }
DWORD OnAddStrength(const TCmd *pCmd, int pnum) DWORD OnAddStrength(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
@ -754,7 +754,7 @@ DWORD OnAddStrength(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnAddMagic(const TCmd *pCmd, int pnum) DWORD OnAddMagic(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
@ -766,7 +766,7 @@ DWORD OnAddMagic(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnAddDexterity(const TCmd *pCmd, int pnum) DWORD OnAddDexterity(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
@ -778,7 +778,7 @@ DWORD OnAddDexterity(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnAddVitality(const TCmd *pCmd, int pnum) DWORD OnAddVitality(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
@ -988,7 +988,7 @@ DWORD OnItemExtra(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnPutItem(const TCmd *pCmd, int pnum) DWORD OnPutItem(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdPItem *>(pCmd); const auto &message = *reinterpret_cast<const TCmdPItem *>(pCmd);
@ -999,7 +999,7 @@ DWORD OnPutItem(const TCmd *pCmd, int pnum)
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player.isOnActiveLevel()) { if (player.isOnActiveLevel()) {
int ii; int ii;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
ii = InvPutItem(player, position, ItemLimbo); ii = InvPutItem(player, position, ItemLimbo);
else else
ii = SyncPutItem(player, position, message.wIndx, message.wCI, message.dwSeed, message.bId, message.bDur, message.bMDur, message.bCh, message.bMCh, message.wValue, message.dwBuff, message.wToHit, message.wMaxDam, message.bMinStr, message.bMinMag, message.bMinDex, message.bAC); ii = SyncPutItem(player, position, message.wIndx, message.wCI, message.dwSeed, message.bId, message.bDur, message.bMDur, message.bCh, message.bMCh, message.wValue, message.dwBuff, message.wToHit, message.wMaxDam, message.bMinStr, message.bMinMag, message.bMinDex, message.bAC);
@ -1046,7 +1046,7 @@ DWORD OnSyncPutItem(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnRespawnItem(const TCmd *pCmd, int pnum) DWORD OnRespawnItem(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdPItem *>(pCmd); const auto &message = *reinterpret_cast<const TCmdPItem *>(pCmd);
@ -1055,7 +1055,7 @@ DWORD OnRespawnItem(const TCmd *pCmd, int pnum)
} else if (IsPItemValid(message)) { } else if (IsPItemValid(message)) {
const Point position { message.x, message.y }; const Point position { message.x, message.y };
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player.isOnActiveLevel() && pnum != static_cast<int>(MyPlayerId)) { if (player.isOnActiveLevel() && pnum != MyPlayerId) {
SyncPutItem(player, position, message.wIndx, message.wCI, message.dwSeed, message.bId, message.bDur, message.bMDur, message.bCh, message.bMCh, message.wValue, message.dwBuff, message.wToHit, message.wMaxDam, message.bMinStr, message.bMinMag, message.bMinDex, message.bAC); SyncPutItem(player, position, message.wIndx, message.wCI, message.dwSeed, message.bId, message.bDur, message.bMDur, message.bCh, message.bMCh, message.wValue, message.dwBuff, message.wToHit, message.wMaxDam, message.bMinStr, message.bMinMag, message.bMinDex, message.bAC);
} }
PutItemRecord(message.dwSeed, message.wCI, message.wIndx); PutItemRecord(message.dwSeed, message.wCI, message.wIndx);
@ -1430,7 +1430,7 @@ DWORD OnTargetSpellPlayer(const TCmd *pCmd, Player &player)
return sizeof(message); return sizeof(message);
} }
DWORD OnKnockback(const TCmd *pCmd, int pnum) DWORD OnKnockback(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
@ -1483,13 +1483,13 @@ DWORD OnTalkXY(const TCmd *pCmd, Player &player)
return sizeof(message); return sizeof(message);
} }
DWORD OnNewLevel(const TCmd *pCmd, int pnum) DWORD OnNewLevel(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam2 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam2 *>(pCmd);
if (gbBufferMsgs == 1) { if (gbBufferMsgs == 1) {
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
} else if (pnum != static_cast<int>(MyPlayerId)) { } else if (pnum != MyPlayerId) {
if (message.wParam1 < WM_FIRST || message.wParam1 > WM_LAST) if (message.wParam1 < WM_FIRST || message.wParam1 > WM_LAST)
return sizeof(message); return sizeof(message);
@ -1506,7 +1506,7 @@ DWORD OnNewLevel(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnWarp(const TCmd *pCmd, int pnum) DWORD OnWarp(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
@ -1519,14 +1519,14 @@ DWORD OnWarp(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnMonstDeath(const TCmd *pCmd, int pnum) DWORD OnMonstDeath(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdLocParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdLocParam1 *>(pCmd);
const Point position { message.x, message.y }; const Point position { message.x, message.y };
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (pnum != static_cast<int>(MyPlayerId) && InDungeonBounds(position) && message.wParam1 < MAXMONSTERS) { else if (pnum != MyPlayerId && InDungeonBounds(position) && message.wParam1 < MAXMONSTERS) {
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player.isOnActiveLevel()) if (player.isOnActiveLevel())
M_SyncStartKill(message.wParam1, position, pnum); M_SyncStartKill(message.wParam1, position, pnum);
@ -1536,14 +1536,14 @@ DWORD OnMonstDeath(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnKillGolem(const TCmd *pCmd, int pnum) DWORD OnKillGolem(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdLoc *>(pCmd); const auto &message = *reinterpret_cast<const TCmdLoc *>(pCmd);
const Point position { message.x, message.y }; const Point position { message.x, message.y };
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (pnum != static_cast<int>(MyPlayerId) && InDungeonBounds(position)) { else if (pnum != MyPlayerId && InDungeonBounds(position)) {
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player.isOnActiveLevel()) if (player.isOnActiveLevel())
M_SyncStartKill(pnum, position, pnum); M_SyncStartKill(pnum, position, pnum);
@ -1553,7 +1553,7 @@ DWORD OnKillGolem(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnAwakeGolem(const TCmd *pCmd, int pnum) DWORD OnAwakeGolem(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdGolem *>(pCmd); const auto &message = *reinterpret_cast<const TCmdGolem *>(pCmd);
const Point position { message._mx, message._my }; const Point position { message._mx, message._my };
@ -1563,10 +1563,10 @@ DWORD OnAwakeGolem(const TCmd *pCmd, int pnum)
} else if (InDungeonBounds(position)) { } else if (InDungeonBounds(position)) {
if (!Players[pnum].isOnActiveLevel()) { if (!Players[pnum].isOnActiveLevel()) {
DeltaSyncGolem(message, pnum, message._currlevel); DeltaSyncGolem(message, pnum, message._currlevel);
} else if (pnum != static_cast<int>(MyPlayerId)) { } else if (pnum != MyPlayerId) {
// Check if this player already has an active golem // Check if this player already has an active golem
for (auto &missile : Missiles) { for (auto &missile : Missiles) {
if (missile._mitype == MIS_GOLEM && missile._misource == pnum) { if (missile._mitype == MIS_GOLEM && static_cast<size_t>(missile._misource) == pnum) {
return sizeof(message); return sizeof(message);
} }
} }
@ -1578,13 +1578,13 @@ DWORD OnAwakeGolem(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnMonstDamage(const TCmd *pCmd, int pnum) DWORD OnMonstDamage(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdMonDamage *>(pCmd); const auto &message = *reinterpret_cast<const TCmdMonDamage *>(pCmd);
if (gbBufferMsgs == 1) { if (gbBufferMsgs == 1) {
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
} else if (pnum != static_cast<int>(MyPlayerId)) { } else if (pnum != MyPlayerId) {
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player.isOnActiveLevel() && message.wMon < MAXMONSTERS) { if (player.isOnActiveLevel() && message.wMon < MAXMONSTERS) {
auto &monster = Monsters[message.wMon]; auto &monster = Monsters[message.wMon];
@ -1601,13 +1601,13 @@ DWORD OnMonstDamage(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnPlayerDeath(const TCmd *pCmd, int pnum) DWORD OnPlayerDeath(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (pnum != static_cast<int>(MyPlayerId)) else if (pnum != MyPlayerId)
StartPlayerKill(pnum, message.wParam1); StartPlayerKill(pnum, message.wParam1);
else else
CheckUpdatePlayer(pnum); CheckUpdatePlayer(pnum);
@ -1709,7 +1709,7 @@ DWORD OnBreakObject(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnChangePlayerItems(const TCmd *pCmd, int pnum) DWORD OnChangePlayerItems(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdChItem *>(pCmd); const auto &message = *reinterpret_cast<const TCmdChItem *>(pCmd);
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1721,7 +1721,7 @@ DWORD OnChangePlayerItems(const TCmd *pCmd, int pnum)
if (gbBufferMsgs == 1) { if (gbBufferMsgs == 1) {
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
} else if (pnum != static_cast<int>(MyPlayerId) && message.wIndx <= IDI_LAST) { } else if (pnum != MyPlayerId && message.wIndx <= IDI_LAST) {
CheckInvSwap(player, bodyLocation, message.wIndx, message.wCI, message.dwSeed, message.bId != 0, message.dwBuff); CheckInvSwap(player, bodyLocation, message.wIndx, message.wCI, message.dwSeed, message.bId != 0, message.dwBuff);
} }
@ -1730,25 +1730,25 @@ DWORD OnChangePlayerItems(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnDeletePlayerItems(const TCmd *pCmd, int pnum) DWORD OnDeletePlayerItems(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdDelItem *>(pCmd); const auto &message = *reinterpret_cast<const TCmdDelItem *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (pnum != static_cast<int>(MyPlayerId) && message.bLoc < NUM_INVLOC) else if (pnum != MyPlayerId && message.bLoc < NUM_INVLOC)
inv_update_rem_item(Players[pnum], static_cast<inv_body_loc>(message.bLoc)); inv_update_rem_item(Players[pnum], static_cast<inv_body_loc>(message.bLoc));
return sizeof(message); return sizeof(message);
} }
DWORD OnPlayerLevel(const TCmd *pCmd, int pnum) DWORD OnPlayerLevel(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (message.wParam1 <= MAXCHARLEVEL && pnum != static_cast<int>(MyPlayerId)) else if (message.wParam1 <= MAXCHARLEVEL && pnum != MyPlayerId)
Players[pnum]._pLevel = static_cast<int8_t>(message.wParam1); Players[pnum]._pLevel = static_cast<int8_t>(message.wParam1);
return sizeof(message); return sizeof(message);
@ -1767,7 +1767,7 @@ DWORD OnDropItem(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnSpawnItem(const TCmd *pCmd, int pnum) DWORD OnSpawnItem(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdPItem *>(pCmd); const auto &message = *reinterpret_cast<const TCmdPItem *>(pCmd);
@ -1776,7 +1776,7 @@ DWORD OnSpawnItem(const TCmd *pCmd, int pnum)
} else if (IsPItemValid(message)) { } else if (IsPItemValid(message)) {
Player &player = Players[pnum]; Player &player = Players[pnum];
Point position = { message.x, message.y }; Point position = { message.x, message.y };
if (player.isOnActiveLevel() && pnum != static_cast<int>(MyPlayerId)) { if (player.isOnActiveLevel() && pnum != MyPlayerId) {
SyncDropItem(position, message.wIndx, message.wCI, message.dwSeed, message.bId, message.bDur, message.bMDur, message.bCh, message.bMCh, message.wValue, message.dwBuff, message.wToHit, message.wMaxDam, message.bMinStr, message.bMinMag, message.bMinDex, message.bAC); SyncDropItem(position, message.wIndx, message.wCI, message.dwSeed, message.bId, message.bDur, message.bMDur, message.bCh, message.bMCh, message.wValue, message.dwBuff, message.wToHit, message.wMaxDam, message.bMinStr, message.bMinMag, message.bMinDex, message.bAC);
} }
PutItemRecord(message.dwSeed, message.wCI, message.wIndx); PutItemRecord(message.dwSeed, message.wCI, message.wIndx);
@ -1786,7 +1786,7 @@ DWORD OnSpawnItem(const TCmd *pCmd, int pnum)
return sizeof(message); return sizeof(message);
} }
DWORD OnSendPlayerInfo(const TCmd *pCmd, int pnum) DWORD OnSendPlayerInfo(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdPlrInfoHdr *>(pCmd); const auto &message = *reinterpret_cast<const TCmdPlrInfoHdr *>(pCmd);
@ -1798,7 +1798,7 @@ DWORD OnSendPlayerInfo(const TCmd *pCmd, int pnum)
return message.wBytes + sizeof(message); return message.wBytes + sizeof(message);
} }
DWORD OnPlayerJoinLevel(const TCmd *pCmd, int pnum) DWORD OnPlayerJoinLevel(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdLocParam2 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdLocParam2 *>(pCmd);
const Point position { message.x, message.y }; const Point position { message.x, message.y };
@ -1824,7 +1824,7 @@ DWORD OnPlayerJoinLevel(const TCmd *pCmd, int pnum)
EventPlrMsg(fmt::format(fmt::runtime(_("Player '{:s}' (level {:d}) just joined the game")), player._pName, player._pLevel)); EventPlrMsg(fmt::format(fmt::runtime(_("Player '{:s}' (level {:d}) just joined the game")), player._pName, player._pLevel));
} }
if (player.plractive && static_cast<int>(MyPlayerId) != pnum) { if (player.plractive && pnum != MyPlayerId) {
player.position.tile = position; player.position.tile = position;
if (isSetLevel) if (isSetLevel)
player.setLevel(static_cast<_setlevels>(playerLevel)); player.setLevel(static_cast<_setlevels>(playerLevel));
@ -1843,14 +1843,14 @@ DWORD OnPlayerJoinLevel(const TCmd *pCmd, int pnum)
dFlags[player.position.tile.x][player.position.tile.y] |= DungeonFlag::DeadPlayer; dFlags[player.position.tile.x][player.position.tile.y] |= DungeonFlag::DeadPlayer;
} }
player._pvid = AddVision(player.position.tile, player._pLightRad, pnum == static_cast<int>(MyPlayerId)); player._pvid = AddVision(player.position.tile, player._pLightRad, pnum == MyPlayerId);
} }
} }
return sizeof(message); return sizeof(message);
} }
DWORD OnActivatePortal(const TCmd *pCmd, int pnum) DWORD OnActivatePortal(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdLocParam3 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdLocParam3 *>(pCmd);
const Point position { message.x, message.y }; const Point position { message.x, message.y };
@ -1863,13 +1863,13 @@ DWORD OnActivatePortal(const TCmd *pCmd, int pnum)
auto dungeonType = static_cast<dungeon_type>(message.wParam2); auto dungeonType = static_cast<dungeon_type>(message.wParam2);
ActivatePortal(pnum, position, level, dungeonType, isSetLevel); ActivatePortal(pnum, position, level, dungeonType, isSetLevel);
if (pnum != static_cast<int>(MyPlayerId)) { if (pnum != MyPlayerId) {
if (leveltype == DTYPE_TOWN) { if (leveltype == DTYPE_TOWN) {
AddInTownPortal(pnum); AddInTownPortal(pnum);
} else if (Players[pnum].isOnActiveLevel()) { } else if (Players[pnum].isOnActiveLevel()) {
bool addPortal = true; bool addPortal = true;
for (auto &missile : Missiles) { for (auto &missile : Missiles) {
if (missile._mitype == MIS_TOWN && missile._misource == pnum) { if (missile._mitype == MIS_TOWN && static_cast<size_t>(missile._misource) == pnum) {
addPortal = false; addPortal = false;
break; break;
} }
@ -1901,12 +1901,12 @@ DWORD OnDeactivatePortal(const TCmd *pCmd, int pnum)
return sizeof(*pCmd); return sizeof(*pCmd);
} }
DWORD OnRestartTown(const TCmd *pCmd, int pnum) DWORD OnRestartTown(const TCmd *pCmd, size_t pnum)
{ {
if (gbBufferMsgs == 1) { if (gbBufferMsgs == 1) {
SendPacket(pnum, pCmd, sizeof(*pCmd)); SendPacket(pnum, pCmd, sizeof(*pCmd));
} else { } else {
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
MyPlayerIsDead = false; MyPlayerIsDead = false;
gamemenu_off(); gamemenu_off();
} }
@ -1916,49 +1916,49 @@ DWORD OnRestartTown(const TCmd *pCmd, int pnum)
return sizeof(*pCmd); return sizeof(*pCmd);
} }
DWORD OnSetStrength(const TCmd *pCmd, int pnum) DWORD OnSetStrength(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (message.wParam1 <= 750 && pnum != static_cast<int>(MyPlayerId)) else if (message.wParam1 <= 750 && pnum != MyPlayerId)
SetPlrStr(Players[pnum], message.wParam1); SetPlrStr(Players[pnum], message.wParam1);
return sizeof(message); return sizeof(message);
} }
DWORD OnSetDexterity(const TCmd *pCmd, int pnum) DWORD OnSetDexterity(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (message.wParam1 <= 750 && pnum != static_cast<int>(MyPlayerId)) else if (message.wParam1 <= 750 && pnum != MyPlayerId)
SetPlrDex(Players[pnum], message.wParam1); SetPlrDex(Players[pnum], message.wParam1);
return sizeof(message); return sizeof(message);
} }
DWORD OnSetMagic(const TCmd *pCmd, int pnum) DWORD OnSetMagic(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (message.wParam1 <= 750 && pnum != static_cast<int>(MyPlayerId)) else if (message.wParam1 <= 750 && pnum != MyPlayerId)
SetPlrMag(Players[pnum], message.wParam1); SetPlrMag(Players[pnum], message.wParam1);
return sizeof(message); return sizeof(message);
} }
DWORD OnSetVitality(const TCmd *pCmd, int pnum) DWORD OnSetVitality(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd); const auto &message = *reinterpret_cast<const TCmdParam1 *>(pCmd);
if (gbBufferMsgs == 1) if (gbBufferMsgs == 1)
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
else if (message.wParam1 <= 750 && pnum != static_cast<int>(MyPlayerId)) else if (message.wParam1 <= 750 && pnum != MyPlayerId)
SetPlrVit(Players[pnum], message.wParam1); SetPlrVit(Players[pnum], message.wParam1);
return sizeof(message); return sizeof(message);
@ -1982,14 +1982,14 @@ DWORD OnFriendlyMode(const TCmd *pCmd, Player &player) // NOLINT(misc-unused-par
return sizeof(*pCmd); return sizeof(*pCmd);
} }
DWORD OnSyncQuest(const TCmd *pCmd, int pnum) DWORD OnSyncQuest(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdQuest *>(pCmd); const auto &message = *reinterpret_cast<const TCmdQuest *>(pCmd);
if (gbBufferMsgs == 1) { if (gbBufferMsgs == 1) {
SendPacket(pnum, &message, sizeof(message)); SendPacket(pnum, &message, sizeof(message));
} else { } else {
if (pnum != static_cast<int>(MyPlayerId) && message.q < MAXQUESTS && message.qstate <= QUEST_HIVE_DONE) if (pnum != MyPlayerId && message.q < MAXQUESTS && message.qstate <= QUEST_HIVE_DONE)
SetMultiQuest(message.q, message.qstate, message.qlog != 0, message.qvar1); SetMultiQuest(message.q, message.qstate, message.qlog != 0, message.qvar1);
sgbDeltaChanged = true; sgbDeltaChanged = true;
} }
@ -2031,14 +2031,14 @@ DWORD OnDebug(const TCmd *pCmd)
return sizeof(*pCmd); return sizeof(*pCmd);
} }
DWORD OnNova(const TCmd *pCmd, int pnum) DWORD OnNova(const TCmd *pCmd, size_t pnum)
{ {
const auto &message = *reinterpret_cast<const TCmdLoc *>(pCmd); const auto &message = *reinterpret_cast<const TCmdLoc *>(pCmd);
const Point position { message.x, message.y }; const Point position { message.x, message.y };
if (gbBufferMsgs != 1) { if (gbBufferMsgs != 1) {
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player.isOnActiveLevel() && pnum != static_cast<int>(MyPlayerId) && InDungeonBounds(position)) { if (player.isOnActiveLevel() && pnum != MyPlayerId && InDungeonBounds(position)) {
ClrPlrPath(player); ClrPlrPath(player);
player._pSpell = SPL_NOVA; player._pSpell = SPL_NOVA;
player._pSplType = RSPLTYPE_INVALID; player._pSplType = RSPLTYPE_INVALID;
@ -2087,7 +2087,7 @@ DWORD OnNakrul(const TCmd *pCmd)
} }
IsUberRoomOpened = true; IsUberRoomOpened = true;
Quests[Q_NAKRUL]._qactive = QUEST_DONE; Quests[Q_NAKRUL]._qactive = QUEST_DONE;
monster_some_crypt(); WeakenNaKrul();
} }
return sizeof(*pCmd); return sizeof(*pCmd);
} }
@ -2174,7 +2174,7 @@ void run_delta_info()
FreePackets(); FreePackets();
} }
void DeltaExportData(int pnum) void DeltaExportData(size_t pnum)
{ {
if (sgbDeltaChanged) { if (sgbDeltaChanged) {
for (auto &it : DeltaLevels) { for (auto &it : DeltaLevels) {
@ -2560,9 +2560,9 @@ void NetSendCmdGolem(uint8_t mx, uint8_t my, Direction dir, uint8_t menemy, int
NetSendLoPri(MyPlayerId, (byte *)&cmd, sizeof(cmd)); NetSendLoPri(MyPlayerId, (byte *)&cmd, sizeof(cmd));
} }
void NetSendCmdLoc(int playerId, bool bHiPri, _cmd_id bCmd, Point position) void NetSendCmdLoc(size_t playerId, bool bHiPri, _cmd_id bCmd, Point position)
{ {
if (playerId == static_cast<int>(MyPlayerId) && WasPlayerCmdAlreadyRequested(bCmd, position)) if (playerId == MyPlayerId && WasPlayerCmdAlreadyRequested(bCmd, position))
return; return;
TCmdLoc cmd; TCmdLoc cmd;
@ -2910,7 +2910,7 @@ void delta_close_portal(int pnum)
sgbDeltaChanged = true; sgbDeltaChanged = true;
} }
uint32_t ParseCmd(int pnum, const TCmd *pCmd) uint32_t ParseCmd(size_t pnum, const TCmd *pCmd)
{ {
sbLastCmd = pCmd->bCmd; sbLastCmd = pCmd->bCmd;
if (sgwPackPlrOffsetTbl[pnum] != 0 && sbLastCmd != CMD_ACK_PLRINFO && sbLastCmd != CMD_SEND_PLRINFO) if (sgwPackPlrOffsetTbl[pnum] != 0 && sbLastCmd != CMD_ACK_PLRINFO && sbLastCmd != CMD_SEND_PLRINFO)

6
Source/msg.h

@ -718,7 +718,7 @@ extern int dwRecCount;
void msg_send_drop_pkt(int pnum, int reason); void msg_send_drop_pkt(int pnum, int reason);
bool msg_wait_resync(); bool msg_wait_resync();
void run_delta_info(); void run_delta_info();
void DeltaExportData(int pnum); void DeltaExportData(size_t pnum);
void DeltaSyncJunk(); void DeltaSyncJunk();
void delta_init(); void delta_init();
void delta_kill_monster(int mi, Point position, const Player &player); void delta_kill_monster(int mi, Point position, const Player &player);
@ -734,7 +734,7 @@ void DeltaLoadLevel();
void ClearLastSendPlayerCmd(); void ClearLastSendPlayerCmd();
void NetSendCmd(bool bHiPri, _cmd_id bCmd); void NetSendCmd(bool bHiPri, _cmd_id bCmd);
void NetSendCmdGolem(uint8_t mx, uint8_t my, Direction dir, uint8_t menemy, int hp, uint8_t cl); void NetSendCmdGolem(uint8_t mx, uint8_t my, Direction dir, uint8_t menemy, int hp, uint8_t cl);
void NetSendCmdLoc(int playerId, bool bHiPri, _cmd_id bCmd, Point position); void NetSendCmdLoc(size_t playerId, bool bHiPri, _cmd_id bCmd, Point position);
void NetSendCmdLocParam1(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1); void NetSendCmdLocParam1(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1);
void NetSendCmdLocParam2(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1, uint16_t wParam2); void NetSendCmdLocParam2(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1, uint16_t wParam2);
void NetSendCmdLocParam3(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1, uint16_t wParam2, uint16_t wParam3); void NetSendCmdLocParam3(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1, uint16_t wParam2, uint16_t wParam3);
@ -752,6 +752,6 @@ void NetSendCmdDamage(bool bHiPri, uint8_t bPlr, uint32_t dwDam);
void NetSendCmdMonDmg(bool bHiPri, uint16_t wMon, uint32_t dwDam); void NetSendCmdMonDmg(bool bHiPri, uint16_t wMon, uint32_t dwDam);
void NetSendCmdString(uint32_t pmask, const char *pszStr); void NetSendCmdString(uint32_t pmask, const char *pszStr);
void delta_close_portal(int pnum); void delta_close_portal(int pnum);
uint32_t ParseCmd(int pnum, const TCmd *pCmd); uint32_t ParseCmd(size_t pnum, const TCmd *pCmd);
} // namespace devilution } // namespace devilution

32
Source/multi.cpp

@ -195,18 +195,18 @@ void MonsterSeeds()
Monsters[i]._mAISeed = seed + i; Monsters[i]._mAISeed = seed + i;
} }
void HandleTurnUpperBit(int pnum) void HandleTurnUpperBit(size_t pnum)
{ {
size_t i; size_t i;
for (i = 0; i < Players.size(); i++) { for (i = 0; i < Players.size(); i++) {
if ((player_state[i] & PS_CONNECTED) != 0 && i != static_cast<size_t>(pnum)) if ((player_state[i] & PS_CONNECTED) != 0 && i != pnum)
break; break;
} }
if (MyPlayerId == i) { if (MyPlayerId == i) {
sgbSendDeltaTbl[pnum] = true; sgbSendDeltaTbl[pnum] = true;
} else if (static_cast<int>(MyPlayerId) == pnum) { } else if (pnum == MyPlayerId) {
gbDeltaSender = i; gbDeltaSender = i;
} }
} }
@ -224,9 +224,9 @@ void ParseTurn(int pnum, uint32_t turn)
} }
} }
void PlayerLeftMsg(int pnum, bool left) void PlayerLeftMsg(size_t pnum, bool left)
{ {
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
return; return;
} }
@ -307,7 +307,7 @@ void BeginTimeout()
CheckDropPlayer(); CheckDropPlayer();
} }
void HandleAllPackets(int pnum, const byte *data, size_t size) void HandleAllPackets(size_t pnum, const byte *data, size_t size)
{ {
for (unsigned offset = 0; offset < size;) { for (unsigned offset = 0; offset < size;) {
int messageSize = ParseCmd(pnum, reinterpret_cast<const TCmd *>(&data[offset])); int messageSize = ParseCmd(pnum, reinterpret_cast<const TCmd *>(&data[offset]));
@ -535,8 +535,8 @@ void multi_msg_countdown()
{ {
for (size_t i = 0; i < Players.size(); i++) { for (size_t i = 0; i < Players.size(); i++) {
if ((player_state[i] & PS_TURN_ARRIVED) != 0) { if ((player_state[i] & PS_TURN_ARRIVED) != 0) {
if (gdwMsgLenTbl[i] == 4) if (gdwMsgLenTbl[i] == sizeof(uint32_t))
ParseTurn(static_cast<int>(i), *(DWORD *)glpMsgTbl[i]); ParseTurn(i, *(uint32_t *)glpMsgTbl[i]);
} }
} }
} }
@ -596,7 +596,7 @@ void multi_process_network_packets()
ClearPlayerLeftState(); ClearPlayerLeftState();
ProcessTmsgs(); ProcessTmsgs();
int dwID = -1; size_t dwID = std::numeric_limits<size_t>::max();
TPktHdr *pkt; TPktHdr *pkt;
uint32_t dwMsgSize = 0; uint32_t dwMsgSize = 0;
while (SNetReceiveMessage(&dwID, (void **)&pkt, &dwMsgSize)) { while (SNetReceiveMessage(&dwID, (void **)&pkt, &dwMsgSize)) {
@ -604,7 +604,7 @@ void multi_process_network_packets()
ClearPlayerLeftState(); ClearPlayerLeftState();
if (dwMsgSize < sizeof(TPktHdr)) if (dwMsgSize < sizeof(TPktHdr))
continue; continue;
if (dwID < 0 || dwID >= MAX_PLRS) if (dwID >= MAX_PLRS)
continue; continue;
if (pkt->wCheck != LoadBE32("\0\0ip")) if (pkt->wCheck != LoadBE32("\0\0ip"))
continue; continue;
@ -621,7 +621,7 @@ void multi_process_network_packets()
} }
Point syncPosition = { pkt->px, pkt->py }; Point syncPosition = { pkt->px, pkt->py };
player.position.last = syncPosition; player.position.last = syncPosition;
if (dwID != static_cast<int>(MyPlayerId)) { if (dwID != MyPlayerId) {
assert(gbBufferMsgs != 2); assert(gbBufferMsgs != 2);
player._pHitPoints = pkt->php; player._pHitPoints = pkt->php;
player._pMaxHP = pkt->pmhp; player._pMaxHP = pkt->pmhp;
@ -664,9 +664,9 @@ void multi_process_network_packets()
CheckPlayerInfoTimeouts(); CheckPlayerInfoTimeouts();
} }
void multi_send_zero_packet(int pnum, _cmd_id bCmd, const byte *data, size_t size) void multi_send_zero_packet(size_t pnum, _cmd_id bCmd, const byte *data, size_t size)
{ {
assert(pnum != static_cast<int>(MyPlayerId)); assert(pnum != MyPlayerId);
assert(data != nullptr); assert(data != nullptr);
assert(size <= 0x0ffff); assert(size <= 0x0ffff);
@ -786,14 +786,14 @@ bool NetInit(bool bSinglePlayer)
return true; return true;
} }
void recv_plrinfo(int pnum, const TCmdPlrInfoHdr &header, bool recv) void recv_plrinfo(size_t pnum, const TCmdPlrInfoHdr &header, bool recv)
{ {
static PlayerPack PackedPlayerBuffer[MAX_PLRS]; static PlayerPack PackedPlayerBuffer[MAX_PLRS];
if (static_cast<int>(MyPlayerId) == pnum) { if (pnum == MyPlayerId) {
return; return;
} }
assert(pnum >= 0 && pnum < MAX_PLRS); assert(pnum < MAX_PLRS);
Player &player = Players[pnum]; Player &player = Players[pnum];
auto &packedPlayer = PackedPlayerBuffer[pnum]; auto &packedPlayer = PackedPlayerBuffer[pnum];

4
Source/multi.h

@ -66,9 +66,9 @@ void multi_net_ping();
*/ */
bool multi_handle_delta(); bool multi_handle_delta();
void multi_process_network_packets(); void multi_process_network_packets();
void multi_send_zero_packet(int pnum, _cmd_id bCmd, const byte *data, size_t size); void multi_send_zero_packet(size_t pnum, _cmd_id bCmd, const byte *data, size_t size);
void NetClose(); void NetClose();
bool NetInit(bool bSinglePlayer); bool NetInit(bool bSinglePlayer);
void recv_plrinfo(int pnum, const TCmdPlrInfoHdr &header, bool recv); void recv_plrinfo(size_t pnum, const TCmdPlrInfoHdr &header, bool recv);
} // namespace devilution } // namespace devilution

98
Source/objects.cpp

@ -2320,7 +2320,7 @@ void OperateChamberOfBoneBook(Object &questBook)
InitQTextMsg(textdef); InitQTextMsg(textdef);
} }
void OperateChest(int pnum, int i, bool sendmsg) void OperateChest(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -2371,18 +2371,18 @@ void OperateChest(int pnum, int i, bool sendmsg)
AddMissile(Objects[i].position, player.position.tile, mdir, mtype, TARGET_PLAYERS, -1, 0, 0); AddMissile(Objects[i].position, player.position.tile, mdir, mtype, TARGET_PLAYERS, -1, 0, 0);
Objects[i]._oTrapFlag = false; Objects[i]._oTrapFlag = false;
} }
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam2(false, CMD_PLROPOBJ, pnum, i); NetSendCmdParam2(false, CMD_PLROPOBJ, pnum, i);
} }
void OperateMushroomPatch(int pnum, Object &questContainer) void OperateMushroomPatch(size_t pnum, Object &questContainer)
{ {
if (ActiveItemCount >= MAXITEMS) { if (ActiveItemCount >= MAXITEMS) {
return; return;
} }
if (Quests[Q_MUSHROOM]._qactive != QUEST_ACTIVE) { if (Quests[Q_MUSHROOM]._qactive != QUEST_ACTIVE) {
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
Players[pnum].Say(HeroSpeech::ICantUseThisYet); Players[pnum].Say(HeroSpeech::ICantUseThisYet);
} }
return; return;
@ -2401,14 +2401,14 @@ void OperateMushroomPatch(int pnum, Object &questContainer)
Quests[Q_MUSHROOM]._qvar1 = QS_MUSHSPAWNED; Quests[Q_MUSHROOM]._qvar1 = QS_MUSHSPAWNED;
} }
void OperateInnSignChest(int pnum, Object &questContainer) void OperateInnSignChest(size_t pnum, Object &questContainer)
{ {
if (ActiveItemCount >= MAXITEMS) { if (ActiveItemCount >= MAXITEMS) {
return; return;
} }
if (Quests[Q_LTBANNER]._qvar1 != 2) { if (Quests[Q_LTBANNER]._qvar1 != 2) {
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
Players[pnum].Say(HeroSpeech::ICantOpenThisYet); Players[pnum].Say(HeroSpeech::ICantOpenThisYet);
} }
return; return;
@ -2426,7 +2426,7 @@ void OperateInnSignChest(int pnum, Object &questContainer)
SpawnQuestItem(IDI_BANNER, pos, 0, 0); SpawnQuestItem(IDI_BANNER, pos, 0, 0);
} }
void OperateSlainHero(int pnum, int i) void OperateSlainHero(size_t pnum, int i)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -2449,7 +2449,7 @@ void OperateSlainHero(int pnum, int i)
CreateMagicWeapon(Objects[i].position, ItemType::Axe, ICURS_BATTLE_AXE, true, false); CreateMagicWeapon(Objects[i].position, ItemType::Axe, ICURS_BATTLE_AXE, true, false);
} }
MyPlayer->Say(HeroSpeech::RestInPeaceMyFriend); MyPlayer->Say(HeroSpeech::RestInPeaceMyFriend);
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
@ -2481,7 +2481,7 @@ void OperateTrapLever(Object &flameLever)
} }
} }
void OperateSarc(int pnum, int i, bool sendmsg) void OperateSarc(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -2496,7 +2496,7 @@ void OperateSarc(int pnum, int i, bool sendmsg)
CreateRndItem(Objects[i].position, false, sendmsg, false); CreateRndItem(Objects[i].position, false, sendmsg, false);
if (Objects[i]._oVar1 >= 8) if (Objects[i]._oVar1 >= 8)
SpawnSkeleton(Objects[i]._oVar2, Objects[i].position); SpawnSkeleton(Objects[i]._oVar2, Objects[i].position);
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
@ -2693,7 +2693,7 @@ void OperateShrineWeird(Player &player)
InitDiabloMsg(EMSG_SHRINE_WEIRD); InitDiabloMsg(EMSG_SHRINE_WEIRD);
} }
void OperateShrineMagical(int pnum) void OperateShrineMagical(size_t pnum)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -2827,7 +2827,7 @@ void OperateShrineCostOfWisdom(Player &player, spell_id spellId, diablo_message
InitDiabloMsg(message); InitDiabloMsg(message);
} }
void OperateShrineCryptic(int pnum) void OperateShrineCryptic(size_t pnum)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -2921,7 +2921,7 @@ void OperateShrineDivine(Player &player, Point spawnPosition)
InitDiabloMsg(EMSG_SHRINE_DIVINE); InitDiabloMsg(EMSG_SHRINE_DIVINE);
} }
void OperateShrineHoly(int pnum) void OperateShrineHoly(size_t pnum)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3182,7 +3182,7 @@ void OperateShrineSparkling(Player &player, Point spawnPosition)
* @param pnum The player that activated the shrine * @param pnum The player that activated the shrine
* @param spawnPosition The position of the shrine, the portal will be placed on the side closest to the player * @param spawnPosition The position of the shrine, the portal will be placed on the side closest to the player
*/ */
void OperateShrineTown(int pnum, Point spawnPosition) void OperateShrineTown(size_t pnum, Point spawnPosition)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3265,7 +3265,7 @@ void OperateShrineMurphys(Player &player)
InitDiabloMsg(EMSG_SHRINE_MURPHYS); InitDiabloMsg(EMSG_SHRINE_MURPHYS);
} }
void OperateShrine(int pnum, int i, _sfx_id sType) void OperateShrine(size_t pnum, int i, _sfx_id sType)
{ {
assert(i >= 0 && i < MAXOBJECTS); assert(i >= 0 && i < MAXOBJECTS);
Object &shrine = Objects[i]; Object &shrine = Objects[i];
@ -3394,7 +3394,7 @@ void OperateShrine(int pnum, int i, _sfx_id sType)
NetSendCmdParam2(false, CMD_PLROPOBJ, pnum, i); NetSendCmdParam2(false, CMD_PLROPOBJ, pnum, i);
} }
void OperateSkelBook(int pnum, int i, bool sendmsg) void OperateSkelBook(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -3408,11 +3408,11 @@ void OperateSkelBook(int pnum, int i, bool sendmsg)
CreateTypeItem(Objects[i].position, false, ItemType::Misc, IMISC_SCROLL, sendmsg, false); CreateTypeItem(Objects[i].position, false, ItemType::Misc, IMISC_SCROLL, sendmsg, false);
else else
CreateTypeItem(Objects[i].position, false, ItemType::Misc, IMISC_BOOK, sendmsg, false); CreateTypeItem(Objects[i].position, false, ItemType::Misc, IMISC_BOOK, sendmsg, false);
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
void OperateBookCase(int pnum, int i, bool sendmsg) void OperateBookCase(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -3436,11 +3436,11 @@ void OperateBookCase(int pnum, int i, bool sendmsg)
zhar._mmode = MonsterMode::Talk; zhar._mmode = MonsterMode::Talk;
} }
} }
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
void OperateDecap(int pnum, int i, bool sendmsg) void OperateDecap(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -3448,11 +3448,11 @@ void OperateDecap(int pnum, int i, bool sendmsg)
Objects[i]._oSelFlag = 0; Objects[i]._oSelFlag = 0;
SetRndSeed(Objects[i]._oRndSeed); SetRndSeed(Objects[i]._oRndSeed);
CreateRndItem(Objects[i].position, false, sendmsg, false); CreateRndItem(Objects[i].position, false, sendmsg, false);
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
void OperateArmorStand(int pnum, int i, bool sendmsg) void OperateArmorStand(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) { if (Objects[i]._oSelFlag == 0) {
return; return;
@ -3470,7 +3470,7 @@ void OperateArmorStand(int pnum, int i, bool sendmsg)
} else if (currlevel >= 13) { } else if (currlevel >= 13) {
CreateTypeItem(Objects[i].position, true, ItemType::HeavyArmor, IMISC_NONE, sendmsg, false); CreateTypeItem(Objects[i].position, true, ItemType::HeavyArmor, IMISC_NONE, sendmsg, false);
} }
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
@ -3507,13 +3507,13 @@ void OperateCauldron(int pnum, int i, _sfx_id sType)
force_redraw = 255; force_redraw = 255;
} }
bool OperateFountains(int pnum, int i) bool OperateFountains(size_t pnum, int i)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
bool applied = false; bool applied = false;
switch (Objects[i]._otype) { switch (Objects[i]._otype) {
case OBJ_BLOODFTN: case OBJ_BLOODFTN:
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
return false; return false;
if (player._pHitPoints < player._pMaxHP) { if (player._pHitPoints < player._pMaxHP) {
@ -3529,7 +3529,7 @@ bool OperateFountains(int pnum, int i)
PlaySfxLoc(LS_FOUNTAIN, Objects[i].position); PlaySfxLoc(LS_FOUNTAIN, Objects[i].position);
break; break;
case OBJ_PURIFYINGFTN: case OBJ_PURIFYINGFTN:
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
return false; return false;
if (player._pMana < player._pMaxMana) { if (player._pMana < player._pMaxMana) {
@ -3561,7 +3561,7 @@ bool OperateFountains(int pnum, int i)
0, 0,
2 * leveltype); 2 * leveltype);
applied = true; applied = true;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
break; break;
case OBJ_TEARFTN: { case OBJ_TEARFTN: {
@ -3569,7 +3569,7 @@ bool OperateFountains(int pnum, int i)
break; break;
PlaySfxLoc(LS_FOUNTAIN, Objects[i].position); PlaySfxLoc(LS_FOUNTAIN, Objects[i].position);
Objects[i]._oSelFlag = 0; Objects[i]._oSelFlag = 0;
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
return false; return false;
unsigned randomValue = (Objects[i]._oRndSeed >> 16) % 12; unsigned randomValue = (Objects[i]._oRndSeed >> 16) % 12;
@ -3598,7 +3598,7 @@ bool OperateFountains(int pnum, int i)
CheckStats(player); CheckStats(player);
applied = true; applied = true;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} break; } break;
default: default:
@ -3608,7 +3608,7 @@ bool OperateFountains(int pnum, int i)
return applied; return applied;
} }
void OperateWeaponRack(int pnum, int i, bool sendmsg) void OperateWeaponRack(size_t pnum, int i, bool sendmsg)
{ {
if (Objects[i]._oSelFlag == 0) if (Objects[i]._oSelFlag == 0)
return; return;
@ -3621,7 +3621,7 @@ void OperateWeaponRack(int pnum, int i, bool sendmsg)
CreateTypeItem(Objects[i].position, leveltype != DTYPE_CATHEDRAL, weaponType, IMISC_NONE, sendmsg, false); CreateTypeItem(Objects[i].position, leveltype != DTYPE_CATHEDRAL, weaponType, IMISC_NONE, sendmsg, false);
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
@ -3658,9 +3658,9 @@ bool OperateNakrulBook(int s)
return false; return false;
} }
void OperateStoryBook(int pnum, int i) void OperateStoryBook(size_t pnum, int i)
{ {
if (Objects[i]._oSelFlag == 0 || qtextflag || pnum != static_cast<int>(MyPlayerId)) { if (Objects[i]._oSelFlag == 0 || qtextflag || pnum != MyPlayerId) {
return; return;
} }
Objects[i]._oAnimFrame = Objects[i]._oVar4; Objects[i]._oAnimFrame = Objects[i]._oVar4;
@ -3680,13 +3680,13 @@ void OperateStoryBook(int pnum, int i)
NetSendCmdParam1(false, CMD_OPERATEOBJ, i); NetSendCmdParam1(false, CMD_OPERATEOBJ, i);
} }
void OperateLazStand(int pnum, int i) void OperateLazStand(size_t pnum, int i)
{ {
if (ActiveItemCount >= MAXITEMS) { if (ActiveItemCount >= MAXITEMS) {
return; return;
} }
if (Objects[i]._oSelFlag == 0 || qtextflag || pnum != static_cast<int>(MyPlayerId)) { if (Objects[i]._oSelFlag == 0 || qtextflag || pnum != MyPlayerId) {
return; return;
} }
@ -3801,11 +3801,11 @@ void BreakCrux(Object &crux)
ObjChangeMap(crux._oVar1, crux._oVar2, crux._oVar3, crux._oVar4); ObjChangeMap(crux._oVar1, crux._oVar2, crux._oVar3, crux._oVar4);
} }
void BreakBarrel(int pnum, Object &barrel, bool forcebreak, bool sendmsg) void BreakBarrel(size_t pnum, Object &barrel, bool forcebreak, bool sendmsg)
{ {
if (barrel._oSelFlag == 0) if (barrel._oSelFlag == 0)
return; return;
if (!forcebreak && pnum != static_cast<int>(MyPlayerId)) { if (!forcebreak && pnum != MyPlayerId) {
return; return;
} }
@ -3858,7 +3858,7 @@ void BreakBarrel(int pnum, Object &barrel, bool forcebreak, bool sendmsg)
if (barrel._oVar2 >= 8) if (barrel._oVar2 >= 8)
SpawnSkeleton(barrel._oVar4, barrel.position); SpawnSkeleton(barrel._oVar4, barrel.position);
} }
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
NetSendCmdParam2(false, CMD_BREAKOBJ, pnum, static_cast<uint16_t>(barrel.GetId())); NetSendCmdParam2(false, CMD_BREAKOBJ, pnum, static_cast<uint16_t>(barrel.GetId()));
} }
} }
@ -4789,9 +4789,9 @@ void ObjChangeMapResync(int x1, int y1, int x2, int y2)
} }
} }
void TryDisarm(int pnum, int i) void TryDisarm(size_t pnum, int i)
{ {
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NewCursor(CURSOR_HAND); NewCursor(CURSOR_HAND);
if (!Objects[i]._oTrapFlag) { if (!Objects[i]._oTrapFlag) {
return; return;
@ -4822,9 +4822,9 @@ int ItemMiscIdIdx(item_misc_id imiscid)
return i; return i;
} }
void OperateObject(int pnum, int i, bool teleFlag) void OperateObject(size_t pnum, int i, bool teleFlag)
{ {
bool sendmsg = pnum == static_cast<int>(MyPlayerId); bool sendmsg = pnum == MyPlayerId;
switch (Objects[i]._otype) { switch (Objects[i]._otype) {
case OBJ_L1LDOOR: case OBJ_L1LDOOR:
case OBJ_L1RDOOR: case OBJ_L1RDOOR:
@ -5044,33 +5044,33 @@ void DeltaSyncOpObject(int cmd, int i)
} }
} }
void SyncOpObject(int pnum, int cmd, int i) void SyncOpObject(size_t pnum, int cmd, int i)
{ {
switch (Objects[i]._otype) { switch (Objects[i]._otype) {
case OBJ_L1LDOOR: case OBJ_L1LDOOR:
case OBJ_L1RDOOR: case OBJ_L1RDOOR:
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
SyncOpL1Door(cmd, i); SyncOpL1Door(cmd, i);
break; break;
case OBJ_L2LDOOR: case OBJ_L2LDOOR:
case OBJ_L2RDOOR: case OBJ_L2RDOOR:
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
SyncOpL2Door(cmd, i); SyncOpL2Door(cmd, i);
break; break;
case OBJ_L3LDOOR: case OBJ_L3LDOOR:
case OBJ_L3RDOOR: case OBJ_L3RDOOR:
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
SyncOpL3Door(cmd, i); SyncOpL3Door(cmd, i);
break; break;
case OBJ_L5LDOOR: case OBJ_L5LDOOR:
case OBJ_L5RDOOR: case OBJ_L5RDOOR:
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
SyncOpL5Door(cmd, i); SyncOpL5Door(cmd, i);
break; break;
case OBJ_LEVER: case OBJ_LEVER:
case OBJ_L5LEVER: case OBJ_L5LEVER:
case OBJ_SWITCHSKL: case OBJ_SWITCHSKL:
OperateLever(i, pnum == static_cast<int>(MyPlayerId)); OperateLever(i, pnum == MyPlayerId);
break; break;
case OBJ_CHEST1: case OBJ_CHEST1:
case OBJ_CHEST2: case OBJ_CHEST2:
@ -5087,7 +5087,7 @@ void SyncOpObject(int pnum, int cmd, int i)
case OBJ_BLINDBOOK: case OBJ_BLINDBOOK:
case OBJ_BLOODBOOK: case OBJ_BLOODBOOK:
case OBJ_STEELTOME: case OBJ_STEELTOME:
OperateBookLever(i, pnum == static_cast<int>(MyPlayerId)); OperateBookLever(i, pnum == MyPlayerId);
break; break;
case OBJ_SHRINEL: case OBJ_SHRINEL:
case OBJ_SHRINER: case OBJ_SHRINER:

6
Source/objects.h

@ -304,10 +304,10 @@ void RedoPlayerVision();
void MonstCheckDoors(Monster &monster); void MonstCheckDoors(Monster &monster);
void ObjChangeMap(int x1, int y1, int x2, int y2); void ObjChangeMap(int x1, int y1, int x2, int y2);
void ObjChangeMapResync(int x1, int y1, int x2, int y2); void ObjChangeMapResync(int x1, int y1, int x2, int y2);
void TryDisarm(int pnum, int i); void TryDisarm(size_t pnum, int i);
int ItemMiscIdIdx(item_misc_id imiscid); int ItemMiscIdIdx(item_misc_id imiscid);
void OperateObject(int pnum, int i, bool TeleFlag); void OperateObject(size_t pnum, int i, bool TeleFlag);
void SyncOpObject(int pnum, int cmd, int i); void SyncOpObject(size_t pnum, int cmd, int i);
void BreakObject(int pnum, Object &object); void BreakObject(int pnum, Object &object);
void DeltaSyncOpObject(int cmd, int i); void DeltaSyncOpObject(int cmd, int i);
void DeltaSyncBreakObj(Object &object); void DeltaSyncBreakObj(Object &object);

222
Source/player.cpp

@ -163,7 +163,7 @@ struct DirectionSettings {
Displacement map; Displacement map;
ScrollDirection scrollDir; ScrollDirection scrollDir;
PLR_MODE walkMode; PLR_MODE walkMode;
void (*walkModeHandler)(int, const DirectionSettings &); void (*walkModeHandler)(size_t, const DirectionSettings &);
}; };
/** Specifies the frame of each animation for which an action is triggered, for each player class. */ /** Specifies the frame of each animation for which an action is triggered, for each player class. */
@ -215,14 +215,14 @@ void PmChangeLightOff(Player &player)
ChangeLightOffset(player._plid, { x, y }); ChangeLightOffset(player._plid, { x, y });
} }
void WalkUpwards(int pnum, const DirectionSettings &walkParams) void WalkUpwards(size_t pnum, const DirectionSettings &walkParams)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
dPlayer[player.position.future.x][player.position.future.y] = -(pnum + 1); dPlayer[player.position.future.x][player.position.future.y] = -(pnum + 1);
player.position.temp = { walkParams.tileAdd.deltaX, walkParams.tileAdd.deltaY }; player.position.temp = { walkParams.tileAdd.deltaX, walkParams.tileAdd.deltaY };
} }
void WalkDownwards(int pnum, const DirectionSettings & /*walkParams*/) void WalkDownwards(size_t pnum, const DirectionSettings & /*walkParams*/)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
dPlayer[player.position.tile.x][player.position.tile.y] = -(pnum + 1); dPlayer[player.position.tile.x][player.position.tile.y] = -(pnum + 1);
@ -234,7 +234,7 @@ void WalkDownwards(int pnum, const DirectionSettings & /*walkParams*/)
PmChangeLightOff(player); PmChangeLightOff(player);
} }
void WalkSides(int pnum, const DirectionSettings &walkParams) void WalkSides(size_t pnum, const DirectionSettings &walkParams)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -311,7 +311,7 @@ bool PlrDirOK(const Player &player, Direction dir)
return true; return true;
} }
void HandleWalkMode(int pnum, Displacement vel, Direction dir) void HandleWalkMode(size_t pnum, Displacement vel, Direction dir)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
const auto &dirModeParams = WalkSettings[static_cast<size_t>(dir)]; const auto &dirModeParams = WalkSettings[static_cast<size_t>(dir)];
@ -324,7 +324,7 @@ void HandleWalkMode(int pnum, Displacement vel, Direction dir)
// The player's tile position after finishing this movement action // The player's tile position after finishing this movement action
player.position.future = player.position.tile + dirModeParams.tileAdd; player.position.future = player.position.tile + dirModeParams.tileAdd;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
ScrollViewPort(player, dirModeParams.scrollDir); ScrollViewPort(player, dirModeParams.scrollDir);
} }
@ -351,11 +351,11 @@ void StartWalkAnimation(Player &player, Direction dir, bool pmWillBeCalled)
/** /**
* @brief Start moving a player to a new tile * @brief Start moving a player to a new tile
*/ */
void StartWalk(int pnum, Displacement vel, Direction dir, bool pmWillBeCalled) void StartWalk(size_t pnum, Displacement vel, Direction dir, bool pmWillBeCalled)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -386,10 +386,10 @@ void ClearStateVariables(Player &player)
player.position.offset2 = { 0, 0 }; player.position.offset2 = { 0, 0 };
} }
void StartWalkStand(int pnum) void StartWalkStand(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartWalkStand: illegal player %i", pnum); app_fatal("StartWalkStand: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -397,7 +397,7 @@ void StartWalkStand(int pnum)
player.position.future = player.position.tile; player.position.future = player.position.tile;
player.position.offset = { 0, 0 }; player.position.offset = { 0, 0 };
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
ScrollInfo.offset = { 0, 0 }; ScrollInfo.offset = { 0, 0 };
ScrollInfo._sdir = ScrollDirection::None; ScrollInfo._sdir = ScrollDirection::None;
ViewPosition = player.position.tile; ViewPosition = player.position.tile;
@ -427,14 +427,14 @@ void ChangeOffset(Player &player)
PmChangeLightOff(player); PmChangeLightOff(player);
} }
void StartAttack(int pnum, Direction d) void StartAttack(size_t pnum, Direction d)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartAttack: illegal player %i", pnum); app_fatal("StartAttack: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -459,14 +459,14 @@ void StartAttack(int pnum, Direction d)
SetPlayerOld(player); SetPlayerOld(player);
} }
void StartRangeAttack(int pnum, Direction d, int cx, int cy) void StartRangeAttack(size_t pnum, Direction d, int cx, int cy)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartRangeAttack: illegal player %i", pnum); app_fatal("StartRangeAttack: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -501,13 +501,13 @@ player_graphic GetPlayerGraphicForSpell(spell_id spellId)
} }
} }
void StartSpell(int pnum, Direction d, int cx, int cy) void StartSpell(size_t pnum, Direction d, int cx, int cy)
{ {
if ((DWORD)pnum >= MAX_PLRS) if (pnum >= MAX_PLRS)
app_fatal("StartSpell: illegal player %i", pnum); app_fatal("StartSpell: illegal player %lu", pnum);
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -604,7 +604,7 @@ void DropHalfPlayersGold(Player &player)
player._pGold /= 2; player._pGold /= 2;
} }
void InitLevelChange(int pnum) void InitLevelChange(size_t pnum)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
Player &myPlayer = *MyPlayer; Player &myPlayer = *MyPlayer;
@ -613,19 +613,19 @@ void InitLevelChange(int pnum)
player.pManaShield = false; player.pManaShield = false;
player.wReflections = 0; player.wReflections = 0;
// share info about your manashield when another player joins the level // share info about your manashield when another player joins the level
if (pnum != static_cast<int>(MyPlayerId) && myPlayer.pManaShield) if (pnum != MyPlayerId && myPlayer.pManaShield)
NetSendCmd(true, CMD_SETSHIELD); NetSendCmd(true, CMD_SETSHIELD);
// share info about your reflect charges when another player joins the level // share info about your reflect charges when another player joins the level
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
NetSendCmdParam1(true, CMD_SETREFLECT, myPlayer.wReflections); NetSendCmdParam1(true, CMD_SETREFLECT, myPlayer.wReflections);
if (pnum == static_cast<int>(MyPlayerId) && qtextflag) { if (pnum == MyPlayerId && qtextflag) {
qtextflag = false; qtextflag = false;
stream_stop(); stream_stop();
} }
RemovePlrFromMap(pnum); RemovePlrFromMap(pnum);
SetPlayerOld(player); SetPlayerOld(player);
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
dPlayer[player.position.tile.x][player.position.tile.y] = pnum + 1; dPlayer[player.position.tile.x][player.position.tile.y] = pnum + 1;
} else { } else {
player._pLvlVisited[player.plrlevel] = true; player._pLvlVisited[player.plrlevel] = true;
@ -635,7 +635,7 @@ void InitLevelChange(int pnum)
player.destAction = ACTION_NONE; player.destAction = ACTION_NONE;
player._pLvlChanging = true; player._pLvlChanging = true;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
player.pLvlLoad = 10; player.pLvlLoad = 10;
} }
} }
@ -643,10 +643,10 @@ void InitLevelChange(int pnum)
/** /**
* @brief Continue movement towards new tile * @brief Continue movement towards new tile
*/ */
bool DoWalk(int pnum, int variant) bool DoWalk(size_t pnum, int variant)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PM_DoWalk: illegal player %i", pnum); app_fatal("PM_DoWalk: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -686,7 +686,7 @@ bool DoWalk(int pnum, int variant)
} }
// Update the "camera" tile position // Update the "camera" tile position
if (pnum == static_cast<int>(MyPlayerId) && ScrollInfo._sdir != ScrollDirection::None) { if (pnum == MyPlayerId && ScrollInfo._sdir != ScrollDirection::None) {
ViewPosition = Point { 0, 0 } + (player.position.tile - ScrollInfo.tile); ViewPosition = Point { 0, 0 } + (player.position.tile - ScrollInfo.tile);
} }
@ -794,17 +794,17 @@ bool DamageWeapon(Player &player, int durrnd)
return false; return false;
} }
bool PlrHitMonst(int pnum, int m, bool adjacentDamage = false) bool PlrHitMonst(size_t pnum, size_t m, bool adjacentDamage = false)
{ {
int hper = 0; int hper = 0;
if ((DWORD)m >= MAXMONSTERS) { if (m >= MAXMONSTERS) {
app_fatal("PlrHitMonst: illegal monster %i", m); app_fatal("PlrHitMonst: illegal monster %lu", m);
} }
auto &monster = Monsters[m]; auto &monster = Monsters[m];
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PlrHitMonst: illegal player %i", pnum); app_fatal("PlrHitMonst: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -902,7 +902,7 @@ bool PlrHitMonst(int pnum, int m, bool adjacentDamage = false)
if (adjacentDamage) if (adjacentDamage)
dam >>= 2; dam >>= 2;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
if (HasAnyOf(player.pDamAcFlags, ItemSpecialEffectHf::Peril)) { if (HasAnyOf(player.pDamAcFlags, ItemSpecialEffectHf::Peril)) {
dam2 += player._pIGetHit << 6; dam2 += player._pIGetHit << 6;
if (dam2 >= 0) { if (dam2 >= 0) {
@ -1059,10 +1059,10 @@ bool PlrHitObj(int pnum, Object &targetObject)
return false; return false;
} }
bool DoAttack(int pnum) bool DoAttack(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PM_DoAttack: illegal player %i", pnum); app_fatal("PM_DoAttack: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1168,10 +1168,10 @@ bool DoAttack(int pnum)
return false; return false;
} }
bool DoRangeAttack(int pnum) bool DoRangeAttack(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PM_DoRangeAttack: illegal player %i", pnum); app_fatal("PM_DoRangeAttack: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1268,10 +1268,10 @@ void DamageParryItem(Player &player)
} }
} }
bool DoBlock(int pnum) bool DoBlock(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PM_DoBlock: illegal player %i", pnum); app_fatal("PM_DoBlock: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1290,9 +1290,6 @@ bool DoBlock(int pnum)
void DamageArmor(Player &player) void DamageArmor(Player &player)
{ {
int a;
Item *pi;
if (&player != MyPlayer) { if (&player != MyPlayer) {
return; return;
} }
@ -1301,7 +1298,7 @@ void DamageArmor(Player &player)
return; return;
} }
a = GenerateRnd(3); int a = GenerateRnd(3);
if (!player.InvBody[INVLOC_CHEST].isEmpty() && player.InvBody[INVLOC_HEAD].isEmpty()) { if (!player.InvBody[INVLOC_CHEST].isEmpty() && player.InvBody[INVLOC_HEAD].isEmpty()) {
a = 1; a = 1;
} }
@ -1309,6 +1306,7 @@ void DamageArmor(Player &player)
a = 0; a = 0;
} }
Item *pi;
if (a != 0) { if (a != 0) {
pi = &player.InvBody[INVLOC_CHEST]; pi = &player.InvBody[INVLOC_CHEST];
} else { } else {
@ -1331,10 +1329,10 @@ void DamageArmor(Player &player)
CalcPlrInv(player, true); CalcPlrInv(player, true);
} }
bool DoSpell(int pnum) bool DoSpell(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PM_DoSpell: illegal player %i", pnum); app_fatal("PM_DoSpell: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1362,10 +1360,10 @@ bool DoSpell(int pnum)
return false; return false;
} }
bool DoGotHit(int pnum) bool DoGotHit(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("PM_DoGotHit: illegal player %i", pnum); app_fatal("PM_DoGotHit: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1410,10 +1408,10 @@ bool IsPlayerAdjacentToObject(Player &player, Object &object)
return x <= 1 && y <= 1; return x <= 1 && y <= 1;
} }
void CheckNewPath(int pnum, bool pmWillBeCalled) void CheckNewPath(size_t pnum, bool pmWillBeCalled)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("CheckNewPath: illegal player %i", pnum); app_fatal("CheckNewPath: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -1466,7 +1464,7 @@ void CheckNewPath(int pnum, bool pmWillBeCalled)
Direction d; Direction d;
if (player.walkpath[0] != WALK_NONE) { if (player.walkpath[0] != WALK_NONE) {
if (player._pmode == PM_STAND) { if (player._pmode == PM_STAND) {
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
if (player.destAction == ACTION_ATTACKMON || player.destAction == ACTION_ATTACKPLR) { if (player.destAction == ACTION_ATTACKMON || player.destAction == ACTION_ATTACKPLR) {
if (player.destAction == ACTION_ATTACKMON) { if (player.destAction == ACTION_ATTACKMON) {
x = abs(player.position.future.x - monster->position.future.x); x = abs(player.position.future.x - monster->position.future.x);
@ -1633,7 +1631,7 @@ void CheckNewPath(int pnum, bool pmWillBeCalled)
} }
break; break;
case ACTION_PICKUPITEM: case ACTION_PICKUPITEM:
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
x = abs(player.position.tile.x - item->position.x); x = abs(player.position.tile.x - item->position.x);
y = abs(player.position.tile.y - item->position.y); y = abs(player.position.tile.y - item->position.y);
if (x <= 1 && y <= 1 && pcurs == CURSOR_HAND && !item->_iRequest) { if (x <= 1 && y <= 1 && pcurs == CURSOR_HAND && !item->_iRequest) {
@ -1643,7 +1641,7 @@ void CheckNewPath(int pnum, bool pmWillBeCalled)
} }
break; break;
case ACTION_PICKUPAITEM: case ACTION_PICKUPAITEM:
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
x = abs(player.position.tile.x - item->position.x); x = abs(player.position.tile.x - item->position.x);
y = abs(player.position.tile.y - item->position.y); y = abs(player.position.tile.y - item->position.y);
if (x <= 1 && y <= 1 && pcurs == CURSOR_HAND) { if (x <= 1 && y <= 1 && pcurs == CURSOR_HAND) {
@ -1652,7 +1650,7 @@ void CheckNewPath(int pnum, bool pmWillBeCalled)
} }
break; break;
case ACTION_TALK: case ACTION_TALK:
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
TalkToTowner(player, player.destParam1); TalkToTowner(player, player.destParam1);
} }
break; break;
@ -2847,14 +2845,14 @@ void FixPlayerLocation(Player &player, Direction bDir)
ChangeVisionXY(player._pvid, player.position.tile); ChangeVisionXY(player._pvid, player.position.tile);
} }
void StartStand(int pnum, Direction dir) void StartStand(size_t pnum, Direction dir)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartStand: illegal player %i", pnum); app_fatal("StartStand: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -2867,14 +2865,14 @@ void StartStand(int pnum, Direction dir)
SetPlayerOld(player); SetPlayerOld(player);
} }
void StartPlrBlock(int pnum, Direction dir) void StartPlrBlock(size_t pnum, Direction dir)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartPlrBlock: illegal player %i", pnum); app_fatal("StartPlrBlock: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -2893,10 +2891,10 @@ void StartPlrBlock(int pnum, Direction dir)
SetPlayerOld(player); SetPlayerOld(player);
} }
void FixPlrWalkTags(int pnum) void FixPlrWalkTags(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("FixPlrWalkTags: illegal player %i", pnum); app_fatal("FixPlrWalkTags: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -2913,7 +2911,7 @@ void FixPlrWalkTags(int pnum)
} }
} }
void RemovePlrFromMap(int pnum) void RemovePlrFromMap(size_t pnum)
{ {
int pp = pnum + 1; int pp = pnum + 1;
int pn = -(pnum + 1); int pn = -(pnum + 1);
@ -2925,14 +2923,14 @@ void RemovePlrFromMap(int pnum)
} }
} }
void StartPlrHit(int pnum, int dam, bool forcehit) void StartPlrHit(size_t pnum, int dam, bool forcehit)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartPlrHit: illegal player %i", pnum); app_fatal("StartPlrHit: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
if (player._pInvincible && player._pHitPoints == 0 && pnum == static_cast<int>(MyPlayerId)) { if (player._pInvincible && player._pHitPoints == 0 && pnum == MyPlayerId) {
SyncPlrKill(pnum, -1); SyncPlrKill(pnum, -1);
return; return;
} }
@ -2977,10 +2975,10 @@ void StartPlrHit(int pnum, int dam, bool forcehit)
__attribute__((no_sanitize("shift-base"))) __attribute__((no_sanitize("shift-base")))
#endif #endif
void void
StartPlayerKill(int pnum, int earflag) StartPlayerKill(size_t pnum, int earflag)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartPlayerKill: illegal player %i", pnum); app_fatal("StartPlayerKill: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -2988,7 +2986,7 @@ StartPlayerKill(int pnum, int earflag)
return; return;
} }
if (static_cast<int>(MyPlayerId) == pnum) { if (MyPlayerId == pnum) {
NetSendCmdParam1(true, CMD_PLRDEAD, earflag); NetSendCmdParam1(true, CMD_PLRDEAD, earflag);
} }
@ -3012,7 +3010,7 @@ StartPlayerKill(int pnum, int earflag)
player._pInvincible = true; player._pInvincible = true;
SetPlayerHitPoints(player, 0); SetPlayerHitPoints(player, 0);
if (pnum != static_cast<int>(MyPlayerId) && earflag == 0 && !diablolevel) { if (pnum != MyPlayerId && earflag == 0 && !diablolevel) {
for (auto &item : player.InvBody) { for (auto &item : player.InvBody) {
item.clear(); item.clear();
} }
@ -3025,7 +3023,7 @@ StartPlayerKill(int pnum, int earflag)
dFlags[player.position.tile.x][player.position.tile.y] |= DungeonFlag::DeadPlayer; dFlags[player.position.tile.x][player.position.tile.y] |= DungeonFlag::DeadPlayer;
SetPlayerOld(player); SetPlayerOld(player);
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
drawhpflag = true; drawhpflag = true;
if (!player.HoldItem.isEmpty()) { if (!player.HoldItem.isEmpty()) {
@ -3097,7 +3095,7 @@ void StripTopGold(Player &player)
player._pGold = CalculateGold(player); player._pGold = CalculateGold(player);
} }
void ApplyPlrDamage(int pnum, int dam, int minHP /*= 0*/, int frac /*= 0*/, int earflag /*= 0*/) void ApplyPlrDamage(size_t pnum, int dam, int minHP /*= 0*/, int frac /*= 0*/, int earflag /*= 0*/)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3107,7 +3105,7 @@ void ApplyPlrDamage(int pnum, int dam, int minHP /*= 0*/, int frac /*= 0*/, int
if (manaShieldLevel > 0) { if (manaShieldLevel > 0) {
totalDamage += totalDamage / -player.GetManaShieldDamageReduction(); totalDamage += totalDamage / -player.GetManaShieldDamageReduction();
} }
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
drawmanaflag = true; drawmanaflag = true;
if (player._pMana >= totalDamage) { if (player._pMana >= totalDamage) {
player._pMana -= totalDamage; player._pMana -= totalDamage;
@ -3120,7 +3118,7 @@ void ApplyPlrDamage(int pnum, int dam, int minHP /*= 0*/, int frac /*= 0*/, int
} }
player._pMana = 0; player._pMana = 0;
player._pManaBase = player._pMaxManaBase - player._pMaxMana; player._pManaBase = player._pMaxManaBase - player._pMaxMana;
if (pnum == static_cast<int>(MyPlayerId)) if (pnum == MyPlayerId)
NetSendCmd(true, CMD_REMSHIELD); NetSendCmd(true, CMD_REMSHIELD);
} }
} }
@ -3144,7 +3142,7 @@ void ApplyPlrDamage(int pnum, int dam, int minHP /*= 0*/, int frac /*= 0*/, int
} }
} }
void SyncPlrKill(int pnum, int earflag) void SyncPlrKill(size_t pnum, int earflag)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3157,9 +3155,9 @@ void SyncPlrKill(int pnum, int earflag)
StartPlayerKill(pnum, earflag); StartPlayerKill(pnum, earflag);
} }
void RemovePlrMissiles(int pnum) void RemovePlrMissiles(size_t pnum)
{ {
if (leveltype != DTYPE_TOWN && pnum == static_cast<int>(MyPlayerId)) { if (leveltype != DTYPE_TOWN && pnum == MyPlayerId) {
auto &golem = Monsters[MyPlayerId]; auto &golem = Monsters[MyPlayerId];
if (golem.position.tile.x != 1 || golem.position.tile.y != 0) { if (golem.position.tile.x != 1 || golem.position.tile.y != 0) {
M_StartKill(MyPlayerId, MyPlayerId); M_StartKill(MyPlayerId, MyPlayerId);
@ -3173,7 +3171,7 @@ void RemovePlrMissiles(int pnum)
} }
for (auto &missile : Missiles) { for (auto &missile : Missiles) {
if (missile._mitype == MIS_STONE && missile._misource == pnum) { if (missile._mitype == MIS_STONE && static_cast<size_t>(missile._misource) == pnum) {
Monsters[missile.var2]._mmode = static_cast<MonsterMode>(missile.var1); Monsters[missile.var2]._mmode = static_cast<MonsterMode>(missile.var1);
} }
} }
@ -3183,12 +3181,12 @@ void RemovePlrMissiles(int pnum)
__attribute__((no_sanitize("shift-base"))) __attribute__((no_sanitize("shift-base")))
#endif #endif
void void
StartNewLvl(int pnum, interface_mode fom, int lvl) StartNewLvl(size_t pnum, interface_mode fom, int lvl)
{ {
InitLevelChange(pnum); InitLevelChange(pnum);
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("StartNewLvl: illegal player %i", pnum); app_fatal("StartNewLvl: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
Player &myPlayer = *MyPlayer; Player &myPlayer = *MyPlayer;
@ -3214,7 +3212,7 @@ StartNewLvl(int pnum, interface_mode fom, int lvl)
app_fatal("StartNewLvl"); app_fatal("StartNewLvl");
} }
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
player._pmode = PM_NEWLVL; player._pmode = PM_NEWLVL;
player._pInvincible = true; player._pInvincible = true;
PostMessage(fom, 0, 0); PostMessage(fom, 0, 0);
@ -3224,11 +3222,11 @@ StartNewLvl(int pnum, interface_mode fom, int lvl)
} }
} }
void RestartTownLvl(int pnum) void RestartTownLvl(size_t pnum)
{ {
InitLevelChange(pnum); InitLevelChange(pnum);
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("RestartTownLvl: illegal player %i", pnum); app_fatal("RestartTownLvl: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3242,14 +3240,14 @@ void RestartTownLvl(int pnum)
CalcPlrInv(player, false); CalcPlrInv(player, false);
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
player._pmode = PM_NEWLVL; player._pmode = PM_NEWLVL;
player._pInvincible = true; player._pInvincible = true;
PostMessage(WM_DIABRETOWN, 0, 0); PostMessage(WM_DIABRETOWN, 0, 0);
} }
} }
void StartWarpLvl(int pnum, int pidx) void StartWarpLvl(size_t pnum, uint16_t pidx)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3266,7 +3264,7 @@ void StartWarpLvl(int pnum, int pidx)
} }
} }
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
SetCurrentPortal(pidx); SetCurrentPortal(pidx);
player._pmode = PM_NEWLVL; player._pmode = PM_NEWLVL;
player._pInvincible = true; player._pInvincible = true;
@ -3586,7 +3584,7 @@ void SyncPlrAnim(Player &player)
ScrollViewPort(player, WalkSettings[static_cast<size_t>(player._pdir)].scrollDir); ScrollViewPort(player, WalkSettings[static_cast<size_t>(player._pdir)].scrollDir);
} }
void SyncInitPlrPos(int pnum) void SyncInitPlrPos(size_t pnum)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -3615,22 +3613,22 @@ void SyncInitPlrPos(int pnum)
player.position.tile = position; player.position.tile = position;
dPlayer[position.x][position.y] = pnum + 1; dPlayer[position.x][position.y] = pnum + 1;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
player.position.future = position; player.position.future = position;
ViewPosition = position; ViewPosition = position;
} }
} }
void SyncInitPlr(int pnum) void SyncInitPlr(size_t pnum)
{ {
if ((DWORD)pnum >= MAX_PLRS) { if (pnum >= MAX_PLRS) {
app_fatal("SyncInitPlr: illegal player %i", pnum); app_fatal("SyncInitPlr: illegal player %lu", pnum);
} }
Player &player = Players[pnum]; Player &player = Players[pnum];
SetPlrAnims(player); SetPlrAnims(player);
SyncInitPlrPos(pnum); SyncInitPlrPos(pnum);
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
player._plid = NO_LIGHT; player._plid = NO_LIGHT;
} }
@ -3845,7 +3843,7 @@ void PlayDungMsgs()
} }
#ifdef BUILD_TESTING #ifdef BUILD_TESTING
bool TestPlayerDoGotHit(int pnum) bool TestPlayerDoGotHit(size_t pnum)
{ {
return DoGotHit(pnum); return DoGotHit(pnum);
} }

28
Source/player.h

@ -763,28 +763,28 @@ void NextPlrLevel(Player &player);
#endif #endif
void AddPlrExperience(Player &player, int lvl, int exp); void AddPlrExperience(Player &player, int lvl, int exp);
void AddPlrMonstExper(int lvl, int exp, char pmask); void AddPlrMonstExper(int lvl, int exp, char pmask);
void ApplyPlrDamage(int pnum, int dam, int minHP = 0, int frac = 0, int earflag = 0); void ApplyPlrDamage(size_t pnum, int dam, int minHP = 0, int frac = 0, int earflag = 0);
void InitPlayer(Player &player, bool FirstTime); void InitPlayer(Player &player, bool FirstTime);
void InitMultiView(); void InitMultiView();
void PlrClrTrans(Point position); void PlrClrTrans(Point position);
void PlrDoTrans(Point position); void PlrDoTrans(Point position);
void SetPlayerOld(Player &player); void SetPlayerOld(Player &player);
void FixPlayerLocation(Player &player, Direction bDir); void FixPlayerLocation(Player &player, Direction bDir);
void StartStand(int pnum, Direction dir); void StartStand(size_t pnum, Direction dir);
void StartPlrBlock(int pnum, Direction dir); void StartPlrBlock(size_t pnum, Direction dir);
void FixPlrWalkTags(int pnum); void FixPlrWalkTags(size_t pnum);
void RemovePlrFromMap(int pnum); void RemovePlrFromMap(size_t pnum);
void StartPlrHit(int pnum, int dam, bool forcehit); void StartPlrHit(size_t pnum, int dam, bool forcehit);
void StartPlayerKill(int pnum, int earflag); void StartPlayerKill(size_t pnum, int earflag);
/** /**
* @brief Strip the top off gold piles that are larger than MaxGold * @brief Strip the top off gold piles that are larger than MaxGold
*/ */
void StripTopGold(Player &player); void StripTopGold(Player &player);
void SyncPlrKill(int pnum, int earflag); void SyncPlrKill(size_t pnum, int earflag);
void RemovePlrMissiles(int pnum); void RemovePlrMissiles(size_t pnum);
void StartNewLvl(int pnum, interface_mode fom, int lvl); void StartNewLvl(size_t pnum, interface_mode fom, int lvl);
void RestartTownLvl(int pnum); void RestartTownLvl(size_t pnum);
void StartWarpLvl(int pnum, int pidx); void StartWarpLvl(size_t pnum, uint16_t pidx);
void ProcessPlayers(); void ProcessPlayers();
void ClrPlrPath(Player &player); void ClrPlrPath(Player &player);
bool PosOkPlayer(const Player &player, Point position); bool PosOkPlayer(const Player &player, Point position);
@ -792,8 +792,8 @@ void MakePlrPath(Player &player, Point targetPosition, bool endspace);
void CalcPlrStaff(Player &player); void CalcPlrStaff(Player &player);
void CheckPlrSpell(bool isShiftHeld, spell_id spellID = MyPlayer->_pRSpell, spell_type spellType = MyPlayer->_pRSplType); void CheckPlrSpell(bool isShiftHeld, spell_id spellID = MyPlayer->_pRSpell, spell_type spellType = MyPlayer->_pRSplType);
void SyncPlrAnim(Player &player); void SyncPlrAnim(Player &player);
void SyncInitPlrPos(int pnum); void SyncInitPlrPos(size_t pnum);
void SyncInitPlr(int pnum); void SyncInitPlr(size_t pnum);
void CheckStats(Player &player); void CheckStats(Player &player);
void ModifyPlrStr(Player &player, int l); void ModifyPlrStr(Player &player, int l);
void ModifyPlrMag(Player &player, int l); void ModifyPlrMag(Player &player, int l);

8
Source/portal.cpp

@ -19,7 +19,7 @@ Portal Portals[MAXPORTAL];
namespace { namespace {
/** Current portal number (a portal array index). */ /** Current portal number (a portal array index). */
int portalindex; uint16_t portalindex;
/** Coordinate of each players portal in town. */ /** Coordinate of each players portal in town. */
Point WarpDrop[MAXPORTAL] = { Point WarpDrop[MAXPORTAL] = {
@ -124,7 +124,7 @@ void RemovePortalMissile(int id)
}); });
} }
void SetCurrentPortal(int p) void SetCurrentPortal(uint16_t p)
{ {
portalindex = p; portalindex = p;
} }
@ -152,7 +152,7 @@ void GetPortalLevel()
leveltype = Portals[portalindex].ltype; leveltype = Portals[portalindex].ltype;
} }
if (portalindex == static_cast<int>(MyPlayerId)) { if (portalindex == MyPlayerId) {
NetSendCmd(true, CMD_DEACTIVATEPORTAL); NetSendCmd(true, CMD_DEACTIVATEPORTAL);
DeactivatePortal(portalindex); DeactivatePortal(portalindex);
} }
@ -165,7 +165,7 @@ void GetPortalLvlPos()
} else { } else {
ViewPosition = Portals[portalindex].position; ViewPosition = Portals[portalindex].position;
if (portalindex != static_cast<int>(MyPlayerId)) { if (portalindex != MyPlayerId) {
ViewPosition.x++; ViewPosition.x++;
ViewPosition.y++; ViewPosition.y++;
} }

2
Source/portal.h

@ -31,7 +31,7 @@ void ActivatePortal(int i, Point position, int lvl, dungeon_type lvltype, bool s
void DeactivatePortal(int i); void DeactivatePortal(int i);
bool PortalOnLevel(int i); bool PortalOnLevel(int i);
void RemovePortalMissile(int id); void RemovePortalMissile(int id);
void SetCurrentPortal(int p); void SetCurrentPortal(uint16_t p);
void GetPortalLevel(); void GetPortalLevel();
void GetPortalLvlPos(); void GetPortalLvlPos();
bool PosOkPortal(int lvl, int x, int y); bool PosOkPortal(int lvl, int x, int y);

4
Source/qol/autopickup.cpp

@ -73,9 +73,9 @@ bool DoPickup(Item item)
} // namespace } // namespace
void AutoPickup(int pnum) void AutoPickup(size_t pnum)
{ {
if (pnum != static_cast<int>(MyPlayerId)) if (pnum != MyPlayerId)
return; return;
if (leveltype == DTYPE_TOWN && !*sgOptions.Gameplay.autoPickupInTown) if (leveltype == DTYPE_TOWN && !*sgOptions.Gameplay.autoPickupInTown)
return; return;

2
Source/qol/autopickup.h

@ -8,6 +8,6 @@
namespace devilution { namespace devilution {
void AutoPickup(int pnum); void AutoPickup(size_t pnum);
} // namespace devilution } // namespace devilution

12
Source/spells.cpp

@ -64,7 +64,7 @@ void ClearReadiedSpell(Player &player)
} }
} }
void PlacePlayer(int pnum) void PlacePlayer(size_t pnum)
{ {
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -100,7 +100,7 @@ void PlacePlayer(int pnum)
dPlayer[newPosition.x][newPosition.y] = pnum + 1; dPlayer[newPosition.x][newPosition.y] = pnum + 1;
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
ViewPosition = newPosition; ViewPosition = newPosition;
} }
} }
@ -166,11 +166,11 @@ int GetManaAmount(Player &player, spell_id sn)
return ma; return ma;
} }
void UseMana(int id, spell_id sn) void UseMana(size_t id, spell_id sn)
{ {
int ma; // mana cost int ma; // mana cost
if (id != static_cast<int>(MyPlayerId)) if (id != MyPlayerId)
return; return;
Player &myPlayer = *MyPlayer; Player &myPlayer = *MyPlayer;
@ -254,9 +254,9 @@ void CastSpell(int id, spell_id spl, int sx, int sy, int dx, int dy, int spllvl)
} }
} }
void DoResurrect(int pnum, uint16_t rid) void DoResurrect(size_t pnum, size_t rid)
{ {
if ((DWORD)pnum >= MAX_PLRS || rid >= MAX_PLRS) { if (pnum >= MAX_PLRS || rid >= MAX_PLRS) {
return; return;
} }

4
Source/spells.h

@ -19,7 +19,7 @@ enum class SpellCheckResult : uint8_t {
bool IsWallSpell(spell_id spl); bool IsWallSpell(spell_id spl);
bool TargetsMonster(spell_id id); bool TargetsMonster(spell_id id);
int GetManaAmount(Player &player, spell_id sn); int GetManaAmount(Player &player, spell_id sn);
void UseMana(int id, spell_id sn); void UseMana(size_t id, spell_id sn);
SpellCheckResult CheckSpell(int id, spell_id sn, spell_type st, bool manaonly); SpellCheckResult CheckSpell(int id, spell_id sn, spell_type st, bool manaonly);
/** /**
@ -36,7 +36,7 @@ void CastSpell(int id, spell_id spl, int sx, int sy, int dx, int dy, int spllvl)
* @param pnum player index * @param pnum player index
* @param rid target player index * @param rid target player index
*/ */
void DoResurrect(int pnum, uint16_t rid); void DoResurrect(size_t pnum, size_t rid);
void DoHealOther(const Player &caster, Player &target); void DoHealOther(const Player &caster, Player &target);
int GetSpellBookLevel(spell_id s); int GetSpellBookLevel(spell_id s);
int GetSpellStaffLevel(spell_id s); int GetSpellStaffLevel(spell_id s);

2
Source/storm/storm_net.cpp

@ -38,7 +38,7 @@ void SErrSetLastError(uint32_t dwErrCode)
dwLastError = dwErrCode; dwLastError = dwErrCode;
} }
bool SNetReceiveMessage(int *senderplayerid, void **data, uint32_t *databytes) bool SNetReceiveMessage(size_t *senderplayerid, void **data, uint32_t *databytes)
{ {
#ifndef NONET #ifndef NONET
std::lock_guard<SdlMutex> lg(storm_net_mutex); std::lock_guard<SdlMutex> lg(storm_net_mutex);

2
Source/storm/storm_net.hpp

@ -112,7 +112,7 @@ bool SNetJoinGame(char *gameName, char *gamePassword, int *playerid);
*/ */
bool SNetLeaveGame(int type); bool SNetLeaveGame(int type);
bool SNetReceiveMessage(int *senderplayerid, void **data, uint32_t *databytes); bool SNetReceiveMessage(size_t *senderplayerid, void **data, uint32_t *databytes);
bool SNetReceiveTurns(int arraysize, char **arraydata, size_t *arraydatabytes, uint32_t *arrayplayerstatus); bool SNetReceiveTurns(int arraysize, char **arraydata, size_t *arraydatabytes, uint32_t *arrayplayerstatus);
typedef void (*SEVTHANDLER)(struct _SNETEVENT *); typedef void (*SEVTHANDLER)(struct _SNETEVENT *);

6
Source/sync.cpp

@ -286,7 +286,7 @@ uint32_t sync_all_monsters(byte *pbBuf, uint32_t dwMaxLen)
return dwMaxLen; return dwMaxLen;
} }
uint32_t OnSyncData(const TCmd *pCmd, int pnum) uint32_t OnSyncData(const TCmd *pCmd, size_t pnum)
{ {
const auto &header = *reinterpret_cast<const TSyncHeader *>(pCmd); const auto &header = *reinterpret_cast<const TSyncHeader *>(pCmd);
@ -295,7 +295,7 @@ uint32_t OnSyncData(const TCmd *pCmd, int pnum)
if (gbBufferMsgs == 1) { if (gbBufferMsgs == 1) {
return header.wLen + sizeof(header); return header.wLen + sizeof(header);
} }
if (pnum == static_cast<int>(MyPlayerId)) { if (pnum == MyPlayerId) {
return header.wLen + sizeof(header); return header.wLen + sizeof(header);
} }
@ -312,7 +312,7 @@ uint32_t OnSyncData(const TCmd *pCmd, int pnum)
continue; continue;
if (GetLevelForMultiplayer(*MyPlayer) == level) { if (GetLevelForMultiplayer(*MyPlayer) == level) {
SyncMonster(pnum > static_cast<int>(MyPlayerId), monsterSyncs[i]); SyncMonster(pnum > MyPlayerId, monsterSyncs[i]);
} }
delta_sync_monster(monsterSyncs[i], level); delta_sync_monster(monsterSyncs[i], level);

2
Source/sync.h

@ -12,7 +12,7 @@
namespace devilution { namespace devilution {
uint32_t sync_all_monsters(byte *pbBuf, uint32_t dwMaxLen); uint32_t sync_all_monsters(byte *pbBuf, uint32_t dwMaxLen);
uint32_t OnSyncData(const TCmd *pCmd, int pnum); uint32_t OnSyncData(const TCmd *pCmd, size_t pnum);
void sync_init(); void sync_init();
} // namespace devilution } // namespace devilution

8
test/player_test.cpp

@ -5,10 +5,10 @@
using namespace devilution; using namespace devilution;
namespace devilution { namespace devilution {
extern bool TestPlayerDoGotHit(int pnum); extern bool TestPlayerDoGotHit(size_t pnum);
} }
int RunBlockTest(int frames, ItemSpecialEffect flags) size_t RunBlockTest(int frames, ItemSpecialEffect flags)
{ {
int pnum = 0; int pnum = 0;
Player &player = Players[pnum]; Player &player = Players[pnum];
@ -17,7 +17,7 @@ int RunBlockTest(int frames, ItemSpecialEffect flags)
player._pIFlags = flags; player._pIFlags = flags;
StartPlrHit(pnum, 5, false); StartPlrHit(pnum, 5, false);
int i = 1; size_t i = 1;
for (; i < 100; i++) { for (; i < 100; i++) {
TestPlayerDoGotHit(pnum); TestPlayerDoGotHit(pnum);
if (player._pmode != PM_GOTHIT) if (player._pmode != PM_GOTHIT)
@ -42,7 +42,7 @@ constexpr int Rogue = 7;
constexpr int Sorcerer = 8; constexpr int Sorcerer = 8;
struct BlockTestCase { struct BlockTestCase {
int expectedRecoveryFrame; size_t expectedRecoveryFrame;
int maxRecoveryFrame; int maxRecoveryFrame;
ItemSpecialEffect itemFlags; ItemSpecialEffect itemFlags;
}; };

Loading…
Cancel
Save