mirror of https://github.com/libAthena/athena.git
438 lines
12 KiB
C++
438 lines
12 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; }
|
|
|
|
} // namespace athena
|