Martin Michelsen
2812 lines
106 KiB
C++
2812 lines
106 KiB
C++
#include "ItemParameterTable.hh"
|
|
|
|
#include "CommonFileFormats.hh"
|
|
|
|
using namespace std;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Utilities
|
|
|
|
template <>
|
|
ServerDropMode phosg::enum_for_name<ServerDropMode>(const char* name) {
|
|
if (!strcmp(name, "DISABLED")) {
|
|
return ServerDropMode::DISABLED;
|
|
} else if (!strcmp(name, "CLIENT")) {
|
|
return ServerDropMode::CLIENT;
|
|
} else if (!strcmp(name, "SERVER_SHARED")) {
|
|
return ServerDropMode::SERVER_SHARED;
|
|
} else if (!strcmp(name, "SERVER_PRIVATE")) {
|
|
return ServerDropMode::SERVER_PRIVATE;
|
|
} else if (!strcmp(name, "SERVER_DUPLICATE")) {
|
|
return ServerDropMode::SERVER_DUPLICATE;
|
|
} else {
|
|
throw runtime_error("invalid drop mode");
|
|
}
|
|
}
|
|
|
|
template <>
|
|
const char* phosg::name_for_enum<ServerDropMode>(ServerDropMode value) {
|
|
switch (value) {
|
|
case ServerDropMode::DISABLED:
|
|
return "DISABLED";
|
|
case ServerDropMode::CLIENT:
|
|
return "CLIENT";
|
|
case ServerDropMode::SERVER_SHARED:
|
|
return "SERVER_SHARED";
|
|
case ServerDropMode::SERVER_PRIVATE:
|
|
return "SERVER_PRIVATE";
|
|
case ServerDropMode::SERVER_DUPLICATE:
|
|
return "SERVER_DUPLICATE";
|
|
default:
|
|
throw runtime_error("invalid drop mode");
|
|
}
|
|
}
|
|
|
|
static void u32_to_item_code(parray<uint8_t, 3>& decoded, uint32_t item) {
|
|
decoded[0] = item >> 16;
|
|
decoded[1] = item >> 8;
|
|
decoded[2] = item;
|
|
}
|
|
|
|
static uint32_t item_code_to_u32(const parray<uint8_t, 3>& item) {
|
|
return (item[0] << 16) | (item[1] << 8) | item[2];
|
|
}
|
|
static uint32_t item_code_to_u32(uint8_t data1_0, uint8_t data1_1, uint8_t data1_2) {
|
|
return (data1_0 << 16) | (data1_1 << 8) | data1_2;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Parsed structures
|
|
|
|
void ItemParameterTable::ItemBase::parse_base_from_json(const phosg::JSON& json) {
|
|
this->id = json.get_int("ID");
|
|
this->type = json.get_int("Type");
|
|
this->skin = json.get_int("Skin");
|
|
this->team_points = json.get_int("TeamPoints");
|
|
}
|
|
phosg::JSON ItemParameterTable::ItemBase::json() const {
|
|
return phosg::JSON::dict(
|
|
{{"ID", this->id}, {"Type", this->type}, {"Skin", this->skin}, {"TeamPoints", this->team_points}});
|
|
}
|
|
|
|
ItemParameterTable::Weapon ItemParameterTable::Weapon::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::Weapon ret;
|
|
ret.parse_base_from_json(json);
|
|
ret.class_flags = json.get_int("ClassFlags");
|
|
ret.atp_min = json.get_int("ATPMin");
|
|
ret.atp_max = json.get_int("ATPMax");
|
|
ret.atp_required = json.get_int("ATPRequired");
|
|
ret.mst_required = json.get_int("MSTRequired");
|
|
ret.ata_required = json.get_int("ATARequired");
|
|
ret.mst = json.get_int("MST");
|
|
ret.max_grind = json.get_int("MaxGrind");
|
|
ret.photon = json.get_int("Photon");
|
|
ret.special = json.get_int("Special");
|
|
ret.ata = json.get_int("ATA");
|
|
ret.stat_boost_entry_index = json.get_int("StatBoostEntryIndex");
|
|
ret.projectile = json.get_int("Projectile");
|
|
ret.trail1_x = json.get_int("Trail1X");
|
|
ret.trail1_y = json.get_int("Trail1Y");
|
|
ret.trail2_x = json.get_int("Trail2X");
|
|
ret.trail2_y = json.get_int("Trail2Y");
|
|
ret.color = json.get_int("Color");
|
|
const auto& unknown_a1 = json.get_list("UnknownA1");
|
|
ret.unknown_a1[0] = unknown_a1[0]->as_int();
|
|
ret.unknown_a1[1] = unknown_a1[1]->as_int();
|
|
ret.unknown_a1[2] = unknown_a1[2]->as_int();
|
|
ret.unknown_a4 = json.get_int("UnknownA4");
|
|
ret.unknown_a5 = json.get_int("UnknownA5");
|
|
ret.tech_boost_entry_index = json.get_int("TechBoostEntryIndex");
|
|
ret.behavior_flags = json.get_int("BehaviorFlags");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::Weapon::json() const {
|
|
phosg::JSON ret = this->ItemBase::json();
|
|
ret.emplace("ClassFlags", this->class_flags);
|
|
ret.emplace("ATPMin", this->atp_min);
|
|
ret.emplace("ATPMax", this->atp_max);
|
|
ret.emplace("ATPRequired", this->atp_required);
|
|
ret.emplace("MSTRequired", this->mst_required);
|
|
ret.emplace("ATARequired", this->ata_required);
|
|
ret.emplace("MST", this->mst);
|
|
ret.emplace("MaxGrind", this->max_grind);
|
|
ret.emplace("Photon", this->photon);
|
|
ret.emplace("Special", this->special);
|
|
ret.emplace("ATA", this->ata);
|
|
ret.emplace("StatBoostEntryIndex", this->stat_boost_entry_index);
|
|
ret.emplace("Projectile", this->projectile);
|
|
ret.emplace("Trail1X", this->trail1_x);
|
|
ret.emplace("Trail1Y", this->trail1_y);
|
|
ret.emplace("Trail2X", this->trail2_x);
|
|
ret.emplace("Trail2Y", this->trail2_y);
|
|
ret.emplace("Color", this->color);
|
|
ret.emplace("UnknownA1", phosg::JSON::list({this->unknown_a1[0], this->unknown_a1[1], this->unknown_a1[2]}));
|
|
ret.emplace("UnknownA4", this->unknown_a4);
|
|
ret.emplace("UnknownA5", this->unknown_a5);
|
|
ret.emplace("TechBoostEntryIndex", this->tech_boost_entry_index);
|
|
ret.emplace("BehaviorFlags", this->behavior_flags);
|
|
return ret;
|
|
}
|
|
|
|
ItemParameterTable::ArmorOrShield ItemParameterTable::ArmorOrShield::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::ArmorOrShield ret;
|
|
ret.parse_base_from_json(json);
|
|
ret.dfp = json.get_int("DFP");
|
|
ret.evp = json.get_int("EVP");
|
|
ret.block_particle = json.get_int("BlockParticle");
|
|
ret.block_effect = json.get_int("BlockEffect");
|
|
ret.class_flags = json.get_int("ClassFlags");
|
|
ret.required_level = json.get_int("RequiredLevel");
|
|
ret.efr = json.get_int("EFR");
|
|
ret.eth = json.get_int("ETH");
|
|
ret.eic = json.get_int("EIC");
|
|
ret.edk = json.get_int("EDK");
|
|
ret.elt = json.get_int("ELT");
|
|
ret.dfp_range = json.get_int("DFPRange");
|
|
ret.evp_range = json.get_int("EVPRange");
|
|
ret.stat_boost_entry_index = json.get_int("StatBoostEntryIndex");
|
|
ret.tech_boost_entry_index = json.get_int("TechBoostEntryIndex");
|
|
ret.flags_type = json.get_int("FlagsType");
|
|
ret.unknown_a4 = json.get_int("UnknownA4");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::ArmorOrShield::json() const {
|
|
phosg::JSON ret = this->ItemBase::json();
|
|
ret.emplace("DFP", this->dfp);
|
|
ret.emplace("EVP", this->evp);
|
|
ret.emplace("BlockParticle", this->block_particle);
|
|
ret.emplace("BlockEffect", this->block_effect);
|
|
ret.emplace("ClassFlags", this->class_flags);
|
|
ret.emplace("RequiredLevel", this->required_level);
|
|
ret.emplace("EFR", this->efr);
|
|
ret.emplace("ETH", this->eth);
|
|
ret.emplace("EIC", this->eic);
|
|
ret.emplace("EDK", this->edk);
|
|
ret.emplace("ELT", this->elt);
|
|
ret.emplace("DFPRange", this->dfp_range);
|
|
ret.emplace("EVPRange", this->evp_range);
|
|
ret.emplace("StatBoostEntryIndex", this->stat_boost_entry_index);
|
|
ret.emplace("TechBoostEntryIndex", this->tech_boost_entry_index);
|
|
ret.emplace("FlagsType", this->flags_type);
|
|
ret.emplace("UnknownA4", this->unknown_a4);
|
|
return ret;
|
|
}
|
|
|
|
ItemParameterTable::Unit ItemParameterTable::Unit::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::Unit ret;
|
|
ret.parse_base_from_json(json);
|
|
ret.stat = json.get_int("Stat");
|
|
ret.stat_amount = json.get_int("StatAmount");
|
|
ret.modifier_amount = json.get_int("ModifierAmount");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::Unit::json() const {
|
|
phosg::JSON ret = this->ItemBase::json();
|
|
ret.emplace("Stat", this->stat);
|
|
ret.emplace("StatAmount", this->stat_amount);
|
|
ret.emplace("ModifierAmount", this->modifier_amount);
|
|
return ret;
|
|
}
|
|
|
|
ItemParameterTable::Mag ItemParameterTable::Mag::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::Mag ret;
|
|
ret.parse_base_from_json(json);
|
|
ret.feed_table = json.get_int("FeedTable");
|
|
ret.photon_blast = json.get_int("PhotonBlast");
|
|
ret.activation = json.get_int("Activation");
|
|
ret.on_pb_full = json.get_int("OnPBFull");
|
|
ret.on_low_hp = json.get_int("OnLowHP");
|
|
ret.on_death = json.get_int("OnDeath");
|
|
ret.on_boss = json.get_int("OnBoss");
|
|
ret.on_pb_full_flag = json.get_int("OnPBFullFlag");
|
|
ret.on_low_hp_flag = json.get_int("OnLowHPFlag");
|
|
ret.on_death_flag = json.get_int("OnDeathFlag");
|
|
ret.on_boss_flag = json.get_int("OnBossFlag");
|
|
ret.class_flags = json.get_int("ClassFlags");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::Mag::json() const {
|
|
phosg::JSON ret = this->ItemBase::json();
|
|
ret.emplace("FeedTable", this->feed_table);
|
|
ret.emplace("PhotonBlast", this->photon_blast);
|
|
ret.emplace("Activation", this->activation);
|
|
ret.emplace("OnPBFull", this->on_pb_full);
|
|
ret.emplace("OnLowHP", this->on_low_hp);
|
|
ret.emplace("OnDeath", this->on_death);
|
|
ret.emplace("OnBoss", this->on_boss);
|
|
ret.emplace("OnPBFullFlag", this->on_pb_full_flag);
|
|
ret.emplace("OnLowHPFlag", this->on_low_hp_flag);
|
|
ret.emplace("OnDeathFlag", this->on_death_flag);
|
|
ret.emplace("OnBossFlag", this->on_boss_flag);
|
|
ret.emplace("ClassFlags", this->class_flags);
|
|
return ret;
|
|
}
|
|
|
|
ItemParameterTable::Tool ItemParameterTable::Tool::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::Tool ret;
|
|
ret.parse_base_from_json(json);
|
|
ret.amount = json.get_int("Amount");
|
|
ret.tech = json.get_int("Tech");
|
|
ret.cost = json.get_int("Cost");
|
|
ret.item_flags = json.get_int("ItemFlags");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::Tool::json() const {
|
|
phosg::JSON ret = this->ItemBase::json();
|
|
ret.emplace("Amount", this->amount);
|
|
ret.emplace("Tech", this->tech);
|
|
ret.emplace("Cost", this->cost);
|
|
ret.emplace("ItemFlags", this->item_flags);
|
|
return ret;
|
|
}
|
|
|
|
ItemParameterTable::MagFeedResult ItemParameterTable::MagFeedResult::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::MagFeedResult ret;
|
|
ret.def = json.get_int("DEF");
|
|
ret.pow = json.get_int("POW");
|
|
ret.dex = json.get_int("DEX");
|
|
ret.mind = json.get_int("MIND");
|
|
ret.iq = json.get_int("IQ");
|
|
ret.synchro = json.get_int("Synchro");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::MagFeedResult::json() const {
|
|
return phosg::JSON::dict({
|
|
{"DEF", this->def},
|
|
{"POW", this->pow},
|
|
{"DEX", this->dex},
|
|
{"MIND", this->mind},
|
|
{"IQ", this->iq},
|
|
{"Synchro", this->synchro},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::Special ItemParameterTable::Special::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::Special ret;
|
|
ret.type = json.get_int("Type");
|
|
ret.amount = json.get_int("Amount");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::Special::json() const {
|
|
return phosg::JSON::dict({{"Type", this->type}, {"Amount", this->amount}});
|
|
}
|
|
|
|
ItemParameterTable::StatBoost ItemParameterTable::StatBoost::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::StatBoost ret;
|
|
ret.stat1 = json.get_int("Stat1");
|
|
ret.amount1 = json.get_int("Amount1");
|
|
ret.stat2 = json.get_int("Stat2");
|
|
ret.amount2 = json.get_int("Amount2");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::StatBoost::json() const {
|
|
return phosg::JSON::dict({
|
|
{"Stat1", this->stat1},
|
|
{"Amount1", this->amount1},
|
|
{"Stat2", this->stat2},
|
|
{"Amount2", this->amount2},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::ItemCombination ItemParameterTable::ItemCombination::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::ItemCombination ret;
|
|
u32_to_item_code(ret.used_item, json.get_int("UsedItem"));
|
|
u32_to_item_code(ret.equipped_item, json.get_int("EquippedItem"));
|
|
u32_to_item_code(ret.result_item, json.get_int("ResultItem"));
|
|
ret.mag_level = json.get_int("MagLevel");
|
|
ret.grind = json.get_int("Grind");
|
|
ret.level = json.get_int("Level");
|
|
ret.char_class = json.get_int("CharClass");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::ItemCombination::json() const {
|
|
return phosg::JSON::dict({
|
|
{"UsedItem", item_code_to_u32(this->used_item)},
|
|
{"EquippedItem", item_code_to_u32(this->equipped_item)},
|
|
{"ResultItem", item_code_to_u32(this->result_item)},
|
|
{"MagLevel", this->mag_level},
|
|
{"Grind", this->grind},
|
|
{"Level", this->level},
|
|
{"CharClass", this->char_class},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::TechBoost ItemParameterTable::TechBoost::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::TechBoost ret;
|
|
ret.tech_num1 = json.get_int("TechNum1");
|
|
ret.flags1 = json.get_int("Flags1");
|
|
ret.amount1 = json.get_int("Amount1");
|
|
ret.tech_num2 = json.get_int("TechNum2");
|
|
ret.flags2 = json.get_int("Flags2");
|
|
ret.amount2 = json.get_int("Amount2");
|
|
ret.tech_num3 = json.get_int("TechNum3");
|
|
ret.flags3 = json.get_int("Flags3");
|
|
ret.amount3 = json.get_int("Amount3");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::TechBoost::json() const {
|
|
return phosg::JSON::dict({
|
|
{"TechNum1", this->tech_num1},
|
|
{"Flags1", this->flags1},
|
|
{"Amount1", this->amount1},
|
|
{"TechNum2", this->tech_num2},
|
|
{"Flags2", this->flags2},
|
|
{"Amount2", this->amount2},
|
|
{"TechNum3", this->tech_num3},
|
|
{"Flags3", this->flags3},
|
|
{"Amount3", this->amount3},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::EventItem ItemParameterTable::EventItem::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::EventItem ret;
|
|
u32_to_item_code(ret.item, json.get_int("Item"));
|
|
ret.probability = json.get_int("Probability");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::EventItem::json() const {
|
|
return phosg::JSON::dict({
|
|
{"Item", item_code_to_u32(this->item)},
|
|
{"Probability", this->probability},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::UnsealableItem ItemParameterTable::UnsealableItem::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::UnsealableItem ret;
|
|
u32_to_item_code(ret.item, json.get_int("Item"));
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::UnsealableItem::json() const {
|
|
return phosg::JSON::dict({{"Item", item_code_to_u32(this->item)}});
|
|
}
|
|
|
|
ItemParameterTable::NonWeaponSaleDivisors ItemParameterTable::NonWeaponSaleDivisors::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::NonWeaponSaleDivisors ret;
|
|
ret.armor_divisor = json.get_float("ArmorDivisor");
|
|
ret.shield_divisor = json.get_float("ShieldDivisor");
|
|
ret.unit_divisor = json.get_float("UnitDivisor");
|
|
ret.mag_divisor = json.get_float("MagDivisor");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::NonWeaponSaleDivisors::json() const {
|
|
return phosg::JSON::dict({
|
|
{"ArmorDivisor", this->armor_divisor},
|
|
{"ShieldDivisor", this->shield_divisor},
|
|
{"UnitDivisor", this->unit_divisor},
|
|
{"MagDivisor", this->mag_divisor},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::ShieldEffect ItemParameterTable::ShieldEffect::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::ShieldEffect ret;
|
|
ret.sound_id = json.get_int("SoundID");
|
|
ret.unknown_a1 = json.get_int("UnknownA1");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::ShieldEffect::json() const {
|
|
return phosg::JSON::dict({{"SoundID", this->sound_id}, {"UnknownA1", this->unknown_a1}});
|
|
}
|
|
|
|
ItemParameterTable::PhotonColorEntry ItemParameterTable::PhotonColorEntry::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::PhotonColorEntry ret;
|
|
ret.unknown_a1 = json.get_int("UnknownA1");
|
|
const auto& unknown_a2 = json.get_list("UnknownA2");
|
|
const auto& unknown_a3 = json.get_list("UnknownA3");
|
|
ret.unknown_a2.x = unknown_a2.at(0)->as_int();
|
|
ret.unknown_a2.y = unknown_a2.at(1)->as_int();
|
|
ret.unknown_a2.z = unknown_a2.at(2)->as_int();
|
|
ret.unknown_a2.t = unknown_a2.at(3)->as_int();
|
|
ret.unknown_a3.x = unknown_a3.at(0)->as_int();
|
|
ret.unknown_a3.y = unknown_a3.at(1)->as_int();
|
|
ret.unknown_a3.z = unknown_a3.at(2)->as_int();
|
|
ret.unknown_a3.t = unknown_a3.at(3)->as_int();
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::PhotonColorEntry::json() const {
|
|
return phosg::JSON::dict({
|
|
{"UnknownA1", this->unknown_a1},
|
|
{"UnknownA2", phosg::JSON::list({this->unknown_a2.x.load(), this->unknown_a2.y.load(), this->unknown_a2.z.load(), this->unknown_a2.t.load()})},
|
|
{"UnknownA3", phosg::JSON::list({this->unknown_a3.x.load(), this->unknown_a3.y.load(), this->unknown_a3.z.load(), this->unknown_a3.t.load()})},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::UnknownA1 ItemParameterTable::UnknownA1::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::UnknownA1 ret;
|
|
ret.unknown_a1 = json.get_int("UnknownA1");
|
|
ret.unknown_a2 = json.get_int("UnknownA2");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::UnknownA1::json() const {
|
|
return phosg::JSON::dict({{"UnknownA1", this->unknown_a1}, {"UnknownA2", this->unknown_a2}});
|
|
}
|
|
|
|
ItemParameterTable::WeaponEffect ItemParameterTable::WeaponEffect::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::WeaponEffect ret;
|
|
ret.sound_id1 = json.get_int("SoundID1");
|
|
ret.eff_value1 = json.get_int("EffectValue1");
|
|
ret.sound_id2 = json.get_int("SoundID2");
|
|
ret.eff_value2 = json.get_int("EffectValue2");
|
|
std::string unknown_a5 = phosg::parse_data_string(json.get_string("UnknownA5"));
|
|
for (size_t z = 0; z < std::min<size_t>(ret.unknown_a5.size(), unknown_a5.size()); z++) {
|
|
ret.unknown_a5[z] = unknown_a5[z];
|
|
}
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::WeaponEffect::json() const {
|
|
return phosg::JSON::dict({
|
|
{"SoundID1", this->sound_id1},
|
|
{"EffectValue1", this->eff_value1},
|
|
{"SoundID2", this->sound_id2},
|
|
{"EffectValue2", this->eff_value2},
|
|
{"UnknownA5", phosg::format_data_string(this->unknown_a5.data(), this->unknown_a5.size())},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::WeaponRange ItemParameterTable::WeaponRange::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::WeaponRange ret;
|
|
ret.unknown_a1 = json.get_int("UnknownA1");
|
|
ret.unknown_a2 = json.get_int("UnknownA2");
|
|
ret.unknown_a3 = json.get_int("UnknownA3");
|
|
ret.unknown_a4 = json.get_int("UnknownA4");
|
|
ret.unknown_a5 = json.get_int("UnknownA5");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::WeaponRange::json() const {
|
|
return phosg::JSON::dict({
|
|
{"UnknownA1", this->unknown_a1},
|
|
{"UnknownA2", this->unknown_a2},
|
|
{"UnknownA3", this->unknown_a3},
|
|
{"UnknownA4", this->unknown_a4},
|
|
{"UnknownA5", this->unknown_a5},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::RangedSpecial ItemParameterTable::RangedSpecial::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::RangedSpecial ret;
|
|
ret.data1_1 = json.get_int("Data1_1");
|
|
ret.data1_2 = json.get_int("Data1_2");
|
|
ret.weapon_range_index = json.get_int("WeaponRangeIndex");
|
|
ret.unknown_a1 = json.get_int("UnknownA1");
|
|
return ret;
|
|
}
|
|
phosg::JSON ItemParameterTable::RangedSpecial::json() const {
|
|
return phosg::JSON::dict({
|
|
{"Data1_1", this->data1_1},
|
|
{"Data1_2", this->data1_2},
|
|
{"WeaponRangeIndex", this->weapon_range_index},
|
|
{"UnknownA1", this->unknown_a1},
|
|
});
|
|
}
|
|
|
|
ItemParameterTable::SoundRemaps ItemParameterTable::SoundRemaps::from_json(const phosg::JSON& json) {
|
|
ItemParameterTable::SoundRemaps ret;
|
|
ret.sound_id = json.get_int("SoundID");
|
|
for (const auto& sound_id_json : json.get_list("ByRTIndex")) {
|
|
ret.by_rt_index.emplace_back(sound_id_json->as_int());
|
|
}
|
|
for (const auto& sound_id_json : json.get_list("ByCharClass")) {
|
|
ret.by_char_class.emplace_back(sound_id_json->as_int());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
phosg::JSON ItemParameterTable::SoundRemaps::json() const {
|
|
auto by_rt_index_json = phosg::JSON::list();
|
|
auto by_char_class_json = phosg::JSON::list();
|
|
for (uint32_t sound_id : this->by_rt_index) {
|
|
by_rt_index_json.emplace_back(sound_id);
|
|
}
|
|
for (uint32_t sound_id : this->by_char_class) {
|
|
by_char_class_json.emplace_back(sound_id);
|
|
}
|
|
return phosg::JSON::dict({
|
|
{"SoundID", this->sound_id},
|
|
{"ByRTIndex", std::move(by_rt_index_json)},
|
|
{"ByCharClass", std::move(by_char_class_json)},
|
|
});
|
|
}
|
|
|
|
phosg::JSON ItemParameterTable::json() const {
|
|
auto items_json = phosg::JSON::dict();
|
|
|
|
for (size_t data1_1 = 0; data1_1 < this->num_weapon_classes(); data1_1++) {
|
|
size_t class_size = this->num_weapons_in_class(data1_1);
|
|
uint8_t weapon_kind = this->get_weapon_kind(data1_1);
|
|
float sale_divisor = this->get_sale_divisor(0, data1_1);
|
|
for (size_t data1_2 = 0; data1_2 < class_size; data1_2++) {
|
|
auto weapon_dict = this->get_weapon(data1_1, data1_2).json();
|
|
weapon_dict.emplace("WeaponKind", weapon_kind);
|
|
weapon_dict.emplace("SaleDivisor", sale_divisor);
|
|
items_json.emplace(std::format("00{:02X}{:02X}", data1_1, data1_2), std::move(weapon_dict));
|
|
}
|
|
}
|
|
for (size_t data1_1 = 1; data1_1 < 3; data1_1++) {
|
|
size_t class_size = this->num_armors_or_shields_in_class(data1_1);
|
|
for (size_t data1_2 = 0; data1_2 < class_size; data1_2++) {
|
|
items_json.emplace(std::format("01{:02X}{:02X}", data1_1, data1_2), this->get_armor_or_shield(data1_1, data1_2).json());
|
|
}
|
|
}
|
|
size_t class_size = this->num_units();
|
|
for (size_t data1_2 = 0; data1_2 < class_size; data1_2++) {
|
|
items_json.emplace(std::format("0103{:02X}", data1_2), this->get_unit(data1_2).json());
|
|
}
|
|
class_size = this->num_mags();
|
|
for (size_t data1_1 = 0; data1_1 < class_size; data1_1++) {
|
|
items_json.emplace(std::format("02{:02X}", data1_1), this->get_mag(data1_1).json());
|
|
}
|
|
for (size_t data1_1 = 0; data1_1 < this->num_tool_classes(); data1_1++) {
|
|
size_t class_size = this->num_tools_in_class(data1_1);
|
|
for (size_t data1_2 = 0; data1_2 < class_size; data1_2++) {
|
|
items_json.emplace(std::format("03{:02X}{:02X}", data1_1, data1_2), this->get_tool(data1_1, data1_2).json());
|
|
}
|
|
}
|
|
|
|
auto photon_colors_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_photon_colors(); z++) {
|
|
photon_colors_json.emplace_back(this->get_photon_color(z).json());
|
|
}
|
|
|
|
auto weapon_ranges_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_weapon_ranges(); z++) {
|
|
weapon_ranges_json.emplace_back(this->get_weapon_range(z).json());
|
|
}
|
|
|
|
float armor_sale_divisor = this->get_sale_divisor(1, 1);
|
|
float shield_sale_divisor = this->get_sale_divisor(1, 2);
|
|
float unit_sale_divisor = this->get_sale_divisor(1, 3);
|
|
float mag_sale_divisor = this->get_sale_divisor(2, 0);
|
|
|
|
auto mag_feed_results_json = phosg::JSON::list();
|
|
for (size_t table_index = 0; table_index < 8; table_index++) {
|
|
auto this_mag_feed_result_json = phosg::JSON::list();
|
|
for (size_t item_index = 0; item_index < 11; item_index++) {
|
|
this_mag_feed_result_json.emplace_back(this->get_mag_feed_result(table_index, item_index).json());
|
|
}
|
|
mag_feed_results_json.emplace_back(std::move(this_mag_feed_result_json));
|
|
}
|
|
|
|
auto [start_star_value_index, end_star_value_index] = this->get_star_value_index_range();
|
|
auto star_values_json = phosg::JSON::list();
|
|
for (size_t z = start_star_value_index; z < end_star_value_index; z++) {
|
|
star_values_json.emplace_back(this->get_item_stars(z));
|
|
}
|
|
|
|
phosg::JSON unknown_a1_json = this->get_unknown_a1();
|
|
|
|
auto specials_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_specials(); z++) {
|
|
specials_json.emplace_back(this->get_special(z).json());
|
|
}
|
|
|
|
auto weapon_effects_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_weapon_effects(); z++) {
|
|
weapon_effects_json.emplace_back(this->get_weapon_effect(z).json());
|
|
}
|
|
|
|
auto weapon_stat_boost_indexes_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_weapon_stat_boost_indexes(); z++) {
|
|
weapon_stat_boost_indexes_json.emplace_back(this->get_weapon_stat_boost_index(z));
|
|
}
|
|
|
|
auto armor_stat_boost_indexes_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_armor_stat_boost_indexes(); z++) {
|
|
armor_stat_boost_indexes_json.emplace_back(this->get_armor_stat_boost_index(z));
|
|
}
|
|
|
|
auto shield_stat_boost_indexes_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_shield_stat_boost_indexes(); z++) {
|
|
shield_stat_boost_indexes_json.emplace_back(this->get_shield_stat_boost_index(z));
|
|
}
|
|
|
|
auto stat_boosts_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_stat_boosts(); z++) {
|
|
stat_boosts_json.emplace_back(this->get_stat_boost(z).json());
|
|
}
|
|
|
|
auto shield_effects_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_shield_effects(); z++) {
|
|
shield_effects_json.emplace_back(this->get_shield_effect(z).json());
|
|
}
|
|
|
|
auto max_tech_levels_json = phosg::JSON::dict();
|
|
for (size_t tech_num = 0; tech_num < 0x13; tech_num++) {
|
|
auto this_tech_ret = phosg::JSON::dict();
|
|
for (size_t char_class = 0; char_class < 0x0C; char_class++) {
|
|
this_tech_ret.emplace(name_for_char_class(char_class), this->get_max_tech_level(char_class, tech_num));
|
|
}
|
|
max_tech_levels_json.emplace(name_for_technique(tech_num), std::move(this_tech_ret));
|
|
}
|
|
|
|
auto combination_table_json = phosg::JSON::list();
|
|
for (const auto& [used_item, combos] : this->all_item_combinations()) {
|
|
for (const auto& combo : combos) {
|
|
combination_table_json.emplace_back(combo.json());
|
|
}
|
|
}
|
|
|
|
auto sound_remaps_json = phosg::JSON::list();
|
|
for (const auto& [_, remaps] : get_all_sound_remaps()) {
|
|
sound_remaps_json.emplace_back(remaps.json());
|
|
}
|
|
|
|
auto tech_boosts_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_tech_boosts(); z++) {
|
|
tech_boosts_json.emplace_back(this->get_tech_boost(z).json());
|
|
}
|
|
|
|
auto unwrap_tables_json = phosg::JSON::list();
|
|
for (size_t event = 0; event < this->num_events(); event++) {
|
|
auto [items, count] = this->get_event_items(event);
|
|
for (size_t z = 0; z < count; z++) {
|
|
unwrap_tables_json.emplace_back(items[z].json());
|
|
}
|
|
}
|
|
|
|
auto unsealable_items_json = phosg::JSON::list();
|
|
const auto& unsealable_items = this->all_unsealable_items();
|
|
for (uint32_t item : unsealable_items) {
|
|
unsealable_items_json.emplace_back(item);
|
|
}
|
|
|
|
auto ranged_specials_json = phosg::JSON::list();
|
|
for (size_t z = 0; z < this->num_ranged_specials(); z++) {
|
|
ranged_specials_json.emplace_back(this->get_ranged_special(z).json());
|
|
}
|
|
|
|
return phosg::JSON::dict({
|
|
{"ArmorSaleDivisor", armor_sale_divisor},
|
|
{"ArmorStatBoostIndexes", std::move(armor_stat_boost_indexes_json)},
|
|
{"ItemCombinations", std::move(combination_table_json)},
|
|
{"Items", std::move(items_json)},
|
|
{"MagFeedResults", std::move(mag_feed_results_json)},
|
|
{"MagSaleDivisor", mag_sale_divisor},
|
|
{"MaxTechLevels", std::move(max_tech_levels_json)},
|
|
{"PhotonColors", std::move(photon_colors_json)},
|
|
{"RangedSpecials", std::move(ranged_specials_json)},
|
|
{"ShieldEffects", std::move(shield_effects_json)},
|
|
{"ShieldSaleDivisor", shield_sale_divisor},
|
|
{"ShieldStatBoostIndexes", std::move(shield_stat_boost_indexes_json)},
|
|
{"SoundRemaps", std::move(sound_remaps_json)},
|
|
{"Specials", std::move(specials_json)},
|
|
{"StarValues", std::move(star_values_json)},
|
|
{"StarValueBaseIndex", start_star_value_index},
|
|
{"SpecialStarsBaseIndex", this->get_special_stars_base_index()},
|
|
{"StatBoosts", std::move(stat_boosts_json)},
|
|
{"TechBoosts", std::move(tech_boosts_json)},
|
|
{"UnitSaleDivisor", unit_sale_divisor},
|
|
{"UnknownA1", std::move(unknown_a1_json)},
|
|
{"UnsealableItems", std::move(unsealable_items_json)},
|
|
{"UnwrapTables", std::move(unwrap_tables_json)},
|
|
{"WeaponEffects", std::move(weapon_effects_json)},
|
|
{"WeaponRanges", std::move(weapon_ranges_json)},
|
|
{"WeaponStatBoostIndexes", std::move(weapon_stat_boost_indexes_json)},
|
|
});
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// JSON implementation
|
|
|
|
class JSONItemParameterTable : public ItemParameterTable {
|
|
public:
|
|
JSONItemParameterTable() = delete;
|
|
|
|
explicit JSONItemParameterTable(const phosg::JSON& json) {
|
|
for (const auto& [key, item_json] : json.get_dict("Items")) {
|
|
auto item_code = phosg::parse_data_string(key);
|
|
if (item_code.size() != 3) {
|
|
throw std::runtime_error("invalid item code in Items dict");
|
|
}
|
|
uint8_t data1_0 = item_code[0];
|
|
uint8_t data1_1 = item_code[1];
|
|
uint8_t data1_2 = item_code[2];
|
|
switch (data1_0) {
|
|
case 0:
|
|
if (this->weapons.size() <= data1_1) {
|
|
this->weapons.resize(data1_1 + 1);
|
|
}
|
|
if (this->weapons[data1_1].size() <= data1_2) {
|
|
this->weapons[data1_1].resize(data1_2 + 1);
|
|
}
|
|
this->weapons[data1_1][data1_2] = Weapon::from_json(*item_json);
|
|
if (this->weapon_kinds.size() <= data1_1) {
|
|
this->weapon_kinds.resize(data1_1 + 1, 0);
|
|
}
|
|
this->weapon_kinds[data1_1] = item_json->get_int("WeaponKind");
|
|
if (this->weapon_sale_divisors.size() <= data1_1) {
|
|
this->weapon_sale_divisors.resize(data1_1 + 1, 0);
|
|
}
|
|
this->weapon_sale_divisors[data1_1] = item_json->get_int("WeaponKind");
|
|
break;
|
|
case 1:
|
|
switch (item_code[1]) {
|
|
case 1:
|
|
if (this->armors.size() <= data1_2) {
|
|
this->armors.resize(data1_2 + 1);
|
|
}
|
|
this->armors[data1_2] = ArmorOrShield::from_json(*item_json);
|
|
break;
|
|
case 2:
|
|
if (this->shields.size() <= data1_2) {
|
|
this->shields.resize(data1_2 + 1);
|
|
}
|
|
this->shields[data1_2] = ArmorOrShield::from_json(*item_json);
|
|
break;
|
|
case 3:
|
|
if (this->units.size() <= data1_2) {
|
|
this->units.resize(data1_2 + 1);
|
|
}
|
|
this->units[data1_2] = Unit::from_json(*item_json);
|
|
break;
|
|
default:
|
|
throw std::runtime_error("invalid defensive item code in Items dict");
|
|
}
|
|
break;
|
|
case 2:
|
|
if (this->mags.size() <= data1_1) {
|
|
this->mags.resize(data1_1 + 1);
|
|
}
|
|
this->mags[data1_1] = Mag::from_json(*item_json);
|
|
break;
|
|
case 3:
|
|
if (this->tools.size() <= data1_1) {
|
|
this->tools.resize(data1_1 + 1);
|
|
}
|
|
if (this->tools[data1_1].size() <= data1_2) {
|
|
this->tools[data1_1].resize(data1_2 + 1);
|
|
}
|
|
this->tools[data1_1][data1_2] = Tool::from_json(*item_json);
|
|
this->tools_by_id.emplace(this->tools[data1_1][data1_2].id, std::make_pair(data1_1, data1_2));
|
|
break;
|
|
default:
|
|
throw std::runtime_error("invalid base item code in Items dict");
|
|
}
|
|
}
|
|
|
|
for (const auto& photon_color_json : json.get_list("PhotonColors")) {
|
|
this->photon_colors.emplace_back(PhotonColorEntry::from_json(*photon_color_json));
|
|
}
|
|
|
|
for (const auto& weapon_range_json : json.get_list("WeaponRanges")) {
|
|
this->weapon_ranges.emplace_back(WeaponRange::from_json(*weapon_range_json));
|
|
}
|
|
|
|
this->armor_sale_divisor = json.get_int("ArmorSaleDivisor");
|
|
this->shield_sale_divisor = json.get_int("ShieldSaleDivisor");
|
|
this->unit_sale_divisor = json.get_int("UnitSaleDivisor");
|
|
this->mag_sale_divisor = json.get_int("MagSaleDivisor");
|
|
|
|
const auto& mag_feed_results_json = json.get_list("MagFeedResults");
|
|
for (size_t table_index = 0; table_index < 8; table_index++) {
|
|
const auto& this_mag_feed_result_json = mag_feed_results_json.at(table_index);
|
|
for (size_t item_index = 0; item_index < 11; item_index++) {
|
|
this->mag_feed_results[table_index][item_index] = MagFeedResult::from_json(
|
|
this_mag_feed_result_json->at(item_index));
|
|
}
|
|
}
|
|
|
|
this->star_value_start_index = json.get_int("StarValueBaseIndex");
|
|
this->special_stars_base_index = json.get_int("SpecialStarsBaseIndex");
|
|
for (const auto& it : json.get_list("StarValues")) {
|
|
this->star_value_table.emplace_back(it->as_int());
|
|
}
|
|
|
|
this->unknown_a1 = json.get_string("UnknownA1");
|
|
|
|
for (const auto& it : json.get_list("Specials")) {
|
|
this->specials.emplace_back(Special::from_json(*it));
|
|
}
|
|
|
|
for (const auto& it : json.get_list("WeaponEffects")) {
|
|
this->weapon_effects.emplace_back(WeaponEffect::from_json(*it));
|
|
}
|
|
|
|
for (const auto& it : json.get_list("WeaponStatBoostIndexes")) {
|
|
this->weapon_stat_boost_indexes.emplace_back(it->as_int());
|
|
}
|
|
for (const auto& it : json.get_list("ArmorStatBoostIndexes")) {
|
|
this->armor_stat_boost_indexes.emplace_back(it->as_int());
|
|
}
|
|
for (const auto& it : json.get_list("ShieldStatBoostIndexes")) {
|
|
this->shield_stat_boost_indexes.emplace_back(it->as_int());
|
|
}
|
|
|
|
for (const auto& it : json.get_list("StatBoosts")) {
|
|
this->stat_boosts.emplace_back(StatBoost::from_json(*it));
|
|
}
|
|
|
|
for (const auto& it : json.get_list("ShieldEffects")) {
|
|
this->shield_effects.emplace_back(ShieldEffect::from_json(*it));
|
|
}
|
|
|
|
const auto& max_tech_levels_json = json.get_dict("MaxTechLevels");
|
|
for (size_t tech_num = 0; tech_num < 0x13; tech_num++) {
|
|
const auto& this_tech_json = max_tech_levels_json.at(name_for_technique(tech_num))->as_dict();
|
|
auto& this_tech_ret = this->max_tech_levels[tech_num];
|
|
for (size_t char_class = 0; char_class < 12; char_class++) {
|
|
this_tech_ret[char_class] = this_tech_json.at(name_for_char_class(char_class))->as_int();
|
|
}
|
|
}
|
|
|
|
for (const auto& combo_json : json.get_list("ItemCombinations")) {
|
|
auto combo = ItemCombination::from_json(*combo_json);
|
|
this->item_combinations[item_code_to_u32(combo.used_item)].emplace_back(std::move(combo));
|
|
}
|
|
|
|
for (const auto& remaps_json : json.get_list("SoundRemaps")) {
|
|
auto remaps = SoundRemaps::from_json(*remaps_json);
|
|
this->sound_remaps.emplace(remaps.sound_id, std::move(remaps));
|
|
}
|
|
|
|
for (const auto& it : json.get_list("TechBoosts")) {
|
|
this->tech_boosts.emplace_back(TechBoost::from_json(*it));
|
|
}
|
|
|
|
for (const auto& table_it : json.get_list("UnwrapTables")) {
|
|
auto& this_table = this->unwrap_table.emplace_back();
|
|
for (const auto& item_it : table_it->as_list()) {
|
|
this_table.emplace_back(EventItem::from_json(*item_it));
|
|
}
|
|
}
|
|
|
|
for (const auto& it : json.get_list("UnsealableItems")) {
|
|
this->unsealable_items.emplace(it->as_int());
|
|
}
|
|
|
|
for (const auto& it : json.get_list("RangedSpecials")) {
|
|
this->ranged_specials.emplace_back(RangedSpecial::from_json(*it));
|
|
}
|
|
}
|
|
|
|
virtual ~JSONItemParameterTable() = default;
|
|
|
|
virtual size_t num_weapon_classes() const {
|
|
return this->weapons.size();
|
|
}
|
|
virtual size_t num_weapons_in_class(uint8_t data1_1) const {
|
|
return this->weapons.at(data1_1).size();
|
|
}
|
|
virtual const Weapon& get_weapon(uint8_t data1_1, uint8_t data1_2) const {
|
|
return this->weapons.at(data1_1).at(data1_2);
|
|
}
|
|
|
|
virtual size_t num_armors_or_shields_in_class(uint8_t data1_1) const {
|
|
if (data1_1 < 1 || data1_1 > 2) {
|
|
throw std::logic_error("invalid armor/shield class");
|
|
}
|
|
return (data1_1 > 1) ? this->armors.size() : this->shields.size();
|
|
}
|
|
virtual const ArmorOrShield& get_armor_or_shield(uint8_t data1_1, uint8_t data1_2) const {
|
|
if (data1_1 < 1 || data1_1 > 2) {
|
|
throw std::logic_error("invalid armor/shield class");
|
|
}
|
|
return (data1_1 > 1) ? this->armors.at(data1_2) : this->shields.at(data1_2);
|
|
}
|
|
|
|
virtual size_t num_units() const {
|
|
return this->units.size();
|
|
}
|
|
virtual const Unit& get_unit(uint8_t data1_2) const {
|
|
return this->units.at(data1_2);
|
|
}
|
|
|
|
virtual size_t num_tool_classes() const {
|
|
return this->tools.size();
|
|
}
|
|
virtual size_t num_tools_in_class(uint8_t data1_1) const {
|
|
return this->tools.at(data1_1).size();
|
|
}
|
|
virtual const Tool& get_tool(uint8_t data1_1, uint8_t data1_2) const {
|
|
return this->tools.at(data1_1).at(data1_2);
|
|
}
|
|
virtual std::pair<uint8_t, uint8_t> find_tool_by_id(uint32_t id) const {
|
|
return this->tools_by_id.at(id);
|
|
}
|
|
|
|
virtual size_t num_mags() const {
|
|
return this->mags.size();
|
|
}
|
|
virtual const Mag& get_mag(uint8_t data1_1) const {
|
|
return this->mags.at(data1_1);
|
|
}
|
|
|
|
virtual uint8_t get_weapon_kind(uint8_t data1_1) const {
|
|
return this->weapon_kinds.at(data1_1);
|
|
}
|
|
|
|
virtual size_t num_photon_colors() const {
|
|
return this->photon_colors.size();
|
|
}
|
|
virtual const PhotonColorEntry& get_photon_color(size_t index) const {
|
|
return this->photon_colors.at(index);
|
|
}
|
|
|
|
virtual size_t num_weapon_ranges() const {
|
|
return this->weapon_ranges.size();
|
|
}
|
|
virtual const WeaponRange& get_weapon_range(size_t index) const {
|
|
return this->weapon_ranges.at(index);
|
|
}
|
|
|
|
virtual float get_sale_divisor(uint8_t data1_0, uint8_t data1_1) const {
|
|
switch (data1_0) {
|
|
case 0:
|
|
return this->weapon_sale_divisors.at(data1_1);
|
|
case 1:
|
|
switch (data1_1) {
|
|
case 1:
|
|
return this->armor_sale_divisor;
|
|
case 2:
|
|
return this->shield_sale_divisor;
|
|
case 3:
|
|
return this->unit_sale_divisor;
|
|
}
|
|
case 2:
|
|
return this->mag_sale_divisor;
|
|
default:
|
|
throw logic_error("item type does not have a sale divisor");
|
|
}
|
|
}
|
|
|
|
virtual const MagFeedResult& get_mag_feed_result(uint8_t table_index, uint8_t item_index) const {
|
|
return this->mag_feed_results.at(table_index).at(item_index);
|
|
}
|
|
|
|
virtual std::pair<uint32_t, uint32_t> get_star_value_index_range() const {
|
|
return std::make_pair(this->star_value_start_index, this->star_value_start_index + this->star_value_table.size());
|
|
}
|
|
virtual uint32_t get_special_stars_base_index() const {
|
|
return this->special_stars_base_index;
|
|
}
|
|
virtual uint8_t get_item_stars(uint32_t id) const {
|
|
return this->star_value_table.at(id - this->star_value_start_index);
|
|
}
|
|
virtual uint8_t get_special_stars(uint8_t special) const {
|
|
return ((special & 0x3F) && !(special & 0x80)) ? this->get_item_stars(special + this->special_stars_base_index) : 0;
|
|
}
|
|
|
|
virtual std::string get_unknown_a1() const {
|
|
return this->unknown_a1;
|
|
}
|
|
|
|
virtual size_t num_specials() const {
|
|
return this->specials.size();
|
|
}
|
|
virtual const Special& get_special(uint8_t special) const {
|
|
return this->specials.at(special);
|
|
}
|
|
|
|
virtual size_t num_weapon_effects() const {
|
|
return this->weapon_effects.size();
|
|
}
|
|
virtual const WeaponEffect& get_weapon_effect(size_t index) const {
|
|
return this->weapon_effects.at(index);
|
|
}
|
|
|
|
virtual size_t num_weapon_stat_boost_indexes() const {
|
|
return this->weapon_stat_boost_indexes.size();
|
|
}
|
|
virtual uint8_t get_weapon_stat_boost_index(size_t index) const {
|
|
return this->weapon_stat_boost_indexes.at(index);
|
|
}
|
|
virtual size_t num_armor_stat_boost_indexes() const {
|
|
return this->armor_stat_boost_indexes.size();
|
|
}
|
|
virtual uint8_t get_armor_stat_boost_index(size_t index) const {
|
|
return this->armor_stat_boost_indexes.at(index);
|
|
}
|
|
virtual size_t num_shield_stat_boost_indexes() const {
|
|
return this->shield_stat_boost_indexes.size();
|
|
}
|
|
virtual uint8_t get_shield_stat_boost_index(size_t index) const {
|
|
return this->shield_stat_boost_indexes.at(index);
|
|
}
|
|
|
|
virtual size_t num_stat_boosts() const {
|
|
return this->stat_boosts.size();
|
|
}
|
|
virtual const StatBoost& get_stat_boost(size_t index) const {
|
|
return this->stat_boosts.at(index);
|
|
}
|
|
|
|
virtual size_t num_shield_effects() const {
|
|
return this->shield_effects.size();
|
|
}
|
|
virtual const ShieldEffect& get_shield_effect(size_t index) const {
|
|
return this->shield_effects.at(index);
|
|
}
|
|
|
|
virtual uint8_t get_max_tech_level(uint8_t char_class, uint8_t tech_num) const {
|
|
return this->max_tech_levels.at(tech_num).at(char_class);
|
|
}
|
|
|
|
virtual const std::map<uint32_t, std::vector<ItemCombination>>& all_item_combinations() const {
|
|
return this->item_combinations;
|
|
}
|
|
|
|
virtual const std::unordered_map<uint32_t, SoundRemaps>& get_all_sound_remaps() const {
|
|
return this->sound_remaps;
|
|
}
|
|
|
|
virtual size_t num_tech_boosts() const {
|
|
return this->tech_boosts.size();
|
|
}
|
|
virtual const TechBoost& get_tech_boost(size_t index) const {
|
|
return this->tech_boosts.at(index);
|
|
}
|
|
|
|
virtual size_t num_events() const {
|
|
return this->unwrap_table.size();
|
|
}
|
|
virtual std::pair<const EventItem*, size_t> get_event_items(uint8_t event_number) const {
|
|
const auto& event_table = this->unwrap_table.at(event_number);
|
|
return std::make_pair(event_table.data(), event_table.size());
|
|
}
|
|
|
|
virtual const std::unordered_set<uint32_t>& all_unsealable_items() const {
|
|
return this->unsealable_items;
|
|
}
|
|
|
|
virtual size_t num_ranged_specials() const {
|
|
return this->ranged_specials.size();
|
|
}
|
|
virtual const RangedSpecial& get_ranged_special(size_t index) const {
|
|
return this->ranged_specials.at(index);
|
|
}
|
|
|
|
protected:
|
|
std::vector<std::vector<Weapon>> weapons;
|
|
std::vector<ArmorOrShield> armors;
|
|
std::vector<ArmorOrShield> shields;
|
|
std::vector<Unit> units;
|
|
std::vector<std::vector<Tool>> tools;
|
|
std::unordered_map<uint32_t, std::pair<uint8_t, uint8_t>> tools_by_id;
|
|
std::vector<Mag> mags;
|
|
std::vector<uint8_t> weapon_kinds;
|
|
std::vector<PhotonColorEntry> photon_colors;
|
|
std::vector<WeaponRange> weapon_ranges;
|
|
std::vector<float> weapon_sale_divisors;
|
|
float armor_sale_divisor;
|
|
float shield_sale_divisor;
|
|
float unit_sale_divisor;
|
|
float mag_sale_divisor;
|
|
std::array<std::array<MagFeedResult, 11>, 8> mag_feed_results;
|
|
std::vector<uint8_t> star_value_table;
|
|
size_t star_value_start_index;
|
|
size_t special_stars_base_index;
|
|
std::string unknown_a1;
|
|
std::vector<Special> specials;
|
|
std::vector<WeaponEffect> weapon_effects;
|
|
std::vector<uint8_t> weapon_stat_boost_indexes;
|
|
std::vector<uint8_t> armor_stat_boost_indexes;
|
|
std::vector<uint8_t> shield_stat_boost_indexes;
|
|
std::vector<StatBoost> stat_boosts;
|
|
std::vector<ShieldEffect> shield_effects;
|
|
MaxTechniqueLevels max_tech_levels;
|
|
std::map<uint32_t, std::vector<ItemCombination>> item_combinations;
|
|
std::unordered_map<uint32_t, SoundRemaps> sound_remaps;
|
|
std::vector<TechBoost> tech_boosts;
|
|
std::vector<std::vector<EventItem>> unwrap_table;
|
|
std::unordered_set<uint32_t> unsealable_items;
|
|
std::vector<RangedSpecial> ranged_specials;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Serialized structures
|
|
|
|
template <bool BE>
|
|
struct ItemBaseV2T {
|
|
/* 00 */ U32T<BE> id = 0xFFFFFFFF;
|
|
/* 04 */
|
|
void parse_into(ItemParameterTable::ItemBase& ret) const {
|
|
ret.id = this->id;
|
|
}
|
|
} __packed_ws_be__(ItemBaseV2T, 4);
|
|
|
|
template <bool BE>
|
|
struct ItemBaseV3T : ItemBaseV2T<BE> {
|
|
/* 04 */ U16T<BE> type = 0;
|
|
/* 06 */ U16T<BE> skin = 0;
|
|
/* 08 */
|
|
void parse_into(ItemParameterTable::ItemBase& ret) const {
|
|
this->ItemBaseV2T<BE>::parse_into(ret);
|
|
ret.type = this->type;
|
|
ret.skin = this->skin;
|
|
}
|
|
} __packed_ws_be__(ItemBaseV3T, 8);
|
|
|
|
struct ItemBaseV4 : ItemBaseV3T<false> {
|
|
/* 08 */ le_uint32_t team_points = 0;
|
|
/* 0C */
|
|
void parse_into(ItemParameterTable::ItemBase& ret) const {
|
|
this->ItemBaseV3T<false>::parse_into(ret);
|
|
ret.team_points = this->team_points;
|
|
}
|
|
} __packed_ws__(ItemBaseV4, 0x0C);
|
|
|
|
struct WeaponDCProtos {
|
|
/* 00 */ ItemBaseV2T<false> base;
|
|
/* 04 */ le_uint16_t class_flags = 0;
|
|
/* 06 */ le_uint16_t atp_min = 0;
|
|
/* 08 */ le_uint16_t atp_max = 0;
|
|
/* 0A */ le_uint16_t atp_required = 0;
|
|
/* 0C */ le_uint16_t mst_required = 0;
|
|
/* 0E */ le_uint16_t ata_required = 0;
|
|
/* 10 */ uint8_t max_grind = 0;
|
|
/* 11 */ uint8_t photon = 0;
|
|
/* 12 */ uint8_t special = 0;
|
|
/* 13 */ uint8_t ata = 0;
|
|
/* 14 */
|
|
operator ItemParameterTable::Weapon() const {
|
|
ItemParameterTable::Weapon ret;
|
|
this->base.parse_into(ret);
|
|
ret.class_flags = this->class_flags;
|
|
ret.atp_min = this->atp_min;
|
|
ret.atp_max = this->atp_max;
|
|
ret.atp_required = this->atp_required;
|
|
ret.mst_required = this->mst_required;
|
|
ret.ata_required = this->ata_required;
|
|
ret.max_grind = this->max_grind;
|
|
ret.photon = this->photon;
|
|
ret.special = this->special;
|
|
ret.ata = this->ata;
|
|
return ret;
|
|
}
|
|
} __packed_ws__(WeaponDCProtos, 0x14);
|
|
|
|
struct WeaponV1V2 : WeaponDCProtos {
|
|
/* 14 */ uint8_t stat_boost_entry_index = 0; // TODO: This could be larger (16 or 32 bits)
|
|
/* 15 */ parray<uint8_t, 3> unknown_a9;
|
|
/* 18 */
|
|
operator ItemParameterTable::Weapon() const {
|
|
ItemParameterTable::Weapon ret = this->WeaponDCProtos::operator ItemParameterTable::Weapon();
|
|
ret.stat_boost_entry_index = this->stat_boost_entry_index;
|
|
return ret;
|
|
}
|
|
} __packed_ws__(WeaponV1V2, 0x18);
|
|
|
|
template <bool BE>
|
|
struct WeaponGCNTET {
|
|
/* 00 */ ItemBaseV3T<BE> base;
|
|
/* 08 */ U16T<BE> class_flags = 0;
|
|
/* 0A */ U16T<BE> atp_min = 0;
|
|
/* 0C */ U16T<BE> atp_max = 0;
|
|
/* 0E */ U16T<BE> atp_required = 0;
|
|
/* 10 */ U16T<BE> mst_required = 0;
|
|
/* 12 */ U16T<BE> ata_required = 0;
|
|
/* 14 */ U16T<BE> mst = 0;
|
|
/* 16 */ uint8_t max_grind = 0;
|
|
/* 17 */ uint8_t photon = 0;
|
|
/* 18 */ uint8_t special = 0;
|
|
/* 19 */ uint8_t ata = 0;
|
|
/* 1A */ uint8_t stat_boost_entry_index = 0;
|
|
/* 1B */ uint8_t projectile = 0;
|
|
/* 1C */ int8_t trail1_x = 0;
|
|
/* 1D */ int8_t trail1_y = 0;
|
|
/* 1E */ int8_t trail2_x = 0;
|
|
/* 1F */ int8_t trail2_y = 0;
|
|
/* 20 */ int8_t color = 0;
|
|
/* 21 */ parray<uint8_t, 3> unknown_a1 = 0;
|
|
/* 24 */
|
|
operator ItemParameterTable::Weapon() const {
|
|
ItemParameterTable::Weapon ret;
|
|
this->base.parse_into(ret);
|
|
ret.class_flags = this->class_flags;
|
|
ret.atp_min = this->atp_min;
|
|
ret.atp_max = this->atp_max;
|
|
ret.atp_required = this->atp_required;
|
|
ret.mst_required = this->mst_required;
|
|
ret.ata_required = this->ata_required;
|
|
ret.mst = this->mst;
|
|
ret.max_grind = this->max_grind;
|
|
ret.photon = this->photon;
|
|
ret.special = this->special;
|
|
ret.ata = this->ata;
|
|
ret.stat_boost_entry_index = this->stat_boost_entry_index;
|
|
ret.projectile = this->projectile;
|
|
ret.trail1_x = this->trail1_x;
|
|
ret.trail1_y = this->trail1_y;
|
|
ret.trail2_x = this->trail2_x;
|
|
ret.trail2_y = this->trail2_y;
|
|
ret.color = this->color;
|
|
ret.unknown_a1 = this->unknown_a1;
|
|
return ret;
|
|
}
|
|
} __packed_ws_be__(WeaponGCNTET, 0x24);
|
|
using WeaponGCNTE = WeaponGCNTET<true>;
|
|
|
|
template <bool BE>
|
|
struct WeaponV3T : WeaponGCNTET<BE> {
|
|
/* 24 */ uint8_t unknown_a4 = 0;
|
|
/* 25 */ uint8_t unknown_a5 = 0;
|
|
/* 26 */ uint8_t tech_boost_entry_index = 0;
|
|
/* 27 */ uint8_t behavior_flags = 0;
|
|
/* 28 */
|
|
operator ItemParameterTable::Weapon() const {
|
|
ItemParameterTable::Weapon ret = this->WeaponGCNTET<BE>::operator ItemParameterTable::Weapon();
|
|
ret.unknown_a4 = this->unknown_a4;
|
|
ret.unknown_a5 = this->unknown_a5;
|
|
ret.tech_boost_entry_index = this->tech_boost_entry_index;
|
|
ret.behavior_flags = this->behavior_flags;
|
|
return ret;
|
|
}
|
|
} __packed_ws_be__(WeaponV3T, 0x28);
|
|
using WeaponGC = WeaponV3T<true>;
|
|
using WeaponXB = WeaponV3T<false>;
|
|
|
|
struct WeaponV4 {
|
|
/* 00 */ ItemBaseV4 base;
|
|
/* 0C */ le_uint16_t class_flags = 0x00FF;
|
|
/* 0E */ le_uint16_t atp_min = 0;
|
|
/* 10 */ le_uint16_t atp_max = 0;
|
|
/* 12 */ le_uint16_t atp_required = 0;
|
|
/* 14 */ le_uint16_t mst_required = 0;
|
|
/* 16 */ le_uint16_t ata_required = 0;
|
|
/* 18 */ le_uint16_t mst = 0;
|
|
/* 1A */ uint8_t max_grind = 0;
|
|
/* 1B */ uint8_t photon = 0;
|
|
/* 1C */ uint8_t special = 0;
|
|
/* 1D */ uint8_t ata = 0;
|
|
/* 1E */ uint8_t stat_boost_entry_index = 0;
|
|
/* 1F */ uint8_t projectile = 0;
|
|
/* 20 */ int8_t trail1_x = 0;
|
|
/* 21 */ int8_t trail1_y = 0;
|
|
/* 22 */ int8_t trail2_x = 0;
|
|
/* 23 */ int8_t trail2_y = 0;
|
|
/* 24 */ int8_t color = 0;
|
|
/* 25 */ parray<uint8_t, 3> unknown_a1 = 0;
|
|
/* 28 */ uint8_t unknown_a4 = 0;
|
|
/* 29 */ uint8_t unknown_a5 = 0;
|
|
/* 2A */ uint8_t tech_boost_entry_index = 0;
|
|
/* 2B */ uint8_t behavior_flags = 0;
|
|
/* 2C */
|
|
operator ItemParameterTable::Weapon() const {
|
|
ItemParameterTable::Weapon ret;
|
|
this->base.parse_into(ret);
|
|
ret.class_flags = this->class_flags;
|
|
ret.atp_min = this->atp_min;
|
|
ret.atp_max = this->atp_max;
|
|
ret.atp_required = this->atp_required;
|
|
ret.mst_required = this->mst_required;
|
|
ret.ata_required = this->ata_required;
|
|
ret.mst = this->mst;
|
|
ret.max_grind = this->max_grind;
|
|
ret.photon = this->photon;
|
|
ret.special = this->special;
|
|
ret.ata = this->ata;
|
|
ret.stat_boost_entry_index = this->stat_boost_entry_index;
|
|
ret.projectile = this->projectile;
|
|
ret.trail1_x = this->trail1_x;
|
|
ret.trail1_y = this->trail1_y;
|
|
ret.trail2_x = this->trail2_x;
|
|
ret.trail2_y = this->trail2_y;
|
|
ret.color = this->color;
|
|
ret.unknown_a1 = this->unknown_a1;
|
|
ret.unknown_a4 = this->unknown_a4;
|
|
ret.unknown_a5 = this->unknown_a5;
|
|
ret.tech_boost_entry_index = this->tech_boost_entry_index;
|
|
ret.behavior_flags = this->behavior_flags;
|
|
return ret;
|
|
}
|
|
} __packed_ws__(WeaponV4, 0x2C);
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct ArmorOrShieldT {
|
|
/* V1/V2 offsets */
|
|
/* 00 */ BaseT base;
|
|
/* 04 */ U16T<BE> dfp = 0;
|
|
/* 06 */ U16T<BE> evp = 0;
|
|
/* 08 */ uint8_t block_particle = 0;
|
|
/* 09 */ uint8_t block_effect = 0;
|
|
/* 0A */ U16T<BE> class_flags = 0x00FF;
|
|
/* 0C */ uint8_t required_level = 0;
|
|
/* 0D */ uint8_t efr = 0;
|
|
/* 0E */ uint8_t eth = 0;
|
|
/* 0F */ uint8_t eic = 0;
|
|
/* 10 */ uint8_t edk = 0;
|
|
/* 11 */ uint8_t elt = 0;
|
|
/* 12 */ uint8_t dfp_range = 0;
|
|
/* 13 */ uint8_t evp_range = 0;
|
|
/* 14 */
|
|
operator ItemParameterTable::ArmorOrShield() const {
|
|
ItemParameterTable::ArmorOrShield ret;
|
|
this->base.parse_into(ret);
|
|
ret.dfp = this->dfp;
|
|
ret.evp = this->evp;
|
|
ret.block_particle = this->block_particle;
|
|
ret.block_effect = this->block_effect;
|
|
ret.class_flags = this->class_flags;
|
|
ret.required_level = this->required_level;
|
|
ret.efr = this->efr;
|
|
ret.eth = this->eth;
|
|
ret.eic = this->eic;
|
|
ret.edk = this->edk;
|
|
ret.elt = this->elt;
|
|
ret.dfp_range = this->dfp_range;
|
|
ret.evp_range = this->evp_range;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(ArmorOrShieldT<ItemBaseV2T<false>, false>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldT<ItemBaseV2T<true>, true>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldT<ItemBaseV3T<false>, false>) == 0x18, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldT<ItemBaseV3T<true>, true>) == 0x18, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldT<ItemBaseV4, false>) == 0x1C, "Structure size is incorrect");
|
|
using ArmorOrShieldDCProtos = ArmorOrShieldT<ItemBaseV2T<false>, false>;
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct ArmorOrShieldFinalT : ArmorOrShieldT<BaseT, BE> {
|
|
/* 14 */ uint8_t stat_boost_entry_index = 0;
|
|
/* 15 */ uint8_t tech_boost_entry_index = 0;
|
|
/* 16 */ uint8_t flags_type = 0;
|
|
/* 17 */ uint8_t unknown_a4 = 0;
|
|
/* 18 */
|
|
operator ItemParameterTable::ArmorOrShield() const {
|
|
ItemParameterTable::ArmorOrShield ret = this->ArmorOrShieldT<BaseT, BE>::operator ItemParameterTable::ArmorOrShield();
|
|
ret.stat_boost_entry_index = this->stat_boost_entry_index;
|
|
ret.tech_boost_entry_index = this->tech_boost_entry_index;
|
|
ret.flags_type = this->flags_type;
|
|
ret.unknown_a4 = this->unknown_a4;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(ArmorOrShieldFinalT<ItemBaseV2T<false>, false>) == 0x18, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldFinalT<ItemBaseV2T<true>, true>) == 0x18, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldFinalT<ItemBaseV3T<false>, false>) == 0x1C, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldFinalT<ItemBaseV3T<true>, true>) == 0x1C, "Structure size is incorrect");
|
|
static_assert(sizeof(ArmorOrShieldFinalT<ItemBaseV4, false>) == 0x20, "Structure size is incorrect");
|
|
using ArmorOrShieldV1V2 = ArmorOrShieldFinalT<ItemBaseV2T<false>, false>;
|
|
using ArmorOrShieldGC = ArmorOrShieldFinalT<ItemBaseV3T<true>, true>;
|
|
using ArmorOrShieldXB = ArmorOrShieldFinalT<ItemBaseV3T<false>, false>;
|
|
using ArmorOrShieldV4 = ArmorOrShieldFinalT<ItemBaseV4, false>;
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct UnitT {
|
|
/* V1/V2 offsets */
|
|
/* 00 */ BaseT base;
|
|
/* 04 */ U16T<BE> stat = 0;
|
|
/* 06 */ U16T<BE> stat_amount = 0;
|
|
/* 08 */
|
|
operator ItemParameterTable::Unit() const {
|
|
ItemParameterTable::Unit ret;
|
|
this->base.parse_into(ret);
|
|
ret.stat = this->stat;
|
|
ret.stat_amount = this->stat_amount;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(UnitT<ItemBaseV2T<false>, false>) == 8, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitT<ItemBaseV2T<true>, true>) == 8, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitT<ItemBaseV3T<false>, false>) == 0x0C, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitT<ItemBaseV3T<true>, true>) == 0x0C, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitT<ItemBaseV4, false>) == 0x10, "Structure size is incorrect");
|
|
using UnitDCProtos = UnitT<ItemBaseV2T<false>, false>;
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct UnitFinalT : UnitT<BaseT, BE> {
|
|
/* 08 */ S16T<BE> modifier_amount = 0;
|
|
/* 0A */ parray<uint8_t, 2> unused;
|
|
/* 0C */
|
|
operator ItemParameterTable::Unit() const {
|
|
ItemParameterTable::Unit ret = this->UnitT<BaseT, BE>::operator ItemParameterTable::Unit();
|
|
ret.modifier_amount = this->modifier_amount;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(UnitFinalT<ItemBaseV2T<false>, false>) == 0x0C, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitFinalT<ItemBaseV2T<true>, true>) == 0x0C, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitFinalT<ItemBaseV3T<false>, false>) == 0x10, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitFinalT<ItemBaseV3T<true>, true>) == 0x10, "Structure size is incorrect");
|
|
static_assert(sizeof(UnitFinalT<ItemBaseV4, false>) == 0x14, "Structure size is incorrect");
|
|
using UnitV1V2 = UnitFinalT<ItemBaseV2T<false>, false>;
|
|
using UnitGC = UnitFinalT<ItemBaseV3T<true>, true>;
|
|
using UnitXB = UnitFinalT<ItemBaseV3T<false>, false>;
|
|
using UnitV4 = UnitFinalT<ItemBaseV4, false>;
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct MagT {
|
|
/* V1/V2 offsets */
|
|
/* 00 */ BaseT base;
|
|
/* 04 */ U16T<BE> feed_table = 0;
|
|
/* 06 */ uint8_t photon_blast = 0;
|
|
/* 07 */ uint8_t activation = 0;
|
|
/* 08 */ uint8_t on_pb_full = 0;
|
|
/* 09 */ uint8_t on_low_hp = 0;
|
|
/* 0A */ uint8_t on_death = 0;
|
|
/* 0B */ uint8_t on_boss = 0;
|
|
/* 0C */ uint8_t on_pb_full_flag = 0;
|
|
/* 0D */ uint8_t on_low_hp_flag = 0;
|
|
/* 0E */ uint8_t on_death_flag = 0;
|
|
/* 0F */ uint8_t on_boss_flag = 0;
|
|
/* 10 */
|
|
operator ItemParameterTable::Mag() const {
|
|
ItemParameterTable::Mag ret;
|
|
this->base.parse_into(ret);
|
|
ret.feed_table = this->feed_table;
|
|
ret.photon_blast = this->photon_blast;
|
|
ret.activation = this->activation;
|
|
ret.on_pb_full = this->on_pb_full;
|
|
ret.on_low_hp = this->on_low_hp;
|
|
ret.on_death = this->on_death;
|
|
ret.on_boss = this->on_boss;
|
|
ret.on_pb_full_flag = this->on_pb_full_flag;
|
|
ret.on_low_hp_flag = this->on_low_hp_flag;
|
|
ret.on_death_flag = this->on_death_flag;
|
|
ret.on_boss_flag = this->on_boss_flag;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(MagT<ItemBaseV2T<false>, false>) == 0x10, "Structure size is incorrect");
|
|
static_assert(sizeof(MagT<ItemBaseV2T<true>, true>) == 0x10, "Structure size is incorrect");
|
|
static_assert(sizeof(MagT<ItemBaseV3T<false>, false>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(MagT<ItemBaseV3T<true>, true>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(MagT<ItemBaseV4, true>) == 0x18, "Structure size is incorrect");
|
|
using MagV1 = MagT<ItemBaseV2T<false>, false>;
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct MagV2V3V4T : MagT<BaseT, BE> {
|
|
U16T<BE> class_flags = 0x00FF;
|
|
parray<uint8_t, 2> unused;
|
|
operator ItemParameterTable::Mag() const {
|
|
ItemParameterTable::Mag ret = this->MagT<BaseT, BE>::operator ItemParameterTable::Mag();
|
|
ret.class_flags = this->class_flags;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(MagV2V3V4T<ItemBaseV2T<false>, false>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(MagV2V3V4T<ItemBaseV2T<true>, true>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(MagV2V3V4T<ItemBaseV3T<false>, false>) == 0x18, "Structure size is incorrect");
|
|
static_assert(sizeof(MagV2V3V4T<ItemBaseV3T<true>, true>) == 0x18, "Structure size is incorrect");
|
|
static_assert(sizeof(MagV2V3V4T<ItemBaseV4, false>) == 0x1C, "Structure size is incorrect");
|
|
using MagV2 = MagV2V3V4T<ItemBaseV2T<false>, false>;
|
|
using MagGC = MagV2V3V4T<ItemBaseV3T<true>, true>;
|
|
using MagXB = MagV2V3V4T<ItemBaseV3T<false>, false>;
|
|
using MagV4 = MagV2V3V4T<ItemBaseV4, false>;
|
|
|
|
template <typename BaseT, bool BE>
|
|
struct ToolT {
|
|
/* V1/V2 offsets */
|
|
/* 00 */ BaseT base;
|
|
/* 04 */ U16T<BE> amount = 0;
|
|
/* 06 */ U16T<BE> tech = 0;
|
|
/* 08 */ S32T<BE> cost = 0;
|
|
/* 0C */ U32T<BE> item_flags = 0;
|
|
/* 10 */
|
|
operator ItemParameterTable::Tool() const {
|
|
ItemParameterTable::Tool ret;
|
|
this->base.parse_into(ret);
|
|
ret.amount = this->amount;
|
|
ret.tech = this->tech;
|
|
ret.cost = this->cost;
|
|
ret.item_flags = this->item_flags;
|
|
return ret;
|
|
}
|
|
} __attribute__((packed));
|
|
static_assert(sizeof(ToolT<ItemBaseV2T<false>, false>) == 0x10, "Structure size is incorrect");
|
|
static_assert(sizeof(ToolT<ItemBaseV2T<true>, true>) == 0x10, "Structure size is incorrect");
|
|
static_assert(sizeof(ToolT<ItemBaseV3T<false>, false>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(ToolT<ItemBaseV3T<true>, true>) == 0x14, "Structure size is incorrect");
|
|
static_assert(sizeof(ToolT<ItemBaseV4, false>) == 0x18, "Structure size is incorrect");
|
|
using ToolV1V2 = ToolT<ItemBaseV2T<false>, false>;
|
|
using ToolGC = ToolT<ItemBaseV3T<true>, true>;
|
|
using ToolXB = ToolT<ItemBaseV3T<false>, false>;
|
|
using ToolV4 = ToolT<ItemBaseV4, false>;
|
|
|
|
using MagFeedResultsList = parray<ItemParameterTable::MagFeedResult, 11>;
|
|
|
|
template <bool BE>
|
|
using MagFeedResultsListOffsetsT = parray<U32T<BE>, 8>;
|
|
|
|
template <bool BE>
|
|
struct SpecialT {
|
|
U16T<BE> type = 0xFFFF;
|
|
U16T<BE> amount = 0;
|
|
operator ItemParameterTable::Special() const {
|
|
return {this->type, this->amount};
|
|
}
|
|
} __packed_ws_be__(SpecialT, 4);
|
|
|
|
template <bool BE>
|
|
struct StatBoostT {
|
|
parray<uint8_t, 2> stats = 0;
|
|
parray<U16T<BE>, 2> amounts = 0;
|
|
operator ItemParameterTable::StatBoost() const {
|
|
return {this->stats[0], this->amounts[0], this->stats[1], this->amounts[1]};
|
|
}
|
|
} __packed_ws_be__(StatBoostT, 6);
|
|
|
|
template <bool BE>
|
|
struct TechBoostEntryT {
|
|
uint8_t tech_num1 = 0;
|
|
uint8_t flags1 = 0;
|
|
parray<uint8_t, 2> unused1;
|
|
F32T<BE> amount1 = 0.0f;
|
|
uint8_t tech_num2 = 0;
|
|
uint8_t flags2 = 0;
|
|
parray<uint8_t, 2> unused2;
|
|
F32T<BE> amount2 = 0.0f;
|
|
uint8_t tech_num3 = 0;
|
|
uint8_t flags3 = 0;
|
|
parray<uint8_t, 2> unused3;
|
|
F32T<BE> amount3 = 0.0f;
|
|
operator ItemParameterTable::TechBoost() const {
|
|
return {
|
|
this->tech_num1,
|
|
this->flags1,
|
|
this->amount1,
|
|
this->tech_num2,
|
|
this->flags2,
|
|
this->amount2,
|
|
this->tech_num3,
|
|
this->flags3,
|
|
this->amount3,
|
|
};
|
|
}
|
|
} __packed_ws_be__(TechBoostEntryT, 0x18);
|
|
|
|
struct NonWeaponSaleDivisorsDCProtos {
|
|
uint8_t armor_divisor = 0;
|
|
uint8_t shield_divisor = 0;
|
|
uint8_t unit_divisor = 0;
|
|
operator ItemParameterTable::NonWeaponSaleDivisors() const {
|
|
return {
|
|
static_cast<float>(this->armor_divisor),
|
|
static_cast<float>(this->shield_divisor),
|
|
static_cast<float>(this->unit_divisor),
|
|
0.0f};
|
|
}
|
|
} __packed_ws__(NonWeaponSaleDivisorsDCProtos, 3);
|
|
|
|
template <bool BE>
|
|
struct NonWeaponSaleDivisorsT {
|
|
F32T<BE> armor_divisor = 0.0f;
|
|
F32T<BE> shield_divisor = 0.0f;
|
|
F32T<BE> unit_divisor = 0.0f;
|
|
F32T<BE> mag_divisor = 0.0f;
|
|
operator ItemParameterTable::NonWeaponSaleDivisors() const {
|
|
return {this->armor_divisor, this->shield_divisor, this->unit_divisor, this->mag_divisor};
|
|
}
|
|
} __packed_ws_be__(NonWeaponSaleDivisorsT, 0x10);
|
|
|
|
template <bool BE>
|
|
struct ShieldEffectT {
|
|
U32T<BE> sound_id;
|
|
U32T<BE> unknown_a1;
|
|
operator ItemParameterTable::ShieldEffect() const {
|
|
return {this->sound_id, this->unknown_a1};
|
|
}
|
|
} __packed_ws_be__(ShieldEffectT, 8);
|
|
|
|
template <bool BE>
|
|
struct PhotonColorEntryT {
|
|
/* 00 */ U32T<BE> unknown_a1;
|
|
/* 04 */ parray<F32T<BE>, 4> unknown_a2;
|
|
/* 14 */ parray<F32T<BE>, 4> unknown_a3;
|
|
/* 24 */
|
|
operator ItemParameterTable::PhotonColorEntry() const {
|
|
ItemParameterTable::PhotonColorEntry ret;
|
|
ret.unknown_a1 = this->unknown_a1;
|
|
ret.unknown_a2.x = this->unknown_a2[0];
|
|
ret.unknown_a2.y = this->unknown_a2[1];
|
|
ret.unknown_a2.z = this->unknown_a2[2];
|
|
ret.unknown_a2.t = this->unknown_a2[3];
|
|
ret.unknown_a3.x = this->unknown_a3[0];
|
|
ret.unknown_a3.y = this->unknown_a3[1];
|
|
ret.unknown_a3.z = this->unknown_a3[2];
|
|
ret.unknown_a3.t = this->unknown_a3[3];
|
|
return ret;
|
|
}
|
|
} __packed_ws_be__(PhotonColorEntryT, 0x24);
|
|
|
|
template <bool BE>
|
|
struct UnknownA1T {
|
|
U16T<BE> unknown_a1;
|
|
U16T<BE> unknown_a2;
|
|
operator ItemParameterTable::UnknownA1() const {
|
|
return {this->unknown_a1, this->unknown_a2};
|
|
}
|
|
} __packed_ws_be__(UnknownA1T, 4);
|
|
|
|
template <bool BE>
|
|
struct WeaponRangeT {
|
|
F32T<BE> unknown_a1;
|
|
F32T<BE> unknown_a2;
|
|
U32T<BE> unknown_a3;
|
|
U32T<BE> unknown_a4;
|
|
U32T<BE> unknown_a5;
|
|
operator ItemParameterTable::WeaponRange() const {
|
|
return {this->unknown_a1, this->unknown_a2, this->unknown_a3, this->unknown_a4, this->unknown_a5};
|
|
}
|
|
} __packed_ws_be__(WeaponRangeT, 0x14);
|
|
|
|
template <bool BE>
|
|
struct WeaponEffectT {
|
|
U32T<BE> sound_id1;
|
|
U32T<BE> eff_value1;
|
|
U32T<BE> sound_id2;
|
|
U32T<BE> eff_value2;
|
|
parray<uint8_t, 0x10> unknown_a5;
|
|
operator ItemParameterTable::WeaponEffect() const {
|
|
return {this->sound_id1, this->eff_value1, this->sound_id2, this->eff_value2, this->unknown_a5};
|
|
}
|
|
} __packed_ws_be__(WeaponEffectT, 0x20);
|
|
|
|
template <bool BE>
|
|
struct SoundRemapTableOffsetsT {
|
|
U32T<BE> sound_id;
|
|
U32T<BE> remaps_for_rt_index_table;
|
|
U32T<BE> remaps_for_char_class_table;
|
|
} __packed_ws_be__(SoundRemapTableOffsetsT, 0x0C);
|
|
|
|
/* The fields in the root structures are as follows. See the specializations of BinaryItemParameterTableT for the
|
|
* values of the hardcoded constants in each version (NumWeaponClasses, etc.).
|
|
* DCTE / 112K / V1 / V2 / GCTE / GCV3 / XBV3 / V4
|
|
* 0013 / 0013 / 0013 / 0013 / ---- / ---- / ---- / ----- entry_count // Count of pointers in root struct; unused
|
|
* 2E1C / 2EB8 / 32E8 / 5AFC / 6F0C / F078 / F084 / 14884 weapon_table // -> {count, offset -> WeaponV*[count]}[NumWeaponClasses]
|
|
* 2D94 / 2E28 / 3258 / 5A5C / 6E4C / EF90 / EF9C / 1478C armor_table // -> {count, offset -> ArmorOrShieldV*[count]}][2]
|
|
* 2DA4 / 2E38 / 3268 / 5A6C / 6E5C / EFA0 / EFAC / 1479C unit_table // -> {count, offset -> UnitV*[count]} (last if out of range)
|
|
* 2DB4 / 2E48 / 3278 / 5A7C / 6E6C / EFB0 / EFBC / 147AC tool_table // -> {count, offset -> ToolV*[count]}[NumToolClasses] (last if out of range)
|
|
* 2DAC / 2E40 / 3270 / 5A74 / 6E64 / EFA8 / EFB4 / 147A4 mag_table // -> {count, offset -> MagV*[count]}
|
|
* 1F98 / 202C / 23C8 / 3DF8 / 47BC / B88C / B8A0 / 0F4B8 weapon_kind_table // -> uint8_t[NumWeaponClasses]
|
|
* 1994 / 1A28 / 1DB0 / 2E4C / 37A4 / A7FC / A7FC / 0DE7C photon_color_table // -> PhotonColorEntry[NumPhotonColors]
|
|
* 1C64 / 1CF8 / 2080 / 32CC / 3A74 / AACC / AACC / 0E194 weapon_range_table // -> WeaponRange[...] (indexed by data1_1, but also by RangedSpecial::weapon_range_index + a version-dependent constant, and also by the result of a vfunc call on some TItemWeapons)
|
|
* 1FBF / 2053 / 23F0 / 3E84 / 484C / B938 / B94C / 0F5A8 weapon_sale_divisor_table // -> uint8_t[NumWeaponClasses] on DC protos; float[NumWeaponClasses] on all other versions
|
|
* 1FE6 / 207A / 248C / 40A8 / 4A80 / BBCC / BBE0 / 0F83C non_weapon_sale_divisor_table // -> NonWeaponSaleDivisors
|
|
* 2F54 / 2FF0 / 3420 / 5F4C / 7384 / F608 / F614 / 1502C mag_feed_table // -> MagFeedResultsTable
|
|
* 22A9 / 233D / 275C / 4378 / 4D50 / BE9C / BEB0 / 0FB0C star_value_table // -> uint8_t[...] (indexed by .id from weapon, armor, etc.)
|
|
* 23EE / 2484 / 28A2 / ---- / ---- / ---- / ---- / ----- unknown_a1 // TODO
|
|
* 275E / 27F4 / 2C12 / 4540 / 4F72 / C100 / C114 / 0FE3C special_table // -> Special[NumSpecials]
|
|
* 2804 / 2898 / 2CB8 / 45E4 / 5018 / C1A4 / C1B8 / 0FEE0 weapon_effect_table // -> WeaponEffect[...]
|
|
* 1908 / 199C / ---- / ---- / ---- / ---- / ---- / ----- weapon_stat_boost_index_table // -> uint8_t[max(weapon.id : weapon_table) - (ItemStarsFirstID - 1)]
|
|
* 0668 / 0668 / ---- / ---- / ---- / ---- / ---- / ----- armor_stat_boost_index_table // -> uint8_t[armor_table[0].count]
|
|
* 030C / 030C / ---- / ---- / ---- / ---- / ---- / ----- shield_stat_boost_index_table // -> uint8_t[armor_table[1].count]
|
|
* 2CE4 / 2D78 / 3198 / 58DC / 68B8 / DE50 / DE64 / 1275C stat_boost_table // -> StatBoost[...]
|
|
* ---- / ---- / ---- / 5704 / 61B8 / D6E4 / D6F8 / 11C80 shield_effect_table // -> ShieldEffect[...] (indexed by data1[2])
|
|
* ---- / ---- / ---- / ---- / 69D8 / DF88 / DF9C / 12894 max_tech_level_table // -> MaxTechniqueLevels
|
|
* ---- / ---- / ---- / ---- / 737C / F5D0 / F5DC / 14FF4 combination_table // -> {count, offset -> ItemCombination[count]}
|
|
* ---- / ---- / ---- / ---- / 68B0 / DE48 / DE5C / 12754 sound_remap_table // -> {count, offset -> {sound_id, by_rt_index_offset -> uint32_t[SoundRemapRTTableSize], by_char_class_offset -> uint32_t[12]}}
|
|
* ---- / ---- / ---- / ---- / 6B1C / EB8C / EBA0 / 14278 tech_boost_table // -> TechBoostEntry[...][3]
|
|
* ---- / ---- / ---- / ---- / ---- / F5F0 / F5FC / 15014 unwrap_table // -> {count, offset -> {count, offset -> EventItem[count]}[count]
|
|
* ---- / ---- / ---- / ---- / ---- / F5F8 / F604 / 1501C unsealable_table // -> {count, offset -> UnsealableItem[count]}
|
|
* ---- / ---- / ---- / ---- / ---- / F600 / F60C / 15024 ranged_special_table // -> {count, offset -> RangedSpecial[count]}
|
|
*/
|
|
|
|
struct RootDCProtos {
|
|
/* ## / DCTE / 112K */
|
|
/* 00 / 0013 / 0013 */ le_uint32_t entry_count;
|
|
/* 04 / 2E1C / 2EB8 */ le_uint32_t weapon_table;
|
|
/* 08 / 2D94 / 2E28 */ le_uint32_t armor_table;
|
|
/* 0C / 2DA4 / 2E38 */ le_uint32_t unit_table;
|
|
/* 10 / 2DB4 / 2E48 */ le_uint32_t tool_table;
|
|
/* 14 / 2DAC / 2E40 */ le_uint32_t mag_table;
|
|
/* 18 / 1F98 / 202C */ le_uint32_t weapon_kind_table;
|
|
/* 1C / 1994 / 1A28 */ le_uint32_t photon_color_table;
|
|
/* 20 / 1C64 / 1CF8 */ le_uint32_t weapon_range_table;
|
|
/* 24 / 1FBF / 2053 */ le_uint32_t weapon_integral_sale_divisor_table;
|
|
/* 28 / 1FE6 / 207A */ le_uint32_t non_weapon_integral_sale_divisor_table;
|
|
/* 2C / 2F54 / 2FF0 */ le_uint32_t mag_feed_table;
|
|
/* 30 / 22A9 / 233D */ le_uint32_t star_value_table;
|
|
/* 34 / 23EE / 2484 */ le_uint32_t unknown_a1;
|
|
/* 38 / 275E / 27F4 */ le_uint32_t special_table;
|
|
/* 3C / 2804 / 2898 */ le_uint32_t weapon_effect_table;
|
|
/* 40 / 1908 / 199C */ le_uint32_t weapon_stat_boost_index_table;
|
|
/* 44 / 0668 / 0668 */ le_uint32_t armor_stat_boost_index_table;
|
|
/* 48 / 030C / 030C */ le_uint32_t shield_stat_boost_index_table;
|
|
/* 4C / 2CE4 / 2D78 */ le_uint32_t stat_boost_table;
|
|
} __packed_ws__(RootDCProtos, 0x50);
|
|
|
|
struct RootV1 {
|
|
/* ## / DCV1 */
|
|
/* 00 / 0013 */ le_uint32_t entry_count;
|
|
/* 04 / 32E8 */ le_uint32_t weapon_table;
|
|
/* 08 / 3258 */ le_uint32_t armor_table;
|
|
/* 0C / 3268 */ le_uint32_t unit_table;
|
|
/* 10 / 3278 */ le_uint32_t tool_table;
|
|
/* 14 / 3270 */ le_uint32_t mag_table;
|
|
/* 18 / 23C8 */ le_uint32_t weapon_kind_table;
|
|
/* 1C / 1DB0 */ le_uint32_t photon_color_table;
|
|
/* 20 / 2080 */ le_uint32_t weapon_range_table;
|
|
/* 24 / 23F0 */ le_uint32_t weapon_sale_divisor_table;
|
|
/* 28 / 248C */ le_uint32_t non_weapon_sale_divisor_table;
|
|
/* 2C / 3420 */ le_uint32_t mag_feed_table;
|
|
/* 30 / 275C */ le_uint32_t star_value_table;
|
|
/* 34 / 28A2 */ le_uint32_t unknown_a1;
|
|
/* 38 / 2C12 */ le_uint32_t special_table;
|
|
/* 3C / 2CB8 */ le_uint32_t weapon_effect_table;
|
|
/* 40 / 3198 */ le_uint32_t stat_boost_table;
|
|
} __packed_ws__(RootV1, 0x44);
|
|
|
|
struct RootV2 {
|
|
/* ## / DCV2 */
|
|
/* 00 / 0013 */ le_uint32_t entry_count;
|
|
/* 04 / 5AFC */ le_uint32_t weapon_table;
|
|
/* 08 / 5A5C */ le_uint32_t armor_table;
|
|
/* 0C / 5A6C */ le_uint32_t unit_table;
|
|
/* 10 / 5A7C */ le_uint32_t tool_table;
|
|
/* 14 / 5A74 */ le_uint32_t mag_table;
|
|
/* 18 / 3DF8 */ le_uint32_t weapon_kind_table;
|
|
/* 1C / 2E4C */ le_uint32_t photon_color_table;
|
|
/* 20 / 32CC */ le_uint32_t weapon_range_table;
|
|
/* 24 / 3E84 */ le_uint32_t weapon_sale_divisor_table;
|
|
/* 28 / 40A8 */ le_uint32_t non_weapon_sale_divisor_table;
|
|
/* 2C / 5F4C */ le_uint32_t mag_feed_table;
|
|
/* 30 / 4378 */ le_uint32_t star_value_table;
|
|
/* 34 / 4540 */ le_uint32_t special_table;
|
|
/* 38 / 45E4 */ le_uint32_t weapon_effect_table;
|
|
/* 3C / 58DC */ le_uint32_t stat_boost_table;
|
|
/* 40 / 5704 */ le_uint32_t shield_effect_table;
|
|
} __packed_ws__(RootV2, 0x44);
|
|
|
|
struct RootGCNTE {
|
|
/* ## / GCTE */
|
|
/* 00 / 6F0C */ be_uint32_t weapon_table;
|
|
/* 04 / 6E4C */ be_uint32_t armor_table;
|
|
/* 08 / 6E5C */ be_uint32_t unit_table;
|
|
/* 0C / 6E6C */ be_uint32_t tool_table;
|
|
/* 10 / 6E64 */ be_uint32_t mag_table;
|
|
/* 14 / 47BC */ be_uint32_t weapon_kind_table;
|
|
/* 18 / 37A4 */ be_uint32_t photon_color_table;
|
|
/* 1C / 3A74 */ be_uint32_t weapon_range_table;
|
|
/* 20 / 484C */ be_uint32_t weapon_sale_divisor_table;
|
|
/* 24 / 4A80 */ be_uint32_t non_weapon_sale_divisor_table;
|
|
/* 28 / 7384 */ be_uint32_t mag_feed_table;
|
|
/* 2C / 4D50 */ be_uint32_t star_value_table;
|
|
/* 30 / 4F72 */ be_uint32_t special_table;
|
|
/* 34 / 5018 */ be_uint32_t weapon_effect_table;
|
|
/* 38 / 68B8 */ be_uint32_t stat_boost_table;
|
|
/* 3C / 61B8 */ be_uint32_t shield_effect_table;
|
|
/* 40 / 69D8 */ be_uint32_t max_tech_level_table;
|
|
/* 44 / 737C */ be_uint32_t combination_table;
|
|
/* 48 / 68B0 */ be_uint32_t sound_remap_table;
|
|
/* 4C / 6B1C */ be_uint32_t tech_boost_table;
|
|
} __packed_ws__(RootGCNTE, 0x50);
|
|
|
|
template <bool BE>
|
|
struct RootV3V4T {
|
|
/* ## / GCV3 / XBV3 / BBV4 */
|
|
/* 00 / F078 / F084 / 14884 */ U32T<BE> weapon_table;
|
|
/* 04 / EF90 / EF9C / 1478C */ U32T<BE> armor_table;
|
|
/* 08 / EFA0 / EFAC / 1479C */ U32T<BE> unit_table;
|
|
/* 0C / EFB0 / EFBC / 147AC */ U32T<BE> tool_table;
|
|
/* 10 / EFA8 / EFB4 / 147A4 */ U32T<BE> mag_table;
|
|
/* 14 / B88C / B8A0 / 0F4B8 */ U32T<BE> weapon_kind_table;
|
|
/* 18 / A7FC / A7FC / 0DE7C */ U32T<BE> photon_color_table;
|
|
/* 1C / AACC / AACC / 0E194 */ U32T<BE> weapon_range_table;
|
|
/* 20 / B938 / B94C / 0F5A8 */ U32T<BE> weapon_sale_divisor_table;
|
|
/* 24 / BBCC / BBE0 / 0F83C */ U32T<BE> non_weapon_sale_divisor_table;
|
|
/* 28 / F608 / F614 / 1502C */ U32T<BE> mag_feed_table;
|
|
/* 2C / BE9C / BEB0 / 0FB0C */ U32T<BE> star_value_table;
|
|
/* 30 / C100 / C114 / 0FE3C */ U32T<BE> special_table;
|
|
/* 34 / C1A4 / C1B8 / 0FEE0 */ U32T<BE> weapon_effect_table;
|
|
/* 38 / DE50 / DE64 / 1275C */ U32T<BE> stat_boost_table;
|
|
/* 3C / D6E4 / D6F8 / 11C80 */ U32T<BE> shield_effect_table;
|
|
/* 40 / DF88 / DF9C / 12894 */ U32T<BE> max_tech_level_table;
|
|
/* 44 / F5D0 / F5DC / 14FF4 */ U32T<BE> combination_table;
|
|
/* 48 / DE48 / DE5C / 12754 */ U32T<BE> sound_remap_table;
|
|
/* 4C / EB8C / EBA0 / 14278 */ U32T<BE> tech_boost_table;
|
|
/* 50 / F5F0 / F5FC / 15014 */ U32T<BE> unwrap_table;
|
|
/* 54 / F5F8 / F604 / 1501C */ U32T<BE> unsealable_table;
|
|
/* 58 / F600 / F60C / 15024 */ U32T<BE> ranged_special_table;
|
|
} __packed_ws_be__(RootV3V4T, 0x5C);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Reader implementation
|
|
|
|
std::set<uint32_t> ItemParameterTable::compute_all_valid_primary_identifiers() const {
|
|
set<uint32_t> ret;
|
|
|
|
auto find_items_1d = [&](uint64_t data1, size_t position) -> size_t {
|
|
ItemData item(data1, 0);
|
|
for (size_t x = 0; x < 0x100; x++) {
|
|
item.data1[position] = x;
|
|
try {
|
|
this->get_item_id(item);
|
|
} catch (const out_of_range&) {
|
|
return x;
|
|
}
|
|
ret.emplace(item.primary_identifier());
|
|
}
|
|
return 0x100;
|
|
};
|
|
auto find_items_2d = [&](uint64_t data1) {
|
|
for (size_t x = 0; x < 0x100; x++) {
|
|
uint64_t effective_data1 = data1 | (static_cast<uint64_t>(x) << 48);
|
|
size_t data2_position = (effective_data1 == 0x0302000000000000) ? 4 : 2;
|
|
if (find_items_1d(effective_data1, data2_position) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
find_items_2d(0x0000000000000000);
|
|
find_items_1d(0x0101000000000000, 2);
|
|
find_items_1d(0x0102000000000000, 2);
|
|
find_items_1d(0x0103000000000000, 2);
|
|
find_items_1d(0x0200000000000000, 1);
|
|
find_items_2d(0x0300000000000000);
|
|
return ret;
|
|
}
|
|
|
|
std::variant<
|
|
const ItemParameterTable::Weapon*,
|
|
const ItemParameterTable::ArmorOrShield*,
|
|
const ItemParameterTable::Unit*,
|
|
const ItemParameterTable::Mag*,
|
|
const ItemParameterTable::Tool*>
|
|
ItemParameterTable::definition_for_primary_identifier(uint32_t primary_identifier) const {
|
|
uint8_t data1_0 = (primary_identifier >> 24) & 0xFF;
|
|
uint8_t data1_1 = (primary_identifier >> 16) & 0xFF;
|
|
uint8_t data1_2 = (primary_identifier >> 8) & 0xFF;
|
|
switch (data1_0) {
|
|
case 0:
|
|
return &this->get_weapon(data1_1, data1_2);
|
|
case 1:
|
|
switch (data1_1) {
|
|
case 1:
|
|
case 2:
|
|
return &this->get_armor_or_shield(data1_1, data1_2);
|
|
case 3:
|
|
return &this->get_unit(data1_2);
|
|
default:
|
|
throw runtime_error("invalid primary identifier");
|
|
}
|
|
case 2:
|
|
return &this->get_mag(data1_1);
|
|
case 3:
|
|
// NOTE: Unlike in ItemData, the tech number comes first in primary identifiers, so we don't need to special-case
|
|
// 0302XXYY here
|
|
return &this->get_tool(data1_1, data1_2);
|
|
default:
|
|
throw runtime_error("invalid primary identifier");
|
|
}
|
|
}
|
|
|
|
uint32_t ItemParameterTable::get_item_id(const ItemData& item) const {
|
|
switch (item.data1[0]) {
|
|
case 0:
|
|
return this->get_weapon(item.data1[1], item.data1[2]).id;
|
|
case 1:
|
|
if (item.data1[1] == 3) {
|
|
return this->get_unit(item.data1[2]).id;
|
|
} else if ((item.data1[1] == 1) || (item.data1[1] == 2)) {
|
|
return this->get_armor_or_shield(item.data1[1], item.data1[2]).id;
|
|
}
|
|
throw runtime_error("invalid item");
|
|
case 2:
|
|
return this->get_mag(item.data1[1]).id;
|
|
case 3:
|
|
if (item.data1[1] == 2) {
|
|
return this->get_tool(2, item.data1[4]).id;
|
|
} else {
|
|
return this->get_tool(item.data1[1], item.data1[2]).id;
|
|
}
|
|
throw logic_error("this should be impossible");
|
|
case 4:
|
|
throw runtime_error("item is meseta and therefore has no definition");
|
|
default:
|
|
throw runtime_error("invalid item");
|
|
}
|
|
}
|
|
|
|
uint32_t ItemParameterTable::get_item_team_points(const ItemData& item) const {
|
|
switch (item.data1[0]) {
|
|
case 0:
|
|
return this->get_weapon(item.data1[1], item.data1[2]).team_points;
|
|
case 1:
|
|
if (item.data1[1] == 3) {
|
|
return this->get_unit(item.data1[2]).team_points;
|
|
} else if ((item.data1[1] == 1) || (item.data1[1] == 2)) {
|
|
return this->get_armor_or_shield(item.data1[1], item.data1[2]).team_points;
|
|
}
|
|
throw runtime_error("invalid item");
|
|
case 2:
|
|
return this->get_mag(item.data1[1]).team_points;
|
|
case 3:
|
|
if (item.data1[1] == 2) {
|
|
return this->get_tool(2, item.data1[4]).team_points;
|
|
} else {
|
|
return this->get_tool(item.data1[1], item.data1[2]).team_points;
|
|
}
|
|
throw logic_error("this should be impossible");
|
|
case 4:
|
|
throw runtime_error("item is meseta and therefore has no definition");
|
|
default:
|
|
throw runtime_error("invalid item");
|
|
}
|
|
}
|
|
|
|
uint8_t ItemParameterTable::get_item_base_stars(const ItemData& item) const {
|
|
switch (item.data1[0]) {
|
|
case 0:
|
|
case 1:
|
|
return this->get_item_stars(this->get_item_id(item));
|
|
case 2:
|
|
return (item.data1[1] >= 0x28) ? 12 : 0;
|
|
case 3: {
|
|
const auto& def = (item.data1[1] == 2)
|
|
? this->get_tool(2, item.data1[4])
|
|
: this->get_tool(item.data1[1], item.data1[2]);
|
|
return (def.item_flags & 0x80) ? 12 : 0;
|
|
}
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
uint8_t ItemParameterTable::get_item_adjusted_stars(const ItemData& item, bool ignore_unidentified) const {
|
|
uint8_t ret = this->get_item_base_stars(item);
|
|
if (item.data1[0] == 0) {
|
|
bool is_unidentified = (!ignore_unidentified) && (item.data1[4] & 0x80);
|
|
if (ret < 9) {
|
|
if (!is_unidentified) {
|
|
ret += this->get_special_stars(item.data1[4]);
|
|
}
|
|
} else if (is_unidentified) {
|
|
ret = 0;
|
|
}
|
|
} else if (item.data1[0] == 1) {
|
|
if (item.data1[1] == 3) {
|
|
int16_t unit_bonus = item.get_unit_bonus();
|
|
if (unit_bonus < 0) {
|
|
ret--;
|
|
} else if (unit_bonus > 0) {
|
|
ret++;
|
|
}
|
|
}
|
|
}
|
|
return min<uint8_t>(ret, 12);
|
|
}
|
|
|
|
std::string ItemParameterTable::get_star_value_table() const {
|
|
auto [start_z, end_z] = this->get_star_value_index_range();
|
|
std::string ret;
|
|
for (size_t z = start_z; z < end_z; z++) {
|
|
ret.push_back(this->get_item_stars(z));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
std::string ItemParameterTable::get_weapon_stat_boost_index_table() const {
|
|
std::string ret;
|
|
for (size_t z = 0; z < this->num_weapon_stat_boost_indexes(); z++) {
|
|
ret.push_back(this->get_weapon_stat_boost_index(z));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
std::string ItemParameterTable::get_armor_stat_boost_index_table() const {
|
|
std::string ret;
|
|
for (size_t z = 0; z < this->num_armor_stat_boost_indexes(); z++) {
|
|
ret.push_back(this->get_armor_stat_boost_index(z));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
std::string ItemParameterTable::get_shield_stat_boost_index_table() const {
|
|
std::string ret;
|
|
for (size_t z = 0; z < this->num_shield_stat_boost_indexes(); z++) {
|
|
ret.push_back(this->get_shield_stat_boost_index(z));
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool ItemParameterTable::is_item_rare(const ItemData& item) const {
|
|
try {
|
|
return (this->get_item_base_stars(item) >= 9);
|
|
} catch (const out_of_range&) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ItemParameterTable::is_unsealable_item(uint8_t data1_0, uint8_t data1_1, uint8_t data1_2) const {
|
|
return this->all_unsealable_items().count(item_code_to_u32(data1_0, data1_1, data1_2));
|
|
}
|
|
|
|
bool ItemParameterTable::is_unsealable_item(const ItemData& item) const {
|
|
return this->is_unsealable_item(item.data1[0], item.data1[1], item.data1[2]);
|
|
}
|
|
|
|
const ItemParameterTable::ItemCombination& ItemParameterTable::get_item_combination(
|
|
const ItemData& used_item, const ItemData& equipped_item) const {
|
|
for (const auto& def : this->all_combinations_for_used_item(used_item)) {
|
|
if ((def.equipped_item[0] == 0xFF || def.equipped_item[0] == equipped_item.data1[0]) &&
|
|
(def.equipped_item[1] == 0xFF || def.equipped_item[1] == equipped_item.data1[1]) &&
|
|
(def.equipped_item[2] == 0xFF || def.equipped_item[2] == equipped_item.data1[2])) {
|
|
return def;
|
|
}
|
|
}
|
|
throw out_of_range("no item combination applies");
|
|
}
|
|
|
|
const std::vector<ItemParameterTable::ItemCombination>& ItemParameterTable::all_combinations_for_used_item(
|
|
const ItemData& used_item) const {
|
|
try {
|
|
return this->all_item_combinations().at(item_code_to_u32(
|
|
used_item.data1[0], used_item.data1[1], used_item.data1[2]));
|
|
} catch (const out_of_range&) {
|
|
static const vector<ItemCombination> ret;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
size_t ItemParameterTable::price_for_item(const ItemData& item) const {
|
|
switch (item.data1[0]) {
|
|
case 0: {
|
|
if (item.data1[4] & 0x80) {
|
|
return 8;
|
|
}
|
|
if (this->is_item_rare(item)) {
|
|
return 80;
|
|
}
|
|
|
|
float sale_divisor = this->get_sale_divisor(0, item.data1[1]);
|
|
if (sale_divisor == 0.0) {
|
|
throw runtime_error("item sale divisor is zero");
|
|
}
|
|
|
|
const auto& def = this->get_weapon(item.data1[1], item.data1[2]);
|
|
double atp_max = def.atp_max + item.data1[3];
|
|
double atp_factor = ((atp_max * atp_max) / sale_divisor);
|
|
|
|
double bonus_factor = 0.0;
|
|
for (size_t bonus_index = 0; bonus_index < 3; bonus_index++) {
|
|
uint8_t bonus_type = item.data1[(2 * bonus_index) + 6];
|
|
if ((bonus_type > 0) && (bonus_type < 6)) {
|
|
bonus_factor += item.data1[(2 * bonus_index) + 7];
|
|
}
|
|
bonus_factor += 100.0;
|
|
}
|
|
|
|
size_t special_stars = this->get_special_stars(item.data1[4]);
|
|
double special_stars_factor = 1000.0 * special_stars * special_stars;
|
|
|
|
return special_stars_factor + ((atp_factor * bonus_factor) / 100.0);
|
|
}
|
|
|
|
case 1: {
|
|
if (this->is_item_rare(item)) {
|
|
return 80;
|
|
}
|
|
|
|
if (item.data1[1] == 3) { // Unit
|
|
return this->get_item_adjusted_stars(item) * this->get_sale_divisor(1, 3);
|
|
}
|
|
|
|
double sale_divisor = (double)this->get_sale_divisor(1, item.data1[1]);
|
|
if (sale_divisor == 0.0) {
|
|
throw runtime_error("item sale divisor is zero");
|
|
}
|
|
|
|
int16_t def_bonus = item.get_armor_or_shield_defense_bonus();
|
|
int16_t evp_bonus = item.get_common_armor_evasion_bonus();
|
|
|
|
const auto& def = this->get_armor_or_shield(item.data1[1], item.data1[2]);
|
|
double power_factor = def.dfp + def.evp + def_bonus + evp_bonus;
|
|
double power_factor_floor = static_cast<int32_t>((power_factor * power_factor) / sale_divisor);
|
|
return power_factor_floor + (70.0 * static_cast<double>(item.data1[5] + 1) * static_cast<double>(def.required_level + 1));
|
|
}
|
|
|
|
case 2:
|
|
return (item.data1[2] + 1) * this->get_sale_divisor(2, item.data1[1]);
|
|
|
|
case 3: {
|
|
const auto& def = (item.data1[1] == 2)
|
|
? this->get_tool(2, item.data1[4])
|
|
: this->get_tool(item.data1[1], item.data1[2]);
|
|
return def.cost * ((item.data1[1] == 2) ? (item.data1[2] + 1) : 1);
|
|
}
|
|
|
|
case 4:
|
|
return item.data2d;
|
|
|
|
default:
|
|
throw runtime_error("invalid item");
|
|
}
|
|
throw logic_error("this should be impossible");
|
|
}
|
|
|
|
template <
|
|
typename RootT,
|
|
typename WeaponT,
|
|
size_t NumWeaponClasses,
|
|
typename ArmorOrShieldT,
|
|
typename UnitT,
|
|
typename ToolT,
|
|
size_t NumToolClasses,
|
|
typename MagT,
|
|
size_t ItemStarsFirstID,
|
|
size_t ItemStarsLastID,
|
|
size_t SpecialStarsBeginIndex,
|
|
size_t NumSpecials,
|
|
size_t NumPhotonColors,
|
|
size_t SoundRemapRTTableSize,
|
|
bool BE>
|
|
class BinaryItemParameterTableT : public ItemParameterTable {
|
|
public:
|
|
explicit BinaryItemParameterTableT(std::shared_ptr<const std::string> data)
|
|
: ItemParameterTable(),
|
|
data(data),
|
|
r(*this->data),
|
|
root(&this->r.pget<RootT>(BE ? r.pget_u32b(r.size() - 0x10) : r.pget_u32l(r.size() - 0x10))) {}
|
|
~BinaryItemParameterTableT() = default;
|
|
|
|
inline size_t indirect_lookup_2d_count(size_t base_offset, size_t co_index) const {
|
|
return this->r.pget<ArrayRefT<BE>>(base_offset + sizeof(ArrayRefT<BE>) * co_index).count;
|
|
}
|
|
|
|
template <typename T>
|
|
const T& indirect_lookup_2d(size_t base_offset, size_t co_index, size_t item_index) const {
|
|
const auto& co = this->r.pget<ArrayRefT<BE>>(base_offset + sizeof(ArrayRefT<BE>) * co_index);
|
|
if (item_index >= co.count) {
|
|
throw out_of_range("2-D array index out of range");
|
|
}
|
|
return this->r.pget<T>(co.offset + sizeof(T) * item_index);
|
|
}
|
|
|
|
template <typename RawT, typename ParsedT>
|
|
const ParsedT& add_to_vector_cache(std::vector<ParsedT>& cache, size_t base_offset, size_t index) const {
|
|
while (cache.size() <= index) {
|
|
cache.emplace_back(this->r.pget<RawT>(base_offset + sizeof(RawT) * cache.size()));
|
|
}
|
|
return cache[index];
|
|
}
|
|
|
|
template <typename RawT, typename ParsedT>
|
|
const ParsedT& add_to_vector_cache_2d_indirect(
|
|
std::vector<ParsedT>& cache, size_t base_offset, size_t major_index, size_t minor_index) const {
|
|
while (cache.size() <= minor_index) {
|
|
cache.emplace_back(indirect_lookup_2d<RawT>(base_offset, major_index, cache.size()));
|
|
}
|
|
return cache[minor_index];
|
|
}
|
|
|
|
virtual size_t num_weapon_classes() const {
|
|
return NumWeaponClasses;
|
|
}
|
|
|
|
virtual size_t num_weapons_in_class(uint8_t data1_1) const {
|
|
if (data1_1 >= NumWeaponClasses) {
|
|
throw out_of_range("weapon ID out of range");
|
|
}
|
|
return this->indirect_lookup_2d_count(this->root->weapon_table, data1_1);
|
|
}
|
|
|
|
virtual const Weapon& get_weapon(uint8_t data1_1, uint8_t data1_2) const {
|
|
if (data1_1 >= NumWeaponClasses) {
|
|
throw out_of_range("weapon ID out of range");
|
|
}
|
|
uint16_t key = (data1_1 << 8) | data1_2;
|
|
auto it = this->weapons.find(key);
|
|
if (it == this->weapons.end()) {
|
|
const auto& weapon = this->indirect_lookup_2d<WeaponT>(this->root->weapon_table, data1_1, data1_2);
|
|
it = this->weapons.emplace(key, weapon).first;
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
virtual size_t num_armors_or_shields_in_class(uint8_t data1_1) const {
|
|
if ((data1_1 < 1) || (data1_1 > 2)) {
|
|
throw out_of_range("armor/shield class ID out of range");
|
|
}
|
|
return this->indirect_lookup_2d_count(this->root->armor_table, data1_1 - 1);
|
|
}
|
|
|
|
virtual const ArmorOrShield& get_armor_or_shield(uint8_t data1_1, uint8_t data1_2) const {
|
|
if ((data1_1 < 1) || (data1_1 > 2)) {
|
|
throw out_of_range("armor/shield class ID out of range");
|
|
}
|
|
auto& vec = (data1_1 == 1) ? this->armors : this->shields;
|
|
return this->add_to_vector_cache_2d_indirect<ArmorOrShieldT>(vec, this->root->armor_table, data1_1 - 1, data1_2);
|
|
}
|
|
|
|
virtual size_t num_units() const {
|
|
return this->indirect_lookup_2d_count(this->root->unit_table, 0);
|
|
}
|
|
|
|
virtual const Unit& get_unit(uint8_t data1_2) const {
|
|
return this->add_to_vector_cache_2d_indirect<UnitT>(this->units, this->root->unit_table, 0, data1_2);
|
|
}
|
|
|
|
virtual size_t num_tool_classes() const {
|
|
return NumToolClasses;
|
|
}
|
|
|
|
virtual size_t num_tools_in_class(uint8_t data1_1) const {
|
|
if (data1_1 >= NumToolClasses) {
|
|
throw out_of_range("tool class ID out of range");
|
|
}
|
|
return this->indirect_lookup_2d_count(this->root->tool_table, data1_1);
|
|
}
|
|
|
|
virtual const Tool& get_tool(uint8_t data1_1, uint8_t data1_2) const {
|
|
if (data1_1 >= NumToolClasses) {
|
|
throw out_of_range("tool class ID out of range");
|
|
}
|
|
uint16_t key = (data1_1 << 8) | data1_2;
|
|
auto it = this->tools.find(key);
|
|
if (it == this->tools.end()) {
|
|
const auto& tool = this->indirect_lookup_2d<ToolT>(this->root->tool_table, data1_1, data1_2);
|
|
it = this->tools.emplace(key, tool).first;
|
|
}
|
|
return it->second;
|
|
}
|
|
|
|
virtual std::pair<uint8_t, uint8_t> find_tool_by_id(uint32_t id) const {
|
|
const auto* cos = &this->r.pget<ArrayRefT<BE>>(this->root->tool_table, NumToolClasses * sizeof(ArrayRefT<BE>));
|
|
for (size_t z = 0; z < NumToolClasses; z++) {
|
|
const auto& co = cos[z];
|
|
const auto* defs = &this->r.pget<ToolT>(co.offset, sizeof(ToolT) * co.count);
|
|
for (size_t y = 0; y < co.count; y++) {
|
|
if (defs[y].base.id == id) {
|
|
return make_pair(z, y);
|
|
}
|
|
}
|
|
}
|
|
throw out_of_range(std::format("invalid tool class {:08X}", id));
|
|
}
|
|
|
|
virtual size_t num_mags() const {
|
|
return this->indirect_lookup_2d_count(this->root->mag_table, 0);
|
|
}
|
|
|
|
virtual const Mag& get_mag(uint8_t data1_1) const {
|
|
return this->add_to_vector_cache_2d_indirect<MagT>(this->mags, this->root->mag_table, 0, data1_1);
|
|
}
|
|
|
|
virtual uint8_t get_weapon_kind(uint8_t data1_1) const {
|
|
return (data1_1 < NumWeaponClasses) ? this->r.pget_u8(this->root->weapon_kind_table + data1_1) : 0x00;
|
|
}
|
|
|
|
virtual size_t num_photon_colors() const {
|
|
return NumPhotonColors;
|
|
}
|
|
|
|
virtual const PhotonColorEntry& get_photon_color(size_t index) const {
|
|
if (index >= NumPhotonColors) {
|
|
throw std::out_of_range("invalid photon color index");
|
|
}
|
|
return this->add_to_vector_cache<PhotonColorEntryT<BE>>(this->photon_colors, this->root->photon_color_table, index);
|
|
}
|
|
|
|
virtual size_t num_weapon_ranges() const {
|
|
return this->get_data_array_count<WeaponRangeT<BE>>(this->root->weapon_range_table);
|
|
}
|
|
|
|
virtual const WeaponRange& get_weapon_range(size_t index) const {
|
|
return this->add_to_vector_cache<WeaponRangeT<BE>>(this->weapon_ranges, this->root->weapon_range_table, index);
|
|
}
|
|
|
|
virtual float get_sale_divisor(uint8_t data1_0, uint8_t data1_1) const {
|
|
if (data1_0 == 0) {
|
|
if (data1_1 >= NumWeaponClasses) {
|
|
return 0.0f;
|
|
}
|
|
if constexpr (requires { this->root->weapon_sale_divisor_table; }) {
|
|
return this->r.pget<F32T<BE>>(this->root->weapon_sale_divisor_table + data1_1 * sizeof(F32T<BE>));
|
|
} else {
|
|
return this->r.pget<uint8_t>(this->root->weapon_integral_sale_divisor_table + data1_1 * sizeof(uint8_t));
|
|
}
|
|
}
|
|
|
|
if constexpr (requires { this->root->non_weapon_sale_divisor_table; }) {
|
|
const auto& divisors = this->r.pget<NonWeaponSaleDivisorsT<BE>>(this->root->non_weapon_sale_divisor_table);
|
|
if (data1_0 == 1) {
|
|
switch (data1_1) {
|
|
case 1:
|
|
return divisors.armor_divisor;
|
|
case 2:
|
|
return divisors.shield_divisor;
|
|
case 3:
|
|
return divisors.unit_divisor;
|
|
}
|
|
} else if (data1_0 == 2) {
|
|
return divisors.mag_divisor;
|
|
}
|
|
} else {
|
|
if (data1_0 == 1) {
|
|
const auto& divisors = this->r.pget<NonWeaponSaleDivisorsDCProtos>(
|
|
this->root->non_weapon_integral_sale_divisor_table);
|
|
switch (data1_1) {
|
|
case 1:
|
|
return divisors.armor_divisor;
|
|
case 2:
|
|
return divisors.shield_divisor;
|
|
case 3:
|
|
return divisors.unit_divisor;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
virtual const MagFeedResult& get_mag_feed_result(uint8_t table_index, uint8_t item_index) const {
|
|
if (table_index >= 8) {
|
|
throw out_of_range("invalid mag feed table index");
|
|
}
|
|
if (item_index >= 11) {
|
|
throw out_of_range("invalid mag feed item index");
|
|
}
|
|
const auto& table_offsets = this->r.pget<MagFeedResultsListOffsetsT<BE>>(this->root->mag_feed_table);
|
|
return this->r.pget<MagFeedResultsList>(table_offsets[table_index])[item_index];
|
|
}
|
|
|
|
virtual std::pair<uint32_t, uint32_t> get_star_value_index_range() const {
|
|
return std::make_pair(ItemStarsFirstID, ItemStarsLastID);
|
|
}
|
|
|
|
virtual uint32_t get_special_stars_base_index() const {
|
|
return SpecialStarsBeginIndex;
|
|
}
|
|
|
|
virtual uint8_t get_item_stars(uint32_t id) const {
|
|
return ((id >= ItemStarsFirstID) && (id < ItemStarsLastID))
|
|
? this->r.pget_u8(this->root->star_value_table + id - ItemStarsFirstID)
|
|
: 0;
|
|
}
|
|
|
|
virtual uint8_t get_special_stars(uint8_t special) const {
|
|
return ((special & 0x3F) && !(special & 0x80)) ? this->get_item_stars(special + SpecialStarsBeginIndex) : 0;
|
|
}
|
|
|
|
virtual std::string get_unknown_a1() const {
|
|
if constexpr (requires { this->root->unknown_a1; }) {
|
|
return this->r.pread(this->root->unknown_a1, this->get_data_range_size(this->root->unknown_a1));
|
|
} else {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
virtual size_t num_specials() const {
|
|
return NumSpecials;
|
|
}
|
|
|
|
virtual const Special& get_special(uint8_t special) const {
|
|
special &= 0x3F;
|
|
if (special >= NumSpecials) {
|
|
throw out_of_range("invalid special index");
|
|
}
|
|
while (this->specials.size() <= special) {
|
|
this->specials.emplace_back(this->r.pget<SpecialT<BE>>(
|
|
this->root->special_table + sizeof(SpecialT<BE>) * this->specials.size()));
|
|
}
|
|
return this->specials[special];
|
|
}
|
|
|
|
virtual size_t num_weapon_effects() const {
|
|
return this->get_data_array_count<WeaponEffectT<BE>>(this->root->weapon_effect_table);
|
|
}
|
|
|
|
virtual const WeaponEffect& get_weapon_effect(size_t index) const {
|
|
return this->add_to_vector_cache<WeaponEffectT<BE>>(this->weapon_effects, this->root->weapon_effect_table, index);
|
|
}
|
|
|
|
virtual size_t num_weapon_stat_boost_indexes() const {
|
|
if constexpr (requires { this->root->weapon_stat_boost_index_table; }) {
|
|
return this->get_data_range_size(this->root->weapon_stat_boost_index_table);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual uint8_t get_weapon_stat_boost_index(size_t index) const {
|
|
if constexpr (requires { this->root->weapon_stat_boost_index_table; }) {
|
|
return this->r.pget_u8(this->root->weapon_stat_boost_index_table + index);
|
|
} else {
|
|
throw std::logic_error("weapon stat boost index table not available");
|
|
}
|
|
}
|
|
|
|
virtual size_t num_armor_stat_boost_indexes() const {
|
|
if constexpr (requires { this->root->armor_stat_boost_index_table; }) {
|
|
return this->get_data_range_size(this->root->armor_stat_boost_index_table);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual uint8_t get_armor_stat_boost_index(size_t index) const {
|
|
if constexpr (requires { this->root->armor_stat_boost_index_table; }) {
|
|
return this->r.pget_u8(this->root->armor_stat_boost_index_table + index);
|
|
} else {
|
|
throw std::logic_error("armor stat boost index table not available");
|
|
}
|
|
}
|
|
|
|
virtual size_t num_shield_stat_boost_indexes() const {
|
|
if constexpr (requires { this->root->shield_stat_boost_index_table; }) {
|
|
return this->get_data_range_size(this->root->shield_stat_boost_index_table);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual uint8_t get_shield_stat_boost_index(size_t index) const {
|
|
if constexpr (requires { this->root->shield_stat_boost_index_table; }) {
|
|
return this->r.pget_u8(this->root->shield_stat_boost_index_table + index);
|
|
} else {
|
|
throw std::logic_error("shield stat boost index table not available");
|
|
}
|
|
}
|
|
|
|
virtual size_t num_stat_boosts() const {
|
|
return this->get_data_array_count<StatBoostT<BE>>(this->root->stat_boost_table);
|
|
}
|
|
|
|
virtual const StatBoost& get_stat_boost(size_t index) const {
|
|
return this->add_to_vector_cache<StatBoostT<BE>>(this->stat_boosts, this->root->stat_boost_table, index);
|
|
}
|
|
|
|
virtual size_t num_shield_effects() const {
|
|
if constexpr (requires { this->root->shield_effect_table; }) {
|
|
return this->get_data_array_count<ShieldEffectT<BE>>(this->root->shield_effect_table);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual const ShieldEffect& get_shield_effect(size_t index) const {
|
|
if constexpr (requires { this->root->shield_effect_table; }) {
|
|
return this->add_to_vector_cache<ShieldEffectT<BE>>(this->shield_effects, this->root->shield_effect_table, index);
|
|
} else {
|
|
throw std::logic_error("shield effect table not available");
|
|
}
|
|
}
|
|
|
|
virtual uint8_t get_max_tech_level(uint8_t char_class, uint8_t tech_num) const {
|
|
if (char_class >= 12) {
|
|
throw out_of_range("invalid character class");
|
|
}
|
|
if (tech_num >= 19) {
|
|
throw out_of_range("invalid technique number");
|
|
}
|
|
if constexpr (requires { this->root->max_tech_level_table; }) {
|
|
return r.pget_u8(this->root->max_tech_level_table + tech_num * 12 + char_class);
|
|
} else {
|
|
if ((tech_num == 14) || (tech_num == 17)) { // Ryuker or Reverser
|
|
return 0;
|
|
} else {
|
|
return ((char_class == 6) || (char_class == 7) || (char_class == 8) || (char_class == 10)) ? 29 : 14;
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual const std::map<uint32_t, std::vector<ItemCombination>>& all_item_combinations() const {
|
|
if constexpr (requires { this->root->combination_table; }) {
|
|
if (!this->item_combination_index.has_value()) {
|
|
auto& ret = this->item_combination_index.emplace();
|
|
const auto& co = this->r.pget<ArrayRefT<BE>>(this->root->combination_table);
|
|
const auto* defs = &this->r.pget<ItemCombination>(co.offset, co.count * sizeof(ItemCombination));
|
|
for (size_t z = 0; z < co.count; z++) {
|
|
ret[item_code_to_u32(defs[z].used_item)].emplace_back(defs[z]);
|
|
}
|
|
}
|
|
return *this->item_combination_index;
|
|
} else {
|
|
static const std::map<uint32_t, std::vector<ItemParameterTable::ItemCombination>> empty_map{};
|
|
return empty_map;
|
|
}
|
|
}
|
|
|
|
virtual const std::unordered_map<uint32_t, SoundRemaps>& get_all_sound_remaps() const {
|
|
if constexpr (requires { this->root->sound_remap_table; }) {
|
|
if (!this->sound_remaps.has_value()) {
|
|
auto& ret = this->sound_remaps.emplace();
|
|
const auto& co = this->r.pget<ArrayRefT<BE>>(this->root->sound_remap_table);
|
|
const auto* entries = this->r.pget_array<SoundRemapTableOffsetsT<BE>>(co.offset, co.count);
|
|
for (size_t z = 0; z < co.count; z++) {
|
|
auto& remaps = ret.emplace(entries[z].sound_id, SoundRemaps{}).first->second;
|
|
remaps.sound_id = entries[z].sound_id;
|
|
auto sub_r = r.sub(entries[z].remaps_for_rt_index_table, SoundRemapRTTableSize * sizeof(U32T<BE>));
|
|
for (size_t z = 0; z < SoundRemapRTTableSize; z++) {
|
|
remaps.by_rt_index.emplace_back(sub_r.template get<U32T<BE>>());
|
|
}
|
|
sub_r = r.sub(entries[z].remaps_for_char_class_table, 12 * sizeof(U32T<BE>));
|
|
for (size_t z = 0; z < 12; z++) {
|
|
remaps.by_char_class.emplace_back(sub_r.template get<U32T<BE>>());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return *this->sound_remaps;
|
|
}
|
|
|
|
virtual size_t num_tech_boosts() const {
|
|
if constexpr (requires { this->root->tech_boost_table; }) {
|
|
return this->get_data_array_count<TechBoostEntryT<BE>>(this->root->tech_boost_table);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual const TechBoost& get_tech_boost(size_t index) const {
|
|
if constexpr (requires { this->root->tech_boost_table; }) {
|
|
return this->add_to_vector_cache<TechBoostEntryT<BE>>(this->tech_boosts, this->root->tech_boost_table, index);
|
|
} else {
|
|
throw std::logic_error("tech boost table not available");
|
|
}
|
|
}
|
|
|
|
virtual size_t num_events() const {
|
|
if constexpr (requires { this->root->unwrap_table; }) {
|
|
return this->r.pget<ArrayRefT<BE>>(this->root->unwrap_table).count;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual std::pair<const EventItem*, size_t> get_event_items(uint8_t event_number) const {
|
|
if constexpr (requires { this->root->unwrap_table; }) {
|
|
const auto& co = this->r.pget<ArrayRefT<BE>>(this->root->unwrap_table);
|
|
if (event_number >= co.count) {
|
|
throw out_of_range("invalid event number");
|
|
}
|
|
const auto& event_co = this->r.pget<ArrayRefT<BE>>(co.offset + sizeof(ArrayRefT<BE>) * event_number);
|
|
const auto* defs = &this->r.pget<EventItem>(event_co.offset, event_co.count * sizeof(EventItem));
|
|
return make_pair(defs, event_co.count);
|
|
} else {
|
|
return make_pair(nullptr, 0);
|
|
}
|
|
}
|
|
|
|
virtual const std::unordered_set<uint32_t>& all_unsealable_items() const {
|
|
if constexpr (requires { this->root->unsealable_table; }) {
|
|
if (!this->unsealable_table.has_value()) {
|
|
auto& ret = this->unsealable_table.emplace();
|
|
const auto& co = this->r.pget<ArrayRefT<BE>>(this->root->unsealable_table);
|
|
const auto* defs = &this->r.pget<UnsealableItem>(co.offset, co.count * sizeof(UnsealableItem));
|
|
for (size_t z = 0; z < co.count; z++) {
|
|
ret.emplace(item_code_to_u32(defs[z].item));
|
|
}
|
|
}
|
|
return *this->unsealable_table;
|
|
} else {
|
|
static const std::unordered_set<uint32_t> empty_set{};
|
|
return empty_set;
|
|
}
|
|
}
|
|
|
|
virtual size_t num_ranged_specials() const {
|
|
if constexpr (requires { this->root->ranged_special_table; }) {
|
|
return this->indirect_lookup_2d_count(this->root->ranged_special_table, 0);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
virtual const RangedSpecial& get_ranged_special(size_t index) const {
|
|
if constexpr (requires { this->root->ranged_special_table; }) {
|
|
return this->indirect_lookup_2d<RangedSpecial>(this->root->ranged_special_table, 0, index);
|
|
} else {
|
|
throw std::logic_error("ranged special table not available");
|
|
}
|
|
}
|
|
|
|
const std::set<uint32_t>& all_start_offsets() const {
|
|
if (!this->start_offsets.has_value()) {
|
|
auto& ret = this->start_offsets.emplace();
|
|
ret.emplace(r.size() - 0x20); // REL footer
|
|
ret.emplace(BE ? r.pget_u32b(r.size() - 0x10) : r.pget_u32l(r.size() - 0x10)); // root
|
|
ret.emplace(BE ? r.pget_u32b(r.size() - 0x20) : r.pget_u32l(r.size() - 0x20)); // relocations
|
|
|
|
const auto& footer = r.pget<RELFileFooterT<BE>>(r.size() - sizeof(RELFileFooterT<BE>));
|
|
auto sub_r = r.sub(footer.relocations_offset, footer.num_relocations * sizeof(U16T<BE>));
|
|
uint32_t offset = 0;
|
|
while (!sub_r.eof()) {
|
|
offset += sub_r.template get<U16T<BE>>() * 4;
|
|
ret.emplace(r.pget<U32T<BE>>(offset));
|
|
}
|
|
}
|
|
return *this->start_offsets;
|
|
}
|
|
|
|
size_t get_data_range_size(size_t start_offset) const {
|
|
const auto& offsets = this->all_start_offsets();
|
|
auto it = offsets.lower_bound(start_offset);
|
|
if (it == offsets.end()) {
|
|
throw std::out_of_range("start offset out of range");
|
|
}
|
|
if (*it == start_offset) {
|
|
it++;
|
|
}
|
|
if (it == offsets.end()) {
|
|
throw std::out_of_range("no further offset beyond start offset");
|
|
}
|
|
return *it - start_offset;
|
|
}
|
|
|
|
template <typename T>
|
|
size_t get_data_array_count(size_t start_offset) const {
|
|
return this->get_data_range_size(start_offset) / sizeof(T);
|
|
}
|
|
|
|
protected:
|
|
std::shared_ptr<const std::string> data;
|
|
phosg::StringReader r;
|
|
const RootT* root;
|
|
|
|
mutable std::optional<std::set<uint32_t>> start_offsets;
|
|
|
|
mutable std::unordered_map<uint16_t, Weapon> weapons;
|
|
mutable std::vector<ArmorOrShield> armors;
|
|
mutable std::vector<ArmorOrShield> shields;
|
|
mutable std::vector<Unit> units;
|
|
mutable std::vector<Mag> mags;
|
|
mutable std::unordered_map<uint16_t, Tool> tools;
|
|
|
|
mutable std::vector<Special> specials;
|
|
mutable std::vector<StatBoost> stat_boosts;
|
|
mutable std::vector<PhotonColorEntry> photon_colors;
|
|
mutable std::vector<WeaponRange> weapon_ranges;
|
|
mutable std::vector<WeaponEffect> weapon_effects;
|
|
mutable std::vector<ShieldEffect> shield_effects;
|
|
mutable std::optional<std::unordered_map<uint32_t, SoundRemaps>> sound_remaps;
|
|
mutable std::vector<TechBoost> tech_boosts;
|
|
|
|
// Key is used_item. We can't index on (used_item, equipped_item) because equipped_item may contain wildcards, and
|
|
// the matching order matters.
|
|
mutable std::optional<std::map<uint32_t, std::vector<ItemCombination>>> item_combination_index;
|
|
|
|
mutable std::optional<std::unordered_set<uint32_t>> unsealable_table;
|
|
};
|
|
|
|
using ItemParameterTableDCNTE = BinaryItemParameterTableT<
|
|
RootDCProtos, // typename RootT
|
|
WeaponDCProtos, // typename WeaponT
|
|
0x27, // size_t NumWeaponClasses
|
|
ArmorOrShieldDCProtos, // typename ArmorOrShieldT
|
|
UnitDCProtos, // typename UnitT
|
|
ToolV1V2, // typename ToolT
|
|
0x0D, // size_t NumToolClasses
|
|
MagV1, // typename MagT
|
|
0x22, // size_t ItemStarsFirstID
|
|
0x168, // size_t ItemStarsLastID
|
|
0xAA, // size_t SpecialStarsBeginIndex
|
|
0x28, // size_t NumSpecials
|
|
0x14, // size_t NumPhotonColors
|
|
0x00, // size_t SoundRemapRTTableSize
|
|
false>; // bool BE
|
|
using ItemParameterTableDC112000 = BinaryItemParameterTableT<
|
|
RootDCProtos, // typename RootT
|
|
WeaponDCProtos, // typename WeaponT
|
|
0x27, // size_t NumWeaponClasses
|
|
ArmorOrShieldDCProtos, // typename ArmorOrShieldT
|
|
UnitDCProtos, // typename UnitT
|
|
ToolV1V2, // typename ToolT
|
|
0x0E, // size_t NumToolClasses
|
|
MagV1, // typename MagT
|
|
0x26, // size_t ItemStarsFirstID
|
|
0x16C, // size_t ItemStarsLastID
|
|
0xAE, // size_t SpecialStarsBeginIndex
|
|
0x28, // size_t NumSpecials
|
|
0x14, // size_t NumPhotonColors
|
|
0x00, // size_t SoundRemapRTTableSize
|
|
false>; // bool BE
|
|
using ItemParameterTableV1 = BinaryItemParameterTableT<
|
|
RootV1, // typename RootT
|
|
WeaponV1V2, // typename WeaponT
|
|
0x27, // size_t NumWeaponClasses
|
|
ArmorOrShieldV1V2, // typename ArmorOrShieldT
|
|
UnitV1V2, // typename UnitT
|
|
ToolV1V2, // typename ToolT
|
|
0x0E, // size_t NumToolClasses
|
|
MagV1, // typename MagT
|
|
0x26, // size_t ItemStarsFirstID
|
|
0x16C, // size_t ItemStarsLastID
|
|
0xAE, // size_t SpecialStarsBeginIndex
|
|
0x29, // size_t NumSpecials
|
|
0x14, // size_t NumPhotonColors
|
|
0x00, // size_t SoundRemapRTTableSize
|
|
false>; // bool BE
|
|
using ItemParameterTableV2 = BinaryItemParameterTableT<
|
|
RootV2, // typename RootT
|
|
WeaponV1V2, // typename WeaponT
|
|
0x89, // size_t NumWeaponClasses
|
|
ArmorOrShieldV1V2, // typename ArmorOrShieldT
|
|
UnitV1V2, // typename UnitT
|
|
ToolV1V2, // typename ToolT
|
|
0x10, // size_t NumToolClasses
|
|
MagV2, // typename MagT
|
|
0x4E, // size_t ItemStarsFirstID
|
|
0x215, // size_t ItemStarsLastID
|
|
0x138, // size_t SpecialStarsBeginIndex
|
|
0x29, // size_t NumSpecials
|
|
0x20, // size_t NumPhotonColors
|
|
0x00, // size_t SoundRemapRTTableSize
|
|
false>; // bool BE
|
|
using ItemParameterTableGCNTE = BinaryItemParameterTableT<
|
|
RootGCNTE, // typename RootT
|
|
WeaponGCNTE, // typename WeaponT
|
|
0x8D, // size_t NumWeaponClasses
|
|
ArmorOrShieldGC, // typename ArmorOrShieldT
|
|
UnitGC, // typename UnitT
|
|
ToolGC, // typename ToolT
|
|
0x13, // size_t NumToolClasses
|
|
MagGC, // typename MagT
|
|
0x76, // size_t ItemStarsFirstID
|
|
0x298, // size_t ItemStarsLastID
|
|
0x1A3, // size_t SpecialStarsBeginIndex
|
|
0x29, // size_t NumSpecials
|
|
0x20, // size_t NumPhotonColors
|
|
0x4F, // size_t SoundRemapRTTableSize
|
|
true>; // bool BE
|
|
using ItemParameterTableGC = BinaryItemParameterTableT<
|
|
RootV3V4T<true>, // typename RootT
|
|
WeaponGC, // typename WeaponT
|
|
0xAA, // size_t NumWeaponClasses
|
|
ArmorOrShieldGC, // typename ArmorOrShieldT
|
|
UnitGC, // typename UnitT
|
|
ToolGC, // typename ToolT
|
|
0x18, // size_t NumToolClasses
|
|
MagGC, // typename MagT
|
|
0x94, // size_t ItemStarsFirstID
|
|
0x2F7, // size_t ItemStarsLastID
|
|
0x1CB, // size_t SpecialStarsBeginIndex
|
|
0x29, // size_t NumSpecials
|
|
0x20, // size_t NumPhotonColors
|
|
0x58, // size_t SoundRemapRTTableSize
|
|
true>; // bool BE
|
|
using ItemParameterTableXB = BinaryItemParameterTableT<
|
|
RootV3V4T<false>, // typename RootT
|
|
WeaponXB, // typename WeaponT
|
|
0xAA, // size_t NumWeaponClasses
|
|
ArmorOrShieldXB, // typename ArmorOrShieldT
|
|
UnitXB, // typename UnitT
|
|
ToolXB, // typename ToolT
|
|
0x18, // size_t NumToolClasses
|
|
MagXB, // typename MagT
|
|
0x94, // size_t ItemStarsFirstID
|
|
0x2F7, // size_t ItemStarsLastID
|
|
0x1CB, // size_t SpecialStarsBeginIndex
|
|
0x29, // size_t NumSpecials
|
|
0x20, // size_t NumPhotonColors
|
|
0x58, // size_t SoundRemapRTTableSize
|
|
false>; // bool BE
|
|
using ItemParameterTableV4 = BinaryItemParameterTableT<
|
|
RootV3V4T<false>, // typename RootT
|
|
WeaponV4, // typename WeaponT
|
|
0xED, // size_t NumWeaponClasses
|
|
ArmorOrShieldV4, // typename ArmorOrShieldT
|
|
UnitV4, // typename UnitT
|
|
ToolV4, // typename ToolT
|
|
0x1B, // size_t NumToolClasses
|
|
MagV4, // typename MagT
|
|
0xB1, // size_t ItemStarsFirstID
|
|
0x437, // size_t ItemStarsLastID
|
|
0x256, // size_t SpecialStarsBeginIndex
|
|
0x29, // size_t NumSpecials
|
|
0x20, // size_t NumPhotonColors
|
|
0x6A, // size_t SoundRemapRTTableSize
|
|
false>; // bool BE
|
|
|
|
std::shared_ptr<ItemParameterTable> ItemParameterTable::from_binary(
|
|
std::shared_ptr<const std::string> data, Version version) {
|
|
switch (version) {
|
|
case Version::DC_NTE:
|
|
return std::make_shared<ItemParameterTableDCNTE>(data);
|
|
case Version::DC_11_2000:
|
|
return std::make_shared<ItemParameterTableDC112000>(data);
|
|
case Version::DC_V1:
|
|
return std::make_shared<ItemParameterTableV1>(data);
|
|
case Version::DC_V2:
|
|
case Version::PC_NTE:
|
|
case Version::PC_V2:
|
|
return std::make_shared<ItemParameterTableV2>(data);
|
|
case Version::GC_NTE:
|
|
return std::make_shared<ItemParameterTableGCNTE>(data);
|
|
case Version::GC_V3:
|
|
case Version::GC_EP3:
|
|
case Version::GC_EP3_NTE:
|
|
return std::make_shared<ItemParameterTableGC>(data);
|
|
case Version::XB_V3:
|
|
return std::make_shared<ItemParameterTableXB>(data);
|
|
case Version::BB_V4:
|
|
return std::make_shared<ItemParameterTableV4>(data);
|
|
default:
|
|
throw std::logic_error("Cannot create item parameter table for this version");
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<ItemParameterTable> ItemParameterTable::from_json(const phosg::JSON& json) {
|
|
return std::make_shared<JSONItemParameterTable>(json);
|
|
}
|