mirror of
https://github.com/zeldaret/botw
synced 2026-05-23 15:01:35 -04:00
Léo Lam
296 lines
8.9 KiB
C++
296 lines
8.9 KiB
C++
#include "KingSystem/ActorSystem/actInfoData.h"
|
|
#include <codec/seadHashCRC32.h>
|
|
#include <math/seadMathNumbers.h>
|
|
#include "KingSystem/Utils/Byaml/Byaml.h"
|
|
#include "KingSystem/Utils/Byaml/ByamlArrayIter.h"
|
|
#include "KingSystem/Utils/Byaml/ByamlData.h"
|
|
#include "KingSystem/Utils/Byaml/ByamlHashIter.h"
|
|
|
|
namespace ksys::act {
|
|
|
|
SEAD_SINGLETON_DISPOSER_IMPL(InfoData)
|
|
|
|
InfoData::~InfoData() {
|
|
if (mHashesIter)
|
|
delete mHashesIter;
|
|
|
|
if (mActorsIter)
|
|
delete mActorsIter;
|
|
|
|
if (mRootIter)
|
|
delete mRootIter;
|
|
|
|
mRootIter = nullptr;
|
|
mHashesIter = nullptr;
|
|
mActorsIter = nullptr;
|
|
mHashesBytes = nullptr;
|
|
mHashes = nullptr;
|
|
mActorsBytes = nullptr;
|
|
mActorOffsets = nullptr;
|
|
}
|
|
|
|
void InfoData::init(u8* data, sead::Heap* heap, sead::Heap* debug_heap) {
|
|
mRootIter = new (heap) al::ByamlIter(data);
|
|
mHashesIter = new (heap) al::ByamlIter();
|
|
mActorsIter = new (heap) al::ByamlIter();
|
|
|
|
if (debug_heap) {
|
|
mDebugEntries = new (debug_heap) DebugEntry[NumDebugEntries];
|
|
for (s32 i = 0; i != NumDebugEntries; ++i)
|
|
mDebugEntries[i].used = false;
|
|
} else {
|
|
mDebugEntries = nullptr;
|
|
}
|
|
|
|
if (mRootIter->tryGetIterByKey(mHashesIter, "Hashes")) {
|
|
mHashesBytes = mHashesIter->getData();
|
|
mHashes = al::ByamlArrayIter(mHashesIter->getRootNode()).getDataTable();
|
|
}
|
|
|
|
if (mRootIter->tryGetIterByKey(mActorsIter, "Actors")) {
|
|
mActorsBytes = mActorsIter->getData();
|
|
mActorOffsets = al::ByamlArrayIter(mActorsIter->getRootNode()).getDataTable();
|
|
}
|
|
|
|
mNumActors = mActorsIter->getSize();
|
|
_88 = 0;
|
|
mDebugHeap = debug_heap;
|
|
mTagsIdx = mRootIter->getKeyIndex("tags");
|
|
mProfileIdx = mRootIter->getKeyIndex("profile");
|
|
mInvalidWeathersIdx = mRootIter->getKeyIndex("invalidWeathers");
|
|
mInvalidTimesIdx = mRootIter->getKeyIndex("invalidTimes");
|
|
mNameIdx = mRootIter->getKeyIndex("name");
|
|
mSystemSameGroupActorNameIdx = mRootIter->getKeyIndex("systemSameGroupActorName");
|
|
}
|
|
|
|
bool InfoData::getActorIter(al::ByamlIter* iter, const char* actor, bool x) const {
|
|
const u32 hash = sead::HashCRC32::calcStringHash(actor);
|
|
|
|
// Perform a binary search.
|
|
s32 a = 0;
|
|
s32 b = mNumActors;
|
|
while (a < b) {
|
|
const s32 idx = (a + b) / 2;
|
|
const u32 hash_i = mHashes[idx];
|
|
|
|
if (hash_i == hash) {
|
|
*iter = al::ByamlIter(mActorsBytes, mActorsBytes + mActorOffsets[idx]);
|
|
return true;
|
|
}
|
|
|
|
if (hash_i >= hash)
|
|
b = idx;
|
|
else
|
|
a = idx + 1;
|
|
}
|
|
|
|
if (x)
|
|
static_cast<void>(logFailure(actor));
|
|
|
|
return false;
|
|
}
|
|
|
|
void InfoData::getRecipeInfo(const char* actor, InfoData::RecipeInfo& info) const {
|
|
al::ByamlIter iter;
|
|
if (getActorIter(&iter, actor)) {
|
|
info.num_items = iter.getIntByKey("normal0StuffNum");
|
|
|
|
info.items[0].name = iter.getStringByKey("normal0ItemName01");
|
|
info.items[0].num = iter.getIntByKey("normal0ItemNum01");
|
|
|
|
info.items[1].name = iter.getStringByKey("normal0ItemName02");
|
|
info.items[1].num = iter.getIntByKey("normal0ItemNum02");
|
|
|
|
info.items[2].name = iter.getStringByKey("normal0ItemName03");
|
|
info.items[2].num = iter.getIntByKey("normal0ItemNum03");
|
|
|
|
} else {
|
|
info.num_items = 0;
|
|
|
|
info.items[0].name = sead::SafeString::cEmptyString;
|
|
info.items[0].num = 0;
|
|
|
|
info.items[1].name = sead::SafeString::cEmptyString;
|
|
info.items[1].num = 0;
|
|
|
|
info.items[2].name = sead::SafeString::cEmptyString;
|
|
info.items[2].num = 0;
|
|
}
|
|
}
|
|
|
|
s32 InfoData::getIntByKey(const al::ByamlIter& iter, const char* key, s32 default_) {
|
|
s32 value;
|
|
return iter.tryGetIntByKey(&value, key) ? value : default_;
|
|
}
|
|
|
|
const char* InfoData::getStringByKey(const al::ByamlIter& iter, const char* key,
|
|
const sead::SafeString& default_) {
|
|
const char* value;
|
|
return iter.tryGetStringByKey(&value, key) ? value : default_.cstr();
|
|
}
|
|
|
|
[[gnu::noinline]] static InfoData::Locator::Type
|
|
getLocatorTypeFromStr(const sead::SafeString& type) {
|
|
static constexpr const char* types[] = {"Trunk", "Branch", "GlowStone",
|
|
"OnTree", "MagnePos", "StopTimerPos"};
|
|
for (s32 i = 0; i < s32(std::size(types)); ++i) {
|
|
if (type == types[i])
|
|
return InfoData::Locator::Type(i);
|
|
}
|
|
return InfoData::Locator::Type::Invalid;
|
|
}
|
|
|
|
void InfoData::getLocators(const char* actor, Locators& info) const {
|
|
info.num = 0;
|
|
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor))
|
|
return;
|
|
|
|
al::ByamlIter iter_locators;
|
|
if (!iter.tryGetIterByKey(&iter_locators, "locators"))
|
|
return;
|
|
|
|
info.num = iter_locators.getSize();
|
|
for (s32 i = 0; i < info.num; ++i) {
|
|
al::ByamlIter it;
|
|
if (!iter_locators.tryGetIterByIndex(&it, i))
|
|
continue;
|
|
|
|
const char* type_str{};
|
|
auto& locator = info.locators[i];
|
|
|
|
it.tryGetFloatByKey(&locator.pos.x, "pos_x");
|
|
it.tryGetFloatByKey(&locator.pos.y, "pos_y");
|
|
it.tryGetFloatByKey(&locator.pos.z, "pos_z");
|
|
|
|
it.tryGetFloatByKey(&locator.rot.x, "rot_x");
|
|
it.tryGetFloatByKey(&locator.rot.y, "rot_y");
|
|
it.tryGetFloatByKey(&locator.rot.z, "rot_z");
|
|
|
|
it.tryGetStringByKey(&type_str, "type");
|
|
locator.type = type_str ? getLocatorTypeFromStr(type_str) : Locator::Type::Invalid;
|
|
|
|
locator.rot *= 2 * sead::numbers::pi / 360.0;
|
|
}
|
|
}
|
|
|
|
void InfoData::getHomeAreas(const char* actor, HomeAreas& info) const {
|
|
info.names.fill("");
|
|
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor))
|
|
return;
|
|
|
|
al::ByamlIter home_area;
|
|
if (!iter.tryGetIterByKey(&home_area, "homeArea"))
|
|
return;
|
|
|
|
for (s32 i = 0, n = home_area.getSize(); i < info.names.size() && i < n; ++i) {
|
|
al::ByamlIter it;
|
|
if (home_area.tryGetIterByIndex(&it, i))
|
|
it.tryGetStringByKey(&info.names[i], "name");
|
|
}
|
|
}
|
|
|
|
// NON_MATCHING: stack
|
|
const char* InfoData::getSameGroupActorName(const char* actor) const {
|
|
al::ByamlIter iter;
|
|
if (getActorIter(&iter, actor, false)) {
|
|
al::ByamlHashIter hash_iter{iter.getRootNode()};
|
|
al::ByamlData data;
|
|
if (hash_iter.getDataByKey(&data, mSystemSameGroupActorNameIdx)) {
|
|
const char* name;
|
|
if (iter.tryConvertString(&name, &data))
|
|
return name;
|
|
}
|
|
}
|
|
return sead::SafeString::cEmptyString.cstr();
|
|
}
|
|
|
|
const char* InfoData::getString(const char* actor, const char* key,
|
|
const sead::SafeString& default_, bool x) const {
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor, x))
|
|
return default_.cstr();
|
|
|
|
return getStringByKey(iter, key, default_);
|
|
}
|
|
|
|
const char* InfoData::getSLinkUser(const char* actor) const {
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor))
|
|
return "Dummy";
|
|
|
|
return getStringByKey(iter, "slink", "Dummy");
|
|
}
|
|
|
|
bool InfoData::getSLinkAndELinkUsers(const char* actor, const char** elink,
|
|
const char** slink) const {
|
|
al::ByamlIter iter;
|
|
if (getActorIter(&iter, actor)) {
|
|
*elink = getStringByKey(iter, "elink", "Dummy");
|
|
*slink = getStringByKey(iter, "slink", "Dummy");
|
|
return true;
|
|
}
|
|
*elink = "Dummy";
|
|
*slink = "Dummy";
|
|
return false;
|
|
}
|
|
|
|
const char* InfoData::getXLinkUser(const char* actor) const {
|
|
return getString(actor, "xlink", "Dummy");
|
|
}
|
|
|
|
bool InfoData::getActorProfile(const char** profile, const char* actor) const {
|
|
al::ByamlIter iter;
|
|
if (getActorIter(&iter, actor)) {
|
|
al::ByamlHashIter hash_iter{iter.getRootNode()};
|
|
al::ByamlData data;
|
|
if (hash_iter.getDataByKey(&data, mProfileIdx))
|
|
return iter.tryConvertString(profile, &data);
|
|
}
|
|
*profile = "Dummy";
|
|
return false;
|
|
}
|
|
|
|
s32 InfoData::getInt(const char* actor, const char* key, s32 default_, bool x) const {
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor, x))
|
|
return default_;
|
|
|
|
return getIntByKey(iter, key, default_);
|
|
}
|
|
|
|
f32 InfoData::getFloat(const char* actor, const char* key, f32 default_, bool x) const {
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor, x))
|
|
return default_;
|
|
|
|
return getFloatByKey(iter, key, default_);
|
|
}
|
|
|
|
bool InfoData::getBool(const char* actor, const char* key, bool default_, bool x) const {
|
|
al::ByamlIter iter;
|
|
if (!getActorIter(&iter, actor, x))
|
|
return default_;
|
|
|
|
return getBoolByKey(iter, key, default_);
|
|
}
|
|
|
|
f32 InfoData::getFloatByKey(const al::ByamlIter& iter, const char* key, f32 default_) {
|
|
f32 value;
|
|
return iter.tryGetFloatByKey(&value, key) ? value : default_;
|
|
}
|
|
|
|
bool InfoData::getBoolByKey(const al::ByamlIter& iter, const char* key, bool default_) {
|
|
bool value;
|
|
return iter.tryGetBoolByKey(&value, key) ? value != 0 : default_;
|
|
}
|
|
|
|
f32 InfoData::getScale(const char* actor) const {
|
|
return getFloat(actor, "actorScale", 1.0);
|
|
}
|
|
|
|
} // namespace ksys::act
|