From abf327664226b7b534c1b210cec8db11ebdcdc0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 25 Oct 2020 18:06:13 +0100 Subject: ksys/gdt: Implement more parts of TriggerParam (notably setters) --- src/KingSystem/GameData/gdtTriggerParam.cpp | 598 +++++++++++++++++++++++++++- src/KingSystem/GameData/gdtTriggerParam.h | 163 +++++++- 2 files changed, 756 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/KingSystem/GameData/gdtTriggerParam.cpp b/src/KingSystem/GameData/gdtTriggerParam.cpp index d400eff7..669d78da 100644 --- a/src/KingSystem/GameData/gdtTriggerParam.cpp +++ b/src/KingSystem/GameData/gdtTriggerParam.cpp @@ -1,8 +1,11 @@ #include "KingSystem/GameData/gdtTriggerParam.h" #include +#include #include #include "KingSystem/GameData/gdtFlagProxy.h" #include "KingSystem/Resource/resResourceGameData.h" +#include "KingSystem/System/PlayReportMgr.h" +#include "KingSystem/Utils/Debug.h" #include "KingSystem/Utils/InitTimeInfo.h" #include "KingSystem/Utils/SafeDelete.h" @@ -81,11 +84,15 @@ inline s32 getFlagIndex(const sead::PtrArray>& flags, u return -1; } -template -inline Flag* getFlagByIndex(const sead::PtrArray& flags, s32 index) { +inline FlagBase* getFlagByIndexBase(const sead::PtrArray& flags, s32 index) { if (index < 0 || index >= flags.size()) return nullptr; - return static_cast*>(flags[index]); + return flags[index]; +} + +template +inline Flag* getFlagByIndex(const sead::PtrArray& flags, s32 index) { + return static_cast*>(getFlagByIndexBase(flags, index)); } template @@ -147,6 +154,219 @@ inline bool getFlagValue(const sead::PtrArray>& arrays, return true; } +/// Modifies the value of a flag. +/// @param success A non-null pointer to a boolean that is set to true if an attempt was made to +/// change the value. +/// @return whether the flag contains the specified value at the end of this function. +template +bool doSetFlagValue(bool* success, const T& value, const sead::PtrArray& flags, s32 idx, + bool check_permissions, bool bypass_one_trigger_check) { + *success = false; + + auto* flag = getFlagByIndex(flags, idx); + if (!flag) + return false; + + if (check_permissions && !flags[idx]->isProgramWritable()) + return false; + + if constexpr (IsAnyOfType()) { + if (!flags[idx]->isOneTrigger() || bypass_one_trigger_check || flag->isInitialValue()) + *success = flag->setValue(value); + else if (!flag->hasValue(value)) + return false; + return true; + } else { + bool can_set_value = false; + if (!flags[idx]->isOneTrigger() || bypass_one_trigger_check || flag->isInitialValue()) { + can_set_value = true; + *success = flag->setValue(value); + } else if (flag->hasValue(value)) { + return true; + } + return can_set_value; + } +} + +void sendFlagChangePlayReport(const sead::SafeString& name, const FlagBase* flag) { + if (!PlayReportMgr::instance()) + return; + + for (s32 i = 0; i < sConfig.num_current_rupee_flag_name_changes; ++i) { + if (name == sConfig.current_rupee_flag_name) { + sead::FixedSafeString<64> value_str; + switch (s32(flag->getType())) { + case FlagType::Bool: + case FlagType::BoolArray: + if (static_cast(flag)->getValue()) + value_str.format("true"); + else + value_str.format("false"); + break; + case FlagType::S32: + case FlagType::S32Array: + value_str.format("%d", static_cast(flag)->getValue()); + break; + case FlagType::F32: + case FlagType::F32Array: + value_str.format("%f", static_cast(flag)->getValue()); + break; + case FlagType::String: + case FlagType::StringArray: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String64: + case FlagType::String64Array: + value_str.format("%s", + static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String256: + case FlagType::String256Array: + value_str.format("%s", + static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::Vector2f: + case FlagType::Vector2fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f", vector.x, vector.y); + break; + } + case FlagType::Vector3f: + case FlagType::Vector3fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f", vector.x, vector.y, vector.z); + break; + } + case FlagType::Vector4f: + case FlagType::Vector4fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f %f", vector.x, vector.y, vector.z, vector.w); + break; + } + default: + break; + } + PlayReportMgr::instance()->reportDebug(name, value_str); + break; + } + } +} + +template +void reportFlagChange(const FlagBase* flag, s32 sub_idx = -1) { + auto* flag_ = static_cast*>(flag); + + const sead::SafeString& name = flag->getName(); + const FlagType type = flag->getType(); + + if constexpr (std::is_same()) { + if ((s32(type) == FlagType::Bool || s32(type) == FlagType::BoolArray) && + PlayReportMgr::instance()) { + if (flag_->getValue()) + PlayReportMgr::instance()->reportDebug("FlagOn", name); + else + PlayReportMgr::instance()->reportDebug("FlagOff", name); + } + } else { + sendFlagChangePlayReport(name, flag); + } + + if (sConfig.shouldPrintStackTrace(name)) { + sead::StackTrace<50> stack_trace; + stack_trace.trace(nullptr); + } + + if (!shouldLogFlagChange(name, type)) + return; + + if constexpr (std::is_same()) { + sead::FixedSafeString<128> message; + const char* name_cstr = flag->getName().cstr(); + const auto type_ = flag->getType(); + if (sub_idx < 0 || type_ != FlagType::BoolArray) + message.format("%s", name_cstr); + else + message.format("%s [%3d]", name_cstr, sub_idx); + + switch (s32(flag->getType())) { + case FlagType::Bool: + case FlagType::BoolArray: + if (flag_->getValue()) + message.append(" : true"); + else + message.append(" : false"); + break; + default: + break; + } + util::PrintDebug(message); + } else { + const char* name_cstr = flag->getName().cstr(); + sead::FixedSafeString<128> message; + const s32 type_ = flag->getType(); + if (sub_idx >= 0 && type_ >= FlagType::BoolArray) + message.format("%s [%3d] :", name_cstr, sub_idx); + else + message.format("%s :", name_cstr); + + sead::FixedSafeString<64> value_str; + switch (s32(flag->getType())) { + case FlagType::Bool: + case FlagType::BoolArray: + if (static_cast(flag)->getValue()) + value_str.format("true"); + else + value_str.format("false"); + break; + case FlagType::S32: + case FlagType::S32Array: + value_str.format("%d", static_cast(flag)->getValue()); + break; + case FlagType::F32: + case FlagType::F32Array: + value_str.format("%f", static_cast(flag)->getValue()); + break; + case FlagType::String: + case FlagType::StringArray: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String64: + case FlagType::String64Array: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::String256: + case FlagType::String256Array: + value_str.format("%s", static_cast(flag)->getValueRef().cstr()); + break; + case FlagType::Vector2f: + case FlagType::Vector2fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f", vector.x, vector.y); + break; + } + case FlagType::Vector3f: + case FlagType::Vector3fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f", vector.x, vector.y, vector.z); + break; + } + case FlagType::Vector4f: + case FlagType::Vector4fArray: { + const auto& vector = static_cast(flag)->getValueRef(); + value_str.format("%f %f %f %f", vector.x, vector.y, vector.z, vector.w); + break; + } + default: + break; + } + message.append(value_str); + util::PrintDebug(message); + } + + static_cast(getFlagColor(type)); + sConfig.index = sConfig.index >= 32 ? 0 : sConfig.index + 1; +} + bool getFlagArraySize(const sead::PtrArray>& arrays, s32 index, s32* out) { if (index < 0 || index >= arrays.size()) return false; @@ -885,7 +1105,93 @@ bool TriggerParam::getMaxValueForS32(s32* max, const sead::SafeString& name) con return true; } -void TriggerParam::recordFlagChange(const FlagBase* flag, s32 idx, s16 sub_idx) { +#define SET_FLAG_VALUE_IMPL_(FUNCTION_NAME, ARG_VALUE_TYPE, FLAGS, T, VALUE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, s32 idx, bool check_permissions, \ + bool bypass_one_trigger_check) { \ + bool success = false; \ + const bool ret = doSetFlagValue(&success, VALUE, FLAGS, idx, check_permissions, \ + bypass_one_trigger_check); \ + if (!success) \ + return ret; \ + \ + recordFlagChange(FLAGS[idx], idx); \ + reportFlagChange(FLAGS[idx]); \ + \ + if constexpr (std::is_same()) { \ + if (FLAGS[idx]->getProperties().isEventAssociated()) \ + mBitFlags.ref().set(BitFlag::EventAssociatedFlagModified); \ + } \ + \ + return ret; \ + } + +#define SET_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, GET_INDEX_FN, ARG_VALUE_TYPE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, const sead::SafeString& name, bool check_permissions, \ + bool, bool bypass_one_trigger_check) { \ + return FUNCTION_NAME(value, GET_INDEX_FN(name), check_permissions, \ + bypass_one_trigger_check); \ + } + +#define SET_ARRAY_FLAG_VALUE_IMPL_(FUNCTION_NAME, ARG_VALUE_TYPE, FLAGS, T, VALUE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, s32 idx, s32 sub_idx, bool check_permissions, \ + bool bypass_one_trigger_check) { \ + bool success = false; \ + \ + if (idx < 0 || idx >= FLAGS.size()) \ + return false; \ + \ + const auto* array = FLAGS[idx]; \ + if (!array) \ + return false; \ + \ + const bool ret = doSetFlagValue(&success, VALUE, *array, sub_idx, check_permissions, \ + bypass_one_trigger_check); \ + if (!success) \ + return ret; \ + \ + const auto* flag = (*FLAGS[idx])[sub_idx]; \ + recordFlagChange(flag, idx, sub_idx); \ + reportFlagChange(flag, sub_idx); \ + \ + return ret; \ + } + +#define SET_STRING_ARRAY_FLAG_VALUE_IMPL_(FUNCTION_NAME, FLAGS, T) \ + bool FUNCTION_NAME(const char* value, s32 idx, s32 sub_idx, bool check_permissions, \ + bool bypass_one_trigger_check) { \ + bool success = false; \ + T value_{value}; \ + success = false; \ + \ + if (idx < 0 || idx >= FLAGS.size()) \ + return false; \ + \ + const auto* array = FLAGS[idx]; \ + if (!array) \ + return false; \ + \ + const bool ret = doSetFlagValue(&success, value_, *array, sub_idx, check_permissions, \ + bypass_one_trigger_check); \ + if (!success) \ + return ret; \ + \ + const auto* flag = (*FLAGS[idx])[sub_idx]; \ + recordFlagChange(flag, idx, sub_idx); \ + reportFlagChange(flag, sub_idx); \ + \ + return ret; \ + } + +#define SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, GET_INDEX_FN, ARG_VALUE_TYPE) \ + bool FUNCTION_NAME(ARG_VALUE_TYPE value, const sead::SafeString& name, s32 sub_idx, \ + bool check_permissions, bool, bool bypass_one_trigger_check) { \ + return FUNCTION_NAME(value, GET_INDEX_FN(name), sub_idx, check_permissions, \ + bypass_one_trigger_check); \ + } + +SET_FLAG_VALUE_IMPL_(TriggerParam::setBool, bool, mBoolFlags, bool, value) + +void TriggerParam::recordFlagChange(const FlagBase* flag, s32 idx, s32 sub_idx) { const auto core = sead::CoreInfo::getCurrentCoreId(); const u32 platform_core_id = sead::CoreInfo::getPlatformCoreId(core); @@ -904,6 +1210,214 @@ void TriggerParam::recordFlagChange(const FlagBase* flag, s32 idx, s16 sub_idx) mBitFlags.ref().set(BitFlag::_8); } +SET_FLAG_VALUE_IMPL_(TriggerParam::setS32, s32, mS32Flags, s32, value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setF32, f32, mF32Flags, f32, value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setStr, const char*, mStringFlags, sead::FixedSafeString<32>, + sead::FixedSafeString<32>(value)) +SET_FLAG_VALUE_IMPL_(TriggerParam::setStr64, const char*, mString64Flags, sead::FixedSafeString<64>, + sead::FixedSafeString<64>(value)) +SET_FLAG_VALUE_IMPL_(TriggerParam::setStr256, const char*, mString256Flags, + sead::FixedSafeString<256>, sead::FixedSafeString<256>(value)) +SET_FLAG_VALUE_IMPL_(TriggerParam::setVec2f, const sead::Vector2f&, mVector2fFlags, sead::Vector2f, + value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setVec3f, const sead::Vector3f&, mVector3fFlags, sead::Vector3f, + value) +SET_FLAG_VALUE_IMPL_(TriggerParam::setVec4f, const sead::Vector4f&, mVector4fFlags, sead::Vector4f, + value) + +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setBool, getBoolIdx, bool) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setS32, getS32Idx, s32) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setF32, getF32Idx, f32) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr, getStrIdx, const char*) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr64, getStr64Idx, const char*) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr256, getStr256Idx, const char*) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec2f, getVec2fIdx, const sead::Vector2f&) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec3f, getVec3fIdx, const sead::Vector3f&) +SET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec4f, getVec4fIdx, const sead::Vector4f&) + +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setBool, bool, mBoolArrayFlags, bool, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setS32, s32, mS32ArrayFlags, s32, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setF32, f32, mF32ArrayFlags, f32, value) +SET_STRING_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setStr, mStringArrayFlags, + sead::FixedSafeString<32>) +SET_STRING_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setStr64, mString64ArrayFlags, + sead::FixedSafeString<64>) +SET_STRING_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setStr256, mString256ArrayFlags, + sead::FixedSafeString<256>) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setVec2f, const sead::Vector2f&, mVector2fArrayFlags, + sead::Vector2f, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setVec3f, const sead::Vector3f&, mVector3fArrayFlags, + sead::Vector3f, value) +SET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::setVec4f, const sead::Vector4f&, mVector4fArrayFlags, + sead::Vector4f, value) + +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setBool, getBoolArrayIdx, bool) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setS32, getS32ArrayIdx, s32) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setF32, getF32ArrayIdx, f32) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr, getStrArrayIdx, const char*) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr64, getStr64ArrayIdx, const char*) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setStr256, getStr256ArrayIdx, const char*) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec2f, getVec2fArrayIdx, const sead::Vector2f&) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec3f, getVec3fArrayIdx, const sead::Vector3f&) +SET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::setVec4f, getVec4fArrayIdx, const sead::Vector4f&) + +#define RESET_FLAG_VALUE_IMPL_(FUNCTION_NAME, FLAGS, T) \ + bool FUNCTION_NAME(s32 idx, bool check_permissions) { \ + auto* flag = getFlagByIndexBase(FLAGS, idx); \ + if (!flag) \ + return false; \ + \ + if (check_permissions && !flag->isProgramWritable()) \ + return false; \ + \ + if (flag->isInitialValue()) \ + return true; \ + \ + flag->resetToInitialValue(); \ + recordFlagChange(FLAGS[idx], idx); \ + reportFlagChange(FLAGS[idx]); \ + \ + return true; \ + } + +#define RESET_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, FLAGS, GET_IDX_FN) \ + bool FUNCTION_NAME(const sead::SafeString& name, bool check_permissions) { \ + return FUNCTION_NAME(GET_IDX_FN(name), check_permissions); \ + } + +#define RESET_ARRAY_FLAG_VALUE_IMPL_(FUNCTION_NAME, ARRAYS, T) \ + bool FUNCTION_NAME(s32 idx, s32 sub_idx, bool check_permissions) { \ + if (idx < 0 || idx >= ARRAYS.size()) \ + return false; \ + \ + const auto* array = ARRAYS[idx]; \ + if (!array) \ + return false; \ + \ + auto* flag = getFlagByIndexBase(*array, sub_idx); \ + if (!flag) \ + return false; \ + \ + if (check_permissions && !flag->isProgramWritable()) \ + return false; \ + \ + if (flag->isInitialValue()) \ + return true; \ + \ + flag->resetToInitialValue(); \ + const auto* flag_ = [&] { return ARRAYS.at(idx)->at(sub_idx); }(); \ + recordFlagChange(flag_, idx, sub_idx); \ + reportFlagChange(flag_, sub_idx); \ + \ + return true; \ + } + +#define RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(FUNCTION_NAME, FLAGS, GET_IDX_FN) \ + bool FUNCTION_NAME(const sead::SafeString& name, s32 sub_idx, bool check_permissions) { \ + return FUNCTION_NAME(GET_IDX_FN(name), sub_idx, check_permissions); \ + } + +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetBool, mBoolFlags, bool) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetS32, mS32Flags, s32) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetF32, mF32Flags, f32) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetStr, mStringFlags, sead::FixedSafeString<32>) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetStr64, mString64Flags, sead::FixedSafeString<64>) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetStr256, mString256Flags, sead::FixedSafeString<256>) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetVec2f, mVector2fFlags, sead::Vector2f) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetVec3f, mVector3fFlags, sead::Vector3f) +RESET_FLAG_VALUE_IMPL_(TriggerParam::resetVec4f, mVector4fFlags, sead::Vector4f) + +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetBool, mBoolFlags, getBoolIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetS32, mS32Flags, getS32Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetF32, mF32Flags, getF32Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr, mStringFlags, getStrIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr64, mString64Flags, getStr64Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr256, mString256Flags, getStr256Idx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec2f, mVector2fFlags, getVec2fIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec3f, mVector3fFlags, getVec3fIdx) +RESET_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec4f, mVector4fFlags, getVec4fIdx) + +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetBool, mBoolArrayFlags, bool) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetS32, mS32ArrayFlags, s32) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetF32, mF32ArrayFlags, f32) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetStr, mStringArrayFlags, sead::FixedSafeString<32>) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetStr64, mString64ArrayFlags, + sead::FixedSafeString<64>) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetStr256, mString256ArrayFlags, + sead::FixedSafeString<256>) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetVec2f, mVector2fArrayFlags, sead::Vector2f) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetVec3f, mVector3fArrayFlags, sead::Vector3f) +RESET_ARRAY_FLAG_VALUE_IMPL_(TriggerParam::resetVec4f, mVector4fArrayFlags, sead::Vector4f) + +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetBool, mBoolArrayFlags, getBoolArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetS32, mS32ArrayFlags, getS32ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetF32, mF32ArrayFlags, getF32ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr, mStringArrayFlags, getStrArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr64, mString64ArrayFlags, getStr64ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetStr256, mString256ArrayFlags, + getStr256ArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec2f, mVector2fArrayFlags, getVec2fArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec3f, mVector3fArrayFlags, getVec3fArrayIdx) +RESET_ARRAY_FLAG_VALUE_BY_KEY_IMPL_(TriggerParam::resetVec4f, mVector4fArrayFlags, getVec4fArrayIdx) + +void TriggerParam::resetAllFlagsToInitialValues() { + for (s32 i = 0; i < mBoolFlags.size(); ++i) + resetBool(i, false); + for (s32 i = 0; i < mS32Flags.size(); ++i) + resetS32(i, false); + for (s32 i = 0; i < mF32Flags.size(); ++i) + resetF32(i, false); + for (s32 i = 0; i < mStringFlags.size(); ++i) + resetStr(i, false); + for (s32 i = 0; i < mString64Flags.size(); ++i) + resetStr64(i, false); + for (s32 i = 0; i < mString256Flags.size(); ++i) + resetStr256(i, false); + for (s32 i = 0; i < mVector2fFlags.size(); ++i) + resetVec2f(i, false); + for (s32 i = 0; i < mVector3fFlags.size(); ++i) + resetVec3f(i, false); + for (s32 i = 0; i < mVector4fFlags.size(); ++i) + resetVec4f(i, false); + + for (s32 i = 0; i < mBoolArrayFlags.size(); ++i) { + for (s32 j = 0; j < mBoolArrayFlags[i]->size(); ++j) + resetBool(i, j, false); + } + for (s32 i = 0; i < mS32ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mS32ArrayFlags[i]->size(); ++j) + resetS32(i, j, false); + } + for (s32 i = 0; i < mF32ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mF32ArrayFlags[i]->size(); ++j) + resetF32(i, j, false); + } + for (s32 i = 0; i < mStringArrayFlags.size(); ++i) { + for (s32 j = 0; j < mStringArrayFlags[i]->size(); ++j) + resetStr(i, j, false); + } + for (s32 i = 0; i < mString64ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mString64ArrayFlags[i]->size(); ++j) + resetStr64(i, j, false); + } + for (s32 i = 0; i < mString256ArrayFlags.size(); ++i) { + for (s32 j = 0; j < mString256ArrayFlags[i]->size(); ++j) + resetStr256(i, j, false); + } + for (s32 i = 0; i < mVector2fArrayFlags.size(); ++i) { + for (s32 j = 0; j < mVector2fArrayFlags[i]->size(); ++j) + resetVec2f(i, j, false); + } + for (s32 i = 0; i < mVector3fArrayFlags.size(); ++i) { + for (s32 j = 0; j < mVector3fArrayFlags[i]->size(); ++j) + resetVec3f(i, j, false); + } + for (s32 i = 0; i < mVector4fArrayFlags.size(); ++i) { + for (s32 j = 0; j < mVector4fArrayFlags[i]->size(); ++j) + resetVec4f(i, j, false); + } +} + s32 TriggerParam::getBoolIdx(u32 name) const { return getFlagIndex(mBoolFlags, name); } @@ -976,6 +1490,82 @@ s32 TriggerParam::getVec4fArrayIdx(u32 name) const { return getFlagIndex(mVector4fArrayFlags, name); } +FlagBool* TriggerParam::getBoolFlag(s32 idx) const { + return static_cast(mBoolFlags[idx]); +} + +FlagS32* TriggerParam::getS32Flag(s32 idx) const { + return static_cast(mS32Flags[idx]); +} + +FlagF32* TriggerParam::getF32Flag(s32 idx) const { + return static_cast(mF32Flags[idx]); +} + +FlagString* TriggerParam::getStrFlag(s32 idx) const { + return static_cast(mStringFlags[idx]); +} + +FlagString64* TriggerParam::getStr64Flag(s32 idx) const { + return static_cast(mString64Flags[idx]); +} + +FlagString256* TriggerParam::getStr256Flag(s32 idx) const { + return static_cast(mString256Flags[idx]); +} + +FlagVector2f* TriggerParam::getVec2fFlag(s32 idx) const { + return static_cast(mVector2fFlags[idx]); +} + +FlagVector3f* TriggerParam::getVec3fFlag(s32 idx) const { + return static_cast(mVector3fFlags[idx]); +} + +FlagVector4f* TriggerParam::getVec4fFlag(s32 idx) const { + return static_cast(mVector4fFlags[idx]); +} + +FlagBool* TriggerParam::getBoolFlag(s32 idx, s32 sub_idx) const { + return static_cast(mBoolArrayFlags[idx]->at(sub_idx)); +} + +FlagS32* TriggerParam::getS32Flag(s32 idx, s32 sub_idx) const { + return static_cast(mS32ArrayFlags[idx]->at(sub_idx)); +} + +FlagF32* TriggerParam::getF32Flag(s32 idx, s32 sub_idx) const { + return static_cast(mF32ArrayFlags[idx]->at(sub_idx)); +} + +FlagString* TriggerParam::getStrFlag(s32 idx, s32 sub_idx) const { + return static_cast(mStringArrayFlags[idx]->at(sub_idx)); +} + +FlagString64* TriggerParam::getStr64Flag(s32 idx, s32 sub_idx) const { + return static_cast(mString64ArrayFlags[idx]->at(sub_idx)); +} + +FlagString256* TriggerParam::getStr256Flag(s32 idx, s32 sub_idx) const { + return static_cast(mString256ArrayFlags[idx]->at(sub_idx)); +} + +FlagVector2f* TriggerParam::getVec2fFlag(s32 idx, s32 sub_idx) const { + return static_cast(mVector2fArrayFlags[idx]->at(sub_idx)); +} + +FlagVector3f* TriggerParam::getVec3fFlag(s32 idx, s32 sub_idx) const { + return static_cast(mVector3fArrayFlags[idx]->at(sub_idx)); +} + +FlagVector4f* TriggerParam::getVec4fFlag(s32 idx, s32 sub_idx) const { + return static_cast(mVector4fArrayFlags[idx]->at(sub_idx)); +} + +void TriggerParam::onResetBoolFlagForRadarMgr(FlagBase* flag, s32 sub_idx) { + reportFlagChange(flag, sub_idx); +} + void TriggerParam::setCurrentRupeeFlagName(const sead::SafeString& name) { if (sConfig.num_current_rupee_flag_name_changes <= 0) { sConfig.getCurrentRupeeFlagName() = name; diff --git a/src/KingSystem/GameData/gdtTriggerParam.h b/src/KingSystem/GameData/gdtTriggerParam.h index b307d499..c98b3b9d 100644 --- a/src/KingSystem/GameData/gdtTriggerParam.h +++ b/src/KingSystem/GameData/gdtTriggerParam.h @@ -225,9 +225,170 @@ public: bool getMinValueForS32(s32* min, const sead::SafeString& name) const; bool getMaxValueForS32(s32* max, const sead::SafeString& name) const; + // region Value setters + + bool setBool(bool value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setS32(s32 value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setF32(f32 value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setStr(const char* value, s32 idx, bool check_permissions, bool bypass_one_trigger_check); + bool setStr64(const char* value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr256(const char* value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, s32 idx, bool check_permissions, + bool bypass_one_trigger_check); + + bool setBool(bool value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setS32(s32 value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setF32(f32 value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr(const char* value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr64(const char* value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr256(const char* value, const sead::SafeString& name, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, const sead::SafeString& name, bool check_permissions, + bool, bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, const sead::SafeString& name, bool check_permissions, + bool, bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, const sead::SafeString& name, bool check_permissions, + bool, bool bypass_one_trigger_check); + + // endregion + + // region Value setters (array) + + bool setBool(bool value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setS32(s32 value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setF32(f32 value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr(const char* value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr64(const char* value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setStr256(const char* value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, s32 idx, s32 sub_idx, bool check_permissions, + bool bypass_one_trigger_check); + + bool setBool(bool value, const sead::SafeString& name, s32 sub_idx, bool check_permissions, + bool, bool bypass_one_trigger_check); + bool setS32(s32 value, const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setF32(f32 value, const sead::SafeString& name, s32 sub_idx, bool check_permissions, bool, + bool bypass_one_trigger_check); + bool setStr(const char* value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setStr64(const char* value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setStr256(const char* value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setVec2f(const sead::Vector2f& value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setVec3f(const sead::Vector3f& value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + bool setVec4f(const sead::Vector4f& value, const sead::SafeString& name, s32 sub_idx, + bool check_permissions, bool, bool bypass_one_trigger_check); + + // endregion + + // region Resetting values + + bool resetBool(s32 idx, bool check_permissions); + bool resetS32(s32 idx, bool check_permissions); + bool resetF32(s32 idx, bool check_permissions); + bool resetStr(s32 idx, bool check_permissions); + bool resetStr64(s32 idx, bool check_permissions); + bool resetStr256(s32 idx, bool check_permissions); + bool resetVec2f(s32 idx, bool check_permissions); + bool resetVec3f(s32 idx, bool check_permissions); + bool resetVec4f(s32 idx, bool check_permissions); + + bool resetBool(const sead::SafeString& name, bool check_permissions); + bool resetS32(const sead::SafeString& name, bool check_permissions); + bool resetF32(const sead::SafeString& name, bool check_permissions); + bool resetStr(const sead::SafeString& name, bool check_permissions); + bool resetStr64(const sead::SafeString& name, bool check_permissions); + bool resetStr256(const sead::SafeString& name, bool check_permissions); + bool resetVec2f(const sead::SafeString& name, bool check_permissions); + bool resetVec3f(const sead::SafeString& name, bool check_permissions); + bool resetVec4f(const sead::SafeString& name, bool check_permissions); + + // endregion + + // region Resetting values (array) + + bool resetBool(s32 idx, s32 sub_idx, bool check_permissions); + bool resetS32(s32 idx, s32 sub_idx, bool check_permissions); + bool resetF32(s32 idx, s32 sub_idx, bool check_permissions); + bool resetStr(s32 idx, s32 sub_idx, bool check_permissions); + bool resetStr64(s32 idx, s32 sub_idx, bool check_permissions); + bool resetStr256(s32 idx, s32 sub_idx, bool check_permissions); + bool resetVec2f(s32 idx, s32 sub_idx, bool check_permissions); + bool resetVec3f(s32 idx, s32 sub_idx, bool check_permissions); + bool resetVec4f(s32 idx, s32 sub_idx, bool check_permissions); + + bool resetBool(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetS32(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetF32(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetStr(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetStr64(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetStr256(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetVec2f(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetVec3f(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + bool resetVec4f(const sead::SafeString& name, s32 sub_idx, bool check_permissions); + + // endregion + + void resetAllFlagsToInitialValues(); + + // region Flag getters + + FlagBool* getBoolFlag(s32 idx) const; + FlagS32* getS32Flag(s32 idx) const; + FlagF32* getF32Flag(s32 idx) const; + FlagString* getStrFlag(s32 idx) const; + FlagString64* getStr64Flag(s32 idx) const; + FlagString256* getStr256Flag(s32 idx) const; + FlagVector2f* getVec2fFlag(s32 idx) const; + FlagVector3f* getVec3fFlag(s32 idx) const; + FlagVector4f* getVec4fFlag(s32 idx) const; + + // endregion + + // region Flag getters (array) + + FlagBool* getBoolFlag(s32 idx, s32 sub_idx) const; + FlagS32* getS32Flag(s32 idx, s32 sub_idx) const; + FlagF32* getF32Flag(s32 idx, s32 sub_idx) const; + FlagString* getStrFlag(s32 idx, s32 sub_idx) const; + FlagString64* getStr64Flag(s32 idx, s32 sub_idx) const; + FlagString256* getStr256Flag(s32 idx, s32 sub_idx) const; + FlagVector2f* getVec2fFlag(s32 idx, s32 sub_idx) const; + FlagVector3f* getVec3fFlag(s32 idx, s32 sub_idx) const; + FlagVector4f* getVec4fFlag(s32 idx, s32 sub_idx) const; + + // endregion + + void onResetBoolFlagForRadarMgr(FlagBase* flag, s32 sub_idx = -1); + private: enum class BitFlag : u8 { _8 = 8, + EventAssociatedFlagModified = 0x10, }; void allocCombinedFlagArrays(sead::Heap* heap); @@ -235,7 +396,7 @@ private: void initResetData(sead::Heap* heap); void initRevivalRandomBools(sead::Heap* heap); - void recordFlagChange(const FlagBase* flag, s32 idx, s16 sub_idx); + void recordFlagChange(const FlagBase* flag, s32 idx, s32 sub_idx = -1); u32 mResourceFlags = 0; -- cgit v1.2.3