incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
077bfb2e7dffb1ff5e0ecc3e0e89a0f550f1f2ab
psopeeps-newserv/src/Map.cc
T
Martin Michelsen 612f305c3a fix battle param header text
2023-03-04 11:42:04 -08:00

737 lines
25 KiB
C++
Raw Blame History

#include "Map.hh"
#include <phosg/Filesystem.hh>
#include <phosg/Strings.hh>
#include "Loggers.hh"
#include "StaticGameData.hh"
using namespace std;
string BattleParamsIndex::Entry::str() const {
string a1str = format_data_string(this->unknown_a1.data(), this->unknown_a1.bytes());
return string_printf(
"BattleParamsEntry[ATP=%hu PSV=%hu EVP=%hu HP=%hu DFP=%hu ATA=%hu LCK=%hu ESP=%hu a1=%s EXP=%" PRIu32 " diff=%" PRIu32 "]",
this->atp.load(),
this->psv.load(),
this->evp.load(),
this->hp.load(),
this->dfp.load(),
this->ata.load(),
this->lck.load(),
this->esp.load(),
a1str.c_str(),
this->experience.load(),
this->difficulty.load());
}
void BattleParamsIndex::Table::print(FILE* stream) const {
auto print_entry = +[](FILE* stream, const Entry& e) {
string a1str = format_data_string(e.unknown_a1.data(), e.unknown_a1.bytes());
fprintf(stream,
"%5hu %5hu %5hu %5hu %5hu %5hu %5hu %5hu %s %5" PRIu32 " %5" PRIu32,
e.atp.load(),
e.psv.load(),
e.evp.load(),
e.hp.load(),
e.dfp.load(),
e.ata.load(),
e.lck.load(),
e.esp.load(),
a1str.c_str(),
e.experience.load(),
e.difficulty.load());
};
for (size_t diff = 0; diff < 4; diff++) {
fprintf(stream, "%c ZZ ATP PSV EVP HP DFP ATA LCK ESP A1 EXP DIFF\n",
abbreviation_for_difficulty(diff));
for (size_t z = 0; z < 0x60; z++) {
fprintf(stream, " %02zX ", z);
print_entry(stream, this->difficulty[diff][z]);
fputc('\n', stream);
}
}
}
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, Episode episode, uint8_t difficulty, uint8_t monster_type) const {
if (difficulty > 4) {
throw invalid_argument("incorrect difficulty");
}
if (monster_type > 0x60) {
throw invalid_argument("incorrect monster type");
}
uint8_t ep_index;
switch (episode) {
case Episode::EP1:
ep_index = 0;
break;
case Episode::EP2:
ep_index = 1;
break;
case Episode::EP4:
ep_index = 2;
break;
default:
throw invalid_argument("invalid episode");
}
return this->files[!!solo][ep_index].table->difficulty[difficulty][monster_type];
}
PSOEnemy::PSOEnemy(uint64_t id) : PSOEnemy(id, 0, 0, 0, 0, "__missing__") { }
PSOEnemy::PSOEnemy(
uint64_t id,
uint16_t source_type,
uint32_t experience,
uint32_t rt_index,
size_t num_clones,
const char* type_name)
: id(id),
source_type(source_type),
hit_flags(0),
last_hit(0),
experience(experience),
rt_index(rt_index),
num_clones(num_clones),
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 " clones=%zu]",
this->id, this->type_name, this->source_type, this->hit_flags, this->last_hit, this->experience, this->rt_index, this->num_clones);
}
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,
Episode 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 create_enemy = [&](
const EnemyEntry& e,
ssize_t bp_index,
uint32_t rt_index,
const char* type_name) {
const BattleParamsIndex::Entry& bp_entry = battle_params->get(
is_solo, episode, difficulty, bp_index);
enemies.emplace_back(
next_enemy_id++,
e.base,
bp_entry.experience,
rt_index,
e.num_clones,
type_name);
};
for (size_t y = 0; y < entry_count; y++) {
const auto& e = map[y];
switch (e.base) {
case 0x40: // Hildebear and Hildetorr
create_enemy(e, 0x49 + (e.skin & 0x01), 0x01 + (e.skin & 0x01), "Hilde(bear|torr)");
break;
case 0x41: // Rappies
if (episode == Episode::EP4) { // Del Rappy and Sand Rappy
if (alt_enemies) {
create_enemy(e, 0x17 + (e.skin & 0x01), 17 + (e.skin & 0x01), "(Del|Sand) Rappy");
} else {
create_enemy(e, 0x05 + (e.skin & 0x01), 17 + (e.skin & 0x01), "(Del|Sand) Rappy");
}
} else { // Rag Rappy and Al Rappy (Love for Episode II)
if (e.skin & 0x01) {
// TODO: Don't know (yet) which rare Rappy it is
create_enemy(e, 0x18 + (e.skin & 0x01), 0xFF, "Rare Rappy");
} else {
create_enemy(e, 0x18 + (e.skin & 0x01), 5, "Rag Rappy");
}
}
break;
case 0x42: // Monest + 30 Mothmants
create_enemy(e, 0x01, 4, "Monest");
for (size_t x = 0; x < 30; x++) {
create_enemy(e, 0x00, 3, "Mothmant");
}
break;
case 0x43: // Savage Wolf and Barbarous Wolf
create_enemy(e, 0x02 + ((e.reserved[10] & 0x800000) ? 1 : 0),
7 + ((e.reserved[10] & 0x800000) ? 1 : 0), "(Savage|Barbarous) Wolf");
break;
case 0x44: // Booma family
create_enemy(e, 0x4B + (e.skin % 3), 9 + (e.skin % 3), "(|Go|Gigo)Booma");
break;
case 0x60: // Grass Assassin
create_enemy(e, 0x4E, 12, "Grass Assassin");
break;
case 0x61: // Del Lily, Poison Lily, Nar Lily
if ((episode == Episode::EP2) && (alt_enemies)) {
create_enemy(e, 0x25, 83, "Del Lily");
} else {
create_enemy(e, 0x04 + ((e.reserved[10] & 0x800000) ? 1 : 0),
13 + ((e.reserved[10] & 0x800000) ? 1 : 0), "(Poison|Nar) Lily");
}
break;
case 0x62: // Nano Dragon
create_enemy(e, 0x1A, 15, "Nano Dragon");
break;
case 0x63: // Shark family
create_enemy(e, 0x4F + (e.skin % 3), 16 + (e.skin % 3), "(Evil|Pal|Guil) Shark");
break;
case 0x64: // Slime + 4 clones
create_enemy(e, 0x2F + ((e.reserved[10] & 0x800000) ? 0 : 1),
19 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Pof?uilly Slime");
for (size_t x = 0; x < 4; x++) {
create_enemy(e, 0x30, 19, "Pof?uilly Slime clone");
}
break;
case 0x65: // Pan Arms, Migium, Hidoom
for (size_t x = 0; x < 3; x++) {
create_enemy(e, 0x31 + x, 21 + x, "(Pan Arms|Hidoom|Migium)");
}
break;
case 0x80: // Dubchic and Gillchic
if (e.skin & 0x01) {
create_enemy(e, 0x1B + (e.skin & 0x01), 50, "(Dub|Gill)chic");
} else {
create_enemy(e, 0x1B + (e.skin & 0x01), 24, "(Dub|Gill)chic");
}
break;
case 0x81: // Garanz
create_enemy(e, 0x1D, 25, "Garanz");
break;
case 0x82: // Sinow Beat and Gold
if (e.reserved[10] & 0x800000) {
create_enemy(e, 0x13, 26 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Sinow (Beat|Gold)");
} else {
create_enemy(e, 0x06, 26 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Sinow (Beat|Gold)");
}
if (e.num_clones == 0) {
create_clones(4);
}
break;
case 0x83: // Canadine
create_enemy(e, 0x07, 28, "Canadine");
break;
case 0x84: // Canadine Group
create_enemy(e, 0x09, 29, "Canune");
for (size_t x = 0; x < 8; x++) {
create_enemy(e, 0x08, 28, "Canadine");
}
break;
case 0x85: // Dubwitch
enemies.emplace_back(next_enemy_id++, e.base, 0xFFFFFFFF, 0, 0, "__dubwitch__");
break;
case 0xA0: // Delsaber
create_enemy(e, 0x52, 30, "Delsaber");
break;
case 0xA1: // Chaos Sorcerer + 2 Bits
create_enemy(e, 0x0A, 31, "Chaos Sorcerer");
create_clones(2);
break;
case 0xA2: // Dark Gunner
create_enemy(e, 0x1E, 34, "Dark Gunner");
break;
case 0xA4: // Chaos Bringer
create_enemy(e, 0x0D, 36, "Chaos Bringer");
break;
case 0xA5: // Dark Belra
create_enemy(e, 0x0E, 37, "Dark Belra");
break;
case 0xA6: // Dimenian family
create_enemy(e, 0x53 + (e.skin % 3), 41 + (e.skin % 3), "(|La|So) Dimenian");
break;
case 0xA7: // Bulclaw + 4 claws
create_enemy(e, 0x1F, 40, "Bulclaw");
for (size_t x = 0; x < 4; x++) {
create_enemy(e, 0x20, 38, "Claw");
}
break;
case 0xA8: // Claw
create_enemy(e, 0x20, 38, "Claw");
break;
case 0xC0: // Dragon or Gal Gryphon
if (episode == Episode::EP1) {
create_enemy(e, 0x12, 44, "Dragon");
} else if (episode == Episode::EP2) {
create_enemy(e, 0x1E, 77, "Gal Gryphon");
}
break;
case 0xC1: // De Rol Le
create_enemy(e, 0x0F, 45, "De Rol Le");
break;
case 0xC2: // Vol Opt form 1
enemies.emplace_back(next_enemy_id++, e.base, 0xFFFFFFFF, 0, 0, "__vol_opt_1__");
break;
case 0xC5: // Vol Opt form 2
create_enemy(e, 0x25, 46, "Vol Opt");
break;
case 0xC8: // Dark Falz + 510 Darvants
if (difficulty) {
create_enemy(e, 0x38, 47, "Dark Falz 3"); // Final form
} else {
create_enemy(e, 0x37, 47, "Dark Falz 2"); // Second form
}
for (size_t x = 0; x < 510; x++) {
create_enemy(e, 0x35, 0, "Darvant");
}
break;
case 0xCA: // Olga Flow
create_enemy(e, 0x2C, 78, "Olga Flow");
create_clones(0x200);
break;
case 0xCB: // Barba Ray
create_enemy(e, 0x0F, 73, "Barba Ray");
create_clones(0x2F);
break;
case 0xCC: // Gol Dragon
create_enemy(e, 0x12, 76, "Gol Dragon");
create_clones(5);
break;
case 0xD4: // Sinows Berill & Spigell
create_enemy(e, (e.reserved[10] & 0x800000) ? 0x13 : 0x06,
62 + ((e.reserved[10] & 0x800000) ? 1 : 0), "Sinow (Berrill|Spigell)");
create_clones(4);
break;
case 0xD5: // Merillia & Meriltas
create_enemy(e, 0x4B + (e.skin & 0x01), 52 + (e.skin & 0x01), "Meril(lia|tas)");
break;
case 0xD6: // Mericus, Merikle, & Mericarol
if (e.skin) {
create_enemy(e, 0x44 + (e.skin % 3), 56 + (e.skin % 3), "Meri(cus|kle|carol)");
} else {
create_enemy(e, 0x3A, 56 + (e.skin % 3), "Meri(cus|kle|carol)");
}
break;
case 0xD7: // Ul Gibbon and Zol Gibbon
create_enemy(e, 0x3B + (e.skin & 0x01), 59 + (e.skin & 0x01), "(Ul|Zol) Gibbon");
break;
case 0xD8: // Gibbles
create_enemy(e, 0x3D, 61, "Gibbles");
break;
case 0xD9: // Gee
create_enemy(e, 0x07, 54, "Gee");
break;
case 0xDA: // Gi Gue
create_enemy(e, 0x1A, 55, "Gi Gue");
break;
case 0xDB: // Deldepth
create_enemy(e, 0x30, 71, "Deldepth");
break;
case 0xDC: // Delbiter
create_enemy(e, 0x0D, 72, "Delbiter");
break;
case 0xDD: // Dolmolm and Dolmdarl
create_enemy(e, 0x4F + (e.skin & 0x01), 64 + (e.skin & 0x01), "Dolm(olm|darl)");
break;
case 0xDE: // Morfos
create_enemy(e, 0x40, 66, "Morfos");
break;
case 0xDF: // Recobox & Recons
create_enemy(e, 0x41, 67, "Recobox");
for (size_t x = 0; x < e.num_clones; x++) {
create_enemy(e, 0x42, 68, "Recon");
}
break;
case 0xE0: // Epsilon, Sinow Zoa and Zele
if ((episode == Episode::EP2) && (alt_enemies)) {
create_enemy(e, 0x23, 84, "Epsilon");
create_clones(4);
} else {
create_enemy(e, 0x43 + (e.skin & 0x01), 69 + (e.skin & 0x01), "Sinow Z(oa|ele)");
}
break;
case 0xE1: // Ill Gill
create_enemy(e, 0x26, 82, "Ill Gill");
break;
case 0x0110: // Astark
create_enemy(e, 0x09, 1, "Astark");
break;
case 0x0111: // Satellite Lizard and Yowie
create_enemy(e, 0x0D + ((e.reserved[10] & 0x800000) ? 1 : 0) + (alt_enemies ? 0x10 : 0),
2 + ((e.reserved[10] & 0x800000) ? 0 : 1), "(Satellite Lizard|Yowie)");
break;
case 0x0112: // Merissa A/AA
create_enemy(e, 0x19 + (e.skin & 0x01), 4 + (e.skin & 0x01), "Merissa AA?");
break;
case 0x0113: // Girtablulu
create_enemy(e, 0x1F, 6, "Girtablulu");
break;
case 0x0114: // Zu and Pazuzu
create_enemy(e, 0x0B + (e.skin & 0x01) + (alt_enemies ? 0x14: 0x00),
7 + (e.skin & 0x01), "(Pazu)?zu");
break;
case 0x0115: // Boota family
if (e.skin & 2) {
create_enemy(e, 0x03, 9 + (e.skin % 3), "(|Ba|Ze) Boota");
} else {
create_enemy(e, 0x00 + (e.skin % 3), 9 + (e.skin % 3), "(|Ba|Ze) Boota");
}
break;
case 0x0116: // Dorphon and Eclair
create_enemy(e, 0x0F + (e.skin & 0x01), 12 + (e.skin & 0x01), "Dorphon( Eclair)?");
break;
case 0x0117: // Goran family
create_enemy(e, 0x11 + (e.skin % 3), (e.skin & 2) ? 15 : ((e.skin & 1) ? 16 : 14), "(Pyro )?Goran( Detonator)?");
break;
case 0x0119: // Saint-Million, Shambertin, Kondrieu
create_enemy(e, 0x22,
(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, 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(e.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], where episode is 0-2
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, {}, {}},
},
},
};
const vector<vector<AreaMapFileIndex>>& map_file_info_for_episode(Episode ep) {
switch (ep) {
case Episode::EP1:
return map_file_info.at(0);
case Episode::EP2:
return map_file_info.at(1);
case Episode::EP4:
return map_file_info.at(2);
default:
throw invalid_argument("episode has no maps");
}
}
void generate_variations(
parray<le_uint32_t, 0x20>& variations,
shared_ptr<mt19937> random,
Episode episode,
bool is_solo) {
const auto& ep_index = map_file_info_for_episode(episode);
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(
Episode 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_for_episode(episode);
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;
}
Reference in New Issue View Git Blame Copy Permalink