mirror of
https://github.com/HarbourMasters/Shipwright.git
synced 2025-07-16 10:02:59 -07:00
0f02201108
* Move all `SaveContext` operations to `Logic` to prepare for encapsulation. * Rename `Area` to `Region`, `areaTable` to `regionTable`, and all local variables named variants of area to region that were of the `RandomizerRegion` or `Region` types. * Fix mistaken renames. * Rename PT_AREA_RESET to PT_REGION_RESET after rebasing on performance timer commit. Change include path for the timer to absolute rather than relative.
449 lines
15 KiB
C++
449 lines
15 KiB
C++
#include "context.h"
|
|
#include "static_data.h"
|
|
#include "soh/OTRGlobals.h"
|
|
#include "soh/Enhancements/item-tables/ItemTableManager.h"
|
|
#include "3drando/shops.hpp"
|
|
#include "dungeon.h"
|
|
#include "logic.h"
|
|
#include "entrance.h"
|
|
#include "settings.h"
|
|
#include "rando_hash.h"
|
|
#include "fishsanity.h"
|
|
#include "macros.h"
|
|
#include "3drando/hints.hpp"
|
|
|
|
#include <fstream>
|
|
#include <spdlog/spdlog.h>
|
|
|
|
namespace Rando {
|
|
std::weak_ptr<Context> Context::mContext;
|
|
|
|
Context::Context() {
|
|
|
|
for (int i = 0; i < RC_MAX; i++) {
|
|
itemLocationTable[i] = ItemLocation(static_cast<RandomizerCheck>(i));
|
|
}
|
|
mEntranceShuffler = std::make_shared<EntranceShuffler>();
|
|
mDungeons = std::make_shared<Dungeons>();
|
|
mLogic = std::make_shared<Logic>();
|
|
mTrials = std::make_shared<Trials>();
|
|
mSettings = std::make_shared<Settings>();
|
|
mFishsanity = std::make_shared<Fishsanity>();
|
|
}
|
|
|
|
RandomizerArea Context::GetAreaFromString(std::string str) {
|
|
return (RandomizerArea)StaticData::areaNameToEnum[str];
|
|
}
|
|
|
|
void Context::InitStaticData() {
|
|
StaticData::HintTable_Init();
|
|
StaticData::trialNameToEnum = StaticData::PopulateTranslationMap(StaticData::trialData);
|
|
StaticData::hintNameToEnum = StaticData::PopulateTranslationMap(StaticData::hintNames);
|
|
StaticData::hintTypeNameToEnum = StaticData::PopulateTranslationMap(StaticData::hintTypeNames);
|
|
StaticData::areaNameToEnum = StaticData::PopulateTranslationMap(StaticData::areaNames);
|
|
StaticData::InitLocationTable();
|
|
}
|
|
|
|
std::shared_ptr<Context> Context::CreateInstance() {
|
|
if (mContext.expired()) {
|
|
auto instance = std::make_shared<Context>();
|
|
mContext = instance;
|
|
GetInstance()->GetLogic()->SetContext(GetInstance());
|
|
return instance;
|
|
}
|
|
return GetInstance();
|
|
}
|
|
|
|
std::shared_ptr<Context> Context::GetInstance() {
|
|
return mContext.lock();
|
|
}
|
|
|
|
Hint* Context::GetHint(const RandomizerHint hintKey) {
|
|
return &hintTable[hintKey];
|
|
}
|
|
|
|
void Context::AddHint(const RandomizerHint hintId, const Hint hint) {
|
|
hintTable[hintId] = hint; //RANDOTODO this should probably be an rvalue
|
|
}
|
|
|
|
ItemLocation* Context::GetItemLocation(const RandomizerCheck locKey) {
|
|
return &itemLocationTable[locKey];
|
|
}
|
|
|
|
ItemLocation* Context::GetItemLocation(size_t locKey) {
|
|
return &itemLocationTable[static_cast<RandomizerCheck>(locKey)];
|
|
}
|
|
|
|
ItemOverride& Context::GetItemOverride(RandomizerCheck locKey) {
|
|
if (!overrides.contains(locKey)) {
|
|
overrides.emplace(locKey, ItemOverride());
|
|
}
|
|
return overrides.at(locKey);
|
|
}
|
|
|
|
ItemOverride& Context::GetItemOverride(size_t locKey) {
|
|
if (!overrides.contains(static_cast<RandomizerCheck>(locKey))) {
|
|
overrides.emplace(static_cast<RandomizerCheck>(locKey), ItemOverride());
|
|
}
|
|
return overrides.at(static_cast<RandomizerCheck>(locKey));
|
|
}
|
|
|
|
void Context::PlaceItemInLocation(const RandomizerCheck locKey, const RandomizerGet item, const bool applyEffectImmediately,
|
|
const bool setHidden) {
|
|
const auto loc = GetItemLocation(locKey);
|
|
SPDLOG_DEBUG("\n");
|
|
SPDLOG_DEBUG(StaticData::RetrieveItem(item).GetName().GetEnglish());
|
|
SPDLOG_DEBUG(" placed at ");
|
|
SPDLOG_DEBUG(StaticData::GetLocation(locKey)->GetName());
|
|
SPDLOG_DEBUG("\n\n");
|
|
|
|
if (applyEffectImmediately || mSettings->GetOption(RSK_LOGIC_RULES).Is(RO_LOGIC_GLITCHLESS) || mSettings->GetOption(RSK_LOGIC_RULES).Is(RO_LOGIC_VANILLA)) {
|
|
StaticData::RetrieveItem(item).ApplyEffect();
|
|
}
|
|
|
|
// TODO? Show Progress
|
|
|
|
// If we're placing a non-shop item in a shop location, we want to record it for custom messages
|
|
if (StaticData::RetrieveItem(item).GetItemType() != ITEMTYPE_SHOP &&
|
|
StaticData::GetLocation(locKey)->IsCategory(Category::cShop)) {
|
|
const int index = TransformShopIndex(GetShopIndex(locKey));
|
|
NonShopItems[index].Name = StaticData::RetrieveItem(item).GetName();
|
|
NonShopItems[index].Repurchaseable =
|
|
StaticData::RetrieveItem(item).GetItemType() == ITEMTYPE_REFILL ||
|
|
StaticData::RetrieveItem(item).GetHintKey() == RHT_PROGRESSIVE_BOMBCHUS;
|
|
}
|
|
|
|
loc->SetPlacedItem(item);
|
|
if (setHidden) {
|
|
loc->SetHidden(true);
|
|
}
|
|
}
|
|
|
|
void Context::AddLocation(const RandomizerCheck loc, std::vector<RandomizerCheck>* destination) {
|
|
if (destination == nullptr) {
|
|
destination = &allLocations;
|
|
}
|
|
destination->push_back(loc);
|
|
}
|
|
|
|
template <typename Container>
|
|
void Context::AddLocations(const Container& locations, std::vector<RandomizerCheck>* destination) {
|
|
if (destination == nullptr) {
|
|
destination = &allLocations;
|
|
}
|
|
destination->insert(destination->end(), std::cbegin(locations), std::cend(locations));
|
|
}
|
|
|
|
void Context::GenerateLocationPool() {
|
|
allLocations.clear();
|
|
AddLocation(RC_LINKS_POCKET);
|
|
if (mSettings->GetOption(RSK_TRIFORCE_HUNT)) {
|
|
AddLocation(RC_TRIFORCE_COMPLETED);
|
|
}
|
|
AddLocations(StaticData::overworldLocations);
|
|
|
|
if (mSettings->GetOption(RSK_FISHSANITY).IsNot(RO_FISHSANITY_OFF)) {
|
|
AddLocations(mFishsanity->GetFishsanityLocations().first);
|
|
}
|
|
|
|
for (const auto dungeon : mDungeons->GetDungeonList()) {
|
|
AddLocations(dungeon->GetDungeonLocations());
|
|
}
|
|
}
|
|
|
|
void Context::AddExcludedOptions() {
|
|
AddLocations(StaticData::overworldLocations, &everyPossibleLocation);
|
|
for (const auto dungeon : mDungeons->GetDungeonList()) {
|
|
AddLocations(dungeon->GetEveryLocation(), &everyPossibleLocation);
|
|
}
|
|
for (const RandomizerCheck rc : everyPossibleLocation) {
|
|
GetItemLocation(rc)->AddExcludeOption();
|
|
}
|
|
}
|
|
|
|
std::vector<RandomizerCheck> Context::GetLocations(const std::vector<RandomizerCheck>& locationPool,
|
|
const Category categoryInclude, const Category categoryExclude) {
|
|
std::vector<RandomizerCheck> locationsInCategory;
|
|
for (RandomizerCheck locKey : locationPool) {
|
|
if (StaticData::GetLocation(locKey)->IsCategory(categoryInclude) &&
|
|
!StaticData::GetLocation(locKey)->IsCategory(categoryExclude)) {
|
|
locationsInCategory.push_back(locKey);
|
|
}
|
|
}
|
|
return locationsInCategory;
|
|
}
|
|
|
|
void Context::ClearItemLocations() {
|
|
for (size_t i = 0; i < itemLocationTable.size(); i++) {
|
|
GetItemLocation(static_cast<RandomizerCheck>(i))->ResetVariables();
|
|
}
|
|
}
|
|
|
|
void Context::ItemReset() {
|
|
for (const RandomizerCheck il : allLocations) {
|
|
GetItemLocation(il)->ResetVariables();
|
|
}
|
|
|
|
for (const RandomizerCheck il : StaticData::dungeonRewardLocations) {
|
|
GetItemLocation(il)->ResetVariables();
|
|
}
|
|
}
|
|
|
|
void Context::LocationReset() {
|
|
for (const RandomizerCheck il : allLocations) {
|
|
GetItemLocation(il)->RemoveFromPool();
|
|
}
|
|
|
|
for (const RandomizerCheck il : StaticData::dungeonRewardLocations) {
|
|
GetItemLocation(il)->RemoveFromPool();
|
|
}
|
|
|
|
for (const RandomizerCheck il : StaticData::gossipStoneLocations) {
|
|
GetItemLocation(il)->RemoveFromPool();
|
|
}
|
|
|
|
for (const RandomizerCheck il : StaticData::staticHintLocations) {
|
|
GetItemLocation(il)->RemoveFromPool();
|
|
}
|
|
}
|
|
|
|
void Context::HintReset() {
|
|
for (const RandomizerCheck il : StaticData::gossipStoneLocations) {
|
|
GetItemLocation(il)->ResetVariables();
|
|
}
|
|
for (Hint& hint : hintTable){
|
|
hint.ResetVariables();
|
|
}
|
|
}
|
|
|
|
void Context::CreateItemOverrides() {
|
|
SPDLOG_DEBUG("NOW CREATING OVERRIDES\n\n");
|
|
for (RandomizerCheck locKey : allLocations) {
|
|
const auto loc = StaticData::GetLocation(locKey);
|
|
// If this is an ice trap, store the disguise model in iceTrapModels
|
|
const auto itemLoc = GetItemLocation(locKey);
|
|
if (itemLoc->GetPlacedRandomizerGet() == RG_ICE_TRAP) {
|
|
ItemOverride val(locKey, RandomElement(possibleIceTrapModels));
|
|
iceTrapModels[locKey] = val.LooksLike();
|
|
val.SetTrickName(GetIceTrapName(val.LooksLike()));
|
|
// If this is ice trap is in a shop, change the name based on what the model will look like
|
|
if (loc->IsCategory(Category::cShop)) {
|
|
NonShopItems[TransformShopIndex(GetShopIndex(locKey))].Name = val.GetTrickName();
|
|
}
|
|
overrides[locKey] = val;
|
|
}
|
|
SPDLOG_DEBUG(loc->GetName());
|
|
SPDLOG_DEBUG(": ");
|
|
SPDLOG_DEBUG(itemLoc->GetPlacedItemName().GetEnglish());
|
|
SPDLOG_DEBUG("\n");
|
|
}
|
|
SPDLOG_DEBUG("Overrides Created: ");
|
|
SPDLOG_DEBUG(std::to_string(overrides.size()));
|
|
}
|
|
|
|
bool Context::IsSeedGenerated() const {
|
|
return mSeedGenerated;
|
|
}
|
|
|
|
void Context::SetSeedGenerated(const bool seedGenerated) {
|
|
mSeedGenerated = seedGenerated;
|
|
}
|
|
|
|
bool Context::IsSpoilerLoaded() const {
|
|
return mSpoilerLoaded;
|
|
}
|
|
|
|
void Context::SetSpoilerLoaded(const bool spoilerLoaded) {
|
|
mSpoilerLoaded = spoilerLoaded;
|
|
}
|
|
|
|
bool Context::IsPlandoLoaded() const {
|
|
return mPlandoLoaded;
|
|
}
|
|
|
|
void Context::SetPlandoLoaded(const bool plandoLoaded) {
|
|
mPlandoLoaded = plandoLoaded;
|
|
}
|
|
|
|
GetItemEntry Context::GetFinalGIEntry(const RandomizerCheck rc, const bool checkObtainability, const GetItemID ogItemId) {
|
|
const auto itemLoc = GetItemLocation(rc);
|
|
if (itemLoc->GetPlacedRandomizerGet() == RG_NONE) {
|
|
if (ogItemId != GI_NONE) {
|
|
return ItemTableManager::Instance->RetrieveItemEntry(MOD_NONE, ogItemId);
|
|
}
|
|
return ItemTableManager::Instance->RetrieveItemEntry(
|
|
MOD_NONE, StaticData::RetrieveItem(StaticData::GetLocation(rc)->GetVanillaItem()).GetItemID());
|
|
}
|
|
if (checkObtainability && OTRGlobals::Instance->gRandomizer->GetItemObtainabilityFromRandomizerGet(
|
|
itemLoc->GetPlacedRandomizerGet()) != CAN_OBTAIN) {
|
|
return ItemTableManager::Instance->RetrieveItemEntry(MOD_NONE, GI_RUPEE_BLUE);
|
|
}
|
|
GetItemEntry giEntry = itemLoc->GetPlacedItem().GetGIEntry_Copy();
|
|
if (overrides.contains(rc)) {
|
|
const auto fakeGiEntry = StaticData::RetrieveItem(overrides[rc].LooksLike()).GetGIEntry();
|
|
giEntry.gid = fakeGiEntry->gid;
|
|
giEntry.gi = fakeGiEntry->gi;
|
|
giEntry.drawItemId = fakeGiEntry->drawItemId;
|
|
giEntry.drawModIndex = fakeGiEntry->drawModIndex;
|
|
giEntry.drawFunc = fakeGiEntry->drawFunc;
|
|
}
|
|
return giEntry;
|
|
}
|
|
|
|
std::string sanitize(std::string stringValue) {
|
|
// Add backslashes.
|
|
for (auto i = stringValue.begin();;) {
|
|
auto const pos =
|
|
std::find_if(i, stringValue.end(), [](char const c) { return '\\' == c || '\'' == c || '"' == c; });
|
|
if (pos == stringValue.end()) {
|
|
break;
|
|
}
|
|
i = std::next(stringValue.insert(pos, '\\'), 2);
|
|
}
|
|
|
|
// Removes others.
|
|
std::erase_if(stringValue, [](char const c) { return '\n' == c || '\r' == c || '\0' == c || '\x1A' == c; });
|
|
|
|
return stringValue;
|
|
}
|
|
|
|
void Context::ParseSpoiler(const char* spoilerFileName, const bool plandoMode) {
|
|
std::ifstream spoilerFileStream(sanitize(spoilerFileName));
|
|
if (!spoilerFileStream) {
|
|
return;
|
|
}
|
|
mSeedGenerated = false;
|
|
mSpoilerLoaded = false;
|
|
mPlandoLoaded = false;
|
|
try {
|
|
nlohmann::json spoilerFileJson;
|
|
spoilerFileStream >> spoilerFileJson;
|
|
ParseHashIconIndexesJson(spoilerFileJson);
|
|
mSettings->ParseJson(spoilerFileJson);
|
|
if (plandoMode) {
|
|
ParseItemLocationsJson(spoilerFileJson);
|
|
ParseHintJson(spoilerFileJson);
|
|
mEntranceShuffler->ParseJson(spoilerFileJson);
|
|
mDungeons->ParseJson(spoilerFileJson);
|
|
mTrials->ParseJson(spoilerFileJson);
|
|
mPlandoLoaded = true;
|
|
}
|
|
mSpoilerLoaded = true;
|
|
mSeedGenerated = false;
|
|
} catch (...) {
|
|
LUSLOG_ERROR("Failed to load Spoiler File: %s", spoilerFileName);
|
|
}
|
|
}
|
|
|
|
void Context::ParseHashIconIndexesJson(nlohmann::json spoilerFileJson) {
|
|
nlohmann::json hashJson = spoilerFileJson["file_hash"];
|
|
int index = 0;
|
|
for (auto it = hashJson.begin(); it != hashJson.end(); ++it) {
|
|
hashIconIndexes[index] = gSeedTextures[it.value()].id;
|
|
index++;
|
|
}
|
|
}
|
|
|
|
void Context::ParseItemLocationsJson(nlohmann::json spoilerFileJson) {
|
|
nlohmann::json locationsJson = spoilerFileJson["locations"];
|
|
for (auto it = locationsJson.begin(); it != locationsJson.end(); ++it) {
|
|
RandomizerCheck rc = StaticData::locationNameToEnum[it.key()];
|
|
if (it->is_structured()) {
|
|
nlohmann::json itemJson = *it;
|
|
for (auto itemit = itemJson.begin(); itemit != itemJson.end(); ++itemit) {
|
|
if (itemit.key() == "item") {
|
|
itemLocationTable[rc].SetPlacedItem(StaticData::itemNameToEnum[itemit.value().get<std::string>()]);
|
|
} else if (itemit.key() == "price") {
|
|
itemLocationTable[rc].SetCustomPrice(itemit.value().get<uint16_t>());
|
|
} else if (itemit.key() == "model") {
|
|
overrides[rc] = ItemOverride(rc, StaticData::itemNameToEnum[itemit.value().get<std::string>()]);
|
|
} else if (itemit.key() == "trickName") {
|
|
overrides[rc].SetTrickName(Text(itemit.value().get<std::string>()));
|
|
}
|
|
}
|
|
} else {
|
|
itemLocationTable[rc].SetPlacedItem(StaticData::itemNameToEnum[it.value().get<std::string>()]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Context::WriteHintJson(nlohmann::ordered_json& spoilerFileJson){
|
|
for (Hint hint: hintTable){
|
|
hint.logHint(spoilerFileJson);
|
|
}
|
|
}
|
|
|
|
nlohmann::json getValueForMessage(std::unordered_map<std::string, nlohmann::json> map, CustomMessage message){
|
|
std::vector<std::string> strings = message.GetAllMessages();
|
|
for (uint8_t language = 0; language < LANGUAGE_MAX; language++){
|
|
if (map.contains(strings[language])){
|
|
return strings[language];
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
|
|
void Context::ParseHintJson(nlohmann::json spoilerFileJson) {
|
|
for (auto hintData : spoilerFileJson["Gossip Stone Hints"].items()){
|
|
RandomizerHint hint = (RandomizerHint)StaticData::hintNameToEnum[hintData.key()];
|
|
AddHint(hint, Hint(hint, hintData.value()));
|
|
}
|
|
for (auto hintData : spoilerFileJson["Static Hints"].items()){
|
|
RandomizerHint hint = (RandomizerHint)StaticData::hintNameToEnum[hintData.key()];
|
|
AddHint(hint, Hint(hint, hintData.value()));
|
|
}
|
|
CreateStaticHints();
|
|
}
|
|
|
|
std::shared_ptr<Settings> Context::GetSettings() {
|
|
return mSettings;
|
|
}
|
|
|
|
std::shared_ptr<EntranceShuffler> Context::GetEntranceShuffler() {
|
|
return mEntranceShuffler;
|
|
}
|
|
|
|
std::shared_ptr<Dungeons> Context::GetDungeons() {
|
|
return mDungeons;
|
|
}
|
|
|
|
std::shared_ptr<Fishsanity> Context::GetFishsanity() {
|
|
return mFishsanity;
|
|
}
|
|
|
|
DungeonInfo* Context::GetDungeon(size_t key) const {
|
|
return mDungeons->GetDungeon(static_cast<DungeonKey>(key));
|
|
}
|
|
|
|
std::shared_ptr<Logic> Context::GetLogic() {
|
|
if (mLogic.get() == nullptr) {
|
|
mLogic = std::make_shared<Logic>();
|
|
}
|
|
return mLogic;
|
|
}
|
|
|
|
std::shared_ptr<Trials> Context::GetTrials() {
|
|
return mTrials;
|
|
}
|
|
|
|
TrialInfo* Context::GetTrial(size_t key) const {
|
|
return mTrials->GetTrial(static_cast<TrialKey>(key));
|
|
}
|
|
|
|
TrialInfo* Context::GetTrial(TrialKey key) const {
|
|
return mTrials->GetTrial(key);
|
|
}
|
|
|
|
Sprite* Context::GetSeedTexture(const uint8_t index) {
|
|
return &gSeedTextures[index];
|
|
}
|
|
|
|
Option& Context::GetOption(const RandomizerSettingKey key) const {
|
|
return mSettings->GetOption(key);
|
|
}
|
|
|
|
TrickOption& Context::GetTrickOption(const RandomizerTrick key) const {
|
|
return mSettings->GetTrickOption(key);
|
|
}
|
|
|
|
} // namespace Rando
|