update map loader
This commit is contained in:
Martin Michelsen
+272
-317
@@ -9,150 +9,93 @@
|
||||
|
||||
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());
|
||||
}
|
||||
uint64_t Map::Enemy::next_enemy_id = 1;
|
||||
|
||||
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());
|
||||
};
|
||||
Map::Enemy::Enemy(EnemyType type)
|
||||
: id(Map::Enemy::next_enemy_id++),
|
||||
type(type),
|
||||
flags(0),
|
||||
last_hit_by_client_id(0) {}
|
||||
|
||||
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);
|
||||
string Map::Enemy::str() const {
|
||||
return string_printf("[Map::Enemy E-%" PRIX64 " type=%s flags=%02hhX last_hit_by_client_id=%hu]",
|
||||
this->id, name_for_enum(this->type), this->flags, this->last_hit_by_client_id);
|
||||
}
|
||||
|
||||
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;
|
||||
/* 00 */ le_uint32_t base;
|
||||
/* 04 */ le_uint16_t unknown_a1;
|
||||
/* 06 */ le_uint16_t num_clones;
|
||||
/* 08 */ le_uint16_t area;
|
||||
/* 0A */ le_uint16_t unknown_a2;
|
||||
/* 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=%" PRIX32 ", a1=%hX, num_clones=%hX, area=%hX, a2=%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.load(), this->unknown_a1.load(), this->num_clones.load(), this->area.load(),
|
||||
this->unknown_a2.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));
|
||||
|
||||
static uint64_t next_enemy_id = 1;
|
||||
struct ObjectEntry {
|
||||
/* 00 */ le_uint16_t 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_uint32_t unknown_a4;
|
||||
/* 2C */ le_uint32_t unknown_a5;
|
||||
/* 30 */ le_uint32_t 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 */
|
||||
|
||||
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) {
|
||||
string str() const {
|
||||
return string_printf("ObjectEntry(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 ", a3=%" PRIX32 ", a4=%" PRIX32 ", a5=%" PRIX32 ", a6=%" PRIX32 ", a7=%" PRIX32 ", a8=%" PRIX32 ", a9=%" PRIX32 ")",
|
||||
this->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_a3.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());
|
||||
}
|
||||
} __attribute__((packed));
|
||||
|
||||
void Map::clear() {
|
||||
this->enemies.clear();
|
||||
}
|
||||
|
||||
void Map::add_enemies_from_map_data(
|
||||
Episode episode, uint8_t difficulty, uint8_t event, shared_ptr<const string> data) {
|
||||
|
||||
const auto* map = reinterpret_cast<const EnemyEntry*>(data->data());
|
||||
size_t entry_count = data->size() / sizeof(EnemyEntry);
|
||||
@@ -160,290 +103,302 @@ vector<PSOEnemy> parse_map(
|
||||
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++);
|
||||
this->enemies.emplace_back(EnemyType::NONE);
|
||||
}
|
||||
};
|
||||
|
||||
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)");
|
||||
case 0x40:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::HILDEBLUE : EnemyType::HILDEBEAR);
|
||||
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");
|
||||
}
|
||||
case 0x41: {
|
||||
bool is_rare = (e.skin & 0x01);
|
||||
switch (episode) {
|
||||
case Episode::EP1:
|
||||
enemies.emplace_back(is_rare ? EnemyType::AL_RAPPY : EnemyType::RAG_RAPPY);
|
||||
break;
|
||||
case Episode::EP2:
|
||||
switch (event) {
|
||||
case 0x01:
|
||||
enemies.emplace_back(EnemyType::SAINT_RAPPY);
|
||||
break;
|
||||
case 0x04:
|
||||
enemies.emplace_back(EnemyType::EGG_RAPPY);
|
||||
break;
|
||||
case 0x05:
|
||||
enemies.emplace_back(EnemyType::HALLO_RAPPY);
|
||||
break;
|
||||
default:
|
||||
enemies.emplace_back(EnemyType::LOVE_RAPPY);
|
||||
}
|
||||
break;
|
||||
case Episode::EP4:
|
||||
if (e.area > 0x05) {
|
||||
enemies.emplace_back(is_rare ? EnemyType::DEL_RAPPY_ALT : EnemyType::SAND_RAPPY_ALT);
|
||||
} else {
|
||||
enemies.emplace_back(is_rare ? EnemyType::DEL_RAPPY : EnemyType::SAND_RAPPY);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
throw logic_error("invalid episode");
|
||||
}
|
||||
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");
|
||||
}
|
||||
case 0x42:
|
||||
enemies.emplace_back(EnemyType::MONEST);
|
||||
for (size_t x = 0; x < e.num_clones; x++) {
|
||||
enemies.emplace_back((x < 30) ? EnemyType::MOTHMANT : EnemyType::UNKNOWN);
|
||||
}
|
||||
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");
|
||||
case 0x43: {
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::BARBAROUS_WOLF : EnemyType::SAVAGE_WOLF);
|
||||
break;
|
||||
case 0x44: // Booma family
|
||||
create_enemy(e, 0x4B + (e.skin % 3), 9 + (e.skin % 3), "(|Go|Gigo)Booma");
|
||||
}
|
||||
case 0x44:
|
||||
static const EnemyType types[3] = {EnemyType::BOOMA, EnemyType::GOBOOMA, EnemyType::GIGOBOOMA};
|
||||
enemies.emplace_back(types[e.skin % 3]);
|
||||
break;
|
||||
case 0x60: // Grass Assassin
|
||||
create_enemy(e, 0x4E, 12, "Grass Assassin");
|
||||
case 0x60:
|
||||
enemies.emplace_back(EnemyType::GRASS_ASSASSIN);
|
||||
break;
|
||||
case 0x61: // Del Lily, Poison Lily, Nar Lily
|
||||
if ((episode == Episode::EP2) && (alt_enemies)) {
|
||||
create_enemy(e, 0x25, 83, "Del Lily");
|
||||
case 0x61:
|
||||
if ((episode == Episode::EP2) && (e.area > 0x0F)) {
|
||||
enemies.emplace_back(EnemyType::DEL_LILY);
|
||||
} else {
|
||||
create_enemy(e, 0x04 + ((e.reserved[10] & 0x800000) ? 1 : 0),
|
||||
13 + ((e.reserved[10] & 0x800000) ? 1 : 0), "(Poison|Nar) Lily");
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::NAR_LILY : EnemyType::POISON_LILY);
|
||||
}
|
||||
break;
|
||||
case 0x62: // Nano Dragon
|
||||
create_enemy(e, 0x1A, 15, "Nano Dragon");
|
||||
case 0x62:
|
||||
enemies.emplace_back(EnemyType::NANO_DRAGON);
|
||||
break;
|
||||
case 0x63: // Shark family
|
||||
create_enemy(e, 0x4F + (e.skin % 3), 16 + (e.skin % 3), "(Evil|Pal|Guil) Shark");
|
||||
case 0x63: {
|
||||
static const EnemyType types[3] = {EnemyType::EVIL_SHARK, EnemyType::PAL_SHARK, EnemyType::GUIL_SHARK};
|
||||
enemies.emplace_back(types[e.skin % 3]);
|
||||
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");
|
||||
}
|
||||
case 0x64: {
|
||||
bool is_common = ((e.unknown_a4 & 0x800000) ? true : false);
|
||||
for (size_t x = 0; x < 5; x++) { // Main slime + 4 clones
|
||||
enemies.emplace_back(is_common ? EnemyType::POFUILLY_SLIME : EnemyType::POUILLY_SLIME);
|
||||
}
|
||||
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)");
|
||||
}
|
||||
}
|
||||
case 0x65:
|
||||
enemies.emplace_back(EnemyType::PAN_ARMS);
|
||||
enemies.emplace_back(EnemyType::HIDOOM);
|
||||
enemies.emplace_back(EnemyType::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");
|
||||
}
|
||||
case 0x80:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::GILLCHIC : EnemyType::DUBCHIC);
|
||||
break;
|
||||
case 0x81: // Garanz
|
||||
create_enemy(e, 0x1D, 25, "Garanz");
|
||||
case 0x81:
|
||||
enemies.emplace_back(EnemyType::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)");
|
||||
}
|
||||
case 0x82:
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::SINOW_GOLD : EnemyType::SINOW_BEAT);
|
||||
if (e.num_clones == 0) {
|
||||
create_clones(4);
|
||||
}
|
||||
break;
|
||||
case 0x83: // Canadine
|
||||
create_enemy(e, 0x07, 28, "Canadine");
|
||||
case 0x83:
|
||||
enemies.emplace_back(EnemyType::CANADINE);
|
||||
break;
|
||||
case 0x84: // Canadine Group
|
||||
create_enemy(e, 0x09, 29, "Canune");
|
||||
case 0x84:
|
||||
enemies.emplace_back(EnemyType::CANANE);
|
||||
for (size_t x = 0; x < 8; x++) {
|
||||
create_enemy(e, 0x08, 28, "Canadine");
|
||||
enemies.emplace_back(EnemyType::CANADINE);
|
||||
}
|
||||
break;
|
||||
case 0x85: // Dubwitch
|
||||
enemies.emplace_back(next_enemy_id++, e.base, 0xFFFFFFFF, 0, 0, "__dubwitch__");
|
||||
case 0x85:
|
||||
enemies.emplace_back(EnemyType::DUBWITCH);
|
||||
break;
|
||||
case 0xA0: // Delsaber
|
||||
create_enemy(e, 0x52, 30, "Delsaber");
|
||||
case 0xA0:
|
||||
enemies.emplace_back(EnemyType::DELSABER);
|
||||
break;
|
||||
case 0xA1: // Chaos Sorcerer + 2 Bits
|
||||
create_enemy(e, 0x0A, 31, "Chaos Sorcerer");
|
||||
case 0xA1:
|
||||
enemies.emplace_back(EnemyType::CHAOS_SORCERER);
|
||||
create_clones(2);
|
||||
break;
|
||||
case 0xA2: // Dark Gunner
|
||||
create_enemy(e, 0x1E, 34, "Dark Gunner");
|
||||
case 0xA2:
|
||||
enemies.emplace_back(EnemyType::DARK_GUNNER);
|
||||
break;
|
||||
case 0xA4: // Chaos Bringer
|
||||
create_enemy(e, 0x0D, 36, "Chaos Bringer");
|
||||
case 0xA3:
|
||||
enemies.emplace_back(EnemyType::DEATH_GUNNER);
|
||||
break;
|
||||
case 0xA5: // Dark Belra
|
||||
create_enemy(e, 0x0E, 37, "Dark Belra");
|
||||
case 0xA4:
|
||||
enemies.emplace_back(EnemyType::CHAOS_BRINGER);
|
||||
break;
|
||||
case 0xA6: // Dimenian family
|
||||
create_enemy(e, 0x53 + (e.skin % 3), 41 + (e.skin % 3), "(|La|So) Dimenian");
|
||||
case 0xA5:
|
||||
enemies.emplace_back(EnemyType::DARK_BELRA);
|
||||
break;
|
||||
case 0xA7: // Bulclaw + 4 claws
|
||||
create_enemy(e, 0x1F, 40, "Bulclaw");
|
||||
case 0xA6: {
|
||||
static const EnemyType types[3] = {EnemyType::DIMENIAN, EnemyType::LA_DIMENIAN, EnemyType::SO_DIMENIAN};
|
||||
enemies.emplace_back(types[e.skin % 3]);
|
||||
break;
|
||||
}
|
||||
case 0xA7:
|
||||
enemies.emplace_back(EnemyType::BULCLAW);
|
||||
for (size_t x = 0; x < 4; x++) {
|
||||
create_enemy(e, 0x20, 38, "Claw");
|
||||
enemies.emplace_back(EnemyType::CLAW);
|
||||
}
|
||||
break;
|
||||
case 0xA8: // Claw
|
||||
create_enemy(e, 0x20, 38, "Claw");
|
||||
case 0xA8:
|
||||
enemies.emplace_back(EnemyType::CLAW);
|
||||
break;
|
||||
case 0xC0: // Dragon or Gal Gryphon
|
||||
case 0xC0:
|
||||
if (episode == Episode::EP1) {
|
||||
create_enemy(e, 0x12, 44, "Dragon");
|
||||
enemies.emplace_back(EnemyType::DRAGON);
|
||||
} else if (episode == Episode::EP2) {
|
||||
create_enemy(e, 0x1E, 77, "Gal Gryphon");
|
||||
enemies.emplace_back(EnemyType::GAL_GRYPHON);
|
||||
} else {
|
||||
throw runtime_error("DRAGON-type enemy placed outside of Episodes 1 or 2");
|
||||
}
|
||||
break;
|
||||
case 0xC1: // De Rol Le
|
||||
create_enemy(e, 0x0F, 45, "De Rol Le");
|
||||
case 0xC1:
|
||||
enemies.emplace_back(EnemyType::DE_ROL_LE);
|
||||
break;
|
||||
case 0xC2: // Vol Opt form 1
|
||||
enemies.emplace_back(next_enemy_id++, e.base, 0xFFFFFFFF, 0, 0, "__vol_opt_1__");
|
||||
case 0xC2:
|
||||
enemies.emplace_back(EnemyType::VOL_OPT_1);
|
||||
break;
|
||||
case 0xC5: // Vol Opt form 2
|
||||
create_enemy(e, 0x25, 46, "Vol Opt");
|
||||
case 0xC5:
|
||||
enemies.emplace_back(EnemyType::VOL_OPT_2);
|
||||
break;
|
||||
case 0xC8: // Dark Falz + 510 Darvants
|
||||
case 0xC8:
|
||||
if (difficulty) {
|
||||
create_enemy(e, 0x38, 47, "Dark Falz 3"); // Final form
|
||||
enemies.emplace_back(EnemyType::DARK_FALZ_3);
|
||||
} else {
|
||||
create_enemy(e, 0x37, 47, "Dark Falz 2"); // Second form
|
||||
enemies.emplace_back(EnemyType::DARK_FALZ_2);
|
||||
}
|
||||
for (size_t x = 0; x < 510; x++) {
|
||||
create_enemy(e, 0x35, 0, "Darvant");
|
||||
enemies.emplace_back(difficulty == 3 ? EnemyType::DARVANT_ULTIMATE : EnemyType::DARVANT);
|
||||
}
|
||||
break;
|
||||
case 0xCA: // Olga Flow
|
||||
create_enemy(e, 0x2C, 78, "Olga Flow");
|
||||
case 0xCA:
|
||||
enemies.emplace_back(EnemyType::OLGA_FLOW_2);
|
||||
create_clones(0x200);
|
||||
break;
|
||||
case 0xCB: // Barba Ray
|
||||
create_enemy(e, 0x0F, 73, "Barba Ray");
|
||||
case 0xCB:
|
||||
enemies.emplace_back(EnemyType::BARBA_RAY);
|
||||
create_clones(0x2F);
|
||||
break;
|
||||
case 0xCC: // Gol Dragon
|
||||
create_enemy(e, 0x12, 76, "Gol Dragon");
|
||||
case 0xCC:
|
||||
enemies.emplace_back(EnemyType::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)");
|
||||
case 0xD4:
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::SINOW_SPIGELL : EnemyType::SINOW_BERILL);
|
||||
create_clones(4);
|
||||
break;
|
||||
case 0xD5: // Merillia & Meriltas
|
||||
create_enemy(e, 0x4B + (e.skin & 0x01), 52 + (e.skin & 0x01), "Meril(lia|tas)");
|
||||
case 0xD5:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::MERILTAS : EnemyType::MERILLIA);
|
||||
break;
|
||||
case 0xD6: // Mericus, Merikle, & Mericarol
|
||||
if (e.skin) {
|
||||
create_enemy(e, 0x44 + (e.skin % 3), 56 + (e.skin % 3), "Meri(cus|kle|carol)");
|
||||
case 0xD6:
|
||||
if (e.skin == 0) {
|
||||
enemies.emplace_back(EnemyType::MERICAROL);
|
||||
} else {
|
||||
create_enemy(e, 0x3A, 56 + (e.skin % 3), "Meri(cus|kle|carol)");
|
||||
enemies.emplace_back(((e.skin % 3) == 2) ? EnemyType::MERICUS : EnemyType::MERIKLE);
|
||||
}
|
||||
break;
|
||||
case 0xD7: // Ul Gibbon and Zol Gibbon
|
||||
create_enemy(e, 0x3B + (e.skin & 0x01), 59 + (e.skin & 0x01), "(Ul|Zol) Gibbon");
|
||||
case 0xD7:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::ZOL_GIBBON : EnemyType::UL_GIBBON);
|
||||
break;
|
||||
case 0xD8: // Gibbles
|
||||
create_enemy(e, 0x3D, 61, "Gibbles");
|
||||
case 0xD8:
|
||||
enemies.emplace_back(EnemyType::GIBBLES);
|
||||
break;
|
||||
case 0xD9: // Gee
|
||||
create_enemy(e, 0x07, 54, "Gee");
|
||||
case 0xD9:
|
||||
enemies.emplace_back(EnemyType::GEE);
|
||||
break;
|
||||
case 0xDA: // Gi Gue
|
||||
create_enemy(e, 0x1A, 55, "Gi Gue");
|
||||
case 0xDA:
|
||||
enemies.emplace_back(EnemyType::GI_GUE);
|
||||
break;
|
||||
case 0xDB: // Deldepth
|
||||
create_enemy(e, 0x30, 71, "Deldepth");
|
||||
case 0xDB:
|
||||
enemies.emplace_back(EnemyType::DELDEPTH);
|
||||
break;
|
||||
case 0xDC: // Delbiter
|
||||
create_enemy(e, 0x0D, 72, "Delbiter");
|
||||
case 0xDC:
|
||||
enemies.emplace_back(EnemyType::DELBITER);
|
||||
break;
|
||||
case 0xDD: // Dolmolm and Dolmdarl
|
||||
create_enemy(e, 0x4F + (e.skin & 0x01), 64 + (e.skin & 0x01), "Dolm(olm|darl)");
|
||||
case 0xDD:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::DOLMDARL : EnemyType::DOLMOLM);
|
||||
break;
|
||||
case 0xDE: // Morfos
|
||||
create_enemy(e, 0x40, 66, "Morfos");
|
||||
case 0xDE:
|
||||
enemies.emplace_back(EnemyType::MORFOS);
|
||||
break;
|
||||
case 0xDF: // Recobox & Recons
|
||||
create_enemy(e, 0x41, 67, "Recobox");
|
||||
case 0xDF:
|
||||
enemies.emplace_back(EnemyType::RECOBOX);
|
||||
for (size_t x = 0; x < e.num_clones; x++) {
|
||||
create_enemy(e, 0x42, 68, "Recon");
|
||||
enemies.emplace_back(EnemyType::RECON);
|
||||
}
|
||||
break;
|
||||
case 0xE0: // Epsilon, Sinow Zoa and Zele
|
||||
if ((episode == Episode::EP2) && (alt_enemies)) {
|
||||
create_enemy(e, 0x23, 84, "Epsilon");
|
||||
case 0xE0:
|
||||
if ((episode == Episode::EP2) && (e.area > 0x0F)) {
|
||||
enemies.emplace_back(EnemyType::EPSILON);
|
||||
create_clones(4);
|
||||
} else {
|
||||
create_enemy(e, 0x43 + (e.skin & 0x01), 69 + (e.skin & 0x01), "Sinow Z(oa|ele)");
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::SINOW_ZELE : EnemyType::SINOW_ZOA);
|
||||
}
|
||||
break;
|
||||
case 0xE1: // Ill Gill
|
||||
create_enemy(e, 0x26, 82, "Ill Gill");
|
||||
case 0xE1:
|
||||
enemies.emplace_back(EnemyType::ILL_GILL);
|
||||
break;
|
||||
case 0x0110: // Astark
|
||||
create_enemy(e, 0x09, 1, "Astark");
|
||||
case 0x0110:
|
||||
enemies.emplace_back(EnemyType::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");
|
||||
case 0x0111:
|
||||
if (e.area > 0x05) {
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::YOWIE_ALT : EnemyType::SATELLITE_LIZARD_ALT);
|
||||
} else {
|
||||
create_enemy(e, 0x00 + (e.skin % 3), 9 + (e.skin % 3), "(|Ba|Ze) Boota");
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::YOWIE : EnemyType::SATELLITE_LIZARD);
|
||||
}
|
||||
break;
|
||||
case 0x0116: // Dorphon and Eclair
|
||||
create_enemy(e, 0x0F + (e.skin & 0x01), 12 + (e.skin & 0x01), "Dorphon( Eclair)?");
|
||||
case 0x0112:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::MERISSA_AA : EnemyType::MERISSA_A);
|
||||
break;
|
||||
case 0x0117: // Goran family
|
||||
create_enemy(e, 0x11 + (e.skin % 3), (e.skin & 2) ? 15 : ((e.skin & 1) ? 16 : 14), "(Pyro )?Goran( Detonator)?");
|
||||
case 0x0113:
|
||||
enemies.emplace_back(EnemyType::GIRTABLULU);
|
||||
break;
|
||||
case 0x0114:
|
||||
if (e.area > 0x05) {
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::PAZUZU_ALT : EnemyType::ZU_ALT);
|
||||
} else {
|
||||
enemies.emplace_back((e.unknown_a4 & 0x800000) ? EnemyType::PAZUZU : EnemyType::ZU);
|
||||
}
|
||||
break;
|
||||
case 0x0115:
|
||||
if (e.skin & 2) {
|
||||
enemies.emplace_back(EnemyType::BA_BOOTA);
|
||||
} else {
|
||||
enemies.emplace_back((e.skin & 1) ? EnemyType::ZE_BOOTA : EnemyType::BOOTA);
|
||||
}
|
||||
break;
|
||||
case 0x0116:
|
||||
enemies.emplace_back((e.skin & 0x01) ? EnemyType::DORPHON_ECLAIR : EnemyType::DORPHON);
|
||||
break;
|
||||
case 0x0117: {
|
||||
static const EnemyType types[3] = {EnemyType::GORAN, EnemyType::PYRO_GORAN, EnemyType::GORAN_DETONATOR};
|
||||
enemies.emplace_back(types[e.skin % 3]);
|
||||
break;
|
||||
}
|
||||
case 0x0119: // Saint-Million, Shambertin, Kondrieu
|
||||
create_enemy(e, 0x22,
|
||||
(e.reserved[10] & 0x800000) ? 21 : (19 + (e.skin & 0x01)),
|
||||
"(Saint-Million|Shambertin|Kondrieu)");
|
||||
if (e.unknown_a4 & 0x800000) {
|
||||
enemies.emplace_back(EnemyType::KONDRIEU);
|
||||
} else {
|
||||
enemies.emplace_back((e.skin & 1) ? EnemyType::SHAMBERTIN : EnemyType::SAINT_MILLION);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
enemies.emplace_back(next_enemy_id++, e.base, 0xFFFFFFFF, 0, 0, "__unknown__");
|
||||
enemies.emplace_back(EnemyType::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);
|
||||
y, y * sizeof(EnemyEntry), e.base.load(), e.skin.load());
|
||||
break;
|
||||
}
|
||||
create_clones(e.num_clones);
|
||||
}
|
||||
|
||||
return enemies;
|
||||
}
|
||||
|
||||
SetDataTable::SetDataTable(shared_ptr<const string> data, bool big_endian) {
|
||||
|
||||
Reference in New Issue
Block a user