mirror of https://github.com/libAthena/athena.git
748 lines
14 KiB
C++
748 lines
14 KiB
C++
#include "athena/ALTTPQuest.hpp"
|
|
#include <iostream>
|
|
|
|
namespace athena
|
|
{
|
|
|
|
ALTTPQuest::ALTTPQuest()
|
|
{
|
|
}
|
|
|
|
ALTTPQuest::~ALTTPQuest()
|
|
{
|
|
m_roomFlags.clear();
|
|
m_overworldEvents.clear();
|
|
m_oldManFlags.clear();
|
|
m_playerName.clear();
|
|
m_unknown1.clear();
|
|
}
|
|
|
|
void ALTTPQuest::setRoomFlags(std::vector<ALTTPRoomFlags*> rf)
|
|
{
|
|
m_roomFlags = rf;
|
|
}
|
|
|
|
void ALTTPQuest::setRoomFlags(ALTTPRoomFlags* rf, atUint32 id)
|
|
{
|
|
m_roomFlags[id] = rf;
|
|
}
|
|
|
|
std::vector<ALTTPRoomFlags*> ALTTPQuest::roomFlags()
|
|
{
|
|
return m_roomFlags;
|
|
}
|
|
|
|
ALTTPRoomFlags* ALTTPQuest::roomFlags(atUint32 id)
|
|
{
|
|
return m_roomFlags[id];
|
|
}
|
|
|
|
void ALTTPQuest::setOverworldEvents(std::vector<ALTTPOverworldEvent*> ow)
|
|
{
|
|
m_overworldEvents = ow;
|
|
}
|
|
|
|
void ALTTPQuest::setOverworldEvents(ALTTPOverworldEvent* ow, atUint32 id)
|
|
{
|
|
m_overworldEvents[id] = ow;
|
|
}
|
|
|
|
std::vector<ALTTPOverworldEvent*> ALTTPQuest::overworldEvents() const
|
|
{
|
|
return m_overworldEvents;
|
|
}
|
|
|
|
ALTTPOverworldEvent* ALTTPQuest::overworldEvent(atUint32 id) const
|
|
{
|
|
if (id > m_overworldEvents.size() - 1)
|
|
{
|
|
atWarning("index out of range");
|
|
return nullptr;
|
|
}
|
|
|
|
return m_overworldEvents[id];
|
|
}
|
|
|
|
void ALTTPQuest::setInventory(const ALTTPInventory& inv)
|
|
{
|
|
m_inventory = inv;
|
|
}
|
|
|
|
const ALTTPInventory& ALTTPQuest::inventory() const
|
|
{
|
|
return m_inventory;
|
|
}
|
|
|
|
void ALTTPQuest::setRupeeMax(atUint16 val)
|
|
{
|
|
m_rupeeMax = val;
|
|
}
|
|
|
|
atUint16 ALTTPQuest::rupeeMax() const
|
|
{
|
|
return m_rupeeMax;
|
|
}
|
|
|
|
void ALTTPQuest::setRupeeCurrent(atUint16 val)
|
|
{
|
|
m_rupeeCurrent = val;
|
|
}
|
|
|
|
atUint16 ALTTPQuest::rupeeCurrent() const
|
|
{
|
|
return m_rupeeCurrent;
|
|
}
|
|
|
|
void ALTTPQuest::setCompasses(ALTTPDungeonItemFlags flags)
|
|
{
|
|
m_compasses = flags;
|
|
}
|
|
|
|
ALTTPDungeonItemFlags ALTTPQuest::compasses() const
|
|
{
|
|
return m_compasses;
|
|
}
|
|
|
|
void ALTTPQuest::setBigKeys(ALTTPDungeonItemFlags flags)
|
|
{
|
|
m_bigKeys = flags;
|
|
}
|
|
|
|
ALTTPDungeonItemFlags ALTTPQuest::bigKeys() const
|
|
{
|
|
return m_bigKeys;
|
|
}
|
|
|
|
void ALTTPQuest::setDungeonMaps(ALTTPDungeonItemFlags flags)
|
|
{
|
|
m_dungeonMaps = flags;
|
|
}
|
|
|
|
ALTTPDungeonItemFlags ALTTPQuest::dungeonMaps() const
|
|
{
|
|
return m_dungeonMaps;
|
|
}
|
|
|
|
void ALTTPQuest::setWishingPond(atUint16 val)
|
|
{
|
|
m_wishingPond = val;
|
|
}
|
|
|
|
atUint16 ALTTPQuest::wishingPond() const
|
|
{
|
|
return m_wishingPond;
|
|
}
|
|
|
|
void ALTTPQuest::setHealthMax(atUint8 val)
|
|
{
|
|
m_healthMax = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::healthMax() const
|
|
{
|
|
return m_healthMax;
|
|
}
|
|
|
|
void ALTTPQuest::setHealth(atUint8 val)
|
|
{
|
|
m_health = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::health() const
|
|
{
|
|
return m_health;
|
|
}
|
|
|
|
void ALTTPQuest::setMagicPower(atUint8 val)
|
|
{
|
|
m_magicPower = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::magicPower() const
|
|
{
|
|
return m_magicPower;
|
|
}
|
|
|
|
void ALTTPQuest::setKeys(atUint8 val)
|
|
{
|
|
m_keys = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::keys() const
|
|
{
|
|
return m_keys;
|
|
}
|
|
|
|
void ALTTPQuest::setBombUpgrades(atUint8 val)
|
|
{
|
|
m_bombUpgrades = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::bombUpgrades() const
|
|
{
|
|
return m_bombUpgrades;
|
|
}
|
|
|
|
void ALTTPQuest::setArrowUpgrades(atUint8 val)
|
|
{
|
|
m_arrowUpgrades = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::arrowUpgrades() const
|
|
{
|
|
return m_arrowUpgrades;
|
|
}
|
|
|
|
void ALTTPQuest::setHealthFiller(atUint8 val)
|
|
{
|
|
m_heartFiller = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::healthFiller() const
|
|
{
|
|
return m_heartFiller;
|
|
}
|
|
void ALTTPQuest::setMagicFiller(atUint8 val)
|
|
{
|
|
m_heartFiller = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::magicFiller() const
|
|
{
|
|
return m_heartFiller;
|
|
}
|
|
|
|
void ALTTPQuest::setPendants(ALTTPPendants val)
|
|
{
|
|
m_pendants = val;
|
|
}
|
|
|
|
ALTTPPendants ALTTPQuest::pendants() const
|
|
{
|
|
return m_pendants;
|
|
}
|
|
|
|
void ALTTPQuest::setBombFiller(atUint8 val)
|
|
{
|
|
m_bombFiller = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::bombFiller() const
|
|
{
|
|
return m_bombFiller;
|
|
}
|
|
|
|
void ALTTPQuest::setArrowFiller(atUint8 val)
|
|
{
|
|
m_arrowFiller = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::arrowFiller() const
|
|
{
|
|
return m_arrowFiller;
|
|
}
|
|
void ALTTPQuest::setArrows(atUint8 val)
|
|
{
|
|
m_arrows = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::arrows() const
|
|
{
|
|
return m_arrows;
|
|
}
|
|
|
|
void ALTTPQuest::setAbilityFlags(ALTTPAbilities val)
|
|
{
|
|
m_abilityFlags = val;
|
|
}
|
|
|
|
ALTTPAbilities ALTTPQuest::abilityFlags() const
|
|
{
|
|
return m_abilityFlags;
|
|
}
|
|
|
|
void ALTTPQuest::setCrystals(ALTTPCrystals val)
|
|
{
|
|
m_crystals = val;
|
|
}
|
|
|
|
ALTTPCrystals ALTTPQuest::crystals() const
|
|
{
|
|
return m_crystals;
|
|
}
|
|
|
|
void ALTTPQuest::setMagicUsage(ALTTPMagicUsage val)
|
|
{
|
|
m_magicUsage = val;
|
|
}
|
|
|
|
ALTTPMagicUsage ALTTPQuest::magicUsage() const
|
|
{
|
|
return m_magicUsage;
|
|
}
|
|
|
|
void ALTTPQuest::setDungeonKeys(std::vector<atUint8> val)
|
|
{
|
|
m_dungeonKeys = val;
|
|
}
|
|
|
|
void ALTTPQuest::setDungeonKeys(atUint32 id, atUint8 val)
|
|
{
|
|
if (id > m_dungeonKeys.size() - 1)
|
|
{
|
|
atWarning("index out of range");
|
|
return;
|
|
}
|
|
|
|
m_dungeonKeys[id] = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::dungeonKeys(atUint32 id) const
|
|
{
|
|
if (id > m_dungeonKeys.size() - 1)
|
|
{
|
|
atWarning("index out of range");
|
|
return 0;
|
|
}
|
|
|
|
return m_dungeonKeys[id];
|
|
}
|
|
|
|
atUint32 ALTTPQuest::dungeonCount() const
|
|
{
|
|
return (atUint32)m_dungeonKeys.size();
|
|
}
|
|
|
|
|
|
void ALTTPQuest::setProgressIndicator(ALTTPProgressIndicator val)
|
|
{
|
|
m_progressIndicator = val;
|
|
}
|
|
|
|
ALTTPProgressIndicator ALTTPQuest::progressIndicator() const
|
|
{
|
|
return m_progressIndicator;
|
|
}
|
|
|
|
void ALTTPQuest::setProgressFlags1(ALTTPProgressFlags1 val)
|
|
{
|
|
m_progressFlags1 = val;
|
|
}
|
|
|
|
ALTTPProgressFlags1 ALTTPQuest::progressFlags1() const
|
|
{
|
|
return m_progressFlags1;
|
|
}
|
|
|
|
void ALTTPQuest::setMapIcon(ALTTPMapIcon val)
|
|
{
|
|
m_mapIcon = val;
|
|
}
|
|
|
|
ALTTPMapIcon ALTTPQuest::mapIcon() const
|
|
{
|
|
return m_mapIcon;
|
|
}
|
|
|
|
void ALTTPQuest::setStartLocation(ALTTPStartLocation val)
|
|
{
|
|
m_startLocation = val;
|
|
}
|
|
|
|
ALTTPStartLocation ALTTPQuest::startLocation() const
|
|
{
|
|
return m_startLocation;
|
|
}
|
|
|
|
void ALTTPQuest::setProgressFlags2(ALTTPProgressFlags2 val)
|
|
{
|
|
m_progressFlags2 = val;
|
|
}
|
|
|
|
ALTTPProgressFlags2 ALTTPQuest::progressFlags2() const
|
|
{
|
|
return m_progressFlags2;
|
|
}
|
|
|
|
void ALTTPQuest::setLightDarkWorldIndicator(ALTTPLightDarkWorldIndicator val)
|
|
{
|
|
m_lightDarkWorldIndicator = val;
|
|
}
|
|
|
|
ALTTPLightDarkWorldIndicator ALTTPQuest::lightDarkWorldIndicator() const
|
|
{
|
|
return m_lightDarkWorldIndicator;
|
|
}
|
|
|
|
void ALTTPQuest::setTagAlong(ALTTPTagAlong val)
|
|
{
|
|
m_tagAlong = val;
|
|
}
|
|
|
|
ALTTPTagAlong ALTTPQuest::tagAlong() const
|
|
{
|
|
return m_tagAlong;
|
|
}
|
|
|
|
void ALTTPQuest::setOldManFlags(std::vector<atUint8> flags)
|
|
{
|
|
m_oldManFlags = flags;
|
|
}
|
|
|
|
void ALTTPQuest::setOldManFlag(atUint32 id, atUint8 val)
|
|
{
|
|
if (id > m_oldManFlags.size() - 1)
|
|
{
|
|
atWarning("index out of range");
|
|
return;
|
|
}
|
|
|
|
m_oldManFlags[id] = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::oldManFlag(atUint32 id)
|
|
{
|
|
if (id > m_oldManFlags.size() - 1)
|
|
{
|
|
atWarning("index out of range");
|
|
return 0;
|
|
}
|
|
return m_oldManFlags[id];
|
|
}
|
|
|
|
atUint32 ALTTPQuest::oldManFlagCount() const
|
|
{
|
|
return (atUint32)m_oldManFlags.size();
|
|
}
|
|
|
|
void ALTTPQuest::setBombFlag(atUint8 flag)
|
|
{
|
|
m_bombFlag = flag;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::bombFlag() const
|
|
{
|
|
return m_bombFlag;
|
|
}
|
|
|
|
void ALTTPQuest::setUnknown1(std::vector<atUint8> flags)
|
|
{
|
|
m_unknown1 = flags;
|
|
}
|
|
|
|
void ALTTPQuest::setUnknown1(atUint32 id, atUint8 val)
|
|
{
|
|
if (id > m_unknown1.size())
|
|
{
|
|
atWarning("index out of range");
|
|
return;
|
|
}
|
|
|
|
m_unknown1[id] = val;
|
|
}
|
|
|
|
atUint8 ALTTPQuest::unknown1(atUint32 id)
|
|
{
|
|
if (id > m_unknown1.size())
|
|
{
|
|
atWarning("index out of range");
|
|
return 0;
|
|
}
|
|
|
|
return m_unknown1[id];
|
|
}
|
|
|
|
atUint32 ALTTPQuest::unknown1Count() const
|
|
{
|
|
return (atUint32)m_unknown1.size();
|
|
}
|
|
|
|
void ALTTPQuest::setPlayerName(std::vector<atUint16> playerName)
|
|
{
|
|
m_playerName = playerName;
|
|
}
|
|
|
|
void ALTTPQuest::setPlayerName(const std::string& playerName)
|
|
{
|
|
if (playerName == std::string() || playerName.size() > 6)
|
|
{
|
|
atWarning("index out of range");
|
|
return;
|
|
}
|
|
|
|
m_playerName.clear();
|
|
|
|
for (atUint32 i = 0; i < 6; i++)
|
|
{
|
|
if (i > playerName.size() - 1)
|
|
{
|
|
m_playerName.push_back((atUint16)0xA9);
|
|
continue;
|
|
}
|
|
|
|
char c = playerName[i];
|
|
|
|
if (c >= 'A' && c <= 'P' && c != 'I')
|
|
{
|
|
|
|
m_playerName.push_back((atUint16)(c - 'A'));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 'Q' && c <= 'Z')
|
|
{
|
|
std::cout << std::hex << (atUint16)((c - 'Q') + 0x20) << std::endl;
|
|
m_playerName.push_back((atUint16)((c - 'Q') + 0x20));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 'a' && c <= 'f')
|
|
{
|
|
std::cout << std::hex << (atUint16)((c - 'a') + 0x2A) << std::endl;
|
|
m_playerName.push_back((atUint16)((c - 'a') + 0x2A));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 'g' && c <= 'v')
|
|
{
|
|
if (c == 'k')
|
|
{
|
|
m_playerName.push_back(0x42);
|
|
continue;
|
|
}
|
|
|
|
if (c == 'i')
|
|
{
|
|
m_playerName.push_back(0x44);
|
|
continue;
|
|
}
|
|
|
|
m_playerName.push_back((atUint16)((c - 'g') + 0x40));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 'w' && c <= 'z')
|
|
{
|
|
m_playerName.push_back((atUint16)((c - 'w') + 0x60));
|
|
continue;
|
|
}
|
|
|
|
if (c >= '0' && c <= '9')
|
|
{
|
|
m_playerName.push_back((atUint16)((c - '0') + 0x64));
|
|
continue;
|
|
}
|
|
|
|
if (c == '-' || c == '.')
|
|
{
|
|
m_playerName.push_back((atUint16)(c - '-') + 0x80);
|
|
continue;
|
|
}
|
|
|
|
switch (c)
|
|
{
|
|
case '?' :
|
|
m_playerName.push_back(0x6E);
|
|
break;
|
|
|
|
case '!' :
|
|
m_playerName.push_back(0x6F);
|
|
break;
|
|
|
|
case ',' :
|
|
m_playerName.push_back(0x82);
|
|
break;
|
|
|
|
case '(' :
|
|
m_playerName.push_back(0x85);
|
|
break;
|
|
|
|
case ')' :
|
|
m_playerName.push_back(0x86);
|
|
break;
|
|
|
|
case 'I' :
|
|
m_playerName.push_back(0xAF);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<atUint16> ALTTPQuest::playerName() const
|
|
{
|
|
return m_playerName;
|
|
}
|
|
|
|
std::string ALTTPQuest::playerNameToString() const
|
|
{
|
|
std::string ret;
|
|
|
|
for (atInt16 c : m_playerName)
|
|
{
|
|
if (c >= 0x00 && c <= 0x0F)
|
|
{
|
|
ret.push_back((char)('A' + c));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 0x20 && c <= 0x29)
|
|
{
|
|
ret.push_back((char)('Q' + (c - 0x20)));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 0x2A && c <= 0x2F)
|
|
{
|
|
ret.push_back((char)('a' + (c - 0x2A)));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 0x40 && c <= 0x4F)
|
|
{
|
|
if (c == 0x42)
|
|
{
|
|
ret.push_back('k');
|
|
continue;
|
|
}
|
|
|
|
if (c == 0x44)
|
|
{
|
|
ret.push_back('i');
|
|
continue;
|
|
}
|
|
|
|
ret.push_back((char)('g' + (c - 0x40)));
|
|
}
|
|
|
|
if (c >= 0x60 && c <= 0x63)
|
|
{
|
|
ret.push_back((char)('w' + (c - 0x60)));
|
|
continue;
|
|
}
|
|
|
|
if (c >= 0x64 && c <= 0x6D)
|
|
{
|
|
ret.push_back((char)('0' + (c - 0x64)));
|
|
continue;
|
|
}
|
|
|
|
if (c == 0x80 || c == 0x81)
|
|
{
|
|
ret.push_back((char)('-' + (c - 0x80)));
|
|
continue;
|
|
}
|
|
|
|
switch (c)
|
|
{
|
|
case 0x6E:
|
|
ret.push_back('?');
|
|
break;
|
|
|
|
case 0x6F:
|
|
ret.push_back('!');
|
|
break;
|
|
|
|
case 0x82:
|
|
ret.push_back(',');
|
|
break;
|
|
|
|
case 0x85:
|
|
ret.push_back('(');
|
|
break;
|
|
|
|
case 0x86:
|
|
ret.push_back(')');
|
|
break;
|
|
|
|
case 0xAF:
|
|
ret.push_back('I');
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void ALTTPQuest::setValid(bool val)
|
|
{
|
|
m_valid = val;
|
|
}
|
|
|
|
bool ALTTPQuest::valid()
|
|
{
|
|
return m_valid;
|
|
}
|
|
|
|
void ALTTPQuest::setDungeonDeathTotals(std::vector<atUint16> val)
|
|
{
|
|
m_dungeonDeathTotals = val;
|
|
}
|
|
|
|
void ALTTPQuest::setDungeonDeathTotal(atUint32 id, atUint16 val)
|
|
{
|
|
if (id > m_dungeonDeathTotals.size())
|
|
{
|
|
atWarning("index out of range");
|
|
return;
|
|
}
|
|
|
|
m_dungeonDeathTotals[id] = val;
|
|
}
|
|
|
|
atUint16 ALTTPQuest::dungeonDeathTotal(atUint32 id) const
|
|
{
|
|
if (id > m_dungeonDeathTotals.size())
|
|
{
|
|
atWarning("index out of range");
|
|
return 0;
|
|
}
|
|
|
|
return m_dungeonDeathTotals[id];
|
|
}
|
|
|
|
atUint16 ALTTPQuest::dungeonDeathTotalCount() const
|
|
{
|
|
return (atUint16)m_dungeonDeathTotals.size();
|
|
}
|
|
|
|
void ALTTPQuest::setUnknown2(atUint16 val)
|
|
{
|
|
m_unknown2 = val;
|
|
}
|
|
|
|
atUint16 ALTTPQuest::unknown2() const
|
|
{
|
|
return m_unknown2;
|
|
}
|
|
|
|
void ALTTPQuest::setDeathSaveCount(atUint16 val)
|
|
{
|
|
m_deathSaveCount = val;
|
|
}
|
|
atUint16 ALTTPQuest::deathSaveCount() const
|
|
{
|
|
return m_deathSaveCount;
|
|
}
|
|
|
|
void ALTTPQuest::setPostGameDeathCounter(atInt16 val)
|
|
{
|
|
m_postGameDeathCounter = val;
|
|
}
|
|
|
|
atInt16 ALTTPQuest::postGameDeathCounter() const
|
|
{
|
|
return m_postGameDeathCounter;
|
|
}
|
|
|
|
void ALTTPQuest::setChecksum(atUint16 checksum)
|
|
{
|
|
m_checksum = checksum;
|
|
}
|
|
|
|
atUint16 ALTTPQuest::checksum() const
|
|
{
|
|
return m_checksum;
|
|
}
|
|
|
|
} // zelda
|