incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a0f02307003067c119f377cc8e36c2573c71cb77
psopeeps-newserv/src/Map.cc
T
Martin Michelsen a0f0230700 forbid rare enemies in challenge mode
2023-11-10 12:41:41 -08:00

840 lines
30 KiB
C++
Raw Blame History

#include "Map.hh"
#include <phosg/Filesystem.hh>
#include <phosg/Random.hh>
#include <phosg/Strings.hh>
#include "Loggers.hh"
#include "PSOEncryption.hh"
#include "Quest.hh"
#include "StaticGameData.hh"
using namespace std;
Map::Enemy::Enemy(EnemyType type)
: type(type),
flags(0),
last_hit_by_client_id(0) {}
string Map::Enemy::str() const {
return string_printf("[Map::Enemy %s flags=%02hhX last_hit_by_client_id=%hu]",
name_for_enum(this->type), this->flags, this->last_hit_by_client_id);
}
struct EnemyEntry {
/* 00 */ le_uint16_t base_type;
/* 02 */ le_uint16_t unknown_a0; // Overwritten by client at load time
/* 04 */ le_uint16_t enemy_index; // Overwritten by client at load time
/* 06 */ le_uint16_t num_children;
/* 08 */ le_uint16_t area;
/* 0A */ le_uint16_t entity_id; // == enemy_index + 0x1000
/* 0C */ le_uint16_t section;
/* 0E */ le_uint16_t wave_number;
/* 10 */ le_uint32_t wave_number2;
/* 14 */ le_float x;
/* 18 */ le_float y;
/* 1C */ le_float z;
/* 20 */ le_uint32_t x_angle;
/* 24 */ le_uint32_t y_angle;
/* 28 */ le_uint32_t z_angle;
/* 2C */ le_uint32_t unknown_a3;
/* 30 */ le_uint32_t unknown_a4;
/* 34 */ le_uint32_t unknown_a5;
/* 38 */ le_uint32_t unknown_a6;
/* 3C */ le_uint32_t unknown_a7;
/* 40 */ le_uint32_t skin;
/* 44 */ le_uint32_t unknown_a8;
/* 48 */
string str() const {
return string_printf("EnemyEntry(base_type=%hX, a0=%hX, enemy_index=%hX, num_children=%hX, area=%hX, entity_id=%hX, section=%hX, wave_number=%hX, wave_number2=%" PRIX32 ", x=%g, y=%g, z=%g, x_angle=%" PRIX32 ", y_angle=%" PRIX32 ", z_angle=%" PRIX32 ", a3=%" PRIX32 ", a4=%" PRIX32 ", a5=%" PRIX32 ", a6=%" PRIX32 ", a7=%" PRIX32 ", skin=%" PRIX32 ", a8=%" PRIX32 ")",
this->base_type.load(), this->unknown_a0.load(), this->enemy_index.load(), this->num_children.load(), this->area.load(),
this->entity_id.load(), this->section.load(), this->wave_number.load(),
this->wave_number2.load(), this->x.load(), this->y.load(), this->z.load(), this->x_angle.load(),
this->y_angle.load(), this->z_angle.load(), this->unknown_a3.load(), this->unknown_a4.load(),
this->unknown_a5.load(), this->unknown_a6.load(), this->unknown_a7.load(), this->skin.load(),
this->unknown_a8.load());
}
} __attribute__((packed));
struct ObjectEntry {
/* 00 */ le_uint16_t base_type;
/* 02 */ le_uint16_t unknown_a1;
/* 04 */ le_uint32_t unknown_a2;
/* 08 */ le_uint16_t id;
/* 0A */ le_uint16_t group;
/* 0C */ le_uint16_t section;
/* 0E */ le_uint16_t unknown_a3;
/* 10 */ le_float x;
/* 14 */ le_float y;
/* 18 */ le_float z;
/* 1C */ le_uint32_t x_angle;
/* 20 */ le_uint32_t y_angle;
/* 24 */ le_uint32_t z_angle;
/* 28 */ le_float unknown_a4;
/* 2C */ le_float unknown_a5;
/* 30 */ le_float unknown_a6;
/* 34 */ le_uint32_t unknown_a7;
/* 38 */ le_uint32_t unknown_a8;
/* 3C */ le_uint32_t unknown_a9;
/* 40 */ le_uint32_t unknown_a10;
/* 44 */
string str() const {
return string_printf("ObjectEntry(base_type=%hX, a1=%hX, a2=%" PRIX32 ", id=%hX, group=%hX, section=%hX, a3=%hX, x=%g, y=%g, z=%g, x_angle=%" PRIX32 ", y_angle=%" PRIX32 ", z_angle=%" PRIX32 ", a4=%g, a5=%g, a6=%g, a7=%" PRIX32 ", a8=%" PRIX32 ", a9=%" PRIX32 ", a9=%" PRIX32 ")",
this->base_type.load(), this->unknown_a1.load(), this->unknown_a2.load(), this->id.load(), this->group.load(),
this->section.load(), this->unknown_a3.load(), this->x.load(), this->y.load(), this->z.load(), this->x_angle.load(),
this->y_angle.load(), this->z_angle.load(), this->unknown_a4.load(), this->unknown_a5.load(), this->unknown_a6.load(),
this->unknown_a7.load(), this->unknown_a8.load(), this->unknown_a9.load(), this->unknown_a9.load());
}
} __attribute__((packed));
void Map::clear() {
this->enemies.clear();
this->rare_enemy_indexes.clear();
}
void Map::add_objects_from_map_data(const void* data, size_t size) {
const auto* map = reinterpret_cast<const ObjectEntry*>(data);
size_t entry_count = size / sizeof(ObjectEntry);
if (size != entry_count * sizeof(ObjectEntry)) {
throw runtime_error("data size is not a multiple of entry size");
}
for (size_t y = 0; y < entry_count; y++) {
const auto& e = map[y];
string hex = format_data_string(&e, sizeof(e));
fprintf(stderr, "[%04zX] %s\n", y, hex.c_str());
}
}
void Map::add_enemies_from_map_data(
Episode episode,
uint8_t difficulty,
uint8_t event,
const void* data,
size_t size,
const RareEnemyRates& rare_rates) {
auto check_rare = [&](bool default_is_rare, uint32_t rare_rate) -> bool {
if (default_is_rare) {
return true;
}
if ((this->rare_enemy_indexes.size() < 0x10) &&
(random_object<uint32_t>() < rare_rate)) {
this->rare_enemy_indexes.emplace_back(this->enemies.size());
return true;
}
return false;
};
const auto* map = reinterpret_cast<const EnemyEntry*>(data);
size_t entry_count = size / sizeof(EnemyEntry);
if (size != entry_count * sizeof(EnemyEntry)) {
throw runtime_error("data size is not a multiple of entry size");
}
for (size_t y = 0; y < entry_count; y++) {
const auto& e = map[y];
string hex = format_data_string(&e, sizeof(e));
fprintf(stderr, "[%04zX] %s\n", y, hex.c_str());
switch (e.base_type) {
case 0x40: {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.hildeblue);
this->enemies.emplace_back(is_rare ? EnemyType::HILDEBLUE : EnemyType::HILDEBEAR);
break;
}
case 0x41: {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.rappy);
switch (episode) {
case Episode::EP1:
this->enemies.emplace_back(is_rare ? EnemyType::AL_RAPPY : EnemyType::RAG_RAPPY);
break;
case Episode::EP2:
if (is_rare) {
switch (event) {
case 0x01:
this->enemies.emplace_back(EnemyType::SAINT_RAPPY);
break;
case 0x04:
this->enemies.emplace_back(EnemyType::EGG_RAPPY);
break;
case 0x05:
this->enemies.emplace_back(EnemyType::HALLO_RAPPY);
break;
default:
this->enemies.emplace_back(EnemyType::LOVE_RAPPY);
}
} else {
this->enemies.emplace_back(EnemyType::RAG_RAPPY);
}
break;
case Episode::EP4:
if (e.area > 0x05) {
this->enemies.emplace_back(is_rare ? EnemyType::DEL_RAPPY_ALT : EnemyType::SAND_RAPPY_ALT);
} else {
this->enemies.emplace_back(is_rare ? EnemyType::DEL_RAPPY : EnemyType::SAND_RAPPY);
}
break;
default:
throw logic_error("invalid episode");
}
break;
}
case 0x42: {
this->enemies.emplace_back(EnemyType::MONEST);
for (size_t x = 0; x < 30; x++) {
this->enemies.emplace_back(EnemyType::MOTHMANT);
}
break;
}
case 0x43: {
this->enemies.emplace_back(e.unknown_a4 ? EnemyType::BARBAROUS_WOLF : EnemyType::SAVAGE_WOLF);
break;
}
case 0x44:
static const EnemyType types[3] = {EnemyType::BOOMA, EnemyType::GOBOOMA, EnemyType::GIGOBOOMA};
this->enemies.emplace_back(types[e.skin % 3]);
break;
case 0x60:
this->enemies.emplace_back(EnemyType::GRASS_ASSASSIN);
break;
case 0x61:
if ((episode == Episode::EP2) && (e.area > 0x0F)) {
this->enemies.emplace_back(EnemyType::DEL_LILY);
} else {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.nar_lily);
this->enemies.emplace_back(is_rare ? EnemyType::NAR_LILY : EnemyType::POISON_LILY);
}
break;
case 0x62:
this->enemies.emplace_back(EnemyType::NANO_DRAGON);
break;
case 0x63: {
static const EnemyType types[3] = {EnemyType::EVIL_SHARK, EnemyType::PAL_SHARK, EnemyType::GUIL_SHARK};
this->enemies.emplace_back(types[e.skin % 3]);
break;
}
case 0x64: {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.pouilly_slime);
for (size_t x = 0; x < 5; x++) { // Main slime + 4 clones
this->enemies.emplace_back(is_rare ? EnemyType::POFUILLY_SLIME : EnemyType::POUILLY_SLIME);
}
break;
}
case 0x65:
this->enemies.emplace_back(EnemyType::PAN_ARMS);
this->enemies.emplace_back(EnemyType::HIDOOM);
this->enemies.emplace_back(EnemyType::MIGIUM);
break;
case 0x80:
this->enemies.emplace_back((e.skin & 0x01) ? EnemyType::GILLCHIC : EnemyType::DUBCHIC);
break;
case 0x81:
this->enemies.emplace_back(EnemyType::GARANZ);
break;
case 0x82: {
EnemyType type = e.unknown_a4 ? EnemyType::SINOW_GOLD : EnemyType::SINOW_BEAT;
size_t count = (e.num_children == 0) ? 5 : (e.num_children + 1);
for (size_t z = 0; z < count; z++) {
this->enemies.emplace_back(type);
}
break;
}
case 0x83:
this->enemies.emplace_back(EnemyType::CANADINE);
break;
case 0x84:
this->enemies.emplace_back(EnemyType::CANANE);
for (size_t x = 0; x < 8; x++) {
this->enemies.emplace_back(EnemyType::CANADINE_GROUP);
}
break;
case 0x85:
this->enemies.emplace_back(EnemyType::DUBWITCH);
break;
case 0xA0:
this->enemies.emplace_back(EnemyType::DELSABER);
break;
case 0xA1:
this->enemies.emplace_back(EnemyType::CHAOS_SORCERER);
this->enemies.emplace_back(EnemyType::BEE_R);
this->enemies.emplace_back(EnemyType::BEE_L);
break;
case 0xA2:
this->enemies.emplace_back(EnemyType::DARK_GUNNER);
break;
case 0xA3:
this->enemies.emplace_back(EnemyType::DEATH_GUNNER);
break;
case 0xA4:
this->enemies.emplace_back(EnemyType::CHAOS_BRINGER);
break;
case 0xA5:
this->enemies.emplace_back(EnemyType::DARK_BELRA);
break;
case 0xA6: {
static const EnemyType types[3] = {EnemyType::DIMENIAN, EnemyType::LA_DIMENIAN, EnemyType::SO_DIMENIAN};
this->enemies.emplace_back(types[e.skin % 3]);
break;
}
case 0xA7:
this->enemies.emplace_back(EnemyType::BULCLAW);
for (size_t x = 0; x < 4; x++) {
this->enemies.emplace_back(EnemyType::CLAW);
}
break;
case 0xA8:
this->enemies.emplace_back(EnemyType::CLAW);
break;
case 0xC0:
if (episode == Episode::EP1) {
this->enemies.emplace_back(EnemyType::DRAGON);
} else if (episode == Episode::EP2) {
this->enemies.emplace_back(EnemyType::GAL_GRYPHON);
} else {
throw runtime_error("DRAGON-type enemy placed outside of Episodes 1 or 2");
}
break;
case 0xC1:
this->enemies.emplace_back(EnemyType::DE_ROL_LE);
for (size_t z = 0; z < 0x0A; z++) {
this->enemies.emplace_back(EnemyType::DE_ROL_LE_BODY);
}
for (size_t z = 0; z < 0x09; z++) {
this->enemies.emplace_back(EnemyType::DE_ROL_LE_MINE);
}
break;
case 0xC2:
this->enemies.emplace_back(EnemyType::VOL_OPT_1);
for (size_t z = 0; z < 6; z++) {
this->enemies.emplace_back(EnemyType::VOL_OPT_PILLAR);
}
for (size_t z = 0; z < 24; z++) {
this->enemies.emplace_back(EnemyType::VOL_OPT_MONITOR);
}
for (size_t z = 0; z < 2; z++) {
this->enemies.emplace_back(EnemyType::NONE);
}
this->enemies.emplace_back(EnemyType::VOL_OPT_AMP);
this->enemies.emplace_back(EnemyType::VOL_OPT_CORE);
this->enemies.emplace_back(EnemyType::NONE);
break;
case 0xC5:
this->enemies.emplace_back(EnemyType::VOL_OPT_2);
break;
case 0xC8:
if (difficulty) {
this->enemies.emplace_back(EnemyType::DARK_FALZ_3);
} else {
this->enemies.emplace_back(EnemyType::DARK_FALZ_2);
}
for (size_t x = 0; x < 0x1FD; x++) {
this->enemies.emplace_back(difficulty == 3 ? EnemyType::DARVANT_ULTIMATE : EnemyType::DARVANT);
}
this->enemies.emplace_back(EnemyType::DARK_FALZ_3);
this->enemies.emplace_back(EnemyType::DARK_FALZ_2);
this->enemies.emplace_back(EnemyType::DARK_FALZ_1);
break;
case 0xCA:
for (size_t z = 0; z < 0x201; z++) {
this->enemies.emplace_back(EnemyType::OLGA_FLOW_2);
}
break;
case 0xCB:
this->enemies.emplace_back(EnemyType::BARBA_RAY);
for (size_t z = 0; z < 0x2F; z++) {
this->enemies.emplace_back(EnemyType::PIG_RAY);
}
break;
case 0xCC:
for (size_t z = 0; z < 6; z++) {
this->enemies.emplace_back(EnemyType::GOL_DRAGON);
}
break;
case 0xD4: {
EnemyType type = (e.skin & 1) ? EnemyType::SINOW_SPIGELL : EnemyType::SINOW_BERILL;
for (size_t z = 0; z < 5; z++) {
this->enemies.emplace_back(type);
}
break;
}
case 0xD5:
this->enemies.emplace_back((e.skin & 0x01) ? EnemyType::MERILTAS : EnemyType::MERILLIA);
break;
case 0xD6:
if (e.skin == 0) {
this->enemies.emplace_back(EnemyType::MERICAROL);
} else {
this->enemies.emplace_back(((e.skin % 3) == 2) ? EnemyType::MERICUS : EnemyType::MERIKLE);
}
break;
case 0xD7:
this->enemies.emplace_back((e.skin & 0x01) ? EnemyType::ZOL_GIBBON : EnemyType::UL_GIBBON);
break;
case 0xD8:
this->enemies.emplace_back(EnemyType::GIBBLES);
break;
case 0xD9:
this->enemies.emplace_back(EnemyType::GEE);
break;
case 0xDA:
this->enemies.emplace_back(EnemyType::GI_GUE);
break;
case 0xDB:
this->enemies.emplace_back(EnemyType::DELDEPTH);
break;
case 0xDC:
this->enemies.emplace_back(EnemyType::DELBITER);
break;
case 0xDD:
this->enemies.emplace_back((e.skin & 0x01) ? EnemyType::DOLMDARL : EnemyType::DOLMOLM);
break;
case 0xDE:
this->enemies.emplace_back(EnemyType::MORFOS);
break;
case 0xDF:
this->enemies.emplace_back(EnemyType::RECOBOX);
for (size_t x = 0; x < e.num_children; x++) {
this->enemies.emplace_back(EnemyType::RECON);
}
break;
case 0xE0:
if ((episode == Episode::EP2) && (e.area > 0x0F)) {
this->enemies.emplace_back(EnemyType::EPSILON);
for (size_t z = 0; z < 4; z++) {
this->enemies.emplace_back(EnemyType::EPSIGUARD);
}
} else {
this->enemies.emplace_back((e.skin & 0x01) ? EnemyType::SINOW_ZELE : EnemyType::SINOW_ZOA);
}
break;
case 0xE1:
this->enemies.emplace_back(EnemyType::ILL_GILL);
break;
case 0x0110:
this->enemies.emplace_back(EnemyType::ASTARK);
break;
case 0x0111:
if (e.area > 0x05) {
this->enemies.emplace_back(e.unknown_a4 ? EnemyType::YOWIE_ALT : EnemyType::SATELLITE_LIZARD_ALT);
} else {
this->enemies.emplace_back(e.unknown_a4 ? EnemyType::YOWIE : EnemyType::SATELLITE_LIZARD);
}
break;
case 0x0112: {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.merissa_aa);
this->enemies.emplace_back(is_rare ? EnemyType::MERISSA_AA : EnemyType::MERISSA_A);
break;
}
case 0x0113:
this->enemies.emplace_back(EnemyType::GIRTABLULU);
break;
case 0x0114: {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.pazuzu);
if (e.area > 0x05) {
this->enemies.emplace_back(is_rare ? EnemyType::PAZUZU_ALT : EnemyType::ZU_ALT);
} else {
this->enemies.emplace_back(is_rare ? EnemyType::PAZUZU : EnemyType::ZU);
}
break;
}
case 0x0115:
if (e.skin & 2) {
this->enemies.emplace_back(EnemyType::BA_BOOTA);
} else {
this->enemies.emplace_back((e.skin & 1) ? EnemyType::ZE_BOOTA : EnemyType::BOOTA);
}
break;
case 0x0116: {
bool is_rare = check_rare(e.skin & 0x01, rare_rates.dorphon_eclair);
this->enemies.emplace_back(is_rare ? EnemyType::DORPHON_ECLAIR : EnemyType::DORPHON);
break;
}
case 0x0117: {
static const EnemyType types[3] = {EnemyType::GORAN, EnemyType::PYRO_GORAN, EnemyType::GORAN_DETONATOR};
this->enemies.emplace_back(types[e.skin % 3]);
break;
}
case 0x0119: {
bool is_rare = check_rare((e.unknown_a4 != 0), rare_rates.kondrieu);
if (is_rare) {
this->enemies.emplace_back(EnemyType::KONDRIEU);
} else {
this->enemies.emplace_back((e.skin & 1) ? EnemyType::SHAMBERTIN : EnemyType::SAINT_MILLION);
}
break;
}
default:
for (size_t z = 0; z < static_cast<size_t>(e.num_children + 1); z++) {
this->enemies.emplace_back(EnemyType::UNKNOWN);
}
static_game_data_log.warning(
"(Entry %zu, offset %zX in file) Unknown enemy type %04hX",
y, y * sizeof(EnemyEntry), e.base_type.load());
break;
}
}
}
struct DATSectionHeader {
le_uint32_t type; // 1 = objects, 2 = enemies. There are other types too
le_uint32_t section_size; // Includes this header
le_uint32_t area;
le_uint32_t data_size;
} __attribute__((packed));
void Map::add_enemies_and_objects_from_quest_data(
Episode episode,
uint8_t difficulty,
uint8_t event,
const void* data,
size_t size,
const RareEnemyRates& rare_rates) {
StringReader r(data, size);
while (!r.eof()) {
const auto& header = r.get<DATSectionHeader>();
static_game_data_log.info("(DAT:%08zX) type=%08" PRIX32 " area=%08" PRIX32 " data_size=%08" PRIX32,
r.where() - sizeof(DATSectionHeader), header.type.load(), header.area.load(), header.data_size.load());
if (header.type == 0 && header.section_size == 0) {
break;
}
if (header.section_size < sizeof(header)) {
throw runtime_error(string_printf("quest layout has invalid section header at offset 0x%zX", r.where() - sizeof(header)));
}
if (header.type == 1) {
if (header.data_size % sizeof(ObjectEntry)) {
throw runtime_error("quest layout object section size is not a multiple of object entry size");
}
this->add_objects_from_map_data(r.getv(header.data_size), header.data_size);
} else if (header.type == 2) {
if (header.data_size % sizeof(EnemyEntry)) {
throw runtime_error("quest layout enemy section size is not a multiple of enemy entry size");
}
this->add_enemies_from_map_data(episode, difficulty, event, r.getv(header.data_size), header.data_size, rare_rates);
static_game_data_log.info("There are now %zu enemies", this->enemies.size());
} else {
r.skip(header.section_size - sizeof(header));
}
}
}
SetDataTable::SetDataTable(shared_ptr<const string> data, bool big_endian) {
if (big_endian) {
this->load_table_t<true>(data);
} else {
this->load_table_t<false>(data);
}
}
template <bool IsBigEndian>
void SetDataTable::load_table_t(shared_ptr<const string> data) {
using U32T = typename conditional<IsBigEndian, be_uint32_t, le_uint32_t>::type;
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<PSOLFGEncryption> random_crypt,
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_crypt->next() % a->variation1_values.size());
variations[z * 2 + 1] = (a->variation2_values.size() < 2) ? 0 : (random_crypt->next() % a->variation2_values.size());
}
}
}
vector<string> map_filenames_for_variation(
Episode episode, bool is_solo, uint8_t area, uint32_t var1, uint32_t var2, bool is_enemies) {
// 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));
}
// Try both _off<e|o>.dat and <e|o>_s.dat suffixes first before falling back
// to non-solo version
vector<string> ret;
if (is_enemies) {
if (is_solo) {
ret.emplace_back(filename + "_offe.dat");
ret.emplace_back(filename + "e_s.dat");
}
ret.emplace_back(filename + "e.dat");
} else {
if (is_solo) {
ret.emplace_back(filename + "_offo.dat");
ret.emplace_back(filename + "o_s.dat");
}
ret.emplace_back(filename + "o.dat");
}
return ret;
}
const Map::RareEnemyRates Map::NO_RARE_ENEMIES = {
.hildeblue = 0x00000000,
.rappy = 0x00000000,
.nar_lily = 0x00000000,
.pouilly_slime = 0x00000000,
.merissa_aa = 0x00000000,
.pazuzu = 0x00000000,
.dorphon_eclair = 0x00000000,
.kondrieu = 0x00000000,
};
const Map::RareEnemyRates Map::DEFAULT_RARE_ENEMIES = {
// All 1/512 except Kondrieu, which is 1/10
.hildeblue = 0x00800000,
.rappy = 0x00800000,
.nar_lily = 0x00800000,
.pouilly_slime = 0x00800000,
.merissa_aa = 0x00800000,
.pazuzu = 0x00800000,
.dorphon_eclair = 0x00800000,
.kondrieu = 0x1999999A,
};
Reference in New Issue View Git Blame Copy Permalink