Martin Michelsen
308 lines
14 KiB
C++
308 lines
14 KiB
C++
#include "LevelTable.hh"
|
|
|
|
#include <string.h>
|
|
|
|
#include <phosg/Filesystem.hh>
|
|
|
|
#include "CommonFileFormats.hh"
|
|
#include "StaticGameData.hh"
|
|
|
|
using namespace std;
|
|
|
|
void LevelTable::reset_to_base(PlayerStats& stats, uint8_t char_class) const {
|
|
stats.level = 0;
|
|
stats.exp = 0;
|
|
stats.char_stats = this->base_stats_for_class(char_class);
|
|
}
|
|
|
|
void LevelTable::advance_to_level(PlayerStats& stats, uint32_t level, uint8_t char_class) const {
|
|
for (; stats.level < level; stats.level++) {
|
|
const auto& level_stats = this->stats_delta_for_level(char_class, stats.level + 1);
|
|
// The original code clamps the resulting stat values to [0, max_stat]; we don't have max_stat handy so we just
|
|
// allow them to be unbounded
|
|
stats.char_stats.atp += level_stats.atp;
|
|
stats.char_stats.mst += level_stats.mst;
|
|
stats.char_stats.evp += level_stats.evp;
|
|
stats.char_stats.hp += level_stats.hp;
|
|
stats.char_stats.dfp += level_stats.dfp;
|
|
stats.char_stats.ata += level_stats.ata;
|
|
// Note: It is not a bug that lck is ignored here; the original code ignores it too.
|
|
stats.exp = level_stats.exp;
|
|
}
|
|
}
|
|
|
|
phosg::JSON LevelTable::json() const {
|
|
auto base_stats_json = phosg::JSON::list();
|
|
auto max_stats_json = phosg::JSON::list();
|
|
auto level_deltas_json = phosg::JSON::list();
|
|
for (size_t char_class = 0; char_class < this->num_char_classes(); char_class++) {
|
|
base_stats_json.emplace_back(this->base_stats_for_class(char_class).json());
|
|
max_stats_json.emplace_back(this->max_stats_for_class(char_class).json());
|
|
auto this_class_level_deltas_json = phosg::JSON::list();
|
|
for (size_t level = 0; level < 200; level++) {
|
|
this_class_level_deltas_json.emplace_back(this->stats_delta_for_level(char_class, level).json());
|
|
}
|
|
level_deltas_json.emplace_back(std::move(this_class_level_deltas_json));
|
|
}
|
|
return phosg::JSON::dict({
|
|
{"BaseStats", std::move(base_stats_json)},
|
|
{"MaxStats", std::move(max_stats_json)},
|
|
{"LevelDeltas", std::move(level_deltas_json)},
|
|
});
|
|
}
|
|
|
|
JSONLevelTable::JSONLevelTable(const phosg::JSON& json) {
|
|
const auto& base_stats_json = json.at("BaseStats").as_list();
|
|
const auto& max_stats_json = json.at("MaxStats").as_list();
|
|
const auto& level_deltas_json = json.at("LevelDeltas").as_list();
|
|
for (size_t char_class = 0; char_class < base_stats_json.size(); char_class++) {
|
|
this->base_stats.emplace_back(CharacterStats::from_json(*base_stats_json.at(char_class)));
|
|
this->max_stats.emplace_back(PlayerStats::from_json(*max_stats_json.at(char_class)));
|
|
const auto& this_class_level_deltas_json = level_deltas_json.at(char_class)->as_list();
|
|
auto& parsed_deltas = this->level_deltas.emplace_back();
|
|
for (size_t level = 0; level < 200; level++) {
|
|
parsed_deltas[level] = LevelStatsDelta::from_json(*this_class_level_deltas_json.at(level));
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t JSONLevelTable::num_char_classes() const {
|
|
return this->base_stats.size();
|
|
}
|
|
|
|
const CharacterStats& JSONLevelTable::base_stats_for_class(uint8_t char_class) const {
|
|
return this->base_stats.at(char_class);
|
|
}
|
|
|
|
const PlayerStats& JSONLevelTable::max_stats_for_class(uint8_t char_class) const {
|
|
return this->max_stats.at(char_class);
|
|
}
|
|
|
|
const LevelStatsDelta& JSONLevelTable::stats_delta_for_level(uint8_t char_class, uint8_t level) const {
|
|
return this->level_deltas.at(char_class).at(level);
|
|
}
|
|
|
|
LevelTableV2::LevelTableV2(const string& data) {
|
|
struct Root {
|
|
// The overall format of this file on V2 has much more data than we actually use. This table is sorted by the
|
|
// offset in the PlayerTable.prs file; note that the offset fields in this structure do not match that order.
|
|
// ## OFFS WHAT -> TARGET
|
|
// 0008 level_deltas[0] -> LevelStatsDelta[200] (by level) (the rest follow immediately)
|
|
// 00 5468 level_deltas -> u32[9] (by char_class)
|
|
// 04 548C hp_tp_factors -> HPTPFactors[3] (by char_class_class; [0] = hunter, [1] = ranger, [2] = force)
|
|
// 08 54A4 max_stats -> PlayerStats[9] (by char_class)
|
|
// 0C 55E8 level_100_stats -> PlayerStats[9] (by char_class)
|
|
// 572C base_stats[0] -> CharacterStats
|
|
// 10 57AC base_stats -> u32[9] (by char_class)
|
|
// 14 57D0 resist_data -> ResistData[9] (by char_class)
|
|
// 18 58F0 attack_data -> AttackData[9] (by char_class)
|
|
// 1C 5AA0 unknown_a4 -> float[15][3] (by [???][attack_number])
|
|
// 20 5B54 unknown_a5 -> float[3][3] (by [strike_number][attack_number])
|
|
// 24 5B78 unknown_a6 -> float[3][3] (by [strike_number][attack_number]) (may be [4][3] in original code; there are 0xC zero bytes after)
|
|
// 28 5BA8 unknown_a7 -> uint8_t[15][3] (same indexes as unknown_a4)
|
|
// 5BD8 unknown_a9[0] -> UnknownA9[15] (index unknown; appears animation-related)
|
|
// 30 5DF4 unknown_a9 -> u32[3] (by char_class_class)
|
|
// 2C 5E00 area_sound_configs -> AreaSoundConfig[0x12] (by area)
|
|
// 5E90 unknown_a10[0] -> (0x10-byte struct)[0x0C] (the rest follow immediately)
|
|
// 34 60D0 unknown_a10 -> u32[3] (by char_class_class)
|
|
// 60DC unknown_a11[0] -> WeaponReference[12] (the rest follow immediately)
|
|
// 38 616C unknown_a11 -> u32[3] (by char_class_class)
|
|
// 6178 unknown_a12[0] -> UnknownA12[15] (the rest follow immediately)
|
|
// 3C 64FC unknown_a12 -> u32[3] (by char_class_class)
|
|
|
|
/* 00 / 5468 * */ le_uint32_t level_deltas;
|
|
/* 04 / 548C * */ le_uint32_t hp_tp_factors;
|
|
/* 08 / 54A4 * */ le_uint32_t max_stats;
|
|
/* 0C / 55E8 * */ le_uint32_t level_100_stats;
|
|
/* 10 / 57AC * */ le_uint32_t base_stats;
|
|
/* 14 / 57D0 * */ le_uint32_t resist_data;
|
|
/* 18 / 58F0 * */ le_uint32_t attack_data;
|
|
/* 1C / 5AA0 * */ le_uint32_t unknown_a4;
|
|
/* 20 / 5B54 * */ le_uint32_t unknown_a5;
|
|
/* 24 / 5B78 * */ le_uint32_t unknown_a6;
|
|
/* 28 / 5BA8 * */ le_uint32_t unknown_a7;
|
|
/* 2C / 5E00 * */ le_uint32_t area_sound_configs;
|
|
/* 30 / 5DF4 * */ le_uint32_t unknown_a9;
|
|
/* 34 / 60D0 * */ le_uint32_t unknown_a10;
|
|
/* 38 / 616C * */ le_uint32_t unknown_a11;
|
|
/* 3C / 64FC * */ le_uint32_t unknown_a12;
|
|
} __packed_ws__(Root, 0x40);
|
|
|
|
phosg::StringReader r(data);
|
|
|
|
const auto& footer = r.pget<RELFileFooter>(r.size() - sizeof(RELFileFooter));
|
|
const auto& offsets = r.pget<Root>(footer.root_offset);
|
|
const auto& level_deltas_offsets = r.pget<parray<le_uint32_t, 9>>(offsets.level_deltas);
|
|
const auto& base_stats_offsets = r.pget<parray<le_uint32_t, 9>>(offsets.base_stats);
|
|
for (size_t char_class = 0; char_class < 9; char_class++) {
|
|
const auto& src_level_deltas = r.pget<parray<LevelStatsDelta, 200>>(level_deltas_offsets[char_class]);
|
|
for (size_t level = 0; level < 200; level++) {
|
|
this->level_deltas[char_class][level] = src_level_deltas[level];
|
|
}
|
|
this->max_stats[char_class] = r.pget<PlayerStats>(offsets.max_stats + char_class * sizeof(PlayerStats));
|
|
this->base_stats[char_class] = r.pget<CharacterStats>(base_stats_offsets[char_class]);
|
|
}
|
|
}
|
|
|
|
size_t LevelTableV2::num_char_classes() const {
|
|
return 9;
|
|
}
|
|
|
|
const CharacterStats& LevelTableV2::base_stats_for_class(uint8_t char_class) const {
|
|
return this->base_stats.at(char_class);
|
|
}
|
|
|
|
const PlayerStats& LevelTableV2::max_stats_for_class(uint8_t char_class) const {
|
|
return this->max_stats.at(char_class);
|
|
}
|
|
|
|
const LevelStatsDelta& LevelTableV2::stats_delta_for_level(uint8_t char_class, uint8_t level) const {
|
|
return this->level_deltas.at(char_class).at(level);
|
|
}
|
|
|
|
size_t LevelTableV3::num_char_classes() const {
|
|
return 12;
|
|
}
|
|
|
|
const CharacterStats& LevelTableV3::base_stats_for_class(uint8_t char_class) const {
|
|
static const array<CharacterStats, 12> data = {
|
|
// ATP MST EVP HP DFP ATA LCK
|
|
CharacterStats{0x0023, 0x001D, 0x002D, 0x0014, 0x0011, 0x001E, 0x000A},
|
|
CharacterStats{0x001E, 0x0028, 0x003C, 0x0013, 0x0016, 0x0019, 0x000A},
|
|
CharacterStats{0x0023, 0x0000, 0x0023, 0x0016, 0x0012, 0x0023, 0x000A},
|
|
CharacterStats{0x0012, 0x0014, 0x0024, 0x0010, 0x000D, 0x0028, 0x000A},
|
|
CharacterStats{0x0019, 0x0000, 0x001F, 0x0012, 0x0012, 0x002D, 0x000A},
|
|
CharacterStats{0x0014, 0x0000, 0x001F, 0x0011, 0x0017, 0x002D, 0x000A},
|
|
CharacterStats{0x000D, 0x0035, 0x0023, 0x0014, 0x000A, 0x000F, 0x000A},
|
|
CharacterStats{0x000D, 0x003C, 0x0032, 0x0013, 0x0007, 0x000C, 0x000A},
|
|
CharacterStats{0x000A, 0x003A, 0x0035, 0x0013, 0x000D, 0x000A, 0x000A},
|
|
CharacterStats{0x0023, 0x0000, 0x0023, 0x0016, 0x0012, 0x0023, 0x000A},
|
|
CharacterStats{0x000D, 0x0035, 0x0023, 0x0014, 0x000A, 0x000F, 0x000A},
|
|
CharacterStats{0x0012, 0x0014, 0x0024, 0x0010, 0x000D, 0x0028, 0x000A},
|
|
};
|
|
return data.at(char_class);
|
|
}
|
|
|
|
static const array<PlayerStats, 12> max_stats_v3_v4 = {
|
|
// ATP MST EVP HP DFP ATA LCK ESP PRX PRY L E M
|
|
PlayerStats{{0x056B, 0x02DC, 0x02F4, 0x0265, 0x0243, 0x054B, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x04CB, 0x0499, 0x032B, 0x0254, 0x024D, 0x056C, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x065D, 0x0000, 0x0294, 0x0379, 0x0259, 0x0514, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x04E7, 0x0299, 0x02CB, 0x02D5, 0x0203, 0x06CB, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x0541, 0x0000, 0x02BB, 0x0430, 0x025E, 0x05FA, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x0492, 0x0000, 0x0313, 0x0439, 0x02B0, 0x062C, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x0365, 0x0504, 0x024C, 0x0302, 0x01F2, 0x0440, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x032B, 0x05DC, 0x02A7, 0x02E3, 0x01CF, 0x04B0, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x0244, 0x06D6, 0x0373, 0x02BE, 0x0186, 0x04EC, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x050B, 0x0000, 0x036D, 0x02EE, 0x020D, 0x05DC, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x03E7, 0x053C, 0x028B, 0x02CC, 0x01D6, 0x03F2, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
PlayerStats{{0x0474, 0x0407, 0x0384, 0x02CF, 0x0241, 0x06C2, 0x0064}, 0x0064, 0.0f, 0.0f, 0, 0, 0},
|
|
};
|
|
|
|
const PlayerStats& LevelTableV3::max_stats_for_class(uint8_t char_class) const {
|
|
return max_stats_v3_v4.at(char_class);
|
|
}
|
|
|
|
const LevelStatsDelta& LevelTableV3::stats_delta_for_level(uint8_t char_class, uint8_t level) const {
|
|
return this->level_deltas.at(char_class).at(level);
|
|
}
|
|
|
|
template <bool BE>
|
|
void parse_level_deltas_t(std::array<std::array<LevelStatsDelta, 200>, 12>& deltas, const string& data) {
|
|
// The V3 format is very simple:
|
|
// root:
|
|
// u32 offset:
|
|
// u32[12] offsets:
|
|
// LevelStatsDeltaBE[200] level_deltas
|
|
phosg::StringReader r(data);
|
|
const auto& footer = r.pget<RELFileFooterT<BE>>(r.size() - sizeof(RELFileFooterT<BE>));
|
|
const auto& offsets = r.pget<parray<U32T<BE>, 12>>(r.pget<U32T<BE>>(footer.root_offset));
|
|
for (size_t char_class = 0; char_class < 12; char_class++) {
|
|
const auto& src_deltas = r.pget<parray<LevelStatsDeltaT<BE>, 200>>(offsets[char_class]);
|
|
for (size_t level = 0; level < 200; level++) {
|
|
deltas[char_class][level] = src_deltas[level];
|
|
}
|
|
}
|
|
}
|
|
|
|
LevelTableGC::LevelTableGC(const string& data) {
|
|
parse_level_deltas_t<true>(this->level_deltas, data);
|
|
}
|
|
|
|
LevelTableXB::LevelTableXB(const string& data) {
|
|
parse_level_deltas_t<false>(this->level_deltas, data);
|
|
}
|
|
|
|
struct RootV4 {
|
|
le_uint32_t base_stats; // -> u32[12] -> CharacterStats
|
|
le_uint32_t level_deltas; // -> u32[12] -> LevelStatsDelta[200]
|
|
} __packed_ws__(RootV4, 8);
|
|
|
|
std::string LevelTable::serialize_binary_v4() const {
|
|
RELFileWriter<false> rel;
|
|
RootV4 root;
|
|
|
|
{
|
|
std::vector<uint32_t> offsets;
|
|
for (size_t char_class = 0; char_class < this->num_char_classes(); char_class++) {
|
|
offsets.emplace_back(rel.put<CharacterStats>(this->base_stats_for_class(char_class)));
|
|
}
|
|
root.base_stats = rel.w.size();
|
|
for (uint32_t offset : offsets) {
|
|
rel.write_offset(offset);
|
|
}
|
|
}
|
|
|
|
{
|
|
std::vector<uint32_t> offsets;
|
|
for (size_t char_class = 0; char_class < this->num_char_classes(); char_class++) {
|
|
offsets.emplace_back(rel.w.size());
|
|
for (size_t level = 0; level < 200; level++) {
|
|
rel.put<LevelStatsDelta>(this->stats_delta_for_level(char_class, level));
|
|
}
|
|
}
|
|
root.level_deltas = rel.w.size();
|
|
for (uint32_t offset : offsets) {
|
|
rel.write_offset(offset);
|
|
}
|
|
}
|
|
|
|
size_t root_offset = rel.put<RootV4>(root);
|
|
rel.relocations.emplace(root_offset);
|
|
rel.relocations.emplace(root_offset + 4);
|
|
|
|
return rel.finalize(root_offset);
|
|
}
|
|
|
|
LevelTableV4::LevelTableV4(const string& data) {
|
|
|
|
phosg::StringReader r(data);
|
|
const auto& footer = r.pget<RELFileFooter>(r.size() - sizeof(RELFileFooter));
|
|
const auto& offsets = r.pget<RootV4>(footer.root_offset);
|
|
const auto& level_deltas_offsets = r.pget<parray<le_uint32_t, 12>>(offsets.level_deltas);
|
|
const auto& base_stats_offsets = r.pget<parray<le_uint32_t, 12>>(offsets.base_stats);
|
|
for (size_t char_class = 0; char_class < 12; char_class++) {
|
|
const auto& src_level_deltas = r.pget<parray<LevelStatsDelta, 200>>(level_deltas_offsets[char_class]);
|
|
for (size_t level = 0; level < 200; level++) {
|
|
this->level_deltas[char_class][level] = src_level_deltas[level];
|
|
}
|
|
this->base_stats[char_class] = r.pget<CharacterStats>(base_stats_offsets[char_class]);
|
|
}
|
|
}
|
|
|
|
size_t LevelTableV4::num_char_classes() const {
|
|
return 12;
|
|
}
|
|
|
|
const CharacterStats& LevelTableV4::base_stats_for_class(uint8_t char_class) const {
|
|
return this->base_stats.at(char_class);
|
|
}
|
|
|
|
const PlayerStats& LevelTableV4::max_stats_for_class(uint8_t char_class) const {
|
|
return max_stats_v3_v4.at(char_class);
|
|
}
|
|
|
|
const LevelStatsDelta& LevelTableV4::stats_delta_for_level(uint8_t char_class, uint8_t level) const {
|
|
return this->level_deltas.at(char_class).at(level);
|
|
}
|