Martin Michelsen
694 lines
27 KiB
C++
694 lines
27 KiB
C++
#include "Map.hh"
|
|
|
|
#include <phosg/Filesystem.hh>
|
|
#include <phosg/Strings.hh>
|
|
|
|
#include "Loggers.hh"
|
|
|
|
using namespace std;
|
|
|
|
|
|
|
|
BattleParamsIndex::BattleParamsIndex(
|
|
shared_ptr<const string> data_on_ep1,
|
|
shared_ptr<const string> data_on_ep2,
|
|
shared_ptr<const string> data_on_ep4,
|
|
shared_ptr<const string> data_off_ep1,
|
|
shared_ptr<const string> data_off_ep2,
|
|
shared_ptr<const string> data_off_ep4) {
|
|
this->files[0][0].data = data_on_ep1;
|
|
this->files[0][1].data = data_on_ep2;
|
|
this->files[0][2].data = data_on_ep4;
|
|
this->files[1][0].data = data_off_ep1;
|
|
this->files[1][1].data = data_off_ep2;
|
|
this->files[1][2].data = data_off_ep4;
|
|
|
|
for (uint8_t is_solo = 0; is_solo < 2; is_solo++) {
|
|
for (uint8_t episode = 0; episode < 3; episode++) {
|
|
auto& file = this->files[is_solo][episode];
|
|
if (file.data->size() < sizeof(Table)) {
|
|
throw runtime_error(string_printf(
|
|
"battle params table size is incorrect (expected %zX bytes, have %zX bytes; is_solo=%hhu, episode=%hhu)",
|
|
sizeof(Table), file.data->size(), is_solo, episode));
|
|
}
|
|
file.table = reinterpret_cast<const Table*>(file.data->data());
|
|
}
|
|
}
|
|
}
|
|
|
|
const BattleParamsIndex::Entry& BattleParamsIndex::get(
|
|
bool solo, uint8_t episode, uint8_t difficulty, uint8_t monster_type) const {
|
|
if (episode > 3) {
|
|
throw invalid_argument("incorrect episode");
|
|
}
|
|
if (difficulty > 4) {
|
|
throw invalid_argument("incorrect difficulty");
|
|
}
|
|
if (monster_type > 0x60) {
|
|
throw invalid_argument("incorrect monster type");
|
|
}
|
|
return this->files[!!solo][episode].table->difficulty[difficulty][monster_type];
|
|
}
|
|
|
|
|
|
|
|
PSOEnemy::PSOEnemy(uint64_t id) : PSOEnemy(id, 0, 0, 0, "__missing__") { }
|
|
|
|
PSOEnemy::PSOEnemy(
|
|
uint64_t id,
|
|
uint16_t source_type,
|
|
uint32_t experience,
|
|
uint32_t rt_index,
|
|
const char* type_name)
|
|
: id(id),
|
|
source_type(source_type),
|
|
hit_flags(0),
|
|
last_hit(0),
|
|
experience(experience),
|
|
rt_index(rt_index),
|
|
type_name(type_name) { }
|
|
|
|
string PSOEnemy::str() const {
|
|
return string_printf("[Enemy E-%" PRIX64 " \"%s\" source_type=%hX hit=%02hhX/%hu exp=%" PRIu32 " rt_index=%" PRIX32 "]",
|
|
this->id, this->type_name, this->source_type, this->hit_flags, this->last_hit, this->experience, this->rt_index);
|
|
}
|
|
|
|
|
|
|
|
struct EnemyEntry {
|
|
uint32_t base;
|
|
uint16_t reserved0;
|
|
uint16_t num_clones;
|
|
uint32_t reserved[11];
|
|
float reserved12;
|
|
uint32_t reserved13;
|
|
uint32_t reserved14;
|
|
uint32_t skin;
|
|
uint32_t reserved15;
|
|
} __attribute__((packed));
|
|
|
|
static uint64_t next_enemy_id = 1;
|
|
|
|
vector<PSOEnemy> parse_map(
|
|
shared_ptr<const BattleParamsIndex> battle_params,
|
|
bool is_solo,
|
|
uint8_t episode,
|
|
uint8_t difficulty,
|
|
shared_ptr<const string> data,
|
|
bool alt_enemies) {
|
|
|
|
const auto* map = reinterpret_cast<const EnemyEntry*>(data->data());
|
|
size_t entry_count = data->size() / sizeof(EnemyEntry);
|
|
if (data->size() != entry_count * sizeof(EnemyEntry)) {
|
|
throw runtime_error("data size is not a multiple of entry size");
|
|
}
|
|
|
|
vector<PSOEnemy> enemies;
|
|
auto create_clones = [&](size_t count) {
|
|
for (; count > 0; count--) {
|
|
enemies.emplace_back(next_enemy_id++);
|
|
}
|
|
};
|
|
|
|
auto get_battle_params = [&](uint8_t type) -> const BattleParamsIndex::Entry& {
|
|
return battle_params->get(is_solo, episode, difficulty, type);
|
|
};
|
|
|
|
for (size_t y = 0; y < entry_count; y++) {
|
|
const auto& e = map[y];
|
|
size_t num_clones = e.num_clones;
|
|
|
|
switch (e.base) {
|
|
case 0x40: // Hildebear and Hildetorr
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x49 + (e.skin & 0x01)).experience,
|
|
0x01 + (e.skin & 0x01), "Hilde(bear|torr)");
|
|
break;
|
|
case 0x41: // Rappies
|
|
if (episode == 3) { // Del Rappy and Sand Rappy
|
|
if (alt_enemies) {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x17 + (e.skin & 0x01)).experience,
|
|
17 + (e.skin & 0x01), "(Del|Sand) Rappy");
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x05 + (e.skin & 0x01)).experience,
|
|
17 + (e.skin & 0x01), "(Del|Sand) Rappy");
|
|
}
|
|
} else { // Rag Rappy and Al Rappy (Love for Episode II)
|
|
if (e.skin & 0x01) {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x18 + (e.skin & 0x01)).experience,
|
|
0xFF, "Rare Rappy"); // Don't know (yet) which rare Rappy it is
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x18 + (e.skin & 0x01)).experience,
|
|
5, "Rag Rappy");
|
|
}
|
|
}
|
|
break;
|
|
case 0x42: // Monest + 30 Mothmants
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x01).experience, 4, "Monest");
|
|
for (size_t x = 0; x < 30; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x00).experience, 3, "Mothmant");
|
|
}
|
|
break;
|
|
case 0x43: // Savage Wolf and Barbarous Wolf
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x02 + ((e.reserved[10] & 0x800000) ? 1 : 0)).experience,
|
|
7 + ((e.reserved[10] & 0x800000) ? 1 : 0), "(Savage|Barbarous) Wolf");
|
|
break;
|
|
case 0x44: // Booma family
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x4B + (e.skin % 3)).experience,
|
|
9 + (e.skin % 3), "(|Go|Gigo)Booma");
|
|
break;
|
|
case 0x60: // Grass Assassin
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x4E).experience, 12, "Grass Assassin");
|
|
break;
|
|
case 0x61: // Del Lily, Poison Lily, Nar Lily
|
|
if ((episode == 2) && (alt_enemies)) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x25).experience, 83, "Del Lily");
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x04 + ((e.reserved[10] & 0x800000) ? 1 : 0)).experience,
|
|
13 + ((e.reserved[10] & 0x800000) ? 1 : 0), "(Poison|Nar) Lily");
|
|
}
|
|
break;
|
|
case 0x62: // Nano Dragon
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1A).experience, 15, "Nano Dragon");
|
|
break;
|
|
case 0x63: // Shark family
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x4F + (e.skin % 3)).experience,
|
|
16 + (e.skin % 3), "(Evil|Pal|Guil) Shark");
|
|
break;
|
|
case 0x64: // Slime + 4 clones
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x2F + ((e.reserved[10] & 0x800000) ? 0 : 1)).experience,
|
|
19 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Pof?uilly Slime");
|
|
for (size_t x = 0; x < 4; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x30).experience, 19, "Pof?uilly Slime clone");
|
|
}
|
|
break;
|
|
case 0x65: // Pan Arms, Migium, Hidoom
|
|
for (size_t x = 0; x < 3; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x31 + x).experience, 21 + x, "(Pan Arms|Hidoom|Migium)");
|
|
}
|
|
break;
|
|
case 0x80: // Dubchic and Gillchic
|
|
if (e.skin & 0x01) {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x1B + (e.skin & 0x01)).experience, 50, "(Dub|Gill)chic");
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x1B + (e.skin & 0x01)).experience, 24, "(Dub|Gill)chic");
|
|
}
|
|
break;
|
|
case 0x81: // Garanz
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1D).experience, 25, "Garanz");
|
|
break;
|
|
case 0x82: // Sinow Beat and Gold
|
|
if (e.reserved[10] & 0x800000) {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x13).experience,
|
|
26 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Sinow (Beat|Gold)");
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x06).experience,
|
|
26 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Sinow (Beat|Gold)");
|
|
}
|
|
if (e.num_clones == 0) {
|
|
create_clones(4);
|
|
}
|
|
break;
|
|
case 0x83: // Canadine
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x07).experience, 28, "Canadine");
|
|
break;
|
|
case 0x84: // Canadine Group
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x09).experience, 29, "Canune");
|
|
for (size_t x = 0; x < 8; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x08).experience, 28, "Canadine");
|
|
}
|
|
break;
|
|
case 0x85: // Dubwitch
|
|
break;
|
|
case 0xA0: // Delsaber
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x52).experience, 30, "Delsaber");
|
|
break;
|
|
case 0xA1: // Chaos Sorcerer + 2 Bits
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x0A).experience, 31, "Chaos Sorcerer");
|
|
create_clones(2);
|
|
break;
|
|
case 0xA2: // Dark Gunner
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1E).experience, 34, "Dark Gunner");
|
|
break;
|
|
case 0xA4: // Chaos Bringer
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x0D).experience, 36, "Chaos Bringer");
|
|
break;
|
|
case 0xA5: // Dark Belra
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x0E).experience, 37, "Dark Belra");
|
|
break;
|
|
case 0xA6: // Dimenian family
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x53 + (e.skin % 3)).experience, 41 + (e.skin % 3), "(|La|So) Dimenian");
|
|
break;
|
|
case 0xA7: // Bulclaw + 4 claws
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1F).experience, 40, "Bulclaw");
|
|
for (size_t x = 0; x < 4; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x20).experience, 38, "Claw");
|
|
}
|
|
break;
|
|
case 0xA8: // Claw
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x20).experience, 38, "Claw");
|
|
break;
|
|
case 0xC0: // Dragon or Gal Gryphon
|
|
if (episode == 1) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x12).experience, 44, "Dragon");
|
|
} else if (episode == 2) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1E).experience, 77, "Gal Gryphon");
|
|
}
|
|
break;
|
|
case 0xC1: // De Rol Le
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x0F).experience, 45, "De Rol Le");
|
|
break;
|
|
case 0xC2: // Vol Opt form 1
|
|
break;
|
|
case 0xC5: // Vol Opt form 2
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x25).experience, 46, "Vol Opt");
|
|
break;
|
|
case 0xC8: // Dark Falz + 510 Helpers
|
|
if (difficulty) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x38).experience, 47, "Dark Falz 3"); // Final form
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x37).experience, 47, "Dark Falz 2"); // Second form
|
|
}
|
|
for (size_t x = 0; x < 510; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x35).experience, 0, "Darvant");
|
|
}
|
|
break;
|
|
case 0xCA: // Olga Flow
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x2C).experience, 78, "Olga Flow");
|
|
create_clones(0x200);
|
|
break;
|
|
case 0xCB: // Barba Ray
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x0F).experience, 73, "Barba Ray");
|
|
create_clones(0x2F);
|
|
break;
|
|
case 0xCC: // Gol Dragon
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x12).experience, 76, "Gol Dragon");
|
|
create_clones(5);
|
|
break;
|
|
case 0xD4: // Sinows Berill & Spigell
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params((e.reserved[10] & 0x800000) ? 0x13 : 0x06).experience,
|
|
62 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Sinow (Berrill|Spigell)");
|
|
create_clones(4);
|
|
break;
|
|
case 0xD5: // Merillia & Meriltas
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x4B + (e.skin & 0x01)).experience,
|
|
52 + (e.skin & 0x01), "Meril(lia|tas)");
|
|
break;
|
|
case 0xD6: // Mericus, Merikle, & Mericarol
|
|
if (e.skin) {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x44 + (e.skin % 3)).experience, 56 + (e.skin % 3), "Meri(cus|kle|carol)");
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x3A).experience, 56 + (e.skin % 3), "Meri(cus|kle|carol)");
|
|
}
|
|
break;
|
|
case 0xD7: // Ul Gibbon and Zol Gibbon
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x3B + (e.skin & 0x01)).experience,
|
|
59 + (e.skin & 0x01), "(Ul|Zol) Gibbon");
|
|
break;
|
|
case 0xD8: // Gibbles
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x3D).experience, 61, "Gibbles");
|
|
break;
|
|
case 0xD9: // Gee
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x07).experience, 54, "Gee");
|
|
break;
|
|
case 0xDA: // Gi Gue
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1A).experience, 55, "Gi Gue");
|
|
break;
|
|
case 0xDB: // Deldepth
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x30).experience, 71, "Deldepth");
|
|
break;
|
|
case 0xDC: // Delbiter
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x0D).experience, 72, "Delbiter");
|
|
break;
|
|
case 0xDD: // Dolmolm and Dolmdarl
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x4F + (e.skin & 0x01)).experience,
|
|
64 + (e.skin & 0x01), "Dolm(olm|darl)");
|
|
break;
|
|
case 0xDE: // Morfos
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x40).experience, 66, "Morfos");
|
|
break;
|
|
case 0xDF: // Recobox & Recons
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x41).experience, 67, "Recobox");
|
|
for (size_t x = 0; x < e.num_clones; x++) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x42).experience, 68, "Recon");
|
|
}
|
|
break;
|
|
case 0xE0: // Epsilon, Sinow Zoa and Zele
|
|
if ((episode == 2) && (alt_enemies)) {
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x23).experience, 84, "Epsilon");
|
|
create_clones(4);
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x43 + (e.skin & 0x01)).experience,
|
|
69 + (e.skin & 0x01), "Sinow Z(oa|ele)");
|
|
}
|
|
break;
|
|
case 0xE1: // Ill Gill
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x26).experience, 82, "Ill Gill");
|
|
break;
|
|
case 0x0110: // Astark
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x09).experience, 1, "Astark");
|
|
break;
|
|
case 0x0111: // Satellite Lizard and Yowie
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x0D + ((e.reserved[10] & 0x800000) ? 1 : 0) + (alt_enemies ? 0x10 : 0)).experience,
|
|
2 + ((e.reserved[10] & 0x800000) ? 0 : 1), "(Satellite Lizard|Yowie)");
|
|
break;
|
|
case 0x0112: // Merissa A/AA
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x19 + (e.skin & 0x01)).experience,
|
|
4 + (e.skin & 0x01), "Merissa AA?");
|
|
break;
|
|
case 0x0113: // Girtablulu
|
|
enemies.emplace_back(next_enemy_id++, e.base, get_battle_params(0x1F).experience, 6, "Girtablulu");
|
|
break;
|
|
case 0x0114: // Zu and Pazuzu
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x0B + (e.skin & 0x01) + (alt_enemies ? 0x14: 0x00)).experience,
|
|
7 + (e.skin & 0x01), "(Pazu)?zu");
|
|
break;
|
|
case 0x0115: // Boota family
|
|
if (e.skin & 2) {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x03).experience, 9 + (e.skin % 3), "(|Ba|Ze) Boota");
|
|
} else {
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x00 + (e.skin % 3)).experience,
|
|
9 + (e.skin % 3), "(|Ba|Ze) Boota");
|
|
}
|
|
break;
|
|
case 0x0116: // Dorphon and Eclair
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x0F + (e.skin & 0x01)).experience,
|
|
12 + (e.skin & 0x01), "Dorphon (Eclair)?");
|
|
break;
|
|
case 0x0117: // Goran family
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x11 + (e.skin % 3)).experience,
|
|
(e.skin & 2) ? 15 : ((e.skin & 1) ? 16 : 14), "Goran...");
|
|
break;
|
|
case 0x0119: // Saint Million, Shambertin, Kondrieu
|
|
enemies.emplace_back(next_enemy_id++, e.base,
|
|
get_battle_params(0x22).experience,
|
|
(e.reserved[10] & 0x800000) ? 21 : (19 + (e.skin & 0x01)),
|
|
"(Saint-Million|Shambertin|Kondrieu)");
|
|
break;
|
|
default:
|
|
enemies.emplace_back(next_enemy_id++, e.base, 0xFFFFFFFF, 0, "__unknown__");
|
|
static_game_data_log.warning(
|
|
"(Entry %zu, offset %zX in file) Unknown enemy type %08" PRIX32 " %08" PRIX32,
|
|
y, y * sizeof(EnemyEntry), e.base, e.skin);
|
|
break;
|
|
}
|
|
create_clones(num_clones);
|
|
}
|
|
|
|
return enemies;
|
|
}
|
|
|
|
|
|
|
|
SetDataTable::SetDataTable(shared_ptr<const string> data, bool big_endian) {
|
|
if (big_endian) {
|
|
this->load_table_t<be_uint32_t>(data);
|
|
} else {
|
|
this->load_table_t<le_uint32_t>(data);
|
|
}
|
|
}
|
|
|
|
template <typename U32T>
|
|
void SetDataTable::load_table_t(shared_ptr<const string> data) {
|
|
StringReader r(*data);
|
|
|
|
struct Footer {
|
|
U32T table3_offset;
|
|
U32T table3_count; // In le_uint16_ts (so *2 for size in bytes)
|
|
U32T unknown_a3; // == 1
|
|
U32T unknown_a4; // == 0
|
|
U32T root_table_offset_offset;
|
|
U32T unknown_a6; // == 0
|
|
U32T unknown_a7; // == 0
|
|
U32T unknown_a8; // == 0
|
|
} __attribute__((packed));
|
|
if (r.size() < sizeof(Footer)) {
|
|
throw runtime_error("set data table is too small");
|
|
}
|
|
auto& footer = r.pget<Footer>(r.size() - sizeof(Footer));
|
|
|
|
uint32_t root_table_offset = r.pget<U32T>(footer.root_table_offset_offset);
|
|
auto root_r = r.sub(root_table_offset, footer.root_table_offset_offset - root_table_offset);
|
|
while (!root_r.eof()) {
|
|
auto& var1_v = this->entries.emplace_back();
|
|
uint32_t var1_table_offset = root_r.template get<U32T>();
|
|
uint32_t var1_table_count = root_r.template get<U32T>();
|
|
auto var1_r = r.sub(var1_table_offset, var1_table_count * 0x08);
|
|
while (!var1_r.eof()) {
|
|
auto& var2_v = var1_v.emplace_back();
|
|
uint32_t var2_table_offset = var1_r.get<U32T>();
|
|
uint32_t var2_table_count = var1_r.get<U32T>();
|
|
auto var2_r = r.sub(var2_table_offset, var2_table_count * 0x0C);
|
|
while (!var2_r.eof()) {
|
|
auto& entry = var2_v.emplace_back();
|
|
entry.name1 = r.pget_cstr(var2_r.get<U32T>());
|
|
entry.enemy_list_basename = r.pget_cstr(var2_r.get<U32T>());
|
|
entry.name3 = r.pget_cstr(var2_r.get<U32T>());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetDataTable::print(FILE* stream) const {
|
|
for (size_t a = 0; a < this->entries.size(); a++) {
|
|
const auto& v1_v = this->entries[a];
|
|
for (size_t v1 = 0; v1 < v1_v.size(); v1++) {
|
|
const auto& v2_v = v1_v[v1];
|
|
for (size_t v2 = 0; v2 < v2_v.size(); v2++) {
|
|
const auto& e = v2_v[v2];
|
|
fprintf(stream, "[%02zX/%02zX/%02zX] %s %s %s\n", a, v1, v2, e.name1.c_str(), e.enemy_list_basename.c_str(), e.name3.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
struct AreaMapFileIndex {
|
|
const char* name_token;
|
|
vector<uint32_t> variation1_values;
|
|
vector<uint32_t> variation2_values;
|
|
|
|
AreaMapFileIndex(
|
|
const char* name_token,
|
|
vector<uint32_t> variation1_values,
|
|
vector<uint32_t> variation2_values)
|
|
: name_token(name_token),
|
|
variation1_values(variation1_values),
|
|
variation2_values(variation2_values) { }
|
|
};
|
|
|
|
// These are indexed as [episode][is_solo][area]
|
|
// (Note that Lobby::episode is 1-3, so we actually use episode - 1)
|
|
static const vector<vector<vector<AreaMapFileIndex>>> map_file_info = {
|
|
{ // Episode 1
|
|
{ // Non-solo
|
|
{"city00", {}, {0}},
|
|
{"forest01", {}, {0, 1, 2, 3, 4}},
|
|
{"forest02", {}, {0, 1, 2, 3, 4}},
|
|
{"cave01", {0, 1, 2}, {0, 1}},
|
|
{"cave02", {0, 1, 2}, {0, 1}},
|
|
{"cave03", {0, 1, 2}, {0, 1}},
|
|
{"machine01", {0, 1, 2}, {0, 1}},
|
|
{"machine02", {0, 1, 2}, {0, 1}},
|
|
{"ancient01", {0, 1, 2}, {0, 1}},
|
|
{"ancient02", {0, 1, 2}, {0, 1}},
|
|
{"ancient03", {0, 1, 2}, {0, 1}},
|
|
{"boss01", {}, {}},
|
|
{"boss02", {}, {}},
|
|
{"boss03", {}, {}},
|
|
{"boss04", {}, {}},
|
|
{nullptr, {}, {}},
|
|
},
|
|
{ // Solo
|
|
{"city00", {}, {0}},
|
|
{"forest01", {}, {0, 2, 4}},
|
|
{"forest02", {}, {0, 3, 4}},
|
|
{"cave01", {0, 1, 2}, {0}},
|
|
{"cave02", {0, 1, 2}, {0}},
|
|
{"cave03", {0, 1, 2}, {0}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
},
|
|
},
|
|
{ // Episode 2
|
|
{ // Non-solo
|
|
{"labo00", {}, {0}},
|
|
{"ruins01", {0, 1}, {0}},
|
|
{"ruins02", {0, 1}, {0}},
|
|
{"space01", {0, 1}, {0}},
|
|
{"space02", {0, 1}, {0}},
|
|
{"jungle01", {}, {0, 1, 2}},
|
|
{"jungle02", {}, {0, 1, 2}},
|
|
{"jungle03", {}, {0, 1, 2}},
|
|
{"jungle04", {0, 1}, {0, 1}},
|
|
{"jungle05", {}, {0, 1, 2}},
|
|
{"seabed01", {0, 1}, {0, 1}},
|
|
{"seabed02", {0, 1}, {0, 1}},
|
|
{"boss05", {}, {}},
|
|
{"boss06", {}, {}},
|
|
{"boss07", {}, {}},
|
|
{"boss08", {}, {}},
|
|
},
|
|
{ // Solo
|
|
{"labo00", {}, {0}},
|
|
{"ruins01", {0, 1}, {0}},
|
|
{"ruins02", {0, 1}, {0}},
|
|
{"space01", {0, 1}, {0}},
|
|
{"space02", {0, 1}, {0}},
|
|
{"jungle01", {}, {0, 1, 2}},
|
|
{"jungle02", {}, {0, 1, 2}},
|
|
{"jungle03", {}, {0, 1, 2}},
|
|
{"jungle04", {0, 1}, {0, 1}},
|
|
{"jungle05", {}, {0, 1, 2}},
|
|
{"seabed01", {0, 1}, {0}},
|
|
{"seabed02", {0, 1}, {0}},
|
|
{"boss05", {}, {}},
|
|
{"boss06", {}, {}},
|
|
{"boss07", {}, {}},
|
|
{"boss08", {}, {}},
|
|
},
|
|
},
|
|
{ // Episode 4
|
|
{ // Non-solo
|
|
{"city02", {0}, {0}},
|
|
{"wilds01", {0}, {0, 1, 2}},
|
|
{"wilds01", {1}, {0, 1, 2}},
|
|
{"wilds01", {2}, {0, 1, 2}},
|
|
{"wilds01", {3}, {0, 1, 2}},
|
|
{"crater01", {0}, {0, 1, 2}},
|
|
{"desert01", {0, 1, 2}, {0}},
|
|
{"desert02", {0}, {0, 1, 2}},
|
|
{"desert03", {0, 1, 2}, {0}},
|
|
{"boss09", {0}, {0}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
},
|
|
{ // Solo
|
|
{"city02", {0}, {0}},
|
|
{"wilds01", {0}, {0, 1, 2}},
|
|
{"wilds01", {1}, {0, 1, 2}},
|
|
{"wilds01", {2}, {0, 1, 2}},
|
|
{"wilds01", {3}, {0, 1, 2}},
|
|
{"crater01", {0}, {0, 1, 2}},
|
|
{"desert01", {0, 1, 2}, {0}},
|
|
{"desert02", {0}, {0, 1, 2}},
|
|
{"desert03", {0, 1, 2}, {0}},
|
|
{"boss09", {0}, {0}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
{nullptr, {}, {}},
|
|
},
|
|
},
|
|
};
|
|
|
|
void generate_variations(
|
|
parray<le_uint32_t, 0x20>& variations,
|
|
shared_ptr<mt19937> random,
|
|
uint8_t episode,
|
|
bool is_solo) {
|
|
const auto& ep_index = map_file_info.at(episode - 1);
|
|
for (size_t z = 0; z < 0x10; z++) {
|
|
const AreaMapFileIndex* a = nullptr;
|
|
if (is_solo) {
|
|
a = &ep_index.at(true).at(z);
|
|
}
|
|
if (!a || !a->name_token) {
|
|
a = &ep_index.at(false).at(z);
|
|
}
|
|
if (!a->name_token) {
|
|
variations[z * 2 + 0] = 0;
|
|
variations[z * 2 + 1] = 0;
|
|
} else {
|
|
variations[z * 2 + 0] = (a->variation1_values.size() < 2) ? 0 :
|
|
((*random)() % a->variation1_values.size());
|
|
variations[z * 2 + 1] = (a->variation2_values.size() < 2) ? 0 :
|
|
((*random)() % a->variation2_values.size());
|
|
}
|
|
}
|
|
}
|
|
|
|
vector<string> map_filenames_for_variation(
|
|
uint8_t episode, bool is_solo, uint8_t area, uint32_t var1, uint32_t var2) {
|
|
// Map filenames are like map_<name_token>[_VV][_VV][_off]<e|o>[_s].dat
|
|
// name_token comes from AreaMapFileIndex
|
|
// _VV are the values from the variation<1|2>_values vector (in contrast to
|
|
// the values sent in the 64 command, which are INDEXES INTO THAT VECTOR)
|
|
// _off or _s are used for solo mode (try both - city uses _s whereas levels
|
|
// use _off apparently)
|
|
// e|o specifies what kind of data: e = enemies, o = objects
|
|
const auto& ep_index = map_file_info.at(episode - 1);
|
|
const AreaMapFileIndex* a = nullptr;
|
|
if (is_solo) {
|
|
a = &ep_index.at(true).at(area);
|
|
}
|
|
if (!a || !a->name_token) {
|
|
a = &ep_index.at(false).at(area);
|
|
}
|
|
if (!a->name_token) {
|
|
return vector<string>();
|
|
}
|
|
|
|
string filename = "map_";
|
|
filename += a->name_token;
|
|
if (!a->variation1_values.empty()) {
|
|
filename += string_printf("_%02" PRIX32, a->variation1_values.at(var1));
|
|
}
|
|
if (!a->variation2_values.empty()) {
|
|
filename += string_printf("_%02" PRIX32, a->variation2_values.at(var2));
|
|
}
|
|
|
|
vector<string> ret;
|
|
if (is_solo) {
|
|
// Try both _offe.dat and e_s.dat suffixes
|
|
ret.emplace_back(filename + "_offe.dat");
|
|
ret.emplace_back(filename + "e_s.dat");
|
|
} else {
|
|
ret.emplace_back(filename + "e.dat");
|
|
}
|
|
return ret;
|
|
}
|