From 842b23803f92af44f71e7f74203e8b8a529e9c2d Mon Sep 17 00:00:00 2001 From: Gleb Mazovetskiy Date: Sun, 5 Oct 2025 22:47:52 +0100 Subject: [PATCH] SDL3: Use endianness swap helpers throughout --- Source/items/validation.cpp | 3 +- Source/levels/reencode_dun_cels.cpp | 19 +- Source/levels/town.cpp | 19 +- Source/loadsave.cpp | 13 +- Source/monster.cpp | 8 +- Source/msg.cpp | 295 ++++++++++++++-------------- Source/multi.cpp | 58 +++--- Source/pack.cpp | 205 +++++++++---------- Source/pfile.cpp | 5 +- Source/sync.cpp | 29 +-- Source/utils/endian_swap.hpp | 40 +++- Source/utils/language.cpp | 17 +- Source/utils/surface_to_pcx.cpp | 68 +++++-- Source/utils/surface_to_pcx.hpp | 15 +- test/drlg_test.hpp | 5 +- test/pack_test.cpp | 41 ++-- test/writehero_test.cpp | 37 ++-- 17 files changed, 497 insertions(+), 380 deletions(-) diff --git a/Source/items/validation.cpp b/Source/items/validation.cpp index 53ba9d25f..a6d4e6dbd 100644 --- a/Source/items/validation.cpp +++ b/Source/items/validation.cpp @@ -13,6 +13,7 @@ #include "msg.h" #include "player.h" #include "spells.h" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" namespace devilution { @@ -184,7 +185,7 @@ bool IsItemDeltaValid(const TCmdPItem &itemDelta) return false; if (!InDungeonBounds({ itemDelta.x, itemDelta.y })) return false; - const _item_indexes idx = static_cast<_item_indexes>(SDL_SwapLE16(itemDelta.def.wIndx)); + const _item_indexes idx = static_cast<_item_indexes>(Swap16LE(itemDelta.def.wIndx)); if (idx == IDI_EAR) return true; if (!IsItemAvailable(idx)) diff --git a/Source/levels/reencode_dun_cels.cpp b/Source/levels/reencode_dun_cels.cpp index d0b095259..a8244df98 100644 --- a/Source/levels/reencode_dun_cels.cpp +++ b/Source/levels/reencode_dun_cels.cpp @@ -9,11 +9,10 @@ #include #include -#include - #include "levels/dun_tile.hpp" #include "utils/attributes.h" #include "utils/endian_read.hpp" +#include "utils/endian_swap.hpp" #include "utils/endian_write.hpp" #include "utils/format_int.hpp" #include "utils/log.hpp" @@ -208,7 +207,7 @@ size_t GetReencodedSize(const uint8_t *dungeonCels, std::span &dungeonCels, std::span result { new std::byte[outSize] }; @@ -259,7 +258,7 @@ void ReencodeDungeonCels(std::unique_ptr &dungeonCels, std::span(out - resultPtr)); lookup += 4; - const uint32_t srcFrameBegin = SDL_SwapLE32(srcOffsets[frame]); + const uint32_t srcFrameBegin = Swap32LE(srcOffsets[frame]); const uint8_t *src = &srcData[srcFrameBegin]; switch (info.type) { case TileType::TransparentSquare: { @@ -268,7 +267,7 @@ void ReencodeDungeonCels(std::unique_ptr &dungeonCels, std::span &dungeonCels, std::span(resultPtr); LogVerbose(" Re-encoded dungeon CELs: {} frames, {} bytes. Extracted {} foliage tiles.", - FormatInteger(SDL_SwapLE32(dstOffsets[0])), - FormatInteger(SDL_SwapLE32(dstOffsets[SDL_SwapLE32(dstOffsets[0]) + 1])), + FormatInteger(Swap32LE(dstOffsets[0])), + FormatInteger(Swap32LE(dstOffsets[Swap32LE(dstOffsets[0]) + 1])), FormatInteger(numFoliage)); dungeonCels = std::move(result); diff --git a/Source/levels/town.cpp b/Source/levels/town.cpp index 1f05631b7..fc1213ddc 100644 --- a/Source/levels/town.cpp +++ b/Source/levels/town.cpp @@ -11,6 +11,7 @@ #include "multi.h" #include "player.h" #include "quests.h" +#include "utils/endian_swap.hpp" namespace devilution { @@ -37,13 +38,13 @@ void FillSector(const char *path, int xi, int yy) int v3 = 218; int v4 = 218; - const int tileId = SDL_SwapLE16(tileLayer[j * size.width + i]) - 1; + const int tileId = Swap16LE(tileLayer[j * size.width + i]) - 1; if (tileId >= 0) { const MegaTile mega = pMegaTiles[tileId]; - v1 = SDL_SwapLE16(mega.micro1); - v2 = SDL_SwapLE16(mega.micro2); - v3 = SDL_SwapLE16(mega.micro3); - v4 = SDL_SwapLE16(mega.micro4); + v1 = Swap16LE(mega.micro1); + v2 = Swap16LE(mega.micro2); + v3 = Swap16LE(mega.micro3); + v4 = Swap16LE(mega.micro4); } dPiece[xx + 0][yy + 0] = v1; @@ -66,10 +67,10 @@ void FillTile(int xx, int yy, int t) { const MegaTile mega = pMegaTiles[t - 1]; - dPiece[xx + 0][yy + 0] = SDL_SwapLE16(mega.micro1); - dPiece[xx + 1][yy + 0] = SDL_SwapLE16(mega.micro2); - dPiece[xx + 0][yy + 1] = SDL_SwapLE16(mega.micro3); - dPiece[xx + 1][yy + 1] = SDL_SwapLE16(mega.micro4); + dPiece[xx + 0][yy + 0] = Swap16LE(mega.micro1); + dPiece[xx + 1][yy + 0] = Swap16LE(mega.micro2); + dPiece[xx + 0][yy + 1] = Swap16LE(mega.micro3); + dPiece[xx + 1][yy + 1] = Swap16LE(mega.micro4); } /** diff --git a/Source/loadsave.cpp b/Source/loadsave.cpp index 7ea7fa254..71c2a5c1f 100644 --- a/Source/loadsave.cpp +++ b/Source/loadsave.cpp @@ -40,6 +40,7 @@ #include "stores.h" #include "utils/algorithm/container.hpp" #include "utils/endian_read.hpp" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" #include "utils/language.h" #include "utils/status_macros.hpp" @@ -62,11 +63,11 @@ T SwapLE(T in) { switch (sizeof(T)) { case 2: - return SDL_SwapLE16(in); + return Swap16LE(in); case 4: - return SDL_SwapLE32(in); + return Swap32LE(in); case 8: - return SDL_SwapLE64(in); + return Swap64LE(in); default: return in; } @@ -77,11 +78,11 @@ T SwapBE(T in) { switch (sizeof(T)) { case 2: - return SDL_SwapBE16(in); + return Swap16BE(in); case 4: - return SDL_SwapBE32(in); + return Swap32BE(in); case 8: - return static_cast(SDL_SwapBE64(in)); + return static_cast(Swap64BE(in)); default: return in; } diff --git a/Source/monster.cpp b/Source/monster.cpp index f8826c956..1e159330e 100644 --- a/Source/monster.cpp +++ b/Source/monster.cpp @@ -24,7 +24,12 @@ #include #include +#ifdef USE_SDL3 +#include +#else #include +#endif + #include #include @@ -85,6 +90,7 @@ #include "utils/algorithm/container.hpp" #include "utils/attributes.h" #include "utils/cl2_to_clx.hpp" +#include "utils/endian_swap.hpp" #include "utils/enum_traits.h" #include "utils/file_name_generator.hpp" #include "utils/is_of.hpp" @@ -3668,7 +3674,7 @@ tl::expected SetMapMonsters(const uint16_t *dunData, Point st for (WorldTileCoord j = 0; j < size.height; j++) { for (WorldTileCoord i = 0; i < size.width; i++) { - auto monsterId = static_cast(SDL_SwapLE16(monsterLayer[j * size.width + i])); + auto monsterId = static_cast(Swap16LE(monsterLayer[j * size.width + i])); if (monsterId != 0) { ASSIGN_OR_RETURN(const size_t typeIndex, AddMonsterType(MonstConvTbl[monsterId - 1], PLACE_SPECIAL)); PlaceMonster(ActiveMonsterCount++, typeIndex, startPosition + Displacement { i, j }); diff --git a/Source/msg.cpp b/Source/msg.cpp index 731c84bb6..14e49252c 100644 --- a/Source/msg.cpp +++ b/Source/msg.cpp @@ -50,6 +50,7 @@ #include "sync.h" #include "tmsg.h" #include "towners.h" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" #include "utils/language.h" #include "utils/str_cat.hpp" @@ -391,7 +392,7 @@ bool WasPlayerCmdAlreadyRequested(_cmd_id bCmd, Point position = {}, uint16_t wP } const TCmdLocParam5 newSendParam = { bCmd, static_cast(position.x), static_cast(position.y), - SDL_SwapLE16(wParam1), SDL_SwapLE16(wParam2), SDL_SwapLE16(wParam3), SDL_SwapLE16(wParam4), SDL_SwapLE16(wParam5) }; + Swap16LE(wParam1), Swap16LE(wParam2), Swap16LE(wParam3), Swap16LE(wParam4), Swap16LE(wParam5) }; if (lastSentPlayerCmd.bCmd == newSendParam.bCmd && lastSentPlayerCmd.x == newSendParam.x && lastSentPlayerCmd.y == newSendParam.y && lastSentPlayerCmd.wParam1 == newSendParam.wParam1 && lastSentPlayerCmd.wParam2 == newSendParam.wParam2 @@ -437,7 +438,7 @@ void PrePacket() auto *cmd = reinterpret_cast(data); data += sizeof(*cmd); remainingBytes -= sizeof(*cmd); - multi_player_left(cmd->bPlr, SDL_SwapLE32(cmd->dwReason)); + multi_player_left(cmd->bPlr, Swap32LE(cmd->dwReason)); continue; } @@ -636,12 +637,12 @@ const std::byte *DeltaImportMonster(const std::byte *src, const std::byte *end, std::byte *DeltaExportSpawnedMonsters(std::byte *dst, const ankerl::unordered_dense::map &spawnedMonsters) { - uint16_t size = SDL_SwapLE16(static_cast(spawnedMonsters.size())); + uint16_t size = Swap16LE(static_cast(spawnedMonsters.size())); memcpy(dst, &size, sizeof(uint16_t)); dst += sizeof(uint16_t); for (const auto &deltaSpawnedMonster : spawnedMonsters) { - uint16_t monsterId = SDL_SwapLE16(static_cast(deltaSpawnedMonster.first)); + uint16_t monsterId = Swap16LE(static_cast(deltaSpawnedMonster.first)); memcpy(dst, &monsterId, sizeof(uint16_t)); dst += sizeof(uint16_t); @@ -659,7 +660,7 @@ const std::byte *DeltaImportSpawnedMonsters(const std::byte *src, const std::byt uint16_t size; memcpy(&size, src, sizeof(uint16_t)); - size = SDL_SwapLE16(size); + size = Swap16LE(size); src += sizeof(uint16_t); if (size > MaxMonsters) return nullptr; @@ -671,7 +672,7 @@ const std::byte *DeltaImportSpawnedMonsters(const std::byte *src, const std::byt for (size_t i = 0; i < size; i++) { uint16_t monsterId; memcpy(&monsterId, src, sizeof(uint16_t)); - monsterId = SDL_SwapLE16(monsterId); + monsterId = Swap16LE(monsterId); src += sizeof(uint16_t); DSpawnedMonster spawnedMonster; @@ -703,7 +704,7 @@ std::byte *DeltaExportJunk(std::byte *dst) sgJunk.quests[q].qstate = quest._qactive; sgJunk.quests[q].qvar1 = quest._qvar1; sgJunk.quests[q].qvar2 = quest._qvar2; - sgJunk.quests[q].qmsg = SDL_SwapLE16(static_cast(quest._qmsg)); + sgJunk.quests[q].qmsg = Swap16LE(static_cast(quest._qmsg)); memcpy(dst, &sgJunk.quests[q], sizeof(MultiQuests)); dst += sizeof(MultiQuests); q++; @@ -856,7 +857,7 @@ void DeltaLoadMonsters(const DLevel &deltaLevel) ChangeLightXY(monster.lightId, position); } - monster.hitPoints = SDL_SwapLE32(deltaMonster.hitPoints); + monster.hitPoints = Swap32LE(deltaMonster.hitPoints); monster.whoHit = deltaMonster.mWhoHit; if (deltaMonster.hitPoints != 0) continue; @@ -923,9 +924,9 @@ void DeltaLoadItems(const DLevel &deltaLevel) if (deltaItem.bCmd == TCmdPItem::PickedUpItem) { const int activeItemIndex = FindGetItem( - SDL_SwapLE32(deltaItem.def.dwSeed), - static_cast<_item_indexes>(SDL_SwapLE16(deltaItem.def.wIndx)), - SDL_SwapLE16(deltaItem.def.wCI)); + Swap32LE(deltaItem.def.dwSeed), + static_cast<_item_indexes>(Swap16LE(deltaItem.def.wIndx)), + Swap16LE(deltaItem.def.wCI)); if (activeItemIndex != -1) { const auto &position = Items[ActiveItems[activeItemIndex]].position; if (dItem[position.x][position.y] == ActiveItems[activeItemIndex] + 1) @@ -949,8 +950,8 @@ void DeltaLoadItems(const DLevel &deltaLevel) size_t OnLevelData(const TCmdPlrInfoHdr &message, size_t maxCmdSize, const Player &player) { - const uint16_t wBytes = SDL_SwapLE16(message.wBytes); - const uint16_t wOffset = SDL_SwapLE16(message.wOffset); + const uint16_t wBytes = Swap16LE(message.wBytes); + const uint16_t wOffset = Swap16LE(message.wOffset); if (!ValidateCmdSize(wBytes + sizeof(message), maxCmdSize, player.getId())) return maxCmdSize; @@ -1151,8 +1152,8 @@ void NetSendCmdGItem2(bool usonly, _cmd_id bCmd, uint8_t mast, uint8_t pnum, con auto ticks = static_cast(SDL_GetTicks()); if (cmd.dwTime == 0) { - cmd.dwTime = SDL_SwapLE32(ticks); - } else if (ticks - SDL_SwapLE32(cmd.dwTime) > 5000) { + cmd.dwTime = Swap32LE(ticks); + } else if (ticks - Swap32LE(cmd.dwTime) > 5000) { return; } @@ -1170,8 +1171,8 @@ bool NetSendCmdReq2(_cmd_id bCmd, const Player &player, uint8_t pnum, const TCmd auto ticks = static_cast(SDL_GetTicks()); if (cmd.dwTime == 0) - cmd.dwTime = SDL_SwapLE32(ticks); - else if (ticks - SDL_SwapLE32(cmd.dwTime) > 5000) + cmd.dwTime = Swap32LE(ticks); + else if (ticks - Swap32LE(cmd.dwTime) > 5000) return false; tmsg_add(reinterpret_cast(&cmd), sizeof(cmd)); @@ -1207,7 +1208,7 @@ size_t OnAddStrength(const TCmdParam1 &message, Player &player) if (gbBufferMsgs == 1) BufferMessage(player, &message, sizeof(message)); else if (message.wParam1 <= 256) - ModifyPlrStr(player, SDL_SwapLE16(message.wParam1)); + ModifyPlrStr(player, Swap16LE(message.wParam1)); return sizeof(message); } @@ -1217,7 +1218,7 @@ size_t OnAddMagic(const TCmdParam1 &message, Player &player) if (gbBufferMsgs == 1) BufferMessage(player, &message, sizeof(message)); else if (message.wParam1 <= 256) - ModifyPlrMag(player, SDL_SwapLE16(message.wParam1)); + ModifyPlrMag(player, Swap16LE(message.wParam1)); return sizeof(message); } @@ -1227,7 +1228,7 @@ size_t OnAddDexterity(const TCmdParam1 &message, Player &player) if (gbBufferMsgs == 1) BufferMessage(player, &message, sizeof(message)); else if (message.wParam1 <= 256) - ModifyPlrDex(player, SDL_SwapLE16(message.wParam1)); + ModifyPlrDex(player, Swap16LE(message.wParam1)); return sizeof(message); } @@ -1237,7 +1238,7 @@ size_t OnAddVitality(const TCmdParam1 &message, Player &player) if (gbBufferMsgs == 1) BufferMessage(player, &message, sizeof(message)); else if (message.wParam1 <= 256) - ModifyPlrVit(player, SDL_SwapLE16(message.wParam1)); + ModifyPlrVit(player, Swap16LE(message.wParam1)); return sizeof(message); } @@ -1246,10 +1247,10 @@ size_t OnGotoGetItem(const TCmdLocParam1 &message, Player &player) { const Point position { message.x, message.y }; - if (gbBufferMsgs != 1 && player.isOnActiveLevel() && InDungeonBounds(position) && SDL_SwapLE16(message.wParam1) < MAXITEMS + 1) { + if (gbBufferMsgs != 1 && player.isOnActiveLevel() && InDungeonBounds(position) && Swap16LE(message.wParam1) < MAXITEMS + 1) { MakePlrPath(player, position, false); player.destAction = ACTION_PICKUPITEM; - player.destParam1 = SDL_SwapLE16(message.wParam1); + player.destParam1 = Swap16LE(message.wParam1); } return sizeof(message); @@ -1269,7 +1270,7 @@ bool IsGItemValid(const TCmdGItem &message) if (!InDungeonBounds({ message.x, message.y })) return false; - return IsItemAvailable(static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx))); + return IsItemAvailable(static_cast<_item_indexes>(Swap16LE(message.def.wIndx))); } bool IsPItemValid(const TCmdPItem &message, const Player &player) @@ -1282,11 +1283,11 @@ bool IsPItemValid(const TCmdPItem &message, const Player &player) if (!InDungeonBounds(position)) return false; - auto idx = static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)); + auto idx = static_cast<_item_indexes>(Swap16LE(message.def.wIndx)); if (idx != IDI_EAR) { - const uint16_t creationFlags = SDL_SwapLE16(message.item.wCI); - const uint32_t dwBuff = SDL_SwapLE16(message.item.dwBuff); + const uint16_t creationFlags = Swap16LE(message.item.wCI); + const uint32_t dwBuff = Swap16LE(message.item.dwBuff); if (idx != IDI_GOLD) ValidateField(creationFlags, IsCreationFlagComboValid(creationFlags)); @@ -1305,9 +1306,9 @@ bool IsPItemValid(const TCmdPItem &message, const Player &player) void PrepareItemForNetwork(const Item &item, TCmdGItem &message) { - message.def.wIndx = static_cast<_item_indexes>(SDL_SwapLE16(item.IDidx)); - message.def.wCI = SDL_SwapLE16(item._iCreateInfo); - message.def.dwSeed = SDL_SwapLE32(item._iSeed); + message.def.wIndx = static_cast<_item_indexes>(Swap16LE(item.IDidx)); + message.def.wCI = Swap16LE(item._iCreateInfo); + message.def.dwSeed = Swap32LE(item._iSeed); if (item.IDidx == IDI_EAR) PrepareEarForNetwork(item, message.ear); @@ -1317,9 +1318,9 @@ void PrepareItemForNetwork(const Item &item, TCmdGItem &message) void PrepareItemForNetwork(const Item &item, TCmdPItem &message) { - message.def.wIndx = static_cast<_item_indexes>(SDL_SwapLE16(item.IDidx)); - message.def.wCI = SDL_SwapLE16(item._iCreateInfo); - message.def.dwSeed = SDL_SwapLE32(item._iSeed); + message.def.wIndx = static_cast<_item_indexes>(Swap16LE(item.IDidx)); + message.def.wCI = Swap16LE(item._iCreateInfo); + message.def.dwSeed = Swap32LE(item._iSeed); if (item.IDidx == IDI_EAR) PrepareEarForNetwork(item, message.ear); @@ -1329,9 +1330,9 @@ void PrepareItemForNetwork(const Item &item, TCmdPItem &message) void PrepareItemForNetwork(const Item &item, TCmdChItem &message) { - message.def.wIndx = static_cast<_item_indexes>(SDL_SwapLE16(item.IDidx)); - message.def.wCI = SDL_SwapLE16(item._iCreateInfo); - message.def.dwSeed = SDL_SwapLE32(item._iSeed); + message.def.wIndx = static_cast<_item_indexes>(Swap16LE(item.IDidx)); + message.def.wCI = Swap16LE(item._iCreateInfo); + message.def.dwSeed = Swap32LE(item._iSeed); if (item.IDidx == IDI_EAR) PrepareEarForNetwork(item, message.ear); @@ -1341,16 +1342,16 @@ void PrepareItemForNetwork(const Item &item, TCmdChItem &message) void RecreateItem(const Player &player, const TCmdPItem &message, Item &item) { - if (message.def.wIndx == SDL_SwapLE16(IDI_EAR)) - RecreateEar(item, SDL_SwapLE16(message.ear.wCI), SDL_SwapLE32(message.ear.dwSeed), message.ear.bCursval, message.ear.heroname); + if (message.def.wIndx == Swap16LE(IDI_EAR)) + RecreateEar(item, Swap16LE(message.ear.wCI), Swap32LE(message.ear.dwSeed), message.ear.bCursval, message.ear.heroname); else RecreateItem(player, message.item, item); } void RecreateItem(const Player &player, const TCmdChItem &message, Item &item) { - if (message.def.wIndx == SDL_SwapLE16(IDI_EAR)) - RecreateEar(item, SDL_SwapLE16(message.ear.wCI), SDL_SwapLE32(message.ear.dwSeed), message.ear.bCursval, message.ear.heroname); + if (message.def.wIndx == Swap16LE(IDI_EAR)) + RecreateEar(item, Swap16LE(message.ear.wCI), Swap32LE(message.ear.dwSeed), message.ear.bCursval, message.ear.heroname); else RecreateItem(player, message.item, item); } @@ -1359,26 +1360,26 @@ int SyncDropItem(Point position, const TItem &item) { return SyncDropItem( position, - static_cast<_item_indexes>(SDL_SwapLE16(item.wIndx)), - SDL_SwapLE16(item.wCI), - SDL_SwapLE32(item.dwSeed), + static_cast<_item_indexes>(Swap16LE(item.wIndx)), + Swap16LE(item.wCI), + Swap32LE(item.dwSeed), item.bId, item.bDur, item.bMDur, item.bCh, item.bMCh, - SDL_SwapLE16(item.wValue), - SDL_SwapLE32(item.dwBuff), - SDL_SwapLE16(item.wToHit), - SDL_SwapLE16(item.wMaxDam)); + Swap16LE(item.wValue), + Swap32LE(item.dwBuff), + Swap16LE(item.wToHit), + Swap16LE(item.wMaxDam)); } int SyncDropEar(Point position, const TEar &ear) { return SyncDropEar( position, - SDL_SwapLE16(ear.wCI), - SDL_SwapLE32(ear.dwSeed), + Swap16LE(ear.wCI), + Swap32LE(ear.dwSeed), ear.bCursval, ear.heroname); } @@ -1417,9 +1418,9 @@ size_t OnRequestGetItem(const TCmdGItem &message, Player &player) return sizeof(message); const Point position { message.x, message.y }; - const uint32_t dwSeed = SDL_SwapLE32(message.def.dwSeed); - const uint16_t wCI = SDL_SwapLE16(message.def.wCI); - const auto wIndx = static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)); + const uint32_t dwSeed = Swap32LE(message.def.dwSeed); + const uint16_t wCI = Swap16LE(message.def.wCI); + const auto wIndx = static_cast<_item_indexes>(Swap16LE(message.def.wIndx)); if (!GetItemRecord(dwSeed, wCI, wIndx)) return sizeof(message); @@ -1464,9 +1465,9 @@ size_t OnGetItem(const TCmdGItem &message, Player &player) return sizeof(message); const Point position { message.x, message.y }; - const uint32_t dwSeed = SDL_SwapLE32(message.def.dwSeed); - const uint16_t wCI = SDL_SwapLE16(message.def.wCI); - const auto wIndx = static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)); + const uint32_t dwSeed = Swap32LE(message.def.dwSeed); + const uint16_t wCI = Swap16LE(message.def.wCI); + const auto wIndx = static_cast<_item_indexes>(Swap16LE(message.def.wIndx)); if (!DeltaGetItem(message, message.bLevel)) { NetSendCmdGItem2(true, CMD_GETITEM, message.bMaster, message.bPnum, message); return sizeof(message); @@ -1497,7 +1498,7 @@ size_t OnGotoAutoGetItem(const TCmdLocParam1 &message, Player &player) { const Point position { message.x, message.y }; - const uint16_t itemIdx = SDL_SwapLE16(message.wParam1); + const uint16_t itemIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && InDungeonBounds(position) && itemIdx < MAXITEMS + 1) { MakePlrPath(player, position, false); player.destAction = ACTION_PICKUPAITEM; @@ -1511,9 +1512,9 @@ size_t OnRequestAutoGetItem(const TCmdGItem &message, Player &player) { if (gbBufferMsgs != 1 && player.isLevelOwnedByLocalClient() && IsGItemValid(message)) { const Point position { message.x, message.y }; - const uint32_t dwSeed = SDL_SwapLE32(message.def.dwSeed); - const uint16_t wCI = SDL_SwapLE16(message.def.wCI); - const auto wIndx = static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)); + const uint32_t dwSeed = Swap32LE(message.def.dwSeed); + const uint16_t wCI = Swap16LE(message.def.wCI); + const auto wIndx = static_cast<_item_indexes>(Swap16LE(message.def.wIndx)); if (GetItemRecord(dwSeed, wCI, wIndx)) { if (FindGetItem(dwSeed, wIndx, wCI) != -1) { NetSendCmdGItem2(false, CMD_AGETITEM, MyPlayerId, message.bPnum, message); @@ -1552,7 +1553,7 @@ size_t OnAutoGetItem(const TCmdGItem &message, Player &player) return sizeof(message); if (message.bPnum != MyPlayerId) { - SyncGetItem(position, SDL_SwapLE32(message.def.dwSeed), static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)), SDL_SwapLE16(message.def.wCI)); + SyncGetItem(position, Swap32LE(message.def.dwSeed), static_cast<_item_indexes>(Swap16LE(message.def.wIndx)), Swap16LE(message.def.wCI)); return sizeof(message); } @@ -1575,7 +1576,7 @@ size_t OnItemExtra(const TCmdGItem &message, Player &player) DeltaGetItem(message, message.bLevel); if (player.isOnActiveLevel()) { const Point position { message.x, message.y }; - SyncGetItem(position, SDL_SwapLE32(message.def.dwSeed), static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)), SDL_SwapLE16(message.def.wCI)); + SyncGetItem(position, Swap32LE(message.def.dwSeed), static_cast<_item_indexes>(Swap16LE(message.def.wIndx)), Swap16LE(message.def.wCI)); } } @@ -1589,9 +1590,9 @@ size_t OnPutItem(const TCmdPItem &message, Player &player) } else if (IsPItemValid(message, player)) { const Point position { message.x, message.y }; const bool isSelf = &player == MyPlayer; - const int32_t dwSeed = SDL_SwapLE32(message.def.dwSeed); - const uint16_t wCI = SDL_SwapLE16(message.def.wCI); - const auto wIndx = static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)); + const int32_t dwSeed = Swap32LE(message.def.dwSeed); + const uint16_t wCI = Swap16LE(message.def.wCI); + const auto wIndx = static_cast<_item_indexes>(Swap16LE(message.def.wIndx)); if (player.isOnActiveLevel()) { int ii; if (isSelf) { @@ -1624,9 +1625,9 @@ size_t OnSyncPutItem(const TCmdPItem &message, Player &player) if (gbBufferMsgs == 1) BufferMessage(player, &message, sizeof(message)); else if (IsPItemValid(message, player)) { - const int32_t dwSeed = SDL_SwapLE32(message.def.dwSeed); - const uint16_t wCI = SDL_SwapLE16(message.def.wCI); - const auto wIndx = static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)); + const int32_t dwSeed = Swap32LE(message.def.dwSeed); + const uint16_t wCI = Swap16LE(message.def.wCI); + const auto wIndx = static_cast<_item_indexes>(Swap16LE(message.def.wIndx)); if (player.isOnActiveLevel()) { const int ii = SyncDropItem(message); if (ii != -1) { @@ -1690,9 +1691,9 @@ size_t OnRangedAttackTile(const TCmdLoc &message, Player &player) bool InitNewSpell(Player &player, uint16_t wParamSpellID, uint16_t wParamSpellType, uint16_t wParamSpellFrom) { - wParamSpellID = SDL_SwapLE16(wParamSpellID); - wParamSpellType = SDL_SwapLE16(wParamSpellType); - wParamSpellFrom = SDL_SwapLE16(wParamSpellFrom); + wParamSpellID = Swap16LE(wParamSpellID); + wParamSpellType = Swap16LE(wParamSpellType); + wParamSpellFrom = Swap16LE(wParamSpellFrom); if (wParamSpellID > static_cast(SpellID::LAST)) return false; @@ -1732,7 +1733,7 @@ size_t OnSpellWall(const TCmdLocParam4 &message, Player &player) return sizeof(message); if (!InDungeonBounds(position)) return sizeof(message); - const int16_t wParamDirection = SDL_SwapLE16(message.wParam3); + const int16_t wParamDirection = Swap16LE(message.wParam3); if (wParamDirection > static_cast(Direction::SouthEast)) return sizeof(message); @@ -1804,7 +1805,7 @@ size_t OnObjectTileAction(const TCmdLoc &message, Player &player) size_t OnAttackMonster(const TCmdParam1 &message, Player &player) { - const uint16_t monsterIdx = SDL_SwapLE16(message.wParam1); + const uint16_t monsterIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && leveltype != DTYPE_TOWN && monsterIdx < MaxMonsters) { const Point position = Monsters[monsterIdx].position.future; @@ -1819,7 +1820,7 @@ size_t OnAttackMonster(const TCmdParam1 &message, Player &player) size_t OnAttackPlayer(const TCmdParam1 &message, Player &player) { - const uint16_t playerIdx = SDL_SwapLE16(message.wParam1); + const uint16_t playerIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && leveltype != DTYPE_TOWN && playerIdx < Players.size()) { MakePlrPath(player, Players[playerIdx].position.future, false); @@ -1832,7 +1833,7 @@ size_t OnAttackPlayer(const TCmdParam1 &message, Player &player) size_t OnRangedAttackMonster(const TCmdParam1 &message, Player &player) { - const uint16_t monsterIdx = SDL_SwapLE16(message.wParam1); + const uint16_t monsterIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && leveltype != DTYPE_TOWN && monsterIdx < MaxMonsters) { ClrPlrPath(player); @@ -1845,7 +1846,7 @@ size_t OnRangedAttackMonster(const TCmdParam1 &message, Player &player) size_t OnRangedAttackPlayer(const TCmdParam1 &message, Player &player) { - const uint16_t playerIdx = SDL_SwapLE16(message.wParam1); + const uint16_t playerIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && leveltype != DTYPE_TOWN && playerIdx < Players.size()) { ClrPlrPath(player); @@ -1864,7 +1865,7 @@ size_t OnSpellMonster(const TCmdParam4 &message, Player &player) return sizeof(message); if (leveltype == DTYPE_TOWN) return sizeof(message); - const uint16_t monsterIdx = SDL_SwapLE16(message.wParam1); + const uint16_t monsterIdx = Swap16LE(message.wParam1); if (monsterIdx >= MaxMonsters) return sizeof(message); @@ -1885,7 +1886,7 @@ size_t OnSpellPlayer(const TCmdParam4 &message, Player &player) return sizeof(message); if (!player.isOnActiveLevel()) return sizeof(message); - const uint16_t playerIdx = SDL_SwapLE16(message.wParam1); + const uint16_t playerIdx = Swap16LE(message.wParam1); if (playerIdx >= Players.size()) return sizeof(message); @@ -1902,7 +1903,7 @@ size_t OnSpellPlayer(const TCmdParam4 &message, Player &player) size_t OnKnockback(const TCmdParam1 &message, Player &player) { - const uint16_t monsterIdx = SDL_SwapLE16(message.wParam1); + const uint16_t monsterIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && leveltype != DTYPE_TOWN && monsterIdx < MaxMonsters) { Monster &monster = Monsters[monsterIdx]; @@ -1915,7 +1916,7 @@ size_t OnKnockback(const TCmdParam1 &message, Player &player) size_t OnResurrect(const TCmdParam1 &message, Player &player) { - const uint16_t playerIdx = SDL_SwapLE16(message.wParam1); + const uint16_t playerIdx = Swap16LE(message.wParam1); if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); @@ -1930,7 +1931,7 @@ size_t OnResurrect(const TCmdParam1 &message, Player &player) size_t OnHealOther(const TCmdParam1 &message, const Player &caster) { - const uint16_t playerIdx = SDL_SwapLE16(message.wParam1); + const uint16_t playerIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (caster.isOnActiveLevel() && playerIdx < Players.size()) { @@ -1944,7 +1945,7 @@ size_t OnHealOther(const TCmdParam1 &message, const Player &caster) size_t OnTalkXY(const TCmdLocParam1 &message, Player &player) { const Point position { message.x, message.y }; - const uint16_t townerIdx = SDL_SwapLE16(message.wParam1); + const uint16_t townerIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1 && player.isOnActiveLevel() && InDungeonBounds(position) && townerIdx < NUM_TOWNERS) { MakePlrPath(player, position, false); @@ -1957,7 +1958,7 @@ size_t OnTalkXY(const TCmdLocParam1 &message, Player &player) size_t OnNewLevel(const TCmdParam2 &message, Player &player) { - const uint16_t eventIdx = SDL_SwapLE16(message.wParam1); + const uint16_t eventIdx = Swap16LE(message.wParam1); if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); @@ -1967,7 +1968,7 @@ size_t OnNewLevel(const TCmdParam2 &message, Player &player) auto mode = static_cast(eventIdx); - const auto levelId = static_cast(SDL_SwapLE16(message.wParam2)); + const auto levelId = static_cast(Swap16LE(message.wParam2)); if (!IsValidLevel(levelId, mode == WM_DIABSETLVL)) { return sizeof(message); } @@ -1980,7 +1981,7 @@ size_t OnNewLevel(const TCmdParam2 &message, Player &player) size_t OnWarp(const TCmdParam1 &message, Player &player) { - const uint16_t portalIdx = SDL_SwapLE16(message.wParam1); + const uint16_t portalIdx = Swap16LE(message.wParam1); if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); @@ -1994,7 +1995,7 @@ size_t OnWarp(const TCmdParam1 &message, Player &player) size_t OnMonstDeath(const TCmdLocParam1 &message, Player &player) { const Point position { message.x, message.y }; - const uint16_t monsterIdx = SDL_SwapLE16(message.wParam1); + const uint16_t monsterIdx = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (&player != MyPlayer && player.plrlevel > 0 && InDungeonBounds(position) && monsterIdx < MaxMonsters) { @@ -2025,7 +2026,7 @@ size_t OnRequestSpawnGolem(const TCmdLocParam1 &message, const Player &player) size_t OnMonstDamage(const TCmdMonDamage &message, Player &player) { - const uint16_t monsterIdx = SDL_SwapLE16(message.wMon); + const uint16_t monsterIdx = Swap16LE(message.wMon); if (gbBufferMsgs != 1) { if (&player != MyPlayer) { @@ -2033,7 +2034,7 @@ size_t OnMonstDamage(const TCmdMonDamage &message, Player &player) Monster &monster = Monsters[monsterIdx]; monster.tag(player); if (monster.hitPoints > 0) { - monster.hitPoints -= SDL_SwapLE32(message.dwDam); + monster.hitPoints -= Swap32LE(message.dwDam); if ((monster.hitPoints >> 6) < 1) monster.hitPoints = 1 << 6; delta_monster_hp(monster, player); @@ -2049,7 +2050,7 @@ size_t OnMonstDamage(const TCmdMonDamage &message, Player &player) size_t OnPlayerDeath(const TCmdParam1 &message, Player &player) { - const auto deathReason = static_cast(SDL_SwapLE16(message.wParam1)); + const auto deathReason = static_cast(Swap16LE(message.wParam1)); if (gbBufferMsgs != 1) { if (&player != MyPlayer) @@ -2065,7 +2066,7 @@ size_t OnPlayerDeath(const TCmdParam1 &message, Player &player) size_t OnPlayerDamage(const TCmdDamage &message, Player &player) { - const uint32_t damage = SDL_SwapLE32(message.dwDam); + const uint32_t damage = Swap32LE(message.dwDam); Player &target = Players[message.bPlr]; if (&target == MyPlayer && leveltype != DTYPE_TOWN && gbBufferMsgs != 1) { @@ -2126,7 +2127,7 @@ size_t OnChangePlayerItems(const TCmdChItem &message, Player &player) if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); - } else if (&player != MyPlayer && IsItemAvailable(static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)))) { + } else if (&player != MyPlayer && IsItemAvailable(static_cast<_item_indexes>(Swap16LE(message.def.wIndx)))) { Item &item = player.InvBody[message.bLoc]; item = {}; RecreateItem(player, message, item); @@ -2157,7 +2158,7 @@ size_t OnChangeInventoryItems(const TCmdChItem &message, Player &player) if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); - } else if (&player != MyPlayer && IsItemAvailable(static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)))) { + } else if (&player != MyPlayer && IsItemAvailable(static_cast<_item_indexes>(Swap16LE(message.def.wIndx)))) { Item item {}; RecreateItem(player, message, item); CheckInvSwap(player, item, message.bLoc); @@ -2168,7 +2169,7 @@ size_t OnChangeInventoryItems(const TCmdChItem &message, Player &player) size_t OnDeleteInventoryItems(const TCmdParam1 &message, Player &player) { - const uint16_t invGridIndex = SDL_SwapLE16(message.wParam1); + const uint16_t invGridIndex = Swap16LE(message.wParam1); if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); @@ -2186,7 +2187,7 @@ size_t OnChangeBeltItems(const TCmdChItem &message, Player &player) if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); - } else if (&player != MyPlayer && IsItemAvailable(static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx)))) { + } else if (&player != MyPlayer && IsItemAvailable(static_cast<_item_indexes>(Swap16LE(message.def.wIndx)))) { Item &item = player.SpdList[message.bLoc]; item = {}; RecreateItem(player, message, item); @@ -2197,7 +2198,7 @@ size_t OnChangeBeltItems(const TCmdChItem &message, Player &player) size_t OnDeleteBeltItems(const TCmdParam1 &message, Player &player) { - const uint16_t spdBarIndex = SDL_SwapLE16(message.wParam1); + const uint16_t spdBarIndex = Swap16LE(message.wParam1); if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); @@ -2210,7 +2211,7 @@ size_t OnDeleteBeltItems(const TCmdParam1 &message, Player &player) size_t OnPlayerLevel(const TCmdParam1 &message, Player &player) { - const uint16_t playerLevel = SDL_SwapLE16(message.wParam1); + const uint16_t playerLevel = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (playerLevel <= player.getMaxCharacterLevel() && &player != MyPlayer) @@ -2241,7 +2242,7 @@ size_t OnSpawnItem(const TCmdPItem &message, Player &player) if (player.isOnActiveLevel() && &player != MyPlayer) { SyncDropItem(message); } - PutItemRecord(SDL_SwapLE32(message.def.dwSeed), SDL_SwapLE16(message.def.wCI), static_cast<_item_indexes>(SDL_SwapLE16(message.def.wIndx))); + PutItemRecord(Swap32LE(message.def.dwSeed), Swap16LE(message.def.wCI), static_cast<_item_indexes>(Swap16LE(message.def.wIndx))); DeltaPutItem(message, { message.x, message.y }, player); } @@ -2250,7 +2251,7 @@ size_t OnSpawnItem(const TCmdPItem &message, Player &player) size_t OnSendPlayerInfo(const TCmdPlrInfoHdr &header, size_t maxCmdSize, Player &player) { - const uint16_t wBytes = SDL_SwapLE16(header.wBytes); + const uint16_t wBytes = Swap16LE(header.wBytes); if (!ValidateCmdSize(wBytes + sizeof(header), maxCmdSize, player.getId())) return maxCmdSize; @@ -2272,7 +2273,7 @@ size_t OnPlayerJoinLevel(const TCmdLocParam2 &message, Player &player) return sizeof(message); } - const auto playerLevel = static_cast(SDL_SwapLE16(message.wParam1)); + const auto playerLevel = static_cast(Swap16LE(message.wParam1)); const bool isSetLevel = message.wParam2 != 0; if (!IsValidLevel(playerLevel, isSetLevel) || !InDungeonBounds(position)) { return sizeof(message); @@ -2321,8 +2322,8 @@ size_t OnPlayerJoinLevel(const TCmdLocParam2 &message, Player &player) size_t OnActivatePortal(const TCmdLocParam3 &message, Player &player) { const Point position { message.x, message.y }; - const auto level = static_cast(SDL_SwapLE16(message.wParam1)); - const uint16_t dungeonTypeIdx = SDL_SwapLE16(message.wParam2); + const auto level = static_cast(Swap16LE(message.wParam1)); + const uint16_t dungeonTypeIdx = Swap16LE(message.wParam2); const bool isSetLevel = message.wParam3 != 0; if (gbBufferMsgs == 1) { @@ -2386,7 +2387,7 @@ size_t OnRestartTown(const TCmd &cmd, Player &player) size_t OnSetStrength(const TCmdParam1 &message, Player &player) { - const uint16_t value = SDL_SwapLE16(message.wParam1); + const uint16_t value = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (value <= 750 && &player != MyPlayer) @@ -2400,7 +2401,7 @@ size_t OnSetStrength(const TCmdParam1 &message, Player &player) size_t OnSetDexterity(const TCmdParam1 &message, Player &player) { - const uint16_t value = SDL_SwapLE16(message.wParam1); + const uint16_t value = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (value <= 750 && &player != MyPlayer) @@ -2414,7 +2415,7 @@ size_t OnSetDexterity(const TCmdParam1 &message, Player &player) size_t OnSetMagic(const TCmdParam1 &message, Player &player) { - const uint16_t value = SDL_SwapLE16(message.wParam1); + const uint16_t value = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (value <= 750 && &player != MyPlayer) @@ -2428,7 +2429,7 @@ size_t OnSetMagic(const TCmdParam1 &message, Player &player) size_t OnSetVitality(const TCmdParam1 &message, Player &player) { - const uint16_t value = SDL_SwapLE16(message.wParam1); + const uint16_t value = Swap16LE(message.wParam1); if (gbBufferMsgs != 1) { if (value <= 750 && &player != MyPlayer) @@ -2469,7 +2470,7 @@ size_t OnSyncQuest(const TCmdQuest &message, Player &player) BufferMessage(player, &message, sizeof(message)); } else { if (&player != MyPlayer && message.q < MAXQUESTS && message.qstate <= QUEST_HIVE_DONE) - SetMultiQuest(message.q, message.qstate, message.qlog != 0, message.qvar1, message.qvar2, SDL_SwapLE16(message.qmsg)); + SetMultiQuest(message.q, message.qstate, message.qlog != 0, message.qvar1, message.qvar2, Swap16LE(message.qmsg)); } return sizeof(message); @@ -2493,8 +2494,8 @@ size_t OnCheatExperience(const TCmd &cmd, Player &player) // NOLINT(misc-unused- size_t OnChangeSpellLevel(const TCmdParam2 &message, Player &player) // NOLINT(misc-unused-parameters) { - const auto spellID = static_cast(SDL_SwapLE16(message.wParam1)); - const uint8_t spellLevel = std::min(static_cast(SDL_SwapLE16(message.wParam2)), MaxSpellLevel); + const auto spellID = static_cast(Swap16LE(message.wParam1)); + const uint8_t spellLevel = std::min(static_cast(Swap16LE(message.wParam2)), MaxSpellLevel); if (gbBufferMsgs == 1) { BufferMessage(player, &message, sizeof(message)); @@ -2530,7 +2531,7 @@ size_t OnRemoveShield(const TCmd &cmd, Player &player) size_t OnSetReflect(const TCmdParam1 &message, Player &player) { if (gbBufferMsgs != 1) - player.wReflections = SDL_SwapLE16(message.wParam1); + player.wReflections = Swap16LE(message.wParam1); return sizeof(message); } @@ -2580,8 +2581,8 @@ size_t OnSpawnMonster(const TCmdSpawnMonster &message, const Player &player) const WorldTilePosition position { message.x, message.y }; - auto typeIndex = static_cast(SDL_SwapLE16(message.typeIndex)); - auto monsterId = static_cast(SDL_SwapLE16(message.monsterId)); + auto typeIndex = static_cast(Swap16LE(message.typeIndex)); + auto monsterId = static_cast(Swap16LE(message.monsterId)); const uint8_t golemOwnerPlayerId = message.golemOwnerPlayerId; if (golemOwnerPlayerId >= Players.size()) { return sizeof(message); @@ -2652,10 +2653,10 @@ void PrepareItemForNetwork(const Item &item, TItem &messageItem) messageItem.bMDur = item._iMaxDur; messageItem.bCh = item._iCharges; messageItem.bMCh = item._iMaxCharges; - messageItem.wValue = SDL_SwapLE16(item._ivalue); - messageItem.wToHit = SDL_SwapLE16(item._iPLToHit); - messageItem.wMaxDam = SDL_SwapLE16(item._iMaxDam); - messageItem.dwBuff = SDL_SwapLE32(item.dwBuff); + messageItem.wValue = Swap16LE(item._ivalue); + messageItem.wToHit = Swap16LE(item._iPLToHit); + messageItem.wMaxDam = Swap16LE(item._iMaxDam); + messageItem.dwBuff = Swap32LE(item.dwBuff); } void PrepareEarForNetwork(const Item &item, TEar &ear) @@ -2666,10 +2667,10 @@ void PrepareEarForNetwork(const Item &item, TEar &ear) void RecreateItem(const Player &player, const TItem &messageItem, Item &item) { - const uint32_t dwBuff = SDL_SwapLE32(messageItem.dwBuff); + const uint32_t dwBuff = Swap32LE(messageItem.dwBuff); RecreateItem(player, item, - static_cast<_item_indexes>(SDL_SwapLE16(messageItem.wIndx)), SDL_SwapLE16(messageItem.wCI), - SDL_SwapLE32(messageItem.dwSeed), SDL_SwapLE16(messageItem.wValue), dwBuff); + static_cast<_item_indexes>(Swap16LE(messageItem.wIndx)), Swap16LE(messageItem.wCI), + Swap32LE(messageItem.dwSeed), Swap16LE(messageItem.wValue), dwBuff); if (messageItem.bId != 0) item._iIdentified = true; item._iMaxDur = messageItem.bMDur; @@ -2677,8 +2678,8 @@ void RecreateItem(const Player &player, const TItem &messageItem, Item &item) item._iMaxCharges = std::clamp(messageItem.bMCh, 0, item._iMaxCharges); item._iCharges = std::clamp(messageItem.bCh, 0, item._iMaxCharges); if (gbIsHellfire) { - item._iPLToHit = ClampToHit(item, static_cast(SDL_SwapLE16(messageItem.wToHit))); - item._iMaxDam = ClampMaxDam(item, static_cast(SDL_SwapLE16(messageItem.wMaxDam))); + item._iPLToHit = ClampToHit(item, static_cast(Swap16LE(messageItem.wToHit))); + item._iMaxDam = ClampMaxDam(item, static_cast(Swap16LE(messageItem.wMaxDam))); } } @@ -2691,7 +2692,7 @@ void msg_send_drop_pkt(uint8_t pnum, int reason) { TFakeDropPlr cmd; - cmd.dwReason = SDL_SwapLE32(reason); + cmd.dwReason = Swap32LE(reason); cmd.bCmd = FAKE_CMD_DROPID; cmd.bPlr = pnum; BufferMessage(pnum, &cmd, sizeof(cmd)); @@ -2803,8 +2804,8 @@ void delta_monster_hp(const Monster &monster, const Player &player) return; DMonsterStr *pD = &GetDeltaLevel(player).monster[monster.getId()]; - if (SDL_SwapLE32(pD->hitPoints) > monster.hitPoints) - pD->hitPoints = SDL_SwapLE32(monster.hitPoints); + if (Swap32LE(pD->hitPoints) > monster.hitPoints) + pD->hitPoints = Swap32LE(monster.hitPoints); } void delta_sync_monster(const TSyncMonster &monsterSync, uint8_t level) @@ -2852,7 +2853,7 @@ void DeltaSyncJunk() quest._qactive = sgJunk.quests[q].qstate; quest._qvar1 = sgJunk.quests[q].qvar1; quest._qvar2 = sgJunk.quests[q].qvar2; - quest._qmsg = static_cast<_speech_id>(SDL_SwapLE16(sgJunk.quests[q].qmsg)); + quest._qmsg = static_cast<_speech_id>(Swap16LE(sgJunk.quests[q].qmsg)); } q++; } @@ -2868,9 +2869,9 @@ void DeltaAddItem(int ii) for (const TCmdPItem &item : deltaLevel.item) { if (item.bCmd != CMD_INVALID - && static_cast<_item_indexes>(SDL_SwapLE16(item.def.wIndx)) == Items[ii].IDidx - && SDL_SwapLE16(item.def.wCI) == Items[ii]._iCreateInfo - && static_cast(SDL_SwapLE32(item.def.dwSeed)) == Items[ii]._iSeed + && static_cast<_item_indexes>(Swap16LE(item.def.wIndx)) == Items[ii].IDidx + && Swap16LE(item.def.wCI) == Items[ii]._iCreateInfo + && static_cast(Swap32LE(item.def.dwSeed)) == Items[ii]._iSeed && IsAnyOf(item.bCmd, TCmdPItem::PickedUpItem, TCmdPItem::FloorItem)) { return; } @@ -2967,9 +2968,9 @@ void NetSendCmdSpawnMonster(Point position, Direction dir, uint16_t typeIndex, u cmd.x = position.x; cmd.y = position.y; cmd.dir = dir; - cmd.typeIndex = SDL_SwapLE16(typeIndex); - cmd.monsterId = SDL_SwapLE16(monsterId); - cmd.seed = SDL_SwapLE32(seed); + cmd.typeIndex = Swap16LE(typeIndex); + cmd.monsterId = Swap16LE(monsterId); + cmd.seed = Swap32LE(seed); cmd.golemOwnerPlayerId = golemOwnerPlayerId; cmd.golemSpellLevel = golemSpellLevel; NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); @@ -3003,7 +3004,7 @@ void NetSendCmdLocParam1(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa cmd.bCmd = bCmd; cmd.x = position.x; cmd.y = position.y; - cmd.wParam1 = SDL_SwapLE16(wParam1); + cmd.wParam1 = Swap16LE(wParam1); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3022,8 +3023,8 @@ void NetSendCmdLocParam2(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa cmd.bCmd = bCmd; cmd.x = position.x; cmd.y = position.y; - cmd.wParam1 = SDL_SwapLE16(wParam1); - cmd.wParam2 = SDL_SwapLE16(wParam2); + cmd.wParam1 = Swap16LE(wParam1); + cmd.wParam2 = Swap16LE(wParam2); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3042,9 +3043,9 @@ void NetSendCmdLocParam3(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa cmd.bCmd = bCmd; cmd.x = position.x; cmd.y = position.y; - cmd.wParam1 = SDL_SwapLE16(wParam1); - cmd.wParam2 = SDL_SwapLE16(wParam2); - cmd.wParam3 = SDL_SwapLE16(wParam3); + cmd.wParam1 = Swap16LE(wParam1); + cmd.wParam2 = Swap16LE(wParam2); + cmd.wParam3 = Swap16LE(wParam3); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3063,10 +3064,10 @@ void NetSendCmdLocParam4(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa cmd.bCmd = bCmd; cmd.x = position.x; cmd.y = position.y; - cmd.wParam1 = SDL_SwapLE16(wParam1); - cmd.wParam2 = SDL_SwapLE16(wParam2); - cmd.wParam3 = SDL_SwapLE16(wParam3); - cmd.wParam4 = SDL_SwapLE16(wParam4); + cmd.wParam1 = Swap16LE(wParam1); + cmd.wParam2 = Swap16LE(wParam2); + cmd.wParam3 = Swap16LE(wParam3); + cmd.wParam4 = Swap16LE(wParam4); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3083,7 +3084,7 @@ void NetSendCmdParam1(bool bHiPri, _cmd_id bCmd, uint16_t wParam1) TCmdParam1 cmd; cmd.bCmd = bCmd; - cmd.wParam1 = SDL_SwapLE16(wParam1); + cmd.wParam1 = Swap16LE(wParam1); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3097,8 +3098,8 @@ void NetSendCmdParam2(bool bHiPri, _cmd_id bCmd, uint16_t wParam1, uint16_t wPar TCmdParam2 cmd; cmd.bCmd = bCmd; - cmd.wParam1 = SDL_SwapLE16(wParam1); - cmd.wParam2 = SDL_SwapLE16(wParam2); + cmd.wParam1 = Swap16LE(wParam1); + cmd.wParam2 = Swap16LE(wParam2); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3113,10 +3114,10 @@ void NetSendCmdParam4(bool bHiPri, _cmd_id bCmd, uint16_t wParam1, uint16_t wPar TCmdParam4 cmd; cmd.bCmd = bCmd; - cmd.wParam1 = SDL_SwapLE16(wParam1); - cmd.wParam2 = SDL_SwapLE16(wParam2); - cmd.wParam3 = SDL_SwapLE16(wParam3); - cmd.wParam4 = SDL_SwapLE16(wParam4); + cmd.wParam1 = Swap16LE(wParam1); + cmd.wParam2 = Swap16LE(wParam2); + cmd.wParam3 = Swap16LE(wParam3); + cmd.wParam4 = Swap16LE(wParam4); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); else @@ -3134,7 +3135,7 @@ void NetSendCmdQuest(bool bHiPri, const Quest &quest) cmd.qlog = quest._qlog ? 1 : 0; cmd.qvar1 = quest._qvar1; cmd.qvar2 = quest._qvar2; - cmd.qmsg = SDL_SwapLE16(quest._qmsg); + cmd.qmsg = Swap16LE(quest._qmsg); if (bHiPri) NetSendHiPri(MyPlayerId, reinterpret_cast(&cmd), sizeof(cmd)); diff --git a/Source/multi.cpp b/Source/multi.cpp index 07ed97284..c945db29c 100644 --- a/Source/multi.cpp +++ b/Source/multi.cpp @@ -10,7 +10,14 @@ #include #include +#ifdef USE_SDL3 +#include +#include +#include +#else #include +#endif + #include #include @@ -34,6 +41,7 @@ #include "sync.h" #include "tmsg.h" #include "utils/endian_read.hpp" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" #include "utils/language.h" #include "utils/str_cat.hpp" @@ -80,12 +88,12 @@ const event_type EventTypes[3] = { void GameData::swapLE() { - size = SDL_SwapLE32(size); - programid = SDL_SwapLE32(programid); - gameSeed[0] = SDL_SwapLE32(gameSeed[0]); - gameSeed[1] = SDL_SwapLE32(gameSeed[1]); - gameSeed[2] = SDL_SwapLE32(gameSeed[2]); - gameSeed[3] = SDL_SwapLE32(gameSeed[3]); + size = Swap32LE(size); + programid = Swap32LE(programid); + gameSeed[0] = Swap32LE(gameSeed[0]); + gameSeed[1] = Swap32LE(gameSeed[1]); + gameSeed[2] = Swap32LE(gameSeed[2]); + gameSeed[3] = Swap32LE(gameSeed[3]); } namespace { @@ -164,10 +172,10 @@ void NetReceivePlayerData(TPkt *pkt) pkt->hdr.py = myPlayer.position.tile.y; pkt->hdr.targx = target.x; pkt->hdr.targy = target.y; - pkt->hdr.php = SDL_SwapLE32(myPlayer._pHitPoints); - pkt->hdr.pmhp = SDL_SwapLE32(myPlayer._pMaxHP); - pkt->hdr.mana = SDL_SwapLE32(myPlayer._pMana); - pkt->hdr.maxmana = SDL_SwapLE32(myPlayer._pMaxMana); + pkt->hdr.php = Swap32LE(myPlayer._pHitPoints); + pkt->hdr.pmhp = Swap32LE(myPlayer._pMaxHP); + pkt->hdr.mana = Swap32LE(myPlayer._pMana); + pkt->hdr.maxmana = Swap32LE(myPlayer._pMaxMana); pkt->hdr.bstr = myPlayer._pBaseStr; pkt->hdr.bmag = myPlayer._pBaseMag; pkt->hdr.bdex = myPlayer._pBaseDex; @@ -220,7 +228,7 @@ void SendPacket(uint8_t playerId, const std::byte *packet, size_t size) NetReceivePlayerData(&pkt); const size_t sizeWithheader = size + sizeof(pkt.hdr); - pkt.hdr.wLen = SDL_SwapLE16(static_cast(sizeWithheader)); + pkt.hdr.wLen = Swap16LE(static_cast(sizeWithheader)); memcpy(pkt.body, packet, size); if (!SNetSendMessage(playerId, &pkt.hdr, sizeWithheader)) nthread_terminate_game("SNetSendMessage0"); @@ -417,7 +425,7 @@ void HandleEvents(_SNETEVENT *pEvt) int32_t leftReason = 0; if (pEvt->data != nullptr && pEvt->databytes >= sizeof(leftReason)) { std::memcpy(&leftReason, pEvt->data, sizeof(leftReason)); - leftReason = SDL_SwapLE32(leftReason); + leftReason = Swap32LE(leftReason); } sgdwPlayerLeftReasonTbl[playerId] = leftReason; if (leftReason == LEAVE_ENDING) @@ -555,7 +563,7 @@ void NetSendHiPri(uint8_t playerId, const std::byte *data, size_t size) destination = CopyBufferedPackets(destination, &lowPriorityBuffer, &remainingSpace); remainingSpace = sync_all_monsters(destination, remainingSpace); const size_t len = gdwNormalMsgSize - remainingSpace; - pkt.hdr.wLen = SDL_SwapLE16(static_cast(len)); + pkt.hdr.wLen = Swap16LE(static_cast(len)); if (!SNetSendMessage(SNPLAYER_OTHERS, &pkt.hdr, len)) nthread_terminate_game("SNetSendMessage"); } @@ -566,7 +574,7 @@ void multi_send_msg_packet(uint32_t pmask, const std::byte *data, size_t size) TPkt pkt; NetReceivePlayerData(&pkt); const size_t len = size + sizeof(pkt.hdr); - pkt.hdr.wLen = SDL_SwapLE16(static_cast(len)); + pkt.hdr.wLen = Swap16LE(static_cast(len)); memcpy(pkt.body, data, size); uint8_t playerID = 0; for (uint32_t v = 1; playerID < Players.size(); playerID++, v <<= 1) { @@ -660,7 +668,7 @@ void multi_process_network_packets() continue; if (pkt->wCheck != HeaderCheckVal) continue; - if (SDL_SwapLE16(pkt->wLen) != dwMsgSize) + if (Swap16LE(pkt->wLen) != dwMsgSize) continue; Player &player = Players[playerId]; if (!IsNetPlayerValid(player)) { @@ -675,10 +683,10 @@ void multi_process_network_packets() player.position.last = syncPosition; if (&player != MyPlayer) { assert(gbBufferMsgs != 2); - player._pHitPoints = SDL_SwapLE32(pkt->php); - player._pMaxHP = SDL_SwapLE32(pkt->pmhp); - player._pMana = SDL_SwapLE32(pkt->mana); - player._pMaxMana = SDL_SwapLE32(pkt->maxmana); + player._pHitPoints = Swap32LE(pkt->php); + player._pMaxHP = Swap32LE(pkt->pmhp); + player._pMana = Swap32LE(pkt->mana); + player._pMaxMana = Swap32LE(pkt->maxmana); const bool cond = gbBufferMsgs == 1; player._pBaseStr = pkt->bstr; player._pBaseMag = pkt->bmag; @@ -729,18 +737,18 @@ void multi_send_zero_packet(uint8_t pnum, _cmd_id bCmd, const std::byte *data, s auto &message = *reinterpret_cast(pkt.body); message.bCmd = bCmd; assert(offset <= 0x0ffff); - message.wOffset = SDL_SwapLE16(static_cast(offset)); + message.wOffset = Swap16LE(static_cast(offset)); size_t dwBody = gdwLargestMsgSize - sizeof(pkt.hdr) - sizeof(message); dwBody = std::min(dwBody, size - offset); assert(dwBody <= 0x0ffff); - message.wBytes = SDL_SwapLE16(static_cast(dwBody)); + message.wBytes = Swap16LE(static_cast(dwBody)); memcpy(&pkt.body[sizeof(message)], &data[offset], dwBody); const size_t dwMsg = sizeof(pkt.hdr) + sizeof(message) + dwBody; assert(dwMsg <= 0x0ffff); - pkt.hdr.wLen = SDL_SwapLE16(static_cast(dwMsg)); + pkt.hdr.wLen = Swap16LE(static_cast(dwMsg)); if (!SNetSendMessage(pnum, &pkt, dwMsg)) { nthread_terminate_game("SNetSendMessage2"); @@ -848,7 +856,7 @@ void recv_plrinfo(Player &player, const TCmdPlrInfoHdr &header, bool recv) const uint8_t pnum = player.getId(); auto &packedPlayer = PackedPlayerBuffer[pnum]; - if (sgwPackPlrOffsetTbl[pnum] != SDL_SwapLE16(header.wOffset)) { + if (sgwPackPlrOffsetTbl[pnum] != Swap16LE(header.wOffset)) { sgwPackPlrOffsetTbl[pnum] = 0; if (header.wOffset != 0) { return; @@ -858,9 +866,9 @@ void recv_plrinfo(Player &player, const TCmdPlrInfoHdr &header, bool recv) SendPlayerInfo(pnum, CMD_ACK_PLRINFO); } - memcpy(reinterpret_cast(&packedPlayer) + SDL_SwapLE16(header.wOffset), reinterpret_cast(&header) + sizeof(header), SDL_SwapLE16(header.wBytes)); + memcpy(reinterpret_cast(&packedPlayer) + Swap16LE(header.wOffset), reinterpret_cast(&header) + sizeof(header), Swap16LE(header.wBytes)); - sgwPackPlrOffsetTbl[pnum] += SDL_SwapLE16(header.wBytes); + sgwPackPlrOffsetTbl[pnum] += Swap16LE(header.wBytes); if (sgwPackPlrOffsetTbl[pnum] != sizeof(packedPlayer)) { return; } diff --git a/Source/pack.cpp b/Source/pack.cpp index e06c7ff47..2e8a6b659 100644 --- a/Source/pack.cpp +++ b/Source/pack.cpp @@ -15,6 +15,7 @@ #include "plrmsg.h" #include "stores.h" #include "utils/endian_read.hpp" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" #include "utils/log.hpp" #include "utils/utf8.hpp" @@ -117,20 +118,20 @@ void PackItem(ItemPack &packedItem, const Item &item, bool isHellfire) if (gbIsSpawn) { idx = RemapItemIdxToSpawn(idx); } - packedItem.idx = SDL_SwapLE16(idx); + packedItem.idx = Swap16LE(idx); if (item.IDidx == IDI_EAR) { - packedItem.iCreateInfo = SDL_SwapLE16(item._iIName[1] | (item._iIName[0] << 8)); - packedItem.iSeed = SDL_SwapLE32(LoadBE32(&item._iIName[2])); + packedItem.iCreateInfo = Swap16LE(item._iIName[1] | (item._iIName[0] << 8)); + packedItem.iSeed = Swap32LE(LoadBE32(&item._iIName[2])); packedItem.bId = item._iIName[6]; packedItem.bDur = item._iIName[7]; packedItem.bMDur = item._iIName[8]; packedItem.bCh = item._iIName[9]; packedItem.bMCh = item._iIName[10]; - packedItem.wValue = SDL_SwapLE16(item._ivalue | (item._iIName[11] << 8) | ((item._iCurs - ICURS_EAR_SORCERER) << 6)); - packedItem.dwBuff = SDL_SwapLE32(LoadBE32(&item._iIName[12])); + packedItem.wValue = Swap16LE(item._ivalue | (item._iIName[11] << 8) | ((item._iCurs - ICURS_EAR_SORCERER) << 6)); + packedItem.dwBuff = Swap32LE(LoadBE32(&item._iIName[12])); } else { - packedItem.iSeed = SDL_SwapLE32(item._iSeed); - packedItem.iCreateInfo = SDL_SwapLE16(item._iCreateInfo); + packedItem.iSeed = Swap32LE(item._iSeed); + packedItem.iCreateInfo = Swap16LE(item._iCreateInfo); packedItem.bId = (item._iMagical << 1) | (item._iIdentified ? 1 : 0); if (item._iMaxDur > 255) packedItem.bMDur = 254; @@ -141,7 +142,7 @@ void PackItem(ItemPack &packedItem, const Item &item, bool isHellfire) packedItem.bCh = item._iCharges; packedItem.bMCh = item._iMaxCharges; if (item.IDidx == IDI_GOLD) - packedItem.wValue = SDL_SwapLE16(item._ivalue); + packedItem.wValue = Swap16LE(item._ivalue); packedItem.dwBuff = item.dwBuff; } } @@ -168,13 +169,13 @@ void PackPlayer(PlayerPack &packed, const Player &player) packed.pBaseVit = player._pBaseVit; packed.pLevel = player.getCharacterLevel(); packed.pStatPts = player._pStatPts; - packed.pExperience = SDL_SwapLE32(player._pExperience); - packed.pGold = SDL_SwapLE32(player._pGold); - packed.pHPBase = SDL_SwapLE32(player._pHPBase); - packed.pMaxHPBase = SDL_SwapLE32(player._pMaxHPBase); - packed.pManaBase = SDL_SwapLE32(player._pManaBase); - packed.pMaxManaBase = SDL_SwapLE32(player._pMaxManaBase); - packed.pMemSpells = SDL_SwapLE64(player._pMemSpells); + packed.pExperience = Swap32LE(player._pExperience); + packed.pGold = Swap32LE(player._pGold); + packed.pHPBase = Swap32LE(player._pHPBase); + packed.pMaxHPBase = Swap32LE(player._pMaxHPBase); + packed.pManaBase = Swap32LE(player._pManaBase); + packed.pMaxManaBase = Swap32LE(player._pMaxManaBase); + packed.pMemSpells = Swap64LE(player._pMemSpells); for (int i = 0; i < 37; i++) // Should be MAX_SPELLS but set to 37 to make save games compatible packed.pSplLvl[i] = player._pSplLvl[i]; @@ -194,9 +195,9 @@ void PackPlayer(PlayerPack &packed, const Player &player) for (int i = 0; i < MaxBeltItems; i++) PackItem(packed.SpdList[i], player.SpdList[i], gbIsHellfire); - packed.wReflections = SDL_SwapLE16(player.wReflections); - packed.pDamAcFlags = SDL_SwapLE32(static_cast(player.pDamAcFlags)); - packed.pDiabloKillLevel = SDL_SwapLE32(player.pDiabloKillLevel); + packed.wReflections = Swap16LE(player.wReflections); + packed.pDamAcFlags = Swap32LE(static_cast(player.pDamAcFlags)); + packed.pDiabloKillLevel = Swap32LE(player.pDiabloKillLevel); packed.bIsHellfire = gbIsHellfire ? 1 : 0; } @@ -206,9 +207,9 @@ void PackNetItem(const Item &item, ItemNetPack &packedItem) packedItem.def.wIndx = static_cast<_item_indexes>(0xFFFF); return; } - packedItem.def.wIndx = static_cast<_item_indexes>(SDL_SwapLE16(item.IDidx)); - packedItem.def.wCI = SDL_SwapLE16(item._iCreateInfo); - packedItem.def.dwSeed = SDL_SwapLE32(item._iSeed); + packedItem.def.wIndx = static_cast<_item_indexes>(Swap16LE(item.IDidx)); + packedItem.def.wCI = Swap16LE(item._iCreateInfo); + packedItem.def.dwSeed = Swap32LE(item._iSeed); if (item.IDidx != IDI_EAR) PrepareItemForNetwork(item, packedItem.item); else @@ -228,12 +229,12 @@ void PackNetPlayer(PlayerNetPack &packed, const Player &player) packed.pBaseVit = player._pBaseVit; packed.pLevel = player.getCharacterLevel(); packed.pStatPts = player._pStatPts; - packed.pExperience = SDL_SwapLE32(player._pExperience); - packed.pHPBase = SDL_SwapLE32(player._pHPBase); - packed.pMaxHPBase = SDL_SwapLE32(player._pMaxHPBase); - packed.pManaBase = SDL_SwapLE32(player._pManaBase); - packed.pMaxManaBase = SDL_SwapLE32(player._pMaxManaBase); - packed.pMemSpells = SDL_SwapLE64(player._pMemSpells); + packed.pExperience = Swap32LE(player._pExperience); + packed.pHPBase = Swap32LE(player._pHPBase); + packed.pMaxHPBase = Swap32LE(player._pMaxHPBase); + packed.pManaBase = Swap32LE(player._pManaBase); + packed.pMaxManaBase = Swap32LE(player._pMaxManaBase); + packed.pMemSpells = Swap64LE(player._pMemSpells); for (int i = 0; i < MAX_SPELLS; i++) packed.pSplLvl[i] = player._pSplLvl[i]; @@ -251,36 +252,36 @@ void PackNetPlayer(PlayerNetPack &packed, const Player &player) for (int i = 0; i < MaxBeltItems; i++) PackNetItem(player.SpdList[i], packed.SpdList[i]); - packed.wReflections = SDL_SwapLE16(player.wReflections); + packed.wReflections = Swap16LE(player.wReflections); packed.pDiabloKillLevel = player.pDiabloKillLevel; packed.pManaShield = player.pManaShield; packed.friendlyMode = player.friendlyMode ? 1 : 0; packed.isOnSetLevel = player.plrIsOnSetLevel; - packed.pStrength = SDL_SwapLE32(player._pStrength); - packed.pMagic = SDL_SwapLE32(player._pMagic); - packed.pDexterity = SDL_SwapLE32(player._pDexterity); - packed.pVitality = SDL_SwapLE32(player._pVitality); - packed.pHitPoints = SDL_SwapLE32(player._pHitPoints); - packed.pMaxHP = SDL_SwapLE32(player._pMaxHP); - packed.pMana = SDL_SwapLE32(player._pMana); - packed.pMaxMana = SDL_SwapLE32(player._pMaxMana); - packed.pDamageMod = SDL_SwapLE32(player._pDamageMod); + packed.pStrength = Swap32LE(player._pStrength); + packed.pMagic = Swap32LE(player._pMagic); + packed.pDexterity = Swap32LE(player._pDexterity); + packed.pVitality = Swap32LE(player._pVitality); + packed.pHitPoints = Swap32LE(player._pHitPoints); + packed.pMaxHP = Swap32LE(player._pMaxHP); + packed.pMana = Swap32LE(player._pMana); + packed.pMaxMana = Swap32LE(player._pMaxMana); + packed.pDamageMod = Swap32LE(player._pDamageMod); // we pack base to block as a basic check that remote players are using the same playerdat values as we are - packed.pBaseToBlk = SDL_SwapLE32(player.getBaseToBlock()); - packed.pIMinDam = SDL_SwapLE32(player._pIMinDam); - packed.pIMaxDam = SDL_SwapLE32(player._pIMaxDam); - packed.pIAC = SDL_SwapLE32(player._pIAC); - packed.pIBonusDam = SDL_SwapLE32(player._pIBonusDam); - packed.pIBonusToHit = SDL_SwapLE32(player._pIBonusToHit); - packed.pIBonusAC = SDL_SwapLE32(player._pIBonusAC); - packed.pIBonusDamMod = SDL_SwapLE32(player._pIBonusDamMod); - packed.pIGetHit = SDL_SwapLE32(player._pIGetHit); - packed.pIEnAc = SDL_SwapLE32(player._pIEnAc); - packed.pIFMinDam = SDL_SwapLE32(player._pIFMinDam); - packed.pIFMaxDam = SDL_SwapLE32(player._pIFMaxDam); - packed.pILMinDam = SDL_SwapLE32(player._pILMinDam); - packed.pILMaxDam = SDL_SwapLE32(player._pILMaxDam); + packed.pBaseToBlk = Swap32LE(player.getBaseToBlock()); + packed.pIMinDam = Swap32LE(player._pIMinDam); + packed.pIMaxDam = Swap32LE(player._pIMaxDam); + packed.pIAC = Swap32LE(player._pIAC); + packed.pIBonusDam = Swap32LE(player._pIBonusDam); + packed.pIBonusToHit = Swap32LE(player._pIBonusToHit); + packed.pIBonusAC = Swap32LE(player._pIBonusAC); + packed.pIBonusDamMod = Swap32LE(player._pIBonusDamMod); + packed.pIGetHit = Swap32LE(player._pIGetHit); + packed.pIEnAc = Swap32LE(player._pIEnAc); + packed.pIFMinDam = Swap32LE(player._pIFMinDam); + packed.pIFMaxDam = Swap32LE(player._pIFMaxDam); + packed.pILMinDam = Swap32LE(player._pILMinDam); + packed.pILMaxDam = Swap32LE(player._pILMaxDam); } void UnPackItem(const ItemPack &packedItem, const Player &player, Item &item, bool isHellfire) @@ -290,7 +291,7 @@ void UnPackItem(const ItemPack &packedItem, const Player &player, Item &item, bo return; } - auto idx = static_cast<_item_indexes>(SDL_SwapLE16(packedItem.idx)); + auto idx = static_cast<_item_indexes>(Swap16LE(packedItem.idx)); if (gbIsSpawn) { idx = RemapItemIdxFromSpawn(idx); @@ -305,10 +306,10 @@ void UnPackItem(const ItemPack &packedItem, const Player &player, Item &item, bo } if (idx == IDI_EAR) { - const uint16_t ic = SDL_SwapLE16(packedItem.iCreateInfo); - const uint32_t iseed = SDL_SwapLE32(packedItem.iSeed); - const uint16_t ivalue = SDL_SwapLE16(packedItem.wValue); - const int32_t ibuff = SDL_SwapLE32(packedItem.dwBuff); + const uint16_t ic = Swap16LE(packedItem.iCreateInfo); + const uint32_t iseed = Swap32LE(packedItem.iSeed); + const uint16_t ivalue = Swap16LE(packedItem.wValue); + const int32_t ibuff = Swap32LE(packedItem.dwBuff); char heroName[17]; heroName[0] = static_cast((ic >> 8) & 0x7F); @@ -334,8 +335,8 @@ void UnPackItem(const ItemPack &packedItem, const Player &player, Item &item, bo item = {}; // Item generation logic will assign CF_HELLFIRE based on isHellfire // so if we carry it over from packedItem, it may be incorrect - const uint32_t dwBuff = SDL_SwapLE32(packedItem.dwBuff) | (isHellfire ? CF_HELLFIRE : 0); - RecreateItem(player, item, idx, SDL_SwapLE16(packedItem.iCreateInfo), SDL_SwapLE32(packedItem.iSeed), SDL_SwapLE16(packedItem.wValue), dwBuff); + const uint32_t dwBuff = Swap32LE(packedItem.dwBuff) | (isHellfire ? CF_HELLFIRE : 0); + RecreateItem(player, item, idx, Swap16LE(packedItem.iCreateInfo), Swap32LE(packedItem.iSeed), Swap16LE(packedItem.wValue), dwBuff); item._iIdentified = (packedItem.bId & 1) != 0; item._iMaxDur = packedItem.bMDur; item._iDurability = ClampDurability(item, packedItem.bDur); @@ -350,8 +351,8 @@ void UnPackPlayer(const PlayerPack &packed, Player &player) player = {}; player.setCharacterLevel(packed.pLevel); - player._pMaxHPBase = SDL_SwapLE32(packed.pMaxHPBase); - player._pHPBase = SDL_SwapLE32(packed.pHPBase); + player._pMaxHPBase = Swap32LE(packed.pMaxHPBase); + player._pHPBase = Swap32LE(packed.pHPBase); player._pHPBase = std::clamp(player._pHPBase, 0, player._pMaxHPBase); player._pMaxHP = player._pMaxHPBase; player._pHitPoints = player._pHPBase; @@ -378,15 +379,15 @@ void UnPackPlayer(const PlayerPack &packed, Player &player) player._pVitality = player._pBaseVit; player._pStatPts = packed.pStatPts; - player._pExperience = SDL_SwapLE32(packed.pExperience); - player._pGold = SDL_SwapLE32(packed.pGold); + player._pExperience = Swap32LE(packed.pExperience); + player._pGold = Swap32LE(packed.pGold); if ((int)(player._pHPBase & 0xFFFFFFC0) < 64) player._pHPBase = 64; - player._pMaxManaBase = SDL_SwapLE32(packed.pMaxManaBase); - player._pManaBase = SDL_SwapLE32(packed.pManaBase); + player._pMaxManaBase = Swap32LE(packed.pMaxManaBase); + player._pManaBase = Swap32LE(packed.pManaBase); player._pManaBase = std::min(player._pManaBase, player._pMaxManaBase); - player._pMemSpells = SDL_SwapLE64(packed.pMemSpells); + player._pMemSpells = Swap64LE(packed.pMemSpells); // Only read spell levels for learnable spells (Diablo) for (int i = 0; i < 37; i++) { // Should be MAX_SPELLS but set to 36 to make save games compatible @@ -428,23 +429,23 @@ void UnPackPlayer(const PlayerPack &packed, Player &player) UnPackItem(packed.SpdList[i], player, player.SpdList[i], isHellfire); CalcPlrInv(player, false); - player.wReflections = SDL_SwapLE16(packed.wReflections); - player.pDiabloKillLevel = SDL_SwapLE32(packed.pDiabloKillLevel); + player.wReflections = Swap16LE(packed.wReflections); + player.pDiabloKillLevel = Swap32LE(packed.pDiabloKillLevel); } bool UnPackNetItem(const Player &player, const ItemNetPack &packedItem, Item &item) { item = {}; - const _item_indexes idx = static_cast<_item_indexes>(SDL_SwapLE16(packedItem.def.wIndx)); + const _item_indexes idx = static_cast<_item_indexes>(Swap16LE(packedItem.def.wIndx)); if (idx < 0 || idx >= static_cast<_item_indexes>(AllItemsList.size())) return true; if (idx == IDI_EAR) { - RecreateEar(item, SDL_SwapLE16(packedItem.ear.wCI), SDL_SwapLE32(packedItem.ear.dwSeed), packedItem.ear.bCursval, packedItem.ear.heroname); + RecreateEar(item, Swap16LE(packedItem.ear.wCI), Swap32LE(packedItem.ear.dwSeed), packedItem.ear.bCursval, packedItem.ear.heroname); return true; } - const uint16_t creationFlags = SDL_SwapLE16(packedItem.item.wCI); - const uint32_t dwBuff = SDL_SwapLE16(packedItem.item.dwBuff); + const uint16_t creationFlags = Swap16LE(packedItem.item.wCI); + const uint32_t dwBuff = Swap16LE(packedItem.item.dwBuff); if (idx != IDI_GOLD) ValidateField(creationFlags, IsCreationFlagComboValid(creationFlags)); if ((creationFlags & CF_TOWN) != 0) @@ -472,13 +473,13 @@ bool UnPackNetPlayer(const PlayerNetPack &packed, Player &player) ValidateField(packed.plrlevel, packed.plrlevel < NUMLEVELS); ValidateField(packed.pLevel, packed.pLevel >= 1 && packed.pLevel <= player.getMaxCharacterLevel()); - const int32_t baseHpMax = SDL_SwapLE32(packed.pMaxHPBase); - const int32_t baseHp = SDL_SwapLE32(packed.pHPBase); - const int32_t hpMax = SDL_SwapLE32(packed.pMaxHP); + const int32_t baseHpMax = Swap32LE(packed.pMaxHPBase); + const int32_t baseHp = Swap32LE(packed.pHPBase); + const int32_t hpMax = Swap32LE(packed.pMaxHP); ValidateFields(baseHp, baseHpMax, baseHp >= (baseHpMax - hpMax) && baseHp <= baseHpMax); - const int32_t baseManaMax = SDL_SwapLE32(packed.pMaxManaBase); - const int32_t baseMana = SDL_SwapLE32(packed.pManaBase); + const int32_t baseManaMax = Swap32LE(packed.pMaxManaBase); + const int32_t baseMana = Swap32LE(packed.pManaBase); ValidateFields(baseMana, baseManaMax, baseMana <= baseManaMax); ValidateFields(packed.pClass, packed.pBaseStr, packed.pBaseStr <= player.GetMaximumAttributeValue(CharacterAttribute::Strength)); @@ -513,11 +514,11 @@ bool UnPackNetPlayer(const PlayerNetPack &packed, Player &player) player._pVitality = player._pBaseVit; player._pStatPts = packed.pStatPts; - player._pExperience = SDL_SwapLE32(packed.pExperience); + player._pExperience = Swap32LE(packed.pExperience); player._pMaxManaBase = baseManaMax; player._pManaBase = baseMana; - player._pMemSpells = SDL_SwapLE64(packed.pMemSpells); - player.wReflections = SDL_SwapLE16(packed.wReflections); + player._pMemSpells = Swap64LE(packed.pMemSpells); + player.wReflections = Swap16LE(packed.wReflections); player.pDiabloKillLevel = packed.pDiabloKillLevel; player.pManaShield = packed.pManaShield != 0; player.friendlyMode = packed.friendlyMode != 0; @@ -578,29 +579,29 @@ bool UnPackNetPlayer(const PlayerNetPack &packed, Player &player) CalcPlrInv(player, false); player._pGold = CalculateGold(player); - ValidateFields(player._pStrength, SDL_SwapLE32(packed.pStrength), player._pStrength == SDL_SwapLE32(packed.pStrength)); - ValidateFields(player._pMagic, SDL_SwapLE32(packed.pMagic), player._pMagic == SDL_SwapLE32(packed.pMagic)); - ValidateFields(player._pDexterity, SDL_SwapLE32(packed.pDexterity), player._pDexterity == SDL_SwapLE32(packed.pDexterity)); - ValidateFields(player._pVitality, SDL_SwapLE32(packed.pVitality), player._pVitality == SDL_SwapLE32(packed.pVitality)); - ValidateFields(player._pHitPoints, SDL_SwapLE32(packed.pHitPoints), player._pHitPoints == SDL_SwapLE32(packed.pHitPoints)); - ValidateFields(player._pMaxHP, SDL_SwapLE32(packed.pMaxHP), player._pMaxHP == SDL_SwapLE32(packed.pMaxHP)); - ValidateFields(player._pMana, SDL_SwapLE32(packed.pMana), player._pMana == SDL_SwapLE32(packed.pMana)); - ValidateFields(player._pMaxMana, SDL_SwapLE32(packed.pMaxMana), player._pMaxMana == SDL_SwapLE32(packed.pMaxMana)); - ValidateFields(player._pDamageMod, SDL_SwapLE32(packed.pDamageMod), player._pDamageMod == SDL_SwapLE32(packed.pDamageMod)); - ValidateFields(player.getBaseToBlock(), SDL_SwapLE32(packed.pBaseToBlk), player.getBaseToBlock() == SDL_SwapLE32(packed.pBaseToBlk)); - ValidateFields(player._pIMinDam, SDL_SwapLE32(packed.pIMinDam), player._pIMinDam == SDL_SwapLE32(packed.pIMinDam)); - ValidateFields(player._pIMaxDam, SDL_SwapLE32(packed.pIMaxDam), player._pIMaxDam == SDL_SwapLE32(packed.pIMaxDam)); - ValidateFields(player._pIAC, SDL_SwapLE32(packed.pIAC), player._pIAC == SDL_SwapLE32(packed.pIAC)); - ValidateFields(player._pIBonusDam, SDL_SwapLE32(packed.pIBonusDam), player._pIBonusDam == SDL_SwapLE32(packed.pIBonusDam)); - ValidateFields(player._pIBonusToHit, SDL_SwapLE32(packed.pIBonusToHit), player._pIBonusToHit == SDL_SwapLE32(packed.pIBonusToHit)); - ValidateFields(player._pIBonusAC, SDL_SwapLE32(packed.pIBonusAC), player._pIBonusAC == SDL_SwapLE32(packed.pIBonusAC)); - ValidateFields(player._pIBonusDamMod, SDL_SwapLE32(packed.pIBonusDamMod), player._pIBonusDamMod == SDL_SwapLE32(packed.pIBonusDamMod)); - ValidateFields(player._pIGetHit, SDL_SwapLE32(packed.pIGetHit), player._pIGetHit == SDL_SwapLE32(packed.pIGetHit)); - ValidateFields(player._pIEnAc, SDL_SwapLE32(packed.pIEnAc), player._pIEnAc == SDL_SwapLE32(packed.pIEnAc)); - ValidateFields(player._pIFMinDam, SDL_SwapLE32(packed.pIFMinDam), player._pIFMinDam == SDL_SwapLE32(packed.pIFMinDam)); - ValidateFields(player._pIFMaxDam, SDL_SwapLE32(packed.pIFMaxDam), player._pIFMaxDam == SDL_SwapLE32(packed.pIFMaxDam)); - ValidateFields(player._pILMinDam, SDL_SwapLE32(packed.pILMinDam), player._pILMinDam == SDL_SwapLE32(packed.pILMinDam)); - ValidateFields(player._pILMaxDam, SDL_SwapLE32(packed.pILMaxDam), player._pILMaxDam == SDL_SwapLE32(packed.pILMaxDam)); + ValidateFields(player._pStrength, Swap32LE(packed.pStrength), player._pStrength == Swap32LE(packed.pStrength)); + ValidateFields(player._pMagic, Swap32LE(packed.pMagic), player._pMagic == Swap32LE(packed.pMagic)); + ValidateFields(player._pDexterity, Swap32LE(packed.pDexterity), player._pDexterity == Swap32LE(packed.pDexterity)); + ValidateFields(player._pVitality, Swap32LE(packed.pVitality), player._pVitality == Swap32LE(packed.pVitality)); + ValidateFields(player._pHitPoints, Swap32LE(packed.pHitPoints), player._pHitPoints == Swap32LE(packed.pHitPoints)); + ValidateFields(player._pMaxHP, Swap32LE(packed.pMaxHP), player._pMaxHP == Swap32LE(packed.pMaxHP)); + ValidateFields(player._pMana, Swap32LE(packed.pMana), player._pMana == Swap32LE(packed.pMana)); + ValidateFields(player._pMaxMana, Swap32LE(packed.pMaxMana), player._pMaxMana == Swap32LE(packed.pMaxMana)); + ValidateFields(player._pDamageMod, Swap32LE(packed.pDamageMod), player._pDamageMod == Swap32LE(packed.pDamageMod)); + ValidateFields(player.getBaseToBlock(), Swap32LE(packed.pBaseToBlk), player.getBaseToBlock() == Swap32LE(packed.pBaseToBlk)); + ValidateFields(player._pIMinDam, Swap32LE(packed.pIMinDam), player._pIMinDam == Swap32LE(packed.pIMinDam)); + ValidateFields(player._pIMaxDam, Swap32LE(packed.pIMaxDam), player._pIMaxDam == Swap32LE(packed.pIMaxDam)); + ValidateFields(player._pIAC, Swap32LE(packed.pIAC), player._pIAC == Swap32LE(packed.pIAC)); + ValidateFields(player._pIBonusDam, Swap32LE(packed.pIBonusDam), player._pIBonusDam == Swap32LE(packed.pIBonusDam)); + ValidateFields(player._pIBonusToHit, Swap32LE(packed.pIBonusToHit), player._pIBonusToHit == Swap32LE(packed.pIBonusToHit)); + ValidateFields(player._pIBonusAC, Swap32LE(packed.pIBonusAC), player._pIBonusAC == Swap32LE(packed.pIBonusAC)); + ValidateFields(player._pIBonusDamMod, Swap32LE(packed.pIBonusDamMod), player._pIBonusDamMod == Swap32LE(packed.pIBonusDamMod)); + ValidateFields(player._pIGetHit, Swap32LE(packed.pIGetHit), player._pIGetHit == Swap32LE(packed.pIGetHit)); + ValidateFields(player._pIEnAc, Swap32LE(packed.pIEnAc), player._pIEnAc == Swap32LE(packed.pIEnAc)); + ValidateFields(player._pIFMinDam, Swap32LE(packed.pIFMinDam), player._pIFMinDam == Swap32LE(packed.pIFMinDam)); + ValidateFields(player._pIFMaxDam, Swap32LE(packed.pIFMaxDam), player._pIFMaxDam == Swap32LE(packed.pIFMaxDam)); + ValidateFields(player._pILMinDam, Swap32LE(packed.pILMinDam), player._pILMinDam == Swap32LE(packed.pILMinDam)); + ValidateFields(player._pILMaxDam, Swap32LE(packed.pILMaxDam), player._pILMaxDam == Swap32LE(packed.pILMaxDam)); ValidateFields(player._pMaxHPBase, player.calculateBaseLife(), player._pMaxHPBase <= player.calculateBaseLife()); ValidateFields(player._pMaxManaBase, player.calculateBaseMana(), player._pMaxManaBase <= player.calculateBaseMana()); diff --git a/Source/pfile.cpp b/Source/pfile.cpp index c070abe09..b6c7ff01f 100644 --- a/Source/pfile.cpp +++ b/Source/pfile.cpp @@ -23,6 +23,7 @@ #include "playerdat.hpp" #include "qol/stash.h" #include "utils/endian_read.hpp" +#include "utils/endian_swap.hpp" #include "utils/file_util.h" #include "utils/language.h" #include "utils/parse_int.hpp" @@ -340,9 +341,9 @@ void CreateDetailDiffs(std::string_view prefix, std::string_view memoryMapFile, app_fatal("read32BitInt failed. Too less bytes to read."); memcpy(&value, compareInfo.data.get() + compareInfo.currentPosition, sizeof(value)); if (useLE) - value = SDL_SwapLE32(value); + value = Swap32LE(value); else - value = SDL_SwapBE32(value); + value = Swap32BE(value); return value; }; diff --git a/Source/sync.cpp b/Source/sync.cpp index 94de0a91c..972a5e7d8 100644 --- a/Source/sync.cpp +++ b/Source/sync.cpp @@ -12,6 +12,7 @@ #include "monster.h" #include "monsters/validation.hpp" #include "player.h" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" namespace devilution { @@ -47,7 +48,7 @@ void SyncMonsterPos(TSyncMonster &monsterSync, int ndx) monsterSync._menemy = encode_enemy(monster); monsterSync._mdelta = sgnMonsterPriority[ndx] > 255 ? 255 : sgnMonsterPriority[ndx]; monsterSync.mWhoHit = monster.whoHit; - monsterSync._mhitpoints = SDL_SwapLE32(monster.hitPoints); + monsterSync._mhitpoints = Swap32LE(monster.hitPoints); sgnMonsterPriority[ndx] = 0xFFFF; sgwLRU[ndx] = monster.activeForTicks == 0 ? 0xFFFF : 0xFFFE; @@ -111,27 +112,27 @@ void SyncPlrInv(TSyncHeader *pHdr) auto &item = Items[pHdr->bItemI]; pHdr->bItemX = item.position.x; pHdr->bItemY = item.position.y; - pHdr->wItemIndx = SDL_SwapLE16(item.IDidx); + pHdr->wItemIndx = Swap16LE(item.IDidx); if (item.IDidx == IDI_EAR) { - pHdr->wItemCI = SDL_SwapLE16((item._iIName[0] << 8) | item._iIName[1]); - pHdr->dwItemSeed = SDL_SwapLE32((item._iIName[2] << 24) | (item._iIName[3] << 16) | (item._iIName[4] << 8) | item._iIName[5]); + pHdr->wItemCI = Swap16LE((item._iIName[0] << 8) | item._iIName[1]); + pHdr->dwItemSeed = Swap32LE((item._iIName[2] << 24) | (item._iIName[3] << 16) | (item._iIName[4] << 8) | item._iIName[5]); pHdr->bItemId = item._iIName[6]; pHdr->bItemDur = item._iIName[7]; pHdr->bItemMDur = item._iIName[8]; pHdr->bItemCh = item._iIName[9]; pHdr->bItemMCh = item._iIName[10]; - pHdr->wItemVal = SDL_SwapLE16((item._iIName[11] << 8) | ((item._iCurs - ICURS_EAR_SORCERER) << 6) | item._ivalue); - pHdr->dwItemBuff = SDL_SwapLE32((item._iIName[12] << 24) | (item._iIName[13] << 16) | (item._iIName[14] << 8) | item._iIName[15]); + pHdr->wItemVal = Swap16LE((item._iIName[11] << 8) | ((item._iCurs - ICURS_EAR_SORCERER) << 6) | item._ivalue); + pHdr->dwItemBuff = Swap32LE((item._iIName[12] << 24) | (item._iIName[13] << 16) | (item._iIName[14] << 8) | item._iIName[15]); } else { - pHdr->wItemCI = SDL_SwapLE16(item._iCreateInfo); - pHdr->dwItemSeed = SDL_SwapLE32(item._iSeed); + pHdr->wItemCI = Swap16LE(item._iCreateInfo); + pHdr->dwItemSeed = Swap32LE(item._iSeed); pHdr->bItemId = item._iIdentified ? 1 : 0; pHdr->bItemDur = item._iDurability; pHdr->bItemMDur = item._iMaxDur; pHdr->bItemCh = item._iCharges; pHdr->bItemMCh = item._iMaxCharges; if (item.IDidx == IDI_GOLD) { - pHdr->wItemVal = SDL_SwapLE16(item._ivalue); + pHdr->wItemVal = Swap16LE(item._ivalue); } } } @@ -141,9 +142,9 @@ void SyncPlrInv(TSyncHeader *pHdr) const auto &item = MyPlayer->InvBody[sgnSyncPInv]; if (!item.isEmpty()) { pHdr->bPInvLoc = sgnSyncPInv; - pHdr->wPInvIndx = SDL_SwapLE16(item.IDidx); - pHdr->wPInvCI = SDL_SwapLE16(item._iCreateInfo); - pHdr->dwPInvSeed = SDL_SwapLE32(item._iSeed); + pHdr->wPInvIndx = Swap16LE(item.IDidx); + pHdr->wPInvCI = Swap16LE(item._iCreateInfo); + pHdr->dwPInvSeed = Swap32LE(item._iSeed); pHdr->bPInvId = item._iIdentified ? 1 : 0; } @@ -268,14 +269,14 @@ size_t sync_all_monsters(std::byte *pbBuf, size_t dwMaxLen) pHdr->wLen += sizeof(TSyncMonster); dwMaxLen -= sizeof(TSyncMonster); } - pHdr->wLen = SDL_SwapLE16(pHdr->wLen); + pHdr->wLen = Swap16LE(pHdr->wLen); return dwMaxLen; } size_t OnSyncData(const TSyncHeader &header, size_t maxCmdSize, const Player &player) { - const uint16_t wLen = SDL_SwapLE16(header.wLen); + const uint16_t wLen = Swap16LE(header.wLen); if (!ValidateCmdSize(wLen + sizeof(header), maxCmdSize, player.getId())) return maxCmdSize; diff --git a/Source/utils/endian_swap.hpp b/Source/utils/endian_swap.hpp index 3aafc669c..d0cb30363 100644 --- a/Source/utils/endian_swap.hpp +++ b/Source/utils/endian_swap.hpp @@ -10,7 +10,7 @@ namespace devilution { -constexpr uint16_t Swap16LE(uint16_t val) +inline uint16_t Swap16LE(uint16_t val) { #ifdef USE_SDL3 return SDL_Swap16LE(val); @@ -19,7 +19,16 @@ constexpr uint16_t Swap16LE(uint16_t val) #endif } -constexpr uint32_t Swap32LE(uint32_t val) +inline uint16_t Swap16BE(uint16_t val) +{ +#ifdef USE_SDL3 + return SDL_Swap16BE(val); +#else + return SDL_SwapBE16(val); +#endif +} + +inline uint32_t Swap32LE(uint32_t val) { #ifdef USE_SDL3 return SDL_Swap32LE(val); @@ -28,4 +37,31 @@ constexpr uint32_t Swap32LE(uint32_t val) #endif } +inline uint32_t Swap32BE(uint32_t val) +{ +#ifdef USE_SDL3 + return SDL_Swap32BE(val); +#else + return SDL_SwapBE32(val); +#endif +} + +inline uint64_t Swap64LE(uint64_t val) +{ +#ifdef USE_SDL3 + return SDL_Swap64LE(val); +#else + return SDL_SwapLE64(val); +#endif +} + +inline uint64_t Swap64BE(uint64_t val) +{ +#ifdef USE_SDL3 + return SDL_Swap64BE(val); +#else + return SDL_SwapBE64(val); +#endif +} + } // namespace devilution diff --git a/Source/utils/language.cpp b/Source/utils/language.cpp index 607fc4864..8e0c8c0a9 100644 --- a/Source/utils/language.cpp +++ b/Source/utils/language.cpp @@ -11,6 +11,7 @@ #include "engine/assets.hpp" #include "options.h" #include "utils/algorithm/container.hpp" +#include "utils/endian_swap.hpp" #include "utils/file_util.h" #include "utils/log.hpp" #include "utils/paths.h" @@ -72,12 +73,12 @@ struct MoHead { void SwapLE(MoHead &head) { - head.magic = SDL_SwapLE32(head.magic); - head.revision.major = SDL_SwapLE16(head.revision.major); - head.revision.minor = SDL_SwapLE16(head.revision.minor); - head.nbMappings = SDL_SwapLE32(head.nbMappings); - head.srcOffset = SDL_SwapLE32(head.srcOffset); - head.dstOffset = SDL_SwapLE32(head.dstOffset); + head.magic = Swap32LE(head.magic); + head.revision.major = Swap16LE(head.revision.major); + head.revision.minor = Swap16LE(head.revision.minor); + head.nbMappings = Swap32LE(head.nbMappings); + head.srcOffset = Swap32LE(head.srcOffset); + head.dstOffset = Swap32LE(head.dstOffset); } struct MoEntry { @@ -87,8 +88,8 @@ struct MoEntry { void SwapLE(MoEntry &entry) { - entry.length = SDL_SwapLE32(entry.length); - entry.offset = SDL_SwapLE32(entry.offset); + entry.length = Swap32LE(entry.length); + entry.offset = Swap32LE(entry.offset); } std::string_view TrimLeft(std::string_view str) diff --git a/Source/utils/surface_to_pcx.cpp b/Source/utils/surface_to_pcx.cpp index efe441872..fe03f9332 100644 --- a/Source/utils/surface_to_pcx.cpp +++ b/Source/utils/surface_to_pcx.cpp @@ -6,18 +6,36 @@ #include #include +#ifdef USE_SDL3 +#include +#include +#else #include +#endif + #include #include "engine/surface.hpp" +#include "utils/endian_swap.hpp" #include "utils/pcx.hpp" namespace devilution { namespace { -tl::expected CheckedFWrite(const void *ptr, size_t size, SDL_RWops *out) +tl::expected CheckedFWrite(const void *ptr, size_t size, +#ifdef USE_SDL3 + SDL_IOStream * +#else + SDL_RWops * +#endif + out) { - if (SDL_RWwrite(out, ptr, size, 1) != 1) { +#ifdef USE_SDL3 + if (SDL_WriteIO(out, ptr, size) != size) +#else + if (SDL_RWwrite(out, ptr, size, 1) != 1) +#endif + { const char *errorMessage = SDL_GetError(); if (errorMessage == nullptr) errorMessage = ""; @@ -35,7 +53,13 @@ tl::expected CheckedFWrite(const void *ptr, size_t size, SDL_ * @param out File stream to write to * @return True on success */ -tl::expected WritePcxHeader(int16_t width, int16_t height, SDL_RWops *out) +tl::expected WritePcxHeader(int16_t width, int16_t height, +#ifdef USE_SDL3 + SDL_IOStream * +#else + SDL_RWops * +#endif + out) { PCXHeader buffer; @@ -44,12 +68,12 @@ tl::expected WritePcxHeader(int16_t width, int16_t height, SD buffer.Version = 5; buffer.Encoding = 1; buffer.BitsPerPixel = 8; - buffer.Xmax = SDL_SwapLE16(width - 1); - buffer.Ymax = SDL_SwapLE16(height - 1); - buffer.HDpi = SDL_SwapLE16(width); - buffer.VDpi = SDL_SwapLE16(height); + buffer.Xmax = Swap16LE(width - 1); + buffer.Ymax = Swap16LE(height - 1); + buffer.HDpi = Swap16LE(width); + buffer.VDpi = Swap16LE(height); buffer.NPlanes = 1; - buffer.BytesPerLine = SDL_SwapLE16(width); + buffer.BytesPerLine = Swap16LE(width); return CheckedFWrite(&buffer, sizeof(buffer), out); } @@ -60,7 +84,13 @@ tl::expected WritePcxHeader(int16_t width, int16_t height, SD * @param out File stream for the PCX file. * @return True if successful, else false */ -tl::expected WritePcxPalette(SDL_Color *palette, SDL_RWops *out) +tl::expected WritePcxPalette(SDL_Color *palette, +#ifdef USE_SDL3 + SDL_IOStream * +#else + SDL_RWops * +#endif + out) { uint8_t pcxPalette[1 + 256 * 3]; @@ -123,7 +153,13 @@ uint8_t *WritePcxLine(uint8_t *src, uint8_t *dst, int width) * @param out File stream for the PCX file. * @return True if successful, else false */ -tl::expected WritePcxPixels(const Surface &buf, SDL_RWops *out) +tl::expected WritePcxPixels(const Surface &buf, +#ifdef USE_SDL3 + SDL_IOStream * +#else + SDL_RWops * +#endif + out) { const int width = buf.w(); const std::unique_ptr pBuffer { new uint8_t[static_cast(2 * width)] }; @@ -140,7 +176,13 @@ tl::expected WritePcxPixels(const Surface &buf, SDL_RWops *ou } // namespace tl::expected -WriteSurfaceToFilePcx(const Surface &buf, SDL_RWops *outStream) +WriteSurfaceToFilePcx(const Surface &buf, +#ifdef USE_SDL3 + SDL_IOStream * +#else + SDL_RWops * +#endif + outStream) { tl::expected result = WritePcxHeader(buf.w(), buf.h(), outStream); if (!result.has_value()) return result; @@ -148,7 +190,11 @@ WriteSurfaceToFilePcx(const Surface &buf, SDL_RWops *outStream) if (!result.has_value()) return result; result = WritePcxPalette(buf.surface->format->palette->colors, outStream); if (!result.has_value()) return result; +#ifdef USE_SDL3 + SDL_CloseIO(outStream); +#else SDL_RWclose(outStream); +#endif return {}; } diff --git a/Source/utils/surface_to_pcx.hpp b/Source/utils/surface_to_pcx.hpp index bb82e0ac7..d6206838b 100644 --- a/Source/utils/surface_to_pcx.hpp +++ b/Source/utils/surface_to_pcx.hpp @@ -1,7 +1,12 @@ -#include #include +#ifdef USE_SDL3 +#include +#include +#else #include +#endif + #include #include "engine/surface.hpp" @@ -9,6 +14,12 @@ namespace devilution { tl::expected -WriteSurfaceToFilePcx(const Surface &buf, SDL_RWops *outStream); +WriteSurfaceToFilePcx(const Surface &buf, +#ifdef USE_SDL3 + SDL_IOStream * +#else + SDL_RWops * +#endif + outStream); } // namespace devilution diff --git a/test/drlg_test.hpp b/test/drlg_test.hpp index 247089aeb..d0a816eae 100644 --- a/test/drlg_test.hpp +++ b/test/drlg_test.hpp @@ -13,6 +13,7 @@ #include "multi.h" #include "player.h" #include "quests.h" +#include "utils/endian_swap.hpp" #include "utils/paths.h" using namespace devilution; @@ -88,7 +89,7 @@ void TestCreateDungeon(int level, uint32_t seed, lvl_entry entry) for (int y = 0; y < DMAXY; y++) { for (int x = 0; x < DMAXX; x++) { - auto tileId = static_cast(SDL_SwapLE16(*tileLayer)); + auto tileId = static_cast(Swap16LE(*tileLayer)); tileLayer++; ASSERT_EQ(dungeon[x][y], tileId) << "Tiles don't match at " << x << "x" << y; } @@ -98,7 +99,7 @@ void TestCreateDungeon(int level, uint32_t seed, lvl_entry entry) for (int y = 16; y < 16 + DMAXY * 2; y++) { for (int x = 16; x < 16 + DMAXX * 2; x++) { - auto sectorId = static_cast(SDL_SwapLE16(*transparentLayer)); + auto sectorId = static_cast(Swap16LE(*transparentLayer)); transparentLayer++; ASSERT_EQ(dTransVal[x][y], sectorId) << "Room/region indexes don't match at " << x << "x" << y; } diff --git a/test/pack_test.cpp b/test/pack_test.cpp index f988de2b8..84a8558b6 100644 --- a/test/pack_test.cpp +++ b/test/pack_test.cpp @@ -8,6 +8,7 @@ #include "monstdat.h" #include "pack.h" #include "playerdat.hpp" +#include "utils/endian_swap.hpp" #include "utils/is_of.hpp" #include "utils/paths.h" @@ -16,34 +17,34 @@ namespace { void SwapLE(ItemPack &pack) { - pack.iSeed = SDL_SwapLE32(pack.iSeed); - pack.iCreateInfo = SDL_SwapLE16(pack.iCreateInfo); - pack.idx = SDL_SwapLE16(pack.idx); - pack.wValue = SDL_SwapLE16(pack.wValue); - pack.dwBuff = SDL_SwapLE32(pack.dwBuff); + pack.iSeed = Swap32LE(pack.iSeed); + pack.iCreateInfo = Swap16LE(pack.iCreateInfo); + pack.idx = Swap16LE(pack.idx); + pack.wValue = Swap16LE(pack.wValue); + pack.dwBuff = Swap32LE(pack.dwBuff); } void SwapLE(PlayerPack &pack) { - pack.dwLowDateTime = SDL_SwapLE32(pack.dwLowDateTime); - pack.dwHighDateTime = SDL_SwapLE32(pack.dwHighDateTime); - pack.pExperience = SDL_SwapLE32(pack.pExperience); - pack.pGold = SDL_SwapLE32(pack.pGold); - pack.pHPBase = SDL_SwapLE32(pack.pHPBase); - pack.pMaxHPBase = SDL_SwapLE32(pack.pMaxHPBase); - pack.pManaBase = SDL_SwapLE32(pack.pManaBase); - pack.pMaxManaBase = SDL_SwapLE32(pack.pMaxManaBase); - pack.pMemSpells = SDL_SwapLE64(pack.pMemSpells); + pack.dwLowDateTime = Swap32LE(pack.dwLowDateTime); + pack.dwHighDateTime = Swap32LE(pack.dwHighDateTime); + pack.pExperience = Swap32LE(pack.pExperience); + pack.pGold = Swap32LE(pack.pGold); + pack.pHPBase = Swap32LE(pack.pHPBase); + pack.pMaxHPBase = Swap32LE(pack.pMaxHPBase); + pack.pManaBase = Swap32LE(pack.pManaBase); + pack.pMaxManaBase = Swap32LE(pack.pMaxManaBase); + pack.pMemSpells = Swap64LE(pack.pMemSpells); for (ItemPack &item : pack.InvBody) SwapLE(item); for (ItemPack &item : pack.InvList) SwapLE(item); for (ItemPack &item : pack.SpdList) SwapLE(item); - pack.wReflections = SDL_SwapLE16(pack.wReflections); - pack.pDiabloKillLevel = SDL_SwapLE32(pack.pDiabloKillLevel); - pack.pDifficulty = SDL_SwapLE32(pack.pDifficulty); - pack.pDamAcFlags = SDL_SwapLE32(pack.pDamAcFlags); + pack.wReflections = Swap16LE(pack.wReflections); + pack.pDiabloKillLevel = Swap32LE(pack.pDiabloKillLevel); + pack.pDifficulty = Swap32LE(pack.pDifficulty); + pack.pDamAcFlags = Swap32LE(pack.pDamAcFlags); } ItemPack SwappedLE(const ItemPack &pack) @@ -834,7 +835,7 @@ TEST_F(PackTest, PackItem_empty) // Copy the value out before comparing to avoid loading a misaligned address. const auto idx = is.idx; - ASSERT_EQ(SDL_SwapLE16(idx), 0xFFFF); + ASSERT_EQ(Swap16LE(idx), 0xFFFF); TestItemNameGeneration(id); } @@ -845,7 +846,7 @@ static void compareGold(const ItemPack &is, int iCurs) ASSERT_EQ(id._iCurs, iCurs); ASSERT_EQ(id.IDidx, IDI_GOLD); // Copy the value out before comparing to avoid loading a misaligned address. - const auto wvalue = SDL_SwapLE16(is.wValue); + const auto wvalue = Swap16LE(is.wValue); ASSERT_EQ(id._ivalue, wvalue); ASSERT_EQ(id._itype, ItemType::Gold); ASSERT_EQ(id._iClass, ICLASS_GOLD); diff --git a/test/writehero_test.cpp b/test/writehero_test.cpp index ef9a86bf4..07f75a94a 100644 --- a/test/writehero_test.cpp +++ b/test/writehero_test.cpp @@ -16,6 +16,7 @@ #include "pack.h" #include "pfile.h" #include "playerdat.hpp" +#include "utils/endian_swap.hpp" #include "utils/file_util.h" #include "utils/paths.h" @@ -30,24 +31,24 @@ constexpr int SpellDatVanilla[] = { void SwapLE(ItemPack &pack) { - pack.iSeed = SDL_SwapLE32(pack.iSeed); - pack.iCreateInfo = SDL_SwapLE16(pack.iCreateInfo); - pack.idx = SDL_SwapLE16(pack.idx); - pack.wValue = SDL_SwapLE16(pack.wValue); - pack.dwBuff = SDL_SwapLE32(pack.dwBuff); + pack.iSeed = Swap32LE(pack.iSeed); + pack.iCreateInfo = Swap16LE(pack.iCreateInfo); + pack.idx = Swap16LE(pack.idx); + pack.wValue = Swap16LE(pack.wValue); + pack.dwBuff = Swap32LE(pack.dwBuff); } void SwapLE(PlayerPack &player) { - player.dwLowDateTime = SDL_SwapLE32(player.dwLowDateTime); - player.dwHighDateTime = SDL_SwapLE32(player.dwHighDateTime); - player.pExperience = SDL_SwapLE32(player.pExperience); - player.pGold = SDL_SwapLE32(player.pGold); - player.pHPBase = SDL_SwapLE32(player.pHPBase); - player.pMaxHPBase = SDL_SwapLE32(player.pMaxHPBase); - player.pManaBase = SDL_SwapLE32(player.pManaBase); - player.pMaxManaBase = SDL_SwapLE32(player.pMaxManaBase); - player.pMemSpells = SDL_SwapLE64(player.pMemSpells); + player.dwLowDateTime = Swap32LE(player.dwLowDateTime); + player.dwHighDateTime = Swap32LE(player.dwHighDateTime); + player.pExperience = Swap32LE(player.pExperience); + player.pGold = Swap32LE(player.pGold); + player.pHPBase = Swap32LE(player.pHPBase); + player.pMaxHPBase = Swap32LE(player.pMaxHPBase); + player.pManaBase = Swap32LE(player.pManaBase); + player.pMaxManaBase = Swap32LE(player.pMaxManaBase); + player.pMemSpells = Swap64LE(player.pMemSpells); for (ItemPack &item : player.InvBody) { SwapLE(item); } @@ -57,10 +58,10 @@ void SwapLE(PlayerPack &player) for (ItemPack &item : player.SpdList) { SwapLE(item); } - player.wReflections = SDL_SwapLE16(player.wReflections); - player.pDiabloKillLevel = SDL_SwapLE32(player.pDiabloKillLevel); - player.pDifficulty = SDL_SwapLE32(player.pDifficulty); - player.pDamAcFlags = SDL_SwapLE32(player.pDamAcFlags); + player.wReflections = Swap16LE(player.wReflections); + player.pDiabloKillLevel = Swap32LE(player.pDiabloKillLevel); + player.pDifficulty = Swap32LE(player.pDifficulty); + player.pDamAcFlags = Swap32LE(player.pDamAcFlags); } void PackItemUnique(ItemPack *id, int idx)