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

Handle cel/cl2 files as byte arrays

pull/1880/head
Anders Jenbo 5 years ago
parent
6474dea0a9
commit
f579b2f287
22 changed files with 230 additions and 245 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/control.cpp
  2. 2
      Source/dead.h
  3. 16
      Source/diablo.cpp
  4. 137
      Source/engine.cpp
  5. 86
      Source/engine.h
  6. 2
      Source/engine/animationinfo.cpp
  7. 6
      Source/engine/animationinfo.h
  8. 2
      Source/gendung.cpp
  9. 2
      Source/gendung.h
  10. 3
      Source/misdat.h
  11. 6
      Source/missiles.cpp
  12. 2
      Source/missiles.h
  13. 6
      Source/monster.cpp
  14. 6
      Source/monster.h
  15. 8
      Source/objects.cpp
  16. 2
      Source/objects.h
  17. 50
      Source/player.cpp
  18. 38
      Source/player.h
  19. 2
      Source/render.cpp
  20. 27
      Source/scrollrt.cpp
  21. 66
      Source/towners.cpp
  22. 4
      Source/towners.h

2
Source/control.cpp
Unescape View File

@ -77,7 +77,7 @@ char infostr[64];
int numpanbtns;
char panelstr[4][64];
bool panelflag;
BYTE SplTransTbl[256];
uint8_t SplTransTbl[256];
int initialDropGoldValue;
bool panbtndown;
bool spselflag;

2
Source/dead.h
Unescape View File

@ -15,7 +15,7 @@ namespace devilution {
static constexpr unsigned MaxDead = 31;
struct DeadStruct {
std::array<uint8_t *, 8> _deadData;
std::array<byte *, 8> _deadData;
int _deadFrame;
int _deadWidth;
uint8_t _deadtrans;

16
Source/diablo.cpp
Unescape View File

@ -1500,11 +1500,11 @@ void LoadLvlGFX()
switch (leveltype) {
case DTYPE_TOWN:
if (gbIsHellfire) {
pDungeonCels = LoadFileInMem<BYTE>("NLevels\\TownData\\Town.CEL");
pDungeonCels = LoadFileInMem("NLevels\\TownData\\Town.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("NLevels\\TownData\\Town.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("NLevels\\TownData\\Town.MIN");
} else {
pDungeonCels = LoadFileInMem<BYTE>("Levels\\TownData\\Town.CEL");
pDungeonCels = LoadFileInMem("Levels\\TownData\\Town.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("Levels\\TownData\\Town.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("Levels\\TownData\\Town.MIN");
}
@ -1512,37 +1512,37 @@ void LoadLvlGFX()
break;
case DTYPE_CATHEDRAL:
if (currlevel < 21) {
pDungeonCels = LoadFileInMem<BYTE>("Levels\\L1Data\\L1.CEL");
pDungeonCels = LoadFileInMem("Levels\\L1Data\\L1.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("Levels\\L1Data\\L1.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("Levels\\L1Data\\L1.MIN");
pSpecialCels = LoadCel("Levels\\L1Data\\L1S.CEL", SpecialCelWidth);
} else {
pDungeonCels = LoadFileInMem<BYTE>("NLevels\\L5Data\\L5.CEL");
pDungeonCels = LoadFileInMem("NLevels\\L5Data\\L5.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("NLevels\\L5Data\\L5.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("NLevels\\L5Data\\L5.MIN");
pSpecialCels = LoadCel("NLevels\\L5Data\\L5S.CEL", SpecialCelWidth);
}
break;
case DTYPE_CATACOMBS:
pDungeonCels = LoadFileInMem<BYTE>("Levels\\L2Data\\L2.CEL");
pDungeonCels = LoadFileInMem("Levels\\L2Data\\L2.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("Levels\\L2Data\\L2.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("Levels\\L2Data\\L2.MIN");
pSpecialCels = LoadCel("Levels\\L2Data\\L2S.CEL", SpecialCelWidth);
break;
case DTYPE_CAVES:
if (currlevel < 17) {
pDungeonCels = LoadFileInMem<BYTE>("Levels\\L3Data\\L3.CEL");
pDungeonCels = LoadFileInMem("Levels\\L3Data\\L3.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("Levels\\L3Data\\L3.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("Levels\\L3Data\\L3.MIN");
} else {
pDungeonCels = LoadFileInMem<BYTE>("NLevels\\L6Data\\L6.CEL");
pDungeonCels = LoadFileInMem("NLevels\\L6Data\\L6.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("NLevels\\L6Data\\L6.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("NLevels\\L6Data\\L6.MIN");
}
pSpecialCels = LoadCel("Levels\\L1Data\\L1S.CEL", SpecialCelWidth);
break;
case DTYPE_HELL:
pDungeonCels = LoadFileInMem<BYTE>("Levels\\L4Data\\L4.CEL");
pDungeonCels = LoadFileInMem("Levels\\L4Data\\L4.CEL");
pMegaTiles = LoadFileInMem<MegaTile>("Levels\\L4Data\\L4.TIL");
pLevelPieces = LoadFileInMem<uint16_t>("Levels\\L4Data\\L4.MIN");
pSpecialCels = LoadCel("Levels\\L2Data\\L2S.CEL", SpecialCelWidth);

137
Source/engine.cpp
Unescape View File

@ -77,7 +77,7 @@ constexpr std::uint8_t GetCelTransparentWidth(std::uint8_t control)
constexpr std::uint8_t MaxCl2Width = 65;
BYTE *GetLightTable(char light)
uint8_t *GetLightTable(char light)
{
int idx = 4096;
if (light == 2)
@ -91,19 +91,19 @@ BYTE *GetLightTable(char light)
CelSprite LoadCel(const char *pszName, int width)
{
return CelSprite(LoadFileInMem<BYTE>(pszName), width);
return CelSprite(LoadFileInMem(pszName), width);
}
CelSprite LoadCel(const char *pszName, const int *widths)
{
return CelSprite(LoadFileInMem<BYTE>(pszName), widths);
return CelSprite(LoadFileInMem(pszName), widths);
}
std::pair<int, int> MeasureSolidHorizontalBounds(const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *src = CelGetFrame(cel.Data(), frame, &nDataSize);
const BYTE *end = src + nDataSize;
auto src = reinterpret_cast<const uint8_t *>(CelGetFrame(cel.Data(), frame, &nDataSize));
auto end = &src[nDataSize];
const int celWidth = cel.Width(frame);
int xBegin = celWidth;
@ -149,22 +149,22 @@ std::pair<int, int> MeasureSolidHorizontalBounds(const CelSprite &cel, int frame
void CelDrawTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrame(cel.Data(), frame, &nDataSize);
auto pRLEBytes = reinterpret_cast<const uint8_t *>(CelGetFrame(cel.Data(), frame, &nDataSize));
CelBlitSafeTo(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame));
}
void CelClippedDrawTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
CelBlitSafeTo(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame));
}
void CelDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame, BYTE *tbl)
void CelDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame, uint8_t *tbl)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrame(cel.Data(), frame, &nDataSize);
auto pRLEBytes = reinterpret_cast<const uint8_t *>(CelGetFrame(cel.Data(), frame, &nDataSize));
if (light_table_index != 0 || tbl != nullptr)
CelBlitLightSafeTo(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame), tbl);
@ -175,7 +175,7 @@ void CelDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite
void CelClippedDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
if (light_table_index != 0)
CelBlitLightSafeTo(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame), nullptr);
@ -186,14 +186,14 @@ void CelClippedDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const Cel
void CelDrawLightRedTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame, char light)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
BYTE *dst = out.at(sx, sy);
BYTE *tbl = GetLightTable(light);
uint8_t *tbl = GetLightTable(light);
const auto celWidth = cel.Width(frame);
for (const BYTE *end = &pRLEBytes[nDataSize]; pRLEBytes != end; dst -= out.pitch() + celWidth) {
for (const uint8_t *end = &pRLEBytes[nDataSize]; pRLEBytes != end; dst -= out.pitch() + celWidth) {
for (int w = celWidth; w > 0;) {
BYTE width = *pRLEBytes++;
uint8_t width = *pRLEBytes++;
if (!IsCelTransparent(width)) {
w -= width;
while (width > 0) {
@ -211,16 +211,16 @@ void CelDrawLightRedTo(const CelOutputBuffer &out, int sx, int sy, const CelSpri
}
}
void CelBlitSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth)
void CelBlitSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth)
{
assert(pRLEBytes != nullptr);
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
for (; src != &pRLEBytes[nDataSize]; dst -= out.pitch() + nWidth) {
for (int w = nWidth; w > 0;) {
BYTE width = *src++;
uint8_t width = *src++;
if (!IsCelTransparent(width)) {
w -= width;
if (dst < out.end() && dst >= out.begin()) {
@ -240,15 +240,15 @@ void CelBlitSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEB
void CelClippedDrawSafeTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
CelBlitSafeTo(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame));
}
void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth, BYTE *tbl)
void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth, uint8_t *tbl)
{
assert(pRLEBytes != nullptr);
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
if (tbl == nullptr)
@ -256,7 +256,7 @@ void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *
for (; src != &pRLEBytes[nDataSize]; dst -= out.pitch() + nWidth) {
for (int w = nWidth; w > 0;) {
BYTE width = *src++;
uint8_t width = *src++;
if (!IsCelTransparent(width)) {
w -= width;
if (dst < out.end() && dst > out.begin()) {
@ -294,18 +294,18 @@ void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *
}
}
void CelBlitLightTransSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth)
void CelBlitLightTransSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth)
{
assert(pRLEBytes != nullptr);
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
BYTE *tbl = &pLightTbl[light_table_index * 256];
uint8_t *tbl = &pLightTbl[light_table_index * 256];
bool shift = ((size_t)dst % 2) != 0;
for (; src != &pRLEBytes[nDataSize]; dst -= out.pitch() + nWidth, shift = !shift) {
for (int w = nWidth; w > 0;) {
BYTE width = *src++;
uint8_t width = *src++;
if (!IsCelTransparent(width)) {
w -= width;
if (dst < out.end() && dst > out.begin()) {
@ -374,18 +374,18 @@ void CelBlitLightTransSafeTo(const CelOutputBuffer &out, int sx, int sy, const B
* @param nWidth Width of sprite
* @param tbl Palette translation table
*/
static void CelBlitLightBlendedSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth, BYTE *tbl)
static void CelBlitLightBlendedSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth, uint8_t *tbl)
{
assert(pRLEBytes != nullptr);
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
if (tbl == nullptr)
tbl = &pLightTbl[light_table_index * 256];
for (; src != &pRLEBytes[nDataSize]; dst -= out.pitch() + nWidth) {
for (int w = nWidth; w > 0;) {
BYTE width = *src++;
uint8_t width = *src++;
if (!IsCelTransparent(width)) {
w -= width;
if (dst < out.end() && dst > out.begin()) {
@ -426,7 +426,7 @@ static void CelBlitLightBlendedSafeTo(const CelOutputBuffer &out, int sx, int sy
void CelClippedBlitLightTransTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
if (cel_transparency_active) {
if (sgOptions.Graphics.bBlendedTransparancy)
@ -442,16 +442,16 @@ void CelClippedBlitLightTransTo(const CelOutputBuffer &out, int sx, int sy, cons
void CelDrawLightRedSafeTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame, char light)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
BYTE *dst = out.at(sx, sy);
BYTE *tbl = GetLightTable(light);
const BYTE *end = &pRLEBytes[nDataSize];
uint8_t *tbl = GetLightTable(light);
const uint8_t *end = &pRLEBytes[nDataSize];
const int celWidth = static_cast<int>(cel.Width(frame));
for (; pRLEBytes != end; dst -= out.pitch() + celWidth) {
for (int w = celWidth; w > 0;) {
BYTE width = *pRLEBytes++;
uint8_t width = *pRLEBytes++;
if (!IsCelTransparent(width)) {
w -= width;
if (dst < out.end() && dst > out.begin()) {
@ -477,14 +477,14 @@ void CelDrawLightRedSafeTo(const CelOutputBuffer &out, int sx, int sy, const Cel
void CelDrawUnsafeTo(const CelOutputBuffer &out, int x, int y, const CelSprite &cel, int frame)
{
int nDataSize;
const BYTE *pRLEBytes = CelGetFrame(cel.Data(), frame, &nDataSize);
const BYTE *end = &pRLEBytes[nDataSize];
auto *pRLEBytes = reinterpret_cast<const uint8_t *>(CelGetFrame(cel.Data(), frame, &nDataSize));
auto *end = &pRLEBytes[nDataSize];
BYTE *dst = out.at(x, y);
const int celWidth = static_cast<int>(cel.Width(frame));
for (; pRLEBytes != end; dst -= out.pitch() + celWidth) {
for (int w = celWidth; w > 0;) {
BYTE width = *pRLEBytes++;
auto width = *pRLEBytes++;
if (!IsCelTransparent(width)) {
w -= width;
memcpy(dst, pRLEBytes, width);
@ -499,18 +499,18 @@ void CelDrawUnsafeTo(const CelOutputBuffer &out, int x, int y, const CelSprite &
}
}
void CelBlitOutlineTo(const CelOutputBuffer &out, BYTE col, int sx, int sy, const CelSprite &cel, int frame, bool skipColorIndexZero)
void CelBlitOutlineTo(const CelOutputBuffer &out, uint8_t col, int sx, int sy, const CelSprite &cel, int frame, bool skipColorIndexZero)
{
int nDataSize;
const BYTE *src = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const BYTE *end = &src[nDataSize];
const uint8_t *src = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *end = &src[nDataSize];
BYTE *dst = out.at(sx, sy);
const int celWidth = static_cast<int>(cel.Width(frame));
for (; src != end; dst -= out.pitch() + celWidth) {
for (int w = celWidth; w > 0;) {
BYTE width = *src++;
uint8_t width = *src++;
if (!IsCelTransparent(width)) {
w -= width;
if (dst < out.end() && dst > out.begin()) {
@ -752,46 +752,19 @@ void LoadFileData(const char *pszName, byte *buffer, size_t fileLen)
SFileCloseFile(file);
}
/**
* @brief Load a file in to the given buffer
* @param pszName Path of file
* @param p Target buffer
* @return Size of file
*/
DWORD LoadFileWithMem(const char *pszName, BYTE *p)
{
assert(pszName);
if (p == nullptr) {
app_fatal("LoadFileWithMem(NULL):\n%s", pszName);
}
HANDLE hsFile;
SFileOpenFile(pszName, &hsFile);
DWORD dwFileLen = SFileGetFileSize(hsFile, nullptr);
if (dwFileLen == 0) {
app_fatal("Zero length SFILE:\n%s", pszName);
}
SFileReadFileThreadSafe(hsFile, p, dwFileLen);
SFileCloseFile(hsFile);
return dwFileLen;
}
/**
* @brief Apply the color swaps to a CL2 sprite
* @param p CL2 buffer
* @param ttbl Palette translation table
* @param nCel Frame number in CL2 file
*/
void Cl2ApplyTrans(BYTE *p, const std::array<uint8_t, 256> &ttbl, int nCel)
void Cl2ApplyTrans(byte *p, const std::array<uint8_t, 256> &ttbl, int nCel)
{
assert(p != nullptr);
for (int i = 1; i <= nCel; i++) {
int nDataSize;
BYTE *dst = CelGetFrame(p, i, &nDataSize) + 10;
auto dst = reinterpret_cast<uint8_t *>(CelGetFrame(p, i, &nDataSize) + 10);
nDataSize -= 10;
while (nDataSize > 0) {
char width = *dst++;
@ -826,9 +799,9 @@ void Cl2ApplyTrans(BYTE *p, const std::array<uint8_t, 256> &ttbl, int nCel)
* @param nDataSize Size of CL2 in bytes
* @param nWidth Width of sprite
*/
static void Cl2BlitSafe(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth)
static void Cl2BlitSafe(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth)
{
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
int w = nWidth;
@ -840,7 +813,7 @@ static void Cl2BlitSafe(const CelOutputBuffer &out, int sx, int sy, const BYTE *
if (width > MaxCl2Width) {
width -= MaxCl2Width;
nDataSize--;
BYTE fill = *src++;
uint8_t fill = *src++;
if (dst < out.end() && dst > out.begin()) {
w -= width;
while (width > 0) {
@ -901,9 +874,9 @@ static void Cl2BlitSafe(const CelOutputBuffer &out, int sx, int sy, const BYTE *
* @param nWidth Width of sprite
* @param col Color index from current palette
*/
static void Cl2BlitOutlineSafe(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth, BYTE col)
static void Cl2BlitOutlineSafe(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth, uint8_t col)
{
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
int w = nWidth;
@ -984,9 +957,9 @@ static void Cl2BlitOutlineSafe(const CelOutputBuffer &out, int sx, int sy, const
* @param nWidth With of CL2 sprite
* @param pTable Light color table
*/
static void Cl2BlitLightSafe(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth, BYTE *pTable)
static void Cl2BlitLightSafe(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth, uint8_t *pTable)
{
const BYTE *src = pRLEBytes;
const uint8_t *src = pRLEBytes;
BYTE *dst = out.at(sx, sy);
int w = nWidth;
@ -998,7 +971,7 @@ static void Cl2BlitLightSafe(const CelOutputBuffer &out, int sx, int sy, const B
if (width > MaxCl2Width) {
width -= MaxCl2Width;
nDataSize--;
BYTE fill = pTable[*src++];
uint8_t fill = pTable[*src++];
if (dst < out.end() && dst > out.begin()) {
w -= width;
while (width > 0) {
@ -1054,17 +1027,17 @@ void Cl2Draw(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, i
assert(frame > 0);
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
Cl2BlitSafe(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame));
}
void Cl2DrawOutline(const CelOutputBuffer &out, BYTE col, int sx, int sy, const CelSprite &cel, int frame)
void Cl2DrawOutline(const CelOutputBuffer &out, uint8_t col, int sx, int sy, const CelSprite &cel, int frame)
{
assert(frame > 0);
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const CelOutputBuffer &sub = out.subregionY(0, out.h() - 1);
Cl2BlitOutlineSafe(sub, sx, sy, pRLEBytes, nDataSize, cel.Width(frame), col);
@ -1075,7 +1048,7 @@ void Cl2DrawLightTbl(const CelOutputBuffer &out, int sx, int sy, const CelSprite
assert(frame > 0);
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
Cl2BlitLightSafe(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame), GetLightTable(light));
}
@ -1084,7 +1057,7 @@ void Cl2DrawLight(const CelOutputBuffer &out, int sx, int sy, const CelSprite &c
assert(frame > 0);
int nDataSize;
const BYTE *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
const uint8_t *pRLEBytes = CelGetFrameClipped(cel.Data(), frame, &nDataSize);
if (light_table_index != 0)
Cl2BlitLightSafe(out, sx, sy, pRLEBytes, nDataSize, cel.Width(frame), &pLightTbl[light_table_index * 256]);

86
Source/engine.h
Unescape View File

@ -139,13 +139,11 @@ struct ActorPosition {
Point temp;
};
inline BYTE *CelGetFrameStart(BYTE *pCelBuff, int nCel)
inline byte *CelGetFrameStart(byte *pCelBuff, int nCel)
{
DWORD *pFrameTable;
const uint32_t *pFrameTable = reinterpret_cast<const std::uint32_t *>(pCelBuff);
pFrameTable = (DWORD *)pCelBuff;
return pCelBuff + SDL_SwapLE32(pFrameTable[nCel]);
return &pCelBuff[SDL_SwapLE32(pFrameTable[nCel])];
}
template <typename T>
@ -172,29 +170,41 @@ constexpr uint32_t LoadBE32(const T *b)
#endif
}
inline BYTE *CelGetFrame(BYTE *pCelBuff, int nCel, int *nDataSize)
inline byte *CelGetFrame(byte *pCelBuff, int nCel, int *nDataSize)
{
DWORD nCellStart = LoadLE32(&pCelBuff[nCel * 4]);
*nDataSize = LoadLE32(&pCelBuff[(nCel + 1) * 4]) - nCellStart;
return pCelBuff + nCellStart;
auto frameTable = reinterpret_cast<const uint32_t *>(pCelBuff);
const uint32_t nCellStart = SDL_SwapLE32(frameTable[nCel]);
*nDataSize = SDL_SwapLE32(frameTable[nCel + 1]) - nCellStart;
return &pCelBuff[nCellStart];
}
inline const BYTE *CelGetFrame(const BYTE *pCelBuff, int nCel, int *nDataSize)
inline const byte *CelGetFrame(const byte *pCelBuff, int nCel, int *nDataSize)
{
DWORD nCellStart = LoadLE32(&pCelBuff[nCel * 4]);
*nDataSize = LoadLE32(&pCelBuff[(nCel + 1) * 4]) - nCellStart;
return pCelBuff + nCellStart;
auto frameTable = reinterpret_cast<const uint32_t *>(pCelBuff);
const uint32_t nCellStart = SDL_SwapLE32(frameTable[nCel]);
*nDataSize = SDL_SwapLE32(frameTable[nCel + 1]) - nCellStart;
return &pCelBuff[nCellStart];
}
inline const BYTE *CelGetFrameClipped(const BYTE *pCelBuff, int nCel, int *nDataSize)
struct FrameHeader {
uint16_t row0;
uint16_t row32;
uint16_t row64;
uint16_t row96;
uint16_t row128;
};
inline const uint8_t *CelGetFrameClipped(const byte *pCelBuff, int nCel, int *nDataSize)
{
DWORD nDataStart;
const BYTE *pRLEBytes = CelGetFrame(pCelBuff, nCel, nDataSize);
const byte *pRLEBytes = CelGetFrame(pCelBuff, nCel, nDataSize);
nDataStart = pRLEBytes[1] << 8 | pRLEBytes[0];
FrameHeader frameHeader;
memcpy(&frameHeader, pRLEBytes, sizeof(FrameHeader));
uint16_t nDataStart = SDL_SwapLE16(frameHeader.row0);
*nDataSize -= nDataStart;
return pRLEBytes + nDataStart;
return reinterpret_cast<const uint8_t *>(&pRLEBytes[nDataStart]);
}
struct CelOutputBuffer {
@ -265,16 +275,16 @@ struct CelOutputBuffer {
return *at(p.x, p.y);
}
BYTE *at(int x, int y) const
uint8_t *at(int x, int y) const
{
return static_cast<BYTE *>(surface->pixels) + region.x + x + surface->pitch * (region.y + y);
return static_cast<uint8_t *>(surface->pixels) + region.x + x + surface->pitch * (region.y + y);
}
BYTE *begin() const
uint8_t *begin() const
{
return at(0, 0);
}
BYTE *end() const
uint8_t *end() const
{
return at(0, region.h);
}
@ -328,14 +338,14 @@ struct CelOutputBuffer {
*/
class CelSprite {
public:
CelSprite(std::unique_ptr<BYTE[]> data, int width)
CelSprite(std::unique_ptr<byte[]> data, int width)
: data_(std::move(data))
, data_ptr_(data_.get())
, width_(width)
{
}
CelSprite(std::unique_ptr<BYTE[]> data, const int *widths)
CelSprite(std::unique_ptr<byte[]> data, const int *widths)
: data_(std::move(data))
, data_ptr_(data_.get())
, widths_(widths)
@ -346,7 +356,7 @@ public:
* Constructs an unowned sprite.
* Ideally we'd like to remove all uses of this constructor.
*/
CelSprite(const BYTE *data, int width)
CelSprite(const byte *data, int width)
: data_ptr_(data)
, width_(width)
{
@ -355,7 +365,7 @@ public:
CelSprite(CelSprite &&) noexcept = default;
CelSprite &operator=(CelSprite &&) noexcept = default;
[[nodiscard]] const BYTE *Data() const
[[nodiscard]] const byte *Data() const
{
return data_ptr_;
}
@ -366,8 +376,8 @@ public:
}
private:
std::unique_ptr<BYTE[]> data_;
const BYTE *data_ptr_;
std::unique_ptr<byte[]> data_;
const byte *data_ptr_;
int width_ = 0;
const int *widths_ = nullptr; // unowned
};
@ -422,7 +432,7 @@ void CelClippedDrawTo(const CelOutputBuffer &out, int sx, int sy, const CelSprit
* @param cel CEL sprite
* @param frame CEL frame number
*/
void CelDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame, BYTE *tbl);
void CelDrawLightTo(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, int frame, uint8_t *tbl);
/**
* @brief Same as CelDrawLightTo but with the option to skip parts of the top and bottom of the sprite
@ -463,7 +473,7 @@ void CelDrawLightRedTo(const CelOutputBuffer &out, int sx, int sy, const CelSpri
* @param pRLEBytes CEL pixel stream (run-length encoded)
* @param nDataSize Size of CEL in bytes
*/
void CelBlitSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth);
void CelBlitSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth);
/**
* @brief Same as CelClippedDrawTo but checks for drawing outside the buffer
@ -484,7 +494,7 @@ void CelClippedDrawSafeTo(const CelOutputBuffer &out, int sx, int sy, const CelS
* @param nDataSize Size of CEL in bytes
* @param tbl Palette translation table
*/
void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth, BYTE *tbl);
void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth, uint8_t *tbl);
/**
* @brief Same as CelBlitLightSafeTo but with stippled transparancy applied
@ -494,7 +504,7 @@ void CelBlitLightSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *
* @param pRLEBytes CEL pixel stream (run-length encoded)
* @param nDataSize Size of CEL in bytes
*/
void CelBlitLightTransSafeTo(const CelOutputBuffer &out, int sx, int sy, const BYTE *pRLEBytes, int nDataSize, int nWidth);
void CelBlitLightTransSafeTo(const CelOutputBuffer &out, int sx, int sy, const uint8_t *pRLEBytes, int nDataSize, int nWidth);
/**
* @brief Same as CelDrawLightRedTo but checks for drawing outside the buffer
@ -517,7 +527,7 @@ void CelDrawLightRedSafeTo(const CelOutputBuffer &out, int sx, int sy, const Cel
* @param frame CEL frame number
* @param skipColorIndexZero If true, color in index 0 will be treated as transparent (these are typically used for shadows in sprites)
*/
void CelBlitOutlineTo(const CelOutputBuffer &out, BYTE col, int sx, int sy, const CelSprite &cel, int frame, bool skipColorIndexZero = true);
void CelBlitOutlineTo(const CelOutputBuffer &out, uint8_t col, int sx, int sy, const CelSprite &cel, int frame, bool skipColorIndexZero = true);
/**
* @brief Set the value of a single pixel in the back buffer, checks bounds
@ -552,7 +562,7 @@ void Cl2Draw(const CelOutputBuffer &out, int sx, int sy, const CelSprite &cel, i
* @param pCelBuff CL2 buffer
* @param nCel CL2 frame number
*/
void Cl2DrawOutline(const CelOutputBuffer &out, BYTE col, int sx, int sy, const CelSprite &cel, int frame);
void Cl2DrawOutline(const CelOutputBuffer &out, uint8_t col, int sx, int sy, const CelSprite &cel, int frame);
/**
* @brief Blit CL2 sprite, and apply a given lighting, to the given buffer at the given coordianates
@ -636,8 +646,11 @@ size_t GetFileSize(const char *pszName);
void LoadFileData(const char *pszName, byte *buffer, size_t bufferSize);
template <typename T>
void LoadFileInMem(const char *path, T *data, std::size_t count)
void LoadFileInMem(const char *path, T *data, std::size_t count = 0)
{
if (count == 0)
count = GetFileSize(path);
LoadFileData(path, reinterpret_cast<byte *>(data), count * sizeof(T));
}
@ -671,8 +684,7 @@ std::unique_ptr<T[]> LoadFileInMem(const char *path, size_t *elements = nullptr)
return buf;
}
DWORD LoadFileWithMem(const char *pszName, BYTE *p);
void Cl2ApplyTrans(BYTE *p, const std::array<uint8_t, 256> &ttbl, int nCel);
void Cl2ApplyTrans(byte *p, const std::array<uint8_t, 256> &ttbl, int nCel);
void PlayInGameMovie(const char *pszMovie);
} // namespace devilution

2
Source/engine/animationinfo.cpp
Unescape View File

@ -52,7 +52,7 @@ int AnimationInfo::GetFrameToUseForRendering() const
return absoluteAnimationFrame;
}
void AnimationInfo::SetNewAnimation(uint8_t *pData, int numberOfFrames, int delayLen, AnimationDistributionFlags flags /*= AnimationDistributionFlags::None*/, int numSkippedFrames /*= 0*/, int distributeFramesBeforeFrame /*= 0*/)
void AnimationInfo::SetNewAnimation(byte *pData, int numberOfFrames, int delayLen, AnimationDistributionFlags flags /*= AnimationDistributionFlags::None*/, int numSkippedFrames /*= 0*/, int distributeFramesBeforeFrame /*= 0*/)
{
if ((flags & AnimationDistributionFlags::RepeatedAction) == AnimationDistributionFlags::RepeatedAction && distributeFramesBeforeFrame != 0 && NumberOfFrames == numberOfFrames && CurrentFrame >= distributeFramesBeforeFrame && CurrentFrame != NumberOfFrames) {
// We showed the same Animation (for example a melee attack) before but truncated the Animation.

6
Source/engine/animationinfo.h
Unescape View File

@ -8,6 +8,8 @@
#include <stdint.h>
#include <type_traits>
#include "engine.h"
namespace devilution {
/**
@ -37,7 +39,7 @@ public:
/*
* @brief Pointer to Animation Data
*/
uint8_t *pData;
byte *pData;
/*
* @brief Additional delay of each animation in the current animation
*/
@ -70,7 +72,7 @@ public:
* @param numSkippedFrames Number of Frames that will be skipped (for example with modifier "faster attack")
* @param distributeFramesBeforeFrame Distribute the numSkippedFrames only before this frame
*/
void SetNewAnimation(uint8_t *pData, int numberOfFrames, int delayLen, AnimationDistributionFlags flags = AnimationDistributionFlags::None, int numSkippedFrames = 0, int distributeFramesBeforeFrame = 0);
void SetNewAnimation(byte *pData, int numberOfFrames, int delayLen, AnimationDistributionFlags flags = AnimationDistributionFlags::None, int numSkippedFrames = 0, int distributeFramesBeforeFrame = 0);
/*
* @brief Process the Animation for a game tick (for example advances the frame)

2
Source/gendung.cpp
Unescape View File

@ -30,7 +30,7 @@ std::optional<CelSprite> pSpecialCels;
/** Specifies the tile definitions of the active dungeon type; (e.g. levels/l1data/l1.til). */
std::unique_ptr<MegaTile[]> pMegaTiles;
std::unique_ptr<uint16_t[]> pLevelPieces;
std::unique_ptr<BYTE[]> pDungeonCels;
std::unique_ptr<byte[]> pDungeonCels;
std::array<uint8_t, MAXTILES + 1> block_lvid;
std::array<bool, MAXTILES + 1> nBlockTable;
std::array<bool, MAXTILES + 1> nSolidTable;

2
Source/gendung.h
Unescape View File

@ -132,7 +132,7 @@ extern bool setloadflag;
extern std::optional<CelSprite> pSpecialCels;
extern std::unique_ptr<MegaTile[]> pMegaTiles;
extern std::unique_ptr<uint16_t[]> pLevelPieces;
extern std::unique_ptr<BYTE[]> pDungeonCels;
extern std::unique_ptr<byte[]> pDungeonCels;
/**
* List of transparancy masks to use for dPieces
*/

3
Source/misdat.h
Unescape View File

@ -8,6 +8,7 @@
#include <cstdint>
#include "effects.h"
#include "engine.h"
namespace devilution {
@ -105,7 +106,7 @@ typedef struct MisFileData {
uint8_t mAnimName;
uint8_t mAnimFAmt;
uint32_t mFlags;
BYTE *mAnimData[16];
byte *mAnimData[16];
uint8_t mAnimDelay[16];
uint8_t mAnimLen[16];
int16_t mAnimWidth[16];

6
Source/missiles.cpp
Unescape View File

@ -1140,16 +1140,16 @@ void LoadMissileGFX(BYTE mi)
char pszName[256];
if ((mfd->mFlags & MFLAG_ALLOW_SPECIAL) != 0) {
sprintf(pszName, "Missiles\\%s.CL2", mfd->mName);
BYTE *file = LoadFileInMem<BYTE>(pszName).release();
byte *file = LoadFileInMem(pszName).release();
for (unsigned i = 0; i < mfd->mAnimFAmt; i++)
mfd->mAnimData[i] = CelGetFrameStart(file, i);
} else if (mfd->mAnimFAmt == 1) {
sprintf(pszName, "Missiles\\%s.CL2", mfd->mName);
mfd->mAnimData[0] = LoadFileInMem<BYTE>(pszName).release();
mfd->mAnimData[0] = LoadFileInMem(pszName).release();
} else {
for (unsigned i = 0; i < mfd->mAnimFAmt; i++) {
sprintf(pszName, "Missiles\\%s%u.CL2", mfd->mName, i + 1);
mfd->mAnimData[i] = LoadFileInMem<BYTE>(pszName).release();
mfd->mAnimData[i] = LoadFileInMem(pszName).release();
}
}
}

2
Source/missiles.h
Unescape View File

@ -42,7 +42,7 @@ struct MissileStruct {
bool _miDelFlag; // Indicate whether the missile should be deleted
uint8_t _miAnimType;
int _miAnimFlags;
BYTE *_miAnimData;
byte *_miAnimData;
int _miAnimDelay; // Tick length of each frame in the current animation
int _miAnimLen; // Number of frames in current animation
int _miAnimWidth;

6
Source/monster.cpp
Unescape View File

@ -346,9 +346,9 @@ void InitMonsterGFX(int monst)
if ((animletter[anim] != 's' || monsterdata[mtype].has_special) && frames > 0) {
sprintf(strBuff, monsterdata[mtype].GraphicType, animletter[anim]);
BYTE *celBuf;
byte *celBuf;
{
auto celData = LoadFileInMem<BYTE>(strBuff);
auto celData = LoadFileInMem(strBuff);
celBuf = celData.get();
Monsters[monst].Anims[anim].CMem = std::move(celData);
}
@ -853,7 +853,7 @@ void PlaceUniqueMonst(int uniqindex, int miniontype, int bosspacksize)
}
sprintf(filestr, "Monsters\\Monsters\\%s.TRN", Uniq->mTrnName);
LoadFileWithMem(filestr, &pLightTbl[256 * (uniquetrans + 19)]);
LoadFileInMem("PlrGFX\\Infra.TRN", &pLightTbl[256 * (uniquetrans + 19)], 256);
Monst->_uniqtrans = uniquetrans++;

6
Source/monster.h
Unescape View File

@ -109,8 +109,8 @@ enum placeflag : uint8_t {
};
struct AnimStruct {
std::unique_ptr<uint8_t[]> CMem;
std::array<uint8_t *, 8> Data;
std::unique_ptr<byte[]> CMem;
std::array<byte *, 8> Data;
int Frames;
int Rate;
};
@ -147,7 +147,7 @@ struct MonsterStruct { // note: missing field _mAFNum
int _menemy;
/** Usually correspond's to the enemy's future position */
Point enemyPosition;
uint8_t *_mAnimData;
byte *_mAnimData;
/** Tick length of each frame in the current animation */
int _mAnimDelay;
/** Increases by one each game tick, counting how close we are to _pAnimDelay */

8
Source/objects.cpp
Unescape View File

@ -68,7 +68,7 @@ enum shrine_type : uint8_t {
int trapid;
int trapdir;
std::unique_ptr<BYTE[]> pObjCels[40];
std::unique_ptr<byte[]> pObjCels[40];
object_graphic_id ObjFileList[40];
int objectactive[MAXOBJECTS];
/** Specifies the number of active objects. */
@ -314,7 +314,7 @@ void InitObjectGFX()
sprintf(filestr, "Objects\\%s.CEL", ObjHiveLoadList[i]);
else if (currlevel >= 21)
sprintf(filestr, "Objects\\%s.CEL", ObjCryptLoadList[i]);
pObjCels[numobjfiles] = LoadFileInMem<BYTE>(filestr);
pObjCels[numobjfiles] = LoadFileInMem(filestr);
numobjfiles++;
}
}
@ -1225,7 +1225,7 @@ void SetMapObjects(const uint16_t *dunData, int startx, int starty)
ObjFileList[numobjfiles] = (object_graphic_id)i;
sprintf(filestr, "Objects\\%s.CEL", ObjMasterLoadList[i]);
pObjCels[numobjfiles] = LoadFileInMem<BYTE>(filestr);
pObjCels[numobjfiles] = LoadFileInMem(filestr);
numobjfiles++;
}
@ -2242,7 +2242,7 @@ void ObjSetMicro(int dx, int dy, int pn)
int blocks = leveltype != DTYPE_HELL ? 10 : 16;
uint16_t *piece = &pLevelPieces[blocks * pn ];
uint16_t *piece = &pLevelPieces[blocks * pn];
MICROS &micros = dpiece_defs_map_2[dx][dy];
for (int i = 0; i < blocks; i++) {

2
Source/objects.h
Unescape View File

@ -20,7 +20,7 @@ struct ObjectStruct {
Point position;
bool _oLight;
uint32_t _oAnimFlag;
unsigned char *_oAnimData;
byte *_oAnimData;
int _oAnimDelay; // Tick length of each frame in the current animation
int _oAnimCnt; // Increases by one each game tick, counting how close we are to _pAnimDelay
int _oAnimLen; // Number of frames in current animation

50
Source/player.cpp
Unescape View File

@ -291,7 +291,7 @@ void PlayerStruct::Stop()
destAction = ACTION_NONE;
}
void SetPlayerGPtrs(BYTE *pData, BYTE **pAnim)
void SetPlayerGPtrs(byte *pData, byte **pAnim)
{
int i;
@ -306,8 +306,8 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
char pszName[256];
const char *szCel;
PlayerStruct *p;
BYTE *pData, *pAnim;
DWORD i;
byte *pData;
byte **pAnim;
if ((DWORD)pnum >= MAX_PLRS) {
app_fatal("LoadPlrGFX: illegal player %d", pnum);
@ -325,7 +325,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
sprintf(prefix, "%c%c%c", CharChar[static_cast<std::size_t>(c)], ArmourChar[p->_pgfxnum >> 4], WepChar[p->_pgfxnum & 0xF]);
const char *cs = ClassPathTbl[static_cast<std::size_t>(c)];
for (i = 1; i <= PFILE_NONDEATH; i <<= 1) {
for (unsigned i = 1; i <= PFILE_NONDEATH; i <<= 1) {
if ((i & gfxflag) == 0) {
continue;
}
@ -337,7 +337,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
szCel = "ST";
}
pData = p->_pNData;
pAnim = (BYTE *)p->_pNAnim;
pAnim = p->_pNAnim;
break;
case PFILE_WALK:
szCel = "AW";
@ -345,7 +345,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
szCel = "WL";
}
pData = p->_pWData;
pAnim = (BYTE *)p->_pWAnim;
pAnim = p->_pWAnim;
break;
case PFILE_ATTACK:
if (leveltype == DTYPE_TOWN) {
@ -353,7 +353,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
}
szCel = "AT";
pData = p->_pAData;
pAnim = (BYTE *)p->_pAAnim;
pAnim = p->_pAAnim;
break;
case PFILE_HIT:
if (leveltype == DTYPE_TOWN) {
@ -361,7 +361,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
}
szCel = "HT";
pData = p->_pHData;
pAnim = (BYTE *)p->_pHAnim;
pAnim = p->_pHAnim;
break;
case PFILE_LIGHTNING:
if (leveltype == DTYPE_TOWN) {
@ -369,7 +369,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
}
szCel = "LM";
pData = p->_pLData;
pAnim = (BYTE *)p->_pLAnim;
pAnim = p->_pLAnim;
break;
case PFILE_FIRE:
if (leveltype == DTYPE_TOWN) {
@ -377,7 +377,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
}
szCel = "FM";
pData = p->_pFData;
pAnim = (BYTE *)p->_pFAnim;
pAnim = p->_pFAnim;
break;
case PFILE_MAGIC:
if (leveltype == DTYPE_TOWN) {
@ -385,7 +385,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
}
szCel = "QM";
pData = p->_pTData;
pAnim = (BYTE *)p->_pTAnim;
pAnim = p->_pTAnim;
break;
case PFILE_DEATH:
if ((p->_pgfxnum & 0xF) != 0) {
@ -393,7 +393,7 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
}
szCel = "DT";
pData = p->_pDData;
pAnim = (BYTE *)p->_pDAnim;
pAnim = p->_pDAnim;
break;
case PFILE_BLOCK:
if (leveltype == DTYPE_TOWN) {
@ -405,15 +405,15 @@ void LoadPlrGFX(int pnum, player_graphic gfxflag)
szCel = "BL";
pData = p->_pBData;
pAnim = (BYTE *)p->_pBAnim;
pAnim = p->_pBAnim;
break;
default:
app_fatal("PLR:2");
}
sprintf(pszName, "PlrGFX\\%s\\%s\\%s%s.CL2", cs, prefix, prefix, szCel);
LoadFileWithMem(pszName, pData);
SetPlayerGPtrs((BYTE *)pData, (BYTE **)pAnim);
LoadFileInMem(pszName, pData);
SetPlayerGPtrs(pData, pAnim);
p->_pGFXLoad |= i;
}
}
@ -496,31 +496,31 @@ void InitPlrGFXMem(int pnum)
const HeroClass c = player._pClass;
// STAND (ST: TOWN, AS: DUNGEON)
player._pNData = new std::uint8_t[std::max(GetPlrGFXSize(c, "ST"), GetPlrGFXSize(c, "AS"))];
player._pNData = new byte[std::max(GetPlrGFXSize(c, "ST"), GetPlrGFXSize(c, "AS"))];
// WALK (WL: TOWN, AW: DUNGEON)
player._pWData = new std::uint8_t[std::max(GetPlrGFXSize(c, "WL"), GetPlrGFXSize(c, "AW"))];
player._pWData = new byte[std::max(GetPlrGFXSize(c, "WL"), GetPlrGFXSize(c, "AW"))];
// ATTACK
player._pAData = new std::uint8_t[GetPlrGFXSize(c, "AT")];
player._pAData = new byte[GetPlrGFXSize(c, "AT")];
// HIT
player._pHData = new std::uint8_t[GetPlrGFXSize(c, "HT")];
player._pHData = new byte[GetPlrGFXSize(c, "HT")];
// LIGHTNING
player._pLData = new std::uint8_t[GetPlrGFXSize(c, "LM")];
player._pLData = new byte[GetPlrGFXSize(c, "LM")];
// FIRE
player._pFData = new std::uint8_t[GetPlrGFXSize(c, "FM")];
player._pFData = new byte[GetPlrGFXSize(c, "FM")];
// MAGIC
player._pTData = new std::uint8_t[GetPlrGFXSize(c, "QM")];
player._pTData = new byte[GetPlrGFXSize(c, "QM")];
// DEATH
player._pDData = new std::uint8_t[GetPlrGFXSize(c, "DT")];
player._pDData = new byte[GetPlrGFXSize(c, "DT")];
// BLOCK
player._pBData = new std::uint8_t[GetPlrGFXSize(c, "BL")];
player._pBData = new byte[GetPlrGFXSize(c, "BL")];
player._pGFXLoad = 0;
}
@ -552,7 +552,7 @@ void FreePlayerGFX(int pnum)
plr[pnum]._pGFXLoad = 0;
}
void NewPlrAnim(int pnum, BYTE *pData, int numberOfFrames, int delayLen, int width, AnimationDistributionFlags flags /*= AnimationDistributionFlags::None*/, int numSkippedFrames /*= 0*/, int distributeFramesBeforeFrame /*= 0*/)
void NewPlrAnim(int pnum, byte *pData, int numberOfFrames, int delayLen, int width, AnimationDistributionFlags flags /*= AnimationDistributionFlags::None*/, int numSkippedFrames /*= 0*/, int distributeFramesBeforeFrame /*= 0*/)
{
if ((DWORD)pnum >= MAX_PLRS) {
app_fatal("NewPlrAnim: illegal player %d", pnum);

38
Source/player.h
Unescape View File

@ -237,29 +237,29 @@ struct PlayerStruct {
bool _pSLvlVisited[NUMLEVELS]; // only 10 used
/** Using player_graphic as bitflags */
int _pGFXLoad;
uint8_t *_pNAnim[8]; // Stand animations
byte *_pNAnim[8]; // Stand animations
int _pNFrames;
int _pNWidth;
uint8_t *_pWAnim[8]; // Walk animations
byte *_pWAnim[8]; // Walk animations
int _pWFrames;
int _pWWidth;
uint8_t *_pAAnim[8]; // Attack animations
byte *_pAAnim[8]; // Attack animations
int _pAFrames;
int _pAWidth;
int _pAFNum;
uint8_t *_pLAnim[8]; // Lightning spell cast animations
uint8_t *_pFAnim[8]; // Fire spell cast animations
uint8_t *_pTAnim[8]; // Generic spell cast animations
byte *_pLAnim[8]; // Lightning spell cast animations
byte *_pFAnim[8]; // Fire spell cast animations
byte *_pTAnim[8]; // Generic spell cast animations
int _pSFrames;
int _pSWidth;
int _pSFNum;
uint8_t *_pHAnim[8]; // Getting hit animations
byte *_pHAnim[8]; // Getting hit animations
int _pHFrames;
int _pHWidth;
uint8_t *_pDAnim[8]; // Death animations
byte *_pDAnim[8]; // Death animations
int _pDFrames;
int _pDWidth;
uint8_t *_pBAnim[8]; // Block animations
byte *_pBAnim[8]; // Block animations
int _pBFrames;
int _pBWidth;
ItemStruct InvBody[NUM_INVLOC];
@ -299,15 +299,15 @@ struct PlayerStruct {
uint8_t pDiabloKillLevel;
_difficulty pDifficulty;
uint32_t pDamAcFlags;
uint8_t *_pNData;
uint8_t *_pWData;
uint8_t *_pAData;
uint8_t *_pLData;
uint8_t *_pFData;
uint8_t *_pTData;
uint8_t *_pHData;
uint8_t *_pDData;
uint8_t *_pBData;
byte *_pNData;
byte *_pWData;
byte *_pAData;
byte *_pLData;
byte *_pFData;
byte *_pTData;
byte *_pHData;
byte *_pDData;
byte *_pBData;
/**
* @brief Gets the most valuable item out of all the player's items that match the given predicate.
@ -403,7 +403,7 @@ void FreePlayerGFX(int pnum);
* @param numSkippedFrames Number of Frames that will be skipped (for example with modifier "faster attack")
* @param distributeFramesBeforeFrame Distribute the numSkippedFrames only before this frame
*/
void NewPlrAnim(int pnum, BYTE *pData, int numberOfFrames, int delayLen, int width, AnimationDistributionFlags flags = AnimationDistributionFlags::None, int numSkippedFrames = 0, int distributeFramesBeforeFrame = 0);
void NewPlrAnim(int pnum, byte *pData, int numberOfFrames, int delayLen, int width, AnimationDistributionFlags flags = AnimationDistributionFlags::None, int numSkippedFrames = 0, int distributeFramesBeforeFrame = 0);
void SetPlrAnims(int pnum);
void CreatePlayer(int pnum, HeroClass c);
int CalcStatDiff(int pnum);

2
Source/render.cpp
Unescape View File

@ -1314,7 +1314,7 @@ void RenderTile(const CelOutputBuffer &out, int x, int y)
const std::uint8_t *tbl = &pLightTbl[256 * light_table_index];
const auto *pFrameTable = reinterpret_cast<const std::uint32_t *>(pDungeonCels.get());
const std::uint8_t *src = &pDungeonCels[SDL_SwapLE32(pFrameTable[level_cel_block & 0xFFF])];
const auto *src = reinterpret_cast<const std::uint8_t *>(&pDungeonCels[SDL_SwapLE32(pFrameTable[level_cel_block & 0xFFF])]);
std::uint8_t *dst = out.at(static_cast<int>(x + clip.left), static_cast<int>(y - clip.bottom));
const auto dstPitch = out.pitch();
mask -= clip.bottom;

27
Source/scrollrt.cpp
Unescape View File

@ -242,13 +242,13 @@ void DrawMissilePrivate(const CelOutputBuffer &out, MissileStruct *m, int sx, in
if (m->_miPreFlag != pre || !m->_miDrawFlag)
return;
BYTE *pCelBuff = m->_miAnimData;
if (pCelBuff == nullptr) {
if (m->_miAnimData == nullptr) {
Log("Draw Missile 2 type {}: NULL Cel Buffer", m->_mitype);
return;
}
int nCel = m->_miAnimFrame;
int frames = SDL_SwapLE32(*(DWORD *)pCelBuff);
auto frameTable = reinterpret_cast<const uint32_t *>(m->_miAnimData);
int frames = SDL_SwapLE32(frameTable[0]);
if (nCel < 1 || frames > 50 || nCel > frames) {
Log("Draw Missile 2: frame {} of {}, missile type=={}", nCel, frames, m->_mitype);
return;
@ -312,14 +312,14 @@ static void DrawMonster(const CelOutputBuffer &out, int x, int y, int mx, int my
return;
}
BYTE *pCelBuff = monster[m]._mAnimData;
if (pCelBuff == nullptr) {
if (monster[m]._mAnimData == nullptr) {
Log("Draw Monster \"{}\": NULL Cel Buffer", monster[m].mName);
return;
}
int nCel = monster[m]._mAnimFrame;
int frames = SDL_SwapLE32(*(DWORD *)pCelBuff);
auto frameTable = reinterpret_cast<const uint32_t *>(monster[m]._mAnimData);
int frames = SDL_SwapLE32(frameTable[0]);
if (nCel < 1 || frames > 50 || nCel > frames) {
const char *szMode = "unknown action";
if (monster[m]._mmode <= 17)
@ -370,7 +370,7 @@ static void DrawManaShield(const CelOutputBuffer &out, int pnum, int x, int y, b
x += CalculateWidth2(plr[pnum]._pAnimWidth) - misfiledata[MFILE_MANASHLD].mAnimWidth2[0];
int width = misfiledata[MFILE_MANASHLD].mAnimWidth[0];
BYTE *pCelBuff = misfiledata[MFILE_MANASHLD].mAnimData[0];
byte *pCelBuff = misfiledata[MFILE_MANASHLD].mAnimData[0];
CelSprite cel { pCelBuff, width };
@ -407,7 +407,7 @@ static void DrawPlayer(const CelOutputBuffer &out, int pnum, int x, int y, int p
PlayerStruct *pPlayer = &plr[pnum];
BYTE *pCelBuff = pPlayer->AnimInfo.pData;
byte *pCelBuff = pPlayer->AnimInfo.pData;
int nCel = pPlayer->AnimInfo.GetFrameToUseForRendering();
if (pCelBuff == nullptr) {
@ -519,14 +519,14 @@ static void DrawObject(const CelOutputBuffer &out, int x, int y, int ox, int oy,
assert(bv >= 0 && bv < MAXOBJECTS);
BYTE *pCelBuff = object[bv]._oAnimData;
byte *pCelBuff = object[bv]._oAnimData;
if (pCelBuff == nullptr) {
Log("Draw Object type {}: NULL Cel Buffer", object[bv]._otype);
return;
}
int nCel = object[bv]._oAnimFrame;
int frames = SDL_SwapLE32(*(DWORD *)pCelBuff);
auto frames = SDL_SwapLE32(reinterpret_cast<const std::uint32_t *>(pCelBuff)[0]);
if (nCel < 1 || frames > 50 || nCel > frames) {
Log("Draw Object: frame {} of {}, object type=={}", nCel, frames, object[bv]._otype);
return;
@ -761,11 +761,10 @@ static void scrollrt_draw_dungeon(const CelOutputBuffer &out, int sx, int sy, in
DeadStruct *pDeadGuy = &dead[(bDead & 0x1F) - 1];
auto dd = static_cast<direction>((bDead >> 5) & 7);
int px = dx - CalculateWidth2(pDeadGuy->_deadWidth);
BYTE *pCelBuff = pDeadGuy->_deadData[dd];
byte *pCelBuff = pDeadGuy->_deadData[dd];
assert(pCelBuff != nullptr);
if (pCelBuff == nullptr)
break;
int frames = SDL_SwapLE32(*(DWORD *)pCelBuff);
auto frameTable = reinterpret_cast<const uint32_t *>(pCelBuff);
int frames = SDL_SwapLE32(frameTable[0]);
int nCel = pDeadGuy->_deadFrame;
if (nCel < 1 || frames > 50 || nCel > frames) {
Log("Unclipped dead: frame {} of {}, deadnum=={}", nCel, frames, (bDead & 0x1F) - 1);

66
Source/towners.cpp
Unescape View File

@ -13,7 +13,7 @@
namespace devilution {
namespace {
std::unique_ptr<BYTE[]> pCowCels;
std::unique_ptr<byte[]> pCowCels;
} // namespace
bool storeflag;
@ -186,16 +186,16 @@ int GetActiveTowner(int t)
return -1;
}
void SetTownerGPtrs(BYTE *pData, byte **pAnim)
void SetTownerGPtrs(byte *pData, byte **pAnim)
{
for (int i = 0; i < 8; i++) {
pAnim[i] = (byte *)CelGetFrameStart(pData, i);
pAnim[i] = CelGetFrameStart(pData, i);
}
}
void NewTownerAnim(int tnum, byte *pAnim, uint8_t numFrames, int Delay)
{
towners[tnum]._tAnimData = (BYTE *)pAnim;
towners[tnum]._tAnimData = pAnim;
towners[tnum]._tAnimLen = numFrames;
towners[tnum]._tAnimFrame = 1;
towners[tnum]._tAnimCnt = 0;
@ -232,9 +232,9 @@ void InitSmith()
InitTownerInfo(numtowners, 96, true, TOWN_SMITH, 62, 63, 0);
InitQstSnds(numtowners, TOWN_SMITH);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Smith\\SmithN.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Smith\\SmithN.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 16;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_SW], towners[numtowners]._tNFrames, 3);
@ -246,9 +246,9 @@ void InitBarOwner()
{
InitTownerInfo(numtowners, 96, true, TOWN_TAVERN, 55, 62, 3);
InitQstSnds(numtowners, TOWN_TAVERN);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\TwnF\\TwnFN.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\TwnF\\TwnFN.CEL");
for (auto &towner : towners[numtowners]._tNAnim) {
towner = (byte *)towners[numtowners]._tNData.get();
towner = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 16;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_SW], towners[numtowners]._tNFrames, 3);
@ -258,13 +258,11 @@ void InitBarOwner()
void InitTownDead()
{
int i;
InitTownerInfo(numtowners, 96, true, TOWN_DEADGUY, 24, 32, -1);
InitQstSnds(numtowners, TOWN_DEADGUY);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Butch\\Deadguy.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNData = LoadFileInMem("Towners\\Butch\\Deadguy.CEL");
for (int i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 8;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_N], towners[numtowners]._tNFrames, 6);
@ -278,9 +276,9 @@ void InitWitch()
InitTownerInfo(numtowners, 96, true, TOWN_WITCH, 80, 20, 5);
InitQstSnds(numtowners, TOWN_WITCH);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\TownWmn1\\Witch.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\TownWmn1\\Witch.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 19;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 6);
@ -294,9 +292,9 @@ void InitBarmaid()
InitTownerInfo(numtowners, 96, true, TOWN_BMAID, 43, 66, -1);
InitQstSnds(numtowners, TOWN_BMAID);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\TownWmn1\\WmnN.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\TownWmn1\\WmnN.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 18;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 6);
@ -310,9 +308,9 @@ void InitBoy()
InitTownerInfo(numtowners, 96, true, TOWN_PEGBOY, 11, 53, -1);
InitQstSnds(numtowners, TOWN_PEGBOY);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\TownBoy\\PegKid1.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\TownBoy\\PegKid1.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 20;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 6);
@ -326,9 +324,9 @@ void InitHealer()
InitTownerInfo(numtowners, 96, true, TOWN_HEALER, 55, 79, 1);
InitQstSnds(numtowners, TOWN_HEALER);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Healer\\Healer.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Healer\\Healer.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 20;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_SE], towners[numtowners]._tNFrames, 6);
@ -342,9 +340,9 @@ void InitTeller()
InitTownerInfo(numtowners, 96, true, TOWN_STORY, 62, 71, 2);
InitQstSnds(numtowners, TOWN_STORY);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Strytell\\Strytell.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Strytell\\Strytell.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 25;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 3);
@ -358,9 +356,9 @@ void InitDrunk()
InitTownerInfo(numtowners, 96, true, TOWN_DRUNK, 71, 84, 4);
InitQstSnds(numtowners, TOWN_DRUNK);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Drunk\\TwnDrunk.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Drunk\\TwnDrunk.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 18;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 3);
@ -375,7 +373,7 @@ void InitCows()
//if ( pCowCels )
// assertion_failed(__LINE__, __FILE__, "! pCowCels");
pCowCels = LoadFileInMem<BYTE>("Towners\\Animals\\Cow.CEL");
pCowCels = LoadFileInMem("Towners\\Animals\\Cow.CEL");
for (i = 0; i < 3; i++) {
x = TownCowX[i];
y = TownCowY[i];
@ -408,9 +406,9 @@ void InitFarmer()
InitTownerInfo(numtowners, 96, true, TOWN_FARMER, 62, 16, -1);
InitQstSnds(numtowners, TOWN_FARMER);
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Farmer\\Farmrn2.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Farmer\\Farmrn2.CEL");
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 15;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 3);
@ -425,12 +423,12 @@ void InitCowFarmer()
InitTownerInfo(numtowners, 96, true, TOWN_COWFARM, 61, 22, -1);
InitQstSnds(numtowners, TOWN_COWFARM);
if (quests[Q_JERSEY]._qactive != QUEST_DONE) {
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Farmer\\cfrmrn2.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Farmer\\cfrmrn2.CEL");
} else {
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Farmer\\mfrmrn2.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Farmer\\mfrmrn2.CEL");
}
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 15;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_SW], towners[numtowners]._tNFrames, 3);
@ -445,12 +443,12 @@ void InitGirl()
InitTownerInfo(numtowners, 96, true, TOWN_GIRL, 77, 43, -1);
InitQstSnds(numtowners, TOWN_GIRL);
if (quests[Q_GIRL]._qactive != QUEST_DONE) {
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Girl\\Girlw1.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Girl\\Girlw1.CEL");
} else {
towners[numtowners]._tNData = LoadFileInMem<BYTE>("Towners\\Girl\\Girls1.CEL");
towners[numtowners]._tNData = LoadFileInMem("Towners\\Girl\\Girls1.CEL");
}
for (i = 0; i < 8; i++) {
towners[numtowners]._tNAnim[i] = (byte *)towners[numtowners]._tNData.get();
towners[numtowners]._tNAnim[i] = towners[numtowners]._tNData.get();
}
towners[numtowners]._tNFrames = 20;
NewTownerAnim(numtowners, towners[numtowners]._tNAnim[DIR_S], towners[numtowners]._tNFrames, 6);

4
Source/towners.h
Unescape View File

@ -42,8 +42,8 @@ struct TNQ {
struct TownerStruct {
byte *_tNAnim[8];
std::unique_ptr<BYTE[]> _tNData;
uint8_t *_tAnimData;
std::unique_ptr<byte[]> _tNData;
byte *_tAnimData;
int16_t _tSeed;
/** Tile position of NPC */
Point position;

Write Preview
Loading…
Cancel
Save