libAthena/athena
2
0
Fork 0
mirror of https://github.com/libAthena/athena.git synced 2025-08-09 13:39:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use standard integer types

Browse Source
This commit is contained in:
Phillip Stephens 2025-04-26 09:34:02 -07:00
parent d2d54fe6ef
commit 9e0486c1f6
93 changed files with 1248 additions and 1257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
include/LZ77/LZBase.hpp
View File

@ -4,31 +4,31 @@
class LZBase { class LZBase {
public: public:
explicit LZBase(atInt32 minimumOffset = 1, atInt32 slidingWindow = 4096, atInt32 minimumMatch = 3, explicit LZBase(int32_t minimumOffset = 1, int32_t slidingWindow = 4096, int32_t minimumMatch = 3,
atInt32 blockSize = 8); int32_t blockSize = 8);
virtual ~LZBase(); virtual ~LZBase();
virtual atUint32 compress(const atUint8* src, atUint8** dest, atUint32 srcLength) = 0; virtual uint32_t compress(const uint8_t* src, uint8_t** dest, uint32_t srcLength) = 0;
virtual atUint32 decompress(const atUint8* src, atUint8** dest, atUint32 srcLength) = 0; virtual uint32_t decompress(const uint8_t* src, uint8_t** dest, uint32_t srcLength) = 0;
void setSlidingWindow(atInt32 SlidingWindow); void setSlidingWindow(int32_t SlidingWindow);
atInt32 slidingWindow() const; int32_t slidingWindow() const;
void setReadAheadBuffer(atInt32 ReadAheadBuffer); void setReadAheadBuffer(int32_t ReadAheadBuffer);
atInt32 readAheadBuffer() const; int32_t readAheadBuffer() const;
void setMinMatch(atInt32 minimumMatch); void setMinMatch(int32_t minimumMatch);
atInt32 minMatch() const; int32_t minMatch() const;
void setBlockSize(atInt32 BlockSize); void setBlockSize(int32_t BlockSize);
atInt32 blockSize() const; int32_t blockSize() const;
void setMinimumOffset(atUint32 minimumOffset); void setMinimumOffset(uint32_t minimumOffset);
atUint32 minimumOffset() const; uint32_t minimumOffset() const;
protected: protected:
LZLengthOffset search(const atUint8* posPtr, const atUint8* dataBegin, const atUint8* dataEnd) const; LZLengthOffset search(const uint8_t* posPtr, const uint8_t* dataBegin, const uint8_t* dataEnd) const;
atInt32 m_slidingWindow; int32_t m_slidingWindow;
atInt32 m_readAheadBuffer; int32_t m_readAheadBuffer;
atInt32 m_minMatch; // Minimum number of bytes that have to matched to go through with compression int32_t m_minMatch; // Minimum number of bytes that have to matched to go through with compression
atInt32 m_blockSize; int32_t m_blockSize;
atUint32 m_minOffset; uint32_t m_minOffset;
LZLookupTable m_lookupTable; LZLookupTable m_lookupTable;
}; };

16
include/LZ77/LZLookupTable.hpp
View File

@ -6,8 +6,8 @@
#include <athena/Types.hpp> #include <athena/Types.hpp>
struct LZLengthOffset { struct LZLengthOffset {
atUint32 length; // The number of bytes compressed uint32_t length; // The number of bytes compressed
atUint16 offset; // How far back in sliding window where bytes that match the lookAheadBuffer is located uint16_t offset; // How far back in sliding window where bytes that match the lookAheadBuffer is located
bool operator==(const LZLengthOffset& lo_pair) const { return length == lo_pair.length && offset == lo_pair.offset; } bool operator==(const LZLengthOffset& lo_pair) const { return length == lo_pair.length && offset == lo_pair.offset; }
bool operator!=(const LZLengthOffset& lo_pair) const { return !operator==(lo_pair); } bool operator!=(const LZLengthOffset& lo_pair) const { return !operator==(lo_pair); }
}; };
@ -15,16 +15,16 @@ struct LZLengthOffset {
class LZLookupTable { class LZLookupTable {
public: public:
LZLookupTable(); LZLookupTable();
explicit LZLookupTable(atInt32 minimumMatch, atInt32 slidingWindow = 4096, atInt32 lookAheadWindow = 18); explicit LZLookupTable(int32_t minimumMatch, int32_t slidingWindow = 4096, int32_t lookAheadWindow = 18);
~LZLookupTable(); ~LZLookupTable();
LZLengthOffset search(const atUint8* curPos, const atUint8* dataBegin, const atUint8* dataEnd); LZLengthOffset search(const uint8_t* curPos, const uint8_t* dataBegin, const uint8_t* dataEnd);
void setLookAheadWindow(atInt32 lookAheadWindow); void setLookAheadWindow(int32_t lookAheadWindow);
private: private:
using LookupTable = std::multimap<std::vector<uint8_t>, int32_t>; using LookupTable = std::multimap<std::vector<uint8_t>, int32_t>;
LookupTable table; LookupTable table;
atInt32 m_minimumMatch = 3; int32_t m_minimumMatch = 3;
atInt32 m_slidingWindow = 4096; int32_t m_slidingWindow = 4096;
atInt32 m_lookAheadWindow = 18; int32_t m_lookAheadWindow = 18;
std::vector<uint8_t> m_buffer; std::vector<uint8_t> m_buffer;
}; };

8
include/LZ77/LZType10.hpp
View File

@ -4,8 +4,8 @@
class LZType10 : public LZBase { class LZType10 : public LZBase {
public: public:
explicit LZType10(atInt32 minimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3, explicit LZType10(int32_t minimumOffset = 1, int32_t SlidingWindow = 4096, int32_t MinimumMatch = 3,
atInt32 BlockSize = 8); int32_t BlockSize = 8);
atUint32 compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLength) override; uint32_t compress(const uint8_t* src, uint8_t** dstBuf, uint32_t srcLength) override;
atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLen) override; uint32_t decompress(const uint8_t* src, uint8_t** dst, uint32_t srcLen) override;
}; };

8
include/LZ77/LZType11.hpp
View File

@ -4,8 +4,8 @@
class LZType11 : public LZBase { class LZType11 : public LZBase {
public: public:
explicit LZType11(atInt32 MinimumOffset = 1, atInt32 SlidingWindow = 4096, atInt32 MinimumMatch = 3, explicit LZType11(int32_t MinimumOffset = 1, int32_t SlidingWindow = 4096, int32_t MinimumMatch = 3,
atInt32 BlockSize = 8); int32_t BlockSize = 8);
atUint32 compress(const atUint8* src, atUint8** dst, atUint32 srcLength) override; uint32_t compress(const uint8_t* src, uint8_t** dst, uint32_t srcLength) override;
atUint32 decompress(const atUint8* src, atUint8** dst, atUint32 srcLength) override; uint32_t decompress(const uint8_t* src, uint8_t** dst, uint32_t srcLength) override;
}; };

6
include/athena/ALTTPFile.hpp
View File

@ -40,7 +40,7 @@ public:
* \param val The new quest to assign to the given index * \param val The new quest to assign to the given index
* \throw InvalidOperationException on index out of range * \throw InvalidOperationException on index out of range
*/ */
void setQuest(atUint32 id, ALTTPQuest* val); void setQuest(uint32_t id, ALTTPQuest* val);
/*! \brief Returns the primary quest list /*! \brief Returns the primary quest list
* *
* \return The primary quest list * \return The primary quest list
@ -54,13 +54,13 @@ public:
* \return ALTTPQuest* * \return ALTTPQuest*
* \throw InvalidOperationException on index out of range * \throw InvalidOperationException on index out of range
*/ */
ALTTPQuest* quest(atUint32 id) const; ALTTPQuest* quest(uint32_t id) const;
/*! \brief Returns the number of primary quests /*! \brief Returns the number of primary quests
* *
* \return The number of quests * \return The number of quests
*/ */
atUint32 questCount() const; uint32_t questCount() const;
private: private:
std::vector<ALTTPQuest*> m_quests; std::vector<ALTTPQuest*> m_quests;

2
include/athena/ALTTPFileReader.hpp
View File

@ -23,7 +23,7 @@ public:
* \param data The existing buffer * \param data The existing buffer
* \param length The length of the existing buffer * \param length The length of the existing buffer
*/ */
ALTTPFileReader(atUint8*, atUint64); ALTTPFileReader(uint8_t*, uint64_t);
/*! \brief This constructor creates an instance from a file on disk. /*! \brief This constructor creates an instance from a file on disk.
* *

4
include/athena/ALTTPFileWriter.hpp
View File

@ -22,7 +22,7 @@ public:
* \param data The existing buffer * \param data The existing buffer
* \param length The length of the existing buffer * \param length The length of the existing buffer
*/ */
ALTTPFileWriter(atUint8*, atUint64); ALTTPFileWriter(uint8_t*, uint64_t);
/*! \brief This constructor creates an instance from a file on disk. /*! \brief This constructor creates an instance from a file on disk.
* *
@ -40,7 +40,7 @@ private:
void writeRoomFlags(ALTTPRoomFlags*); void writeRoomFlags(ALTTPRoomFlags*);
void writeOverworldEvent(ALTTPOverworldEvent*); void writeOverworldEvent(ALTTPOverworldEvent*);
void writeDungeonItems(ALTTPDungeonItemFlags); void writeDungeonItems(ALTTPDungeonItemFlags);
atUint16 calculateChecksum(atUint32 game); uint16_t calculateChecksum(uint32_t game);
}; };
} // namespace io } // namespace io

168
include/athena/ALTTPQuest.hpp
View File

@ -33,7 +33,7 @@ public:
* \param rf * \param rf
* \param id * \param id
*/ */
void setRoomFlags(ALTTPRoomFlags* rf, atUint32 id); void setRoomFlags(ALTTPRoomFlags* rf, uint32_t id);
/*! /*!
* \brief roomFlags * \brief roomFlags
@ -46,7 +46,7 @@ public:
* \param id * \param id
* \return * \return
*/ */
ALTTPRoomFlags* roomFlags(atUint32 id); ALTTPRoomFlags* roomFlags(uint32_t id);
/*! /*!
* \brief setOverworldEvents * \brief setOverworldEvents
@ -59,7 +59,7 @@ public:
* \param ow * \param ow
* \param id * \param id
*/ */
void setOverworldEvents(ALTTPOverworldEvent* ow, atUint32 id); void setOverworldEvents(ALTTPOverworldEvent* ow, uint32_t id);
/*! /*!
* \brief overworldEvents * \brief overworldEvents
@ -72,7 +72,7 @@ public:
* \param id * \param id
* \return * \return
*/ */
ALTTPOverworldEvent* overworldEvent(atUint32 id) const; ALTTPOverworldEvent* overworldEvent(uint32_t id) const;
/*! /*!
* \brief setInventory * \brief setInventory
@ -90,25 +90,25 @@ public:
* \brief setRupeeMax * \brief setRupeeMax
* \param val * \param val
*/ */
void setRupeeMax(atUint16 val); void setRupeeMax(uint16_t val);
/*! /*!
* \brief rupeeMax * \brief rupeeMax
* \return * \return
*/ */
atUint16 rupeeMax() const; uint16_t rupeeMax() const;
/*! /*!
* \brief setRupeeCurrent * \brief setRupeeCurrent
* \param val * \param val
*/ */
void setRupeeCurrent(atUint16 val); void setRupeeCurrent(uint16_t val);
/*! /*!
* \brief rupeeCurrent * \brief rupeeCurrent
* \return * \return
*/ */
atUint16 rupeeCurrent() const; uint16_t rupeeCurrent() const;
/*! /*!
* \brief setCompasses * \brief setCompasses
@ -150,109 +150,109 @@ public:
* \brief setWishingPond * \brief setWishingPond
* \param val * \param val
*/ */
void setWishingPond(atUint16 val); void setWishingPond(uint16_t val);
/*! /*!
* \brief wishingPond * \brief wishingPond
* \return * \return
*/ */
atUint16 wishingPond() const; uint16_t wishingPond() const;
/*! /*!
* \brief setHealthMax * \brief setHealthMax
* \param val * \param val
*/ */
void setHealthMax(atUint8 val); void setHealthMax(uint8_t val);
/*! /*!
* \brief healthMax * \brief healthMax
* \return * \return
*/ */
atUint8 healthMax() const; uint8_t healthMax() const;
/*! /*!
* \brief setHealth * \brief setHealth
* \param val * \param val
*/ */
void setHealth(atUint8 val); void setHealth(uint8_t val);
/*! /*!
* \brief health * \brief health
* \return * \return
*/ */
atUint8 health() const; uint8_t health() const;
/*! /*!
* \brief setMagicPower * \brief setMagicPower
* \param val * \param val
*/ */
void setMagicPower(atUint8 val); void setMagicPower(uint8_t val);
/*! /*!
* \brief magicPower * \brief magicPower
* \return * \return
*/ */
atUint8 magicPower() const; uint8_t magicPower() const;
/*! /*!
* \brief setKeys * \brief setKeys
* \param val * \param val
*/ */
void setKeys(atUint8 val); void setKeys(uint8_t val);
/*! /*!
* \brief keys * \brief keys
* \return * \return
*/ */
atUint8 keys() const; uint8_t keys() const;
/*! /*!
* \brief setBombUpgrades * \brief setBombUpgrades
* \param val * \param val
*/ */
void setBombUpgrades(atUint8 val); void setBombUpgrades(uint8_t val);
/*! /*!
* \brief bombUpgrades * \brief bombUpgrades
* \return * \return
*/ */
atUint8 bombUpgrades() const; uint8_t bombUpgrades() const;
/*! /*!
* \brief setArrowUpgrades * \brief setArrowUpgrades
* \param val * \param val
*/ */
void setArrowUpgrades(atUint8 val); void setArrowUpgrades(uint8_t val);
/*! /*!
* \brief arrowUpgrades * \brief arrowUpgrades
* \return * \return
*/ */
atUint8 arrowUpgrades() const; uint8_t arrowUpgrades() const;
/*! /*!
* \brief setHealthFiller * \brief setHealthFiller
* \param val * \param val
*/ */
void setHealthFiller(atUint8 val); void setHealthFiller(uint8_t val);
/*! /*!
* \brief healthFiller * \brief healthFiller
* \return * \return
*/ */
atUint8 healthFiller() const; uint8_t healthFiller() const;
/*! /*!
* \brief setMagicFiller * \brief setMagicFiller
* \param val * \param val
*/ */
void setMagicFiller(atUint8 val); void setMagicFiller(uint8_t val);
/*! /*!
* \brief magicFiller * \brief magicFiller
* \return * \return
*/ */
atUint8 magicFiller() const; uint8_t magicFiller() const;
/*! /*!
* \brief setPendants * \brief setPendants
@ -270,37 +270,37 @@ public:
* \brief setBombFiller * \brief setBombFiller
* \param val * \param val
*/ */
void setBombFiller(atUint8 val); void setBombFiller(uint8_t val);
/*! /*!
* \brief bombFiller * \brief bombFiller
* \return * \return
*/ */
atUint8 bombFiller() const; uint8_t bombFiller() const;
/*! /*!
* \brief setArrowFiller * \brief setArrowFiller
* \param val * \param val
*/ */
void setArrowFiller(atUint8 val); void setArrowFiller(uint8_t val);
/*! /*!
* \brief arrowFiller * \brief arrowFiller
* \return * \return
*/ */
atUint8 arrowFiller() const; uint8_t arrowFiller() const;
/*! /*!
* \brief setArrows * \brief setArrows
* \param val * \param val
*/ */
void setArrows(atUint8 val); void setArrows(uint8_t val);
/*! /*!
* \brief arrows * \brief arrows
* \return * \return
*/ */
atUint8 arrows() const; uint8_t arrows() const;
/*! /*!
* \brief setAbilityFlags * \brief setAbilityFlags
@ -342,27 +342,27 @@ public:
* \brief setDungeonKeys * \brief setDungeonKeys
* \param val * \param val
*/ */
void setDungeonKeys(std::vector<atUint8> val); void setDungeonKeys(std::vector<uint8_t> val);
/*! /*!
* \brief setDungeonKeys * \brief setDungeonKeys
* \param id * \param id
* \param val * \param val
*/ */
void setDungeonKeys(atUint32 id, atUint8 val); void setDungeonKeys(uint32_t id, uint8_t val);
/*! /*!
* \brief dungeonKeys * \brief dungeonKeys
* \param id * \param id
* \return * \return
*/ */
atUint8 dungeonKeys(atUint32 id) const; uint8_t dungeonKeys(uint32_t id) const;
/*! /*!
* \brief dungeonCount * \brief dungeonCount
* \return * \return
*/ */
atUint32 dungeonCount() const; uint32_t dungeonCount() const;
/*! /*!
* \brief setProgressIndicator * \brief setProgressIndicator
@ -452,71 +452,71 @@ public:
* \brief setOldManFlags * \brief setOldManFlags
* \param flags * \param flags
*/ */
void setOldManFlags(std::vector<atUint8> flags); void setOldManFlags(std::vector<uint8_t> flags);
/*! /*!
* \brief setOldManFlag * \brief setOldManFlag
* \param id * \param id
* \param val * \param val
*/ */
void setOldManFlag(atUint32 id, atUint8 val); void setOldManFlag(uint32_t id, uint8_t val);
/*! /*!
* \brief oldManFlag * \brief oldManFlag
* \param id * \param id
* \return * \return
*/ */
atUint8 oldManFlag(atUint32 id); uint8_t oldManFlag(uint32_t id);
/*! /*!
* \brief oldManFlagCount * \brief oldManFlagCount
* \return * \return
*/ */
atUint32 oldManFlagCount() const; uint32_t oldManFlagCount() const;
/*! /*!
* \brief setBombFlag * \brief setBombFlag
* \param flag * \param flag
*/ */
void setBombFlag(atUint8 flag); void setBombFlag(uint8_t flag);
/*! /*!
* \brief bombFlag * \brief bombFlag
* \return * \return
*/ */
atUint8 bombFlag() const; uint8_t bombFlag() const;
/*! /*!
* \brief setUnknown1 * \brief setUnknown1
* \param flags * \param flags
*/ */
void setUnknown1(std::vector<atUint8> flags); void setUnknown1(std::vector<uint8_t> flags);
/*! /*!
* \brief setUnknown1 * \brief setUnknown1
* \param id * \param id
* \param val * \param val
*/ */
void setUnknown1(atUint32 id, atUint8 val); void setUnknown1(uint32_t id, uint8_t val);
/*! /*!
* \brief unknown1 * \brief unknown1
* \param id * \param id
* \return * \return
*/ */
atUint8 unknown1(atUint32 id); uint8_t unknown1(uint32_t id);
/*! /*!
* \brief unknown1Count * \brief unknown1Count
* \return * \return
*/ */
atUint32 unknown1Count() const; uint32_t unknown1Count() const;
/*! /*!
* \brief setPlayerName * \brief setPlayerName
* \param playerName * \param playerName
*/ */
void setPlayerName(std::vector<atUint16> playerName); void setPlayerName(std::vector<uint16_t> playerName);
/*! /*!
* \brief setPlayerName * \brief setPlayerName
* \param playerName * \param playerName
@ -526,7 +526,7 @@ public:
* \brief playerName * \brief playerName
* \return * \return
*/ */
std::vector<atUint16> playerName() const; std::vector<uint16_t> playerName() const;
/*! /*!
* \brief playerNameToString * \brief playerNameToString
* \return * \return
@ -549,102 +549,102 @@ public:
* \brief setDungeonDeathTotals * \brief setDungeonDeathTotals
* \param val * \param val
*/ */
void setDungeonDeathTotals(std::vector<atUint16> val); void setDungeonDeathTotals(std::vector<uint16_t> val);
/*! /*!
* \brief setDungeonDeathTotal * \brief setDungeonDeathTotal
* \param id * \param id
* \param val * \param val
*/ */
void setDungeonDeathTotal(atUint32 id, atUint16 val); void setDungeonDeathTotal(uint32_t id, uint16_t val);
/*! /*!
* \brief dungeonDeathTotal * \brief dungeonDeathTotal
* \param id * \param id
* \return * \return
*/ */
atUint16 dungeonDeathTotal(atUint32 id) const; uint16_t dungeonDeathTotal(uint32_t id) const;
/*! /*!
* \brief dungeonDeathTotalCount * \brief dungeonDeathTotalCount
* \return * \return
*/ */
atUint16 dungeonDeathTotalCount() const; uint16_t dungeonDeathTotalCount() const;
/*! /*!
* \brief setUnknown2 * \brief setUnknown2
* \param val * \param val
*/ */
void setUnknown2(atUint16 val); void setUnknown2(uint16_t val);
/*! /*!
* \brief unknown2 * \brief unknown2
* \return * \return
*/ */
atUint16 unknown2() const; uint16_t unknown2() const;
/*! /*!
* \brief setDeathSaveCount * \brief setDeathSaveCount
* \param val * \param val
*/ */
void setDeathSaveCount(atUint16 val); void setDeathSaveCount(uint16_t val);
/*! /*!
* \brief deathSaveCount * \brief deathSaveCount
* \return * \return
*/ */
atUint16 deathSaveCount() const; uint16_t deathSaveCount() const;
/*! /*!
* \brief setPostGameDeathCounter * \brief setPostGameDeathCounter
* \param val * \param val
*/ */
void setPostGameDeathCounter(atInt16 val); void setPostGameDeathCounter(int16_t val);
/*! /*!
* \brief postGameDeathCounter * \brief postGameDeathCounter
* \return * \return
*/ */
atInt16 postGameDeathCounter() const; int16_t postGameDeathCounter() const;
/*! /*!
* \brief setChecksum * \brief setChecksum
* \param checksum * \param checksum
*/ */
void setChecksum(atUint16 checksum); void setChecksum(uint16_t checksum);
/*! /*!
* \brief checksum * \brief checksum
* \return * \return
*/ */
atUint16 checksum() const; uint16_t checksum() const;
private: private:
std::vector<ALTTPRoomFlags*> m_roomFlags; std::vector<ALTTPRoomFlags*> m_roomFlags;
std::vector<ALTTPOverworldEvent*> m_overworldEvents; std::vector<ALTTPOverworldEvent*> m_overworldEvents;
ALTTPInventory m_inventory; ALTTPInventory m_inventory;
atUint16 m_rupeeMax; uint16_t m_rupeeMax;
atUint16 m_rupeeCurrent; uint16_t m_rupeeCurrent;
ALTTPDungeonItemFlags m_compasses; ALTTPDungeonItemFlags m_compasses;
ALTTPDungeonItemFlags m_bigKeys; ALTTPDungeonItemFlags m_bigKeys;
ALTTPDungeonItemFlags m_dungeonMaps; ALTTPDungeonItemFlags m_dungeonMaps;
atUint16 m_wishingPond; uint16_t m_wishingPond;
atUint8 m_healthMax; uint8_t m_healthMax;
atUint8 m_health; uint8_t m_health;
atUint8 m_magicPower; uint8_t m_magicPower;
atUint8 m_keys; uint8_t m_keys;
atUint8 m_bombUpgrades; uint8_t m_bombUpgrades;
atUint8 m_arrowUpgrades; uint8_t m_arrowUpgrades;
atUint8 m_heartFiller; uint8_t m_heartFiller;
atUint8 m_magicFiller; uint8_t m_magicFiller;
ALTTPPendants m_pendants; ALTTPPendants m_pendants;
atUint8 m_bombFiller; uint8_t m_bombFiller;
atUint8 m_arrowFiller; uint8_t m_arrowFiller;
atUint8 m_arrows; uint8_t m_arrows;
ALTTPAbilities m_abilityFlags; ALTTPAbilities m_abilityFlags;
ALTTPCrystals m_crystals; ALTTPCrystals m_crystals;
ALTTPMagicUsage m_magicUsage; ALTTPMagicUsage m_magicUsage;
std::vector<atUint8> m_dungeonKeys; std::vector<uint8_t> m_dungeonKeys;
ALTTPProgressIndicator m_progressIndicator; ALTTPProgressIndicator m_progressIndicator;
ALTTPProgressFlags1 m_progressFlags1; ALTTPProgressFlags1 m_progressFlags1;
ALTTPMapIcon m_mapIcon; ALTTPMapIcon m_mapIcon;
@ -652,16 +652,16 @@ private:
ALTTPProgressFlags2 m_progressFlags2; ALTTPProgressFlags2 m_progressFlags2;
ALTTPLightDarkWorldIndicator m_lightDarkWorldIndicator; ALTTPLightDarkWorldIndicator m_lightDarkWorldIndicator;
ALTTPTagAlong m_tagAlong; ALTTPTagAlong m_tagAlong;
std::vector<atUint8> m_oldManFlags; std::vector<uint8_t> m_oldManFlags;
atUint8 m_bombFlag; uint8_t m_bombFlag;
std::vector<atUint8> m_unknown1; std::vector<uint8_t> m_unknown1;
std::vector<atUint16> m_playerName; std::vector<uint16_t> m_playerName;
bool m_valid; bool m_valid;
std::vector<atUint16> m_dungeonDeathTotals; std::vector<uint16_t> m_dungeonDeathTotals;
atUint16 m_unknown2; uint16_t m_unknown2;
atUint16 m_deathSaveCount; uint16_t m_deathSaveCount;
atInt16 m_postGameDeathCounter; int16_t m_postGameDeathCounter;
atUint16 m_checksum; uint16_t m_checksum;
}; };
} // namespace athena } // namespace athena

4
include/athena/ALTTPStructs.hpp
View File

@ -92,7 +92,7 @@ struct ALTTPDungeonItemFlags {
bool IcePalace : 1; bool IcePalace : 1;
bool SkullWoods : 1; bool SkullWoods : 1;
}; };
atUint8 flags1; uint8_t flags1;
}; };
union { union {
@ -106,7 +106,7 @@ struct ALTTPDungeonItemFlags {
bool HyruleCastle : 1; // unused exist in original game bool HyruleCastle : 1; // unused exist in original game
bool SewerPassage : 1; // unused exist in original game bool SewerPassage : 1; // unused exist in original game
}; };
atUint8 flags2; uint8_t flags2;
}; };
}; };

10
include/athena/Checksums.hpp
View File

@ -3,9 +3,9 @@
#include "athena/Types.hpp" #include "athena/Types.hpp"
namespace athena::checksums { namespace athena::checksums {
atUint64 crc64(const atUint8* data, atUint64 length, atUint64 seed = 0xFFFFFFFFFFFFFFFF, uint64_t crc64(const uint8_t* data, uint64_t length, uint64_t seed = 0xFFFFFFFFFFFFFFFF,
atUint64 final = 0xFFFFFFFFFFFFFFFF); uint64_t final = 0xFFFFFFFFFFFFFFFF);
atUint32 crc32(const atUint8* data, atUint64 length, atUint32 seed = 0xFFFFFFFF, atUint32 final = 0xFFFFFFFF); uint32_t crc32(const uint8_t* data, uint64_t length, uint32_t seed = 0xFFFFFFFF, uint32_t final = 0xFFFFFFFF);
atUint16 crc16CCITT(const atUint8* data, atUint64 length, atUint16 seed = 0xFFFF, atUint16 final = 0); uint16_t crc16CCITT(const uint8_t* data, uint64_t length, uint16_t seed = 0xFFFF, uint16_t final = 0);
atUint16 crc16(const atUint8* data, atUint64 length, atUint16 seed = 0, atUint16 final = 0); uint16_t crc16(const uint8_t* data, uint64_t length, uint16_t seed = 0, uint16_t final = 0);
} // namespace athena::checksums } // namespace athena::checksums

12
include/athena/Compression.hpp
View File

@ -4,8 +4,8 @@
namespace athena::io::Compression { namespace athena::io::Compression {
// Zlib compression // Zlib compression
atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen); int32_t decompressZlib(const uint8_t* src, uint32_t srcLen, uint8_t* dst, uint32_t dstLen);
atInt32 compressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen); int32_t compressZlib(const uint8_t* src, uint32_t srcLen, uint8_t* dst, uint32_t dstLen);
#if AT_LZOKAY #if AT_LZOKAY
// lzo compression // lzo compression
@ -13,9 +13,9 @@ atInt32 decompressLZO(const atUint8* source, atInt32 sourceSize, atUint8* dst, a
#endif #endif
// Yaz0 encoding // Yaz0 encoding
atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize); uint32_t yaz0Decode(const uint8_t* src, uint8_t* dst, uint32_t uncompressedSize);
atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data); uint32_t yaz0Encode(const uint8_t* src, uint32_t srcSize, uint8_t* data);
atUint32 decompressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst); uint32_t decompressLZ77(const uint8_t* src, uint32_t srcLen, uint8_t** dst);
atUint32 compressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst, bool extended = false); uint32_t compressLZ77(const uint8_t* src, uint32_t srcLen, uint8_t** dst, bool extended = false);
} // namespace athena::io::Compression } // namespace athena::io::Compression

4
include/athena/FileInfo.hpp
View File

@ -24,8 +24,8 @@ public:
std::string extension() const; std::string extension() const;
static std::string extension(std::string_view path) { return FileInfo(path).extension(); } static std::string extension(std::string_view path) { return FileInfo(path).extension(); }
atUint64 size() const; uint64_t size() const;
static atUint64 size(std::string_view path) { return FileInfo(path).size(); } static uint64_t size(std::string_view path) { return FileInfo(path).size(); }
bool exists() const; bool exists() const;
static bool exists(std::string_view path) { return FileInfo(path).exists(); } static bool exists(std::string_view path) { return FileInfo(path).exists(); }

24
include/athena/FileReader.hpp
View File

@ -10,8 +10,8 @@
namespace athena::io { namespace athena::io {
class FileReader : public IStreamReader { class FileReader : public IStreamReader {
public: public:
explicit FileReader(std::string_view filename, atInt32 cacheSize = (32 * 1024), bool globalErr = true); explicit FileReader(std::string_view filename, int32_t cacheSize = (32 * 1024), bool globalErr = true);
explicit FileReader(std::wstring_view filename, atInt32 cacheSize = (32 * 1024), bool globalErr = true); explicit FileReader(std::wstring_view filename, int32_t cacheSize = (32 * 1024), bool globalErr = true);
~FileReader() override; ~FileReader() override;
std::string filename() const { std::string filename() const {
@ -33,12 +33,12 @@ public:
void open(); void open();
void close(); void close();
bool isOpen() const { return m_fileHandle != nullptr; } bool isOpen() const { return m_fileHandle != nullptr; }
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t pos, SeekOrigin origin = SeekOrigin::Current) override;
atUint64 position() const override; uint64_t position() const override;
atUint64 length() const override; uint64_t length() const override;
atUint64 readUBytesToBuf(void* buf, atUint64 len) override; uint64_t readUBytesToBuf(void* buf, uint64_t len) override;
void setCacheSize(const atInt32 blockSize); void setCacheSize(const int32_t blockSize);
#if _WIN32 #if _WIN32
using HandleType = void*; using HandleType = void*;
@ -55,11 +55,11 @@ protected:
std::string m_filename; std::string m_filename;
#endif #endif
HandleType m_fileHandle; HandleType m_fileHandle;
atUint64 m_fileSize; uint64_t m_fileSize;
std::unique_ptr<atUint8[]> m_cacheData; std::unique_ptr<uint8_t[]> m_cacheData;
atInt32 m_blockSize; int32_t m_blockSize;
atInt32 m_curBlock; int32_t m_curBlock;
atUint64 m_offset; uint64_t m_offset;
bool m_globalErr; bool m_globalErr;
}; };
} // namespace athena::io } // namespace athena::io

18
include/athena/FileWriter.hpp
View File

@ -30,10 +30,10 @@ public:
void open(bool overwrite = true); void open(bool overwrite = true);
void close(); void close();
bool isOpen() const { return m_fileHandle != nullptr; } bool isOpen() const { return m_fileHandle != nullptr; }
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t pos, SeekOrigin origin = SeekOrigin::Current) override;
atUint64 position() const override; uint64_t position() const override;
atUint64 length() const override; uint64_t length() const override;
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const uint8_t* data, uint64_t len) override;
#ifdef _WIN32 #ifdef _WIN32
using HandleType = void*; using HandleType = void*;
@ -61,7 +61,7 @@ class TransactionalFileWriter : public IStreamWriter {
#endif #endif
bool m_overwrite, m_globalErr; bool m_overwrite, m_globalErr;
std::vector<uint8_t> m_deferredBuffer; std::vector<uint8_t> m_deferredBuffer;
atUint64 m_position = 0; uint64_t m_position = 0;
public: public:
explicit TransactionalFileWriter(std::string_view filename, bool overwrite = true, bool globalErr = true) explicit TransactionalFileWriter(std::string_view filename, bool overwrite = true, bool globalErr = true)
@ -94,10 +94,10 @@ public:
m_position = 0; m_position = 0;
} }
atUint64 position() const override { return m_position; } uint64_t position() const override { return m_position; }
atUint64 length() const override { return m_deferredBuffer.size(); } uint64_t length() const override { return m_deferredBuffer.size(); }
void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t pos, SeekOrigin origin = SeekOrigin::Current) override;
void writeUBytes(const atUint8* data, atUint64 len) override; void writeUBytes(const uint8_t* data, uint64_t len) override;
~TransactionalFileWriter() override { flush(); } ~TransactionalFileWriter() override { flush(); }
}; };

6
include/athena/IStream.hpp
View File

@ -12,10 +12,10 @@ public:
Endian endian() const { return m_endian; } Endian endian() const { return m_endian; }
bool isBigEndian() const { return (m_endian == Endian::Big); } bool isBigEndian() const { return (m_endian == Endian::Big); }
bool isLittleEndian() const { return (m_endian == Endian::Little); } bool isLittleEndian() const { return (m_endian == Endian::Little); }
virtual void seek(atInt64, SeekOrigin) = 0; virtual void seek(int64_t, SeekOrigin) = 0;
virtual bool atEnd() const = 0; virtual bool atEnd() const = 0;
virtual atUint64 position() const = 0; virtual uint64_t position() const = 0;
virtual atUint64 length() const = 0; virtual uint64_t length() const = 0;
bool hasError() const { return m_hasError; } bool hasError() const { return m_hasError; }
protected: protected:

172
include/athena/IStreamReader.hpp
View File

@ -24,7 +24,7 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek relative to * @param origin The Origin to seek relative to
*/ */
void seek(atInt64 position, SeekOrigin origin = SeekOrigin::Current) override = 0; void seek(int64_t position, SeekOrigin origin = SeekOrigin::Current) override = 0;
/** @brief Sets the buffer's position relative to the next 64-byte aligned position.<br /> /** @brief Sets the buffer's position relative to the next 64-byte aligned position.<br />
*/ */
@ -52,33 +52,33 @@ public:
* *
* @return The current position in the stream. * @return The current position in the stream.
*/ */
atUint64 position() const override = 0; uint64_t position() const override = 0;
/** @brief Returns the length of the file. /** @brief Returns the length of the file.
* *
* @return True length of the file. * @return True length of the file.
*/ */
atUint64 length() const override = 0; uint64_t length() const override = 0;
/** @brief Reads a byte at the current position and advances the current position /** @brief Reads a byte at the current position and advances the current position
* *
* @return The value at the current position * @return The value at the current position
*/ */
atInt8 readByte() { int8_t readByte() {
atInt8 val = 0; int8_t val = 0;
readUBytesToBuf(&val, 1); readUBytesToBuf(&val, 1);
return val; return val;
} }
template <class T> template <class T>
atInt8 readVal(std::enable_if_t<std::is_same_v<T, atInt8>>* = nullptr) { int8_t readVal(std::enable_if_t<std::is_same_v<T, int8_t>>* = nullptr) {
return readByte(); return readByte();
} }
template <class T> template <class T>
atInt8 readValLittle(std::enable_if_t<std::is_same_v<T, atInt8>>* = nullptr) { int8_t readValLittle(std::enable_if_t<std::is_same_v<T, int8_t>>* = nullptr) {
return readByte(); return readByte();
} }
template <class T> template <class T>
atInt8 readValBig(std::enable_if_t<std::is_same_v<T, atInt8>>* = nullptr) { int8_t readValBig(std::enable_if_t<std::is_same_v<T, int8_t>>* = nullptr) {
return readByte(); return readByte();
} }
@ -86,17 +86,17 @@ public:
* *
* @return The value at the current position * @return The value at the current position
*/ */
atUint8 readUByte() { return readByte(); } uint8_t readUByte() { return readByte(); }
template <class T> template <class T>
atUint8 readVal(std::enable_if_t<std::is_same_v<T, atUint8>>* = nullptr) { uint8_t readVal(std::enable_if_t<std::is_same_v<T, uint8_t>>* = nullptr) {
return readUByte(); return readUByte();
} }
template <class T> template <class T>
atUint8 readValLittle(std::enable_if_t<std::is_same_v<T, atUint8>>* = nullptr) { uint8_t readValLittle(std::enable_if_t<std::is_same_v<T, uint8_t>>* = nullptr) {
return readUByte(); return readUByte();
} }
template <class T> template <class T>
atUint8 readValBig(std::enable_if_t<std::is_same_v<T, atUint8>>* = nullptr) { uint8_t readValBig(std::enable_if_t<std::is_same_v<T, uint8_t>>* = nullptr) {
return readUByte(); return readUByte();
} }
@ -104,8 +104,8 @@ public:
* *
* @return The buffer at the current position from the given length. * @return The buffer at the current position from the given length.
*/ */
std::unique_ptr<atInt8[]> readBytes(atUint64 length) { std::unique_ptr<int8_t[]> readBytes(uint64_t length) {
auto buf = std::make_unique<atInt8[]>(length); auto buf = std::make_unique<int8_t[]>(length);
readUBytesToBuf(buf.get(), length); readUBytesToBuf(buf.get(), length);
return buf; return buf;
} }
@ -114,8 +114,8 @@ public:
* *
* @return The buffer at the current position from the given length. * @return The buffer at the current position from the given length.
*/ */
std::unique_ptr<atUint8[]> readUBytes(atUint64 length) { std::unique_ptr<uint8_t[]> readUBytes(uint64_t length) {
auto buf = std::make_unique<atUint8[]>(length); auto buf = std::make_unique<uint8_t[]>(length);
readUBytesToBuf(buf.get(), length); readUBytesToBuf(buf.get(), length);
return buf; return buf;
} }
@ -125,7 +125,7 @@ public:
* @param len The length of the buffer * @param len The length of the buffer
* @return How much data was actually read, useful for detecting read errors. * @return How much data was actually read, useful for detecting read errors.
*/ */
atUint64 readBytesToBuf(void* buf, atUint64 len) { return readUBytesToBuf(buf, len); } uint64_t readBytesToBuf(void* buf, uint64_t len) { return readUBytesToBuf(buf, len); }
/** @brief Attempts to read a fixed length of data into a pre-allocated buffer, this function is client defined /** @brief Attempts to read a fixed length of data into a pre-allocated buffer, this function is client defined
* and must be implemented. * and must be implemented.
@ -133,20 +133,20 @@ public:
* @param len The length of the buffer * @param len The length of the buffer
* @return How much data was actually read, useful for detecting read errors. * @return How much data was actually read, useful for detecting read errors.
*/ */
virtual atUint64 readUBytesToBuf(void* buf, atUint64 len) = 0; virtual uint64_t readUBytesToBuf(void* buf, uint64_t len) = 0;
/** @brief Reads a Int16 and swaps to endianness specified by setEndian depending on platform /** @brief Reads a Int16 and swaps to endianness specified by setEndian depending on platform
* and advances the current position * and advances the current position
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt16 readInt16() { int16_t readInt16() {
atInt16 val = 0; int16_t val = 0;
readUBytesToBuf(&val, 2); readUBytesToBuf(&val, 2);
return m_endian == Endian::Big ? utility::BigInt16(val) : utility::LittleInt16(val); return m_endian == Endian::Big ? utility::BigInt16(val) : utility::LittleInt16(val);
} }
template <class T> template <class T>
atInt16 readVal(std::enable_if_t<std::is_same_v<T, atInt16>>* = nullptr) { int16_t readVal(std::enable_if_t<std::is_same_v<T, int16_t>>* = nullptr) {
return readInt16(); return readInt16();
} }
@ -155,13 +155,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt16 readInt16Little() { int16_t readInt16Little() {
atInt16 val = 0; int16_t val = 0;
readUBytesToBuf(&val, 2); readUBytesToBuf(&val, 2);
return utility::LittleInt16(val); return utility::LittleInt16(val);
} }
template <class T> template <class T>
atInt16 readValLittle(std::enable_if_t<std::is_same_v<T, atInt16>>* = nullptr) { int16_t readValLittle(std::enable_if_t<std::is_same_v<T, int16_t>>* = nullptr) {
return readInt16Little(); return readInt16Little();
} }
@ -170,13 +170,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt16 readInt16Big() { int16_t readInt16Big() {
atInt16 val = 0; int16_t val = 0;
readUBytesToBuf(&val, 2); readUBytesToBuf(&val, 2);
return utility::BigInt16(val); return utility::BigInt16(val);
} }
template <class T> template <class T>
atInt16 readValBig(std::enable_if_t<std::is_same_v<T, atInt16>>* = nullptr) { int16_t readValBig(std::enable_if_t<std::is_same_v<T, int16_t>>* = nullptr) {
return readInt16Big(); return readInt16Big();
} }
@ -185,9 +185,9 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint16 readUint16() { return readInt16(); } uint16_t readUint16() { return readInt16(); }
template <class T> template <class T>
atUint16 readVal(std::enable_if_t<std::is_same_v<T, atUint16>>* = 0) { uint16_t readVal(std::enable_if_t<std::is_same_v<T, uint16_t>>* = 0) {
return readUint16(); return readUint16();
} }
@ -196,13 +196,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint16 readUint16Little() { uint16_t readUint16Little() {
atUint16 val = 0; uint16_t val = 0;
readUBytesToBuf(&val, 2); readUBytesToBuf(&val, 2);
return utility::LittleUint16(val); return utility::LittleUint16(val);
} }
template <class T> template <class T>
atUint16 readValLittle(std::enable_if_t<std::is_same_v<T, atUint16>>* = nullptr) { uint16_t readValLittle(std::enable_if_t<std::is_same_v<T, uint16_t>>* = nullptr) {
return readUint16Little(); return readUint16Little();
} }
@ -211,13 +211,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint16 readUint16Big() { uint16_t readUint16Big() {
atUint16 val = 0; uint16_t val = 0;
readUBytesToBuf(&val, 2); readUBytesToBuf(&val, 2);
return utility::BigUint16(val); return utility::BigUint16(val);
} }
template <class T> template <class T>
atUint16 readValBig(std::enable_if_t<std::is_same_v<T, atUint16>>* = nullptr) { uint16_t readValBig(std::enable_if_t<std::is_same_v<T, uint16_t>>* = nullptr) {
return readUint16Big(); return readUint16Big();
} }
@ -226,13 +226,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt32 readInt32() { int32_t readInt32() {
atInt32 val = 0; int32_t val = 0;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return m_endian == Endian::Big ? utility::BigInt32(val) : utility::LittleInt32(val); return m_endian == Endian::Big ? utility::BigInt32(val) : utility::LittleInt32(val);
} }
template <class T> template <class T>
atInt32 readVal(std::enable_if_t<std::is_same_v<T, atInt32>>* = nullptr) { int32_t readVal(std::enable_if_t<std::is_same_v<T, int32_t>>* = nullptr) {
return readInt32(); return readInt32();
} }
@ -241,13 +241,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt32 readInt32Little() { int32_t readInt32Little() {
atInt32 val = 0; int32_t val = 0;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return utility::LittleInt32(val); return utility::LittleInt32(val);
} }
template <class T> template <class T>
atInt32 readValLittle(std::enable_if_t<std::is_same_v<T, atInt32>>* = nullptr) { int32_t readValLittle(std::enable_if_t<std::is_same_v<T, int32_t>>* = nullptr) {
return readInt32Little(); return readInt32Little();
} }
@ -256,13 +256,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt32 readInt32Big() { int32_t readInt32Big() {
atInt32 val = 0; int32_t val = 0;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return utility::BigInt32(val); return utility::BigInt32(val);
} }
template <class T> template <class T>
atInt32 readValBig(std::enable_if_t<std::is_same_v<T, atInt32>>* = nullptr) { int32_t readValBig(std::enable_if_t<std::is_same_v<T, int32_t>>* = nullptr) {
return readInt32Big(); return readInt32Big();
} }
@ -271,9 +271,9 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint32 readUint32() { return readInt32(); } uint32_t readUint32() { return readInt32(); }
template <class T> template <class T>
atUint32 readVal(std::enable_if_t<std::is_same_v<T, atUint32>>* = nullptr) { uint32_t readVal(std::enable_if_t<std::is_same_v<T, uint32_t>>* = nullptr) {
return readUint32(); return readUint32();
} }
@ -282,13 +282,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint32 readUint32Little() { uint32_t readUint32Little() {
atUint32 val = 0; uint32_t val = 0;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return utility::LittleUint32(val); return utility::LittleUint32(val);
} }
template <class T> template <class T>
atInt32 readValLittle(std::enable_if_t<std::is_same_v<T, atUint32>>* = nullptr) { int32_t readValLittle(std::enable_if_t<std::is_same_v<T, uint32_t>>* = nullptr) {
return readUint32Little(); return readUint32Little();
} }
@ -297,13 +297,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint32 readUint32Big() { uint32_t readUint32Big() {
atUint32 val = 0; uint32_t val = 0;
readUBytesToBuf(&val, 4); readUBytesToBuf(&val, 4);
return utility::BigUint32(val); return utility::BigUint32(val);
} }
template <class T> template <class T>
atUint32 readValBig(std::enable_if_t<std::is_same_v<T, atUint32>>* = nullptr) { uint32_t readValBig(std::enable_if_t<std::is_same_v<T, uint32_t>>* = nullptr) {
return readUint32Big(); return readUint32Big();
} }
@ -312,13 +312,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt64 readInt64() { int64_t readInt64() {
atInt64 val = 0; int64_t val = 0;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return m_endian == Endian::Big ? utility::BigInt64(val) : utility::LittleInt64(val); return m_endian == Endian::Big ? utility::BigInt64(val) : utility::LittleInt64(val);
} }
template <class T> template <class T>
atInt64 readVal(std::enable_if_t<std::is_same_v<T, atInt64>>* = nullptr) { int64_t readVal(std::enable_if_t<std::is_same_v<T, int64_t>>* = nullptr) {
return readInt64(); return readInt64();
} }
@ -327,13 +327,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt64 readInt64Little() { int64_t readInt64Little() {
atInt64 val = 0; int64_t val = 0;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return utility::LittleInt64(val); return utility::LittleInt64(val);
} }
template <class T> template <class T>
atInt64 readValLittle(std::enable_if_t<std::is_same_v<T, atInt64>>* = nullptr) { int64_t readValLittle(std::enable_if_t<std::is_same_v<T, int64_t>>* = nullptr) {
return readInt64Little(); return readInt64Little();
} }
@ -342,13 +342,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atInt64 readInt64Big() { int64_t readInt64Big() {
atInt64 val = 0; int64_t val = 0;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return utility::BigInt64(val); return utility::BigInt64(val);
} }
template <class T> template <class T>
atInt64 readValBig(std::enable_if_t<std::is_same_v<T, atInt64>>* = nullptr) { int64_t readValBig(std::enable_if_t<std::is_same_v<T, int64_t>>* = nullptr) {
return readInt64Big(); return readInt64Big();
} }
@ -357,9 +357,9 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint64 readUint64() { return readInt64(); } uint64_t readUint64() { return readInt64(); }
template <class T> template <class T>
atUint64 readVal(std::enable_if_t<std::is_same_v<T, atUint64>>* = nullptr) { uint64_t readVal(std::enable_if_t<std::is_same_v<T, uint64_t>>* = nullptr) {
return readUint64(); return readUint64();
} }
@ -368,13 +368,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint64 readUint64Little() { uint64_t readUint64Little() {
atUint64 val = 0; uint64_t val = 0;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return utility::LittleUint64(val); return utility::LittleUint64(val);
} }
template <class T> template <class T>
atUint64 readValLittle(std::enable_if_t<std::is_same_v<T, atUint64>>* = nullptr) { uint64_t readValLittle(std::enable_if_t<std::is_same_v<T, uint64_t>>* = nullptr) {
return readUint64Little(); return readUint64Little();
} }
@ -383,13 +383,13 @@ public:
* *
* @return The value at the current address * @return The value at the current address
*/ */
atUint64 readUint64Big() { uint64_t readUint64Big() {
atUint64 val = 0; uint64_t val = 0;
readUBytesToBuf(&val, 8); readUBytesToBuf(&val, 8);
return utility::BigUint64(val); return utility::BigUint64(val);
} }
template <class T> template <class T>
atUint64 readValBig(std::enable_if_t<std::is_same_v<T, atUint64>>* = nullptr) { uint64_t readValBig(std::enable_if_t<std::is_same_v<T, uint64_t>>* = nullptr) {
return readUint64Big(); return readUint64Big();
} }
@ -488,7 +488,7 @@ public:
* @return The value at the current address * @return The value at the current address
*/ */
bool readBool() { bool readBool() {
atUint8 val = false; uint8_t val = false;
readUBytesToBuf(&val, 1); readUBytesToBuf(&val, 1);
return val != 0; return val != 0;
} }
@ -927,13 +927,13 @@ public:
* *
* @return The read string * @return The read string
*/ */
std::string readString(atInt32 fixedLen = -1, bool doSeek = true) { std::string readString(int32_t fixedLen = -1, bool doSeek = true) {
if (fixedLen == 0) if (fixedLen == 0)
return std::string(); return std::string();
std::string ret; std::string ret;
atUint8 chr = readByte(); uint8_t chr = readByte();
atInt32 i; int32_t i;
for (i = 1; chr != 0; ++i) { for (i = 1; chr != 0; ++i) {
ret += chr; ret += chr;
@ -961,14 +961,14 @@ public:
* *
* @return The read wstring * @return The read wstring
*/ */
std::wstring readWString(atInt32 fixedLen = -1, bool doSeek = true) { std::wstring readWString(int32_t fixedLen = -1, bool doSeek = true) {
if (fixedLen == 0) if (fixedLen == 0)
return std::wstring(); return std::wstring();
std::wstring ret; std::wstring ret;
atUint16 chr = readUint16(); uint16_t chr = readUint16();
atInt32 i; int32_t i;
for (i = 1; chr != 0; ++i) { for (i = 1; chr != 0; ++i) {
ret += chr; ret += chr;
@ -997,14 +997,14 @@ public:
* *
* @return The read wstring * @return The read wstring
*/ */
std::wstring readWStringLittle(atInt32 fixedLen = -1, bool doSeek = true) { std::wstring readWStringLittle(int32_t fixedLen = -1, bool doSeek = true) {
if (fixedLen == 0) if (fixedLen == 0)
return std::wstring(); return std::wstring();
std::wstring ret; std::wstring ret;
atUint16 chr = readUint16Little(); uint16_t chr = readUint16Little();
atInt32 i; int32_t i;
for (i = 1; chr != 0; ++i) { for (i = 1; chr != 0; ++i) {
ret += chr; ret += chr;
@ -1033,13 +1033,13 @@ public:
* *
* @return The read wstring * @return The read wstring
*/ */
std::wstring readWStringBig(atInt32 fixedLen = -1, bool doSeek = true) { std::wstring readWStringBig(int32_t fixedLen = -1, bool doSeek = true) {
if (fixedLen == 0) if (fixedLen == 0)
return std::wstring(); return std::wstring();
std::wstring ret; std::wstring ret;
atUint16 chr = readUint16Big(); uint16_t chr = readUint16Big();
atInt32 i; int32_t i;
for (i = 1; chr != 0; ++i) { for (i = 1; chr != 0; ++i) {
ret += chr; ret += chr;
@ -1068,13 +1068,13 @@ public:
* *
* @return The read wstring * @return The read wstring
*/ */
std::u16string readU16StringBig(atInt32 fixedLen = -1, bool doSeek = true) { std::u16string readU16StringBig(int32_t fixedLen = -1, bool doSeek = true) {
if (fixedLen == 0) if (fixedLen == 0)
return std::u16string(); return std::u16string();
std::u16string ret; std::u16string ret;
char16_t chr = readUint16Big(); char16_t chr = readUint16Big();
atInt32 i; int32_t i;
for (i = 1; chr != 0; ++i) { for (i = 1; chr != 0; ++i) {
ret += chr; ret += chr;
@ -1103,13 +1103,13 @@ public:
* *
* @return The read wstring * @return The read wstring
*/ */
std::u32string readU32StringBig(atInt32 fixedLen = -1, bool doSeek = true) { std::u32string readU32StringBig(int32_t fixedLen = -1, bool doSeek = true) {
if (fixedLen == 0) if (fixedLen == 0)
return std::u32string(); return std::u32string();
std::u32string ret; std::u32string ret;
char32_t chr = readUint32Big(); char32_t chr = readUint32Big();
atInt32 i; int32_t i;
for (i = 1; chr != 0; ++i) { for (i = 1; chr != 0; ++i) {
ret += chr; ret += chr;

172
include/athena/IStreamWriter.hpp
View File

@ -19,7 +19,7 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The location to seek relative to * @param origin The location to seek relative to
*/ */
void seek(atInt64 position, SeekOrigin origin = SeekOrigin::Current) override = 0; void seek(int64_t position, SeekOrigin origin = SeekOrigin::Current) override = 0;
/** @brief Sets the buffers position relative to the next 32-byte aligned position.<br /> /** @brief Sets the buffers position relative to the next 32-byte aligned position.<br />
*/ */
@ -27,11 +27,11 @@ public:
/** @brief Writes zero up to specified absolute offset.<br /> /** @brief Writes zero up to specified absolute offset.<br />
*/ */
void writeZeroTo(atInt64 pos) { void writeZeroTo(int64_t pos) {
atInt64 delta = pos - position(); int64_t delta = pos - position();
if (delta <= 0) if (delta <= 0)
return; return;
for (atInt64 i = 0; i < delta; ++i) for (int64_t i = 0; i < delta; ++i)
writeUByte(0); writeUByte(0);
} }
@ -45,29 +45,29 @@ public:
* *
* @return The current position in the stream. * @return The current position in the stream.
*/ */
atUint64 position() const override = 0; uint64_t position() const override = 0;
/** @brief Returns whether or not the stream is at the end. /** @brief Returns whether or not the stream is at the end.
* *
* @return True if at end; False otherwise. * @return True if at end; False otherwise.
*/ */
atUint64 length() const override = 0; uint64_t length() const override = 0;
/** @brief Writes a byte at the current position and advances the position by one byte. /** @brief Writes a byte at the current position and advances the position by one byte.
* @param val The value to write * @param val The value to write
*/ */
void writeUByte(atUint8 val) { writeUBytes(&val, 1); } void writeUByte(uint8_t val) { writeUBytes(&val, 1); }
void writeVal(atUint8 val) { writeUByte(val); } void writeVal(uint8_t val) { writeUByte(val); }
void writeValLittle(atUint8 val) { writeUByte(val); } void writeValLittle(uint8_t val) { writeUByte(val); }
void writeValBig(atUint8 val) { writeUByte(val); } void writeValBig(uint8_t val) { writeUByte(val); }
/** @brief Writes a byte at the current position and advances the position by one byte. /** @brief Writes a byte at the current position and advances the position by one byte.
* @param val The value to write * @param val The value to write
*/ */
void writeByte(atInt8 val) { writeUByte(val); } void writeByte(int8_t val) { writeUByte(val); }
void writeVal(atInt8 val) { writeByte(val); } void writeVal(int8_t val) { writeByte(val); }
void writeValLittle(atInt8 val) { writeByte(val); } void writeValLittle(int8_t val) { writeByte(val); }
void writeValBig(atInt8 val) { writeByte(val); } void writeValBig(int8_t val) { writeByte(val); }
/** @brief Writes the given buffer with the specified length, buffers can be bigger than the length /** @brief Writes the given buffer with the specified length, buffers can be bigger than the length
* however it's undefined behavior to try and write a buffer which is smaller than the given length. * however it's undefined behavior to try and write a buffer which is smaller than the given length.
@ -75,7 +75,7 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
virtual void writeUBytes(const atUint8* data, atUint64 length) = 0; virtual void writeUBytes(const uint8_t* data, uint64_t length) = 0;
/** @brief Writes the given buffer with the specified length, buffers can be bigger than the length /** @brief Writes the given buffer with the specified length, buffers can be bigger than the length
* however it's undefined behavior to try and write a buffer which is smaller than the given length. * however it's undefined behavior to try and write a buffer which is smaller than the given length.
@ -83,14 +83,14 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeBytes(const void* data, atUint64 length) { writeUBytes(reinterpret_cast<const atUint8*>(data), length); } void writeBytes(const void* data, uint64_t length) { writeUBytes(reinterpret_cast<const uint8_t*>(data), length); }
/** @brief Writes an Int16 to the buffer and advances the buffer. /** @brief Writes an Int16 to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings. * It also swaps the bytes depending on the platform and Stream settings.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt16(atInt16 val) { void writeInt16(int16_t val) {
if (m_endian == Endian::Big) { if (m_endian == Endian::Big) {
utility::BigInt16(val); utility::BigInt16(val);
} else { } else {
@ -98,60 +98,60 @@ public:
} }
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeVal(atInt16 val) { writeInt16(val); } void writeVal(int16_t val) { writeInt16(val); }
/** @brief Writes an Int16 to the buffer and advances the buffer. /** @brief Writes an Int16 to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform. * It also swaps the bytes against little depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt16Little(atInt16 val) { void writeInt16Little(int16_t val) {
utility::LittleInt16(val); utility::LittleInt16(val);
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeValLittle(atInt16 val) { writeInt16Little(val); } void writeValLittle(int16_t val) { writeInt16Little(val); }
/** @brief Writes an Int16 to the buffer and advances the buffer. /** @brief Writes an Int16 to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform. * It also swaps the bytes against big depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt16Big(atInt16 val) { void writeInt16Big(int16_t val) {
utility::BigInt16(val); utility::BigInt16(val);
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeValBig(atInt16 val) { writeInt16Big(val); } void writeValBig(int16_t val) { writeInt16Big(val); }
/** @brief Writes an Uint16 to the buffer and advances the buffer. /** @brief Writes an Uint16 to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings * It also swaps the bytes depending on the platform and Stream settings
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint16(atUint16 val) { writeInt16(val); } void writeUint16(uint16_t val) { writeInt16(val); }
void writeVal(atUint16 val) { writeUint16(val); } void writeVal(uint16_t val) { writeUint16(val); }
/** @brief Writes an Uint16 to the buffer and advances the buffer. /** @brief Writes an Uint16 to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform * It also swaps the bytes against little depending on the platform
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint16Little(atUint16 val) { writeInt16Little(val); } void writeUint16Little(uint16_t val) { writeInt16Little(val); }
void writeValLittle(atUint16 val) { writeUint16Little(val); } void writeValLittle(uint16_t val) { writeUint16Little(val); }
/** @brief Writes an Uint16 to the buffer and advances the buffer. /** @brief Writes an Uint16 to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform * It also swaps the bytes against big depending on the platform
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint16Big(atUint16 val) { writeInt16Big(val); } void writeUint16Big(uint16_t val) { writeInt16Big(val); }
void writeValBig(atUint16 val) { writeUint16Big(val); } void writeValBig(uint16_t val) { writeUint16Big(val); }
/** @brief Writes an Int32 to the buffer and advances the buffer. /** @brief Writes an Int32 to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings. * It also swaps the bytes depending on the platform and Stream settings.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt32(atInt32 val) { void writeInt32(int32_t val) {
if (m_endian == Endian::Big) { if (m_endian == Endian::Big) {
utility::BigInt32(val); utility::BigInt32(val);
} else { } else {
@ -159,60 +159,60 @@ public:
} }
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeVal(atInt32 val) { writeInt32(val); } void writeVal(int32_t val) { writeInt32(val); }
/** @brief Writes an Int32 to the buffer and advances the buffer. /** @brief Writes an Int32 to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform. * It also swaps the bytes against little depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt32Little(atInt32 val) { void writeInt32Little(int32_t val) {
utility::LittleInt32(val); utility::LittleInt32(val);
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeValLittle(atInt32 val) { writeInt32Little(val); } void writeValLittle(int32_t val) { writeInt32Little(val); }
/** @brief Writes an Int32 to the buffer and advances the buffer. /** @brief Writes an Int32 to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform. * It also swaps the bytes against big depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt32Big(atInt32 val) { void writeInt32Big(int32_t val) {
utility::BigInt32(val); utility::BigInt32(val);
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeValBig(atInt32 val) { writeInt32Big(val); } void writeValBig(int32_t val) { writeInt32Big(val); }
/** @brief Writes an Uint32 to the buffer and advances the buffer. /** @brief Writes an Uint32 to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings. * It also swaps the bytes depending on the platform and Stream settings.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint32(atUint32 val) { writeInt32(val); } void writeUint32(uint32_t val) { writeInt32(val); }
void writeVal(atUint32 val) { writeUint32(val); } void writeVal(uint32_t val) { writeUint32(val); }
/** @brief Writes an Uint32 to the buffer and advances the buffer. /** @brief Writes an Uint32 to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform. * It also swaps the bytes against little depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint32Little(atUint32 val) { writeInt32Little(val); } void writeUint32Little(uint32_t val) { writeInt32Little(val); }
void writeValLittle(atUint32 val) { writeUint32Little(val); } void writeValLittle(uint32_t val) { writeUint32Little(val); }
/** @brief Writes an Uint32 to the buffer and advances the buffer. /** @brief Writes an Uint32 to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform. * It also swaps the bytes against big depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint32Big(atUint32 val) { writeInt32Big(val); } void writeUint32Big(uint32_t val) { writeInt32Big(val); }
void writeValBig(atUint32 val) { writeUint32Big(val); } void writeValBig(uint32_t val) { writeUint32Big(val); }
/** @brief Writes an Int64 to the buffer and advances the buffer. /** @brief Writes an Int64 to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings. * It also swaps the bytes depending on the platform and Stream settings.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt64(atInt64 val) { void writeInt64(int64_t val) {
if (m_endian == Endian::Big) { if (m_endian == Endian::Big) {
utility::BigInt64(val); utility::BigInt64(val);
} else { } else {
@ -220,53 +220,53 @@ public:
} }
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeVal(atInt64 val) { writeInt64(val); } void writeVal(int64_t val) { writeInt64(val); }
/** @brief Writes an Int64 to the buffer and advances the buffer. /** @brief Writes an Int64 to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform. * It also swaps the bytes against little depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt64Little(atInt64 val) { void writeInt64Little(int64_t val) {
utility::LittleInt64(val); utility::LittleInt64(val);
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeValLittle(atInt64 val) { writeInt64Little(val); } void writeValLittle(int64_t val) { writeInt64Little(val); }
/** @brief Writes an Int64 to the buffer and advances the buffer. /** @brief Writes an Int64 to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform. * It also swaps the bytes against big depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeInt64Big(atInt64 val) { void writeInt64Big(int64_t val) {
utility::BigInt64(val); utility::BigInt64(val);
writeBytes(&val, sizeof(val)); writeBytes(&val, sizeof(val));
} }
void writeValBig(atInt64 val) { writeInt64Big(val); } void writeValBig(int64_t val) { writeInt64Big(val); }
/** @brief Writes an Uint64 to the buffer and advances the buffer. /** @brief Writes an Uint64 to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings. * It also swaps the bytes depending on the platform and Stream settings.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint64(atUint64 val) { writeInt64(val); } void writeUint64(uint64_t val) { writeInt64(val); }
void writeVal(atUint64 val) { writeUint64(val); } void writeVal(uint64_t val) { writeUint64(val); }
/** @brief Writes an Uint64 to the buffer and advances the buffer. /** @brief Writes an Uint64 to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform. * It also swaps the bytes against little depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint64Little(atUint64 val) { writeInt64Little(val); } void writeUint64Little(uint64_t val) { writeInt64Little(val); }
void writeValLittle(atUint64 val) { writeUint64Little(val); } void writeValLittle(uint64_t val) { writeUint64Little(val); }
/** @brief Writes an Uint64 to the buffer and advances the buffer. /** @brief Writes an Uint64 to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform. * It also swaps the bytes against big depending on the platform.
* *
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeUint64Big(atUint64 val) { writeInt64Big(val); } void writeUint64Big(uint64_t val) { writeInt64Big(val); }
void writeValBig(atUint64 val) { writeUint64Big(val); } void writeValBig(uint64_t val) { writeUint64Big(val); }
/** @brief Writes an float to the buffer and advances the buffer. /** @brief Writes an float to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings. * It also swaps the bytes depending on the platform and Stream settings.
@ -348,7 +348,7 @@ public:
* @param val The value to write to the buffer * @param val The value to write to the buffer
*/ */
void writeBool(bool val) { void writeBool(bool val) {
const auto u8Value = atUint8(val); const auto u8Value = uint8_t(val);
writeUBytes(&u8Value, sizeof(u8Value)); writeUBytes(&u8Value, sizeof(u8Value));
} }
void writeVal(bool val) { writeBool(val); } void writeVal(bool val) { writeBool(val); }
@ -651,7 +651,7 @@ public:
* *
* Endianness is set with setEndian * Endianness is set with setEndian
*/ */
void writeStringAsWString(std::string_view str, atInt32 fixedLen = -1) { void writeStringAsWString(std::string_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
std::string tmpStr = std::string("\xEF\xBB\xBF") + str.data(); std::string tmpStr = std::string("\xEF\xBB\xBF") + str.data();
@ -666,11 +666,11 @@ public:
} }
buf += len; buf += len;
if (wc != 0xFEFF) if (wc != 0xFEFF)
writeUint16(atUint16(wc)); writeUint16(uint16_t(wc));
} }
writeUint16(0); writeUint16(0);
} else { } else {
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
utf8proc_int32_t wc = 0; utf8proc_int32_t wc = 0;
if (*buf) { if (*buf) {
utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc); utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc);
@ -686,7 +686,7 @@ public:
continue; continue;
} }
writeUint16(atUint16(wc)); writeUint16(uint16_t(wc));
} }
} }
} }
@ -699,7 +699,7 @@ public:
* *
* Endianness is little * Endianness is little
*/ */
void writeStringAsWStringLittle(std::string_view str, atInt32 fixedLen = -1) { void writeStringAsWStringLittle(std::string_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
std::string tmpStr = std::string("\xEF\xBB\xBF") + str.data(); std::string tmpStr = std::string("\xEF\xBB\xBF") + str.data();
@ -714,11 +714,11 @@ public:
} }
buf += len; buf += len;
if (wc != 0xFEFF) if (wc != 0xFEFF)
writeUint16Little(atUint16(wc)); writeUint16Little(uint16_t(wc));
} }
writeUint16Little(0); writeUint16Little(0);
} else { } else {
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
utf8proc_int32_t wc = 0; utf8proc_int32_t wc = 0;
if (*buf) { if (*buf) {
utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc); utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc);
@ -734,7 +734,7 @@ public:
continue; continue;
} }
writeUint16Little(atUint16(wc)); writeUint16Little(uint16_t(wc));
} }
} }
} }
@ -747,7 +747,7 @@ public:
* *
* Endianness is big * Endianness is big
*/ */
void writeStringAsWStringBig(std::string_view str, atInt32 fixedLen = -1) { void writeStringAsWStringBig(std::string_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
@ -763,11 +763,11 @@ public:
} }
buf += len; buf += len;
if (wc != 0xFEFF) if (wc != 0xFEFF)
writeUint16Big(atUint16(wc)); writeUint16Big(uint16_t(wc));
} }
writeUint16Big(0); writeUint16Big(0);
} else { } else {
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
utf8proc_int32_t wc = 0; utf8proc_int32_t wc = 0;
if (*buf) { if (*buf) {
utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc); utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc);
@ -783,7 +783,7 @@ public:
continue; continue;
} }
writeUint16Big(atUint16(wc)); writeUint16Big(uint16_t(wc));
} }
} }
} }
@ -793,12 +793,12 @@ public:
* @param str The string to write to the buffer * @param str The string to write to the buffer
* @param fixedLen If not -1, the number of characters to zero-fill string to * @param fixedLen If not -1, the number of characters to zero-fill string to
*/ */
void writeString(std::string_view str, atInt32 fixedLen = -1) { void writeString(std::string_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
if (fixedLen < 0) { if (fixedLen < 0) {
for (atUint8 c : str) { for (uint8_t c : str) {
writeUByte(c); writeUByte(c);
if (c == '\0') if (c == '\0')
@ -807,8 +807,8 @@ public:
writeUByte(0); writeUByte(0);
} else { } else {
auto it = str.begin(); auto it = str.begin();
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
atUint8 chr; uint8_t chr;
if (it == str.end()) if (it == str.end())
chr = 0; chr = 0;
else else
@ -826,12 +826,12 @@ public:
* *
* Endianness is set with setEndian * Endianness is set with setEndian
*/ */
void writeWString(std::wstring_view str, atInt32 fixedLen = -1) { void writeWString(std::wstring_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
if (fixedLen < 0) { if (fixedLen < 0) {
for (atUint16 c : str) { for (uint16_t c : str) {
writeUint16(c); writeUint16(c);
if (c == L'\0') if (c == L'\0')
@ -840,8 +840,8 @@ public:
writeUint16(0); writeUint16(0);
} else { } else {
auto it = str.begin(); auto it = str.begin();
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
atUint16 chr; uint16_t chr;
if (it == str.end()) if (it == str.end())
chr = 0; chr = 0;
else else
@ -859,12 +859,12 @@ public:
* *
* Endianness is little * Endianness is little
*/ */
void writeWStringLittle(std::wstring_view str, atInt32 fixedLen = -1) { void writeWStringLittle(std::wstring_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
if (fixedLen < 0) { if (fixedLen < 0) {
for (atUint16 c : str) { for (uint16_t c : str) {
writeUint16Little(c); writeUint16Little(c);
if (c == L'\0') if (c == L'\0')
@ -873,8 +873,8 @@ public:
writeUint16Little(0); writeUint16Little(0);
} else { } else {
auto it = str.begin(); auto it = str.begin();
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
atUint16 chr; uint16_t chr;
if (it == str.end()) if (it == str.end())
chr = 0; chr = 0;
else else
@ -892,7 +892,7 @@ public:
* *
* Endianness is big * Endianness is big
*/ */
void writeWStringBig(std::wstring_view str, atInt32 fixedLen = -1) { void writeWStringBig(std::wstring_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
@ -906,7 +906,7 @@ public:
writeUint16Big(0); writeUint16Big(0);
} else { } else {
auto it = str.begin(); auto it = str.begin();
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
wchar_t chr; wchar_t chr;
if (it == str.end()) if (it == str.end())
chr = 0; chr = 0;
@ -925,7 +925,7 @@ public:
* *
* Endianness is big * Endianness is big
*/ */
void writeU16StringBig(std::u16string_view str, atInt32 fixedLen = -1) { void writeU16StringBig(std::u16string_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
@ -939,7 +939,7 @@ public:
writeUint16Big(0); writeUint16Big(0);
} else { } else {
auto it = str.begin(); auto it = str.begin();
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
char16_t chr; char16_t chr;
if (it == str.end()) if (it == str.end())
chr = 0; chr = 0;
@ -958,7 +958,7 @@ public:
* *
* Endianness is big * Endianness is big
*/ */
void writeU32StringBig(std::u32string_view str, atInt32 fixedLen = -1) { void writeU32StringBig(std::u32string_view str, int32_t fixedLen = -1) {
if (fixedLen == 0) if (fixedLen == 0)
return; return;
@ -972,7 +972,7 @@ public:
writeUint32Big(0); writeUint32Big(0);
} else { } else {
auto it = str.begin(); auto it = str.begin();
for (atInt32 i = 0; i < fixedLen; ++i) { for (int32_t i = 0; i < fixedLen; ++i) {
char32_t chr; char32_t chr;
if (it == str.end()) if (it == str.end())
chr = 0; chr = 0;
@ -984,15 +984,15 @@ public:
} }
void writeValBig(std::u32string_view val) { writeU32StringBig(val); } void writeValBig(std::u32string_view val) { writeU32StringBig(val); }
void fill(atUint8 val, atUint64 length) { void fill(uint8_t val, uint64_t length) {
if (length == 0) if (length == 0)
return; return;
const std::vector<atUint8> tmp(length, val); const std::vector<uint8_t> tmp(length, val);
writeUBytes(tmp.data(), length); writeUBytes(tmp.data(), length);
} }
void fill(atInt8 val, atUint64 length) { fill((atUint8)val, length); } void fill(int8_t val, uint64_t length) { fill((uint8_t)val, length); }
/** @brief Performs automatic std::vector enumeration writes using numeric type T /** @brief Performs automatic std::vector enumeration writes using numeric type T
* @param vector The std::vector read from when writing data * @param vector The std::vector read from when writing data

2
include/athena/MCFile.hpp
View File

@ -19,7 +19,7 @@ public:
MCFile(); MCFile();
static atUint8* unscramble(atUint8* data, atUint64 length); static uint8_t* unscramble(uint8_t* data, uint64_t length);
private: private:
MCSlot* m_slots[3]; MCSlot* m_slots[3];

2
include/athena/MCFileReader.hpp
View File

@ -23,7 +23,7 @@ public:
* \param data The existing buffer * \param data The existing buffer
* \param length The length of the existing buffer * \param length The length of the existing buffer
*/ */
MCFileReader(atUint8*, atUint64); MCFileReader(uint8_t*, uint64_t);
/*! /*!
* \brief This constructor creates an instance from a file on disk. * \brief This constructor creates an instance from a file on disk.

6
include/athena/MCFileWriter.hpp
View File

@ -24,7 +24,7 @@ public:
* \param data The existing buffer * \param data The existing buffer
* \param length The length of the existing buffer * \param length The length of the existing buffer
*/ */
MCFileWriter(atUint8*, atUint64); MCFileWriter(uint8_t*, uint64_t);
/*! /*!
* \brief This constructor creates an instance from a file on disk. * \brief This constructor creates an instance from a file on disk.
@ -40,10 +40,10 @@ public:
*/ */
void writeFile(MCFile* file); void writeFile(MCFile* file);
static atUint16 calculateChecksum(atUint8* data, atUint32 length); static uint16_t calculateChecksum(uint8_t* data, uint32_t length);
private: private:
atUint16 calculateSlotChecksum(atUint32 game); uint16_t calculateSlotChecksum(uint32_t game);
}; };
} // namespace io } // namespace io

2
include/athena/MCSlot.hpp
View File

@ -6,7 +6,7 @@
namespace athena { namespace athena {
class MCSlot : public ZQuestFile { class MCSlot : public ZQuestFile {
public: public:
MCSlot(std::unique_ptr<atUint8[]>&& data, atUint32 length); MCSlot(std::unique_ptr<uint8_t[]>&& data, uint32_t length);
}; };
} // namespace athena } // namespace athena

24
include/athena/MemoryReader.hpp
View File

@ -28,26 +28,26 @@ public:
* \param takeOwnership Memory will be freed with the reader if set. * \param takeOwnership Memory will be freed with the reader if set.
* \param globalErr Whether or not global errors are enabled. * \param globalErr Whether or not global errors are enabled.
*/ */
explicit MemoryReader(const void* data, atUint64 length, bool takeOwnership = false, bool globalErr = true); explicit MemoryReader(const void* data, uint64_t length, bool takeOwnership = false, bool globalErr = true);
/*! \brief Sets the buffers position relative to the specified position.<br /> /*! \brief Sets the buffers position relative to the specified position.<br />
* It seeks relative to the current position by default. * It seeks relative to the current position by default.
* \param position where in the buffer to seek * \param position where in the buffer to seek
* \param origin The Origin to seek \sa SeekOrigin * \param origin The Origin to seek \sa SeekOrigin
*/ */
void seek(atInt64 position, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t position, SeekOrigin origin = SeekOrigin::Current) override;
/*! \brief Returns the current position in the stream. /*! \brief Returns the current position in the stream.
* *
* \return Int64 The current position in the stream. * \return Int64 The current position in the stream.
*/ */
atUint64 position() const override { return m_position; } uint64_t position() const override { return m_position; }
/*! \brief Returns whether or not the stream is at the end. /*! \brief Returns whether or not the stream is at the end.
* *
* \return bool True if at end; False otherwise. * \return bool True if at end; False otherwise.
*/ */
atUint64 length() const override { return m_length; } uint64_t length() const override { return m_length; }
/*! \brief Sets the buffer to the given one, deleting the current one.<br /> /*! \brief Sets the buffer to the given one, deleting the current one.<br />
* <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data * <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data
@ -59,7 +59,7 @@ public:
* \param takeOwnership Memory will be freed with the reader if set * \param takeOwnership Memory will be freed with the reader if set
* \throw IOException * \throw IOException
*/ */
void setData(const atUint8* data, atUint64 length, bool takeOwnership = false); void setData(const uint8_t* data, uint64_t length, bool takeOwnership = false);
/*! \brief Returns a copy of the current buffer.<br /> /*! \brief Returns a copy of the current buffer.<br />
* Changes to the copy do not affect the buffer so it's perfectly safe to * Changes to the copy do not affect the buffer so it's perfectly safe to
@ -68,19 +68,19 @@ public:
* as Stream now owns the address, this is done to keep memory usage down. * as Stream now owns the address, this is done to keep memory usage down.
* \return Uint8* The copy of the buffer. * \return Uint8* The copy of the buffer.
*/ */
atUint8* data() const; uint8_t* data() const;
/*! \brief Reads a specified number of bytes to user-allocated buffer /*! \brief Reads a specified number of bytes to user-allocated buffer
* \param buf User-allocated buffer pointer * \param buf User-allocated buffer pointer
* \param len Length to read * \param len Length to read
* \return Number of bytes read * \return Number of bytes read
*/ */
atUint64 readUBytesToBuf(void* buf, atUint64 len) override; uint64_t readUBytesToBuf(void* buf, uint64_t len) override;
protected: protected:
const void* m_data = nullptr; const void* m_data = nullptr;
atUint64 m_length = 0; uint64_t m_length = 0;
atUint64 m_position = 0; uint64_t m_position = 0;
bool m_owns = false; bool m_owns = false;
bool m_globalErr = true; bool m_globalErr = true;
}; };
@ -92,7 +92,7 @@ public:
* \param data The existing buffer * \param data The existing buffer
* \param length The length of the existing buffer * \param length The length of the existing buffer
*/ */
explicit MemoryCopyReader(const void* data, atUint64 length); explicit MemoryCopyReader(const void* data, uint64_t length);
/*! \brief This constructor creates an instance from a file on disk. /*! \brief This constructor creates an instance from a file on disk.
* *
@ -100,11 +100,11 @@ public:
*/ */
explicit MemoryCopyReader(const std::string& filename) : m_filepath(filename) { loadData(); } explicit MemoryCopyReader(const std::string& filename) : m_filepath(filename) { loadData(); }
void setData(const atUint8* data, atUint64 length); void setData(const uint8_t* data, uint64_t length);
protected: protected:
void loadData(); void loadData();
std::unique_ptr<atUint8[]> m_dataCopy; std::unique_ptr<uint8_t[]> m_dataCopy;
std::string m_filepath; //!< Path to the target file std::string m_filepath; //!< Path to the target file
}; };

32
include/athena/MemoryWriter.hpp
View File

@ -26,26 +26,26 @@ public:
* @param takeOwnership Whether or not this writer takes ownership of the supplied data buffer. * @param takeOwnership Whether or not this writer takes ownership of the supplied data buffer.
* If true, the buffer will be deleted by this when the destructor executes. * If true, the buffer will be deleted by this when the destructor executes.
*/ */
explicit MemoryWriter(atUint8* data, atUint64 length, bool takeOwnership = false); explicit MemoryWriter(uint8_t* data, uint64_t length, bool takeOwnership = false);
/*! @brief Sets the buffers position relative to the specified position.<br /> /*! @brief Sets the buffers position relative to the specified position.<br />
* It seeks relative to the current position by default. * It seeks relative to the current position by default.
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek @sa SeekOrigin * @param origin The Origin to seek @sa SeekOrigin
*/ */
void seek(atInt64 position, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t position, SeekOrigin origin = SeekOrigin::Current) override;
/*! @brief Returns the current position in the stream. /*! @brief Returns the current position in the stream.
* *
* @return Int64 The current position in the stream. * @return Int64 The current position in the stream.
*/ */
atUint64 position() const override { return m_position; } uint64_t position() const override { return m_position; }
/*! @brief Returns the length of the stream. /*! @brief Returns the length of the stream.
* *
* @return Int64 The length of the stream. * @return Int64 The length of the stream.
*/ */
atUint64 length() const override { return m_length; } uint64_t length() const override { return m_length; }
bool isOpen() const { return true; } bool isOpen() const { return true; }
@ -54,14 +54,14 @@ public:
* @param length The length of the new buffer. * @param length The length of the new buffer.
* @param takeOwnership Whether the Stream now owns the buffer. * @param takeOwnership Whether the Stream now owns the buffer.
*/ */
void setData(atUint8* data, atUint64 length, bool takeOwnership = false); void setData(uint8_t* data, uint64_t length, bool takeOwnership = false);
/*! @brief Returns a copy of the current buffer.<br /> /*! @brief Returns a copy of the current buffer.<br />
* Changes to the copy do not affect the buffer so it's perfectly safe to * Changes to the copy do not affect the buffer so it's perfectly safe to
* directly edit the buffer and use setData to set the new information.<br /> * directly edit the buffer and use setData to set the new information.<br />
* @return Uint8* The copy of the buffer. * @return Uint8* The copy of the buffer.
*/ */
atUint8* data() const; uint8_t* data() const;
/*! @brief Sets the target file /*! @brief Sets the target file
* *
@ -87,13 +87,13 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeUBytes(const atUint8* data, atUint64 length) override; void writeUBytes(const uint8_t* data, uint64_t length) override;
protected: protected:
MemoryWriter() = default; MemoryWriter() = default;
atUint8* m_data = nullptr; uint8_t* m_data = nullptr;
atUint64 m_length = 0; uint64_t m_length = 0;
atUint64 m_position = 0; uint64_t m_position = 0;
bool m_bufferOwned = false; bool m_bufferOwned = false;
std::string m_filepath; //!< Path to the target file std::string m_filepath; //!< Path to the target file
}; };
@ -105,7 +105,7 @@ public:
* @param data The existing buffer * @param data The existing buffer
* @param length The length of the existing buffer * @param length The length of the existing buffer
*/ */
explicit MemoryCopyWriter(atUint8* data = nullptr, atUint64 length = 0x10); explicit MemoryCopyWriter(uint8_t* data = nullptr, uint64_t length = 0x10);
/*! @brief This constructor creates an instance from a file on disk. /*! @brief This constructor creates an instance from a file on disk.
* *
@ -118,7 +118,7 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek @sa SeekOrigin * @param origin The Origin to seek @sa SeekOrigin
*/ */
void seek(atInt64 position, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t position, SeekOrigin origin = SeekOrigin::Current) override;
/*! @brief Sets the buffer to the given one, deleting the current one.<br /> /*! @brief Sets the buffer to the given one, deleting the current one.<br />
* <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data * <b>BEWARE:</b> As this deletes the current buffer it WILL cause a loss of data
@ -129,7 +129,7 @@ public:
* @param length The length of the new buffer. * @param length The length of the new buffer.
* @throw IOException * @throw IOException
*/ */
void setData(const atUint8* data, atUint64 length); void setData(const uint8_t* data, uint64_t length);
/*! @brief Writes the given buffer with the specified length, buffers can be bigger than the length /*! @brief Writes the given buffer with the specified length, buffers can be bigger than the length
* however it's undefined behavior to try and write a buffer which is smaller than the given length. * however it's undefined behavior to try and write a buffer which is smaller than the given length.
@ -137,13 +137,13 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeUBytes(const atUint8* data, atUint64 length) override; void writeUBytes(const uint8_t* data, uint64_t length) override;
protected: protected:
std::unique_ptr<atUint8[]> m_dataCopy; std::unique_ptr<uint8_t[]> m_dataCopy;
private: private:
void resize(atUint64 newSize); void resize(uint64_t newSize);
}; };
} // namespace athena::io } // namespace athena::io

4
include/athena/SkywardSwordFile.hpp
View File

@ -19,7 +19,7 @@ public:
~SkywardSwordFile(); ~SkywardSwordFile();
void addQuest(SkywardSwordQuest* q); void addQuest(SkywardSwordQuest* q);
SkywardSwordQuest* quest(atUint32 id); SkywardSwordQuest* quest(uint32_t id);
std::vector<SkywardSwordQuest*> questList() const; std::vector<SkywardSwordQuest*> questList() const;
void setRegion(Region region); void setRegion(Region region);
@ -29,7 +29,7 @@ private:
Region m_region; Region m_region;
// A vector is a bit overkill // A vector is a bit overkill
std::vector<SkywardSwordQuest*> m_quests; std::vector<SkywardSwordQuest*> m_quests;
atUint32 m_numQuests; uint32_t m_numQuests;
}; };
} // namespace athena } // namespace athena

2
include/athena/SkywardSwordFileReader.hpp
View File

@ -7,7 +7,7 @@ class SkywardSwordFile;
namespace io { namespace io {
class SkywardSwordFileReader : public MemoryCopyReader { class SkywardSwordFileReader : public MemoryCopyReader {
public: public:
SkywardSwordFileReader(atUint8* data, atUint64 length); SkywardSwordFileReader(uint8_t* data, uint64_t length);
SkywardSwordFileReader(const std::string& filename); SkywardSwordFileReader(const std::string& filename);
SkywardSwordFile* read(); SkywardSwordFile* read();

2
include/athena/SkywardSwordFileWriter.hpp
View File

@ -9,7 +9,7 @@ namespace io {
class SkywardSwordFileWriter : public MemoryCopyWriter { class SkywardSwordFileWriter : public MemoryCopyWriter {
public: public:
SkywardSwordFileWriter(atUint8* data, atUint64 len); SkywardSwordFileWriter(uint8_t* data, uint64_t len);
SkywardSwordFileWriter(const std::string& filename); SkywardSwordFileWriter(const std::string& filename);
void write(SkywardSwordFile* file); void write(SkywardSwordFile* file);

32
include/athena/SkywardSwordQuest.hpp
View File

@ -11,40 +11,40 @@ class SkywardSwordQuest : public ZQuestFile {
public: public:
enum AmmoType { Arrows, Bombs, Seeds }; enum AmmoType { Arrows, Bombs, Seeds };
SkywardSwordQuest(std::unique_ptr<atUint8[]>&& data, atUint32 len); SkywardSwordQuest(std::unique_ptr<uint8_t[]>&& data, uint32_t len);
void setPlayerName(const std::string& name); void setPlayerName(const std::string& name);
std::string playerName() const; std::string playerName() const;
void setRupeeCount(atUint16 value); void setRupeeCount(uint16_t value);
atUint16 rupeeCount(); uint16_t rupeeCount();
void setAmmoCount(AmmoType type, atUint32 count); void setAmmoCount(AmmoType type, uint32_t count);
atUint32 ammoCount(AmmoType type); uint32_t ammoCount(AmmoType type);
void setMaxHP(atUint16 val); void setMaxHP(uint16_t val);
atUint16 maxHP(); uint16_t maxHP();
float maxHearts(); float maxHearts();
void setSpawnHP(atUint16 val); void setSpawnHP(uint16_t val);
atUint16 spawnHP(); uint16_t spawnHP();
float spawnHearts(); float spawnHearts();
void setCurrentHP(atUint16 val); void setCurrentHP(uint16_t val);
atUint16 currentHP(); uint16_t currentHP();
float currentHearts(); float currentHearts();
std::string currentLocation(); std::string currentLocation();
std::string currentArea(); std::string currentArea();
std::string currentLocationCopy(); std::string currentLocationCopy();
void setSkipData(std::unique_ptr<atUint8[]>&& data); void setSkipData(std::unique_ptr<uint8_t[]>&& data);
atUint8* skipData() const; uint8_t* skipData() const;
atUint32 slotChecksum(); uint32_t slotChecksum();
atUint32 skipChecksum(); uint32_t skipChecksum();
void fixChecksums(); void fixChecksums();
void setNew(bool isNew); void setNew(bool isNew);
bool isNew() const; bool isNew() const;
private: private:
std::unique_ptr<atUint8[]> m_skipData; std::unique_ptr<uint8_t[]> m_skipData;
}; };
} // namespace athena } // namespace athena

18
include/athena/Sprite.hpp
View File

@ -30,23 +30,23 @@ public:
int stateId(int index) const; int stateId(int index) const;
void setStateIds(std::vector<int> ids); void setStateIds(std::vector<int> ids);
std::vector<int> stateIds() const; std::vector<int> stateIds() const;
atUint32 stateCount() const; uint32_t stateCount() const;
void setCurrentState(atUint32 id); void setCurrentState(uint32_t id);
atUint32 currentState() const; uint32_t currentState() const;
bool addFrame(SpriteFrame* Frame); bool addFrame(SpriteFrame* Frame);
bool removeFrame(SpriteFrame* Frame); bool removeFrame(SpriteFrame* Frame);
SpriteFrame* Frame(atUint32 id); SpriteFrame* Frame(uint32_t id);
void setFrame(atUint32 id); void setFrame(uint32_t id);
void setFrames(std::vector<SpriteFrame*> frames); void setFrames(std::vector<SpriteFrame*> frames);
atUint32 frameCount() const; uint32_t frameCount() const;
std::vector<SpriteFrame*> frames() const; std::vector<SpriteFrame*> frames() const;
SpriteFile* container() const; SpriteFile* container() const;
void setCurrentFrame(SpriteFrame* frame); void setCurrentFrame(SpriteFrame* frame);
void setCurrentFrame(atUint32 id); void setCurrentFrame(uint32_t id);
SpriteFrame* currentFrame() const; SpriteFrame* currentFrame() const;
void advanceFrame(); void advanceFrame();
@ -61,8 +61,8 @@ private:
Vector2Df m_position; Vector2Df m_position;
std::vector<int> m_stateIds; //!< Stores the texture id's for each state. std::vector<int> m_stateIds; //!< Stores the texture id's for each state.
std::vector<SpriteFrame*> m_frames; std::vector<SpriteFrame*> m_frames;
atUint32 m_currentState; uint32_t m_currentState;
atUint32 m_currentFrame; uint32_t m_currentFrame;
}; };
} // namespace athena::Sakura } // namespace athena::Sakura

26
include/athena/SpriteFile.hpp
View File

@ -19,32 +19,32 @@ public:
/*! /*!
* \brief Major * \brief Major
*/ */
static const atUint32 Major; static const uint32_t Major;
/*! /*!
* \brief Minor * \brief Minor
*/ */
static const atUint32 Minor; static const uint32_t Minor;
/*! /*!
* \brief Revision * \brief Revision
*/ */
static const atUint32 Revision; static const uint32_t Revision;
/*! /*!
* \brief Patch * \brief Patch
*/ */
static const atUint32 Build; static const uint32_t Build;
/*! /*!
* \brief Version * \brief Version
*/ */
static const atUint32 Version; static const uint32_t Version;
/*! /*!
* \brief Magic * \brief Magic
*/ */
static const atUint32 Magic; static const uint32_t Magic;
/*! /*!
* \brief SSprite * \brief SSprite
@ -58,7 +58,7 @@ public:
* \param originX * \param originX
* \param originY * \param originY
*/ */
SpriteFile(atUint32 width, atUint32 height, float originX, float originY); SpriteFile(uint32_t width, uint32_t height, float originX, float originY);
/*! /*!
* \brief SSpriteFile * \brief SSpriteFile
@ -84,7 +84,7 @@ public slots:
* \param width * \param width
* \param height * \param height
*/ */
void setSize(atUint32 width, atUint32 height); void setSize(uint32_t width, uint32_t height);
/*! /*!
* \brief setSize * \brief setSize
@ -102,13 +102,13 @@ public slots:
* \brief width * \brief width
* \return * \return
*/ */
atUint32 width() const; uint32_t width() const;
/*! /*!
* \brief height * \brief height
* \return * \return
*/ */
atUint32 height() const; uint32_t height() const;
/*! /*!
* \brief setOrigin * \brief setOrigin
@ -158,10 +158,10 @@ public slots:
* \param id * \param id
* \return * \return
*/ */
STexture* texture(atUint32 id); STexture* texture(uint32_t id);
std::vector<STexture*> textures() const; std::vector<STexture*> textures() const;
atUint32 textureCount() const; uint32_t textureCount() const;
/*! /*!
* \brief setTextures * \brief setTextures
* \param textures * \param textures
@ -177,7 +177,7 @@ public slots:
Sprite* sprite(const std::string& name); Sprite* sprite(const std::string& name);
std::unordered_map<std::string, Sprite*> sprites() const; std::unordered_map<std::string, Sprite*> sprites() const;
atUint32 spriteCount() const; uint32_t spriteCount() const;
private: private:
std::vector<STexture*> m_textures; std::vector<STexture*> m_textures;

2
include/athena/SpriteFileReader.hpp
View File

@ -11,7 +11,7 @@ namespace io {
class SpriteFileReader : public MemoryCopyReader { class SpriteFileReader : public MemoryCopyReader {
public: public:
SpriteFileReader(atUint8* data, atUint64 length); SpriteFileReader(uint8_t* data, uint64_t length);
SpriteFileReader(const std::string& filepath); SpriteFileReader(const std::string& filepath);
Sakura::SpriteFile* readFile(); Sakura::SpriteFile* readFile();

2
include/athena/SpriteFileWriter.hpp
View File

@ -11,7 +11,7 @@ namespace io {
class SpriteFileWriter : public MemoryCopyWriter { class SpriteFileWriter : public MemoryCopyWriter {
public: public:
SpriteFileWriter(atUint8* data, atUint64 length); SpriteFileWriter(uint8_t* data, uint64_t length);
SpriteFileWriter(std::string_view filepath); SpriteFileWriter(std::string_view filepath);

2
include/athena/SpriteFrame.hpp
View File

@ -31,7 +31,7 @@ public:
void setParts(std::vector<SpritePart*> parts); void setParts(std::vector<SpritePart*> parts);
std::vector<SpritePart*> parts() const; std::vector<SpritePart*> parts() const;
atUint32 partCount() const; uint32_t partCount() const;
void setRoot(Sprite* root); void setRoot(Sprite* root);
Sprite* root() const; Sprite* root() const;

4
include/athena/SpritePart.hpp
View File

@ -56,7 +56,7 @@ public:
* \param width * \param width
* \param height * \param height
*/ */
void setSize(atUint32 width, atUint32 height); void setSize(uint32_t width, uint32_t height);
/*! /*!
* \brief setSize * \brief setSize
@ -105,6 +105,6 @@ private:
Vector2Di m_size; Vector2Di m_size;
bool m_flippedH; bool m_flippedH;
bool m_flippedV; bool m_flippedV;
atUint32 m_frameIndex; uint32_t m_frameIndex;
}; };
} // namespace athena::Sakura } // namespace athena::Sakura

9
include/athena/Types.hpp
View File

@ -3,15 +3,6 @@
#include <cinttypes> #include <cinttypes>
#include <cstdint> #include <cstdint>
using atInt8 = std::int8_t;
using atUint8 = std::uint8_t;
using atInt16 = std::int16_t;
using atUint16 = std::uint16_t;
using atInt32 = std::int32_t;
using atUint32 = std::uint32_t;
using atInt64 = std::int64_t;
using atUint64 = std::uint64_t;
// Vector types // Vector types
#include "simd/simd.hpp" #include "simd/simd.hpp"
struct atVec2f { struct atVec2f {

66
include/athena/Utility.hpp
View File

@ -10,7 +10,7 @@
#include "athena/Types.hpp" #include "athena/Types.hpp"
namespace athena::utility { namespace athena::utility {
inline bool isEmpty(atInt8* buf, atUint32 size) { return !std::memcmp(buf, buf + 1, size - 1); } inline bool isEmpty(int8_t* buf, uint32_t size) { return !std::memcmp(buf, buf + 1, size - 1); }
#if _WIN32 #if _WIN32
constexpr bool isSystemBigEndian() { return false; } constexpr bool isSystemBigEndian() { return false; }
#else #else
@ -25,7 +25,7 @@ constexpr ::athena::Endian NotSystemEndian = isSystemBigEndian() ? ::athena::End
#define BSWAP_CONSTEXPR constexpr #define BSWAP_CONSTEXPR constexpr
#endif #endif
BSWAP_CONSTEXPR atInt16 swap16(atInt16 val) { BSWAP_CONSTEXPR int16_t swap16(int16_t val) {
#if __GNUC__ #if __GNUC__
return __builtin_bswap16(val); return __builtin_bswap16(val);
#elif _MSC_VER #elif _MSC_VER
@ -34,8 +34,8 @@ BSWAP_CONSTEXPR atInt16 swap16(atInt16 val) {
return (val = (val << 8) | ((val >> 8) & 0xFF)); return (val = (val << 8) | ((val >> 8) & 0xFF));
#endif #endif
} }
BSWAP_CONSTEXPR atUint16 swapU16(atUint16 val) { return (atUint16)swap16(val); } BSWAP_CONSTEXPR uint16_t swapU16(uint16_t val) { return (uint16_t)swap16(val); }
BSWAP_CONSTEXPR atInt32 swap32(atInt32 val) { BSWAP_CONSTEXPR int32_t swap32(int32_t val) {
#if __GNUC__ #if __GNUC__
return __builtin_bswap32(val); return __builtin_bswap32(val);
#elif _MSC_VER #elif _MSC_VER
@ -46,8 +46,8 @@ BSWAP_CONSTEXPR atInt32 swap32(atInt32 val) {
return val; return val;
#endif #endif
} }
BSWAP_CONSTEXPR atUint32 swapU32(atUint32 val) { return (atUint32)swap32(val); } BSWAP_CONSTEXPR uint32_t swapU32(uint32_t val) { return (uint32_t)swap32(val); }
BSWAP_CONSTEXPR atInt64 swap64(atInt64 val) { BSWAP_CONSTEXPR int64_t swap64(int64_t val) {
#if __GNUC__ #if __GNUC__
return __builtin_bswap64(val); return __builtin_bswap64(val);
#elif _MSC_VER #elif _MSC_VER
@ -60,90 +60,90 @@ BSWAP_CONSTEXPR atInt64 swap64(atInt64 val) {
(((atInt64)(val)&0x000000000000FF00ULL) << 40) | (((atInt64)(val)&0x00000000000000FFULL) << 56)))); (((atInt64)(val)&0x000000000000FF00ULL) << 40) | (((atInt64)(val)&0x00000000000000FFULL) << 56))));
#endif #endif
} }
BSWAP_CONSTEXPR atUint64 swapU64(atUint64 val) { return (atUint64)swap64(val); } BSWAP_CONSTEXPR uint64_t swapU64(uint64_t val) { return (uint64_t)swap64(val); }
BSWAP_CONSTEXPR float swapFloat(float val) { BSWAP_CONSTEXPR float swapFloat(float val) {
union { float f; atInt32 i; } uval1 = {val}; union { float f; int32_t i; } uval1 = {val};
union { atInt32 i; float f; } uval2 = {swap32(uval1.i)}; union { int32_t i; float f; } uval2 = {swap32(uval1.i)};
return uval2.f; return uval2.f;
} }
BSWAP_CONSTEXPR double swapDouble(double val) { BSWAP_CONSTEXPR double swapDouble(double val) {
union { double f; atInt64 i; } uval1 = {val}; union { double f; int64_t i; } uval1 = {val};
union { atInt64 i; double f; } uval2 = {swap64(uval1.i)}; union { int64_t i; double f; } uval2 = {swap64(uval1.i)};
return uval2.f; return uval2.f;
} }
BSWAP_CONSTEXPR atInt16 LittleInt16(atInt16& val) { BSWAP_CONSTEXPR int16_t LittleInt16(int16_t& val) {
if constexpr (athena::utility::isSystemBigEndian()) if constexpr (athena::utility::isSystemBigEndian())
val = athena::utility::swap16(val); val = athena::utility::swap16(val);
return val; return val;
} }
BSWAP_CONSTEXPR atUint16 LittleUint16(atUint16& val) { BSWAP_CONSTEXPR uint16_t LittleUint16(uint16_t& val) {
atInt16 ret = val; int16_t ret = val;
LittleInt16(ret); LittleInt16(ret);
val = ret; val = ret;
return val; return val;
} }
BSWAP_CONSTEXPR atInt16 BigInt16(atInt16& val) { BSWAP_CONSTEXPR int16_t BigInt16(int16_t& val) {
if constexpr (!athena::utility::isSystemBigEndian()) if constexpr (!athena::utility::isSystemBigEndian())
val = athena::utility::swap16(val); val = athena::utility::swap16(val);
return val; return val;
} }
BSWAP_CONSTEXPR atUint16 BigUint16(atUint16& val) { BSWAP_CONSTEXPR uint16_t BigUint16(uint16_t& val) {
atInt16 ret = val; int16_t ret = val;
BigInt16(ret); BigInt16(ret);
val = ret; val = ret;
return val; return val;
} }
BSWAP_CONSTEXPR atInt32 LittleInt32(atInt32& val) { BSWAP_CONSTEXPR int32_t LittleInt32(int32_t& val) {
if constexpr (athena::utility::isSystemBigEndian()) if constexpr (athena::utility::isSystemBigEndian())
val = athena::utility::swap32(val); val = athena::utility::swap32(val);
return val; return val;
} }
BSWAP_CONSTEXPR atUint32 LittleUint32(atUint32& val) { BSWAP_CONSTEXPR uint32_t LittleUint32(uint32_t& val) {
atInt32 ret = val; int32_t ret = val;
LittleInt32(ret); LittleInt32(ret);
val = ret; val = ret;
return val; return val;
} }
BSWAP_CONSTEXPR atInt32 BigInt32(atInt32& val) { BSWAP_CONSTEXPR int32_t BigInt32(int32_t& val) {
if constexpr (!athena::utility::isSystemBigEndian()) if constexpr (!athena::utility::isSystemBigEndian())
val = athena::utility::swap32(val); val = athena::utility::swap32(val);
return val; return val;
} }
BSWAP_CONSTEXPR atUint32 BigUint32(atUint32& val) { BSWAP_CONSTEXPR uint32_t BigUint32(uint32_t& val) {
atInt32 ret = val; int32_t ret = val;
BigInt32(ret); BigInt32(ret);
val = ret; val = ret;
return val; return val;
} }
BSWAP_CONSTEXPR atInt64 LittleInt64(atInt64& val) { BSWAP_CONSTEXPR int64_t LittleInt64(int64_t& val) {
if constexpr (athena::utility::isSystemBigEndian()) if constexpr (athena::utility::isSystemBigEndian())
val = athena::utility::swap64(val); val = athena::utility::swap64(val);
return val; return val;
} }
BSWAP_CONSTEXPR atUint64 LittleUint64(atUint64& val) { BSWAP_CONSTEXPR uint64_t LittleUint64(uint64_t& val) {
atInt64 ret = val; int64_t ret = val;
LittleInt64(ret); LittleInt64(ret);
val = ret; val = ret;
return val; return val;
} }
BSWAP_CONSTEXPR atInt64 BigInt64(atInt64& val) { BSWAP_CONSTEXPR int64_t BigInt64(int64_t& val) {
if constexpr (!athena::utility::isSystemBigEndian()) if constexpr (!athena::utility::isSystemBigEndian())
val = athena::utility::swap64(val); val = athena::utility::swap64(val);
return val; return val;
} }
BSWAP_CONSTEXPR atUint64 BigUint64(atUint64& val) { BSWAP_CONSTEXPR uint64_t BigUint64(uint64_t& val) {
atInt64 ret = val; int64_t ret = val;
BigInt64(ret); BigInt64(ret);
val = ret; val = ret;
@ -175,9 +175,9 @@ BSWAP_CONSTEXPR double BigDouble(double val) {
return val; return val;
} }
void fillRandom(atUint8* rndArea, atUint64 count); void fillRandom(uint8_t* rndArea, uint64_t count);
std::vector<std::string> split(std::string_view s, char delim); std::vector<std::string> split(std::string_view s, char delim);
atUint64 rand64(); uint64_t rand64();
std::string join(const std::vector<std::string>& elems, std::string_view delims); std::string join(const std::vector<std::string>& elems, std::string_view delims);
void tolower(std::string& str); void tolower(std::string& str);
void toupper(std::string& str); void toupper(std::string& str);
@ -193,9 +193,9 @@ std::string& rtrim(std::string& s);
// trim from both ends // trim from both ends
std::string& trim(std::string& s); std::string& trim(std::string& s);
atUint64 fileSize(std::string_view filename); uint64_t fileSize(std::string_view filename);
#ifdef _WIN32 #ifdef _WIN32
atUint64 fileSize(std::wstring_view filename); uint64_t fileSize(std::wstring_view filename);
#endif #endif
std::string wideToUtf8(std::wstring_view src); std::string wideToUtf8(std::wstring_view src);

10
include/athena/VectorWriter.hpp
View File

@ -22,19 +22,19 @@ public:
* @param position where in the buffer to seek * @param position where in the buffer to seek
* @param origin The Origin to seek @sa SeekOrigin * @param origin The Origin to seek @sa SeekOrigin
*/ */
void seek(atInt64 position, SeekOrigin origin = SeekOrigin::Current) override; void seek(int64_t position, SeekOrigin origin = SeekOrigin::Current) override;
/*! @brief Returns the current position in the stream. /*! @brief Returns the current position in the stream.
* *
* @return Int64 The current position in the stream. * @return Int64 The current position in the stream.
*/ */
atUint64 position() const override { return m_position; } uint64_t position() const override { return m_position; }
/*! @brief Returns the length of the stream. /*! @brief Returns the length of the stream.
* *
* @return Int64 The length of the stream. * @return Int64 The length of the stream.
*/ */
atUint64 length() const override { return m_data.size(); } uint64_t length() const override { return m_data.size(); }
bool isOpen() const { return true; } bool isOpen() const { return true; }
@ -48,11 +48,11 @@ public:
* @param data The buffer to write * @param data The buffer to write
* @param length The amount to write * @param length The amount to write
*/ */
void writeUBytes(const atUint8* data, atUint64 length) override; void writeUBytes(const uint8_t* data, uint64_t length) override;
protected: protected:
std::vector<uint8_t> m_data; std::vector<uint8_t> m_data;
atUint64 m_position = 0; uint64_t m_position = 0;
}; };
} // namespace athena::io } // namespace athena::io

36
include/athena/WiiBanner.hpp
View File

@ -27,7 +27,7 @@ public:
* \param m_banner * \param m_banner
* \param icons * \param icons
*/ */
WiiBanner(atUint32 gameId, const std::u16string& title, const std::u16string& subtitle, WiiImage* m_banner, WiiBanner(uint32_t gameId, const std::u16string& title, const std::u16string& subtitle, WiiImage* m_banner,
std::vector<WiiImage*> icons); std::vector<WiiImage*> icons);
virtual ~WiiBanner(); virtual ~WiiBanner();
@ -35,13 +35,13 @@ public:
* \brief setGameID * \brief setGameID
* \param id * \param id
*/ */
void setGameID(atUint64 id); void setGameID(uint64_t id);
/*! /*!
* \brief gameID * \brief gameID
* \return * \return
*/ */
atUint64 gameID() const; uint64_t gameID() const;
/*! /*!
* \brief setBannerImage * \brief setBannerImage
@ -59,13 +59,13 @@ public:
* \brief setBannerSize * \brief setBannerSize
* \param size * \param size
*/ */
void setBannerSize(atUint32 size); void setBannerSize(uint32_t size);
/*! /*!
* \brief bannerSize * \brief bannerSize
* \return * \return
*/ */
atUint32 bannerSize() const; uint32_t bannerSize() const;
/*! /*!
* \brief setTitle * \brief setTitle
@ -102,14 +102,14 @@ public:
* \param id * \param id
* \param icon * \param icon
*/ */
void setIcon(atUint32 id, WiiImage* icon); void setIcon(uint32_t id, WiiImage* icon);
/*! /*!
* \brief getIcon * \brief getIcon
* \param id * \param id
* \return * \return
*/ */
WiiImage* getIcon(atUint32 id) const; WiiImage* getIcon(uint32_t id) const;
/*! /*!
* \brief icons * \brief icons
@ -121,46 +121,46 @@ public:
* \brief setAnimationSpeed * \brief setAnimationSpeed
* \param animSpeed * \param animSpeed
*/ */
void setAnimationSpeed(atUint16 animSpeed); void setAnimationSpeed(uint16_t animSpeed);
/*! /*!
* \brief animationSpeed * \brief animationSpeed
* \return * \return
*/ */
atUint16 animationSpeed() const; uint16_t animationSpeed() const;
/*! /*!
* \brief setPermissions * \brief setPermissions
* \param permissions * \param permissions
*/ */
void setPermissions(atUint8 permissions); void setPermissions(uint8_t permissions);
/*! /*!
* \brief permissions * \brief permissions
* \return * \return
*/ */
atUint8 permissions() const; uint8_t permissions() const;
/*! /*!
* \brief setFlags * \brief setFlags
* \param flags * \param flags
*/ */
void setFlags(atUint32 flags); void setFlags(uint32_t flags);
/*! /*!
* \brief flags * \brief flags
* \return * \return
*/ */
atUint32 flags() const; uint32_t flags() const;
protected: protected:
private: private:
atUint64 m_gameId; uint64_t m_gameId;
WiiImage* m_banner; WiiImage* m_banner;
atUint32 m_animSpeed; uint32_t m_animSpeed;
atUint8 m_permissions; uint8_t m_permissions;
atUint32 m_flags; uint32_t m_flags;
atUint32 m_bannerSize; uint32_t m_bannerSize;
std::vector<WiiImage*> m_icons; std::vector<WiiImage*> m_icons;
std::u16string m_title; std::u16string m_title;
std::u16string m_subtitle; std::u16string m_subtitle;

28
include/athena/WiiFile.hpp
View File

@ -7,11 +7,11 @@
namespace athena { namespace athena {
const atUint8 SD_KEY[16] = {0xab, 0x01, 0xb9, 0xd8, 0xe1, 0x62, 0x2b, 0x08, const uint8_t SD_KEY[16] = {0xab, 0x01, 0xb9, 0xd8, 0xe1, 0x62, 0x2b, 0x08,
0xaf, 0xba, 0xd8, 0x4d, 0xbf, 0xc2, 0xa5, 0x5d}; 0xaf, 0xba, 0xd8, 0x4d, 0xbf, 0xc2, 0xa5, 0x5d};
const atUint8 SD_IV[16] = {0x21, 0x67, 0x12, 0xe6, 0xaa, 0x1f, 0x68, 0x9f, const uint8_t SD_IV[16] = {0x21, 0x67, 0x12, 0xe6, 0xaa, 0x1f, 0x68, 0x9f,
0x95, 0xc5, 0xa2, 0x23, 0x24, 0xdc, 0x6a, 0x98}; 0x95, 0xc5, 0xa2, 0x23, 0x24, 0xdc, 0x6a, 0x98};
const atUint8 MD5_BLANKER[16] = {0x0e, 0x65, 0x37, 0x81, 0x99, 0xbe, 0x45, 0x17, const uint8_t MD5_BLANKER[16] = {0x0e, 0x65, 0x37, 0x81, 0x99, 0xbe, 0x45, 0x17,
0xab, 0x06, 0xec, 0x22, 0x45, 0x1a, 0x57, 0x93}; 0xab, 0x06, 0xec, 0x22, 0x45, 0x1a, 0x57, 0x93};
/*! \class WiiFile /*! \class WiiFile
@ -59,7 +59,7 @@ public:
* \param data * \param data
* \param length * \param length
*/ */
WiiFile(const std::string& filename, atUint8 permissions, const atUint8* data, atUint32 length); WiiFile(const std::string& filename, uint8_t permissions, const uint8_t* data, uint32_t length);
virtual ~WiiFile(); virtual ~WiiFile();
/*! /*!
@ -78,12 +78,12 @@ public:
* \brief setData * \brief setData
* \param data * \param data
*/ */
void setData(const atUint8* data); void setData(const uint8_t* data);
/*! /*!
* \brief data * \brief data
* \return * \return
*/ */
atUint8* data() const; uint8_t* data() const;
/*! /*!
* \brief setLength * \brief setLength
@ -101,25 +101,25 @@ public:
* \brief setPermissions * \brief setPermissions
* \param permissions * \param permissions
*/ */
void setPermissions(const atUint8 permissions); void setPermissions(const uint8_t permissions);
/*! /*!
* \brief permissions * \brief permissions
* \return * \return
*/ */
atUint8 permissions() const; uint8_t permissions() const;
/*! /*!
* \brief setAttributes * \brief setAttributes
* \param attr * \param attr
*/ */
void setAttributes(const atUint8 attr); void setAttributes(const uint8_t attr);
/*! /*!
* \brief attributes * \brief attributes
* \return * \return
*/ */
atUint8 attributes() const; uint8_t attributes() const;
/*! /*!
* \brief setType * \brief setType
@ -188,7 +188,7 @@ public:
* \brief fileCount * \brief fileCount
* \return * \return
*/ */
atUint32 fileCount(); uint32_t fileCount();
/*! /*!
* \brief allChildren * \brief allChildren
@ -204,12 +204,12 @@ public:
protected: protected:
private: private:
atUint8 m_permissions; uint8_t m_permissions;
atUint8 m_attributes; uint8_t m_attributes;
Type m_type; Type m_type;
std::string m_filename; std::string m_filename;
int m_fileLen; int m_fileLen;
atUint8* m_fileData; uint8_t* m_fileData;
WiiFile* m_parent; WiiFile* m_parent;
std::vector<WiiFile*> m_children; std::vector<WiiFile*> m_children;
}; };

22
include/athena/WiiImage.hpp
View File

@ -20,54 +20,54 @@ public:
* \param height * \param height
* \param data * \param data
*/ */
WiiImage(atUint32 width, atUint32 height, std::unique_ptr<atUint8[]>&& data); WiiImage(uint32_t width, uint32_t height, std::unique_ptr<uint8_t[]>&& data);
/*! /*!
* \brief setWidth * \brief setWidth
* \param width * \param width
*/ */
void setWidth(const atUint32 width); void setWidth(const uint32_t width);
/*! /*!
* \brief width * \brief width
* \return * \return
*/ */
atUint32 width() const; uint32_t width() const;
/*! /*!
* \brief setHeight * \brief setHeight
* \param height * \param height
*/ */
void setHeight(const atUint32 height); void setHeight(const uint32_t height);
/*! /*!
* \brief height * \brief height
* \return * \return
*/ */
atUint32 height() const; uint32_t height() const;
/*! /*!
* \brief setData * \brief setData
* \param data * \param data
*/ */
void setData(const atUint8* data); void setData(const uint8_t* data);
/*! /*!
* \brief data * \brief data
* \return * \return
*/ */
atUint8* data(); uint8_t* data();
/*! /*!
* \brief toRGBA * \brief toRGBA
* \return * \return
*/ */
atUint8* toRGBA(); uint8_t* toRGBA();
private: private:
atUint32 m_width; uint32_t m_width;
atUint32 m_height; uint32_t m_height;
std::unique_ptr<atUint8[]> m_data; std::unique_ptr<uint8_t[]> m_data;
}; };
} // namespace athena } // namespace athena

2
include/athena/WiiSave.hpp
View File

@ -48,7 +48,7 @@ public:
*/ */
WiiFile* file(const std::string& filename); WiiFile* file(const std::string& filename);
atUint32 fileCount() const; uint32_t fileCount() const;
/*! /*!
* \brief fileList * \brief fileList
* \return * \return

6
include/athena/WiiSaveReader.hpp
View File

@ -25,7 +25,7 @@ public:
* \param data The existing buffer * \param data The existing buffer
* \param length The length of the existing buffer * \param length The length of the existing buffer
*/ */
WiiSaveReader(const atUint8*, atUint64); WiiSaveReader(const uint8_t*, uint64_t);
/*! \brief This constructor creates an instance from a file on disk. /*! \brief This constructor creates an instance from a file on disk.
* *
@ -42,8 +42,8 @@ public:
private: private:
WiiBanner* readBanner(); WiiBanner* readBanner();
WiiFile* readFile(); WiiFile* readFile();
WiiImage* readImage(atUint32 width, atUint32 height); WiiImage* readImage(uint32_t width, uint32_t height);
void readCerts(atUint32 totalSize); void readCerts(uint32_t totalSize);
WiiFile* buildTree(std::vector<WiiFile*> files); WiiFile* buildTree(std::vector<WiiFile*> files);
}; };

6
include/athena/WiiSaveWriter.hpp
View File

@ -36,14 +36,14 @@ public:
* \param filepath * \param filepath
* \return * \return
*/ */
bool writeSave(WiiSave* save, atUint8* macAddress, atUint32 ngId, atUint8* ngPriv, atUint8* ngSig, atUint32 ngKeyId, bool writeSave(WiiSave* save, uint8_t* macAddress, uint32_t ngId, uint8_t* ngPriv, uint8_t* ngSig, uint32_t ngKeyId,
const std::string& filepath = ""); const std::string& filepath = "");
private: private:
void writeBanner(WiiBanner* banner); void writeBanner(WiiBanner* banner);
atUint32 writeFile(WiiFile* file); uint32_t writeFile(WiiFile* file);
void writeImage(WiiImage* image); void writeImage(WiiImage* image);
void writeCerts(atUint32 filesSize, atUint32 ngId, atUint8* ngPriv, atUint8* ngSig, atUint32 ngKeyId); void writeCerts(uint32_t filesSize, uint32_t ngId, uint8_t* ngPriv, uint8_t* ngSig, uint32_t ngKeyId);
}; };
} // namespace io } // namespace io

22
include/athena/ZQuestFile.hpp
View File

@ -18,24 +18,24 @@ public:
/*! /*!
* \brief The current major version of the ZQuest format * \brief The current major version of the ZQuest format
*/ */
static const atUint32 Major; static const uint32_t Major;
/*! /*!
* \brief The current minor version of the ZQuest format * \brief The current minor version of the ZQuest format
*/ */
static const atUint32 Minor; static const uint32_t Minor;
/*! /*!
* \brief The current revision of the ZQuest format * \brief The current revision of the ZQuest format
*/ */
static const atUint32 Revision; static const uint32_t Revision;
/*! /*!
* \brief The current version of the ZQuest format * \brief The current version of the ZQuest format
*/ */
static const atUint32 Version; static const uint32_t Version;
/*! /*!
* \brief The magic number used to identify the file e.g. "ZQS1" * \brief The magic number used to identify the file e.g. "ZQS1"
*/ */
static const atUint32 Magic; static const uint32_t Magic;
/*! /*!
* \enum Game * \enum Game
@ -79,7 +79,7 @@ public:
* \param data * \param data
* \param length * \param length
*/ */
ZQuestFile(Game game, Endian endian, std::unique_ptr<atUint8[]>&& data, atUint32 length, ZQuestFile(Game game, Endian endian, std::unique_ptr<uint8_t[]>&& data, uint32_t length,
const std::string& gameString = std::string()); const std::string& gameString = std::string());
/*! /*!
@ -111,19 +111,19 @@ public:
* \param data The data to assign * \param data The data to assign
* \param length The length of the data * \param length The length of the data
*/ */
void setData(std::unique_ptr<atUint8[]>&& data, atUint32 length); void setData(std::unique_ptr<uint8_t[]>&& data, uint32_t length);
/*! /*!
* \brief data * \brief data
* \return * \return
*/ */
atUint8* data() const; uint8_t* data() const;
/*! /*!
* \brief length * \brief length
* \return * \return
*/ */
atUint32 length() const; uint32_t length() const;
void setGameString(const std::string& gameString); void setGameString(const std::string& gameString);
/*! /*!
@ -138,8 +138,8 @@ protected:
Game m_game; Game m_game;
std::string m_gameString; std::string m_gameString;
Endian m_endian; Endian m_endian;
std::unique_ptr<atUint8[]> m_data; std::unique_ptr<uint8_t[]> m_data;
atUint32 m_length; uint32_t m_length;
// Game strings support // Game strings support
}; };

2
include/athena/ZQuestFileReader.hpp
View File

@ -20,7 +20,7 @@ public:
* \param data * \param data
* \param length * \param length
*/ */
ZQuestFileReader(atUint8* data, atUint64 length); ZQuestFileReader(uint8_t* data, uint64_t length);
/*! /*!
* \brief ZQuestFileReader * \brief ZQuestFileReader

2
include/athena/ZQuestFileWriter.hpp
View File

@ -19,7 +19,7 @@ public:
* \param data * \param data
* \param length * \param length
*/ */
ZQuestFileWriter(atUint8* data, atUint64 length); ZQuestFileWriter(uint8_t* data, uint64_t length);
/*! /*!
* \brief ZQuestFileWriter * \brief ZQuestFileWriter

12
include/bn.hpp
View File

@ -2,10 +2,10 @@
#include "athena/Types.hpp" #include "athena/Types.hpp"
namespace bignum { namespace bignum {
int compare(const atUint8* a, const atUint8* b, atUint32 n); int compare(const uint8_t* a, const uint8_t* b, uint32_t n);
void subModulus(atUint8* a, const atUint8* N, atUint32 n); void subModulus(uint8_t* a, const uint8_t* N, uint32_t n);
void add(atUint8* d, atUint8* a, const atUint8* b, const atUint8* N, atUint32 n); void add(uint8_t* d, uint8_t* a, const uint8_t* b, const uint8_t* N, uint32_t n);
void mul(atUint8* d, atUint8* a, const atUint8* b, const atUint8* N, atUint32 n); void mul(uint8_t* d, uint8_t* a, const uint8_t* b, const uint8_t* N, uint32_t n);
void exp(atUint8* d, const atUint8* a, const atUint8* N, atUint32 n, atUint8* e, atUint32 en); void exp(uint8_t* d, const uint8_t* a, const uint8_t* N, uint32_t n, uint8_t* e, uint32_t en);
void inv(atUint8* d, atUint8* a, const atUint8* N, atUint32 n); void inv(uint8_t* d, uint8_t* a, const uint8_t* N, uint32_t n);
} // namespace bignum } // namespace bignum

6
include/ec.hpp
View File

@ -2,7 +2,7 @@
#include "athena/Types.hpp" #include "athena/Types.hpp"
namespace ecc { namespace ecc {
void checkEC(atUint8* ng, atUint8* ap, atUint8* sig, atUint8* sigHash, bool& apValid, bool& ngValid); void checkEC(uint8_t* ng, uint8_t* ap, uint8_t* sig, uint8_t* sigHash, bool& apValid, bool& ngValid);
void makeECCert(atUint8* cert, atUint8* sig, const char* signer, const char* name, atUint8* priv, atUint32 keyId); void makeECCert(uint8_t* cert, uint8_t* sig, const char* signer, const char* name, uint8_t* priv, uint32_t keyId);
void createECDSA(atUint8* R, atUint8* S, atUint8* k, atUint8* hash); void createECDSA(uint8_t* R, uint8_t* S, uint8_t* k, uint8_t* hash);
} // namespace ecc } // namespace ecc

2
include/sha1.h
View File

@ -37,7 +37,7 @@ void SHA1Input(SHA1Context*,
atUint8* getSha1(atUint8* stuff, atUint32 stuff_size); uint8_t* getSha1(uint8_t* stuff, uint32_t stuff_size);
#ifdef __cplusplus #ifdef __cplusplus
} }

44
src/LZ77/LZBase.cpp
View File

@ -26,12 +26,12 @@ int subMatch(const uint8_t* str1, const uint8_t* str2, const int len) {
// Up to 4096 bytes Up to 18 bytes // Up to 4096 bytes Up to 18 bytes
// Sliding Window // Sliding Window
// Up to 4114 bytes // Up to 4114 bytes
LZLengthOffset windowSearch(const atUint8* beginSearchPtr, const atUint8* searchPosPtr, const atUint8* endLABufferPtr, LZLengthOffset windowSearch(const uint8_t* beginSearchPtr, const uint8_t* searchPosPtr, const uint8_t* endLABufferPtr,
const atUint8* startLBPtr) { const uint8_t* startLBPtr) {
atInt32 size = (atUint32)(endLABufferPtr - beginSearchPtr); // Size of the entire sliding window int32_t size = (uint32_t)(endLABufferPtr - beginSearchPtr); // Size of the entire sliding window
atInt32 n = (atUint32)(endLABufferPtr - searchPosPtr); int32_t n = (uint32_t)(endLABufferPtr - searchPosPtr);
LZLengthOffset result = {0, 0}; LZLengthOffset result = {0, 0};
atInt32 temp = 0; int32_t temp = 0;
if (n > size) // If the string that is being looked for is bigger than the string that is being searched if (n > size) // If the string that is being looked for is bigger than the string that is being searched
return result; return result;
@ -44,12 +44,12 @@ LZLengthOffset windowSearch(const atUint8* beginSearchPtr, const atUint8* search
do { do {
temp = subMatch(startLBPtr, searchPosPtr, n); temp = subMatch(startLBPtr, searchPosPtr, n);
if (result.length < (atUint32)temp) { if (result.length < (uint32_t)temp) {
result.length = temp; result.length = temp;
result.offset = (atInt32)(searchPosPtr - startLBPtr); result.offset = (int32_t)(searchPosPtr - startLBPtr);
} }
if (result.length == (atUint32)n) if (result.length == (uint32_t)n)
return result; return result;
// ReadAheadBuffer is the maximum size of a character match // ReadAheadBuffer is the maximum size of a character match
@ -60,7 +60,7 @@ LZLengthOffset windowSearch(const atUint8* beginSearchPtr, const atUint8* search
} }
} // Anonymous namespace } // Anonymous namespace
LZBase::LZBase(atInt32 minimumOffset, atInt32 slidingWindow, atInt32 minimumMatch, atInt32 blockSize) LZBase::LZBase(int32_t minimumOffset, int32_t slidingWindow, int32_t minimumMatch, int32_t blockSize)
: m_slidingWindow(slidingWindow) : m_slidingWindow(slidingWindow)
, m_readAheadBuffer(minimumMatch) , m_readAheadBuffer(minimumMatch)
, m_minMatch(minimumMatch) , m_minMatch(minimumMatch)
@ -69,25 +69,25 @@ LZBase::LZBase(atInt32 minimumOffset, atInt32 slidingWindow, atInt32 minimumMatc
LZBase::~LZBase() = default; LZBase::~LZBase() = default;
void LZBase::setSlidingWindow(atInt32 slidingWindow) { m_slidingWindow = slidingWindow; } void LZBase::setSlidingWindow(int32_t slidingWindow) { m_slidingWindow = slidingWindow; }
atInt32 LZBase::slidingWindow() const { return m_slidingWindow; } int32_t LZBase::slidingWindow() const { return m_slidingWindow; }
void LZBase::setReadAheadBuffer(atInt32 readAheadBuffer) { m_readAheadBuffer = readAheadBuffer; } void LZBase::setReadAheadBuffer(int32_t readAheadBuffer) { m_readAheadBuffer = readAheadBuffer; }
atInt32 LZBase::readAheadBuffer() const { return m_readAheadBuffer; } int32_t LZBase::readAheadBuffer() const { return m_readAheadBuffer; }
void LZBase::setMinMatch(atInt32 minimumMatch) { m_minMatch = minimumMatch; } void LZBase::setMinMatch(int32_t minimumMatch) { m_minMatch = minimumMatch; }
atInt32 LZBase::minMatch() const { return m_minMatch; } int32_t LZBase::minMatch() const { return m_minMatch; }
void LZBase::setBlockSize(atInt32 blockSize) { m_blockSize = blockSize; } void LZBase::setBlockSize(int32_t blockSize) { m_blockSize = blockSize; }
atInt32 LZBase::blockSize() const { return m_blockSize; } int32_t LZBase::blockSize() const { return m_blockSize; }
void LZBase::setMinimumOffset(atUint32 minimumOffset) { m_minOffset = minimumOffset; } void LZBase::setMinimumOffset(uint32_t minimumOffset) { m_minOffset = minimumOffset; }
atUint32 LZBase::minimumOffset() const { return m_minOffset; } uint32_t LZBase::minimumOffset() const { return m_minOffset; }
/* /*
DerricMc: DerricMc:
@ -100,7 +100,7 @@ atUint32 LZBase::minimumOffset() const { return m_minOffset; }
and 17 bytes did match then 17 bytes match is return). and 17 bytes did match then 17 bytes match is return).
*/ */
LZLengthOffset LZBase::search(const atUint8* posPtr, const atUint8* dataBegin, const atUint8* dataEnd) const { LZLengthOffset LZBase::search(const uint8_t* posPtr, const uint8_t* dataBegin, const uint8_t* dataEnd) const {
LZLengthOffset results = {0, 0}; LZLengthOffset results = {0, 0};
// Returns negative 1 for Search failures since the current position is passed the size to be compressed // Returns negative 1 for Search failures since the current position is passed the size to be compressed
@ -109,7 +109,7 @@ LZLengthOffset LZBase::search(const atUint8* posPtr, const atUint8* dataBegin, c
return results; return results;
} }
const atUint8* searchWindow; const uint8_t* searchWindow;
// LookAheadBuffer is ReadAheadBuffer Size if there are more bytes than ReadAheadBufferSize waiting // LookAheadBuffer is ReadAheadBuffer Size if there are more bytes than ReadAheadBufferSize waiting
// to be compressed else the number of remaining bytes is the LookAheadBuffer // to be compressed else the number of remaining bytes is the LookAheadBuffer
const int lookAheadBuffer_len = const int lookAheadBuffer_len =
@ -121,7 +121,7 @@ LZLengthOffset LZBase::search(const atUint8* posPtr, const atUint8* dataBegin, c
else else
searchWindow = dataBegin; searchWindow = dataBegin;
const atUint8* endPos = posPtr + lookAheadBuffer_len; const uint8_t* endPos = posPtr + lookAheadBuffer_len;
if (!((posPtr - dataBegin < 1) || (dataEnd - posPtr < m_minMatch))) if (!((posPtr - dataBegin < 1) || (dataEnd - posPtr < m_minMatch)))
results = windowSearch(searchWindow, posPtr, endPos, posPtr - m_minOffset); results = windowSearch(searchWindow, posPtr, endPos, posPtr - m_minOffset);

14
src/LZ77/LZLookupTable.cpp
View File

@ -3,7 +3,7 @@
LZLookupTable::LZLookupTable() : m_buffer(m_minimumMatch) {} LZLookupTable::LZLookupTable() : m_buffer(m_minimumMatch) {}
LZLookupTable::LZLookupTable(atInt32 minimumMatch, atInt32 slidingWindow, atInt32 lookAheadWindow) { LZLookupTable::LZLookupTable(int32_t minimumMatch, int32_t slidingWindow, int32_t lookAheadWindow) {
if (minimumMatch > 0) if (minimumMatch > 0)
m_minimumMatch = minimumMatch; m_minimumMatch = minimumMatch;
else else
@ -21,14 +21,14 @@ LZLookupTable::LZLookupTable(atInt32 minimumMatch, atInt32 slidingWindow, atInt3
LZLookupTable::~LZLookupTable() = default; LZLookupTable::~LZLookupTable() = default;
void LZLookupTable::setLookAheadWindow(atInt32 lookAheadWindow) { void LZLookupTable::setLookAheadWindow(int32_t lookAheadWindow) {
if (lookAheadWindow > 0) if (lookAheadWindow > 0)
m_lookAheadWindow = lookAheadWindow; m_lookAheadWindow = lookAheadWindow;
else else
m_lookAheadWindow = 18; m_lookAheadWindow = 18;
} }
LZLengthOffset LZLookupTable::search(const atUint8* curPos, const atUint8* dataBegin, const atUint8* dataEnd) { LZLengthOffset LZLookupTable::search(const uint8_t* curPos, const uint8_t* dataBegin, const uint8_t* dataEnd) {
LZLengthOffset loPair = {0, 0}; LZLengthOffset loPair = {0, 0};
// Returns negative 1 for search failures since the current position is passed the size to be compressed // Returns negative 1 for search failures since the current position is passed the size to be compressed
@ -38,7 +38,7 @@ LZLengthOffset LZLookupTable::search(const atUint8* curPos, const atUint8* dataB
} }
std::copy(curPos, curPos + m_minimumMatch, m_buffer.begin()); std::copy(curPos, curPos + m_minimumMatch, m_buffer.begin());
int32_t currentOffset = static_cast<atInt32>(curPos - dataBegin); int32_t currentOffset = static_cast<int32_t>(curPos - dataBegin);
// Find code // Find code
if (currentOffset > 0 && (dataEnd - curPos) >= m_minimumMatch) { if (currentOffset > 0 && (dataEnd - curPos) >= m_minimumMatch) {
@ -60,13 +60,13 @@ LZLengthOffset LZLookupTable::search(const atUint8* curPos, const atUint8* dataB
// Store the longest match found so far into length_offset struct. // Store the longest match found so far into length_offset struct.
// When lengths are the same the closer offset to the lookahead buffer wins // When lengths are the same the closer offset to the lookahead buffer wins
if (loPair.length < (atUint32)matchLength) { if (loPair.length < (uint32_t)matchLength) {
loPair.length = matchLength; loPair.length = matchLength;
loPair.offset = currentOffset - iter->second; loPair.offset = currentOffset - iter->second;
} }
// Found the longest match so break out of loop // Found the longest match so break out of loop
if (loPair.length == (atUint32)m_lookAheadWindow) if (loPair.length == (uint32_t)m_lookAheadWindow)
break; break;
} }
} }
@ -75,7 +75,7 @@ LZLengthOffset LZLookupTable::search(const atUint8* curPos, const atUint8* dataB
// Insert code // Insert code
table.insert(std::make_pair(m_buffer, currentOffset)); table.insert(std::make_pair(m_buffer, currentOffset));
for (atUint32 i = 1; i < loPair.length; i++) { for (uint32_t i = 1; i < loPair.length; i++) {
if (dataEnd - (curPos + i) < m_minimumMatch) if (dataEnd - (curPos + i) < m_minimumMatch)
break; break;

56
src/LZ77/LZType10.cpp
View File

@ -8,46 +8,46 @@
#include <athena/MemoryWriter.hpp> #include <athena/MemoryWriter.hpp>
LZType10::LZType10(atInt32 MinimumOffset, atInt32 SlidingWindow, atInt32 MinimumMatch, atInt32 BlockSize) LZType10::LZType10(int32_t MinimumOffset, int32_t SlidingWindow, int32_t MinimumMatch, int32_t BlockSize)
: LZBase(MinimumOffset, SlidingWindow, MinimumMatch, BlockSize) { : LZBase(MinimumOffset, SlidingWindow, MinimumMatch, BlockSize) {
// ReadAheadBuffer is normalize between (minumum match) and(minimum match + 15) so that matches fit within // ReadAheadBuffer is normalize between (minumum match) and(minimum match + 15) so that matches fit within
// 4-bits. // 4-bits.
m_readAheadBuffer = m_minMatch + 0xF; m_readAheadBuffer = m_minMatch + 0xF;
} }
atUint32 LZType10::compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLength) { uint32_t LZType10::compress(const uint8_t* src, uint8_t** dstBuf, uint32_t srcLength) {
atUint32 encodeSize = (srcLength << 8) | (0x10); uint32_t encodeSize = (srcLength << 8) | (0x10);
encodeSize = athena::utility::LittleUint32(encodeSize); // File size needs to be written as little endian always encodeSize = athena::utility::LittleUint32(encodeSize); // File size needs to be written as little endian always
athena::io::MemoryCopyWriter outbuf("tmp"); athena::io::MemoryCopyWriter outbuf("tmp");
outbuf.writeUint32(encodeSize); outbuf.writeUint32(encodeSize);
const atUint8* ptrStart = src; const uint8_t* ptrStart = src;
const atUint8* ptrEnd = src + srcLength; const uint8_t* ptrEnd = src + srcLength;
// At most their will be two bytes written if the bytes can be compressed. So if all bytes in the block can be // At most their will be two bytes written if the bytes can be compressed. So if all bytes in the block can be
// compressed it would take blockSize*2 bytes // compressed it would take blockSize*2 bytes
auto compressedBytes = std::unique_ptr<atUint8[]>(new atUint8[m_blockSize * 2]); // Holds the compressed bytes yet to be written auto compressedBytes = std::unique_ptr<uint8_t[]>(new uint8_t[m_blockSize * 2]); // Holds the compressed bytes yet to be written
while (ptrStart < ptrEnd) { while (ptrStart < ptrEnd) {
atUint8 blockLen = 0; uint8_t blockLen = 0;
// In Binary represents 1 if byte is compressed or 0 if not compressed // In Binary represents 1 if byte is compressed or 0 if not compressed
// For example 01001000 means that the second and fifth byte in the blockSize from the left is compressed // For example 01001000 means that the second and fifth byte in the blockSize from the left is compressed
atUint8* ptrBytes = compressedBytes.get(); uint8_t* ptrBytes = compressedBytes.get();
for (atInt32 i = 0; i < m_blockSize; i++) { for (int32_t i = 0; i < m_blockSize; i++) {
// length_offset searchResult=Search(ptrStart, filedata, ptrEnd); // length_offset searchResult=Search(ptrStart, filedata, ptrEnd);
const LZLengthOffset searchResult = m_lookupTable.search(ptrStart, src, ptrEnd); const LZLengthOffset searchResult = m_lookupTable.search(ptrStart, src, ptrEnd);
// If the number of bytes to be compressed is at least the size of the Minimum match // If the number of bytes to be compressed is at least the size of the Minimum match
if (searchResult.length >= static_cast<atUint32>(m_minMatch)) { if (searchResult.length >= static_cast<uint32_t>(m_minMatch)) {
// Gotta swap the bytes since system is wii is big endian and most computers are little endian // Gotta swap the bytes since system is wii is big endian and most computers are little endian
atUint16 lenOff = (((searchResult.length - m_minMatch) & 0xF) << 12) | ((searchResult.offset - 1) & 0xFFF); uint16_t lenOff = (((searchResult.length - m_minMatch) & 0xF) << 12) | ((searchResult.offset - 1) & 0xFFF);
athena::utility::BigUint16(lenOff); athena::utility::BigUint16(lenOff);
memcpy(ptrBytes, &lenOff, sizeof(atUint16)); memcpy(ptrBytes, &lenOff, sizeof(uint16_t));
ptrBytes += sizeof(atUint16); ptrBytes += sizeof(uint16_t);
ptrStart += searchResult.length; ptrStart += searchResult.length;
@ -60,7 +60,7 @@ atUint32 LZType10::compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLe
} }
outbuf.writeByte(blockLen); outbuf.writeByte(blockLen);
outbuf.writeUBytes(compressedBytes.get(), static_cast<atUint64>(ptrBytes - compressedBytes.get())); outbuf.writeUBytes(compressedBytes.get(), static_cast<uint64_t>(ptrBytes - compressedBytes.get()));
} }
// Add zeros until the file is a multiple of 4 // Add zeros until the file is a multiple of 4
@ -70,16 +70,16 @@ atUint32 LZType10::compress(const atUint8* src, atUint8** dstBuf, atUint32 srcLe
*dstBuf = outbuf.data(); *dstBuf = outbuf.data();
outbuf.save(); outbuf.save();
return static_cast<atUint32>(outbuf.length()); return static_cast<uint32_t>(outbuf.length());
} }
atUint32 LZType10::decompress(const atUint8* src, atUint8** dst, atUint32 srcLength) { uint32_t LZType10::decompress(const uint8_t* src, uint8_t** dst, uint32_t srcLength) {
if (*src != 0x10) { if (*src != 0x10) {
return 0; return 0;
} }
// Size of data when it is uncompressed // Size of data when it is uncompressed
atUint32 uncompressedSize; uint32_t uncompressedSize;
std::memcpy(&uncompressedSize, src, sizeof(uncompressedSize)); std::memcpy(&uncompressedSize, src, sizeof(uncompressedSize));
// The compressed file has the filesize encoded in little endian // The compressed file has the filesize encoded in little endian
@ -88,28 +88,28 @@ atUint32 LZType10::decompress(const atUint8* src, atUint8** dst, atUint32 srcLen
// first byte is the encode flag // first byte is the encode flag
uncompressedSize = uncompressedSize >> 8; uncompressedSize = uncompressedSize >> 8;
auto uncompressedData = std::unique_ptr<atUint8[]>(new atUint8[uncompressedSize]); auto uncompressedData = std::unique_ptr<uint8_t[]>(new uint8_t[uncompressedSize]);
atUint8* outputPtr = uncompressedData.get(); uint8_t* outputPtr = uncompressedData.get();
atUint8* outputEndPtr = uncompressedData.get() + uncompressedSize; uint8_t* outputEndPtr = uncompressedData.get() + uncompressedSize;
const atUint8* inputPtr = src + 4; const uint8_t* inputPtr = src + 4;
const atUint8* inputEndPtr = src + srcLength; const uint8_t* inputEndPtr = src + srcLength;
while (inputPtr < inputEndPtr && outputPtr < outputEndPtr) { while (inputPtr < inputEndPtr && outputPtr < outputEndPtr) {
const atUint8 isCompressed = *inputPtr++; const uint8_t isCompressed = *inputPtr++;
for (atUint32 i = 0; i < static_cast<atUint32>(m_blockSize); i++) { for (uint32_t i = 0; i < static_cast<uint32_t>(m_blockSize); i++) {
// Checks to see if the next byte is compressed by looking // Checks to see if the next byte is compressed by looking
// at its binary representation - E.g 10010000 // at its binary representation - E.g 10010000
// This says that the first extracted byte and the four extracted byte is compressed // This says that the first extracted byte and the four extracted byte is compressed
if ((isCompressed >> (7 - i)) & 0x1) { if ((isCompressed >> (7 - i)) & 0x1) {
atUint16 lenOff; uint16_t lenOff;
memcpy(&lenOff, inputPtr, sizeof(atUint16)); memcpy(&lenOff, inputPtr, sizeof(uint16_t));
athena::utility::BigUint16(lenOff); athena::utility::BigUint16(lenOff);
inputPtr += sizeof(atUint16); // Move forward two bytes inputPtr += sizeof(uint16_t); // Move forward two bytes
// length offset pair has been decoded. // length offset pair has been decoded.
LZLengthOffset decoding; LZLengthOffset decoding;
decoding.length = (lenOff >> 12) + m_minMatch; decoding.length = (lenOff >> 12) + m_minMatch;
decoding.offset = static_cast<atUint16>((lenOff & 0xFFF) + 1); decoding.offset = static_cast<uint16_t>((lenOff & 0xFFF) + 1);
if ((outputPtr - decoding.offset) < uncompressedData.get()) { if ((outputPtr - decoding.offset) < uncompressedData.get()) {
// If the offset to look for uncompressed is passed the current uncompresed data then the data is not // If the offset to look for uncompressed is passed the current uncompresed data then the data is not

86
src/LZ77/LZType11.cpp
View File

@ -8,41 +8,41 @@
#include <athena/MemoryWriter.hpp> #include <athena/MemoryWriter.hpp>
LZType11::LZType11(atInt32 minimumOffset, atInt32 slidingWindow, atInt32 minimumMatch, atInt32 blockSize) LZType11::LZType11(int32_t minimumOffset, int32_t slidingWindow, int32_t minimumMatch, int32_t blockSize)
: LZBase(minimumOffset, slidingWindow, minimumMatch, blockSize) { : LZBase(minimumOffset, slidingWindow, minimumMatch, blockSize) {
m_readAheadBuffer = (0xF + 0xFF + 0xFFFF + m_minMatch); m_readAheadBuffer = (0xF + 0xFF + 0xFFFF + m_minMatch);
m_lookupTable.setLookAheadWindow(m_readAheadBuffer); m_lookupTable.setLookAheadWindow(m_readAheadBuffer);
} }
atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLength) { uint32_t LZType11::compress(const uint8_t* src, uint8_t** dst, uint32_t srcLength) {
athena::io::MemoryCopyWriter outbuff("tmp"); athena::io::MemoryCopyWriter outbuff("tmp");
if (srcLength > 0xFFFFFF) { // If length is greater than 24 bits or 16 Megs if (srcLength > 0xFFFFFF) { // If length is greater than 24 bits or 16 Megs
atUint32 encodeFlag = 0x11; uint32_t encodeFlag = 0x11;
athena::utility::LittleUint32(encodeFlag); athena::utility::LittleUint32(encodeFlag);
athena::utility::LittleUint32(srcLength); // Filesize data is little endian athena::utility::LittleUint32(srcLength); // Filesize data is little endian
outbuff.writeUint32(encodeFlag); outbuff.writeUint32(encodeFlag);
outbuff.writeUint32(srcLength); outbuff.writeUint32(srcLength);
} else { } else {
atUint32 encodeSize = (srcLength << 8) | (0x11); uint32_t encodeSize = (srcLength << 8) | (0x11);
athena::utility::LittleUint32(encodeSize); athena::utility::LittleUint32(encodeSize);
outbuff.writeUint32(encodeSize); outbuff.writeUint32(encodeSize);
} }
const atUint8* ptrStart = src; const uint8_t* ptrStart = src;
const atUint8* ptrEnd = src + srcLength; const uint8_t* ptrEnd = src + srcLength;
// At most their will be two bytes written if the bytes can be compressed. So if all bytes in the block can be // At most their will be two bytes written if the bytes can be compressed. So if all bytes in the block can be
// compressed it would take blockSize*2 bytes // compressed it would take blockSize*2 bytes
// Holds the compressed bytes yet to be written // Holds the compressed bytes yet to be written
auto compressedBytes = std::unique_ptr<atUint8[]>(new atUint8[m_blockSize * 2]); auto compressedBytes = std::unique_ptr<uint8_t[]>(new uint8_t[m_blockSize * 2]);
const atUint8 maxTwoByteMatch = 0xF + 1; const uint8_t maxTwoByteMatch = 0xF + 1;
const atUint8 minThreeByteMatch = maxTwoByteMatch + 1; // Minimum Three byte match is maximum TwoByte match + 1 const uint8_t minThreeByteMatch = maxTwoByteMatch + 1; // Minimum Three byte match is maximum TwoByte match + 1
const atUint16 maxThreeByteMatch = 0xFF + minThreeByteMatch; const uint16_t maxThreeByteMatch = 0xFF + minThreeByteMatch;
const atUint16 minFourByteMatch = maxThreeByteMatch + 1; // Minimum Four byte match is maximum Three Byte match + 1 const uint16_t minFourByteMatch = maxThreeByteMatch + 1; // Minimum Four byte match is maximum Three Byte match + 1
const atInt32 maxFourByteMatch = 0xFFFF + minFourByteMatch; const int32_t maxFourByteMatch = 0xFFFF + minFourByteMatch;
/* /*
Normaliazation Example: If MIN_MATCH is 3 then 3 gets mapped to 2 and 16 gets mapped to 15. Normaliazation Example: If MIN_MATCH is 3 then 3 gets mapped to 2 and 16 gets mapped to 15.
@ -59,36 +59,36 @@ atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLengt
In the four byte case the first 4 bits a 0001 In the four byte case the first 4 bits a 0001
*/ */
while (ptrStart < ptrEnd) { while (ptrStart < ptrEnd) {
atUint8 blockSize = 0; uint8_t blockSize = 0;
// In Binary represents 1 if byte is compressed or 0 if not compressed // In Binary represents 1 if byte is compressed or 0 if not compressed
// For example 01001000 means that the second and fifth byte in the blockSize from the left is compressed // For example 01001000 means that the second and fifth byte in the blockSize from the left is compressed
atUint8* ptrBytes = compressedBytes.get(); uint8_t* ptrBytes = compressedBytes.get();
for (atInt32 i = 0; i < m_blockSize; i++) { for (int32_t i = 0; i < m_blockSize; i++) {
// length_offset searchResult=Search(filedata,ptrStart,ptrEnd); // length_offset searchResult=Search(filedata,ptrStart,ptrEnd);
const LZLengthOffset searchResult = m_lookupTable.search(ptrStart, src, ptrEnd); const LZLengthOffset searchResult = m_lookupTable.search(ptrStart, src, ptrEnd);
// If the number of bytes to be compressed is at least the size of the Minimum match // If the number of bytes to be compressed is at least the size of the Minimum match
if (searchResult.length >= static_cast<atUint32>(m_minMatch)) { if (searchResult.length >= static_cast<uint32_t>(m_minMatch)) {
// Gotta swap the bytes since system is wii is big endian and most computers are little endian // Gotta swap the bytes since system is wii is big endian and most computers are little endian
if (searchResult.length <= maxTwoByteMatch) { if (searchResult.length <= maxTwoByteMatch) {
atUint16 lenOff = ((((searchResult.length - 1) & 0xF) << 12) | // Bits 15-12 uint16_t lenOff = ((((searchResult.length - 1) & 0xF) << 12) | // Bits 15-12
((searchResult.offset - 1) & 0xFFF) // Bits 11-0 ((searchResult.offset - 1) & 0xFFF) // Bits 11-0
); );
athena::utility::BigUint16(lenOff); athena::utility::BigUint16(lenOff);
memcpy(ptrBytes, &lenOff, 2); memcpy(ptrBytes, &lenOff, 2);
ptrBytes += 2; ptrBytes += 2;
} else if (searchResult.length <= maxThreeByteMatch) { } else if (searchResult.length <= maxThreeByteMatch) {
atUint32 lenOff = ((((searchResult.length - minThreeByteMatch) & 0xFF) << 12) | // Bits 20-12 uint32_t lenOff = ((((searchResult.length - minThreeByteMatch) & 0xFF) << 12) | // Bits 20-12
((searchResult.offset - 1) & 0xFFF) // Bits 11-0 ((searchResult.offset - 1) & 0xFFF) // Bits 11-0
); );
athena::utility::BigUint32(lenOff); athena::utility::BigUint32(lenOff);
memcpy(ptrBytes, reinterpret_cast<atUint8*>(&lenOff) + 1, memcpy(ptrBytes, reinterpret_cast<uint8_t*>(&lenOff) + 1,
3); // Make sure to copy the lower 24 bits. 0x12345678- This statement copies 0x123456 3); // Make sure to copy the lower 24 bits. 0x12345678- This statement copies 0x123456
ptrBytes += 3; ptrBytes += 3;
} else if (searchResult.length <= static_cast<atUint32>(maxFourByteMatch)) { } else if (searchResult.length <= static_cast<uint32_t>(maxFourByteMatch)) {
atUint32 lenOff = ((1 << 28) | // Bits 31-28 Flag to say that this is four bytes uint32_t lenOff = ((1 << 28) | // Bits 31-28 Flag to say that this is four bytes
(((searchResult.length - minFourByteMatch) & 0xFFFF) << 12) | // Bits 28-12 (((searchResult.length - minFourByteMatch) & 0xFFFF) << 12) | // Bits 28-12
((searchResult.offset - 1) & 0xFFF) // Bits 11-0 ((searchResult.offset - 1) & 0xFFF) // Bits 11-0
); );
@ -108,7 +108,7 @@ atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLengt
} }
outbuff.writeByte(blockSize); outbuff.writeByte(blockSize);
outbuff.writeUBytes(compressedBytes.get(), static_cast<atUint64>(ptrBytes - compressedBytes.get())); outbuff.writeUBytes(compressedBytes.get(), static_cast<uint64_t>(ptrBytes - compressedBytes.get()));
} }
// Add zeros until the file is a multiple of 4 // Add zeros until the file is a multiple of 4
@ -117,66 +117,66 @@ atUint32 LZType11::compress(const atUint8* src, atUint8** dst, atUint32 srcLengt
} }
*dst = outbuff.data(); *dst = outbuff.data();
return static_cast<atUint32>(outbuff.length()); return static_cast<uint32_t>(outbuff.length());
} }
atUint32 LZType11::decompress(const atUint8* src, atUint8** dst, atUint32 srcLength) { uint32_t LZType11::decompress(const uint8_t* src, uint8_t** dst, uint32_t srcLength) {
if (*src != 0x11) { if (*src != 0x11) {
return 0; return 0;
} }
atUint32 uncompressedLen; uint32_t uncompressedLen;
std::memcpy(&uncompressedLen, src, sizeof(uncompressedLen)); std::memcpy(&uncompressedLen, src, sizeof(uncompressedLen));
athena::utility::LittleUint32(uncompressedLen); // The compressed file has the filesize encoded in little endian athena::utility::LittleUint32(uncompressedLen); // The compressed file has the filesize encoded in little endian
uncompressedLen = uncompressedLen >> 8; // First byte is the encode flag uncompressedLen = uncompressedLen >> 8; // First byte is the encode flag
atUint32 currentOffset = 4; uint32_t currentOffset = 4;
// If the filesize var is zero then the true filesize is over 14MB and must be read in from the next 4 bytes // If the filesize var is zero then the true filesize is over 14MB and must be read in from the next 4 bytes
if (uncompressedLen == 0) { if (uncompressedLen == 0) {
atUint32 filesize; uint32_t filesize;
std::memcpy(&filesize, src + 4, sizeof(filesize)); std::memcpy(&filesize, src + 4, sizeof(filesize));
filesize = athena::utility::LittleUint32(filesize); filesize = athena::utility::LittleUint32(filesize);
currentOffset += 4; currentOffset += 4;
} }
auto uncompressedData = std::unique_ptr<atUint8[]>(new atUint8[uncompressedLen]); auto uncompressedData = std::unique_ptr<uint8_t[]>(new uint8_t[uncompressedLen]);
atUint8* outputPtr = uncompressedData.get(); uint8_t* outputPtr = uncompressedData.get();
atUint8* outputEndPtr = uncompressedData.get() + uncompressedLen; uint8_t* outputEndPtr = uncompressedData.get() + uncompressedLen;
const atUint8* inputPtr = src + currentOffset; const uint8_t* inputPtr = src + currentOffset;
const atUint8* inputEndPtr = src + srcLength; const uint8_t* inputEndPtr = src + srcLength;
LZLengthOffset decoding; LZLengthOffset decoding;
const atUint8 maxTwoByteMatch = 0xF + 1; const uint8_t maxTwoByteMatch = 0xF + 1;
const atUint8 threeByteDenorm = maxTwoByteMatch + 1; // Amount to add to length when compression is 3 bytes const uint8_t threeByteDenorm = maxTwoByteMatch + 1; // Amount to add to length when compression is 3 bytes
const atUint16 maxThreeByteMatch = 0xFF + threeByteDenorm; const uint16_t maxThreeByteMatch = 0xFF + threeByteDenorm;
const atUint16 fourByteDenorm = maxThreeByteMatch + 1; const uint16_t fourByteDenorm = maxThreeByteMatch + 1;
while (inputPtr < inputEndPtr && outputPtr < outputEndPtr) { while (inputPtr < inputEndPtr && outputPtr < outputEndPtr) {
const atUint8 isCompressed = *inputPtr++; const uint8_t isCompressed = *inputPtr++;
for (atInt32 i = 0; i < m_blockSize; i++) { for (int32_t i = 0; i < m_blockSize; i++) {
// Checks to see if the next byte is compressed by looking // Checks to see if the next byte is compressed by looking
// at its binary representation - E.g 10010000 // at its binary representation - E.g 10010000
// This says that the first extracted byte and the four extracted byte is compressed // This says that the first extracted byte and the four extracted byte is compressed
if ((isCompressed >> (7 - i)) & 0x1) { if ((isCompressed >> (7 - i)) & 0x1) {
const atUint8 metaDataSize = *inputPtr >> 4; // Look at the top 4 bits const uint8_t metaDataSize = *inputPtr >> 4; // Look at the top 4 bits
if (metaDataSize >= 2) { // Two Bytes of Length/Offset MetaData if (metaDataSize >= 2) { // Two Bytes of Length/Offset MetaData
atUint16 lenOff = 0; uint16_t lenOff = 0;
memcpy(&lenOff, inputPtr, 2); memcpy(&lenOff, inputPtr, 2);
inputPtr += 2; inputPtr += 2;
athena::utility::BigUint16(lenOff); athena::utility::BigUint16(lenOff);
decoding.length = (lenOff >> 12) + 1; decoding.length = (lenOff >> 12) + 1;
decoding.offset = (lenOff & 0xFFF) + 1; decoding.offset = (lenOff & 0xFFF) + 1;
} else if (metaDataSize == 0) { // Three Bytes of Length/Offset MetaData } else if (metaDataSize == 0) { // Three Bytes of Length/Offset MetaData
atUint32 lenOff = 0; uint32_t lenOff = 0;
memcpy(reinterpret_cast<atUint8*>(&lenOff) + 1, inputPtr, 3); memcpy(reinterpret_cast<uint8_t*>(&lenOff) + 1, inputPtr, 3);
inputPtr += 3; inputPtr += 3;
athena::utility::BigUint32(lenOff); athena::utility::BigUint32(lenOff);
decoding.length = (lenOff >> 12) + threeByteDenorm; decoding.length = (lenOff >> 12) + threeByteDenorm;
decoding.offset = (lenOff & 0xFFF) + 1; decoding.offset = (lenOff & 0xFFF) + 1;
} else if (metaDataSize == 1) { // Four Bytes of Length/Offset MetaData } else if (metaDataSize == 1) { // Four Bytes of Length/Offset MetaData
atUint32 lenOff = 0; uint32_t lenOff = 0;
memcpy(&lenOff, inputPtr, 4); memcpy(&lenOff, inputPtr, 4);
inputPtr += 4; inputPtr += 4;
athena::utility::BigUint32(lenOff); athena::utility::BigUint32(lenOff);

6
src/athena/ALTTPFile.cpp
View File

@ -7,7 +7,7 @@ ALTTPFile::ALTTPFile() {}
ALTTPFile::ALTTPFile(std::vector<ALTTPQuest*> quests, std::vector<ALTTPQuest*> backup) ALTTPFile::ALTTPFile(std::vector<ALTTPQuest*> quests, std::vector<ALTTPQuest*> backup)
: m_quests(quests), m_backup(backup) {} : m_quests(quests), m_backup(backup) {}
void ALTTPFile::setQuest(atUint32 id, ALTTPQuest* val) { void ALTTPFile::setQuest(uint32_t id, ALTTPQuest* val) {
if (id > m_quests.size()) { if (id > m_quests.size()) {
atWarning("index out of range"); atWarning("index out of range");
return; return;
@ -17,7 +17,7 @@ void ALTTPFile::setQuest(atUint32 id, ALTTPQuest* val) {
} }
std::vector<ALTTPQuest*> ALTTPFile::questList() const { return m_quests; } std::vector<ALTTPQuest*> ALTTPFile::questList() const { return m_quests; }
ALTTPQuest* ALTTPFile::quest(atUint32 id) const { ALTTPQuest* ALTTPFile::quest(uint32_t id) const {
if (id > m_quests.size()) { if (id > m_quests.size()) {
atWarning("index out of range"); atWarning("index out of range");
return nullptr; return nullptr;
@ -26,5 +26,5 @@ ALTTPQuest* ALTTPFile::quest(atUint32 id) const {
return m_quests[id]; return m_quests[id];
} }
atUint32 ALTTPFile::questCount() const { return (atUint32)m_quests.size(); } uint32_t ALTTPFile::questCount() const { return (uint32_t)m_quests.size(); }
} // namespace athena } // namespace athena

24
src/athena/ALTTPFileReader.cpp
View File

@ -6,7 +6,7 @@
namespace athena::io { namespace athena::io {
ALTTPFileReader::ALTTPFileReader(atUint8* data, atUint64 length) : MemoryCopyReader(data, length) {} ALTTPFileReader::ALTTPFileReader(uint8_t* data, uint64_t length) : MemoryCopyReader(data, length) {}
ALTTPFileReader::ALTTPFileReader(const std::string& filename) : MemoryCopyReader(filename) {} ALTTPFileReader::ALTTPFileReader(const std::string& filename) : MemoryCopyReader(filename) {}
@ -14,16 +14,16 @@ ALTTPFile* ALTTPFileReader::readFile() {
std::vector<ALTTPQuest*> quests; std::vector<ALTTPQuest*> quests;
std::vector<ALTTPQuest*> backup; std::vector<ALTTPQuest*> backup;
for (atUint32 i = 0; i < 6; i++) { for (uint32_t i = 0; i < 6; i++) {
// Temporary values to use for each save // Temporary values to use for each save
ALTTPQuest* quest = new ALTTPQuest(); ALTTPQuest* quest = new ALTTPQuest();
std::vector<ALTTPRoomFlags*> roomFlags; std::vector<ALTTPRoomFlags*> roomFlags;
std::vector<ALTTPOverworldEvent*> owEvents; std::vector<ALTTPOverworldEvent*> owEvents;
std::vector<atUint8> dungeonKeys; std::vector<uint8_t> dungeonKeys;
std::vector<atUint8> oldmanFlags; std::vector<uint8_t> oldmanFlags;
std::vector<atUint8> unknown1; std::vector<uint8_t> unknown1;
std::vector<atUint16> playerName; std::vector<uint16_t> playerName;
std::vector<atUint16> dungeonDeaths; std::vector<uint16_t> dungeonDeaths;
int j = 0x140; int j = 0x140;
@ -55,7 +55,7 @@ ALTTPFile* ALTTPFileReader::readFile() {
quest->setArrowUpgrades(readByte()); quest->setArrowUpgrades(readByte());
quest->setHealthFiller(readByte()); quest->setHealthFiller(readByte());
quest->setMagicFiller(readByte()); quest->setMagicFiller(readByte());
atUint8 pendantsByte = readUByte(); uint8_t pendantsByte = readUByte();
ALTTPPendants pendants; ALTTPPendants pendants;
pendants.Courage = pendantsByte & 1; pendants.Courage = pendantsByte & 1;
pendants.Wisdom = (pendantsByte >> 1) & 1; pendants.Wisdom = (pendantsByte >> 1) & 1;
@ -70,7 +70,7 @@ ALTTPFile* ALTTPFileReader::readFile() {
quest->setArrowFiller(readByte()); quest->setArrowFiller(readByte());
quest->setArrows(readByte()); quest->setArrows(readByte());
seek(1); seek(1);
atUint8 abilitiesByte = readUByte(); uint8_t abilitiesByte = readUByte();
ALTTPAbilities abilities; ALTTPAbilities abilities;
abilities.Nothing = abilitiesByte & 1; abilities.Nothing = abilitiesByte & 1;
abilities.Swim = (abilitiesByte >> 1) & 1; abilities.Swim = (abilitiesByte >> 1) & 1;
@ -154,7 +154,7 @@ ALTTPFile* ALTTPFileReader::readFile() {
ALTTPRoomFlags* ALTTPFileReader::readRoomFlags() { ALTTPRoomFlags* ALTTPFileReader::readRoomFlags() {
ALTTPRoomFlags* flags = new ALTTPRoomFlags; ALTTPRoomFlags* flags = new ALTTPRoomFlags;
atUint8 flagsByte = readUByte(); uint8_t flagsByte = readUByte();
flags->Chest1 = flagsByte & 1; flags->Chest1 = flagsByte & 1;
flags->Chest2 = (flagsByte >> 1) & 1; flags->Chest2 = (flagsByte >> 1) & 1;
flags->Chest3 = (flagsByte >> 2) & 1; flags->Chest3 = (flagsByte >> 2) & 1;
@ -178,7 +178,7 @@ ALTTPRoomFlags* ALTTPFileReader::readRoomFlags() {
ALTTPOverworldEvent* ALTTPFileReader::readOverworldEvent() { ALTTPOverworldEvent* ALTTPFileReader::readOverworldEvent() {
ALTTPOverworldEvent* event = new ALTTPOverworldEvent; ALTTPOverworldEvent* event = new ALTTPOverworldEvent;
atUint8 flagsByte = readUByte(); uint8_t flagsByte = readUByte();
event->Unused1 = flagsByte & 1; event->Unused1 = flagsByte & 1;
event->HeartPiece = (flagsByte >> 1) & 1; event->HeartPiece = (flagsByte >> 1) & 1;
event->Overlay = (flagsByte >> 2) & 1; event->Overlay = (flagsByte >> 2) & 1;
@ -192,7 +192,7 @@ ALTTPOverworldEvent* ALTTPFileReader::readOverworldEvent() {
ALTTPDungeonItemFlags ALTTPFileReader::readDungeonFlags() { ALTTPDungeonItemFlags ALTTPFileReader::readDungeonFlags() {
ALTTPDungeonItemFlags flags; ALTTPDungeonItemFlags flags;
atUint8 flagsByte = readUByte(); uint8_t flagsByte = readUByte();
flags.Unused1 = flagsByte & 1; flags.Unused1 = flagsByte & 1;
flags.Unused2 = (flagsByte >> 1) & 1; flags.Unused2 = (flagsByte >> 1) & 1;
flags.GanonsTower = (flagsByte >> 2) & 1; flags.GanonsTower = (flagsByte >> 2) & 1;

36
src/athena/ALTTPFileWriter.cpp
View File

@ -7,14 +7,14 @@ namespace athena {
namespace io { namespace io {
ALTTPFileWriter::ALTTPFileWriter(atUint8* data, atUint64 length) : MemoryCopyWriter(data, length) {} ALTTPFileWriter::ALTTPFileWriter(uint8_t* data, uint64_t length) : MemoryCopyWriter(data, length) {}
ALTTPFileWriter::ALTTPFileWriter(const std::string& filename) : MemoryCopyWriter(filename) {} ALTTPFileWriter::ALTTPFileWriter(const std::string& filename) : MemoryCopyWriter(filename) {}
void ALTTPFileWriter::writeFile(ALTTPFile* file) { void ALTTPFileWriter::writeFile(ALTTPFile* file) {
ALTTPQuest* quest = NULL; ALTTPQuest* quest = NULL;
for (atUint32 i = 0; i < 6; i++) { for (uint32_t i = 0; i < 6; i++) {
if (i < 3) if (i < 3)
quest = file->quest(i); quest = file->quest(i);
else else
@ -28,7 +28,7 @@ void ALTTPFileWriter::writeFile(ALTTPFile* file) {
writeOverworldEvent(quest->overworldEvent(j)); writeOverworldEvent(quest->overworldEvent(j));
} }
writeBytes((atInt8*)&quest->inventory(), sizeof(ALTTPInventory)); writeBytes((int8_t*)&quest->inventory(), sizeof(ALTTPInventory));
writeUint16(quest->rupeeMax()); writeUint16(quest->rupeeMax());
writeUint16(quest->rupeeCurrent()); writeUint16(quest->rupeeCurrent());
writeDungeonItems(quest->compasses()); writeDungeonItems(quest->compasses());
@ -44,7 +44,7 @@ void ALTTPFileWriter::writeFile(ALTTPFile* file) {
writeByte(quest->healthFiller()); writeByte(quest->healthFiller());
writeByte(quest->magicFiller()); writeByte(quest->magicFiller());
ALTTPPendants pendants = quest->pendants(); ALTTPPendants pendants = quest->pendants();
atUint8 pendantsByte = 0; uint8_t pendantsByte = 0;
pendantsByte |= pendants.Courage; pendantsByte |= pendants.Courage;
pendantsByte |= pendants.Wisdom << 1; pendantsByte |= pendants.Wisdom << 1;
pendantsByte |= pendants.Power << 2; pendantsByte |= pendants.Power << 2;
@ -54,7 +54,7 @@ void ALTTPFileWriter::writeFile(ALTTPFile* file) {
writeByte(quest->arrows()); writeByte(quest->arrows());
seek(1); seek(1);
ALTTPAbilities abilities = quest->abilityFlags(); ALTTPAbilities abilities = quest->abilityFlags();
atUint8 abilitiesByte = 0; uint8_t abilitiesByte = 0;
abilitiesByte |= abilities.Nothing; abilitiesByte |= abilities.Nothing;
abilitiesByte |= abilities.Swim << 1; abilitiesByte |= abilities.Swim << 1;
abilitiesByte |= abilities.Dash << 2; abilitiesByte |= abilities.Dash << 2;
@ -65,23 +65,23 @@ void ALTTPFileWriter::writeFile(ALTTPFile* file) {
abilitiesByte |= abilities.Unknown2 << 7; abilitiesByte |= abilities.Unknown2 << 7;
writeUByte(abilitiesByte); writeUByte(abilitiesByte);
ALTTPCrystals crystals = quest->crystals(); ALTTPCrystals crystals = quest->crystals();
writeBytes((atInt8*)&crystals, sizeof(ALTTPCrystals)); writeBytes((int8_t*)&crystals, sizeof(ALTTPCrystals));
ALTTPMagicUsage magicUsage = quest->magicUsage(); ALTTPMagicUsage magicUsage = quest->magicUsage();
writeBytes((atInt8*)&magicUsage, sizeof(ALTTPMagicUsage)); writeBytes((int8_t*)&magicUsage, sizeof(ALTTPMagicUsage));
for (int j = 0; j < 0x010; j++) for (int j = 0; j < 0x010; j++)
writeByte(quest->dungeonKeys(j)); writeByte(quest->dungeonKeys(j));
seek(0x039); seek(0x039);
writeByte((atInt8)quest->progressIndicator()); writeByte((int8_t)quest->progressIndicator());
ALTTPProgressFlags1 progress1 = quest->progressFlags1(); ALTTPProgressFlags1 progress1 = quest->progressFlags1();
writeBytes((atInt8*)&progress1, sizeof(ALTTPProgressFlags1)); writeBytes((int8_t*)&progress1, sizeof(ALTTPProgressFlags1));
writeByte(quest->mapIcon()); writeByte(quest->mapIcon());
writeByte(quest->startLocation()); writeByte(quest->startLocation());
ALTTPProgressFlags2 progress2 = quest->progressFlags2(); ALTTPProgressFlags2 progress2 = quest->progressFlags2();
writeBytes((atInt8*)&progress2, sizeof(ALTTPProgressFlags2)); writeBytes((int8_t*)&progress2, sizeof(ALTTPProgressFlags2));
ALTTPLightDarkWorldIndicator indicator = quest->lightDarkWorldIndicator(); ALTTPLightDarkWorldIndicator indicator = quest->lightDarkWorldIndicator();
writeBytes((atInt8*)&indicator, 1); writeBytes((int8_t*)&indicator, 1);
seek(1); seek(1);
writeByte(quest->tagAlong()); writeByte(quest->tagAlong());
@ -111,7 +111,7 @@ void ALTTPFileWriter::writeFile(ALTTPFile* file) {
} }
void ALTTPFileWriter::writeRoomFlags(ALTTPRoomFlags* flags) { void ALTTPFileWriter::writeRoomFlags(ALTTPRoomFlags* flags) {
atUint8 flagsByte = 0; uint8_t flagsByte = 0;
flagsByte |= flags->Chest1; flagsByte |= flags->Chest1;
flagsByte |= flags->Chest2 << 1; flagsByte |= flags->Chest2 << 1;
flagsByte |= flags->Chest3 << 2; flagsByte |= flags->Chest3 << 2;
@ -134,7 +134,7 @@ void ALTTPFileWriter::writeRoomFlags(ALTTPRoomFlags* flags) {
} }
void ALTTPFileWriter::writeOverworldEvent(ALTTPOverworldEvent* event) { void ALTTPFileWriter::writeOverworldEvent(ALTTPOverworldEvent* event) {
atUint8 flagsByte = 0; uint8_t flagsByte = 0;
flagsByte |= event->Unused1; flagsByte |= event->Unused1;
flagsByte |= event->HeartPiece << 1; flagsByte |= event->HeartPiece << 1;
flagsByte |= event->Overlay << 2; flagsByte |= event->Overlay << 2;
@ -147,7 +147,7 @@ void ALTTPFileWriter::writeOverworldEvent(ALTTPOverworldEvent* event) {
} }
void ALTTPFileWriter::writeDungeonItems(ALTTPDungeonItemFlags flags) { void ALTTPFileWriter::writeDungeonItems(ALTTPDungeonItemFlags flags) {
atUint8 flagsByte = 0; uint8_t flagsByte = 0;
flagsByte |= flags.Unused1; flagsByte |= flags.Unused1;
flagsByte |= flags.Unused2 << 1; flagsByte |= flags.Unused2 << 1;
flagsByte |= flags.GanonsTower << 2; flagsByte |= flags.GanonsTower << 2;
@ -168,7 +168,7 @@ void ALTTPFileWriter::writeDungeonItems(ALTTPDungeonItemFlags flags) {
writeUByte(flagsByte); writeUByte(flagsByte);
} }
atUint16 ALTTPFileWriter::calculateChecksum(atUint32 game) { uint16_t ALTTPFileWriter::calculateChecksum(uint32_t game) {
/* /*
* ALTTP's checksum is very basic * ALTTP's checksum is very basic
* It adds each word up and then subtracts the sum from 0x5a5a * It adds each word up and then subtracts the sum from 0x5a5a
@ -185,11 +185,11 @@ atUint16 ALTTPFileWriter::calculateChecksum(atUint32 game) {
*/ */
// First we start at 0 // First we start at 0
atUint16 sum = 0; uint16_t sum = 0;
for (atUint32 i = 0; i < 0x4FE; i += 2) for (uint32_t i = 0; i < 0x4FE; i += 2)
// Add each word one by one // Add each word one by one
sum += *(atUint16*)(m_data + (i + (0x500 * game))); sum += *(uint16_t*)(m_data + (i + (0x500 * game)));
// Subtract it from 0x5a5a to get our true checksum // Subtract it from 0x5a5a to get our true checksum
return (0x5a5a - sum); return (0x5a5a - sum);

144
src/athena/ALTTPQuest.cpp
View File

@ -15,19 +15,19 @@ ALTTPQuest::~ALTTPQuest() {
void ALTTPQuest::setRoomFlags(std::vector<ALTTPRoomFlags*> rf) { m_roomFlags = rf; } void ALTTPQuest::setRoomFlags(std::vector<ALTTPRoomFlags*> rf) { m_roomFlags = rf; }
void ALTTPQuest::setRoomFlags(ALTTPRoomFlags* rf, atUint32 id) { m_roomFlags[id] = rf; } void ALTTPQuest::setRoomFlags(ALTTPRoomFlags* rf, uint32_t id) { m_roomFlags[id] = rf; }
std::vector<ALTTPRoomFlags*> ALTTPQuest::roomFlags() { return m_roomFlags; } std::vector<ALTTPRoomFlags*> ALTTPQuest::roomFlags() { return m_roomFlags; }
ALTTPRoomFlags* ALTTPQuest::roomFlags(atUint32 id) { return m_roomFlags[id]; } ALTTPRoomFlags* ALTTPQuest::roomFlags(uint32_t id) { return m_roomFlags[id]; }
void ALTTPQuest::setOverworldEvents(std::vector<ALTTPOverworldEvent*> ow) { m_overworldEvents = ow; } void ALTTPQuest::setOverworldEvents(std::vector<ALTTPOverworldEvent*> ow) { m_overworldEvents = ow; }
void ALTTPQuest::setOverworldEvents(ALTTPOverworldEvent* ow, atUint32 id) { m_overworldEvents[id] = ow; } void ALTTPQuest::setOverworldEvents(ALTTPOverworldEvent* ow, uint32_t id) { m_overworldEvents[id] = ow; }
std::vector<ALTTPOverworldEvent*> ALTTPQuest::overworldEvents() const { return m_overworldEvents; } std::vector<ALTTPOverworldEvent*> ALTTPQuest::overworldEvents() const { return m_overworldEvents; }
ALTTPOverworldEvent* ALTTPQuest::overworldEvent(atUint32 id) const { ALTTPOverworldEvent* ALTTPQuest::overworldEvent(uint32_t id) const {
if (id > m_overworldEvents.size() - 1) { if (id > m_overworldEvents.size() - 1) {
atWarning("index out of range"); atWarning("index out of range");
return nullptr; return nullptr;
@ -40,13 +40,13 @@ void ALTTPQuest::setInventory(const ALTTPInventory& inv) { m_inventory = inv; }
const ALTTPInventory& ALTTPQuest::inventory() const { return m_inventory; } const ALTTPInventory& ALTTPQuest::inventory() const { return m_inventory; }
void ALTTPQuest::setRupeeMax(atUint16 val) { m_rupeeMax = val; } void ALTTPQuest::setRupeeMax(uint16_t val) { m_rupeeMax = val; }
atUint16 ALTTPQuest::rupeeMax() const { return m_rupeeMax; } uint16_t ALTTPQuest::rupeeMax() const { return m_rupeeMax; }
void ALTTPQuest::setRupeeCurrent(atUint16 val) { m_rupeeCurrent = val; } void ALTTPQuest::setRupeeCurrent(uint16_t val) { m_rupeeCurrent = val; }
atUint16 ALTTPQuest::rupeeCurrent() const { return m_rupeeCurrent; } uint16_t ALTTPQuest::rupeeCurrent() const { return m_rupeeCurrent; }
void ALTTPQuest::setCompasses(ALTTPDungeonItemFlags flags) { m_compasses = flags; } void ALTTPQuest::setCompasses(ALTTPDungeonItemFlags flags) { m_compasses = flags; }
@ -60,55 +60,55 @@ void ALTTPQuest::setDungeonMaps(ALTTPDungeonItemFlags flags) { m_dungeonMaps = f
ALTTPDungeonItemFlags ALTTPQuest::dungeonMaps() const { return m_dungeonMaps; } ALTTPDungeonItemFlags ALTTPQuest::dungeonMaps() const { return m_dungeonMaps; }
void ALTTPQuest::setWishingPond(atUint16 val) { m_wishingPond = val; } void ALTTPQuest::setWishingPond(uint16_t val) { m_wishingPond = val; }
atUint16 ALTTPQuest::wishingPond() const { return m_wishingPond; } uint16_t ALTTPQuest::wishingPond() const { return m_wishingPond; }
void ALTTPQuest::setHealthMax(atUint8 val) { m_healthMax = val; } void ALTTPQuest::setHealthMax(uint8_t val) { m_healthMax = val; }
atUint8 ALTTPQuest::healthMax() const { return m_healthMax; } uint8_t ALTTPQuest::healthMax() const { return m_healthMax; }
void ALTTPQuest::setHealth(atUint8 val) { m_health = val; } void ALTTPQuest::setHealth(uint8_t val) { m_health = val; }
atUint8 ALTTPQuest::health() const { return m_health; } uint8_t ALTTPQuest::health() const { return m_health; }
void ALTTPQuest::setMagicPower(atUint8 val) { m_magicPower = val; } void ALTTPQuest::setMagicPower(uint8_t val) { m_magicPower = val; }
atUint8 ALTTPQuest::magicPower() const { return m_magicPower; } uint8_t ALTTPQuest::magicPower() const { return m_magicPower; }
void ALTTPQuest::setKeys(atUint8 val) { m_keys = val; } void ALTTPQuest::setKeys(uint8_t val) { m_keys = val; }
atUint8 ALTTPQuest::keys() const { return m_keys; } uint8_t ALTTPQuest::keys() const { return m_keys; }
void ALTTPQuest::setBombUpgrades(atUint8 val) { m_bombUpgrades = val; } void ALTTPQuest::setBombUpgrades(uint8_t val) { m_bombUpgrades = val; }
atUint8 ALTTPQuest::bombUpgrades() const { return m_bombUpgrades; } uint8_t ALTTPQuest::bombUpgrades() const { return m_bombUpgrades; }
void ALTTPQuest::setArrowUpgrades(atUint8 val) { m_arrowUpgrades = val; } void ALTTPQuest::setArrowUpgrades(uint8_t val) { m_arrowUpgrades = val; }
atUint8 ALTTPQuest::arrowUpgrades() const { return m_arrowUpgrades; } uint8_t ALTTPQuest::arrowUpgrades() const { return m_arrowUpgrades; }
void ALTTPQuest::setHealthFiller(atUint8 val) { m_heartFiller = val; } void ALTTPQuest::setHealthFiller(uint8_t val) { m_heartFiller = val; }
atUint8 ALTTPQuest::healthFiller() const { return m_heartFiller; } uint8_t ALTTPQuest::healthFiller() const { return m_heartFiller; }
void ALTTPQuest::setMagicFiller(atUint8 val) { m_heartFiller = val; } void ALTTPQuest::setMagicFiller(uint8_t val) { m_heartFiller = val; }
atUint8 ALTTPQuest::magicFiller() const { return m_heartFiller; } uint8_t ALTTPQuest::magicFiller() const { return m_heartFiller; }
void ALTTPQuest::setPendants(ALTTPPendants val) { m_pendants = val; } void ALTTPQuest::setPendants(ALTTPPendants val) { m_pendants = val; }
ALTTPPendants ALTTPQuest::pendants() const { return m_pendants; } ALTTPPendants ALTTPQuest::pendants() const { return m_pendants; }
void ALTTPQuest::setBombFiller(atUint8 val) { m_bombFiller = val; } void ALTTPQuest::setBombFiller(uint8_t val) { m_bombFiller = val; }
atUint8 ALTTPQuest::bombFiller() const { return m_bombFiller; } uint8_t ALTTPQuest::bombFiller() const { return m_bombFiller; }
void ALTTPQuest::setArrowFiller(atUint8 val) { m_arrowFiller = val; } void ALTTPQuest::setArrowFiller(uint8_t val) { m_arrowFiller = val; }
atUint8 ALTTPQuest::arrowFiller() const { return m_arrowFiller; } uint8_t ALTTPQuest::arrowFiller() const { return m_arrowFiller; }
void ALTTPQuest::setArrows(atUint8 val) { m_arrows = val; } void ALTTPQuest::setArrows(uint8_t val) { m_arrows = val; }
atUint8 ALTTPQuest::arrows() const { return m_arrows; } uint8_t ALTTPQuest::arrows() const { return m_arrows; }
void ALTTPQuest::setAbilityFlags(ALTTPAbilities val) { m_abilityFlags = val; } void ALTTPQuest::setAbilityFlags(ALTTPAbilities val) { m_abilityFlags = val; }
@ -122,9 +122,9 @@ void ALTTPQuest::setMagicUsage(ALTTPMagicUsage val) { m_magicUsage = val; }
ALTTPMagicUsage ALTTPQuest::magicUsage() const { return m_magicUsage; } ALTTPMagicUsage ALTTPQuest::magicUsage() const { return m_magicUsage; }
void ALTTPQuest::setDungeonKeys(std::vector<atUint8> val) { m_dungeonKeys = val; } void ALTTPQuest::setDungeonKeys(std::vector<uint8_t> val) { m_dungeonKeys = val; }
void ALTTPQuest::setDungeonKeys(atUint32 id, atUint8 val) { void ALTTPQuest::setDungeonKeys(uint32_t id, uint8_t val) {
if (id > m_dungeonKeys.size() - 1) { if (id > m_dungeonKeys.size() - 1) {
atWarning("index out of range"); atWarning("index out of range");
return; return;
@ -133,7 +133,7 @@ void ALTTPQuest::setDungeonKeys(atUint32 id, atUint8 val) {
m_dungeonKeys[id] = val; m_dungeonKeys[id] = val;
} }
atUint8 ALTTPQuest::dungeonKeys(atUint32 id) const { uint8_t ALTTPQuest::dungeonKeys(uint32_t id) const {
if (id > m_dungeonKeys.size() - 1) { if (id > m_dungeonKeys.size() - 1) {
atWarning("index out of range"); atWarning("index out of range");
return 0; return 0;
@ -142,7 +142,7 @@ atUint8 ALTTPQuest::dungeonKeys(atUint32 id) const {
return m_dungeonKeys[id]; return m_dungeonKeys[id];
} }
atUint32 ALTTPQuest::dungeonCount() const { return (atUint32)m_dungeonKeys.size(); } uint32_t ALTTPQuest::dungeonCount() const { return (uint32_t)m_dungeonKeys.size(); }
void ALTTPQuest::setProgressIndicator(ALTTPProgressIndicator val) { m_progressIndicator = val; } void ALTTPQuest::setProgressIndicator(ALTTPProgressIndicator val) { m_progressIndicator = val; }
@ -172,9 +172,9 @@ void ALTTPQuest::setTagAlong(ALTTPTagAlong val) { m_tagAlong = val; }
ALTTPTagAlong ALTTPQuest::tagAlong() const { return m_tagAlong; } ALTTPTagAlong ALTTPQuest::tagAlong() const { return m_tagAlong; }
void ALTTPQuest::setOldManFlags(std::vector<atUint8> flags) { m_oldManFlags = flags; } void ALTTPQuest::setOldManFlags(std::vector<uint8_t> flags) { m_oldManFlags = flags; }
void ALTTPQuest::setOldManFlag(atUint32 id, atUint8 val) { void ALTTPQuest::setOldManFlag(uint32_t id, uint8_t val) {
if (id > m_oldManFlags.size() - 1) { if (id > m_oldManFlags.size() - 1) {
atWarning("index out of range"); atWarning("index out of range");
return; return;
@ -183,7 +183,7 @@ void ALTTPQuest::setOldManFlag(atUint32 id, atUint8 val) {
m_oldManFlags[id] = val; m_oldManFlags[id] = val;
} }
atUint8 ALTTPQuest::oldManFlag(atUint32 id) { uint8_t ALTTPQuest::oldManFlag(uint32_t id) {
if (id > m_oldManFlags.size() - 1) { if (id > m_oldManFlags.size() - 1) {
atWarning("index out of range"); atWarning("index out of range");
return 0; return 0;
@ -191,15 +191,15 @@ atUint8 ALTTPQuest::oldManFlag(atUint32 id) {
return m_oldManFlags[id]; return m_oldManFlags[id];
} }
atUint32 ALTTPQuest::oldManFlagCount() const { return (atUint32)m_oldManFlags.size(); } uint32_t ALTTPQuest::oldManFlagCount() const { return (uint32_t)m_oldManFlags.size(); }
void ALTTPQuest::setBombFlag(atUint8 flag) { m_bombFlag = flag; } void ALTTPQuest::setBombFlag(uint8_t flag) { m_bombFlag = flag; }
atUint8 ALTTPQuest::bombFlag() const { return m_bombFlag; } uint8_t ALTTPQuest::bombFlag() const { return m_bombFlag; }
void ALTTPQuest::setUnknown1(std::vector<atUint8> flags) { m_unknown1 = flags; } void ALTTPQuest::setUnknown1(std::vector<uint8_t> flags) { m_unknown1 = flags; }
void ALTTPQuest::setUnknown1(atUint32 id, atUint8 val) { void ALTTPQuest::setUnknown1(uint32_t id, uint8_t val) {
if (id > m_unknown1.size()) { if (id > m_unknown1.size()) {
atWarning("index out of range"); atWarning("index out of range");
return; return;
@ -208,7 +208,7 @@ void ALTTPQuest::setUnknown1(atUint32 id, atUint8 val) {
m_unknown1[id] = val; m_unknown1[id] = val;
} }
atUint8 ALTTPQuest::unknown1(atUint32 id) { uint8_t ALTTPQuest::unknown1(uint32_t id) {
if (id > m_unknown1.size()) { if (id > m_unknown1.size()) {
atWarning("index out of range"); atWarning("index out of range");
return 0; return 0;
@ -217,9 +217,9 @@ atUint8 ALTTPQuest::unknown1(atUint32 id) {
return m_unknown1[id]; return m_unknown1[id];
} }
atUint32 ALTTPQuest::unknown1Count() const { return (atUint32)m_unknown1.size(); } uint32_t ALTTPQuest::unknown1Count() const { return (uint32_t)m_unknown1.size(); }
void ALTTPQuest::setPlayerName(std::vector<atUint16> playerName) { m_playerName = playerName; } void ALTTPQuest::setPlayerName(std::vector<uint16_t> playerName) { m_playerName = playerName; }
void ALTTPQuest::setPlayerName(const std::string& playerName) { void ALTTPQuest::setPlayerName(const std::string& playerName) {
if (playerName == std::string() || playerName.size() > 6) { if (playerName == std::string() || playerName.size() > 6) {
@ -229,9 +229,9 @@ void ALTTPQuest::setPlayerName(const std::string& playerName) {
m_playerName.clear(); m_playerName.clear();
for (atUint32 i = 0; i < 6; i++) { for (uint32_t i = 0; i < 6; i++) {
if (i > playerName.size() - 1) { if (i > playerName.size() - 1) {
m_playerName.push_back((atUint16)0xA9); m_playerName.push_back((uint16_t)0xA9);
continue; continue;
} }
@ -239,19 +239,19 @@ void ALTTPQuest::setPlayerName(const std::string& playerName) {
if (c >= 'A' && c <= 'P' && c != 'I') { if (c >= 'A' && c <= 'P' && c != 'I') {
m_playerName.push_back((atUint16)(c - 'A')); m_playerName.push_back((uint16_t)(c - 'A'));
continue; continue;
} }
if (c >= 'Q' && c <= 'Z') { if (c >= 'Q' && c <= 'Z') {
std::cout << std::hex << (atUint16)((c - 'Q') + 0x20) << std::endl; std::cout << std::hex << (uint16_t)((c - 'Q') + 0x20) << std::endl;
m_playerName.push_back((atUint16)((c - 'Q') + 0x20)); m_playerName.push_back((uint16_t)((c - 'Q') + 0x20));
continue; continue;
} }
if (c >= 'a' && c <= 'f') { if (c >= 'a' && c <= 'f') {
std::cout << std::hex << (atUint16)((c - 'a') + 0x2A) << std::endl; std::cout << std::hex << (uint16_t)((c - 'a') + 0x2A) << std::endl;
m_playerName.push_back((atUint16)((c - 'a') + 0x2A)); m_playerName.push_back((uint16_t)((c - 'a') + 0x2A));
continue; continue;
} }
@ -266,22 +266,22 @@ void ALTTPQuest::setPlayerName(const std::string& playerName) {
continue; continue;
} }
m_playerName.push_back((atUint16)((c - 'g') + 0x40)); m_playerName.push_back((uint16_t)((c - 'g') + 0x40));
continue; continue;
} }
if (c >= 'w' && c <= 'z') { if (c >= 'w' && c <= 'z') {
m_playerName.push_back((atUint16)((c - 'w') + 0x60)); m_playerName.push_back((uint16_t)((c - 'w') + 0x60));
continue; continue;
} }
if (c >= '0' && c <= '9') { if (c >= '0' && c <= '9') {
m_playerName.push_back((atUint16)((c - '0') + 0x64)); m_playerName.push_back((uint16_t)((c - '0') + 0x64));
continue; continue;
} }
if (c == '-' || c == '.') { if (c == '-' || c == '.') {
m_playerName.push_back((atUint16)(c - '-') + 0x80); m_playerName.push_back((uint16_t)(c - '-') + 0x80);
continue; continue;
} }
@ -313,12 +313,12 @@ void ALTTPQuest::setPlayerName(const std::string& playerName) {
} }
} }
std::vector<atUint16> ALTTPQuest::playerName() const { return m_playerName; } std::vector<uint16_t> ALTTPQuest::playerName() const { return m_playerName; }
std::string ALTTPQuest::playerNameToString() const { std::string ALTTPQuest::playerNameToString() const {
std::string ret; std::string ret;
for (atInt16 c : m_playerName) { for (int16_t c : m_playerName) {
if (c >= 0x00 && c <= 0x0F) { if (c >= 0x00 && c <= 0x0F) {
ret.push_back((char)('A' + c)); ret.push_back((char)('A' + c));
continue; continue;
@ -397,9 +397,9 @@ void ALTTPQuest::setValid(bool val) { m_valid = val; }
bool ALTTPQuest::valid() { return m_valid; } bool ALTTPQuest::valid() { return m_valid; }
void ALTTPQuest::setDungeonDeathTotals(std::vector<atUint16> val) { m_dungeonDeathTotals = val; } void ALTTPQuest::setDungeonDeathTotals(std::vector<uint16_t> val) { m_dungeonDeathTotals = val; }
void ALTTPQuest::setDungeonDeathTotal(atUint32 id, atUint16 val) { void ALTTPQuest::setDungeonDeathTotal(uint32_t id, uint16_t val) {
if (id > m_dungeonDeathTotals.size()) { if (id > m_dungeonDeathTotals.size()) {
atWarning("index out of range"); atWarning("index out of range");
return; return;
@ -408,7 +408,7 @@ void ALTTPQuest::setDungeonDeathTotal(atUint32 id, atUint16 val) {
m_dungeonDeathTotals[id] = val; m_dungeonDeathTotals[id] = val;
} }
atUint16 ALTTPQuest::dungeonDeathTotal(atUint32 id) const { uint16_t ALTTPQuest::dungeonDeathTotal(uint32_t id) const {
if (id > m_dungeonDeathTotals.size()) { if (id > m_dungeonDeathTotals.size()) {
atWarning("index out of range"); atWarning("index out of range");
return 0; return 0;
@ -417,21 +417,21 @@ atUint16 ALTTPQuest::dungeonDeathTotal(atUint32 id) const {
return m_dungeonDeathTotals[id]; return m_dungeonDeathTotals[id];
} }
atUint16 ALTTPQuest::dungeonDeathTotalCount() const { return (atUint16)m_dungeonDeathTotals.size(); } uint16_t ALTTPQuest::dungeonDeathTotalCount() const { return (uint16_t)m_dungeonDeathTotals.size(); }
void ALTTPQuest::setUnknown2(atUint16 val) { m_unknown2 = val; } void ALTTPQuest::setUnknown2(uint16_t val) { m_unknown2 = val; }
atUint16 ALTTPQuest::unknown2() const { return m_unknown2; } uint16_t ALTTPQuest::unknown2() const { return m_unknown2; }
void ALTTPQuest::setDeathSaveCount(atUint16 val) { m_deathSaveCount = val; } void ALTTPQuest::setDeathSaveCount(uint16_t val) { m_deathSaveCount = val; }
atUint16 ALTTPQuest::deathSaveCount() const { return m_deathSaveCount; } uint16_t ALTTPQuest::deathSaveCount() const { return m_deathSaveCount; }
void ALTTPQuest::setPostGameDeathCounter(atInt16 val) { m_postGameDeathCounter = val; } void ALTTPQuest::setPostGameDeathCounter(int16_t val) { m_postGameDeathCounter = val; }
atInt16 ALTTPQuest::postGameDeathCounter() const { return m_postGameDeathCounter; } int16_t ALTTPQuest::postGameDeathCounter() const { return m_postGameDeathCounter; }
void ALTTPQuest::setChecksum(atUint16 checksum) { m_checksum = checksum; } void ALTTPQuest::setChecksum(uint16_t checksum) { m_checksum = checksum; }
atUint16 ALTTPQuest::checksum() const { return m_checksum; } uint16_t ALTTPQuest::checksum() const { return m_checksum; }
} // namespace athena } // namespace athena

26
src/athena/Checksums.cpp
View File

@ -1,8 +1,8 @@
#include "athena/Checksums.hpp" #include "athena/Checksums.hpp"
namespace athena::checksums { namespace athena::checksums {
atUint64 crc64(const atUint8* data, atUint64 length, atUint64 seed, atUint64 final) { uint64_t crc64(const uint8_t* data, uint64_t length, uint64_t seed, uint64_t final) {
static const atUint64 crc64Table[256] = { static const uint64_t crc64Table[256] = {
0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5, 0x493366450E42ECDF, 0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5, 0x493366450E42ECDF,
0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A, 0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D,
0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x17870F5D4F51B498, 0x5577EEB6E6BB820B, 0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847,
@ -60,7 +60,7 @@ atUint64 crc64(const atUint8* data, atUint64 length, atUint64 seed, atUint64 fin
if (!data) if (!data)
return seed; return seed;
atUint64 checksum = seed; uint64_t checksum = seed;
int pos = 0; int pos = 0;
while (length--) while (length--)
@ -69,8 +69,8 @@ atUint64 crc64(const atUint8* data, atUint64 length, atUint64 seed, atUint64 fin
return checksum ^ final; return checksum ^ final;
} }
atUint32 crc32(const atUint8* data, atUint64 length, atUint32 seed, atUint32 final) { uint32_t crc32(const uint8_t* data, uint64_t length, uint32_t seed, uint32_t final) {
static const atUint32 crc32Table[256] = { static const uint32_t crc32Table[256] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832,
0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A,
@ -104,7 +104,7 @@ atUint32 crc32(const atUint8* data, atUint64 length, atUint32 seed, atUint32 fin
if (!data) if (!data)
return seed; return seed;
atUint32 checksum = seed; uint32_t checksum = seed;
int pos = 0; int pos = 0;
while (length--) while (length--)
@ -113,8 +113,8 @@ atUint32 crc32(const atUint8* data, atUint64 length, atUint32 seed, atUint32 fin
return checksum ^ final; return checksum ^ final;
} }
atUint16 crc16CCITT(const atUint8* data, atUint64 length, atUint16 seed, atUint16 final) { uint16_t crc16CCITT(const uint8_t* data, uint64_t length, uint16_t seed, uint16_t final) {
static const atUint16 crc16CCITTTable[256] = { static const uint16_t crc16CCITTTable[256] = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad,
0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a,
0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b,
@ -135,7 +135,7 @@ atUint16 crc16CCITT(const atUint8* data, atUint64 length, atUint16 seed, atUint1
0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74,
0x2e93, 0x3eb2, 0x0ed1, 0x1ef0}; 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0};
atUint16 checksum = seed; uint16_t checksum = seed;
int pos = 0; int pos = 0;
while (length--) while (length--)
@ -144,12 +144,12 @@ atUint16 crc16CCITT(const atUint8* data, atUint64 length, atUint16 seed, atUint1
return checksum ^ final; return checksum ^ final;
} }
atUint16 crc16(const atUint8* data, atUint64 length, atUint16 seed, atUint64 final) { uint16_t crc16(const uint8_t* data, uint64_t length, uint16_t seed, uint64_t final) {
if (data == nullptr) { if (data == nullptr) {
return seed; return seed;
} }
static const atUint16 crc16Table[256] = { static const uint16_t crc16Table[256] = {
0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1,
0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40,
0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1,
@ -170,8 +170,8 @@ atUint16 crc16(const atUint8* data, atUint64 length, atUint16 seed, atUint64 fin
0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341,
0x4100, 0x81C1, 0x8081, 0x4040}; 0x4100, 0x81C1, 0x8081, 0x4040};
atInt32 pos = 0; int32_t pos = 0;
atUint16 checksum = seed; uint16_t checksum = seed;
while (length--) while (length--)
checksum = (crc16Table[(checksum ^ data[pos++]) & 0xFF] ^ (checksum >> 8)); checksum = (crc16Table[(checksum ^ data[pos++]) & 0xFF] ^ (checksum >> 8));

86
src/athena/Compression.cpp
View File

@ -10,7 +10,7 @@
namespace athena::io::Compression { namespace athena::io::Compression {
void zlibInitZStrm(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen, z_stream& strm) { void zlibInitZStrm(const uint8_t* src, uint32_t srcLen, uint8_t* dst, uint32_t dstLen, z_stream& strm) {
strm.avail_in = srcLen; strm.avail_in = srcLen;
strm.avail_out = dstLen; strm.avail_out = dstLen;
strm.next_in = const_cast<Bytef*>(src); strm.next_in = const_cast<Bytef*>(src);
@ -19,8 +19,8 @@ void zlibInitZStrm(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 d
strm.zfree = Z_NULL; strm.zfree = Z_NULL;
strm.opaque = Z_NULL; strm.opaque = Z_NULL;
} }
atInt32 zlibInflate(z_stream& strm, atInt32 bits) { int32_t zlibInflate(z_stream& strm, int32_t bits) {
atInt32 ret = inflateInit2(&strm, bits); int32_t ret = inflateInit2(&strm, bits);
if (ret == Z_OK) { if (ret == Z_OK) {
ret = inflate(&strm, Z_FINISH); ret = inflate(&strm, Z_FINISH);
if (ret == Z_STREAM_END) { if (ret == Z_STREAM_END) {
@ -29,12 +29,12 @@ atInt32 zlibInflate(z_stream& strm, atInt32 bits) {
} }
return ret; return ret;
} }
atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) { int32_t decompressZlib(const uint8_t* src, uint32_t srcLen, uint8_t* dst, uint32_t dstLen) {
z_stream strm = {}; z_stream strm = {};
zlibInitZStrm(src, srcLen, dst, dstLen, strm); zlibInitZStrm(src, srcLen, dst, dstLen, strm);
// 15 window bits, and the | 16 tells zlib to to detect if using gzip or zlib // 15 window bits, and the | 16 tells zlib to to detect if using gzip or zlib
atInt32 ret = zlibInflate(strm, MAX_WBITS | 16); int32_t ret = zlibInflate(strm, MAX_WBITS | 16);
if (ret != Z_STREAM_END) { if (ret != Z_STREAM_END) {
// Try again without gzip // Try again without gzip
zlibInitZStrm(src, srcLen, dst, dstLen, strm); zlibInitZStrm(src, srcLen, dst, dstLen, strm);
@ -49,7 +49,7 @@ atInt32 decompressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint
return ret; return ret;
} }
atInt32 compressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32 dstLen) { int32_t compressZlib(const uint8_t* src, uint32_t srcLen, uint8_t* dst, uint32_t dstLen) {
z_stream strm = {}; z_stream strm = {};
strm.total_in = strm.avail_in = srcLen; strm.total_in = strm.avail_in = srcLen;
strm.total_out = strm.avail_out = dstLen; strm.total_out = strm.avail_out = dstLen;
@ -60,8 +60,8 @@ atInt32 compressZlib(const atUint8* src, atUint32 srcLen, atUint8* dst, atUint32
strm.zfree = Z_NULL; strm.zfree = Z_NULL;
strm.opaque = Z_NULL; strm.opaque = Z_NULL;
atInt32 err = -1; int32_t err = -1;
atInt32 ret = -1; int32_t ret = -1;
err = deflateInit(&strm, Z_BEST_COMPRESSION); err = deflateInit(&strm, Z_BEST_COMPRESSION);
@ -97,11 +97,11 @@ atInt32 decompressLZO(const atUint8* source, const atInt32 sourceSize, atUint8*
// src points to the yaz0 source data (to the "real" source data, not at the header!) // src points to the yaz0 source data (to the "real" source data, not at the header!)
// dst points to a buffer uncompressedSize bytes large (you get uncompressedSize from // dst points to a buffer uncompressedSize bytes large (you get uncompressedSize from
// the second 4 bytes in the Yaz0 header). // the second 4 bytes in the Yaz0 header).
atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize) { uint32_t yaz0Decode(const uint8_t* src, uint8_t* dst, uint32_t uncompressedSize) {
atUint32 srcPlace = 0, dstPlace = 0; // current read/write positions uint32_t srcPlace = 0, dstPlace = 0; // current read/write positions
atInt32 validBitCount = 0; // number of valid bits left in "code" byte int32_t validBitCount = 0; // number of valid bits left in "code" byte
atUint8 currCodeByte; uint8_t currCodeByte;
while (dstPlace < uncompressedSize) { while (dstPlace < uncompressedSize) {
// read new "code" byte if the current one is used up // read new "code" byte if the current one is used up
@ -118,14 +118,14 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize)
srcPlace++; srcPlace++;
} else { } else {
// RLE part // RLE part
atUint8 byte1 = src[srcPlace]; uint8_t byte1 = src[srcPlace];
atUint8 byte2 = src[srcPlace + 1]; uint8_t byte2 = src[srcPlace + 1];
srcPlace += 2; srcPlace += 2;
atUint32 dist = ((byte1 & 0xF) << 8) | byte2; uint32_t dist = ((byte1 & 0xF) << 8) | byte2;
atUint32 copySource = dstPlace - (dist + 1); uint32_t copySource = dstPlace - (dist + 1);
atUint32 numBytes = byte1 >> 4; uint32_t numBytes = byte1 >> 4;
if (numBytes == 0) { if (numBytes == 0) {
numBytes = src[srcPlace] + 0x12; numBytes = src[srcPlace] + 0x12;
@ -134,7 +134,7 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize)
numBytes += 2; numBytes += 2;
// copy run // copy run
for (atUint32 i = 0; i < numBytes; ++i) { for (uint32_t i = 0; i < numBytes; ++i) {
dst[dstPlace] = dst[copySource]; dst[dstPlace] = dst[copySource];
copySource++; copySource++;
dstPlace++; dstPlace++;
@ -151,25 +151,25 @@ atUint32 yaz0Decode(const atUint8* src, atUint8* dst, atUint32 uncompressedSize)
// Yaz0 encode // Yaz0 encode
typedef struct { typedef struct {
atUint32 srcPos, dstPos; uint32_t srcPos, dstPos;
} yaz0_Ret; } yaz0_Ret;
atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos); uint32_t simpleEnc(const uint8_t* src, int32_t size, int32_t pos, uint32_t* pMatchPos);
atUint32 nintendoEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos); uint32_t nintendoEnc(const uint8_t* src, int32_t size, int32_t pos, uint32_t* pMatchPos);
atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) { uint32_t yaz0Encode(const uint8_t* src, uint32_t srcSize, uint8_t* data) {
yaz0_Ret r = {0, 0}; yaz0_Ret r = {0, 0};
atInt32 pos = 0; int32_t pos = 0;
atUint8 dst[24]; // 8 codes * 3 bytes maximum uint8_t dst[24]; // 8 codes * 3 bytes maximum
atUint32 dstSize = 0; uint32_t dstSize = 0;
atUint32 i; uint32_t i;
atUint32 validBitCount = 0; // number of valid bits left in "code" byte uint32_t validBitCount = 0; // number of valid bits left in "code" byte
atUint8 currCodeByte = 0; uint8_t currCodeByte = 0;
while (r.srcPos < srcSize) { while (r.srcPos < srcSize) {
atUint32 numBytes; uint32_t numBytes;
atUint32 matchPos; uint32_t matchPos;
numBytes = nintendoEnc(src, srcSize, r.srcPos, &matchPos); numBytes = nintendoEnc(src, srcSize, r.srcPos, &matchPos);
if (numBytes < 3) { if (numBytes < 3) {
@ -181,8 +181,8 @@ atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) {
currCodeByte |= (0x80 >> validBitCount); currCodeByte |= (0x80 >> validBitCount);
} else { } else {
// RLE part // RLE part
atUint32 dist = r.srcPos - matchPos - 1; uint32_t dist = r.srcPos - matchPos - 1;
atUint8 byte1, byte2, byte3; uint8_t byte1, byte2, byte3;
if (numBytes >= 0x12) // 3 byte encoding if (numBytes >= 0x12) // 3 byte encoding
{ {
@ -244,11 +244,11 @@ atUint32 yaz0Encode(const atUint8* src, atUint32 srcSize, atUint8* data) {
} }
// a lookahead encoding scheme for ngc Yaz0 // a lookahead encoding scheme for ngc Yaz0
atUint32 nintendoEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos) { uint32_t nintendoEnc(const uint8_t* src, int32_t size, int32_t pos, uint32_t* pMatchPos) {
atUint32 numBytes = 1; uint32_t numBytes = 1;
static atUint32 numBytes1; static uint32_t numBytes1;
static atUint32 matchPos; static uint32_t matchPos;
static atInt32 prevFlag = 0; static int32_t prevFlag = 0;
// if prevFlag is set, it means that the previous position was determined by look-ahead try. // if prevFlag is set, it means that the previous position was determined by look-ahead try.
// so just use it. this is not the best optimization, but nintendo's choice for speed. // so just use it. this is not the best optimization, but nintendo's choice for speed.
@ -278,10 +278,10 @@ atUint32 nintendoEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pM
} }
// simple and straight encoding scheme for Yaz0 // simple and straight encoding scheme for Yaz0
atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMatchPos) { uint32_t simpleEnc(const uint8_t* src, int32_t size, int32_t pos, uint32_t* pMatchPos) {
int startPos = pos - 0x1000, j, i; int startPos = pos - 0x1000, j, i;
atUint32 numBytes = 1; uint32_t numBytes = 1;
atUint32 matchPos = 0; uint32_t matchPos = 0;
if (startPos < 0) if (startPos < 0)
startPos = 0; startPos = 0;
@ -292,7 +292,7 @@ atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMat
break; break;
} }
if ((atUint32)j > numBytes) { if ((uint32_t)j > numBytes) {
numBytes = j; numBytes = j;
matchPos = i; matchPos = i;
} }
@ -306,7 +306,7 @@ atUint32 simpleEnc(const atUint8* src, atInt32 size, atInt32 pos, atUint32* pMat
return numBytes; return numBytes;
} }
atUint32 decompressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst) { uint32_t decompressLZ77(const uint8_t* src, uint32_t srcLen, uint8_t** dst) {
if (*src == 0x11) { if (*src == 0x11) {
return LZType11().decompress(src, dst, srcLen); return LZType11().decompress(src, dst, srcLen);
} }
@ -314,7 +314,7 @@ atUint32 decompressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst) {
return LZType10(2).decompress(src, dst, srcLen); return LZType10(2).decompress(src, dst, srcLen);
} }
atUint32 compressLZ77(const atUint8* src, atUint32 srcLen, atUint8** dst, bool extended) { uint32_t compressLZ77(const uint8_t* src, uint32_t srcLen, uint8_t** dst, bool extended) {
if (extended) if (extended)
return LZType11().compress(src, dst, srcLen); return LZType11().compress(src, dst, srcLen);

2
src/athena/Dir.cpp
View File

@ -50,7 +50,7 @@ bool Dir::rm(std::string_view path) { return !(remove((m_path + "/" + path.data(
bool Dir::touch() { bool Dir::touch() {
std::srand(std::time(nullptr)); std::srand(std::time(nullptr));
atUint64 tmp = utility::rand64(); uint64_t tmp = utility::rand64();
std::string tmpFile = std::format("{:016X}.tmp", tmp); std::string tmpFile = std::format("{:016X}.tmp", tmp);
bool ret = FileInfo(m_path + "/" + tmpFile).touch(); bool ret = FileInfo(m_path + "/" + tmpFile).touch();
if (ret) if (ret)

2
src/athena/FileInfo.cpp
View File

@ -69,7 +69,7 @@ std::string FileInfo::extension() const {
return m_path.substr(pos + 1); return m_path.substr(pos + 1);
} }
atUint64 FileInfo::size() const { return utility::fileSize(m_path); } uint64_t FileInfo::size() const { return utility::fileSize(m_path); }
bool FileInfo::exists() const { bool FileInfo::exists() const {
atStat64_t st; atStat64_t st;

38
src/athena/FileReaderWin32.cpp
View File

@ -8,14 +8,14 @@
#include "win32_largefilewrapper.h" #include "win32_largefilewrapper.h"
namespace athena::io { namespace athena::io {
FileReader::FileReader(std::string_view filename, atInt32 cacheSize, bool globalErr) FileReader::FileReader(std::string_view filename, int32_t cacheSize, bool globalErr)
: m_fileHandle(nullptr), m_cacheData(nullptr), m_offset(0), m_globalErr(globalErr) { : m_fileHandle(nullptr), m_cacheData(nullptr), m_offset(0), m_globalErr(globalErr) {
m_filename = utility::utf8ToWide(filename); m_filename = utility::utf8ToWide(filename);
open(); open();
setCacheSize(cacheSize); setCacheSize(cacheSize);
} }
FileReader::FileReader(std::wstring_view filename, atInt32 cacheSize, bool globalErr) FileReader::FileReader(std::wstring_view filename, int32_t cacheSize, bool globalErr)
: m_fileHandle(nullptr), m_cacheData(nullptr), m_offset(0), m_globalErr(globalErr) { : m_fileHandle(nullptr), m_cacheData(nullptr), m_offset(0), m_globalErr(globalErr) {
m_filename = filename; m_filename = filename;
open(); open();
@ -64,13 +64,13 @@ void FileReader::close() {
return; return;
} }
void FileReader::seek(atInt64 pos, SeekOrigin origin) { void FileReader::seek(int64_t pos, SeekOrigin origin) {
if (!isOpen()) if (!isOpen())
return; return;
// check block position // check block position
if (m_blockSize > 0) { if (m_blockSize > 0) {
atUint64 oldOff = m_offset; uint64_t oldOff = m_offset;
switch (origin) { switch (origin) {
case SeekOrigin::Begin: case SeekOrigin::Begin:
m_offset = pos; m_offset = pos;
@ -97,7 +97,7 @@ void FileReader::seek(atInt64 pos, SeekOrigin origin) {
SetFilePointerEx(m_fileHandle, li, nullptr, FILE_BEGIN); SetFilePointerEx(m_fileHandle, li, nullptr, FILE_BEGIN);
DWORD readSz; DWORD readSz;
ReadFile(m_fileHandle, m_cacheData.get(), m_blockSize, &readSz, nullptr); ReadFile(m_fileHandle, m_cacheData.get(), m_blockSize, &readSz, nullptr);
m_curBlock = (atInt32)block; m_curBlock = (int32_t)block;
} }
} else { } else {
LARGE_INTEGER li; LARGE_INTEGER li;
@ -110,7 +110,7 @@ void FileReader::seek(atInt64 pos, SeekOrigin origin) {
} }
} }
atUint64 FileReader::position() const { uint64_t FileReader::position() const {
if (!isOpen()) { if (!isOpen()) {
if (m_globalErr) if (m_globalErr)
atError("File not open"); atError("File not open");
@ -127,7 +127,7 @@ atUint64 FileReader::position() const {
} }
} }
atUint64 FileReader::length() const { uint64_t FileReader::length() const {
if (!isOpen()) { if (!isOpen()) {
if (m_globalErr) if (m_globalErr)
atError("File not open"); atError("File not open");
@ -139,7 +139,7 @@ atUint64 FileReader::length() const {
return res.QuadPart; return res.QuadPart;
} }
atUint64 FileReader::readUBytesToBuf(void* buf, atUint64 len) { uint64_t FileReader::readUBytesToBuf(void* buf, uint64_t len) {
if (!isOpen()) { if (!isOpen()) {
if (m_globalErr) if (m_globalErr)
atError("File not open for reading"); atError("File not open for reading");
@ -154,16 +154,16 @@ atUint64 FileReader::readUBytesToBuf(void* buf, atUint64 len) {
} else { } else {
LARGE_INTEGER fs; LARGE_INTEGER fs;
GetFileSizeEx(m_fileHandle, &fs); GetFileSizeEx(m_fileHandle, &fs);
if (m_offset >= atUint64(fs.QuadPart)) if (m_offset >= uint64_t(fs.QuadPart))
return 0; return 0;
if (m_offset + len >= atUint64(fs.QuadPart)) if (m_offset + len >= uint64_t(fs.QuadPart))
len = fs.QuadPart - m_offset; len = fs.QuadPart - m_offset;
size_t block = m_offset / m_blockSize; size_t block = m_offset / m_blockSize;
atUint64 cacheOffset = m_offset % m_blockSize; uint64_t cacheOffset = m_offset % m_blockSize;
atUint64 cacheSize; uint64_t cacheSize;
atUint64 rem = len; uint64_t rem = len;
atUint8* dst = (atUint8*)buf; uint8_t* dst = (uint8_t*)buf;
while (rem) { while (rem) {
if (block != m_curBlock) { if (block != m_curBlock) {
@ -172,7 +172,7 @@ atUint64 FileReader::readUBytesToBuf(void* buf, atUint64 len) {
SetFilePointerEx(m_fileHandle, li, nullptr, FILE_BEGIN); SetFilePointerEx(m_fileHandle, li, nullptr, FILE_BEGIN);
DWORD readSz; DWORD readSz;
ReadFile(m_fileHandle, m_cacheData.get(), m_blockSize, &readSz, nullptr); ReadFile(m_fileHandle, m_cacheData.get(), m_blockSize, &readSz, nullptr);
m_curBlock = (atInt32)block; m_curBlock = (int32_t)block;
} }
cacheSize = rem; cacheSize = rem;
@ -186,19 +186,19 @@ atUint64 FileReader::readUBytesToBuf(void* buf, atUint64 len) {
++block; ++block;
} }
m_offset += len; m_offset += len;
return dst - (atUint8*)buf; return dst - (uint8_t*)buf;
} }
} }
void FileReader::setCacheSize(const atInt32 blockSize) { void FileReader::setCacheSize(const int32_t blockSize) {
m_blockSize = blockSize; m_blockSize = blockSize;
if (m_blockSize > length()) if (m_blockSize > length())
m_blockSize = (atInt32)length(); m_blockSize = (int32_t)length();
m_curBlock = -1; m_curBlock = -1;
if (m_blockSize > 0) if (m_blockSize > 0)
m_cacheData.reset(new atUint8[m_blockSize]); m_cacheData.reset(new uint8_t[m_blockSize]);
} }
} // namespace athena::io } // namespace athena::io

6
src/athena/FileWriterGeneric.cpp
View File

@ -3,7 +3,7 @@
#include <cstring> #include <cstring>
namespace athena::io { namespace athena::io {
void TransactionalFileWriter::seek(atInt64 pos, SeekOrigin origin) { void TransactionalFileWriter::seek(int64_t pos, SeekOrigin origin) {
switch (origin) { switch (origin) {
case SeekOrigin::Begin: case SeekOrigin::Begin:
m_position = pos; m_position = pos;
@ -16,8 +16,8 @@ void TransactionalFileWriter::seek(atInt64 pos, SeekOrigin origin) {
} }
} }
void TransactionalFileWriter::writeUBytes(const atUint8* data, atUint64 len) { void TransactionalFileWriter::writeUBytes(const uint8_t* data, uint64_t len) {
atUint64 neededSz = m_position + len; uint64_t neededSz = m_position + len;
if (neededSz > m_deferredBuffer.size()) { if (neededSz > m_deferredBuffer.size()) {
m_deferredBuffer.reserve(neededSz * 2); m_deferredBuffer.reserve(neededSz * 2);
m_deferredBuffer.resize(neededSz); m_deferredBuffer.resize(neededSz);

14
src/athena/FileWriterWin32.cpp
View File

@ -76,7 +76,7 @@ void FileWriter::close() {
MoveFileExW(tmpFilename.c_str(), m_filename.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH); MoveFileExW(tmpFilename.c_str(), m_filename.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
} }
void FileWriter::seek(atInt64 pos, SeekOrigin origin) { void FileWriter::seek(int64_t pos, SeekOrigin origin) {
if (!isOpen()) { if (!isOpen()) {
if (m_globalErr) if (m_globalErr)
atError("Unable to seek in file, not open"); atError("Unable to seek in file, not open");
@ -93,16 +93,16 @@ void FileWriter::seek(atInt64 pos, SeekOrigin origin) {
} }
} }
atUint64 FileWriter::position() const { uint64_t FileWriter::position() const {
LARGE_INTEGER li = {}; LARGE_INTEGER li = {};
LARGE_INTEGER res; LARGE_INTEGER res;
SetFilePointerEx(m_fileHandle, li, &res, FILE_CURRENT); SetFilePointerEx(m_fileHandle, li, &res, FILE_CURRENT);
return static_cast<atUint64>(res.QuadPart); return static_cast<uint64_t>(res.QuadPart);
} }
atUint64 FileWriter::length() const { return utility::fileSize(m_filename); } uint64_t FileWriter::length() const { return utility::fileSize(m_filename); }
void FileWriter::writeUBytes(const atUint8* data, atUint64 len) { void FileWriter::writeUBytes(const uint8_t* data, uint64_t len) {
if (!isOpen()) { if (!isOpen()) {
if (m_globalErr) { if (m_globalErr) {
atError("File not open for writing"); atError("File not open for writing");
@ -111,9 +111,9 @@ void FileWriter::writeUBytes(const atUint8* data, atUint64 len) {
return; return;
} }
atUint64 remaining = len; uint64_t remaining = len;
do { do {
const auto toWrite = static_cast<DWORD>(std::min(remaining, atUint64{std::numeric_limits<DWORD>::max()})); const auto toWrite = static_cast<DWORD>(std::min(remaining, uint64_t{std::numeric_limits<DWORD>::max()}));
DWORD written = 0; DWORD written = 0;
if (WriteFile(m_fileHandle, data, toWrite, &written, nullptr) == FALSE) { if (WriteFile(m_fileHandle, data, toWrite, &written, nullptr) == FALSE) {

18
src/athena/MCFile.cpp
View File

@ -7,9 +7,9 @@ const char MCFile::VERSION_US[33] = "AGBZELDA:THE MINISH CAP:ZELDA 5\0";
MCFile::MCFile() {} MCFile::MCFile() {}
// TODO: Rewrite this to be more optimized, the current solution takes quite a few cycles // TODO: Rewrite this to be more optimized, the current solution takes quite a few cycles
atUint8* reverse(atUint8* data, atUint32 length) { uint8_t* reverse(uint8_t* data, uint32_t length) {
atUint32 a = 0; uint32_t a = 0;
atUint32 swap; uint32_t swap;
for (; a < --length; a++) { for (; a < --length; a++) {
swap = data[a]; swap = data[a];
@ -20,15 +20,15 @@ atUint8* reverse(atUint8* data, atUint32 length) {
return data; return data;
} }
atUint8* MCFile::unscramble(atUint8* data, atUint64 length) { uint8_t* MCFile::unscramble(uint8_t* data, uint64_t length) {
if (!data) if (!data)
return nullptr; return nullptr;
for (atUint32 i = 0; i < length; i += 8) { for (uint32_t i = 0; i < length; i += 8) {
atUint32 block1 = *(atUint32*)reverse((data + i), 4); uint32_t block1 = *(uint32_t*)reverse((data + i), 4);
atUint32 block2 = *(atUint32*)reverse((data + i + 4), 4); uint32_t block2 = *(uint32_t*)reverse((data + i + 4), 4);
*(atUint32*)(data + i) = block2; *(uint32_t*)(data + i) = block2;
*(atUint32*)(data + i + 4) = block1; *(uint32_t*)(data + i + 4) = block1;
} }
return data; return data;

4
src/athena/MCFileReader.cpp
View File

@ -4,8 +4,8 @@ namespace athena {
namespace io { namespace io {
static const atUint32 SCRAMBLE_VALUE = 0x5A424741; static const uint32_t SCRAMBLE_VALUE = 0x5A424741;
MCFileReader::MCFileReader(atUint8* data, atUint64 length) : MemoryCopyReader(data, length) {} MCFileReader::MCFileReader(uint8_t* data, uint64_t length) : MemoryCopyReader(data, length) {}
MCFileReader::MCFileReader(const std::string& filename) : MemoryCopyReader(filename) {} MCFileReader::MCFileReader(const std::string& filename) : MemoryCopyReader(filename) {}

18
src/athena/MCFileWriter.cpp
View File

@ -2,19 +2,19 @@
namespace athena::io { namespace athena::io {
MCFileWriter::MCFileWriter(atUint8* data, atUint64 length) : MemoryCopyWriter(data, length) {} MCFileWriter::MCFileWriter(uint8_t* data, uint64_t length) : MemoryCopyWriter(data, length) {}
MCFileWriter::MCFileWriter(const std::string& filename) : MemoryCopyWriter(filename) {} MCFileWriter::MCFileWriter(const std::string& filename) : MemoryCopyWriter(filename) {}
// TODO: Check the implementation, it seems to work fine, however it's not exactly correct, // TODO: Check the implementation, it seems to work fine, however it's not exactly correct,
// looking at the disassembly, MC seems to do some weird checking that isn't being done with this solution // looking at the disassembly, MC seems to do some weird checking that isn't being done with this solution
// need to figure out what it's doing and whether it's relevant to the checksum. // need to figure out what it's doing and whether it's relevant to the checksum.
atUint16 MCFileWriter::calculateSlotChecksum(atUint32 game) { uint16_t MCFileWriter::calculateSlotChecksum(uint32_t game) {
atUint16 first = calculateChecksum((m_data + 0x34 + (0x10 * game)), 4); uint16_t first = calculateChecksum((m_data + 0x34 + (0x10 * game)), 4);
atUint16 second = calculateChecksum((m_data + 0x80 + (0x500 * game)), 0x500); uint16_t second = calculateChecksum((m_data + 0x80 + (0x500 * game)), 0x500);
first = (first + second) & 0xFFFF; first = (first + second) & 0xFFFF;
atUint16 result = first << 16; uint16_t result = first << 16;
second = ~first & 0xFFFF; second = ~first & 0xFFFF;
second += 1; second += 1;
result += second; result += second;
@ -22,12 +22,12 @@ atUint16 MCFileWriter::calculateSlotChecksum(atUint32 game) {
return result; return result;
} }
atUint16 MCFileWriter::calculateChecksum(atUint8* data, atUint32 length) { uint16_t MCFileWriter::calculateChecksum(uint8_t* data, uint32_t length) {
atUint16 sum = 0; uint16_t sum = 0;
int i = length; int i = length;
for (atUint32 j = 0; j < length; j += 2) { for (uint32_t j = 0; j < length; j += 2) {
sum += *(atUint16*)(data + j) ^ i; sum += *(uint16_t*)(data + j) ^ i;
i -= 2; i -= 2;
} }

2
src/athena/MCSlot.cpp
View File

@ -2,7 +2,7 @@
namespace athena { namespace athena {
MCSlot::MCSlot(std::unique_ptr<atUint8[]>&& data, atUint32 length) MCSlot::MCSlot(std::unique_ptr<uint8_t[]>&& data, uint32_t length)
: ZQuestFile(ZQuestFile::MC, Endian::Little, std::move(data), length) {} : ZQuestFile(ZQuestFile::MC, Endian::Little, std::move(data), length) {}
} // namespace athena } // namespace athena

46
src/athena/MemoryReader.cpp
View File

@ -9,7 +9,7 @@
#endif // HW_RVL #endif // HW_RVL
namespace athena::io { namespace athena::io {
MemoryReader::MemoryReader(const void* data, atUint64 length, bool takeOwnership, bool globalErr) MemoryReader::MemoryReader(const void* data, uint64_t length, bool takeOwnership, bool globalErr)
: m_data(data), m_length(length), m_position(0), m_owns(takeOwnership), m_globalErr(globalErr) { : m_data(data), m_length(length), m_position(0), m_owns(takeOwnership), m_globalErr(globalErr) {
if (!data) { if (!data) {
if (m_globalErr) if (m_globalErr)
@ -21,10 +21,10 @@ MemoryReader::MemoryReader(const void* data, atUint64 length, bool takeOwnership
MemoryReader::~MemoryReader() { MemoryReader::~MemoryReader() {
if (m_owns) if (m_owns)
delete[] static_cast<const atUint8*>(m_data); delete[] static_cast<const uint8_t*>(m_data);
} }
MemoryCopyReader::MemoryCopyReader(const void* data, atUint64 length) : MemoryReader(data, length, false) { MemoryCopyReader::MemoryCopyReader(const void* data, uint64_t length) : MemoryReader(data, length, false) {
if (!data) { if (!data) {
if (m_globalErr) if (m_globalErr)
atError("data cannot be NULL"); atError("data cannot be NULL");
@ -32,15 +32,15 @@ MemoryCopyReader::MemoryCopyReader(const void* data, atUint64 length) : MemoryRe
return; return;
} }
m_dataCopy.reset(new atUint8[m_length]); m_dataCopy.reset(new uint8_t[m_length]);
m_data = m_dataCopy.get(); m_data = m_dataCopy.get();
memmove(m_dataCopy.get(), data, m_length); memmove(m_dataCopy.get(), data, m_length);
} }
void MemoryReader::seek(atInt64 position, SeekOrigin origin) { void MemoryReader::seek(int64_t position, SeekOrigin origin) {
switch (origin) { switch (origin) {
case SeekOrigin::Begin: case SeekOrigin::Begin:
if ((position < 0 || atInt64(position) > atInt64(m_length))) { if ((position < 0 || int64_t(position) > int64_t(m_length))) {
if (m_globalErr) if (m_globalErr)
atFatal("Position {:08X} outside stream bounds ", position); atFatal("Position {:08X} outside stream bounds ", position);
m_position = m_length; m_position = m_length;
@ -48,11 +48,11 @@ void MemoryReader::seek(atInt64 position, SeekOrigin origin) {
return; return;
} }
m_position = atUint64(position); m_position = uint64_t(position);
break; break;
case SeekOrigin::Current: case SeekOrigin::Current:
if (((atInt64(m_position) + position) < 0 || (m_position + atUint64(position)) > m_length)) { if (((int64_t(m_position) + position) < 0 || (m_position + uint64_t(position)) > m_length)) {
if (m_globalErr) if (m_globalErr)
atFatal("Position {:08X} outside stream bounds ", position); atFatal("Position {:08X} outside stream bounds ", position);
m_position = (position < 0 ? 0 : m_length); m_position = (position < 0 ? 0 : m_length);
@ -64,7 +64,7 @@ void MemoryReader::seek(atInt64 position, SeekOrigin origin) {
break; break;
case SeekOrigin::End: case SeekOrigin::End:
if ((((atInt64)m_length - position < 0) || (m_length - position) > m_length)) { if ((((int64_t)m_length - position < 0) || (m_length - position) > m_length)) {
if (m_globalErr) if (m_globalErr)
atFatal("Position {:08X} outside stream bounds ", position); atFatal("Position {:08X} outside stream bounds ", position);
m_position = m_length; m_position = m_length;
@ -77,31 +77,31 @@ void MemoryReader::seek(atInt64 position, SeekOrigin origin) {
} }
} }
void MemoryReader::setData(const atUint8* data, atUint64 length, bool takeOwnership) { void MemoryReader::setData(const uint8_t* data, uint64_t length, bool takeOwnership) {
if (m_owns) if (m_owns)
delete[] static_cast<const atUint8*>(m_data); delete[] static_cast<const uint8_t*>(m_data);
m_data = (atUint8*)data; m_data = (uint8_t*)data;
m_length = length; m_length = length;
m_position = 0; m_position = 0;
m_owns = takeOwnership; m_owns = takeOwnership;
} }
void MemoryCopyReader::setData(const atUint8* data, atUint64 length) { void MemoryCopyReader::setData(const uint8_t* data, uint64_t length) {
m_dataCopy.reset(new atUint8[length]); m_dataCopy.reset(new uint8_t[length]);
m_data = m_dataCopy.get(); m_data = m_dataCopy.get();
memmove(m_dataCopy.get(), data, length); memmove(m_dataCopy.get(), data, length);
m_length = length; m_length = length;
m_position = 0; m_position = 0;
} }
atUint8* MemoryReader::data() const { uint8_t* MemoryReader::data() const {
atUint8* ret = new atUint8[m_length]; uint8_t* ret = new uint8_t[m_length];
memset(ret, 0, m_length); memset(ret, 0, m_length);
memmove(ret, m_data, m_length); memmove(ret, m_data, m_length);
return ret; return ret;
} }
atUint64 MemoryReader::readUBytesToBuf(void* buf, atUint64 length) { uint64_t MemoryReader::readUBytesToBuf(void* buf, uint64_t length) {
if (m_position >= m_length) { if (m_position >= m_length) {
if (m_globalErr) if (m_globalErr)
atError("Position {:08X} outside stream bounds ", m_position); atError("Position {:08X} outside stream bounds ", m_position);
@ -111,14 +111,14 @@ atUint64 MemoryReader::readUBytesToBuf(void* buf, atUint64 length) {
} }
length = std::min(length, m_length - m_position); length = std::min(length, m_length - m_position);
memmove(buf, static_cast<const atUint8*>(m_data) + m_position, length); memmove(buf, static_cast<const uint8_t*>(m_data) + m_position, length);
m_position += length; m_position += length;
return length; return length;
} }
void MemoryCopyReader::loadData() { void MemoryCopyReader::loadData() {
FILE* in; FILE* in;
atUint64 length; uint64_t length;
in = fopen(m_filepath.c_str(), "rb"); in = fopen(m_filepath.c_str(), "rb");
if (!in) { if (!in) {
@ -131,17 +131,17 @@ void MemoryCopyReader::loadData() {
rewind(in); rewind(in);
length = utility::fileSize(m_filepath); length = utility::fileSize(m_filepath);
m_dataCopy.reset(new atUint8[length]); m_dataCopy.reset(new uint8_t[length]);
m_data = m_dataCopy.get(); m_data = m_dataCopy.get();
atUint64 done = 0; uint64_t done = 0;
atUint64 blocksize = BLOCKSZ; uint64_t blocksize = BLOCKSZ;
do { do {
if (blocksize > length - done) if (blocksize > length - done)
blocksize = length - done; blocksize = length - done;
atInt64 ret = fread(m_dataCopy.get() + done, 1, blocksize, in); int64_t ret = fread(m_dataCopy.get() + done, 1, blocksize, in);
if (ret < 0) { if (ret < 0) {
if (m_globalErr) if (m_globalErr)

52
src/athena/MemoryWriter.cpp
View File

@ -9,7 +9,7 @@
namespace athena::io { namespace athena::io {
MemoryWriter::MemoryWriter(atUint8* data, atUint64 length, bool takeOwnership) MemoryWriter::MemoryWriter(uint8_t* data, uint64_t length, bool takeOwnership)
: m_data(data), m_length(length), m_bufferOwned(takeOwnership) { : m_data(data), m_length(length), m_bufferOwned(takeOwnership) {
if (!data) { if (!data) {
atError("data cannot be NULL"); atError("data cannot be NULL");
@ -25,7 +25,7 @@ MemoryWriter::~MemoryWriter() {
m_length = 0; m_length = 0;
} }
MemoryCopyWriter::MemoryCopyWriter(atUint8* data, atUint64 length) { MemoryCopyWriter::MemoryCopyWriter(uint8_t* data, uint64_t length) {
m_data = data; m_data = data;
m_length = length; m_length = length;
m_position = 0; m_position = 0;
@ -36,7 +36,7 @@ MemoryCopyWriter::MemoryCopyWriter(atUint8* data, atUint64 length) {
setError(); setError();
return; return;
} }
m_dataCopy.reset(new atUint8[length]); m_dataCopy.reset(new uint8_t[length]);
m_data = m_dataCopy.get(); m_data = m_dataCopy.get();
if (data) if (data)
memmove(m_data, data, length); memmove(m_data, data, length);
@ -46,7 +46,7 @@ MemoryCopyWriter::MemoryCopyWriter(std::string_view filename) {
m_filepath = filename; m_filepath = filename;
m_length = 0x10; m_length = 0x10;
m_position = 0; m_position = 0;
m_dataCopy.reset(new atUint8[m_length]); m_dataCopy.reset(new uint8_t[m_length]);
m_data = m_dataCopy.get(); m_data = m_dataCopy.get();
m_bufferOwned = false; m_bufferOwned = false;
@ -57,7 +57,7 @@ MemoryCopyWriter::MemoryCopyWriter(std::string_view filename) {
} }
} }
void MemoryWriter::seek(atInt64 position, SeekOrigin origin) { void MemoryWriter::seek(int64_t position, SeekOrigin origin) {
switch (origin) { switch (origin) {
case SeekOrigin::Begin: case SeekOrigin::Begin:
if (position < 0) { if (position < 0) {
@ -66,7 +66,7 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin) {
return; return;
} }
if ((atUint64)position > m_length) { if ((uint64_t)position > m_length) {
atError("data exceeds available buffer space"); atError("data exceeds available buffer space");
setError(); setError();
return; return;
@ -76,7 +76,7 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin) {
break; break;
case SeekOrigin::Current: case SeekOrigin::Current:
if ((((atInt64)m_position + position) < 0)) { if ((((int64_t)m_position + position) < 0)) {
atError("Position outside stream bounds"); atError("Position outside stream bounds");
setError(); setError();
return; return;
@ -92,13 +92,13 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin) {
break; break;
case SeekOrigin::End: case SeekOrigin::End:
if (((atInt64)m_length - position) < 0) { if (((int64_t)m_length - position) < 0) {
atError("Position outside stream bounds"); atError("Position outside stream bounds");
setError(); setError();
return; return;
} }
if ((atUint64)position > m_length) { if ((uint64_t)position > m_length) {
atError("data exceeds available buffer space"); atError("data exceeds available buffer space");
setError(); setError();
return; return;
@ -109,7 +109,7 @@ void MemoryWriter::seek(atInt64 position, SeekOrigin origin) {
} }
} }
void MemoryCopyWriter::seek(atInt64 position, SeekOrigin origin) { void MemoryCopyWriter::seek(int64_t position, SeekOrigin origin) {
switch (origin) { switch (origin) {
case SeekOrigin::Begin: case SeekOrigin::Begin:
if (position < 0) { if (position < 0) {
@ -118,14 +118,14 @@ void MemoryCopyWriter::seek(atInt64 position, SeekOrigin origin) {
return; return;
} }
if ((atUint64)position > m_length) if ((uint64_t)position > m_length)
resize(position); resize(position);
m_position = position; m_position = position;
break; break;
case SeekOrigin::Current: case SeekOrigin::Current:
if ((((atInt64)m_position + position) < 0)) { if ((((int64_t)m_position + position) < 0)) {
atError("Position outside stream bounds"); atError("Position outside stream bounds");
setError(); setError();
return; return;
@ -138,13 +138,13 @@ void MemoryCopyWriter::seek(atInt64 position, SeekOrigin origin) {
break; break;
case SeekOrigin::End: case SeekOrigin::End:
if (((atInt64)m_length - position) < 0) { if (((int64_t)m_length - position) < 0) {
atError("Position outside stream bounds"); atError("Position outside stream bounds");
setError(); setError();
return; return;
} }
if ((atUint64)position > m_length) if ((uint64_t)position > m_length)
resize(position); resize(position);
m_position = m_length - position; m_position = m_length - position;
@ -152,7 +152,7 @@ void MemoryCopyWriter::seek(atInt64 position, SeekOrigin origin) {
} }
} }
void MemoryWriter::setData(atUint8* data, atUint64 length, bool takeOwnership) { void MemoryWriter::setData(uint8_t* data, uint64_t length, bool takeOwnership) {
if (m_bufferOwned) if (m_bufferOwned)
delete m_data; delete m_data;
@ -162,8 +162,8 @@ void MemoryWriter::setData(atUint8* data, atUint64 length, bool takeOwnership) {
m_bufferOwned = takeOwnership; m_bufferOwned = takeOwnership;
} }
void MemoryCopyWriter::setData(const atUint8* data, atUint64 length) { void MemoryCopyWriter::setData(const uint8_t* data, uint64_t length) {
m_dataCopy.reset(new atUint8[length]); m_dataCopy.reset(new uint8_t[length]);
m_data = m_dataCopy.get(); m_data = m_dataCopy.get();
memmove(m_data, data, length); memmove(m_data, data, length);
m_length = length; m_length = length;
@ -171,8 +171,8 @@ void MemoryCopyWriter::setData(const atUint8* data, atUint64 length) {
m_bufferOwned = false; m_bufferOwned = false;
} }
atUint8* MemoryWriter::data() const { uint8_t* MemoryWriter::data() const {
atUint8* ret = new atUint8[m_length]; uint8_t* ret = new uint8_t[m_length];
memset(ret, 0, m_length); memset(ret, 0, m_length);
memmove(ret, m_data, m_length); memmove(ret, m_data, m_length);
return ret; return ret;
@ -197,15 +197,15 @@ void MemoryWriter::save(std::string_view filename) {
return; return;
} }
atUint64 done = 0; uint64_t done = 0;
atUint64 blocksize = BLOCKSZ; uint64_t blocksize = BLOCKSZ;
do { do {
if (blocksize > m_length - done) { if (blocksize > m_length - done) {
blocksize = m_length - done; blocksize = m_length - done;
} }
const atInt64 ret = std::fwrite(m_data + done, 1, blocksize, out.get()); const int64_t ret = std::fwrite(m_data + done, 1, blocksize, out.get());
if (ret < 0) { if (ret < 0) {
atError("Error writing data to disk"); atError("Error writing data to disk");
@ -221,7 +221,7 @@ void MemoryWriter::save(std::string_view filename) {
} while (done < m_length); } while (done < m_length);
} }
void MemoryWriter::writeUBytes(const atUint8* data, atUint64 length) { void MemoryWriter::writeUBytes(const uint8_t* data, uint64_t length) {
if (!data) { if (!data) {
atError("data cannnot be NULL"); atError("data cannnot be NULL");
setError(); setError();
@ -239,7 +239,7 @@ void MemoryWriter::writeUBytes(const atUint8* data, atUint64 length) {
m_position += length; m_position += length;
} }
void MemoryCopyWriter::writeUBytes(const atUint8* data, atUint64 length) { void MemoryCopyWriter::writeUBytes(const uint8_t* data, uint64_t length) {
if (!data) { if (!data) {
atError("data cannnot be NULL"); atError("data cannnot be NULL");
setError(); setError();
@ -254,14 +254,14 @@ void MemoryCopyWriter::writeUBytes(const atUint8* data, atUint64 length) {
m_position += length; m_position += length;
} }
void MemoryCopyWriter::resize(atUint64 newSize) { void MemoryCopyWriter::resize(uint64_t newSize) {
if (newSize < m_length) { if (newSize < m_length) {
atError("New size cannot be less to the old size."); atError("New size cannot be less to the old size.");
return; return;
} }
// Allocate and copy new buffer // Allocate and copy new buffer
auto newArray = std::make_unique<atUint8[]>(newSize); auto newArray = std::make_unique<uint8_t[]>(newSize);
if (m_dataCopy) { if (m_dataCopy) {
std::memmove(newArray.get(), m_dataCopy.get(), m_length); std::memmove(newArray.get(), m_dataCopy.get(), m_length);
} }

2
src/athena/SkywardSwordFile.cpp
View File

@ -17,7 +17,7 @@ void SkywardSwordFile::addQuest(athena::SkywardSwordQuest* q) {
m_quests.push_back(q); m_quests.push_back(q);
} }
SkywardSwordQuest* SkywardSwordFile::quest(atUint32 id) { SkywardSwordQuest* SkywardSwordFile::quest(uint32_t id) {
if (id > m_quests.size() - 1) { if (id > m_quests.size() - 1) {
atWarning("index out of range"); atWarning("index out of range");
return nullptr; return nullptr;

8
src/athena/SkywardSwordFileReader.cpp
View File

@ -5,7 +5,7 @@
namespace athena::io { namespace athena::io {
SkywardSwordFileReader::SkywardSwordFileReader(atUint8* data, atUint64 length) : MemoryCopyReader(data, length) { SkywardSwordFileReader::SkywardSwordFileReader(uint8_t* data, uint64_t length) : MemoryCopyReader(data, length) {
setEndian(Endian::Big); setEndian(Endian::Big);
} }
@ -21,7 +21,7 @@ SkywardSwordFile* SkywardSwordFileReader::read() {
return nullptr; return nullptr;
} }
atUint32 magic = readUint32(); uint32_t magic = readUint32();
if (magic != SkywardSwordFile::USMagic && magic != SkywardSwordFile::JAMagic && magic != SkywardSwordFile::EUMagic) { if (magic != SkywardSwordFile::USMagic && magic != SkywardSwordFile::JAMagic && magic != SkywardSwordFile::EUMagic) {
atError("Not a valid Skyward Sword save file"); atError("Not a valid Skyward Sword save file");
@ -29,7 +29,7 @@ SkywardSwordFile* SkywardSwordFileReader::read() {
} }
seek(0x01C, SeekOrigin::Begin); seek(0x01C, SeekOrigin::Begin);
atUint32 headerSize = readUint32(); // Seems to be (headerSize - 1) uint32_t headerSize = readUint32(); // Seems to be (headerSize - 1)
if (headerSize != 0x1D) { if (headerSize != 0x1D) {
atError("Invalid header size, Corrupted data?"); atError("Invalid header size, Corrupted data?");
@ -44,7 +44,7 @@ SkywardSwordFile* SkywardSwordFileReader::read() {
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
SkywardSwordQuest* q = new SkywardSwordQuest(readUBytes(0x53C0), 0x53C0); SkywardSwordQuest* q = new SkywardSwordQuest(readUBytes(0x53C0), 0x53C0);
atUint64 pos = position(); uint64_t pos = position();
// seek to the skip data for this particular quest // seek to the skip data for this particular quest
seek(0xFB60 + (i * 0x24), SeekOrigin::Begin); seek(0xFB60 + (i * 0x24), SeekOrigin::Begin);
q->setSkipData(readUBytes(0x24)); q->setSkipData(readUBytes(0x24));

6
src/athena/SkywardSwordFileWriter.cpp
View File

@ -4,7 +4,7 @@
namespace athena::io { namespace athena::io {
SkywardSwordFileWriter::SkywardSwordFileWriter(atUint8* data, atUint64 len) : MemoryCopyWriter(data, len) { SkywardSwordFileWriter::SkywardSwordFileWriter(uint8_t* data, uint64_t len) : MemoryCopyWriter(data, len) {
setEndian(Endian::Big); setEndian(Endian::Big);
} }
@ -18,7 +18,7 @@ void SkywardSwordFileWriter::write(SkywardSwordFile* file) {
return; return;
} }
atUint32 magic = (file->region() == Region::NTSC uint32_t magic = (file->region() == Region::NTSC
? SkywardSwordFile::USMagic ? SkywardSwordFile::USMagic
: (file->region() == Region::NTSCJ ? SkywardSwordFile::JAMagic : SkywardSwordFile::EUMagic)); : (file->region() == Region::NTSCJ ? SkywardSwordFile::JAMagic : SkywardSwordFile::EUMagic));
@ -39,7 +39,7 @@ void SkywardSwordFileWriter::write(SkywardSwordFile* file) {
q->fixChecksums(); q->fixChecksums();
// Write the save data // Write the save data
writeUBytes(q->data(), q->length()); writeUBytes(q->data(), q->length());
atUint64 pos = position(); uint64_t pos = position();
// Write the slots skip data // Write the slots skip data
seek(0xFB60 + (i * 0x24), SeekOrigin::Begin); seek(0xFB60 + (i * 0x24), SeekOrigin::Begin);
writeUBytes(q->skipData(), 0x24); writeUBytes(q->skipData(), 0x24);

104
src/athena/SkywardSwordQuest.cpp
View File

@ -7,47 +7,47 @@
namespace athena { namespace athena {
namespace priv { namespace priv {
static const atUint32 NAME_OFFSET = 0x08D4; static const uint32_t NAME_OFFSET = 0x08D4;
static const atUint32 RUPEE_COUNT_OFFSET = 0x0A5E; static const uint32_t RUPEE_COUNT_OFFSET = 0x0A5E;
static const atUint32 AMMO_COUNT_OFFSET = 0x0A60; static const uint32_t AMMO_COUNT_OFFSET = 0x0A60;
static const atUint32 MAX_HP_OFFSET = 0x5302; static const uint32_t MAX_HP_OFFSET = 0x5302;
static const atUint32 SPAWN_HP_OFFSET = 0x5304; static const uint32_t SPAWN_HP_OFFSET = 0x5304;
static const atUint32 CURRENT_HP_OFFSET = 0x5306; static const uint32_t CURRENT_HP_OFFSET = 0x5306;
static const atUint32 ROOM_ID_OFFSET = 0x5309; static const uint32_t ROOM_ID_OFFSET = 0x5309;
static const atUint32 CURRENT_LOCATION_OFFSET = 0x531C; static const uint32_t CURRENT_LOCATION_OFFSET = 0x531C;
static const atUint32 CURRENT_AREA_OFFSET = 0x533C; static const uint32_t CURRENT_AREA_OFFSET = 0x533C;
static const atUint32 CURRENT_LOCATION_COPY_OFFSET = 0x535C; static const uint32_t CURRENT_LOCATION_COPY_OFFSET = 0x535C;
static const atUint32 CHECKSUM_OFFSET = 0x53BC; static const uint32_t CHECKSUM_OFFSET = 0x53BC;
static const atUint32 ISNEW_OFFSET = 0x53AD; static const uint32_t ISNEW_OFFSET = 0x53AD;
static const atUint32 SKIP_CHECKSUM_OFFSET = 0x20; static const uint32_t SKIP_CHECKSUM_OFFSET = 0x20;
} // namespace priv } // namespace priv
union AmmoValues { union AmmoValues {
struct { struct {
atUint32 arrows : 7; uint32_t arrows : 7;
atUint32 bombs : 7; uint32_t bombs : 7;
atUint32 : 9; uint32_t : 9;
atUint32 seeds : 7; uint32_t seeds : 7;
atUint32 : 2; uint32_t : 2;
}; };
atUint32 value; uint32_t value;
}; };
SkywardSwordQuest::SkywardSwordQuest(std::unique_ptr<atUint8[]>&& data, atUint32 len) SkywardSwordQuest::SkywardSwordQuest(std::unique_ptr<uint8_t[]>&& data, uint32_t len)
: ZQuestFile(ZQuestFile::SS, Endian::Big, std::move(data), len) {} : ZQuestFile(ZQuestFile::SS, Endian::Big, std::move(data), len) {}
void SkywardSwordQuest::setSkipData(std::unique_ptr<atUint8[]>&& data) { m_skipData = std::move(data); } void SkywardSwordQuest::setSkipData(std::unique_ptr<uint8_t[]>&& data) { m_skipData = std::move(data); }
atUint8* SkywardSwordQuest::skipData() const { return m_skipData.get(); } uint8_t* SkywardSwordQuest::skipData() const { return m_skipData.get(); }
void SkywardSwordQuest::setPlayerName(const std::string& name) { void SkywardSwordQuest::setPlayerName(const std::string& name) {
if (name.length() > 8) if (name.length() > 8)
atDebug("WARNING: name cannot be greater than 8 characters, automatically truncating"); atDebug("WARNING: name cannot be greater than 8 characters, automatically truncating");
const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(name.c_str()); const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(name.c_str());
for (atUint32 i = 0; i < 8; i++) { for (uint32_t i = 0; i < 8; i++) {
atUint16& c = *(atUint16*)(m_data.get() + priv::NAME_OFFSET + (i * 2)); uint16_t& c = *(uint16_t*)(m_data.get() + priv::NAME_OFFSET + (i * 2));
if (!*buf) { if (!*buf) {
c = 0; c = 0;
@ -61,7 +61,7 @@ void SkywardSwordQuest::setPlayerName(const std::string& name) {
return; return;
} }
buf += len; buf += len;
c = atUint16(wc); c = uint16_t(wc);
utility::BigUint16(c); utility::BigUint16(c);
} }
} }
@ -69,8 +69,8 @@ void SkywardSwordQuest::setPlayerName(const std::string& name) {
std::string SkywardSwordQuest::playerName() const { std::string SkywardSwordQuest::playerName() const {
std::string val; std::string val;
for (atUint32 i = 0; i < 8; i++) { for (uint32_t i = 0; i < 8; i++) {
atUint16 c = *(atUint16*)(m_data.get() + priv::NAME_OFFSET + (i * 2)); uint16_t c = *(uint16_t*)(m_data.get() + priv::NAME_OFFSET + (i * 2));
if (c == 0) if (c == 0)
break; break;
@ -85,18 +85,18 @@ std::string SkywardSwordQuest::playerName() const {
return val; return val;
} }
void SkywardSwordQuest::setRupeeCount(atUint16 value) { void SkywardSwordQuest::setRupeeCount(uint16_t value) {
atUint16& tmp = *(atUint16*)(m_data.get() + priv::RUPEE_COUNT_OFFSET); uint16_t& tmp = *(uint16_t*)(m_data.get() + priv::RUPEE_COUNT_OFFSET);
tmp = value; tmp = value;
utility::BigUint16(tmp); utility::BigUint16(tmp);
} }
atUint16 SkywardSwordQuest::rupeeCount() { uint16_t SkywardSwordQuest::rupeeCount() {
atUint16 ret = *(atUint16*)(m_data.get() + priv::RUPEE_COUNT_OFFSET); uint16_t ret = *(uint16_t*)(m_data.get() + priv::RUPEE_COUNT_OFFSET);
return utility::BigUint16(ret); return utility::BigUint16(ret);
} }
void SkywardSwordQuest::setAmmoCount(SkywardSwordQuest::AmmoType type, atUint32 count) { void SkywardSwordQuest::setAmmoCount(SkywardSwordQuest::AmmoType type, uint32_t count) {
AmmoValues& values = *(AmmoValues*)(m_data.get() + priv::AMMO_COUNT_OFFSET); AmmoValues& values = *(AmmoValues*)(m_data.get() + priv::AMMO_COUNT_OFFSET);
utility::BigUint32(values.value); utility::BigUint32(values.value);
@ -117,7 +117,7 @@ void SkywardSwordQuest::setAmmoCount(SkywardSwordQuest::AmmoType type, atUint32
utility::BigUint32(values.value); utility::BigUint32(values.value);
} }
atUint32 SkywardSwordQuest::ammoCount(AmmoType type) { uint32_t SkywardSwordQuest::ammoCount(AmmoType type) {
AmmoValues values = *(AmmoValues*)(m_data.get() + priv::AMMO_COUNT_OFFSET); AmmoValues values = *(AmmoValues*)(m_data.get() + priv::AMMO_COUNT_OFFSET);
utility::BigUint32(values.value); utility::BigUint32(values.value);
@ -136,34 +136,34 @@ atUint32 SkywardSwordQuest::ammoCount(AmmoType type) {
} }
} }
void SkywardSwordQuest::setMaxHP(atUint16 val) { void SkywardSwordQuest::setMaxHP(uint16_t val) {
*(atUint16*)(m_data.get() + priv::MAX_HP_OFFSET) = utility::BigUint16(val); *(uint16_t*)(m_data.get() + priv::MAX_HP_OFFSET) = utility::BigUint16(val);
} }
atUint16 SkywardSwordQuest::maxHP() { uint16_t SkywardSwordQuest::maxHP() {
atUint16 ret = *(atUint16*)(m_data.get() + priv::MAX_HP_OFFSET); uint16_t ret = *(uint16_t*)(m_data.get() + priv::MAX_HP_OFFSET);
return utility::BigUint16(ret); return utility::BigUint16(ret);
} }
float SkywardSwordQuest::maxHearts() { return (maxHP() / 4.f); } float SkywardSwordQuest::maxHearts() { return (maxHP() / 4.f); }
void SkywardSwordQuest::setSpawnHP(atUint16 val) { void SkywardSwordQuest::setSpawnHP(uint16_t val) {
*(atUint16*)(m_data.get() + priv::SPAWN_HP_OFFSET) = utility::BigUint16(val); *(uint16_t*)(m_data.get() + priv::SPAWN_HP_OFFSET) = utility::BigUint16(val);
} }
atUint16 SkywardSwordQuest::spawnHP() { uint16_t SkywardSwordQuest::spawnHP() {
atUint16 ret = *(atUint16*)(m_data.get() + priv::SPAWN_HP_OFFSET); uint16_t ret = *(uint16_t*)(m_data.get() + priv::SPAWN_HP_OFFSET);
return utility::BigUint16(ret); return utility::BigUint16(ret);
} }
float SkywardSwordQuest::spawnHearts() { return (spawnHP() / 4.f); } float SkywardSwordQuest::spawnHearts() { return (spawnHP() / 4.f); }
void SkywardSwordQuest::setCurrentHP(atUint16 val) { void SkywardSwordQuest::setCurrentHP(uint16_t val) {
*(atUint16*)(m_data.get() + priv::CURRENT_HP_OFFSET) = utility::BigUint16(val); *(uint16_t*)(m_data.get() + priv::CURRENT_HP_OFFSET) = utility::BigUint16(val);
} }
atUint16 SkywardSwordQuest::currentHP() { uint16_t SkywardSwordQuest::currentHP() {
atUint16 ret = *(atUint16*)(m_data.get() + priv::CURRENT_HP_OFFSET); uint16_t ret = *(uint16_t*)(m_data.get() + priv::CURRENT_HP_OFFSET);
return utility::BigUint16(ret); return utility::BigUint16(ret);
} }
@ -179,28 +179,28 @@ std::string SkywardSwordQuest::currentLocationCopy() {
return std::string((char*)m_data.get() + priv::CURRENT_LOCATION_COPY_OFFSET); return std::string((char*)m_data.get() + priv::CURRENT_LOCATION_COPY_OFFSET);
} }
atUint32 SkywardSwordQuest::slotChecksum() { uint32_t SkywardSwordQuest::slotChecksum() {
atUint32 ret = *(atUint32*)(m_data.get() + priv::CHECKSUM_OFFSET); uint32_t ret = *(uint32_t*)(m_data.get() + priv::CHECKSUM_OFFSET);
utility::BigUint32(ret); utility::BigUint32(ret);
return ret; return ret;
} }
atUint32 SkywardSwordQuest::skipChecksum() { uint32_t SkywardSwordQuest::skipChecksum() {
atUint32 ret = *(atUint32*)(m_skipData.get() + priv::SKIP_CHECKSUM_OFFSET); uint32_t ret = *(uint32_t*)(m_skipData.get() + priv::SKIP_CHECKSUM_OFFSET);
utility::BigUint32(ret); utility::BigUint32(ret);
return ret; return ret;
} }
void SkywardSwordQuest::fixChecksums() { void SkywardSwordQuest::fixChecksums() {
atUint32 checksum = checksums::crc32(m_data.get(), priv::CHECKSUM_OFFSET); uint32_t checksum = checksums::crc32(m_data.get(), priv::CHECKSUM_OFFSET);
utility::BigUint32(checksum); utility::BigUint32(checksum);
*(atUint32*)(m_data.get() + priv::CHECKSUM_OFFSET) = checksum; *(uint32_t*)(m_data.get() + priv::CHECKSUM_OFFSET) = checksum;
checksum = checksums::crc32(m_skipData.get(), priv::SKIP_CHECKSUM_OFFSET); checksum = checksums::crc32(m_skipData.get(), priv::SKIP_CHECKSUM_OFFSET);
utility::BigUint32(checksum); utility::BigUint32(checksum);
*(atUint32*)(m_skipData.get() + priv::SKIP_CHECKSUM_OFFSET) = checksum; *(uint32_t*)(m_skipData.get() + priv::SKIP_CHECKSUM_OFFSET) = checksum;
} }
void SkywardSwordQuest::setNew(bool isNew) { *(bool*)(m_data.get() + priv::ISNEW_OFFSET) = isNew; } void SkywardSwordQuest::setNew(bool isNew) { *(bool*)(m_data.get() + priv::ISNEW_OFFSET) = isNew; }

16
src/athena/Sprite.cpp
View File

@ -55,16 +55,16 @@ void Sprite::setStateIds(std::vector<int> ids) {
std::vector<int> Sprite::stateIds() const { return m_stateIds; } std::vector<int> Sprite::stateIds() const { return m_stateIds; }
atUint32 Sprite::stateCount() const { return (atUint32)m_stateIds.size(); } uint32_t Sprite::stateCount() const { return (uint32_t)m_stateIds.size(); }
void Sprite::setCurrentState(const atUint32 id) { void Sprite::setCurrentState(const uint32_t id) {
if (id >= m_stateIds.size()) if (id >= m_stateIds.size())
return; return;
m_currentState = id; m_currentState = id;
} }
atUint32 Sprite::currentState() const { return m_currentState; } uint32_t Sprite::currentState() const { return m_currentState; }
bool Sprite::addFrame(SpriteFrame* part) { bool Sprite::addFrame(SpriteFrame* part) {
if (m_frames.size() > 65536) if (m_frames.size() > 65536)
@ -89,7 +89,7 @@ bool Sprite::removeFrame(SpriteFrame* frame) {
return false; return false;
} }
void Sprite::setFrame(atUint32 id) { void Sprite::setFrame(uint32_t id) {
if (id > m_frames.size()) if (id > m_frames.size())
return; return;
} }
@ -110,14 +110,14 @@ void Sprite::setFrames(std::vector<SpriteFrame*> frames) {
m_frames = frames; m_frames = frames;
} }
atUint32 Sprite::frameCount() const { return (atUint32)m_frames.size(); } uint32_t Sprite::frameCount() const { return (uint32_t)m_frames.size(); }
std::vector<SpriteFrame*> Sprite::frames() const { return m_frames; } std::vector<SpriteFrame*> Sprite::frames() const { return m_frames; }
SpriteFile* Sprite::container() const { return m_root; } SpriteFile* Sprite::container() const { return m_root; }
void Sprite::setCurrentFrame(SpriteFrame* frame) { void Sprite::setCurrentFrame(SpriteFrame* frame) {
atUint32 id = 0; uint32_t id = 0;
for (SpriteFrame* tmpFrame : m_frames) { for (SpriteFrame* tmpFrame : m_frames) {
if (tmpFrame == frame) { if (tmpFrame == frame) {
@ -129,7 +129,7 @@ void Sprite::setCurrentFrame(SpriteFrame* frame) {
} }
} }
void Sprite::setCurrentFrame(atUint32 id) { void Sprite::setCurrentFrame(uint32_t id) {
if (id >= m_frames.size()) if (id >= m_frames.size())
return; return;
@ -142,7 +142,7 @@ void Sprite::advanceFrame() {
m_currentFrame++; m_currentFrame++;
if (m_currentFrame >= m_frames.size()) if (m_currentFrame >= m_frames.size())
m_currentFrame = (atUint32)m_frames.size() - 1; m_currentFrame = (uint32_t)m_frames.size() - 1;
} }
void Sprite::retreatFrame() { void Sprite::retreatFrame() {

26
src/athena/SpriteFile.cpp
View File

@ -4,17 +4,17 @@
#include <iostream> #include <iostream>
namespace athena::Sakura { namespace athena::Sakura {
const atUint32 SpriteFile::Major = 1; const uint32_t SpriteFile::Major = 1;
const atUint32 SpriteFile::Minor = 0; const uint32_t SpriteFile::Minor = 0;
const atUint32 SpriteFile::Revision = 2; const uint32_t SpriteFile::Revision = 2;
const atUint32 SpriteFile::Build = 0; const uint32_t SpriteFile::Build = 0;
const atUint32 SpriteFile::Version = Major | (Minor << 8) | (Revision << 16) | (Build << 24); const uint32_t SpriteFile::Version = Major | (Minor << 8) | (Revision << 16) | (Build << 24);
const atUint32 SpriteFile::Magic = 'S' | ('P' << 8) | ('R' << 16) | ('S' << 24); const uint32_t SpriteFile::Magic = 'S' | ('P' << 8) | ('R' << 16) | ('S' << 24);
SpriteFile::SpriteFile() {} SpriteFile::SpriteFile() {}
SpriteFile::SpriteFile(atUint32 width, atUint32 height, float originX, float originY) SpriteFile::SpriteFile(uint32_t width, uint32_t height, float originX, float originY)
: m_size(width, height), m_origin(originX, originY) {} : m_size(width, height), m_origin(originX, originY) {}
SpriteFile::SpriteFile(const Vector2Di& size, const Vector2Df& origin) : m_size(size), m_origin(origin) {} SpriteFile::SpriteFile(const Vector2Di& size, const Vector2Df& origin) : m_size(size), m_origin(origin) {}
@ -28,15 +28,15 @@ SpriteFile::~SpriteFile() {
m_sprites.clear(); m_sprites.clear();
} }
void SpriteFile::setSize(atUint32 width, atUint32 height) { setSize(Vector2Di(width, height)); } void SpriteFile::setSize(uint32_t width, uint32_t height) { setSize(Vector2Di(width, height)); }
void SpriteFile::setSize(const Vector2Di& size) { m_size = size; } void SpriteFile::setSize(const Vector2Di& size) { m_size = size; }
Vector2Di SpriteFile::size() const { return m_size; } Vector2Di SpriteFile::size() const { return m_size; }
atUint32 SpriteFile::width() const { return m_size.x; } uint32_t SpriteFile::width() const { return m_size.x; }
atUint32 SpriteFile::height() const { return m_size.y; } uint32_t SpriteFile::height() const { return m_size.y; }
void SpriteFile::setOrigin(const float x, const float y) { setOrigin(Vector2Df(x, y)); } void SpriteFile::setOrigin(const float x, const float y) { setOrigin(Vector2Df(x, y)); }
@ -65,7 +65,7 @@ void SpriteFile::removeTexture(int id) {
delete tex; delete tex;
} }
STexture* SpriteFile::texture(atUint32 id) { STexture* SpriteFile::texture(uint32_t id) {
if (id >= m_textures.size()) if (id >= m_textures.size())
return NULL; return NULL;
@ -74,7 +74,7 @@ STexture* SpriteFile::texture(atUint32 id) {
std::vector<STexture*> SpriteFile::textures() const { return m_textures; } std::vector<STexture*> SpriteFile::textures() const { return m_textures; }
atUint32 SpriteFile::textureCount() const { return (atUint32)m_textures.size(); } uint32_t SpriteFile::textureCount() const { return (uint32_t)m_textures.size(); }
void SpriteFile::addSprite(Sprite* sprite) { void SpriteFile::addSprite(Sprite* sprite) {
std::string name(sprite->name()); std::string name(sprite->name());
@ -125,7 +125,7 @@ Sprite* SpriteFile::sprite(const std::string& name) {
std::unordered_map<std::string, Sprite*> SpriteFile::sprites() const { return m_sprites; } std::unordered_map<std::string, Sprite*> SpriteFile::sprites() const { return m_sprites; }
atUint32 SpriteFile::spriteCount() const { return (atUint32)m_sprites.size(); } uint32_t SpriteFile::spriteCount() const { return (uint32_t)m_sprites.size(); }
void SpriteFile::setTextures(std::vector<STexture*> textures) { void SpriteFile::setTextures(std::vector<STexture*> textures) {
if (textures.size() == 0) if (textures.size() == 0)

34
src/athena/SpriteFileReader.cpp
View File

@ -6,21 +6,21 @@
#include "athena/Utility.hpp" #include "athena/Utility.hpp"
namespace athena::io { namespace athena::io {
SpriteFileReader::SpriteFileReader(atUint8* data, atUint64 length) : MemoryCopyReader(data, length) {} SpriteFileReader::SpriteFileReader(uint8_t* data, uint64_t length) : MemoryCopyReader(data, length) {}
SpriteFileReader::SpriteFileReader(const std::string& filepath) : MemoryCopyReader(filepath) {} SpriteFileReader::SpriteFileReader(const std::string& filepath) : MemoryCopyReader(filepath) {}
Sakura::SpriteFile* SpriteFileReader::readFile() { Sakura::SpriteFile* SpriteFileReader::readFile() {
Sakura::SpriteFile* ret = NULL; Sakura::SpriteFile* ret = NULL;
atUint32 magic = readUint32(); uint32_t magic = readUint32();
if (magic != Sakura::SpriteFile::Magic) { if (magic != Sakura::SpriteFile::Magic) {
atError("Not a valid Sakura Sprite container"); atError("Not a valid Sakura Sprite container");
return nullptr; return nullptr;
} }
atUint32 version = readUint32(); uint32_t version = readUint32();
// TODO: Make this more verbose // TODO: Make this more verbose
if (version != Sakura::SpriteFile::Version) { if (version != Sakura::SpriteFile::Version) {
@ -33,14 +33,14 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
// Such as the texture count, it's dimensions, and it's origin. // Such as the texture count, it's dimensions, and it's origin.
// After that we have the number of sprites contained in this // After that we have the number of sprites contained in this
// sprite container. // sprite container.
atUint16 textureCount = uint16_t textureCount =
readUint16(); // Having it as a Uint16 gives us the ability to have up to 65536 different states readUint16(); // Having it as a Uint16 gives us the ability to have up to 65536 different states
// This is probably overkill, but it's better safe than sorry. // This is probably overkill, but it's better safe than sorry.
atUint32 width = readUint32(); uint32_t width = readUint32();
atUint32 height = readUint32(); uint32_t height = readUint32();
float originX = readFloat(); float originX = readFloat();
float originY = readFloat(); float originY = readFloat();
atUint16 spriteCount = readUint16(); uint16_t spriteCount = readUint16();
// Lets go ahead and create or new container. // Lets go ahead and create or new container.
ret = new Sakura::SpriteFile(width, height, originX, originY); ret = new Sakura::SpriteFile(width, height, originX, originY);
@ -50,7 +50,7 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
// to migrate this code to Big Endian based systems, such as the wii // to migrate this code to Big Endian based systems, such as the wii
// which require data to be 32 byte aligned, or it causes some issues. // which require data to be 32 byte aligned, or it causes some issues.
// It's also convenient to have this, for later expansion. // It's also convenient to have this, for later expansion.
atUint32 reserved = readUint32(); uint32_t reserved = readUint32();
// Next we have to load the textures // Next we have to load the textures
// If we tried to add them one at a time to the sprite container // If we tried to add them one at a time to the sprite container
@ -63,7 +63,7 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
QList<Sakura::STexture*> textures; QList<Sakura::STexture*> textures;
#endif #endif
for (atUint16 i = 0; i < textureCount; i++) { for (uint16_t i = 0; i < textureCount; i++) {
Sakura::STexture* texture = new Sakura::STexture; Sakura::STexture* texture = new Sakura::STexture;
texture->Filepath = readString(); texture->Filepath = readString();
texture->Preload = readBool(); texture->Preload = readBool();
@ -84,7 +84,7 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
QMap<QString, Sakura::Sprite*> sprites; QMap<QString, Sakura::Sprite*> sprites;
#endif #endif
for (atUint16 i = 0; i < spriteCount; i++) { for (uint16_t i = 0; i < spriteCount; i++) {
Sakura::Sprite* sprite = new Sakura::Sprite(ret); Sakura::Sprite* sprite = new Sakura::Sprite(ret);
#ifndef ATHENA_USE_QT #ifndef ATHENA_USE_QT
std::string name = readString(); std::string name = readString();
@ -92,8 +92,8 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
QString name = QString::fromStdString(readString()); QString name = QString::fromStdString(readString());
#endif #endif
sprite->setName(name); sprite->setName(name);
atUint16 frameCount = readUint16(); uint16_t frameCount = readUint16();
atUint16 stateCount = readUint16(); uint16_t stateCount = readUint16();
// Each state id corresponds to a texture held in the parent class // Each state id corresponds to a texture held in the parent class
std::vector<int> stateIds; std::vector<int> stateIds;
@ -116,10 +116,10 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
QList<Sakura::SpriteFrame*> frames; QList<Sakura::SpriteFrame*> frames;
#endif #endif
for (atUint32 k = 0; k < frameCount; k++) { for (uint32_t k = 0; k < frameCount; k++) {
Sakura::SpriteFrame* frame = new Sakura::SpriteFrame(sprite); Sakura::SpriteFrame* frame = new Sakura::SpriteFrame(sprite);
frame->setFrameTime(readFloat()); frame->setFrameTime(readFloat());
atUint16 partCount = readUint16(); uint16_t partCount = readUint16();
#ifndef ATHENA_USE_QT #ifndef ATHENA_USE_QT
std::vector<Sakura::SpritePart*> parts; std::vector<Sakura::SpritePart*> parts;
@ -127,7 +127,7 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
QList<Sakura::SpritePart*> parts; QList<Sakura::SpritePart*> parts;
#endif #endif
for (atUint8 j = 0; j < partCount; j++) { for (uint8_t j = 0; j < partCount; j++) {
Sakura::SpritePart* part = new Sakura::SpritePart(frame); Sakura::SpritePart* part = new Sakura::SpritePart(frame);
#ifndef ATHENA_USE_QT #ifndef ATHENA_USE_QT
std::string name = readString(); std::string name = readString();
@ -143,8 +143,8 @@ Sakura::SpriteFile* SpriteFileReader::readFile() {
float texXOff = readFloat(); float texXOff = readFloat();
float texYOff = readFloat(); float texYOff = readFloat();
part->setTextureOffset(texXOff, texYOff); part->setTextureOffset(texXOff, texYOff);
atUint32 width = readUint32(); uint32_t width = readUint32();
atUint32 height = readUint32(); uint32_t height = readUint32();
part->setSize(width, height); part->setSize(width, height);
bool flippedH = readBool(); bool flippedH = readBool();
part->setFlippedHorizontally(flippedH); part->setFlippedHorizontally(flippedH);

2
src/athena/SpriteFileWriter.cpp
View File

@ -5,7 +5,7 @@
#include "athena/SpriteFrame.hpp" #include "athena/SpriteFrame.hpp"
namespace athena::io { namespace athena::io {
SpriteFileWriter::SpriteFileWriter(atUint8* data, atUint64 length) : MemoryCopyWriter(data, length) {} SpriteFileWriter::SpriteFileWriter(uint8_t* data, uint64_t length) : MemoryCopyWriter(data, length) {}
SpriteFileWriter::SpriteFileWriter(std::string_view filepath) : MemoryCopyWriter(filepath) {} SpriteFileWriter::SpriteFileWriter(std::string_view filepath) : MemoryCopyWriter(filepath) {}

2
src/athena/SpriteFrame.cpp
View File

@ -14,7 +14,7 @@ void SpriteFrame::setParts(std::vector<SpritePart*> parts) { m_parts = parts; }
std::vector<SpritePart*> SpriteFrame::parts() const { return m_parts; } std::vector<SpritePart*> SpriteFrame::parts() const { return m_parts; }
atUint32 SpriteFrame::partCount() const { return (atUint32)m_parts.size(); } uint32_t SpriteFrame::partCount() const { return (uint32_t)m_parts.size(); }
float SpriteFrame::frameTime() const { return m_frameTime; } float SpriteFrame::frameTime() const { return m_frameTime; }

2
src/athena/SpritePart.cpp
View File

@ -34,7 +34,7 @@ void SpritePart::setTextureOffset(const Vector2Df& offset) { m_textureOffset = o
Vector2Df SpritePart::textureOffset() const { return m_textureOffset; } Vector2Df SpritePart::textureOffset() const { return m_textureOffset; }
void SpritePart::setSize(atUint32 width, atUint32 height) { setSize(Vector2Di(width, height)); } void SpritePart::setSize(uint32_t width, uint32_t height) { setSize(Vector2Di(width, height)); }
void SpritePart::setSize(const Vector2Di& size) { m_size = size; } void SpritePart::setSize(const Vector2Di& size) { m_size = size; }

26
src/athena/Utility.cpp
View File

@ -20,16 +20,16 @@
namespace athena::utility { namespace athena::utility {
void fillRandom(atUint8* rndArea, atUint64 count) { void fillRandom(uint8_t* rndArea, uint64_t count) {
atUint8* buf = rndArea; uint8_t* buf = rndArea;
for (atUint64 i = 0; i < count / 4; i++) { for (uint64_t i = 0; i < count / 4; i++) {
*(atUint32*)(buf) = rand(); *(uint32_t*)(buf) = rand();
buf += 4; buf += 4;
} }
atUint64 rem = count % 4; uint64_t rem = count % 4;
if (rem) { if (rem) {
for (atUint64 j = 0; j < rem; j++) { for (uint64_t j = 0; j < rem; j++) {
*buf = rand(); *buf = rand();
buf++; buf++;
} }
@ -113,14 +113,14 @@ int countChar(std::string_view str, const char chr, int* lastOccur) {
return ret; return ret;
} }
atUint64 fileSize(std::string_view filename) { uint64_t fileSize(std::string_view filename) {
atStat64_t st; atStat64_t st;
atStat64(filename.data(), &st); atStat64(filename.data(), &st);
return st.st_size; return st.st_size;
} }
#ifdef _WIN32 #ifdef _WIN32
atUint64 fileSize(std::wstring_view filename) { uint64_t fileSize(std::wstring_view filename) {
atStat64_t st; atStat64_t st;
_wstati64(filename.data(), &st); _wstati64(filename.data(), &st);
return st.st_size; return st.st_size;
@ -151,12 +151,12 @@ std::string& trim(std::string& s) {
return s; return s;
} }
atUint64 rand64() { uint64_t rand64() {
// Combine 4 parts of low 16-bit of each rand() // Combine 4 parts of low 16-bit of each rand()
atUint64 r0 = (atUint64)rand() << 48; uint64_t r0 = (uint64_t)rand() << 48;
atUint64 r1 = (atUint64)rand() << 48 >> 16; uint64_t r1 = (uint64_t)rand() << 48 >> 16;
atUint64 r2 = (atUint64)rand() << 48 >> 32; uint64_t r2 = (uint64_t)rand() << 48 >> 32;
atUint64 r3 = (atUint64)rand() << 48 >> 48; uint64_t r3 = (uint64_t)rand() << 48 >> 48;
return r0 | r1 | r2 | r3; return r0 | r1 | r2 | r3;
} }

16
src/athena/VectorWriter.cpp
View File

@ -6,7 +6,7 @@
namespace athena::io { namespace athena::io {
void VectorWriter::seek(atInt64 position, SeekOrigin origin) { void VectorWriter::seek(int64_t position, SeekOrigin origin) {
switch (origin) { switch (origin) {
case SeekOrigin::Begin: case SeekOrigin::Begin:
if (position < 0) { if (position < 0) {
@ -15,14 +15,14 @@ void VectorWriter::seek(atInt64 position, SeekOrigin origin) {
return; return;
} }
if ((atUint64)position > m_data.size()) if ((uint64_t)position > m_data.size())
m_data.resize(position); m_data.resize(position);
m_position = position; m_position = position;
break; break;
case SeekOrigin::Current: case SeekOrigin::Current:
if ((((atInt64)m_position + position) < 0)) { if ((((int64_t)m_position + position) < 0)) {
atError("Position outside stream bounds"); atError("Position outside stream bounds");
setError(); setError();
return; return;
@ -35,13 +35,13 @@ void VectorWriter::seek(atInt64 position, SeekOrigin origin) {
break; break;
case SeekOrigin::End: case SeekOrigin::End:
if (((atInt64)m_data.size() - position) < 0) { if (((int64_t)m_data.size() - position) < 0) {
atError("Position outside stream bounds"); atError("Position outside stream bounds");
setError(); setError();
return; return;
} }
if ((atUint64)position > m_data.size()) { if ((uint64_t)position > m_data.size()) {
atError("data exceeds vector size"); atError("data exceeds vector size");
setError(); setError();
return; return;
@ -52,7 +52,7 @@ void VectorWriter::seek(atInt64 position, SeekOrigin origin) {
} }
} }
void VectorWriter::writeUBytes(const atUint8* data, atUint64 length) { void VectorWriter::writeUBytes(const uint8_t* data, uint64_t length) {
if (!data) { if (!data) {
atError("data cannnot be NULL"); atError("data cannnot be NULL");
setError(); setError();
@ -61,7 +61,7 @@ void VectorWriter::writeUBytes(const atUint8* data, atUint64 length) {
if (m_position < m_data.size()) { if (m_position < m_data.size()) {
size_t delta = std::min(m_data.size() - m_position, length); size_t delta = std::min(m_data.size() - m_position, length);
memmove(reinterpret_cast<atInt8*>(&m_data[m_position]), data, delta); memmove(reinterpret_cast<int8_t*>(&m_data[m_position]), data, delta);
data += delta; data += delta;
length -= delta; length -= delta;
m_position += delta; m_position += delta;
@ -70,7 +70,7 @@ void VectorWriter::writeUBytes(const atUint8* data, atUint64 length) {
if (length != 0) { if (length != 0) {
size_t insertPos = m_data.size(); size_t insertPos = m_data.size();
m_data.resize(insertPos + length); m_data.resize(insertPos + length);
memmove(reinterpret_cast<atInt8*>(&m_data[insertPos]), data, length); memmove(reinterpret_cast<int8_t*>(&m_data[insertPos]), data, length);
m_position += length; m_position += length;
} }
} }

26
src/athena/WiiBanner.cpp
View File

@ -8,7 +8,7 @@ namespace athena {
WiiBanner::WiiBanner() : m_gameId(0), m_banner(NULL), m_flags(0), m_bannerSize(0) {} WiiBanner::WiiBanner() : m_gameId(0), m_banner(NULL), m_flags(0), m_bannerSize(0) {}
WiiBanner::WiiBanner(atUint32 gameId, const std::u16string& title, const std::u16string& subtitle, WiiImage* banner, WiiBanner::WiiBanner(uint32_t gameId, const std::u16string& title, const std::u16string& subtitle, WiiImage* banner,
std::vector<WiiImage*> icons) std::vector<WiiImage*> icons)
: m_gameId(gameId) : m_gameId(gameId)
, m_banner(banner) , m_banner(banner)
@ -23,9 +23,9 @@ WiiBanner::~WiiBanner() {
m_icons.clear(); m_icons.clear();
} }
void WiiBanner::setGameID(atUint64 id) { m_gameId = id; } void WiiBanner::setGameID(uint64_t id) { m_gameId = id; }
atUint64 WiiBanner::gameID() const { return m_gameId; } uint64_t WiiBanner::gameID() const { return m_gameId; }
void WiiBanner::setTitle(const std::u16string& title) { m_title = title; } void WiiBanner::setTitle(const std::u16string& title) { m_title = title; }
const std::u16string& WiiBanner::title() const { return m_title; } const std::u16string& WiiBanner::title() const { return m_title; }
@ -36,14 +36,14 @@ const std::u16string& WiiBanner::subtitle() const { return m_subtitle; }
void WiiBanner::addIcon(WiiImage* icon) { m_icons.push_back(icon); } void WiiBanner::addIcon(WiiImage* icon) { m_icons.push_back(icon); }
void WiiBanner::setIcon(atUint32 id, WiiImage* icon) { void WiiBanner::setIcon(uint32_t id, WiiImage* icon) {
if (m_icons[id] != NULL) { if (m_icons[id] != NULL) {
delete m_icons[id]; delete m_icons[id];
m_icons[id] = icon; m_icons[id] = icon;
} }
} }
WiiImage* WiiBanner::getIcon(atUint32 id) const { WiiImage* WiiBanner::getIcon(uint32_t id) const {
if (!m_icons[id]) if (!m_icons[id])
return NULL; return NULL;
@ -55,20 +55,20 @@ void WiiBanner::setBannerImage(WiiImage* banner) { m_banner = banner; }
WiiImage* WiiBanner::bannerImage() const { return m_banner; } WiiImage* WiiBanner::bannerImage() const { return m_banner; }
void WiiBanner::setAnimationSpeed(atUint16 animSpeed) { m_animSpeed = animSpeed; } void WiiBanner::setAnimationSpeed(uint16_t animSpeed) { m_animSpeed = animSpeed; }
atUint16 WiiBanner::animationSpeed() const { return m_animSpeed; } uint16_t WiiBanner::animationSpeed() const { return m_animSpeed; }
void WiiBanner::setPermissions(atUint8 permissions) { m_permissions = permissions; } void WiiBanner::setPermissions(uint8_t permissions) { m_permissions = permissions; }
atUint8 WiiBanner::permissions() const { return m_permissions; } uint8_t WiiBanner::permissions() const { return m_permissions; }
void WiiBanner::setBannerSize(atUint32 size) { m_bannerSize = size; } void WiiBanner::setBannerSize(uint32_t size) { m_bannerSize = size; }
atUint32 WiiBanner::bannerSize() const { return m_bannerSize; } uint32_t WiiBanner::bannerSize() const { return m_bannerSize; }
void WiiBanner::setFlags(atUint32 flags) { m_flags = flags; } void WiiBanner::setFlags(uint32_t flags) { m_flags = flags; }
atUint32 WiiBanner::flags() const { return m_flags; } uint32_t WiiBanner::flags() const { return m_flags; }
} // namespace athena } // namespace athena

26
src/athena/WiiFile.cpp
View File

@ -25,13 +25,13 @@ WiiFile::WiiFile(const std::string& filename)
, m_fileData(NULL) , m_fileData(NULL)
, m_parent(NULL) {} , m_parent(NULL) {}
WiiFile::WiiFile(const std::string& filename, atUint8 permissions, const atUint8* data, atUint32 length) WiiFile::WiiFile(const std::string& filename, uint8_t permissions, const uint8_t* data, uint32_t length)
: m_permissions(permissions) : m_permissions(permissions)
, m_attributes(0) , m_attributes(0)
, m_type(WiiFile::File) , m_type(WiiFile::File)
, m_filename(filename) , m_filename(filename)
, m_fileLen(length) , m_fileLen(length)
, m_fileData((atUint8*)data) {} , m_fileData((uint8_t*)data) {}
WiiFile::~WiiFile() { WiiFile::~WiiFile() {
if (m_fileData) if (m_fileData)
@ -45,28 +45,28 @@ void WiiFile::setFilename(const std::string& filename) { m_filename = filename;
std::string WiiFile::filename() const { return m_filename; } std::string WiiFile::filename() const { return m_filename; }
void WiiFile::setPermissions(const atUint8 permissions) { m_permissions = (atUint8)permissions; } void WiiFile::setPermissions(const uint8_t permissions) { m_permissions = (uint8_t)permissions; }
atUint8 WiiFile::permissions() const { return m_permissions; } uint8_t WiiFile::permissions() const { return m_permissions; }
void WiiFile::setData(const atUint8* data) { void WiiFile::setData(const uint8_t* data) {
if (m_fileData) { if (m_fileData) {
delete[] m_fileData; delete[] m_fileData;
m_fileData = NULL; m_fileData = NULL;
} }
m_fileData = (atUint8*)data; m_fileData = (uint8_t*)data;
} }
atUint8* WiiFile::data() const { return m_fileData; } uint8_t* WiiFile::data() const { return m_fileData; }
void WiiFile::setLength(const int len) { m_fileLen = (int)len; } void WiiFile::setLength(const int len) { m_fileLen = (int)len; }
int WiiFile::length() const { return m_fileLen; } int WiiFile::length() const { return m_fileLen; }
void WiiFile::setAttributes(const atUint8 attr) { m_attributes = attr; } void WiiFile::setAttributes(const uint8_t attr) { m_attributes = attr; }
atUint8 WiiFile::attributes() const { return m_attributes; } uint8_t WiiFile::attributes() const { return m_attributes; }
void WiiFile::setType(WiiFile::Type type) { m_type = type; } void WiiFile::setType(WiiFile::Type type) { m_type = type; }
@ -88,14 +88,14 @@ void WiiFile::addChild(WiiFile* file) {
// Lets figure out it's place // Lets figure out it's place
std::string tmpName(file->filename()); std::string tmpName(file->filename());
// Since we only support *NIX paths this is simple // Since we only support *NIX paths this is simple
atUint32 depth = athena::utility::countChar(tmpName, '/'); uint32_t depth = athena::utility::countChar(tmpName, '/');
bool owned = false; bool owned = false;
while ((depth--) > 0) { while ((depth--) > 0) {
// add them from the beginning of the path up // add them from the beginning of the path up
tmpName = tmpName.substr(0, tmpName.find('/')); tmpName = tmpName.substr(0, tmpName.find('/'));
for (atUint32 i = 0; i < m_children.size(); i++) { for (uint32_t i = 0; i < m_children.size(); i++) {
if (m_children[i]->filename() == tmpName) { if (m_children[i]->filename() == tmpName) {
std::string newName = file->filename(); std::string newName = file->filename();
newName = newName.substr(newName.rfind("/") + 1, newName.size() - newName.rfind("/")); newName = newName.substr(newName.rfind("/") + 1, newName.size() - newName.rfind("/"));
@ -154,7 +154,7 @@ void WiiFile::setParent(WiiFile* parent) {
m_parent->addChild(this); m_parent->addChild(this);
} }
atUint32 WiiFile::fileCount() { uint32_t WiiFile::fileCount() {
size_t ret = m_children.size(); size_t ret = m_children.size();
for (WiiFile* f : m_children) { for (WiiFile* f : m_children) {
@ -164,7 +164,7 @@ atUint32 WiiFile::fileCount() {
ret += f->fileCount(); ret += f->fileCount();
} }
return (atUint32)ret; return (uint32_t)ret;
} }
std::vector<WiiFile*> WiiFile::allChildren() { std::vector<WiiFile*> WiiFile::allChildren() {

46
src/athena/WiiImage.cpp
View File

@ -5,22 +5,22 @@
namespace athena { namespace athena {
WiiImage::WiiImage(atUint32 width, atUint32 height, std::unique_ptr<atUint8[]>&& data) WiiImage::WiiImage(uint32_t width, uint32_t height, std::unique_ptr<uint8_t[]>&& data)
: m_width(width), m_height(height), m_data(std::move(data)) {} : m_width(width), m_height(height), m_data(std::move(data)) {}
atUint8* WiiImage::data() { return m_data.get(); } uint8_t* WiiImage::data() { return m_data.get(); }
atUint32 WiiImage::width() const { return m_width; } uint32_t WiiImage::width() const { return m_width; }
atUint32 WiiImage::height() const { return m_height; } uint32_t WiiImage::height() const { return m_height; }
atUint8* WiiImage::toRGBA() { uint8_t* WiiImage::toRGBA() {
atUint32 x, y; uint32_t x, y;
atUint32 x1, y1; uint32_t x1, y1;
atUint32 iv; uint32_t iv;
atUint8* bitmapdata = NULL; uint8_t* bitmapdata = NULL;
bitmapdata = new atUint8[m_width * m_height * 4]; bitmapdata = new uint8_t[m_width * m_height * 4];
if (bitmapdata == NULL) if (bitmapdata == NULL)
return NULL; return NULL;
@ -29,27 +29,27 @@ atUint8* WiiImage::toRGBA() {
for (x1 = 0; x1 < m_width; x1 += 4) { for (x1 = 0; x1 < m_width; x1 += 4) {
for (y = y1; y < (y1 + 4); y++) { for (y = y1; y < (y1 + 4); y++) {
for (x = x1; x < (x1 + 4); x++) { for (x = x1; x < (x1 + 4); x++) {
atUint16 oldpixel = *(atUint16*)(m_data.get() + ((iv++) * 2)); uint16_t oldpixel = *(uint16_t*)(m_data.get() + ((iv++) * 2));
// if((x >= m_width) || (y >= m_height)) // if((x >= m_width) || (y >= m_height))
// continue; // continue;
oldpixel = utility::swapU16(oldpixel); oldpixel = utility::swapU16(oldpixel);
if (oldpixel & (1 << 15)) { if (oldpixel & (1 << 15)) {
// RGB5 // RGB5
atUint8 b = (((oldpixel >> 10) & 0x1F) * 255) / 31; uint8_t b = (((oldpixel >> 10) & 0x1F) * 255) / 31;
atUint8 g = (((oldpixel >> 5) & 0x1F) * 255) / 31; uint8_t g = (((oldpixel >> 5) & 0x1F) * 255) / 31;
atUint8 r = (((oldpixel >> 0) & 0x1F) * 255) / 31; uint8_t r = (((oldpixel >> 0) & 0x1F) * 255) / 31;
atUint8 a = 255; uint8_t a = 255;
atUint8 rgba = (r << 0) | (g << 8) | (b << 16) | (a << 24); uint8_t rgba = (r << 0) | (g << 8) | (b << 16) | (a << 24);
(*(atUint32**)&bitmapdata)[x + (y * m_width)] = rgba; (*(uint32_t**)&bitmapdata)[x + (y * m_width)] = rgba;
} else { } else {
// RGB4A3 // RGB4A3
atUint8 a = (((oldpixel >> 12) & 0x7) * 255) / 7; uint8_t a = (((oldpixel >> 12) & 0x7) * 255) / 7;
atUint8 b = (((oldpixel >> 8) & 0xF) * 255) / 15; uint8_t b = (((oldpixel >> 8) & 0xF) * 255) / 15;
atUint8 g = (((oldpixel >> 4) & 0xF) * 255) / 15; uint8_t g = (((oldpixel >> 4) & 0xF) * 255) / 15;
atUint8 r = (((oldpixel >> 0) & 0xF) * 255) / 15; uint8_t r = (((oldpixel >> 0) & 0xF) * 255) / 15;
atUint32 rgba = (r << 0) | (g << 8) | (b << 16) | (a << 24); uint32_t rgba = (r << 0) | (g << 8) | (b << 16) | (a << 24);
(*(atUint32**)&bitmapdata)[x + (y * m_width)] = rgba; (*(uint32_t**)&bitmapdata)[x + (y * m_width)] = rgba;
} }
} }
} }

2
src/athena/WiiSave.cpp
View File

@ -47,7 +47,7 @@ WiiFile* WiiSave::file(const std::string& filepath) {
return m_root->child(cleanPath); return m_root->child(cleanPath);
} }
atUint32 WiiSave::fileCount() const { return m_root->fileCount(); } uint32_t WiiSave::fileCount() const { return m_root->fileCount(); }
WiiFile* WiiSave::root() { return m_root; } WiiFile* WiiSave::root() { return m_root; }

72
src/athena/WiiSaveReader.cpp
View File

@ -17,7 +17,7 @@ namespace athena {
namespace io { namespace io {
WiiSaveReader::WiiSaveReader(const atUint8* data, atUint64 length) : MemoryCopyReader(data, length) { WiiSaveReader::WiiSaveReader(const uint8_t* data, uint64_t length) : MemoryCopyReader(data, length) {
setEndian(Endian::Big); setEndian(Endian::Big);
} }
@ -39,14 +39,14 @@ std::unique_ptr<WiiSave> WiiSaveReader::readSave() {
} }
ret->setBanner(banner); ret->setBanner(banner);
atUint32 bkVer = readUint32(); uint32_t bkVer = readUint32();
if (bkVer != 0x00000070) { if (bkVer != 0x00000070) {
atError("Invalid BacKup header size"); atError("Invalid BacKup header size");
return nullptr; return nullptr;
} }
atUint32 bkMagic = readUint32(); uint32_t bkMagic = readUint32();
if (bkMagic != 0x426B0001) { if (bkMagic != 0x426B0001) {
atError("Invalid BacKup header magic"); atError("Invalid BacKup header magic");
@ -54,12 +54,12 @@ std::unique_ptr<WiiSave> WiiSaveReader::readSave() {
} }
/*atUint32 ngId =*/readUint32(); /*atUint32 ngId =*/readUint32();
atUint32 numFiles = readUint32(); uint32_t numFiles = readUint32();
/*int fileSize =*/readUint32(); /*int fileSize =*/readUint32();
seek(8); // skip unknown data; seek(8); // skip unknown data;
atUint32 totalSize = readUint32(); uint32_t totalSize = readUint32();
seek(64); // Unknown (Most likely padding) seek(64); // Unknown (Most likely padding)
seek(8); seek(8);
seek(6); seek(6);
@ -68,7 +68,7 @@ std::unique_ptr<WiiSave> WiiSaveReader::readSave() {
std::vector<WiiFile*> files; std::vector<WiiFile*> files;
for (atUint32 i = 0; i < numFiles; ++i) { for (uint32_t i = 0; i < numFiles; ++i) {
WiiFile* file = readFile(); WiiFile* file = readFile();
if (file) if (file)
@ -82,18 +82,18 @@ std::unique_ptr<WiiSave> WiiSaveReader::readSave() {
} }
WiiBanner* WiiSaveReader::readBanner() { WiiBanner* WiiSaveReader::readBanner() {
atUint8* dec = new atUint8[0xF0C0]; uint8_t* dec = new uint8_t[0xF0C0];
memset(dec, 0, 0xF0C0); memset(dec, 0, 0xF0C0);
std::unique_ptr<atUint8[]> buf = readUBytes(0xF0C0); std::unique_ptr<uint8_t[]> buf = readUBytes(0xF0C0);
atUint8* oldData = data(); uint8_t* oldData = data();
atUint64 oldPos = position(); uint64_t oldPos = position();
atUint64 oldLen = length(); uint64_t oldLen = length();
atUint64 gameId; uint64_t gameId;
atUint32 bannerSize; uint32_t bannerSize;
atUint8 permissions; uint8_t permissions;
atUint8 md5[16]; uint8_t md5[16];
atUint8 md5Calc[16]; uint8_t md5Calc[16];
atUint8 tmpIV[16]; uint8_t tmpIV[16];
memcpy(tmpIV, SD_IV, 16); memcpy(tmpIV, SD_IV, 16);
std::cout << "Decrypting: banner.bin..."; std::cout << "Decrypting: banner.bin...";
@ -210,24 +210,24 @@ WiiBanner* WiiSaveReader::readBanner() {
return banner; return banner;
} }
WiiImage* WiiSaveReader::readImage(atUint32 width, atUint32 height) { WiiImage* WiiSaveReader::readImage(uint32_t width, uint32_t height) {
std::unique_ptr<atUint8[]> image = readUBytes(width * height * 2); std::unique_ptr<uint8_t[]> image = readUBytes(width * height * 2);
if (!utility::isEmpty((atInt8*)image.get(), width * height * 2)) if (!utility::isEmpty((int8_t*)image.get(), width * height * 2))
return new WiiImage(width, height, std::move(image)); return new WiiImage(width, height, std::move(image));
return NULL; return NULL;
} }
WiiFile* WiiSaveReader::readFile() { WiiFile* WiiSaveReader::readFile() {
atUint32 fileLen; uint32_t fileLen;
atUint8 permissions; uint8_t permissions;
atUint8 attributes; uint8_t attributes;
atUint8 type; uint8_t type;
std::string name; std::string name;
WiiFile* ret; WiiFile* ret;
atUint32 magic = readUint32(); uint32_t magic = readUint32();
if (magic != 0x03adf17e) { if (magic != 0x03adf17e) {
std::cerr << "Not a valid File entry header: 0x" << std::hex << magic << std::endl; std::cerr << "Not a valid File entry header: 0x" << std::hex << magic << std::endl;
@ -243,17 +243,17 @@ WiiFile* WiiSaveReader::readFile() {
ret->setPermissions(permissions); ret->setPermissions(permissions);
ret->setAttributes(attributes); ret->setAttributes(attributes);
ret->setType((WiiFile::Type)type); ret->setType((WiiFile::Type)type);
std::unique_ptr<atUint8[]> iv = readUBytes(0x10); std::unique_ptr<uint8_t[]> iv = readUBytes(0x10);
seek(0x20); seek(0x20);
if (type == WiiFile::File) { if (type == WiiFile::File) {
// Read file data // Read file data
int roundedLen = (fileLen + 63) & ~63; int roundedLen = (fileLen + 63) & ~63;
std::unique_ptr<atUint8[]> filedata = readUBytes(roundedLen); std::unique_ptr<uint8_t[]> filedata = readUBytes(roundedLen);
// Decrypt file // Decrypt file
std::cout << "Decrypting: " << ret->filename() << "..."; std::cout << "Decrypting: " << ret->filename() << "...";
atUint8* decData = new atUint8[roundedLen]; uint8_t* decData = new uint8_t[roundedLen];
std::unique_ptr<IAES> aes = NewAES(); std::unique_ptr<IAES> aes = NewAES();
aes->setKey(SD_KEY); aes->setKey(SD_KEY);
aes->decrypt(iv.get(), filedata.get(), decData, roundedLen); aes->decrypt(iv.get(), filedata.get(), decData, roundedLen);
@ -265,19 +265,19 @@ WiiFile* WiiSaveReader::readFile() {
return ret; return ret;
} }
void WiiSaveReader::readCerts(atUint32 totalSize) { void WiiSaveReader::readCerts(uint32_t totalSize) {
std::cout << "Reading certs..." << std::endl; std::cout << "Reading certs..." << std::endl;
atUint32 dataSize = totalSize - 0x340; uint32_t dataSize = totalSize - 0x340;
std::unique_ptr<atUint8[]> sig = readUBytes(0x40); std::unique_ptr<uint8_t[]> sig = readUBytes(0x40);
std::unique_ptr<atUint8[]> ngCert = readUBytes(0x180); std::unique_ptr<uint8_t[]> ngCert = readUBytes(0x180);
std::unique_ptr<atUint8[]> apCert = readUBytes(0x180); std::unique_ptr<uint8_t[]> apCert = readUBytes(0x180);
seek(0xF0C0, SeekOrigin::Begin); seek(0xF0C0, SeekOrigin::Begin);
std::unique_ptr<atUint8[]> data = readUBytes(dataSize); std::unique_ptr<uint8_t[]> data = readUBytes(dataSize);
atUint8* hash; uint8_t* hash;
std::cout << "validating..." << std::endl; std::cout << "validating..." << std::endl;
hash = getSha1(data.get(), dataSize); hash = getSha1(data.get(), dataSize);
atUint8* hash2 = getSha1(hash, 20); uint8_t* hash2 = getSha1(hash, 20);
bool ngValid = false; bool ngValid = false;
bool apValid = false; bool apValid = false;
ecc::checkEC(ngCert.get(), apCert.get(), sig.get(), hash2, apValid, ngValid); ecc::checkEC(ngCert.get(), apCert.get(), sig.get(), hash2, apValid, ngValid);

90
src/athena/WiiSaveWriter.cpp
View File

@ -27,8 +27,8 @@ namespace io {
WiiSaveWriter::WiiSaveWriter(const std::string& filename) : MemoryCopyWriter(filename) { setEndian(Endian::Big); } WiiSaveWriter::WiiSaveWriter(const std::string& filename) : MemoryCopyWriter(filename) { setEndian(Endian::Big); }
bool WiiSaveWriter::writeSave(WiiSave* save, atUint8* macAddress, atUint32 ngId, atUint8* ngPriv, atUint8* ngSig, bool WiiSaveWriter::writeSave(WiiSave* save, uint8_t* macAddress, uint32_t ngId, uint8_t* ngPriv, uint8_t* ngSig,
atUint32 ngKeyId, const std::string& filepath) { uint32_t ngKeyId, const std::string& filepath) {
if (!save) { if (!save) {
atError("save cannot be NULL"); atError("save cannot be NULL");
return false; return false;
@ -48,16 +48,16 @@ bool WiiSaveWriter::writeSave(WiiSave* save, atUint8* macAddress, atUint32 ngId,
writeUint32(0); // totalSize writeUint32(0); // totalSize
seek(64); seek(64);
writeUint64(save->banner()->gameID()); writeUint64(save->banner()->gameID());
writeBytes((atInt8*)macAddress, 6); writeBytes((int8_t*)macAddress, 6);
seek(2); // unknown; seek(2); // unknown;
seek(0x10); // padding; seek(0x10); // padding;
atUint32 totalSize = 0; uint32_t totalSize = 0;
for (WiiFile* file : save->allFiles()) { for (WiiFile* file : save->allFiles()) {
totalSize += writeFile(file); totalSize += writeFile(file);
} }
atUint64 pos = position(); uint64_t pos = position();
// Write size data // Write size data
seek(0xF0C0 + 0x10, SeekOrigin::Begin); seek(0xF0C0 + 0x10, SeekOrigin::Begin);
writeUint32(totalSize); writeUint32(totalSize);
@ -75,10 +75,10 @@ bool WiiSaveWriter::writeSave(WiiSave* save, atUint8* macAddress, atUint32 ngId,
void WiiSaveWriter::writeBanner(WiiBanner* banner) { void WiiSaveWriter::writeBanner(WiiBanner* banner) {
setEndian(Endian::Big); setEndian(Endian::Big);
writeInt64(banner->gameID()); writeInt64(banner->gameID());
writeInt32((0x60a0 + 0x1200) * (atUint32)banner->icons().size()); writeInt32((0x60a0 + 0x1200) * (uint32_t)banner->icons().size());
writeByte((atInt8)banner->permissions()); writeByte((int8_t)banner->permissions());
seek(1); seek(1);
writeBytes((atInt8*)MD5_BLANKER, 16); writeBytes((int8_t*)MD5_BLANKER, 16);
seek(2); seek(2);
writeInt32(0x5749424E); // WIBN writeInt32(0x5749424E); // WIBN
writeInt32(banner->flags()); writeInt32(banner->flags());
@ -100,42 +100,42 @@ void WiiSaveWriter::writeBanner(WiiBanner* banner) {
seek(0x00C0, SeekOrigin::Begin); seek(0x00C0, SeekOrigin::Begin);
WiiImage* bannerImage = banner->bannerImage(); WiiImage* bannerImage = banner->bannerImage();
writeBytes((atInt8*)bannerImage->data(), bannerImage->width() * bannerImage->height() * 2); writeBytes((int8_t*)bannerImage->data(), bannerImage->width() * bannerImage->height() * 2);
// For empty icons // For empty icons
atUint8* tmpIcon = new atUint8[48 * 48 * 2]; uint8_t* tmpIcon = new uint8_t[48 * 48 * 2];
memset(tmpIcon, 0, 48 * 48 * 2); memset(tmpIcon, 0, 48 * 48 * 2);
for (atUint32 i = 0; i < 8; ++i) { for (uint32_t i = 0; i < 8; ++i) {
if (i < banner->icons().size()) { if (i < banner->icons().size()) {
writeImage(banner->icons()[i]); writeImage(banner->icons()[i]);
} else { } else {
writeBytes((atInt8*)tmpIcon, 48 * 48 * 2); writeBytes((int8_t*)tmpIcon, 48 * 48 * 2);
} }
} }
delete[] tmpIcon; // delete tmp buffer; delete[] tmpIcon; // delete tmp buffer;
atUint8* hash = new atUint8[0x10]; uint8_t* hash = new uint8_t[0x10];
MD5Hash::MD5(hash, (atUint8*)data(), 0xF0C0); MD5Hash::MD5(hash, (uint8_t*)data(), 0xF0C0);
seek(0x0E, SeekOrigin::Begin); seek(0x0E, SeekOrigin::Begin);
writeBytes((atInt8*)hash, 0x10); writeBytes((int8_t*)hash, 0x10);
std::unique_ptr<IAES> aes = NewAES(); std::unique_ptr<IAES> aes = NewAES();
aes->setKey(SD_KEY); aes->setKey(SD_KEY);
atUint8 data[0xF0C0]; uint8_t data[0xF0C0];
memcpy(data, this->data(), 0xF0C0); memcpy(data, this->data(), 0xF0C0);
atUint8 tmpIV[26]; uint8_t tmpIV[26];
memcpy(tmpIV, SD_IV, 16); memcpy(tmpIV, SD_IV, 16);
aes->encrypt(tmpIV, data, data, 0xF0C0); aes->encrypt(tmpIV, data, data, 0xF0C0);
seek(0, SeekOrigin::Begin); seek(0, SeekOrigin::Begin);
writeBytes((atInt8*)data, 0xF0C0); writeBytes((int8_t*)data, 0xF0C0);
seek(0xF0C0, SeekOrigin::Begin); seek(0xF0C0, SeekOrigin::Begin);
} }
atUint32 WiiSaveWriter::writeFile(WiiFile* file) { uint32_t WiiSaveWriter::writeFile(WiiFile* file) {
atUint32 ret = 0x80; uint32_t ret = 0x80;
// Write the File magic // Write the File magic
writeUint32(0x03ADF17E); writeUint32(0x03ADF17E);
@ -144,28 +144,28 @@ atUint32 WiiSaveWriter::writeFile(WiiFile* file) {
writeByte(file->attributes()); writeByte(file->attributes());
writeByte(file->type()); writeByte(file->type());
atUint8 name[0x45]; uint8_t name[0x45];
utility::fillRandom(name, 0x45); utility::fillRandom(name, 0x45);
memcpy(name, file->fullpath().c_str(), file->fullpath().size()); memcpy(name, file->fullpath().c_str(), file->fullpath().size());
name[file->fullpath().size()] = '\0'; name[file->fullpath().size()] = '\0';
writeBytes((atInt8*)name, 0x45); writeBytes((int8_t*)name, 0x45);
atUint8 iv[16]; uint8_t iv[16];
utility::fillRandom(iv, 0x10); utility::fillRandom(iv, 0x10);
writeBytes((atInt8*)iv, 0x10); writeBytes((int8_t*)iv, 0x10);
atUint8 crap[0x20]; uint8_t crap[0x20];
utility::fillRandom(crap, 0x20); utility::fillRandom(crap, 0x20);
writeBytes((atInt8*)crap, 0x20); writeBytes((int8_t*)crap, 0x20);
if (file->type() == WiiFile::File) { if (file->type() == WiiFile::File) {
int roundedSize = (file->length() + 63) & ~63; int roundedSize = (file->length() + 63) & ~63;
atUint8* data = new atUint8[roundedSize]; uint8_t* data = new uint8_t[roundedSize];
memset(data, 0, roundedSize); memset(data, 0, roundedSize);
std::unique_ptr<IAES> aes = NewAES(); std::unique_ptr<IAES> aes = NewAES();
aes->setKey(SD_KEY); aes->setKey(SD_KEY);
aes->encrypt(iv, file->data(), data, roundedSize); aes->encrypt(iv, file->data(), data, roundedSize);
writeBytes((atInt8*)data, roundedSize); writeBytes((int8_t*)data, roundedSize);
ret += roundedSize; ret += roundedSize;
delete[] data; delete[] data;
} }
@ -174,21 +174,21 @@ atUint32 WiiSaveWriter::writeFile(WiiFile* file) {
} }
void WiiSaveWriter::writeImage(WiiImage* image) { void WiiSaveWriter::writeImage(WiiImage* image) {
atInt8* data = (atInt8*)image->data(); int8_t* data = (int8_t*)image->data();
writeBytes(data, image->width() * image->height() * 2); writeBytes(data, image->width() * image->height() * 2);
} }
void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8* ngPriv, atUint8* ngSig, atUint32 ngKeyId) { void WiiSaveWriter::writeCerts(uint32_t filesSize, uint32_t ngId, uint8_t* ngPriv, uint8_t* ngSig, uint32_t ngKeyId) {
atUint8 sig[0x40]; uint8_t sig[0x40];
atUint8 ngCert[0x180]; uint8_t ngCert[0x180];
atUint8 apCert[0x180]; uint8_t apCert[0x180];
atUint8* hash; uint8_t* hash;
atUint8 apPriv[30]; uint8_t apPriv[30];
atUint8 apSig[60]; uint8_t apSig[60];
char signer[64]; char signer[64];
char name[64]; char name[64];
atUint8* buf; uint8_t* buf;
atUint32 dataSize; uint32_t dataSize;
sprintf(signer, "Root-CA00000001-MS00000002"); sprintf(signer, "Root-CA00000001-MS00000002");
sprintf(name, "NG%08x", ngId); sprintf(name, "NG%08x", ngId);
@ -209,12 +209,12 @@ void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8* ngPri
delete[] hash; delete[] hash;
dataSize = filesSize + 0x80; dataSize = filesSize + 0x80;
buf = new atUint8[dataSize]; buf = new uint8_t[dataSize];
atUint8* rawData = data(); uint8_t* rawData = data();
memcpy(buf, rawData + 0xF0C0, dataSize); memcpy(buf, rawData + 0xF0C0, dataSize);
hash = getSha1(buf, dataSize); hash = getSha1(buf, dataSize);
atUint8* hash2 = getSha1(hash, 20); uint8_t* hash2 = getSha1(hash, 20);
delete[] hash; delete[] hash;
delete[] buf; delete[] buf;
@ -224,12 +224,12 @@ void WiiSaveWriter::writeCerts(atUint32 filesSize, atUint32 ngId, atUint8* ngPri
if (!utility::isSystemBigEndian()) if (!utility::isSystemBigEndian())
stuff = utility::swap32(stuff); stuff = utility::swap32(stuff);
*(atUint32*)(sig + 60) = stuff; *(uint32_t*)(sig + 60) = stuff;
delete[] hash2; delete[] hash2;
writeBytes((atInt8*)sig, 0x40); writeBytes((int8_t*)sig, 0x40);
writeBytes((atInt8*)ngCert, 0x180); writeBytes((int8_t*)ngCert, 0x180);
writeBytes((atInt8*)apCert, 0x180); writeBytes((int8_t*)apCert, 0x180);
} }
} // namespace io } // namespace io

18
src/athena/ZQuestFile.cpp
View File

@ -27,17 +27,17 @@ void initGameStrings() {
GameStrings.push_back("A Link Between Worlds"); GameStrings.push_back("A Link Between Worlds");
} }
const atUint32 ZQuestFile::Major = 2; const uint32_t ZQuestFile::Major = 2;
const atUint32 ZQuestFile::Minor = 0; const uint32_t ZQuestFile::Minor = 0;
const atUint32 ZQuestFile::Revision = 0; const uint32_t ZQuestFile::Revision = 0;
const atUint32 ZQuestFile::Version = Major | (Minor << 8) | (Revision << 16); const uint32_t ZQuestFile::Version = Major | (Minor << 8) | (Revision << 16);
const atUint32 ZQuestFile::Magic = 'Z' | ('Q' << 8) | ('S' << 16) | (('0' + ZQuestFile::Major) << 24); const uint32_t ZQuestFile::Magic = 'Z' | ('Q' << 8) | ('S' << 16) | (('0' + ZQuestFile::Major) << 24);
ZQuestFile::ZQuestFile() : m_game(NoGame), m_endian(Endian::Little), m_length(0) { initGameStrings(); } ZQuestFile::ZQuestFile() : m_game(NoGame), m_endian(Endian::Little), m_length(0) { initGameStrings(); }
ZQuestFile::ZQuestFile(ZQuestFile::Game game, Endian endian, std::unique_ptr<atUint8[]>&& data, atUint32 length, ZQuestFile::ZQuestFile(ZQuestFile::Game game, Endian endian, std::unique_ptr<uint8_t[]>&& data, uint32_t length,
const std::string& gameString) const std::string& gameString)
: m_game(game), m_gameString(gameString), m_endian(endian), m_data(std::move(data)), m_length(length) { : m_game(game), m_gameString(gameString), m_endian(endian), m_data(std::move(data)), m_length(length) {
initGameStrings(); initGameStrings();
@ -61,14 +61,14 @@ void ZQuestFile::setEndian(Endian endian) { m_endian = endian; }
Endian ZQuestFile::endian() const { return m_endian; } Endian ZQuestFile::endian() const { return m_endian; }
void ZQuestFile::setData(std::unique_ptr<atUint8[]>&& data, atUint32 length) { void ZQuestFile::setData(std::unique_ptr<uint8_t[]>&& data, uint32_t length) {
m_data = std::move(data); m_data = std::move(data);
m_length = length; m_length = length;
} }
atUint8* ZQuestFile::data() const { return m_data.get(); } uint8_t* ZQuestFile::data() const { return m_data.get(); }
atUint32 ZQuestFile::length() const { return m_length; } uint32_t ZQuestFile::length() const { return m_length; }
void ZQuestFile::setGameString(const std::string& gameString) { m_gameString = gameString; } void ZQuestFile::setGameString(const std::string& gameString) { m_gameString = gameString; }

14
src/athena/ZQuestFileReader.cpp
View File

@ -9,16 +9,16 @@
namespace athena::io { namespace athena::io {
ZQuestFileReader::ZQuestFileReader(atUint8* data, atUint64 length) : MemoryCopyReader(data, length) {} ZQuestFileReader::ZQuestFileReader(uint8_t* data, uint64_t length) : MemoryCopyReader(data, length) {}
ZQuestFileReader::ZQuestFileReader(const std::string& filename) : MemoryCopyReader(filename) {} ZQuestFileReader::ZQuestFileReader(const std::string& filename) : MemoryCopyReader(filename) {}
ZQuestFile* ZQuestFileReader::read() { ZQuestFile* ZQuestFileReader::read() {
atUint32 magic, version, compressedLen, uncompressedLen; uint32_t magic, version, compressedLen, uncompressedLen;
ZQuestFile::Game game = ZQuestFile::NoGame; ZQuestFile::Game game = ZQuestFile::NoGame;
std::string gameString; std::string gameString;
atUint16 BOM; uint16_t BOM;
atUint32 checksum = 0; uint32_t checksum = 0;
magic = readUint32(); magic = readUint32();
@ -56,7 +56,7 @@ ZQuestFile* ZQuestFileReader::read() {
seek(0x0A); seek(0x0A);
} }
std::unique_ptr<atUint8[]> data = readUBytes(compressedLen); // compressedLen is always the total file size std::unique_ptr<uint8_t[]> data = readUBytes(compressedLen); // compressedLen is always the total file size
if (version >= ZQUEST_VERSION_CHECK(2, 0, 0)) { if (version >= ZQUEST_VERSION_CHECK(2, 0, 0)) {
if (checksum != athena::checksums::crc32(data.get(), compressedLen)) { if (checksum != athena::checksums::crc32(data.get(), compressedLen)) {
@ -70,8 +70,8 @@ ZQuestFile* ZQuestFileReader::read() {
} }
if (compressedLen != uncompressedLen) { if (compressedLen != uncompressedLen) {
atUint8* dst = new atUint8[uncompressedLen]; uint8_t* dst = new uint8_t[uncompressedLen];
atUint32 dstLen = io::Compression::decompressZlib(data.get(), compressedLen, dst, uncompressedLen); uint32_t dstLen = io::Compression::decompressZlib(data.get(), compressedLen, dst, uncompressedLen);
if (dstLen != uncompressedLen) { if (dstLen != uncompressedLen) {
delete[] dst; delete[] dst;

12
src/athena/ZQuestFileWriter.cpp
View File

@ -5,7 +5,7 @@
namespace athena::io { namespace athena::io {
ZQuestFileWriter::ZQuestFileWriter(atUint8* data, atUint64 length) : MemoryCopyWriter(data, length) {} ZQuestFileWriter::ZQuestFileWriter(uint8_t* data, uint64_t length) : MemoryCopyWriter(data, length) {}
ZQuestFileWriter::ZQuestFileWriter(const std::string& filename) : MemoryCopyWriter(filename) {} ZQuestFileWriter::ZQuestFileWriter(const std::string& filename) : MemoryCopyWriter(filename) {}
@ -17,12 +17,12 @@ void ZQuestFileWriter::write(ZQuestFile* quest, bool compress) {
writeUint32(ZQuestFile::Magic); writeUint32(ZQuestFile::Magic);
writeUint32(ZQuestFile::Version); writeUint32(ZQuestFile::Version);
atUint8* questData = quest->data(); uint8_t* questData = quest->data();
atUint32 compLen; uint32_t compLen;
if (compress) { if (compress) {
atUint8* compData = uint8_t* compData =
new atUint8[quest->length() + 0x40]; // add 20 bytes because sometimes the file grows with compression new uint8_t[quest->length() + 0x40]; // add 20 bytes because sometimes the file grows with compression
compLen = quest->length() + 0x40; compLen = quest->length() + 0x40;
compLen = io::Compression::compressZlib(questData, quest->length(), compData, compLen); compLen = io::Compression::compressZlib(questData, quest->length(), compData, compLen);
@ -44,7 +44,7 @@ void ZQuestFileWriter::write(ZQuestFile* quest, bool compress) {
} }
writeUint32(quest->length()); writeUint32(quest->length());
writeBytes((atInt8*)quest->gameString().substr(0, 0x0A).c_str(), 0x0A); writeBytes((int8_t*)quest->gameString().substr(0, 0x0A).c_str(), 0x0A);
writeUint16(quest->endian() == Endian::Big ? 0xFFFE : 0xFEFF); writeUint16(quest->endian() == Endian::Big ? 0xFFFE : 0xFEFF);
writeUint32(athena::checksums::crc32(questData, compLen)); writeUint32(athena::checksums::crc32(questData, compLen));
writeUBytes(questData, compLen); writeUBytes(questData, compLen);

38
src/bn.cpp
View File

@ -5,21 +5,21 @@
namespace bignum { namespace bignum {
void subModulus(atUint8* a, const atUint8* N, atUint32 n) { void subModulus(uint8_t* a, const uint8_t* N, uint32_t n) {
atUint8 c = 0; uint8_t c = 0;
for (atUint32 i = n - 1; i < n; i--) { for (uint32_t i = n - 1; i < n; i--) {
atUint32 dig = N[i] + c; uint32_t dig = N[i] + c;
c = (a[i] < dig); c = (a[i] < dig);
a[i] -= dig; a[i] -= dig;
} }
} }
void add(atUint8* d, atUint8* a, const atUint8* b, const atUint8* N, atUint32 n) { void add(uint8_t* d, uint8_t* a, const uint8_t* b, const uint8_t* N, uint32_t n) {
atUint8 c = 0; uint8_t c = 0;
for (atUint32 i = n - 1; i < n; i--) { for (uint32_t i = n - 1; i < n; i--) {
atUint32 dig = a[i] + b[i] + c; uint32_t dig = a[i] + b[i] + c;
c = (dig >= 0x100); c = (dig >= 0x100);
d[i] = dig; d[i] = dig;
} }
@ -31,11 +31,11 @@ void add(atUint8* d, atUint8* a, const atUint8* b, const atUint8* N, atUint32 n)
subModulus(d, N, n); subModulus(d, N, n);
} }
void mul(atUint8* d, atUint8* a, const atUint8* b, const atUint8* N, atUint32 n) { void mul(uint8_t* d, uint8_t* a, const uint8_t* b, const uint8_t* N, uint32_t n) {
memset(d, 0, n); memset(d, 0, n);
for (atUint32 i = 0; i < n; i++) { for (uint32_t i = 0; i < n; i++) {
for (atUint8 mask = 0x80; mask != 0; mask >>= 1) { for (uint8_t mask = 0x80; mask != 0; mask >>= 1) {
add(d, d, d, N, n); add(d, d, d, N, n);
if ((a[i] & mask) != 0) if ((a[i] & mask) != 0)
@ -44,13 +44,13 @@ void mul(atUint8* d, atUint8* a, const atUint8* b, const atUint8* N, atUint32 n)
} }
} }
void exp(atUint8* d, const atUint8* a, const atUint8* N, atUint32 n, atUint8* e, atUint32 en) { void exp(uint8_t* d, const uint8_t* a, const uint8_t* N, uint32_t n, uint8_t* e, uint32_t en) {
atUint8 t[512]; uint8_t t[512];
memset(d, 0, n); memset(d, 0, n);
d[n - 1] = 1; d[n - 1] = 1;
for (atUint32 i = 0; i < en; i++) { for (uint32_t i = 0; i < en; i++) {
for (atUint8 mask = 0x80; mask != 0; mask >>= 1) { for (uint8_t mask = 0x80; mask != 0; mask >>= 1) {
mul(t, d, d, N, n); mul(t, d, d, N, n);
if ((e[i] & mask) != 0) if ((e[i] & mask) != 0)
@ -61,8 +61,8 @@ void exp(atUint8* d, const atUint8* a, const atUint8* N, atUint32 n, atUint8* e,
} }
} }
void inv(atUint8* d, atUint8* a, const atUint8* N, atUint32 n) { void inv(uint8_t* d, uint8_t* a, const uint8_t* N, uint32_t n) {
atUint8 t[512], s[512]; uint8_t t[512], s[512];
memcpy(t, N, n); memcpy(t, N, n);
memset(s, 0, n); memset(s, 0, n);
@ -71,8 +71,8 @@ void inv(atUint8* d, atUint8* a, const atUint8* N, atUint32 n) {
exp(d, a, N, n, t, n); exp(d, a, N, n, t, n);
} }
int compare(const atUint8* a, const atUint8* b, atUint32 n) { int compare(const uint8_t* a, const uint8_t* b, uint32_t n) {
for (atUint32 i = 0; i < n; i++) { for (uint32_t i = 0; i < n; i++) {
if (a[i] < b[i]) if (a[i] < b[i])
return -1; return -1;

120
src/ec.cpp
View File

@ -6,20 +6,20 @@
#include "sha1.h" #include "sha1.h"
namespace ecc { namespace ecc {
static int checkZero(const atUint8* d) { return !memcmp(d, d + 1, 29) && d[0] == 0; } static int checkZero(const uint8_t* d) { return !memcmp(d, d + 1, 29) && d[0] == 0; }
static void add(atUint8* d, const atUint8* a, const atUint8* b) { static void add(uint8_t* d, const uint8_t* a, const uint8_t* b) {
for (atUint32 i = 0; i < 30; i++) for (uint32_t i = 0; i < 30; i++)
d[i] = a[i] ^ b[i]; d[i] = a[i] ^ b[i];
} }
static void multiply(atUint8* d, const atUint8* a, const atUint8* b) { static void multiply(uint8_t* d, const uint8_t* a, const uint8_t* b) {
memset(d, 0, 30); memset(d, 0, 30);
for (atUint32 n = 0, i = 0, mask = 1; n < 233; n++) { for (uint32_t n = 0, i = 0, mask = 1; n < 233; n++) {
atUint8 x, y; uint8_t x, y;
atUint8 carry = d[0] & 1; uint8_t carry = d[0] & 1;
x = 0; x = 0;
for (atUint32 i = 0; i < 29; i++) { for (uint32_t i = 0; i < 29; i++) {
y = d[i + 1]; y = d[i + 1];
d[i] = x ^ (y >> 7); d[i] = x ^ (y >> 7);
x = y << 1; x = y << 1;
@ -38,18 +38,18 @@ static void multiply(atUint8* d, const atUint8* a, const atUint8* b) {
} }
} }
static void squareToWide(atUint8* d, const atUint8* a) { static void squareToWide(uint8_t* d, const uint8_t* a) {
static const atUint8 sq[16] = {0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15, static const uint8_t sq[16] = {0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x15,
0x40, 0x41, 0x44, 0x45, 0x50, 0x51, 0x54, 0x55}; 0x40, 0x41, 0x44, 0x45, 0x50, 0x51, 0x54, 0x55};
for (atUint32 i = 0; i < 30; i++) { for (uint32_t i = 0; i < 30; i++) {
d[2 * i] = sq[a[i] >> 4]; d[2 * i] = sq[a[i] >> 4];
d[2 * i + 1] = sq[a[i] & 15]; d[2 * i + 1] = sq[a[i] & 15];
} }
} }
static void wideReduce(atUint8* d) { static void wideReduce(uint8_t* d) {
atUint32 i; uint32_t i;
atUint8 x; uint8_t x;
for (i = 0; i < 30; i++) { for (i = 0; i < 30; i++) {
x = d[i]; x = d[i];
@ -67,8 +67,8 @@ static void wideReduce(atUint8* d) {
d[30] &= 1; d[30] &= 1;
} }
static void square(atUint8* d, const atUint8* a) { static void square(uint8_t* d, const uint8_t* a) {
atUint8 wide[60]; uint8_t wide[60];
squareToWide(wide, a); squareToWide(wide, a);
wideReduce(wide); wideReduce(wide);
@ -76,8 +76,8 @@ static void square(atUint8* d, const atUint8* a) {
memcpy(d, wide + 30, 30); memcpy(d, wide + 30, 30);
} }
static void itInvert(atUint8* d, const atUint8* a, const atUint8* b, atUint32 j) { static void itInvert(uint8_t* d, const uint8_t* a, const uint8_t* b, uint32_t j) {
atUint8 t[30]; uint8_t t[30];
memcpy(t, a, 30); memcpy(t, a, 30);
while (j--) { while (j--) {
square(d, t); square(d, t);
@ -86,9 +86,9 @@ static void itInvert(atUint8* d, const atUint8* a, const atUint8* b, atUint32 j)
multiply(d, t, b); multiply(d, t, b);
} }
static void invert(atUint8* d, const atUint8* a) { static void invert(uint8_t* d, const uint8_t* a) {
atUint8 t[30]; uint8_t t[30];
atUint8 s[30]; uint8_t s[30];
itInvert(t, a, a, 1); itInvert(t, a, a, 1);
itInvert(s, t, a, 1); itInvert(s, t, a, 1);
@ -103,12 +103,12 @@ static void invert(atUint8* d, const atUint8* a) {
square(d, s); square(d, s);
} }
static void pointDouble(atUint8* r, const atUint8* p) { static void pointDouble(uint8_t* r, const uint8_t* p) {
atUint8 s[30], t[30]; uint8_t s[30], t[30];
const atUint8* px = p; const uint8_t* px = p;
const atUint8* py = p + 30; const uint8_t* py = p + 30;
atUint8* rx = r; uint8_t* rx = r;
atUint8* ry = r + 30; uint8_t* ry = r + 30;
if (checkZero(px)) { if (checkZero(px)) {
memset(rx, 0, 30); memset(rx, 0, 30);
@ -132,14 +132,14 @@ static void pointDouble(atUint8* r, const atUint8* p) {
add(ry, ry, t); add(ry, ry, t);
} }
static void pointAdd(atUint8* r, const atUint8* p, const atUint8* q) { static void pointAdd(uint8_t* r, const uint8_t* p, const uint8_t* q) {
atUint8 s[30], t[30], u[30]; uint8_t s[30], t[30], u[30];
const atUint8* px = p; const uint8_t* px = p;
const atUint8* py = p + 30; const uint8_t* py = p + 30;
const atUint8* qx = q; const uint8_t* qx = q;
const atUint8* qy = q + 30; const uint8_t* qy = q + 30;
atUint8* rx = r; uint8_t* rx = r;
atUint8* ry = r + 30; uint8_t* ry = r + 30;
if (checkZero(p) && checkZero(p + 30)) { if (checkZero(p) && checkZero(p + 30)) {
memcpy(rx, qx, 30); memcpy(rx, qx, 30);
@ -183,11 +183,11 @@ static void pointAdd(atUint8* r, const atUint8* p, const atUint8* q) {
add(ry, s, rx); add(ry, s, rx);
} }
static void pointMultiply(atUint8* d, const atUint8* a, const atUint8* b) { static void pointMultiply(uint8_t* d, const uint8_t* a, const uint8_t* b) {
memset(d, 0, 30); memset(d, 0, 30);
memset(d + 30, 0, 30); memset(d + 30, 0, 30);
for (atUint32 i = 0; i < 30; i++) { for (uint32_t i = 0; i < 30; i++) {
for (atUint8 mask = 0x80; mask != 0; mask >>= 1) { for (uint8_t mask = 0x80; mask != 0; mask >>= 1) {
pointDouble(d, d); pointDouble(d, d);
if ((a[i] & mask) != 0) if ((a[i] & mask) != 0)
@ -196,21 +196,21 @@ static void pointMultiply(atUint8* d, const atUint8* a, const atUint8* b) {
} }
} }
static const atUint8 ecG[60] = {0x00, 0xfa, 0xc9, 0xdf, 0xcb, 0xac, 0x83, 0x13, 0xbb, 0x21, 0x39, 0xf1, static const uint8_t ecG[60] = {0x00, 0xfa, 0xc9, 0xdf, 0xcb, 0xac, 0x83, 0x13, 0xbb, 0x21, 0x39, 0xf1,
0xbb, 0x75, 0x5f, 0xef, 0x65, 0xbc, 0x39, 0x1f, 0x8b, 0x36, 0xf8, 0xf8, 0xbb, 0x75, 0x5f, 0xef, 0x65, 0xbc, 0x39, 0x1f, 0x8b, 0x36, 0xf8, 0xf8,
0xeb, 0x73, 0x71, 0xfd, 0x55, 0x8b, 0x01, 0x00, 0x6a, 0x08, 0xa4, 0x19, 0xeb, 0x73, 0x71, 0xfd, 0x55, 0x8b, 0x01, 0x00, 0x6a, 0x08, 0xa4, 0x19,
0x03, 0x35, 0x06, 0x78, 0xe5, 0x85, 0x28, 0xbe, 0xbf, 0x8a, 0x0b, 0xef, 0x03, 0x35, 0x06, 0x78, 0xe5, 0x85, 0x28, 0xbe, 0xbf, 0x8a, 0x0b, 0xef,
0xf8, 0x67, 0xa7, 0xca, 0x36, 0x71, 0x6f, 0x7e, 0x01, 0xf8, 0x10, 0x52}; 0xf8, 0x67, 0xa7, 0xca, 0x36, 0x71, 0x6f, 0x7e, 0x01, 0xf8, 0x10, 0x52};
static const atUint8 ecN[30] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, static const uint8_t ecN[30] = {0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xe9, 0x74, 0xe7, 0x2f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xe9, 0x74, 0xe7, 0x2f,
0x8a, 0x69, 0x22, 0x03, 0x1d, 0x26, 0x03, 0xcf, 0xe0, 0xd7}; 0x8a, 0x69, 0x22, 0x03, 0x1d, 0x26, 0x03, 0xcf, 0xe0, 0xd7};
bool checkECDSA(atUint8* Q, atUint8* R, atUint8* S, atUint8* hash) { bool checkECDSA(uint8_t* Q, uint8_t* R, uint8_t* S, uint8_t* hash) {
atUint8 Sinv[30]; uint8_t Sinv[30];
atUint8 e[30]; uint8_t e[30];
atUint8 w1[30], w2[30]; uint8_t w1[30], w2[30];
atUint8 r1[60], r2[60]; uint8_t r1[60], r2[60];
bignum::inv(Sinv, S, ecN, 30); bignum::inv(Sinv, S, ecN, 30);
@ -231,35 +231,35 @@ bool checkECDSA(atUint8* Q, atUint8* R, atUint8* S, atUint8* hash) {
return (bignum::compare(r1, R, 30) == 0); return (bignum::compare(r1, R, 30) == 0);
} }
void makeECCert(atUint8* cert, atUint8* sig, const char* signer, const char* name, atUint8* priv, atUint32 keyId) { void makeECCert(uint8_t* cert, uint8_t* sig, const char* signer, const char* name, uint8_t* priv, uint32_t keyId) {
memset(cert, 0, 0x180); memset(cert, 0, 0x180);
*(atUint32*)(cert) = 0x10002; *(uint32_t*)(cert) = 0x10002;
if (!athena::utility::isSystemBigEndian()) if (!athena::utility::isSystemBigEndian())
*(atUint32*)(cert) = athena::utility::swapU32(*(atUint32*)(cert)); *(uint32_t*)(cert) = athena::utility::swapU32(*(uint32_t*)(cert));
memcpy((char*)cert + 4, sig, 60); memcpy((char*)cert + 4, sig, 60);
strcpy((char*)cert + 0x80, signer); strcpy((char*)cert + 0x80, signer);
*(atUint32*)(cert + 0xc0) = 2; *(uint32_t*)(cert + 0xc0) = 2;
if (!athena::utility::isSystemBigEndian()) if (!athena::utility::isSystemBigEndian())
*(atUint32*)(cert + 0xc0) = athena::utility::swapU32(*(atUint32*)(cert + 0xc0)); *(uint32_t*)(cert + 0xc0) = athena::utility::swapU32(*(uint32_t*)(cert + 0xc0));
strcpy((char*)cert + 0xc4, name); strcpy((char*)cert + 0xc4, name);
*(atUint32*)(cert + 0x104) = keyId; *(uint32_t*)(cert + 0x104) = keyId;
if (!athena::utility::isSystemBigEndian()) if (!athena::utility::isSystemBigEndian())
*(atUint32*)(cert + 0x104) = athena::utility::swapU32(*(atUint32*)(cert + 0x104)); *(uint32_t*)(cert + 0x104) = athena::utility::swapU32(*(uint32_t*)(cert + 0x104));
pointMultiply(cert + 0x108, priv, ecG); pointMultiply(cert + 0x108, priv, ecG);
} }
void createECDSA(atUint8* R, atUint8* S, atUint8* k, atUint8* hash) { void createECDSA(uint8_t* R, uint8_t* S, uint8_t* k, uint8_t* hash) {
atUint8 e[30]; uint8_t e[30];
atUint8 kk[30]; uint8_t kk[30];
atUint8 m[30]; uint8_t m[30];
atUint8 minv[30]; uint8_t minv[30];
atUint8 mG[60]; uint8_t mG[60];
memset(e, 0, 30); memset(e, 0, 30);
memcpy(e + 10, hash, 20); memcpy(e + 10, hash, 20);
@ -284,8 +284,8 @@ void createECDSA(atUint8* R, atUint8* S, atUint8* k, atUint8* hash) {
bignum::mul(S, minv, kk, ecN, 30); bignum::mul(S, minv, kk, ecN, 30);
} }
void checkEC(atUint8* ng, atUint8* ap, atUint8* sig, atUint8* sigHash, bool& apValid, bool& ngValid) { void checkEC(uint8_t* ng, uint8_t* ap, uint8_t* sig, uint8_t* sigHash, bool& apValid, bool& ngValid) {
atUint8* apHash = getSha1(ap + 0x80, 0x100); uint8_t* apHash = getSha1(ap + 0x80, 0x100);
ngValid = checkECDSA(ng + 0x0108, ap + 0x04, ap + 0x22, apHash); ngValid = checkECDSA(ng + 0x0108, ap + 0x04, ap + 0x22, apHash);
apValid = checkECDSA(ap + 0x0108, sig, sig + 30, sigHash); apValid = checkECDSA(ap + 0x0108, sig, sig + 30, sigHash);
} }

6
src/sha1.cpp
View File

@ -334,15 +334,15 @@ void SHA1PadMessage(SHA1Context* context) {
SHA1ProcessMessageBlock(context); SHA1ProcessMessageBlock(context);
} }
atUint8* getSha1(atUint8* stuff, atUint32 stuff_size) { uint8_t* getSha1(uint8_t* stuff, uint32_t stuff_size) {
SHA1Context sha; SHA1Context sha;
SHA1Reset(&sha); SHA1Reset(&sha);
SHA1Input(&sha, (const atUint8*)stuff, stuff_size); SHA1Input(&sha, (const uint8_t*)stuff, stuff_size);
if (!SHA1Result(&sha)) if (!SHA1Result(&sha))
return 0; return 0;
atUint8* ret = new atUint8[20]; uint8_t* ret = new uint8_t[20];
memset(ret, 0, 20); memset(ret, 0, 20);
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {