incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1c3e8ca53c37b977b45194a0b4ae775260fc2741
psopeeps-newserv/src/ItemParameterTable.cc
T
Martin Michelsen 6b636c4694 rewrite MagEvolutionTable
2026-05-02 10:48:22 -07:00

1419 lines
52 KiB
C++
Raw Blame History

#include "ItemParameterTable.hh"
#include "CommonFileFormats.hh"
using namespace std;
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");
}
}
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 = 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 = this->tech_boost;
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 = 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 = this->tech_boost;
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 = 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 = this->tech_boost;
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;
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 TechniqueBoostEntryT {
uint8_t tech_num = 0;
uint8_t flags = 0;
parray<uint8_t, 2> unused;
F32T<BE> amount = 0.0f;
operator ItemParameterTable::TechniqueBoost() const {
return {this->tech_num, this->flags, this->amount};
}
} __packed_ws_be__(TechniqueBoostEntryT, 8);
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 UnknownA5T {
U32T<BE> target_param;
U32T<BE> unknown_a2;
U32T<BE> unknown_a3;
operator ItemParameterTable::UnknownA5() const {
return {this->target_param, this->unknown_a2, this->unknown_a3};
}
} __packed_ws_be__(UnknownA5T, 0x0C);
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 WeaponEffect {
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__(WeaponEffect, 0x20);
/* The fields in the root structure are:
* DCTE / 112K / V1 / V2 / GCTE / V3 / V4
* 0013 / 0013 / 0013 / 0013 / / / entry_count // Count of pointers in root struct; unused
* 0668 / 0668 / / / / / armor_stat_boost_index_table // -> [uint8_t]
* 2D94 / 2E28 / 3258 / 5A5C / 6E4C / EF90 / 1478C armor_table // -> [{count, offset -> [ArmorOrShieldV*]}](2; armors and shields)
* / / / / 737C / F5D0 / 14FF4 combination_table // -> {count, offset -> [ItemCombination]}
* 2F54 / 2FF0 / 3420 / 5F4C / 7384 / F608 / 1502C mag_feed_table // -> MagFeedResultsTable
* 2DAC / 2E40 / 3270 / 5A74 / 6E64 / EFA8 / 147A4 mag_table // -> {count, offset -> [MagV*]}
* / / / / 69D8 / DF88 / 12894 max_tech_level_table // -> MaxTechniqueLevels
* 1FE6 / 207A / 248C / 40A8 / 4A80 / BBCC / 0F83C non_weapon_sale_divisor_table // -> NonWeaponSaleDivisors
* 1994 / 1A28 / 1DB0 / 2E4C / 37A4 / A7FC / 0DE7C photon_color_table // -> PhotonColorEntry[...]
* / / / / / F600 / 15024 ranged_special_table // -> {count, offset -> [RangedSpecial]}
* / / 3198 / 5704 / 61B8 / D6E4 / 11C80 shield_effect_table // -> ShieldEffect[...] (indexed by data1[2])
* 030C / 030C / / / / / shield_stat_boost_index_table // -> [uint8_t]
* 275E / 27F4 / 2C12 / 4540 / 4F72 / C100 / 0FE3C special_table // -> [Special]
* 22A9 / 233D / 275C / 4378 / 4D50 / BE9C / 0FB0C star_value_table // -> [uint8_t] (indexed by .id from weapon, armor, etc.)
* 2CE4 / 2D78 / 2CB8 / 58DC / 68B8 / DE50 / 1275C stat_boost_table // -> [StatBoost]
* / / / / 6B1C / EB8C / 14278 tech_boost_table // -> [TechniqueBoostEntry[3]]
* 2DB4 / 2E48 / 3278 / 5A7C / 6E6C / EFB0 / 147AC tool_table // -> [{count, offset -> [ToolV*]}] (last if out of range)
* 2DA4 / 2E38 / 3268 / 5A6C / 6E5C / EFA0 / 1479C unit_table // -> {count, offset -> [UnitV*]} (last if out of range)
* 23EE / 2484 / 28A2 / 45E4 / / / unknown_a1 // TODO
* / / / / 68B0 / DE48 / 12754 unknown_a5 // -> {count, offset -> [UnknownA5]}
* / / / / / F5F8 / 1501C unsealable_table // -> {count, offset -> [UnsealableItem]}
* / / / / / F5F0 / 15014 unwrap_table // -> {count, offset -> [{count, offset -> [EventItem]}]}
* 1F98 / 202C / 23C8 / 3DF8 / 47BC / B88C / 0F4B8 weapon_class_table // -> [uint8_t](0x89)
* 2804 / 2898 / / / 5018 / C1A4 / 0FEE0 weapon_effect_table // -> [WeaponEffect]
* 1C64 / 1CF8 / 2080 / 32CC / 3A74 / AACC / 0E194 weapon_range_table // -> WeaponRange[...]
* 1FBF / 2053 / 23F0 / 3E84 / 484C / B938 / 0F5A8 weapon_sale_divisor_table // -> [uint8_t] on DC protos; [float] on all other versions
* 1908 / 199C / / / / / weapon_stat_boost_index_table // -> [StatBoost]
* 2E1C / 2EB8 / 32E8 / 5AFC / 6F0C / F078 / 14884 weapon_table // -> [{count, offset -> [WeaponV*]}]
*/
struct RootDCProtos {
/* 00 */ le_uint32_t entry_count;
/* 04 */ le_uint32_t weapon_table;
/* 08 */ le_uint32_t armor_table;
/* 0C */ le_uint32_t unit_table;
/* 10 */ le_uint32_t tool_table;
/* 14 */ le_uint32_t mag_table;
/* 18 */ le_uint32_t weapon_class_table;
/* 1C */ le_uint32_t photon_color_table;
/* 20 */ le_uint32_t weapon_range_table;
/* 24 */ le_uint32_t weapon_integral_sale_divisor_table;
/* 28 */ le_uint32_t non_weapon_integral_sale_divisor_table;
/* 2C */ le_uint32_t mag_feed_table;
/* 30 */ le_uint32_t star_value_table;
/* 34 */ le_uint32_t unknown_a1;
/* 38 */ le_uint32_t special_table;
/* 3C */ le_uint32_t weapon_effect_table;
/* 40 */ le_uint32_t weapon_stat_boost_index_table;
/* 44 */ le_uint32_t armor_stat_boost_index_table;
/* 48 */ le_uint32_t shield_stat_boost_index_table;
/* 4C */ le_uint32_t stat_boost_table;
} __packed_ws__(RootDCProtos, 0x50);
struct RootV1V2 {
/* 00 */ le_uint32_t entry_count;
/* 04 */ le_uint32_t weapon_table;
/* 08 */ le_uint32_t armor_table;
/* 0C */ le_uint32_t unit_table;
/* 10 */ le_uint32_t tool_table;
/* 14 */ le_uint32_t mag_table;
/* 18 */ le_uint32_t weapon_class_table;
/* 1C */ le_uint32_t photon_color_table;
/* 20 */ le_uint32_t weapon_range_table;
/* 24 */ le_uint32_t weapon_sale_divisor_table;
/* 28 */ le_uint32_t non_weapon_sale_divisor_table;
/* 2C */ le_uint32_t mag_feed_table;
/* 30 */ le_uint32_t star_value_table;
/* 34 */ le_uint32_t unknown_a1;
/* 38 */ le_uint32_t special_table;
/* 3C */ le_uint32_t stat_boost_table;
/* 40 */ le_uint32_t shield_effect_table;
} __packed_ws__(RootV1V2, 0x44);
struct RootGCNTE {
/* 00 */ be_uint32_t weapon_table;
/* 04 */ be_uint32_t armor_table;
/* 08 */ be_uint32_t unit_table;
/* 0C */ be_uint32_t tool_table;
/* 10 */ be_uint32_t mag_table;
/* 14 */ be_uint32_t weapon_class_table;
/* 18 */ be_uint32_t photon_color_table;
/* 1C */ be_uint32_t weapon_range_table;
/* 20 */ be_uint32_t weapon_sale_divisor_table;
/* 24 */ be_uint32_t non_weapon_sale_divisor_table;
/* 28 */ be_uint32_t mag_feed_table;
/* 2C */ be_uint32_t star_value_table;
/* 30 */ be_uint32_t special_table;
/* 34 */ be_uint32_t weapon_effect_table;
/* 38 */ be_uint32_t stat_boost_table;
/* 3C */ be_uint32_t shield_effect_table;
/* 40 */ be_uint32_t max_tech_level_table;
/* 44 */ be_uint32_t combination_table;
/* 48 */ be_uint32_t unknown_a5;
/* 4C */ be_uint32_t tech_boost_table;
} __packed_ws__(RootGCNTE, 0x50);
template <bool BE>
struct RootV3V4T {
/* 00 */ U32T<BE> weapon_table;
/* 04 */ U32T<BE> armor_table;
/* 08 */ U32T<BE> unit_table;
/* 0C */ U32T<BE> tool_table;
/* 10 */ U32T<BE> mag_table;
/* 14 */ U32T<BE> weapon_class_table;
/* 18 */ U32T<BE> photon_color_table;
/* 1C */ U32T<BE> weapon_range_table;
/* 20 */ U32T<BE> weapon_sale_divisor_table;
/* 24 */ U32T<BE> non_weapon_sale_divisor_table;
/* 28 */ U32T<BE> mag_feed_table;
/* 2C */ U32T<BE> star_value_table;
/* 30 */ U32T<BE> special_table;
/* 34 */ U32T<BE> weapon_effect_table;
/* 38 */ U32T<BE> stat_boost_table;
/* 3C */ U32T<BE> shield_effect_table;
/* 40 */ U32T<BE> max_tech_level_table;
/* 44 */ U32T<BE> combination_table;
/* 48 */ U32T<BE> unknown_a5;
/* 4C */ U32T<BE> tech_boost_table;
/* 50 */ U32T<BE> unwrap_table;
/* 54 */ U32T<BE> unsealable_table;
/* 58 */ U32T<BE> ranged_special_table;
} __packed_ws_be__(RootV3V4T, 0x5C);
ItemParameterTable::ItemParameterTable(std::shared_ptr<const std::string> data)
: data(data), r(*this->data) {}
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);
}
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(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->get_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::get_all_combinations_for_used_item(
const ItemData& used_item) const {
try {
uint32_t key = (used_item.data1[0] << 16) | (used_item.data1[1] << 8) | used_item.data1[2];
return this->get_all_item_combinations().at(key);
} 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(item.data1[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(item.data1[0], 3);
}
double sale_divisor = (double)this->get_sale_divisor(item.data1[0], 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,
bool BE>
class ItemParameterTableT : public ItemParameterTable {
public:
explicit ItemParameterTableT(std::shared_ptr<const std::string> data)
: ItemParameterTable(data),
root(&this->r.pget<RootT>(BE ? r.pget_u32b(r.size() - 0x10) : r.pget_u32l(r.size() - 0x10))) {}
~ItemParameterTableT() = 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);
}
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;
while (vec.size() <= data1_2) {
vec.emplace_back(this->indirect_lookup_2d<ArmorOrShieldT>(this->root->armor_table, data1_1 - 1, vec.size()));
}
return vec[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 {
while (this->units.size() <= data1_2) {
this->units.emplace_back(this->indirect_lookup_2d<UnitT>(this->root->unit_table, 0, this->units.size()));
}
return this->units[data1_2];
}
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 {
while (this->mags.size() <= data1_1) {
this->mags.emplace_back(this->indirect_lookup_2d<MagT>(this->root->mag_table, 0, data1_1));
}
return this->mags[data1_1];
}
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 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 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 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 const StatBoost& get_stat_boost(uint8_t entry_index) const {
while (this->stat_boosts.size() <= entry_index) {
this->stat_boosts.emplace_back(this->r.pget<StatBoostT<BE>>(
this->root->stat_boost_table + sizeof(StatBoostT<BE>) * this->stat_boosts.size()));
}
return this->stat_boosts[entry_index];
}
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 uint8_t get_weapon_class(uint8_t data1_1) const {
return (data1_1 < NumWeaponClasses) ? this->r.pget_u8(this->root->weapon_class_table + data1_1) : 0x00;
}
virtual bool is_unsealable_item(uint8_t data1_0, uint8_t data1_1, uint8_t data1_2) const {
if constexpr (requires { this->root->unsealable_table; }) {
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++) {
if ((defs[z].item[0] == data1_0) && (defs[z].item[1] == data1_1) && (defs[z].item[2] == data1_2)) {
return true;
}
}
}
return false;
}
virtual const std::map<uint32_t, std::vector<ItemCombination>>& get_all_item_combinations() const {
if constexpr (requires { this->root->combination_table; }) {
if (this->item_combination_index.empty()) {
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++) {
const auto& def = defs[z];
uint32_t key = (def.used_item[0] << 16) | (def.used_item[1] << 8) | def.used_item[2];
this->item_combination_index[key].emplace_back(def);
}
}
return this->item_combination_index;
}
static const std::map<uint32_t, std::vector<ItemParameterTable::ItemCombination>> empty_map;
return empty_map;
}
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);
}
}
protected:
const RootT* root;
};
using ItemParameterTableDCNTE = ItemParameterTableT<
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
false>; // bool BE
using ItemParameterTableDC112000 = ItemParameterTableT<
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
false>; // bool BE
using ItemParameterTableV1 = ItemParameterTableT<
RootV1V2, // 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
false>; // bool BE
using ItemParameterTableV2 = ItemParameterTableT<
RootV1V2, // 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
false>; // bool BE
using ItemParameterTableGCNTE = ItemParameterTableT<
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
true>; // bool BE
using ItemParameterTableGC = ItemParameterTableT<
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
true>; // bool BE
using ItemParameterTableXB = ItemParameterTableT<
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
false>; // bool BE
using ItemParameterTableV4 = ItemParameterTableT<
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
false>; // bool BE
std::shared_ptr<ItemParameterTable> ItemParameterTable::create(
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");
}
}
Reference in New Issue View Git Blame Copy Permalink