mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

♻️Migrate more code away from miniwin

pull/1958/head
Anders Jenbo 5 years ago
parent
29a488738e
commit
a095bc0bf7
28 changed files with 194 additions and 216 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      Source/DiabloUI/art.cpp
  2. 1
      Source/automap.cpp
  3. 11
      Source/codec.cpp
  4. 6
      Source/codec.h
  5. 4
      Source/dthread.cpp
  6. 2
      Source/dthread.h
  7. 8
      Source/encrypt.cpp
  8. 10
      Source/encrypt.h
  9. 2
      Source/engine.cpp
  10. 9
      Source/loadsave.cpp
  11. 8
      Source/mpqapi.cpp
  12. 4
      Source/mpqapi.h
  13. 152
      Source/msg.cpp
  14. 8
      Source/msg.h
  15. 51
      Source/multi.cpp
  16. 10
      Source/multi.h
  17. 79
      Source/pfile.cpp
  18. 5
      Source/pfile.h
  19. 2
      Source/player.cpp
  20. 4
      Source/sound.cpp
  21. 2
      Source/storm/storm.h
  22. 2
      Source/storm/storm_sdl_rw.cpp
  23. 2
      Source/storm/storm_svid.cpp
  24. 7
      Source/sync.cpp
  25. 6
      Source/sync.h
  26. 4
      Source/tmsg.cpp
  27. 8
      Source/tmsg.h
  28. 1
      Source/utils/soundsample.h

2
Source/DiabloUI/art.cpp
Unescape View File

@ -32,7 +32,7 @@ bool LoadPcxPixelsAndPalette(HANDLE handle, int width, int height, std::uint8_t
BYTE *buffer, std::size_t bufferPitch, SDL_Color *palette)
{
const bool has256ColorPalette = palette != nullptr && bpp == 8;
std::uint32_t pixelDataSize = SFileGetFileSize(handle, nullptr);
std::uint32_t pixelDataSize = SFileGetFileSize(handle);
if (pixelDataSize == static_cast<std::uint32_t>(-1)) {
return false;
}

1
Source/automap.cpp
Unescape View File

@ -10,7 +10,6 @@
#include "control.h"
#include "engine/render/automap_render.hpp"
#include "inv.h"
#include "miniwin/miniwin.h"
#include "monster.h"
#include "palette.h"
#include "player.h"

11
Source/codec.cpp
Unescape View File

@ -8,15 +8,16 @@
#include <cstdint>
#include "appfat.h"
#include "engine.h"
#include "miniwin/miniwin.h"
#include "sha.h"
namespace devilution {
struct CodecSignature {
DWORD checksum;
BYTE error;
BYTE last_chunk_size;
uint32_t checksum;
uint8_t error;
uint8_t last_chunk_size;
uint16_t unused;
};
@ -54,7 +55,7 @@ static void codec_init_key(const char *pszPassword)
memset(key, 0, sizeof(key));
}
int codec_decode(BYTE *pbSrcDst, DWORD size, const char *pszPassword)
std::size_t codec_decode(byte *pbSrcDst, std::size_t size, const char *pszPassword)
{
char buf[128];
char dst[SHA1HashSize];
@ -105,7 +106,7 @@ std::size_t codec_get_encoded_len(std::size_t dwSrcBytes)
return dwSrcBytes + sizeof(CodecSignature);
}
void codec_encode(BYTE *pbSrcDst, std::size_t size, std::size_t size_64, const char *pszPassword)
void codec_encode(byte *pbSrcDst, std::size_t size, std::size_t size_64, const char *pszPassword)
{
char buf[128];
char tmp[SHA1HashSize];

6
Source/codec.h
Unescape View File

@ -7,12 +7,12 @@
#include <cstddef>
#include "miniwin/miniwin.h"
#include "engine.h"
namespace devilution {
int codec_decode(BYTE *pbSrcDst, DWORD size, const char *pszPassword);
std::size_t codec_decode(byte *pbSrcDst, std::size_t size, const char *pszPassword);
std::size_t codec_get_encoded_len(std::size_t dwSrcBytes);
void codec_encode(BYTE *pbSrcDst, std::size_t size, std::size_t size_64, const char *pszPassword);
void codec_encode(byte *pbSrcDst, std::size_t size, std::size_t size_64, const char *pszPassword);
} // namespace devilution

4
Source/dthread.cpp
Unescape View File

@ -69,7 +69,7 @@ void dthread_remove_player(uint8_t pnum)
sgMemCrit.Leave();
}
void dthread_send_delta(int pnum, char cmd, void *pbSrc, int dwLen)
void dthread_send_delta(int pnum, _cmd_id cmd, byte *pbSrc, int dwLen)
{
TMegaPkt *pkt;
TMegaPkt *p;
@ -81,7 +81,7 @@ void dthread_send_delta(int pnum, char cmd, void *pbSrc, int dwLen)
pkt = static_cast<TMegaPkt *>(std::malloc(dwLen + 20));
pkt->pNext = nullptr;
pkt->dwSpaceLeft = pnum;
pkt->data[0] = cmd;
pkt->data[0] = static_cast<byte>(cmd);
*(DWORD *)&pkt->data[4] = dwLen;
memcpy(&pkt->data[8], pbSrc, dwLen);
sgMemCrit.Enter();

2
Source/dthread.h
Unescape View File

@ -8,7 +8,7 @@
namespace devilution {
void dthread_remove_player(uint8_t pnum);
void dthread_send_delta(int pnum, char cmd, void *pbSrc, int dwLen);
void dthread_send_delta(int pnum, _cmd_id cmd, byte *pbSrc, int dwLen);
void dthread_start();
void dthread_cleanup();

8
Source/encrypt.cpp
Unescape View File

@ -95,7 +95,7 @@ static void PkwareBufferWrite(char *buf, unsigned int *size, void *param)
pInfo->destOffset += *size;
}
uint32_t PkwareCompress(uint8_t *srcData, uint32_t size)
uint32_t PkwareCompress(byte *srcData, uint32_t size)
{
std::unique_ptr<char[]> ptr { new char[CMP_BUFFER_SIZE] };
@ -103,7 +103,7 @@ uint32_t PkwareCompress(uint8_t *srcData, uint32_t size)
if (destSize < 2 * 4096)
destSize = 2 * 4096;
std::unique_ptr<uint8_t[]> destData { new uint8_t[destSize] };
std::unique_ptr<byte[]> destData { new byte[destSize] };
TDataInfo param;
param.srcData = srcData;
@ -124,12 +124,12 @@ uint32_t PkwareCompress(uint8_t *srcData, uint32_t size)
return size;
}
void PkwareDecompress(uint8_t *inBuff, int recvSize, int maxBytes)
void PkwareDecompress(byte *inBuff, int recvSize, int maxBytes)
{
TDataInfo info;
std::unique_ptr<char[]> ptr { new char[CMP_BUFFER_SIZE] };
std::unique_ptr<uint8_t[]> outBuff { new uint8_t[maxBytes] };
std::unique_ptr<byte[]> outBuff { new byte[maxBytes] };
info.srcData = inBuff;
info.srcOffset = 0;

10
Source/encrypt.h
Unescape View File

@ -7,14 +7,14 @@
#include <cstdint>
#include "miniwin/miniwin.h"
#include "engine.h"
namespace devilution {
struct TDataInfo {
BYTE *srcData;
byte *srcData;
uint32_t srcOffset;
BYTE *destData;
byte *destData;
uint32_t destOffset;
uint32_t size;
};
@ -23,7 +23,7 @@ void Decrypt(uint32_t *castBlock, uint32_t size, uint32_t key);
void Encrypt(uint32_t *castBlock, uint32_t size, uint32_t key);
uint32_t Hash(const char *s, int type);
void InitHash();
uint32_t PkwareCompress(uint8_t *srcData, uint32_t size);
void PkwareDecompress(uint8_t *inBuff, int recvSize, int maxBytes);
uint32_t PkwareCompress(byte *srcData, uint32_t size);
void PkwareDecompress(byte *inBuff, int recvSize, int maxBytes);
} // namespace devilution

2
Source/engine.cpp
Unescape View File

@ -229,7 +229,7 @@ size_t GetFileSize(const char *pszName)
{
HANDLE file;
SFileOpenFile(pszName, &file);
const size_t fileLen = SFileGetFileSize(file, nullptr);
const size_t fileLen = SFileGetFileSize(file);
SFileCloseFileThreadSafe(file);
return fileLen;

9
Source/loadsave.cpp
Unescape View File

@ -14,6 +14,7 @@
#include "cursor.h"
#include "dead.h"
#include "doom.h"
#include "engine.h"
#include "init.h"
#include "inv.h"
#include "lighting.h"
@ -63,9 +64,9 @@ T SwapBE(T in)
}
class LoadHelper {
std::unique_ptr<uint8_t[]> m_buffer;
std::unique_ptr<byte[]> m_buffer;
uint32_t m_cur = 0;
uint32_t m_size;
size_t m_size;
template <class T>
T next()
@ -132,14 +133,14 @@ public:
class SaveHelper {
const char *m_szFileName;
std::unique_ptr<uint8_t[]> m_buffer;
std::unique_ptr<byte[]> m_buffer;
uint32_t m_cur = 0;
uint32_t m_capacity;
public:
SaveHelper(const char *szFileName, size_t bufferLen)
: m_szFileName(szFileName)
, m_buffer(new uint8_t[codec_get_encoded_len(bufferLen)])
, m_buffer(new byte[codec_get_encoded_len(bufferLen)])
, m_capacity(bufferLen)
{
}

8
Source/mpqapi.cpp
Unescape View File

@ -533,7 +533,7 @@ static _BLOCKENTRY *mpqapi_add_file(const char *pszName, _BLOCKENTRY *pBlk, int
return pBlk;
}
static bool mpqapi_write_file_contents(const char *pszName, const BYTE *pbData, DWORD dwLen, _BLOCKENTRY *pBlk)
static bool mpqapi_write_file_contents(const char *pszName, const byte *pbData, size_t dwLen, _BLOCKENTRY *pBlk)
{
const char *tmp;
while ((tmp = strchr(pszName, ':')))
@ -542,7 +542,7 @@ static bool mpqapi_write_file_contents(const char *pszName, const BYTE *pbData,
pszName = tmp + 1;
Hash(pszName, 3);
constexpr uint32_t sectorSize = 4096;
constexpr size_t sectorSize = 4096;
const uint32_t num_sectors = (dwLen + (sectorSize - 1)) / sectorSize;
const uint32_t offset_table_bytesize = sizeof(uint32_t) * (num_sectors + 1);
pBlk->offset = mpqapi_find_free_block(dwLen + offset_table_bytesize, &pBlk->sizealloc);
@ -578,7 +578,7 @@ static bool mpqapi_write_file_contents(const char *pszName, const BYTE *pbData,
#endif
uint32_t destsize = offset_table_bytesize;
BYTE mpq_buf[sectorSize];
byte mpq_buf[sectorSize];
std::size_t cur_sector = 0;
while (true) {
uint32_t len = std::min(dwLen, sectorSize);
@ -613,7 +613,7 @@ static bool mpqapi_write_file_contents(const char *pszName, const BYTE *pbData,
return true;
}
bool mpqapi_write_file(const char *pszName, const BYTE *pbData, DWORD dwLen)
bool mpqapi_write_file(const char *pszName, const byte *pbData, size_t dwLen)
{
_BLOCKENTRY *blockEntry;

4
Source/mpqapi.h
Unescape View File

@ -7,7 +7,7 @@
#include <cstdint>
#include "miniwin/miniwin.h"
#include "engine.h"
namespace devilution {
@ -39,7 +39,7 @@ struct _BLOCKENTRY {
void mpqapi_remove_hash_entry(const char *pszName);
void mpqapi_remove_hash_entries(bool (*fnGetName)(uint8_t, char *));
bool mpqapi_write_file(const char *pszName, const BYTE *pbData, DWORD dwLen);
bool mpqapi_write_file(const char *pszName, const byte *pbData, size_t dwLen);
void mpqapi_rename(char *pszOld, char *pszNew);
bool mpqapi_has_file(const char *pszName);
bool OpenMPQ(const char *pszArchive);

152
Source/msg.cpp
Unescape View File

@ -38,7 +38,7 @@ static int sgnCurrMegaPlayer;
static DLevel sgLevels[NUMLEVELS];
static BYTE sbLastCmd;
static TMegaPkt *sgpCurrPkt;
static BYTE sgRecvBuf[sizeof(DLevel) + 1];
static byte sgRecvBuf[sizeof(DLevel) + 1];
static BYTE sgbRecvCmd;
static LocalLevel sgLocals[NUMLEVELS];
static DJunk sgJunk;
@ -75,26 +75,32 @@ static void msg_free_packets()
static void msg_pre_packet()
{
int i = -1;
uint8_t playerId = -1;
for (TMegaPkt *pkt = sgpMegaPkt; pkt != nullptr; pkt = pkt->pNext) {
BYTE *data = pkt->data;
byte *data = pkt->data;
size_t spaceLeft = sizeof(pkt->data);
while (spaceLeft != pkt->dwSpaceLeft) {
if (*data == FAKE_CMD_SETID) {
auto cmdId = static_cast<_cmd_id>(*data);
if (cmdId == FAKE_CMD_SETID) {
auto *cmd = (TFakeCmdPlr *)data;
data += sizeof(*cmd);
spaceLeft -= sizeof(*cmd);
i = cmd->bPlr;
} else if (*data == FAKE_CMD_DROPID) {
playerId = cmd->bPlr;
continue;
}
if (cmdId == FAKE_CMD_DROPID) {
auto *cmd = (TFakeDropPlr *)data;
data += sizeof(*cmd);
spaceLeft -= sizeof(*cmd);
multi_player_left(cmd->bPlr, cmd->dwReason);
} else {
int pktSize = ParseCmd(i, (TCmd *)data);
data += pktSize;
spaceLeft -= pktSize;
continue;
}
int pktSize = ParseCmd(playerId, (TCmd *)data);
data += pktSize;
spaceLeft -= pktSize;
}
}
}
@ -202,11 +208,11 @@ void run_delta_info()
msg_free_packets();
}
static BYTE *DeltaExportItem(BYTE *dst, TCmdPItem *src)
static byte *DeltaExportItem(byte *dst, TCmdPItem *src)
{
for (int i = 0; i < MAXITEMS; i++, src++) {
if (src->bCmd == 0xFF)
*dst++ = 0xFF;
*dst++ = byte { 0xFF };
else {
memcpy(dst, src, sizeof(TCmdPItem));
dst += sizeof(TCmdPItem);
@ -216,10 +222,10 @@ static BYTE *DeltaExportItem(BYTE *dst, TCmdPItem *src)
return dst;
}
static BYTE *DeltaImportItem(BYTE *src, TCmdPItem *dst)
static byte *DeltaImportItem(byte *src, TCmdPItem *dst)
{
for (int i = 0; i < MAXITEMS; i++, dst++) {
if (*src == 0xFF) {
if (*src == byte { 0xFF }) {
memset(dst, 0xFF, sizeof(TCmdPItem));
src++;
} else {
@ -231,23 +237,23 @@ static BYTE *DeltaImportItem(BYTE *src, TCmdPItem *dst)
return src;
}
static BYTE *DeltaExportObject(BYTE *dst, DObjectStr *src)
static byte *DeltaExportObject(byte *dst, DObjectStr *src)
{
memcpy(dst, src, sizeof(DObjectStr) * MAXOBJECTS);
return dst + sizeof(DObjectStr) * MAXOBJECTS;
}
static BYTE *DeltaImportObject(BYTE *src, DObjectStr *dst)
static byte *DeltaImportObject(byte *src, DObjectStr *dst)
{
memcpy(dst, src, sizeof(DObjectStr) * MAXOBJECTS);
return src + sizeof(DObjectStr) * MAXOBJECTS;
}
static BYTE *DeltaExportMonster(BYTE *dst, DMonsterStr *src)
static byte *DeltaExportMonster(byte *dst, DMonsterStr *src)
{
for (int i = 0; i < MAXMONSTERS; i++, src++) {
if (src->_mx == 0xFF)
*dst++ = 0xFF;
*dst++ = byte { 0xFF };
else {
memcpy(dst, src, sizeof(DMonsterStr));
dst += sizeof(DMonsterStr);
@ -257,10 +263,10 @@ static BYTE *DeltaExportMonster(BYTE *dst, DMonsterStr *src)
return dst;
}
static BYTE *DeltaImportMonster(BYTE *src, DMonsterStr *dst)
static byte *DeltaImportMonster(byte *src, DMonsterStr *dst)
{
for (int i = 0; i < MAXMONSTERS; i++, dst++) {
if (*src == 0xFF) {
if (*src == byte { 0xFF }) {
memset(dst, 0xFF, sizeof(DMonsterStr));
src++;
} else {
@ -272,13 +278,13 @@ static BYTE *DeltaImportMonster(BYTE *src, DMonsterStr *dst)
return src;
}
static BYTE *DeltaExportJunk(BYTE *dst)
static byte *DeltaExportJunk(byte *dst)
{
int i, q;
for (i = 0; i < MAXPORTAL; i++) {
if (sgJunk.portal[i].x == 0xFF) {
*dst++ = 0xFF;
*dst++ = byte { 0xFF };
} else {
memcpy(dst, &sgJunk.portal[i], sizeof(DPortal));
dst += sizeof(DPortal);
@ -299,12 +305,12 @@ static BYTE *DeltaExportJunk(BYTE *dst)
return dst;
}
static void DeltaImportJunk(BYTE *src)
static void DeltaImportJunk(byte *src)
{
int i, q;
for (i = 0; i < MAXPORTAL; i++) {
if (*src == 0xFF) {
if (*src == byte { 0xFF }) {
memset(&sgJunk.portal[i], 0xFF, sizeof(DPortal));
src++;
SetPortalStats(i, false, 0, 0, 0, DTYPE_TOWN);
@ -333,12 +339,12 @@ static void DeltaImportJunk(BYTE *src)
}
}
static DWORD msg_comp_level(BYTE *buffer, BYTE *end)
static DWORD msg_comp_level(byte *buffer, byte *end)
{
DWORD size = end - buffer - 1;
DWORD pkSize = PkwareCompress(buffer + 1, size);
*buffer = size != pkSize;
*buffer = size != pkSize ? byte { 1 } : byte { 0 };
return pkSize + 1;
}
@ -347,31 +353,31 @@ void DeltaExportData(int pnum)
{
if (sgbDeltaChanged) {
int size;
std::unique_ptr<BYTE[]> dst { new BYTE[sizeof(DLevel) + 1] };
BYTE *dstEnd;
std::unique_ptr<byte[]> dst { new byte[sizeof(DLevel) + 1] };
byte *dstEnd;
for (int i = 0; i < NUMLEVELS; i++) {
dstEnd = &dst[1];
dstEnd = DeltaExportItem(dstEnd, sgLevels[i].item);
dstEnd = DeltaExportObject(dstEnd, sgLevels[i].object);
dstEnd = DeltaExportMonster(dstEnd, sgLevels[i].monster);
size = msg_comp_level(dst.get(), dstEnd);
dthread_send_delta(pnum, i + CMD_DLEVEL_0, dst.get(), size);
dthread_send_delta(pnum, static_cast<_cmd_id>(i + CMD_DLEVEL_0), dst.get(), size);
}
dstEnd = &dst[1];
dstEnd = DeltaExportJunk(dstEnd);
size = msg_comp_level(dst.get(), dstEnd);
dthread_send_delta(pnum, CMD_DLEVEL_JUNK, dst.get(), size);
}
char src = 0;
byte src { 0 };
dthread_send_delta(pnum, CMD_DLEVEL_END, &src, 1);
}
static void DeltaImportData(BYTE cmd, DWORD recv_offset)
{
if (sgRecvBuf[0] != 0)
if (sgRecvBuf[0] != byte { 0 })
PkwareDecompress(&sgRecvBuf[1], recv_offset, sizeof(sgRecvBuf) - 1);
BYTE *src = &sgRecvBuf[1];
byte *src = &sgRecvBuf[1];
if (cmd == CMD_DLEVEL_JUNK) {
DeltaImportJunk(src);
} else if (cmd >= CMD_DLEVEL_0 && cmd <= CMD_DLEVEL_24) {
@ -852,9 +858,9 @@ void NetSendCmd(bool bHiPri, _cmd_id bCmd)
cmd.bCmd = bCmd;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdGolem(BYTE mx, BYTE my, direction dir, BYTE menemy, int hp, BYTE cl)
@ -868,7 +874,7 @@ void NetSendCmdGolem(BYTE mx, BYTE my, direction dir, BYTE menemy, int hp, BYTE
cmd._menemy = menemy;
cmd._mhitpoints = hp;
cmd._currlevel = cl;
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdLoc(int playerId, bool bHiPri, _cmd_id bCmd, Point position)
@ -879,9 +885,9 @@ void NetSendCmdLoc(int playerId, bool bHiPri, _cmd_id bCmd, Point position)
cmd.x = position.x;
cmd.y = position.y;
if (bHiPri)
NetSendHiPri(playerId, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(playerId, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(playerId, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(playerId, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdLocParam1(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1)
@ -893,9 +899,9 @@ void NetSendCmdLocParam1(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa
cmd.y = position.y;
cmd.wParam1 = wParam1;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdLocParam2(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1, uint16_t wParam2)
@ -908,9 +914,9 @@ void NetSendCmdLocParam2(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa
cmd.wParam1 = wParam1;
cmd.wParam2 = wParam2;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdLocParam3(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wParam1, uint16_t wParam2, uint16_t wParam3)
@ -924,9 +930,9 @@ void NetSendCmdLocParam3(bool bHiPri, _cmd_id bCmd, Point position, uint16_t wPa
cmd.wParam2 = wParam2;
cmd.wParam3 = wParam3;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdParam1(bool bHiPri, _cmd_id bCmd, uint16_t wParam1)
@ -936,9 +942,9 @@ void NetSendCmdParam1(bool bHiPri, _cmd_id bCmd, uint16_t wParam1)
cmd.bCmd = bCmd;
cmd.wParam1 = wParam1;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdParam2(bool bHiPri, _cmd_id bCmd, uint16_t wParam1, uint16_t wParam2)
@ -949,9 +955,9 @@ void NetSendCmdParam2(bool bHiPri, _cmd_id bCmd, uint16_t wParam1, uint16_t wPar
cmd.wParam1 = wParam1;
cmd.wParam2 = wParam2;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdParam3(bool bHiPri, _cmd_id bCmd, uint16_t wParam1, uint16_t wParam2, uint16_t wParam3)
@ -963,9 +969,9 @@ void NetSendCmdParam3(bool bHiPri, _cmd_id bCmd, uint16_t wParam1, uint16_t wPar
cmd.wParam2 = wParam2;
cmd.wParam3 = wParam3;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdQuest(bool bHiPri, BYTE q)
@ -978,9 +984,9 @@ void NetSendCmdQuest(bool bHiPri, BYTE q)
cmd.qlog = quests[q]._qlog;
cmd.qvar1 = quests[q]._qvar1;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdGItem(bool bHiPri, _cmd_id bCmd, BYTE mast, BYTE pnum, BYTE ii)
@ -1026,9 +1032,9 @@ void NetSendCmdGItem(bool bHiPri, _cmd_id bCmd, BYTE mast, BYTE pnum, BYTE ii)
}
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdGItem2(bool usonly, _cmd_id bCmd, BYTE mast, BYTE pnum, TCmdGItem *p)
@ -1042,7 +1048,7 @@ void NetSendCmdGItem2(bool usonly, _cmd_id bCmd, BYTE mast, BYTE pnum, TCmdGItem
if (!usonly) {
cmd.dwTime = 0;
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
return;
}
@ -1053,7 +1059,7 @@ void NetSendCmdGItem2(bool usonly, _cmd_id bCmd, BYTE mast, BYTE pnum, TCmdGItem
return;
}
multi_msg_add((BYTE *)&cmd.bCmd, sizeof(cmd));
multi_msg_add((byte *)&cmd.bCmd, sizeof(cmd));
}
bool NetSendCmdReq2(_cmd_id bCmd, BYTE mast, BYTE pnum, TCmdGItem *p)
@ -1071,7 +1077,7 @@ bool NetSendCmdReq2(_cmd_id bCmd, BYTE mast, BYTE pnum, TCmdGItem *p)
else if (ticks - cmd.dwTime > 5000)
return false;
multi_msg_add((BYTE *)&cmd.bCmd, sizeof(cmd));
multi_msg_add((byte *)&cmd.bCmd, sizeof(cmd));
return true;
}
@ -1083,7 +1089,7 @@ void NetSendCmdExtra(TCmdGItem *p)
memcpy(&cmd, p, sizeof(cmd));
cmd.dwTime = 0;
cmd.bCmd = CMD_ITEMEXTRA;
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdPItem(bool bHiPri, _cmd_id bCmd, Point position)
@ -1124,9 +1130,9 @@ void NetSendCmdPItem(bool bHiPri, _cmd_id bCmd, Point position)
}
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdChItem(bool bHiPri, BYTE bLoc)
@ -1142,9 +1148,9 @@ void NetSendCmdChItem(bool bHiPri, BYTE bLoc)
cmd.dwBuff = plr[myplr].HoldItem.dwBuff;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdDelItem(bool bHiPri, BYTE bLoc)
@ -1154,9 +1160,9 @@ void NetSendCmdDelItem(bool bHiPri, BYTE bLoc)
cmd.bLoc = bLoc;
cmd.bCmd = CMD_DELPLRITEMS;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdDItem(bool bHiPri, int ii)
@ -1197,9 +1203,9 @@ void NetSendCmdDItem(bool bHiPri, int ii)
}
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
static bool i_own_level(int nReqLevel)
@ -1220,7 +1226,7 @@ static bool i_own_level(int nReqLevel)
return i == myplr;
}
void NetSendCmdDamage(bool bHiPri, BYTE bPlr, DWORD dwDam)
void NetSendCmdDamage(bool bHiPri, uint8_t bPlr, DWORD dwDam)
{
TCmdDamage cmd;
@ -1228,9 +1234,9 @@ void NetSendCmdDamage(bool bHiPri, BYTE bPlr, DWORD dwDam)
cmd.bPlr = bPlr;
cmd.dwDam = dwDam;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdMonDmg(bool bHiPri, uint16_t wMon, DWORD dwDam)
@ -1241,9 +1247,9 @@ void NetSendCmdMonDmg(bool bHiPri, uint16_t wMon, DWORD dwDam)
cmd.wMon = wMon;
cmd.dwDam = dwDam;
if (bHiPri)
NetSendHiPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendHiPri(myplr, (byte *)&cmd, sizeof(cmd));
else
NetSendLoPri(myplr, (BYTE *)&cmd, sizeof(cmd));
NetSendLoPri(myplr, (byte *)&cmd, sizeof(cmd));
}
void NetSendCmdString(uint32_t pmask, const char *pszStr)
@ -1254,7 +1260,7 @@ void NetSendCmdString(uint32_t pmask, const char *pszStr)
dwStrLen = strlen(pszStr);
cmd.bCmd = CMD_STRING;
strcpy(cmd.str, pszStr);
multi_send_msg_packet(pmask, (BYTE *)&cmd.bCmd, dwStrLen + 2);
multi_send_msg_packet(pmask, (byte *)&cmd.bCmd, dwStrLen + 2);
}
static DWORD On_STRING2(int pnum, TCmd *pCmd)
@ -1268,7 +1274,7 @@ static DWORD On_STRING2(int pnum, TCmd *pCmd)
return len + 2; // length of string + nul terminator + sizeof(p->bCmd)
}
static void delta_open_portal(int pnum, BYTE x, BYTE y, BYTE bLevel, dungeon_type bLType, BYTE bSetLvl)
static void delta_open_portal(int pnum, uint8_t x, uint8_t y, uint8_t bLevel, dungeon_type bLType, bool bSetLvl)
{
sgbDeltaChanged = true;
sgJunk.portal[pnum].x = x;
@ -1309,7 +1315,7 @@ static void msg_errorf(const char *pszFmt, ...)
static DWORD On_SYNCDATA(TCmd *pCmd, int pnum)
{
return sync_update(pnum, (const BYTE *)pCmd);
return sync_update(pnum, (const byte *)pCmd);
}
static DWORD On_WALKXY(TCmd *pCmd, int pnum)

8
Source/msg.h
Unescape View File

@ -356,7 +356,7 @@ struct TPktHdr {
struct TPkt {
TPktHdr hdr;
uint8_t body[493];
byte body[493];
};
struct DMonsterStr {
@ -406,13 +406,13 @@ struct DJunk {
struct TMegaPkt {
struct TMegaPkt *pNext;
uint32_t dwSpaceLeft;
uint8_t data[32000];
byte data[32000];
};
#pragma pack(pop)
struct TBuffer {
uint32_t dwNextWriteOffset;
uint8_t bData[4096];
byte bData[4096];
};
extern bool deltaload;
@ -447,7 +447,7 @@ void NetSendCmdPItem(bool bHiPri, _cmd_id bCmd, Point position);
void NetSendCmdChItem(bool bHiPri, BYTE bLoc);
void NetSendCmdDelItem(bool bHiPri, BYTE bLoc);
void NetSendCmdDItem(bool bHiPri, int ii);
void NetSendCmdDamage(bool bHiPri, BYTE bPlr, DWORD dwDam);
void NetSendCmdDamage(bool bHiPri, uint8_t bPlr, DWORD dwDam);
void NetSendCmdMonDmg(bool bHiPri, uint16_t bMon, DWORD dwDam);
void NetSendCmdString(uint32_t pmask, const char *pszStr);
void delta_close_portal(int pnum);

51
Source/multi.cpp
Unescape View File

@ -64,7 +64,7 @@ const event_type event_types[3] = {
static void buffer_init(TBuffer *pBuf)
{
pBuf->dwNextWriteOffset = 0;
pBuf->bData[0] = 0;
pBuf->bData[0] = byte { 0 };
}
// Microsoft VisualC 2-11/net runtime
@ -73,33 +73,28 @@ static int multi_check_pkt_valid(TBuffer *pBuf)
return pBuf->dwNextWriteOffset == 0;
}
static void multi_copy_packet(TBuffer *buf, void *packet, BYTE size)
static void multi_copy_packet(TBuffer *buf, byte *packet, uint8_t size)
{
BYTE *p;
if (buf->dwNextWriteOffset + size + 2 > 0x1000) {
return;
}
p = &buf->bData[buf->dwNextWriteOffset];
byte *p = &buf->bData[buf->dwNextWriteOffset];
buf->dwNextWriteOffset += size + 1;
*p = size;
*p = static_cast<byte>(size);
p++;
memcpy(p, packet, size);
p[size] = 0;
p[size] = byte { 0 };
}
static BYTE *multi_recv_packet(TBuffer *pBuf, BYTE *body, DWORD *size)
static byte *multi_recv_packet(TBuffer *pBuf, byte *body, DWORD *size)
{
BYTE *src_ptr;
size_t chunk_size;
if (pBuf->dwNextWriteOffset != 0) {
src_ptr = pBuf->bData;
byte *src_ptr = pBuf->bData;
while (true) {
if (*src_ptr == 0)
auto chunk_size = static_cast<uint8_t>(*src_ptr);
if (chunk_size == 0)
break;
chunk_size = *src_ptr;
if (chunk_size > *size)
break;
src_ptr++;
@ -131,7 +126,7 @@ static void NetRecvPlrData(TPkt *pkt)
pkt->hdr.bdex = plr[myplr]._pBaseDex;
}
void multi_msg_add(BYTE *pbMsg, BYTE bLen)
void multi_msg_add(byte *pbMsg, BYTE bLen)
{
if (pbMsg && bLen) {
tmsg_add(pbMsg, bLen);
@ -149,7 +144,7 @@ static void multi_send_packet(int playerId, void *packet, BYTE dwSize)
nthread_terminate_game("SNetSendMessage0");
}
void NetSendLoPri(int playerId, BYTE *pbMsg, BYTE bLen)
void NetSendLoPri(int playerId, byte *pbMsg, BYTE bLen)
{
if (pbMsg && bLen) {
multi_copy_packet(&sgLoPriBuf, pbMsg, bLen);
@ -157,10 +152,8 @@ void NetSendLoPri(int playerId, BYTE *pbMsg, BYTE bLen)
}
}
void NetSendHiPri(int playerId, BYTE *pbMsg, BYTE bLen)
void NetSendHiPri(int playerId, byte *pbMsg, BYTE bLen)
{
BYTE *hipri_body;
BYTE *lowpri_body;
DWORD size, len;
TPkt pkt;
@ -172,8 +165,8 @@ void NetSendHiPri(int playerId, BYTE *pbMsg, BYTE bLen)
gbShouldValidatePackage = true;
NetRecvPlrData(&pkt);
size = gdwNormalMsgSize - sizeof(TPktHdr);
hipri_body = multi_recv_packet(&sgHiPriBuf, pkt.body, &size);
lowpri_body = multi_recv_packet(&sgLoPriBuf, hipri_body, &size);
byte *hipri_body = multi_recv_packet(&sgHiPriBuf, pkt.body, &size);
byte *lowpri_body = multi_recv_packet(&sgLoPriBuf, hipri_body, &size);
size = sync_all_monsters(lowpri_body, size);
len = gdwNormalMsgSize - size;
pkt.hdr.wLen = len;
@ -182,7 +175,7 @@ void NetSendHiPri(int playerId, BYTE *pbMsg, BYTE bLen)
}
}
void multi_send_msg_packet(uint32_t pmask, BYTE *src, BYTE len)
void multi_send_msg_packet(uint32_t pmask, byte *src, BYTE len)
{
DWORD v, p, t;
TPkt pkt;
@ -429,7 +422,7 @@ bool multi_handle_delta()
return true;
}
static void multi_handle_all_packets(int pnum, BYTE *pData, int nSize)
static void multi_handle_all_packets(int pnum, byte *pData, int nSize)
{
int nLen;
@ -448,8 +441,8 @@ static void multi_process_tmsgs()
int cnt;
TPkt pkt;
while ((cnt = tmsg_get((BYTE *)&pkt)) != 0) {
multi_handle_all_packets(myplr, (BYTE *)&pkt, cnt);
while ((cnt = tmsg_get((byte *)&pkt)) != 0) {
multi_handle_all_packets(myplr, (byte *)&pkt, cnt);
}
}
@ -509,13 +502,13 @@ void multi_process_network_packets()
}
}
}
multi_handle_all_packets(dwID, (BYTE *)(pkt + 1), dwMsgSize - sizeof(TPktHdr));
multi_handle_all_packets(dwID, (byte *)(pkt + 1), dwMsgSize - sizeof(TPktHdr));
}
if (SErrGetLastError() != STORM_ERROR_NO_MESSAGES_WAITING)
nthread_terminate_game("SNetReceiveMsg");
}
void multi_send_zero_packet(int pnum, _cmd_id bCmd, BYTE *pbSrc, DWORD dwLen)
void multi_send_zero_packet(int pnum, _cmd_id bCmd, byte *pbSrc, DWORD dwLen)
{
DWORD dwOffset, dwBody, dwMsg;
TPkt pkt;
@ -580,12 +573,12 @@ void multi_send_zero_packet(int pnum, _cmd_id bCmd, BYTE *pbSrc, DWORD dwLen)
}
}
static void multi_send_pinfo(int pnum, char cmd)
static void multi_send_pinfo(int pnum, _cmd_id cmd)
{
PkPlayerStruct pkplr;
PackPlayer(&pkplr, plr[myplr], true);
dthread_send_delta(pnum, cmd, &pkplr, sizeof(pkplr));
dthread_send_delta(pnum, cmd, (byte *)&pkplr, sizeof(pkplr));
}
static dungeon_type InitLevelType(int l)

10
Source/multi.h
Unescape View File

@ -47,16 +47,16 @@ extern char szPlayerName[128];
extern BYTE gbDeltaSender;
extern uint32_t player_state[MAX_PLRS];
void multi_msg_add(BYTE *pbMsg, BYTE bLen);
void NetSendLoPri(int playerId, BYTE *pbMsg, BYTE bLen);
void NetSendHiPri(int playerId, BYTE *pbMsg, BYTE bLen);
void multi_send_msg_packet(uint32_t pmask, BYTE *src, BYTE len);
void multi_msg_add(byte *pbMsg, BYTE bLen);
void NetSendLoPri(int playerId, byte *pbMsg, BYTE bLen);
void NetSendHiPri(int playerId, byte *pbMsg, BYTE bLen);
void multi_send_msg_packet(uint32_t pmask, byte *src, BYTE len);
void multi_msg_countdown();
void multi_player_left(int pnum, int reason);
void multi_net_ping();
bool multi_handle_delta();
void multi_process_network_packets();
void multi_send_zero_packet(int pnum, _cmd_id bCmd, BYTE *pbSrc, DWORD dwLen);
void multi_send_zero_packet(int pnum, _cmd_id bCmd, byte *pbSrc, DWORD dwLen);
void NetClose();
bool NetInit(bool bSinglePlayer);
bool multi_init_single(GameData *gameData);

79
Source/pfile.cpp
Unescape View File

@ -8,6 +8,7 @@
#include <string>
#include "codec.h"
#include "engine.h"
#include "init.h"
#include "loadsave.h"
#include "mainmenu.h"
@ -27,7 +28,7 @@ namespace devilution {
namespace {
std::string GetSavePath(DWORD save_num)
std::string GetSavePath(uint32_t save_num)
{
std::string path = paths::PrefPath();
const char *ext = ".sv";
@ -89,11 +90,10 @@ bool GetTempSaveNames(uint8_t dwIndex, char *szTemp)
void pfile_rename_temp_to_perm()
{
DWORD dwIndex;
char szTemp[MAX_PATH];
char szPerm[MAX_PATH];
dwIndex = 0;
uint32_t dwIndex = 0;
while (GetTempSaveNames(dwIndex, szTemp)) {
[[maybe_unused]] bool result = GetPermSaveNames(dwIndex, szPerm); // DO NOT PUT DIRECTLY INTO ASSERT!
assert(result);
@ -120,9 +120,9 @@ const char *pfile_get_password()
return gbIsMultiplayer ? PASSWORD_MULTI : PASSWORD_SINGLE;
}
static DWORD pfile_get_save_num_from_name(const char *name)
static uint32_t pfile_get_save_num_from_name(const char *name)
{
DWORD i;
uint32_t i;
for (i = 0; i < MAX_CHARACTERS; i++) {
if (strcasecmp(hero_names[i], name) == 0)
@ -132,33 +132,35 @@ static DWORD pfile_get_save_num_from_name(const char *name)
return i;
}
static std::unique_ptr<uint8_t[]> pfile_read_archive(HANDLE archive, const char *pszName, uint32_t *pdwLen)
static std::unique_ptr<byte[]> pfile_read_archive(HANDLE archive, const char *pszName, size_t *pdwLen = nullptr)
{
DWORD nread;
HANDLE file;
if (!SFileOpenFileEx(archive, pszName, 0, &file))
return nullptr;
*pdwLen = SFileGetFileSize(file, nullptr);
if (*pdwLen == 0)
size_t length = SFileGetFileSize(file);
if (length == 0)
return nullptr;
std::unique_ptr<uint8_t[]> buf { new uint8_t[*pdwLen] };
if (!SFileReadFileThreadSafe(file, buf.get(), *pdwLen, &nread))
std::unique_ptr<byte[]> buf { new byte[length] };
if (!SFileReadFileThreadSafe(file, buf.get(), length))
return nullptr;
SFileCloseFileThreadSafe(file);
*pdwLen = codec_decode(buf.get(), *pdwLen, pfile_get_password());
if (*pdwLen == 0)
length = codec_decode(buf.get(), length, pfile_get_password());
if (length == 0)
return nullptr;
if (pdwLen != nullptr)
*pdwLen = length;
return buf;
}
static bool pfile_read_hero(HANDLE archive, PkPlayerStruct *pPack)
{
DWORD read;
size_t read;
auto buf = pfile_read_archive(archive, "hero", &read);
if (buf == nullptr)
@ -176,14 +178,14 @@ static bool pfile_read_hero(HANDLE archive, PkPlayerStruct *pPack)
static void pfile_encode_hero(const PkPlayerStruct *pack)
{
size_t packedLen = codec_get_encoded_len(sizeof(*pack));
std::unique_ptr<uint8_t[]> packed { new uint8_t[packedLen] };
std::unique_ptr<byte[]> packed { new byte[packedLen] };
memcpy(packed.get(), pack, sizeof(*pack));
codec_encode(packed.get(), sizeof(*pack), packedLen, pfile_get_password());
mpqapi_write_file("hero", packed.get(), packedLen);
}
static bool pfile_open_archive(DWORD save_num)
static bool pfile_open_archive(uint32_t save_num)
{
if (OpenMPQ(GetSavePath(save_num).c_str()))
return true;
@ -191,7 +193,7 @@ static bool pfile_open_archive(DWORD save_num)
return false;
}
static HANDLE pfile_open_save_archive(DWORD save_num)
static HANDLE pfile_open_save_archive(uint32_t save_num)
{
HANDLE archive;
@ -258,7 +260,7 @@ bool pfile_ui_set_hero_infos(bool (*ui_add_hero_info)(_uiheroinfo *))
{
memset(hero_names, 0, sizeof(hero_names));
for (DWORD i = 0; i < MAX_CHARACTERS; i++) {
for (uint32_t i = 0; i < MAX_CHARACTERS; i++) {
HANDLE archive = pfile_open_save_archive(i);
if (archive != nullptr) {
PkPlayerStruct pkplr;
@ -291,8 +293,7 @@ bool pfile_archive_contains_game(HANDLE hsArchive)
if (gbIsMultiplayer)
return false;
uint32_t dwLen;
auto gameData = pfile_read_archive(hsArchive, "game", &dwLen);
auto gameData = pfile_read_archive(hsArchive, "game");
if (gameData == nullptr)
return false;
@ -311,10 +312,9 @@ void pfile_ui_set_class_stats(unsigned int player_class_nr, _uidefaultstats *cla
bool pfile_ui_save_create(_uiheroinfo *heroinfo)
{
DWORD save_num;
PkPlayerStruct pkplr;
save_num = pfile_get_save_num_from_name(heroinfo->name);
uint32_t save_num = pfile_get_save_num_from_name(heroinfo->name);
if (save_num >= MAX_CHARACTERS) {
for (save_num = 0; save_num < MAX_CHARACTERS; save_num++) {
if (!hero_names[save_num][0])
@ -372,9 +372,7 @@ bool pfile_get_file_name(uint8_t lvl, char *dst)
bool pfile_delete_save(_uiheroinfo *hero_info)
{
DWORD save_num;
save_num = pfile_get_save_num_from_name(hero_info->name);
uint32_t save_num = pfile_get_save_num_from_name(hero_info->name);
if (save_num < MAX_CHARACTERS) {
hero_names[save_num][0] = '\0';
RemoveFile(GetSavePath(save_num).c_str());
@ -385,10 +383,9 @@ bool pfile_delete_save(_uiheroinfo *hero_info)
void pfile_read_player_from_save(char name[16], int playerId)
{
HANDLE archive;
DWORD save_num;
PkPlayerStruct pkplr;
save_num = pfile_get_save_num_from_name(name);
uint32_t save_num = pfile_get_save_num_from_name(name);
archive = pfile_open_save_archive(save_num);
if (archive == nullptr)
app_fatal("%s", _("Unable to open archive"));
@ -414,7 +411,7 @@ bool LevelFileExists()
GetPermLevelNames(szName);
DWORD save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
uint32_t save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
if (!pfile_open_archive(save_num))
app_fatal("%s", _("Unable to read to save file archive"));
@ -433,15 +430,12 @@ void GetTempLevelNames(char *szTemp)
void GetPermLevelNames(char *szPerm)
{
DWORD save_num;
bool has_file;
save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
uint32_t save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
GetTempLevelNames(szPerm);
if (!pfile_open_archive(save_num))
app_fatal("%s", _("Unable to read to save file archive"));
has_file = mpqapi_has_file(szPerm);
bool has_file = mpqapi_has_file(szPerm);
mpqapi_flush_and_close(true);
if (!has_file) {
if (setlevel)
@ -456,31 +450,18 @@ void pfile_remove_temp_files()
if (gbIsMultiplayer)
return;
DWORD save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
uint32_t save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
if (!pfile_open_archive(save_num))
app_fatal("%s", _("Unable to write to save file archive"));
mpqapi_remove_hash_entries(GetTempSaveNames);
mpqapi_flush_and_close(true);
}
void pfile_write_save_file(const char *pszName, BYTE *pbData, DWORD dwLen, DWORD qwLen)
{
DWORD save_num;
save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
codec_encode(pbData, dwLen, qwLen, pfile_get_password());
if (!pfile_open_archive(save_num))
app_fatal("%s", _("Unable to write to save file archive"));
mpqapi_write_file(pszName, pbData, qwLen);
mpqapi_flush_and_close(true);
}
std::unique_ptr<uint8_t[]> pfile_read(const char *pszName, DWORD *pdwLen)
std::unique_ptr<byte[]> pfile_read(const char *pszName, size_t *pdwLen)
{
DWORD save_num;
HANDLE archive;
save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
uint32_t save_num = pfile_get_save_num_from_name(plr[myplr]._pName);
archive = pfile_open_save_archive(save_num);
if (archive == nullptr)
return nullptr;

5
Source/pfile.h
Unescape View File

@ -23,7 +23,7 @@ public:
~PFileScopedArchiveWriter();
private:
DWORD save_num_;
int save_num_;
bool clear_tables_;
};
@ -40,8 +40,7 @@ bool LevelFileExists();
void GetTempLevelNames(char *szTemp);
void GetPermLevelNames(char *szPerm);
void pfile_remove_temp_files();
void pfile_write_save_file(const char *pszName, BYTE *pbData, DWORD dwLen, DWORD qwLen);
std::unique_ptr<uint8_t[]> pfile_read(const char *pszName, DWORD *pdwLen);
std::unique_ptr<byte[]> pfile_read(const char *pszName, size_t *pdwLen);
void pfile_update(bool force_save);
} // namespace devilution

2
Source/player.cpp
Unescape View File

@ -537,7 +537,7 @@ static DWORD GetPlrGFXSize(HeroClass c, const char *szCel)
sprintf(pszName, "PlrGFX\\%s\\%s\\%s%s.CL2", ClassPathTbl[static_cast<std::size_t>(c)], Type, Type, szCel);
if (SFileOpenFile(pszName, &hsFile)) {
assert(hsFile);
dwSize = SFileGetFileSize(hsFile, nullptr);
dwSize = SFileGetFileSize(hsFile);
SFileCloseFileThreadSafe(hsFile);
if (dwMaxSize <= dwSize) {
dwMaxSize = dwSize;

4
Source/sound.cpp
Unescape View File

@ -45,7 +45,7 @@ void LoadMusic(HANDLE handle)
#ifndef DISABLE_STREAMING_MUSIC
SDL_RWops *musicRw = SFileRw_FromStormHandle(handle);
#else
int bytestoread = SFileGetFileSize(handle, 0);
int bytestoread = SFileGetFileSize(handle);
musicBuffer = new char[bytestoread];
SFileReadFileThreadSafe(handle, musicBuffer, bytestoread);
SFileCloseFileThreadSafe(handle);
@ -174,7 +174,7 @@ std::unique_ptr<TSnd> sound_file_load(const char *path, bool stream)
if (!SFileOpenFile(path, &file)) {
ErrDlg("SFileOpenFile failed", path, __FILE__, __LINE__);
}
DWORD dwBytes = SFileGetFileSize(file, nullptr);
DWORD dwBytes = SFileGetFileSize(file);
auto wave_file = MakeArraySharedPtr<std::uint8_t>(dwBytes);
SFileReadFileThreadSafe(file, wave_file.get(), dwBytes);
error = snd->DSB.SetChunk(wave_file, dwBytes);

2
Source/storm/storm.h
Unescape View File

@ -252,7 +252,7 @@ bool WINAPI SFileOpenArchive(const char *szMpqName, DWORD dwPriority, DWORD dwFl
bool WINAPI SFileCloseArchive(HANDLE hArchive);
bool WINAPI SFileOpenFileEx(HANDLE hMpq, const char *szFileName, DWORD dwSearchScope, HANDLE *phFile);
bool WINAPI SFileReadFile(HANDLE hFile, void *buffer, DWORD nNumberOfBytesToRead, DWORD *read, int *lpDistanceToMoveHigh);
DWORD WINAPI SFileGetFileSize(HANDLE hFile, uint32_t *lpFileSizeHigh);
DWORD WINAPI SFileGetFileSize(HANDLE hFile, uint32_t *lpFileSizeHigh = nullptr);
DWORD WINAPI SFileSetFilePointer(HANDLE, int, int *, int);
bool WINAPI SFileCloseFile(HANDLE hFile);

2
Source/storm/storm_sdl_rw.cpp
Unescape View File

@ -22,7 +22,7 @@ static void SFileRwSetHandle(struct SDL_RWops *context, HANDLE handle)
#ifndef USE_SDL1
static Sint64 SFileRwSize(struct SDL_RWops *context)
{
return SFileGetFileSize(SFileRwGetHandle(context), nullptr);
return SFileGetFileSize(SFileRwGetHandle(context));
}
#endif

2
Source/storm/storm_svid.cpp
Unescape View File

@ -155,7 +155,7 @@ bool SVidPlayBegin(const char *filename, int flags, HANDLE *video)
FILE *file = FILE_FromStormHandle(*video);
SVidSMK = smk_open_filepointer(file, SMK_MODE_DISK);
#else
int bytestoread = SFileGetFileSize(*video, nullptr);
int bytestoread = SFileGetFileSize(*video);
SVidBuffer = std::unique_ptr<uint8_t[]> { new uint8_t[bytestoread] };
SFileReadFileThreadSafe(*video, SVidBuffer.get(), bytestoread);
SFileCloseFileThreadSafe(*video);

7
Source/sync.cpp
Unescape View File

@ -158,7 +158,7 @@ static void SyncPlrInv(TSyncHeader *pHdr)
} // namespace
uint32_t sync_all_monsters(const BYTE *pbBuf, uint32_t dwMaxLen)
uint32_t sync_all_monsters(const byte *pbBuf, uint32_t dwMaxLen)
{
TSyncHeader *pHdr;
int i;
@ -252,12 +252,11 @@ static void sync_monster(int pnum, const TSyncMonster *p)
decode_enemy(ndx, p->_menemy);
}
uint32_t sync_update(int pnum, const BYTE *pbBuf)
uint32_t sync_update(int pnum, const byte *pbBuf)
{
TSyncHeader *pHdr;
uint16_t wLen;
pHdr = (TSyncHeader *)pbBuf;
TSyncHeader *pHdr = (TSyncHeader *)pbBuf;
pbBuf += sizeof(*pHdr);
if (pHdr->bCmd != CMD_SYNCDATA) {

6
Source/sync.h
Unescape View File

@ -7,12 +7,12 @@
#include <cstdint>
#include "miniwin/miniwin.h"
#include "engine.h"
namespace devilution {
uint32_t sync_all_monsters(const BYTE *pbBuf, uint32_t dwMaxLen);
uint32_t sync_update(int pnum, const BYTE *pbBuf);
uint32_t sync_all_monsters(const byte *pbBuf, uint32_t dwMaxLen);
uint32_t sync_update(int pnum, const byte *pbBuf);
void sync_init();
} // namespace devilution

4
Source/tmsg.cpp
Unescape View File

@ -15,7 +15,7 @@ TMsg *sgpTimedMsgHead;
} // namespace
int tmsg_get(BYTE *pbMsg)
int tmsg_get(byte *pbMsg)
{
int len;
TMsg *head;
@ -34,7 +34,7 @@ int tmsg_get(BYTE *pbMsg)
return len;
}
void tmsg_add(BYTE *pbMsg, uint8_t bLen)
void tmsg_add(byte *pbMsg, uint8_t bLen)
{
TMsg **tail;

8
Source/tmsg.h
Unescape View File

@ -7,7 +7,7 @@
#include <cstdint>
#include "miniwin/miniwin.h"
#include "engine.h"
namespace devilution {
@ -22,12 +22,12 @@ struct TMsg {
TMsgHdr hdr;
// this is actually alignment padding, but the message body is appended to the struct
// so it's convenient to use byte-alignment and name it "body"
uint8_t body[3];
byte body[3];
};
#pragma pack(pop)
int tmsg_get(BYTE *pbMsg);
void tmsg_add(BYTE *pbMsg, uint8_t bLen);
int tmsg_get(byte *pbMsg);
void tmsg_add(byte *pbMsg, uint8_t bLen);
void tmsg_start();
void tmsg_cleanup();

1
Source/utils/soundsample.h
Unescape View File

@ -6,7 +6,6 @@
#include <Aulib/Stream.h>
#include "miniwin/miniwin.h"
#include "utils/stdcompat/shared_ptr_array.hpp"
namespace devilution {

Write Preview
Loading…
Cancel
Save