incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

make EXP computation match the client

Browse Source
This commit is contained in:
Martin Michelsen
2023-11-13 17:56:26 -08:00
parent 1ca0e928a4
commit a1b457a5e6
8 changed files with 155 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/CommandFormats.hh
+1 -1
View File
@@ -2744,7 +2744,7 @@ struct C_SetChallengeModeDifficulty_BB_03DF {
} __packed__; } __packed__;
struct C_SetChallengeModeEXPMultiplier_BB_04DF { struct C_SetChallengeModeEXPMultiplier_BB_04DF {
le_float exp_multiplier = 0; le_float exp_multiplier = 1.0f;
} __packed__; } __packed__;
struct C_SetChallengeRankText_BB_05DF { struct C_SetChallengeRankText_BB_05DF {
src/Lobby.cc
+2 -1
View File
@@ -23,7 +23,8 @@ Lobby::Lobby(shared_ptr<ServerState> s, uint32_t id)
episode(Episode::NONE), episode(Episode::NONE),
mode(GameMode::NORMAL), mode(GameMode::NORMAL),
difficulty(0), difficulty(0),
exp_multiplier(1.0f), base_exp_multiplier(1),
challenge_exp_multiplier(1.0f),
random_seed(random_object<uint32_t>()), random_seed(random_object<uint32_t>()),
event(0), event(0),
block(0), block(0),
src/Lobby.hh
+2 -1
View File
@@ -82,7 +82,8 @@ struct Lobby : public std::enable_shared_from_this<Lobby> {
Episode episode; Episode episode;
GameMode mode; GameMode mode;
uint8_t difficulty; // 0-3 uint8_t difficulty; // 0-3
float exp_multiplier; uint16_t base_exp_multiplier;
float challenge_exp_multiplier;
std::string password; std::string password;
std::string name; std::string name;
// This seed is also sent to the client for rare enemy generation // This seed is also sent to the client for rare enemy generation
src/Map.cc
+104 -98
View File
@@ -62,45 +62,46 @@ void Map::add_enemy(
Episode episode, Episode episode,
uint8_t difficulty, uint8_t difficulty,
uint8_t event, uint8_t event,
uint8_t floor,
size_t index, size_t index,
const EnemyEntry& e, const EnemyEntry& e,
const RareEnemyRates& rare_rates) { const RareEnemyRates& rare_rates) {
switch (e.base_type) { switch (e.base_type) {
case 0x40: { case 0x40: {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.hildeblue); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.hildeblue);
this->add_enemy(e.floor, is_rare ? EnemyType::HILDEBLUE : EnemyType::HILDEBEAR); this->add_enemy(floor, is_rare ? EnemyType::HILDEBLUE : EnemyType::HILDEBEAR);
break; break;
} }
case 0x41: { case 0x41: {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.rappy); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.rappy);
switch (episode) { switch (episode) {
case Episode::EP1: case Episode::EP1:
this->add_enemy(e.floor, is_rare ? EnemyType::AL_RAPPY : EnemyType::RAG_RAPPY); this->add_enemy(floor, is_rare ? EnemyType::AL_RAPPY : EnemyType::RAG_RAPPY);
break; break;
case Episode::EP2: case Episode::EP2:
if (is_rare) { if (is_rare) {
switch (event) { switch (event) {
case 0x01: case 0x01:
this->add_enemy(e.floor, EnemyType::SAINT_RAPPY); this->add_enemy(floor, EnemyType::SAINT_RAPPY);
break; break;
case 0x04: case 0x04:
this->add_enemy(e.floor, EnemyType::EGG_RAPPY); this->add_enemy(floor, EnemyType::EGG_RAPPY);
break; break;
case 0x05: case 0x05:
this->add_enemy(e.floor, EnemyType::HALLO_RAPPY); this->add_enemy(floor, EnemyType::HALLO_RAPPY);
break; break;
default: default:
this->add_enemy(e.floor, EnemyType::LOVE_RAPPY); this->add_enemy(floor, EnemyType::LOVE_RAPPY);
} }
} else { } else {
this->add_enemy(e.floor, EnemyType::RAG_RAPPY); this->add_enemy(floor, EnemyType::RAG_RAPPY);
} }
break; break;
case Episode::EP4: case Episode::EP4:
if (e.floor > 0x05) { if (e.floor > 0x05) {
this->add_enemy(e.floor, is_rare ? EnemyType::DEL_RAPPY_ALT : EnemyType::SAND_RAPPY_ALT); this->add_enemy(floor, is_rare ? EnemyType::DEL_RAPPY_ALT : EnemyType::SAND_RAPPY_ALT);
} else { } else {
this->add_enemy(e.floor, is_rare ? EnemyType::DEL_RAPPY : EnemyType::SAND_RAPPY); this->add_enemy(floor, is_rare ? EnemyType::DEL_RAPPY : EnemyType::SAND_RAPPY);
} }
break; break;
default: default:
@@ -109,292 +110,292 @@ void Map::add_enemy(
break; break;
} }
case 0x42: { case 0x42: {
this->add_enemy(e.floor, EnemyType::MONEST); this->add_enemy(floor, EnemyType::MONEST);
for (size_t x = 0; x < 30; x++) { for (size_t x = 0; x < 30; x++) {
this->add_enemy(e.floor, EnemyType::MOTHMANT); this->add_enemy(floor, EnemyType::MOTHMANT);
} }
break; break;
} }
case 0x43: { case 0x43: {
this->add_enemy(e.floor, e.fparam2 ? EnemyType::BARBAROUS_WOLF : EnemyType::SAVAGE_WOLF); this->add_enemy(floor, e.fparam2 ? EnemyType::BARBAROUS_WOLF : EnemyType::SAVAGE_WOLF);
break; break;
} }
case 0x44: case 0x44:
static const EnemyType types[3] = {EnemyType::BOOMA, EnemyType::GOBOOMA, EnemyType::GIGOBOOMA}; static const EnemyType types[3] = {EnemyType::BOOMA, EnemyType::GOBOOMA, EnemyType::GIGOBOOMA};
this->add_enemy(e.floor, types[e.uparam1 % 3]); this->add_enemy(floor, types[e.uparam1 % 3]);
break; break;
case 0x60: case 0x60:
this->add_enemy(e.floor, EnemyType::GRASS_ASSASSIN); this->add_enemy(floor, EnemyType::GRASS_ASSASSIN);
break; break;
case 0x61: case 0x61:
if ((episode == Episode::EP2) && (e.floor > 0x0F)) { if ((episode == Episode::EP2) && (e.floor > 0x0F)) {
this->add_enemy(e.floor, EnemyType::DEL_LILY); this->add_enemy(floor, EnemyType::DEL_LILY);
} else { } else {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.nar_lily); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.nar_lily);
this->add_enemy(e.floor, is_rare ? EnemyType::NAR_LILY : EnemyType::POISON_LILY); this->add_enemy(floor, is_rare ? EnemyType::NAR_LILY : EnemyType::POISON_LILY);
} }
break; break;
case 0x62: case 0x62:
this->add_enemy(e.floor, EnemyType::NANO_DRAGON); this->add_enemy(floor, EnemyType::NANO_DRAGON);
break; break;
case 0x63: { case 0x63: {
static const EnemyType types[3] = {EnemyType::EVIL_SHARK, EnemyType::PAL_SHARK, EnemyType::GUIL_SHARK}; static const EnemyType types[3] = {EnemyType::EVIL_SHARK, EnemyType::PAL_SHARK, EnemyType::GUIL_SHARK};
this->add_enemy(e.floor, types[e.uparam1 % 3]); this->add_enemy(floor, types[e.uparam1 % 3]);
break; break;
} }
case 0x64: { case 0x64: {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.pouilly_slime); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.pouilly_slime);
for (size_t x = 0; x < 5; x++) { // Main slime + 4 clones for (size_t x = 0; x < 5; x++) { // Main slime + 4 clones
this->add_enemy(e.floor, is_rare ? EnemyType::POFUILLY_SLIME : EnemyType::POUILLY_SLIME); this->add_enemy(floor, is_rare ? EnemyType::POFUILLY_SLIME : EnemyType::POUILLY_SLIME);
} }
break; break;
} }
case 0x65: case 0x65:
this->add_enemy(e.floor, EnemyType::PAN_ARMS); this->add_enemy(floor, EnemyType::PAN_ARMS);
this->add_enemy(e.floor, EnemyType::HIDOOM); this->add_enemy(floor, EnemyType::HIDOOM);
this->add_enemy(e.floor, EnemyType::MIGIUM); this->add_enemy(floor, EnemyType::MIGIUM);
break; break;
case 0x80: case 0x80:
this->add_enemy(e.floor, (e.uparam1 & 0x01) ? EnemyType::GILLCHIC : EnemyType::DUBCHIC); this->add_enemy(floor, (e.uparam1 & 0x01) ? EnemyType::GILLCHIC : EnemyType::DUBCHIC);
break; break;
case 0x81: case 0x81:
this->add_enemy(e.floor, EnemyType::GARANZ); this->add_enemy(floor, EnemyType::GARANZ);
break; break;
case 0x82: { case 0x82: {
EnemyType type = e.fparam2 ? EnemyType::SINOW_GOLD : EnemyType::SINOW_BEAT; EnemyType type = e.fparam2 ? EnemyType::SINOW_GOLD : EnemyType::SINOW_BEAT;
size_t count = (e.num_children == 0) ? 5 : (e.num_children + 1); size_t count = (e.num_children == 0) ? 5 : (e.num_children + 1);
for (size_t z = 0; z < count; z++) { for (size_t z = 0; z < count; z++) {
this->add_enemy(e.floor, type); this->add_enemy(floor, type);
} }
break; break;
} }
case 0x83: case 0x83:
this->add_enemy(e.floor, EnemyType::CANADINE); this->add_enemy(floor, EnemyType::CANADINE);
break; break;
case 0x84: case 0x84:
this->add_enemy(e.floor, EnemyType::CANANE); this->add_enemy(floor, EnemyType::CANANE);
for (size_t x = 0; x < 8; x++) { for (size_t x = 0; x < 8; x++) {
this->add_enemy(e.floor, EnemyType::CANADINE_GROUP); this->add_enemy(floor, EnemyType::CANADINE_GROUP);
} }
break; break;
case 0x85: case 0x85:
this->add_enemy(e.floor, EnemyType::DUBWITCH); this->add_enemy(floor, EnemyType::DUBWITCH);
break; break;
case 0xA0: case 0xA0:
this->add_enemy(e.floor, EnemyType::DELSABER); this->add_enemy(floor, EnemyType::DELSABER);
break; break;
case 0xA1: case 0xA1:
this->add_enemy(e.floor, EnemyType::CHAOS_SORCERER); this->add_enemy(floor, EnemyType::CHAOS_SORCERER);
this->add_enemy(e.floor, EnemyType::BEE_R); this->add_enemy(floor, EnemyType::BEE_R);
this->add_enemy(e.floor, EnemyType::BEE_L); this->add_enemy(floor, EnemyType::BEE_L);
break; break;
case 0xA2: case 0xA2:
this->add_enemy(e.floor, EnemyType::DARK_GUNNER); this->add_enemy(floor, EnemyType::DARK_GUNNER);
break; break;
case 0xA3: case 0xA3:
this->add_enemy(e.floor, EnemyType::DEATH_GUNNER); this->add_enemy(floor, EnemyType::DEATH_GUNNER);
break; break;
case 0xA4: case 0xA4:
this->add_enemy(e.floor, EnemyType::CHAOS_BRINGER); this->add_enemy(floor, EnemyType::CHAOS_BRINGER);
break; break;
case 0xA5: case 0xA5:
this->add_enemy(e.floor, EnemyType::DARK_BELRA); this->add_enemy(floor, EnemyType::DARK_BELRA);
break; break;
case 0xA6: { case 0xA6: {
static const EnemyType types[3] = {EnemyType::DIMENIAN, EnemyType::LA_DIMENIAN, EnemyType::SO_DIMENIAN}; static const EnemyType types[3] = {EnemyType::DIMENIAN, EnemyType::LA_DIMENIAN, EnemyType::SO_DIMENIAN};
this->add_enemy(e.floor, types[e.uparam1 % 3]); this->add_enemy(floor, types[e.uparam1 % 3]);
break; break;
} }
case 0xA7: case 0xA7:
this->add_enemy(e.floor, EnemyType::BULCLAW); this->add_enemy(floor, EnemyType::BULCLAW);
for (size_t x = 0; x < 4; x++) { for (size_t x = 0; x < 4; x++) {
this->add_enemy(e.floor, EnemyType::CLAW); this->add_enemy(floor, EnemyType::CLAW);
} }
break; break;
case 0xA8: case 0xA8:
this->add_enemy(e.floor, EnemyType::CLAW); this->add_enemy(floor, EnemyType::CLAW);
break; break;
case 0xC0: case 0xC0:
if (episode == Episode::EP1) { if (episode == Episode::EP1) {
this->add_enemy(e.floor, EnemyType::DRAGON); this->add_enemy(floor, EnemyType::DRAGON);
} else if (episode == Episode::EP2) { } else if (episode == Episode::EP2) {
this->add_enemy(e.floor, EnemyType::GAL_GRYPHON); this->add_enemy(floor, EnemyType::GAL_GRYPHON);
} else { } else {
throw runtime_error("DRAGON-type enemy placed outside of Episodes 1 or 2"); throw runtime_error("DRAGON-type enemy placed outside of Episodes 1 or 2");
} }
break; break;
case 0xC1: case 0xC1:
this->add_enemy(e.floor, EnemyType::DE_ROL_LE); this->add_enemy(floor, EnemyType::DE_ROL_LE);
for (size_t z = 0; z < 0x0A; z++) { for (size_t z = 0; z < 0x0A; z++) {
this->add_enemy(e.floor, EnemyType::DE_ROL_LE_BODY); this->add_enemy(floor, EnemyType::DE_ROL_LE_BODY);
} }
for (size_t z = 0; z < 0x09; z++) { for (size_t z = 0; z < 0x09; z++) {
this->add_enemy(e.floor, EnemyType::DE_ROL_LE_MINE); this->add_enemy(floor, EnemyType::DE_ROL_LE_MINE);
} }
break; break;
case 0xC2: case 0xC2:
this->add_enemy(e.floor, EnemyType::VOL_OPT_1); this->add_enemy(floor, EnemyType::VOL_OPT_1);
for (size_t z = 0; z < 6; z++) { for (size_t z = 0; z < 6; z++) {
this->add_enemy(e.floor, EnemyType::VOL_OPT_PILLAR); this->add_enemy(floor, EnemyType::VOL_OPT_PILLAR);
} }
for (size_t z = 0; z < 24; z++) { for (size_t z = 0; z < 24; z++) {
this->add_enemy(e.floor, EnemyType::VOL_OPT_MONITOR); this->add_enemy(floor, EnemyType::VOL_OPT_MONITOR);
} }
for (size_t z = 0; z < 2; z++) { for (size_t z = 0; z < 2; z++) {
this->add_enemy(e.floor, EnemyType::NONE); this->add_enemy(floor, EnemyType::NONE);
} }
this->add_enemy(e.floor, EnemyType::VOL_OPT_AMP); this->add_enemy(floor, EnemyType::VOL_OPT_AMP);
this->add_enemy(e.floor, EnemyType::VOL_OPT_CORE); this->add_enemy(floor, EnemyType::VOL_OPT_CORE);
this->add_enemy(e.floor, EnemyType::NONE); this->add_enemy(floor, EnemyType::NONE);
break; break;
case 0xC5: case 0xC5:
this->add_enemy(e.floor, EnemyType::VOL_OPT_2); this->add_enemy(floor, EnemyType::VOL_OPT_2);
break; break;
case 0xC8: case 0xC8:
if (difficulty) { if (difficulty) {
this->add_enemy(e.floor, EnemyType::DARK_FALZ_3); this->add_enemy(floor, EnemyType::DARK_FALZ_3);
} else { } else {
this->add_enemy(e.floor, EnemyType::DARK_FALZ_2); this->add_enemy(floor, EnemyType::DARK_FALZ_2);
} }
for (size_t x = 0; x < 0x1FD; x++) { for (size_t x = 0; x < 0x1FD; x++) {
this->add_enemy(e.floor, difficulty == 3 ? EnemyType::DARVANT_ULTIMATE : EnemyType::DARVANT); this->add_enemy(floor, difficulty == 3 ? EnemyType::DARVANT_ULTIMATE : EnemyType::DARVANT);
} }
this->add_enemy(e.floor, EnemyType::DARK_FALZ_3); this->add_enemy(floor, EnemyType::DARK_FALZ_3);
this->add_enemy(e.floor, EnemyType::DARK_FALZ_2); this->add_enemy(floor, EnemyType::DARK_FALZ_2);
this->add_enemy(e.floor, EnemyType::DARK_FALZ_1); this->add_enemy(floor, EnemyType::DARK_FALZ_1);
break; break;
case 0xCA: case 0xCA:
for (size_t z = 0; z < 0x201; z++) { for (size_t z = 0; z < 0x201; z++) {
this->add_enemy(e.floor, EnemyType::OLGA_FLOW_2); this->add_enemy(floor, EnemyType::OLGA_FLOW_2);
} }
break; break;
case 0xCB: case 0xCB:
this->add_enemy(e.floor, EnemyType::BARBA_RAY); this->add_enemy(floor, EnemyType::BARBA_RAY);
for (size_t z = 0; z < 0x2F; z++) { for (size_t z = 0; z < 0x2F; z++) {
this->add_enemy(e.floor, EnemyType::PIG_RAY); this->add_enemy(floor, EnemyType::PIG_RAY);
} }
break; break;
case 0xCC: case 0xCC:
for (size_t z = 0; z < 6; z++) { for (size_t z = 0; z < 6; z++) {
this->add_enemy(e.floor, EnemyType::GOL_DRAGON); this->add_enemy(floor, EnemyType::GOL_DRAGON);
} }
break; break;
case 0xD4: { case 0xD4: {
EnemyType type = (e.uparam1 & 1) ? EnemyType::SINOW_SPIGELL : EnemyType::SINOW_BERILL; EnemyType type = (e.uparam1 & 1) ? EnemyType::SINOW_SPIGELL : EnemyType::SINOW_BERILL;
for (size_t z = 0; z < 5; z++) { for (size_t z = 0; z < 5; z++) {
this->add_enemy(e.floor, type); this->add_enemy(floor, type);
} }
break; break;
} }
case 0xD5: case 0xD5:
this->add_enemy(e.floor, (e.uparam1 & 0x01) ? EnemyType::MERILTAS : EnemyType::MERILLIA); this->add_enemy(floor, (e.uparam1 & 0x01) ? EnemyType::MERILTAS : EnemyType::MERILLIA);
break; break;
case 0xD6: case 0xD6:
if (e.uparam1 == 0) { if (e.uparam1 == 0) {
this->add_enemy(e.floor, EnemyType::MERICAROL); this->add_enemy(floor, EnemyType::MERICAROL);
} else { } else {
this->add_enemy(e.floor, ((e.uparam1 % 3) == 2) ? EnemyType::MERICUS : EnemyType::MERIKLE); this->add_enemy(floor, ((e.uparam1 % 3) == 2) ? EnemyType::MERICUS : EnemyType::MERIKLE);
} }
break; break;
case 0xD7: case 0xD7:
this->add_enemy(e.floor, (e.uparam1 & 0x01) ? EnemyType::ZOL_GIBBON : EnemyType::UL_GIBBON); this->add_enemy(floor, (e.uparam1 & 0x01) ? EnemyType::ZOL_GIBBON : EnemyType::UL_GIBBON);
break; break;
case 0xD8: case 0xD8:
this->add_enemy(e.floor, EnemyType::GIBBLES); this->add_enemy(floor, EnemyType::GIBBLES);
break; break;
case 0xD9: case 0xD9:
this->add_enemy(e.floor, EnemyType::GEE); this->add_enemy(floor, EnemyType::GEE);
break; break;
case 0xDA: case 0xDA:
this->add_enemy(e.floor, EnemyType::GI_GUE); this->add_enemy(floor, EnemyType::GI_GUE);
break; break;
case 0xDB: case 0xDB:
this->add_enemy(e.floor, EnemyType::DELDEPTH); this->add_enemy(floor, EnemyType::DELDEPTH);
break; break;
case 0xDC: case 0xDC:
this->add_enemy(e.floor, EnemyType::DELBITER); this->add_enemy(floor, EnemyType::DELBITER);
break; break;
case 0xDD: case 0xDD:
this->add_enemy(e.floor, (e.uparam1 & 0x01) ? EnemyType::DOLMDARL : EnemyType::DOLMOLM); this->add_enemy(floor, (e.uparam1 & 0x01) ? EnemyType::DOLMDARL : EnemyType::DOLMOLM);
break; break;
case 0xDE: case 0xDE:
this->add_enemy(e.floor, EnemyType::MORFOS); this->add_enemy(floor, EnemyType::MORFOS);
break; break;
case 0xDF: case 0xDF:
this->add_enemy(e.floor, EnemyType::RECOBOX); this->add_enemy(floor, EnemyType::RECOBOX);
for (size_t x = 0; x < e.num_children; x++) { for (size_t x = 0; x < e.num_children; x++) {
this->add_enemy(e.floor, EnemyType::RECON); this->add_enemy(floor, EnemyType::RECON);
} }
break; break;
case 0xE0: case 0xE0:
if ((episode == Episode::EP2) && (e.floor > 0x0F)) { if ((episode == Episode::EP2) && (e.floor > 0x0F)) {
this->add_enemy(e.floor, EnemyType::EPSILON); this->add_enemy(floor, EnemyType::EPSILON);
for (size_t z = 0; z < 4; z++) { for (size_t z = 0; z < 4; z++) {
this->add_enemy(e.floor, EnemyType::EPSIGUARD); this->add_enemy(floor, EnemyType::EPSIGUARD);
} }
} else { } else {
this->add_enemy(e.floor, (e.uparam1 & 0x01) ? EnemyType::SINOW_ZELE : EnemyType::SINOW_ZOA); this->add_enemy(floor, (e.uparam1 & 0x01) ? EnemyType::SINOW_ZELE : EnemyType::SINOW_ZOA);
} }
break; break;
case 0xE1: case 0xE1:
this->add_enemy(e.floor, EnemyType::ILL_GILL); this->add_enemy(floor, EnemyType::ILL_GILL);
break; break;
case 0x0110: case 0x0110:
this->add_enemy(e.floor, EnemyType::ASTARK); this->add_enemy(floor, EnemyType::ASTARK);
break; break;
case 0x0111: case 0x0111:
if (e.floor > 0x05) { if (e.floor > 0x05) {
this->add_enemy(e.floor, e.fparam2 ? EnemyType::YOWIE_ALT : EnemyType::SATELLITE_LIZARD_ALT); this->add_enemy(floor, e.fparam2 ? EnemyType::YOWIE_ALT : EnemyType::SATELLITE_LIZARD_ALT);
} else { } else {
this->add_enemy(e.floor, e.fparam2 ? EnemyType::YOWIE : EnemyType::SATELLITE_LIZARD); this->add_enemy(floor, e.fparam2 ? EnemyType::YOWIE : EnemyType::SATELLITE_LIZARD);
} }
break; break;
case 0x0112: { case 0x0112: {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.merissa_aa); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.merissa_aa);
this->add_enemy(e.floor, is_rare ? EnemyType::MERISSA_AA : EnemyType::MERISSA_A); this->add_enemy(floor, is_rare ? EnemyType::MERISSA_AA : EnemyType::MERISSA_A);
break; break;
} }
case 0x0113: case 0x0113:
this->add_enemy(e.floor, EnemyType::GIRTABLULU); this->add_enemy(floor, EnemyType::GIRTABLULU);
break; break;
case 0x0114: { case 0x0114: {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.pazuzu); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.pazuzu);
if (e.floor > 0x05) { if (e.floor > 0x05) {
this->add_enemy(e.floor, is_rare ? EnemyType::PAZUZU_ALT : EnemyType::ZU_ALT); this->add_enemy(floor, is_rare ? EnemyType::PAZUZU_ALT : EnemyType::ZU_ALT);
} else { } else {
this->add_enemy(e.floor, is_rare ? EnemyType::PAZUZU : EnemyType::ZU); this->add_enemy(floor, is_rare ? EnemyType::PAZUZU : EnemyType::ZU);
} }
break; break;
} }
case 0x0115: case 0x0115:
if (e.uparam1 & 2) { if (e.uparam1 & 2) {
this->add_enemy(e.floor, EnemyType::BA_BOOTA); this->add_enemy(floor, EnemyType::BA_BOOTA);
} else { } else {
this->add_enemy(e.floor, (e.uparam1 & 1) ? EnemyType::ZE_BOOTA : EnemyType::BOOTA); this->add_enemy(floor, (e.uparam1 & 1) ? EnemyType::ZE_BOOTA : EnemyType::BOOTA);
} }
break; break;
case 0x0116: { case 0x0116: {
bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.dorphon_eclair); bool is_rare = this->check_and_log_rare_enemy(e.uparam1 & 0x01, rare_rates.dorphon_eclair);
this->add_enemy(e.floor, is_rare ? EnemyType::DORPHON_ECLAIR : EnemyType::DORPHON); this->add_enemy(floor, is_rare ? EnemyType::DORPHON_ECLAIR : EnemyType::DORPHON);
break; break;
} }
case 0x0117: { case 0x0117: {
static const EnemyType types[3] = {EnemyType::GORAN, EnemyType::PYRO_GORAN, EnemyType::GORAN_DETONATOR}; static const EnemyType types[3] = {EnemyType::GORAN, EnemyType::PYRO_GORAN, EnemyType::GORAN_DETONATOR};
this->add_enemy(e.floor, types[e.uparam1 % 3]); this->add_enemy(floor, types[e.uparam1 % 3]);
break; break;
} }
case 0x0119: { case 0x0119: {
bool is_rare = this->check_and_log_rare_enemy((e.fparam2 != 0.0f), rare_rates.kondrieu); bool is_rare = this->check_and_log_rare_enemy((e.fparam2 != 0.0f), rare_rates.kondrieu);
if (is_rare) { if (is_rare) {
this->add_enemy(e.floor, EnemyType::KONDRIEU); this->add_enemy(floor, EnemyType::KONDRIEU);
} else { } else {
this->add_enemy(e.floor, (e.uparam1 & 1) ? EnemyType::SHAMBERTIN : EnemyType::SAINT_MILLION); this->add_enemy(floor, (e.uparam1 & 1) ? EnemyType::SHAMBERTIN : EnemyType::SAINT_MILLION);
} }
break; break;
} }
default: default:
for (size_t z = 0; z < static_cast<size_t>(e.num_children + 1); z++) { for (size_t z = 0; z < static_cast<size_t>(e.num_children + 1); z++) {
this->add_enemy(e.floor, EnemyType::UNKNOWN); this->add_enemy(floor, EnemyType::UNKNOWN);
} }
static_game_data_log.warning( static_game_data_log.warning(
"(Entry %zu, offset %zX in file) Unknown enemy type %04hX", "(Entry %zu, offset %zX in file) Unknown enemy type %04hX",
@@ -407,6 +408,7 @@ void Map::add_enemies_from_map_data(
Episode episode, Episode episode,
uint8_t difficulty, uint8_t difficulty,
uint8_t event, uint8_t event,
uint8_t floor,
const void* data, const void* data,
size_t size, size_t size,
const RareEnemyRates& rare_rates) { const RareEnemyRates& rare_rates) {
@@ -417,7 +419,7 @@ void Map::add_enemies_from_map_data(
StringReader r(data, size); StringReader r(data, size);
for (size_t y = 0; y < entry_count; y++) { for (size_t y = 0; y < entry_count; y++) {
this->add_enemy(episode, difficulty, event, y, r.get<EnemyEntry>(), rare_rates); this->add_enemy(episode, difficulty, event, floor, y, r.get<EnemyEntry>(), rare_rates);
} }
} }
@@ -500,6 +502,7 @@ void Map::add_random_enemies_from_map_data(
Episode episode, Episode episode,
uint8_t difficulty, uint8_t difficulty,
uint8_t event, uint8_t event,
uint8_t floor,
StringReader wave_events_segment_r, StringReader wave_events_segment_r,
StringReader locations_segment_r, StringReader locations_segment_r,
StringReader definitions_segment_r, StringReader definitions_segment_r,
@@ -579,6 +582,7 @@ void Map::add_random_enemies_from_map_data(
e.base_type = rand_enemy_base_types.at(weight_entry.base_type_index); e.base_type = rand_enemy_base_types.at(weight_entry.base_type_index);
e.wave_number = wave_number; e.wave_number = wave_number;
e.section = entry.section; e.section = entry.section;
e.floor = floor;
size_t bs_min = 0; size_t bs_min = 0;
size_t bs_max = definitions_header.entry_count - 1; size_t bs_max = definitions_header.entry_count - 1;
@@ -619,7 +623,7 @@ void Map::add_random_enemies_from_map_data(
enemy_log.info("Creating enemy with base_type %04hX fparam2 %g uparam1 %04hX", e.base_type.load(), e.fparam2.load(), e.uparam1.load()); enemy_log.info("Creating enemy with base_type %04hX fparam2 %g uparam1 %04hX", e.base_type.load(), e.fparam2.load(), e.uparam1.load());
// Trace: at 0080E6FE CX is base_type // Trace: at 0080E6FE CX is base_type
this->add_enemy(episode, difficulty, event, 0, e, rare_rates); this->add_enemy(episode, difficulty, event, floor, 0, e, rare_rates);
} else { } else {
enemy_log.info("Cannot create enemy: parameters are missing"); enemy_log.info("Cannot create enemy: parameters are missing");
} }
@@ -743,6 +747,7 @@ void Map::add_enemies_and_objects_from_quest_data(
episode, episode,
difficulty, difficulty,
event, event,
floor,
r.pgetv(sections.enemies + sizeof(header), header.data_size), r.pgetv(sections.enemies + sizeof(header), header.data_size),
header.data_size, header.data_size,
rare_rates); rare_rates);
@@ -758,6 +763,7 @@ void Map::add_enemies_and_objects_from_quest_data(
episode, episode,
difficulty, difficulty,
event, event,
floor,
r.sub(sections.wave_events + sizeof(SectionHeader), wave_events_header.data_size), r.sub(sections.wave_events + sizeof(SectionHeader), wave_events_header.data_size),
r.sub(sections.random_enemy_locations + sizeof(SectionHeader), random_enemy_locations_header.data_size), r.sub(sections.random_enemy_locations + sizeof(SectionHeader), random_enemy_locations_header.data_size),
r.sub(sections.random_enemy_definitions + sizeof(SectionHeader), random_enemy_definitions_header.data_size), r.sub(sections.random_enemy_definitions + sizeof(SectionHeader), random_enemy_definitions_header.data_size),
src/Map.hh
+3
View File
@@ -222,6 +222,7 @@ struct Map {
Episode episode, Episode episode,
uint8_t difficulty, uint8_t difficulty,
uint8_t event, uint8_t event,
uint8_t floor,
size_t index, size_t index,
const EnemyEntry& e, const EnemyEntry& e,
const RareEnemyRates& rare_rates = Map::DEFAULT_RARE_ENEMIES); const RareEnemyRates& rare_rates = Map::DEFAULT_RARE_ENEMIES);
@@ -229,6 +230,7 @@ struct Map {
Episode episode, Episode episode,
uint8_t difficulty, uint8_t difficulty,
uint8_t event, uint8_t event,
uint8_t floor,
const void* data, const void* data,
size_t size, size_t size,
const RareEnemyRates& rare_rates = Map::DEFAULT_RARE_ENEMIES); const RareEnemyRates& rare_rates = Map::DEFAULT_RARE_ENEMIES);
@@ -236,6 +238,7 @@ struct Map {
Episode episode, Episode episode,
uint8_t difficulty, uint8_t difficulty,
uint8_t event, uint8_t event,
uint8_t floor,
StringReader wave_events_r, StringReader wave_events_r,
StringReader random_enemy_locations_r, StringReader random_enemy_locations_r,
StringReader random_enemy_definitions_r, StringReader random_enemy_definitions_r,
src/ReceiveCommands.cc
+4 -4
View File
@@ -3342,8 +3342,8 @@ static void on_DF_BB(shared_ptr<Client> c, uint16_t command, uint32_t, string& d
case 0x04DF: { case 0x04DF: {
const auto& cmd = check_size_t<C_SetChallengeModeEXPMultiplier_BB_04DF>(data); const auto& cmd = check_size_t<C_SetChallengeModeEXPMultiplier_BB_04DF>(data);
l->exp_multiplier = cmd.exp_multiplier; l->challenge_exp_multiplier = cmd.exp_multiplier;
l->log.info("(Challenge mode) EXP multiplier set to %g", l->exp_multiplier); l->log.info("(Challenge mode) EXP multiplier set to %g", l->challenge_exp_multiplier);
break; break;
} }
@@ -3740,7 +3740,7 @@ shared_ptr<Lobby> create_game_generic(
auto map_data = s->load_bb_file(filename, "", "map/" + filename); auto map_data = s->load_bb_file(filename, "", "map/" + filename);
size_t start_offset = game->map->enemies.size(); size_t start_offset = game->map->enemies.size();
game->map->add_enemies_from_map_data( game->map->add_enemies_from_map_data(
game->episode, game->difficulty, game->event, map_data->data(), map_data->size()); game->episode, game->difficulty, game->event, floor, map_data->data(), map_data->size());
size_t entries_loaded = game->map->enemies.size() - start_offset; size_t entries_loaded = game->map->enemies.size() - start_offset;
c->log.info("[Map/%zu:e] Loaded %s (%zu entries)", c->log.info("[Map/%zu:e] Loaded %s (%zu entries)",
floor, filename.c_str(), entries_loaded); floor, filename.c_str(), entries_loaded);
@@ -3916,7 +3916,7 @@ static void on_6F(shared_ptr<Client> c, uint16_t command, uint32_t, string& data
c->config.clear_flag(Client::Flag::LOADING); c->config.clear_flag(Client::Flag::LOADING);
send_resume_game(l, c); send_resume_game(l, c);
if ((l->base_version == GameVersion::BB) && (l->mode != GameMode::CHALLENGE)) { if (l->base_version == GameVersion::BB) {
send_set_exp_multiplier(l); send_set_exp_multiplier(l);
} }
send_server_time(c); send_server_time(c);
src/ReceiveSubcommands.cc
+38 -23
View File
@@ -1790,11 +1790,11 @@ static void on_enemy_killed_bb(shared_ptr<Client> c, uint8_t, uint8_t, const voi
return; return;
} }
uint32_t experience = 0xFFFFFFFF; double experience = 0.0;
try { try {
const auto& bp_table = s->battle_params->get_table(l->mode == GameMode::SOLO, l->episode); const auto& bp_table = s->battle_params->get_table(l->mode == GameMode::SOLO, l->episode);
uint32_t bp_index = battle_param_index_for_enemy_type(l->episode, e.type); uint32_t bp_index = battle_param_index_for_enemy_type(l->episode, e.type);
experience = bp_table.stats[l->difficulty][bp_index].experience * l->exp_multiplier; experience = bp_table.stats[l->difficulty][bp_index].experience;
} catch (const exception& e) { } catch (const exception& e) {
if (c->config.check_flag(Client::Flag::DEBUG_ENABLED)) { if (c->config.check_flag(Client::Flag::DEBUG_ENABLED)) {
send_text_message_printf(c, "$C5E-%hX __MISSING__\n%s", cmd.enemy_index.load(), e.what()); send_text_message_printf(c, "$C5E-%hX __MISSING__\n%s", cmd.enemy_index.load(), e.what());
@@ -1804,28 +1804,43 @@ static void on_enemy_killed_bb(shared_ptr<Client> c, uint8_t, uint8_t, const voi
} }
e.flags |= Map::Enemy::Flag::DEFEATED; e.flags |= Map::Enemy::Flag::DEFEATED;
for (size_t x = 0; x < l->max_clients; x++) { if (experience != 0.0) {
if (!((e.flags >> x) & 1)) { for (size_t x = 0; x < l->max_clients; x++) {
continue; // Player did not hit this enemy auto lc = l->clients[x];
} if (!lc) {
auto other_c = l->clients[x]; continue;
if (!other_c) {
continue; // No player
}
if (other_c->floor != e.floor) {
continue;
}
if (experience != 0xFFFFFFFF) {
// Killer gets full experience, others get 77%
bool is_killer = (e.last_hit_by_client_id == other_c->lobby_client_id);
uint32_t player_exp = is_killer ? experience : ((experience * 77) / 100);
if (other_c->config.check_flag(Client::Flag::DEBUG_ENABLED)) {
send_text_message_printf(c, "$C5+%" PRIu32 " E-%hX %s",
player_exp, cmd.enemy_index.load(), name_for_enum(e.type));
} }
if (other_c->game_data.character()->disp.stats.level < 199) { if (!((e.flags >> x) & 1)) {
add_player_exp(other_c, player_exp); if (lc->config.check_flag(Client::Flag::DEBUG_ENABLED)) {
send_text_message_printf(lc, "$C5E-%hX %s\n$C4NOHIT", cmd.enemy_index.load(), name_for_enum(e.type));
}
continue; // Player did not hit this enemy
}
if (lc->floor != e.floor) {
if (lc->config.check_flag(Client::Flag::DEBUG_ENABLED)) {
send_text_message_printf(lc, "$C5E-%hX %s\n$C4FLOOR Y:%02" PRIX32 " E:%02hhX",
cmd.enemy_index.load(), name_for_enum(e.type), lc->floor, e.floor);
}
continue;
}
// In PSOBB, Sega decided to add a 30% EXP boost for Episode 2. They could
// have done something reasonable, like edit the BattleParamEntry files so
// the monsters would all give more EXP, but they did something far lazier
// instead: they just stuck an if statement in the client's EXP request
// function. We, unfortunately, have to do the same here.
bool is_killer = (e.last_hit_by_client_id == lc->lobby_client_id);
bool is_ep2 = (l->episode == Episode::EP2);
uint32_t player_exp = experience *
(is_killer ? 1.0 : 0.8) *
l->base_exp_multiplier *
l->challenge_exp_multiplier *
(is_ep2 ? 1.3 : 1.0);
if (lc->config.check_flag(Client::Flag::DEBUG_ENABLED)) {
send_text_message_printf(lc, "$C5+%" PRIu32 " E-%hX %s", player_exp, cmd.enemy_index.load(), name_for_enum(e.type));
}
if (lc->game_data.character()->disp.stats.level < 199) {
add_player_exp(lc, player_exp);
} }
} }
} }
src/SendCommands.cc
+1 -4
View File
@@ -2287,10 +2287,7 @@ void send_set_exp_multiplier(std::shared_ptr<Lobby> l) {
if (!l->is_game()) { if (!l->is_game()) {
throw logic_error("6xDD can only be sent in games (not in lobbies)"); throw logic_error("6xDD can only be sent in games (not in lobbies)");
} }
if (floorf(l->exp_multiplier) != l->exp_multiplier) { G_SetEXPMultiplier_BB_6xDD cmd = {{0xDD, sizeof(G_SetEXPMultiplier_BB_6xDD) / 4, (l->mode == GameMode::CHALLENGE) ? 1 : l->base_exp_multiplier}};
throw runtime_error("EXP multiplier is not an integer");
}
G_SetEXPMultiplier_BB_6xDD cmd = {{0xDD, sizeof(G_SetEXPMultiplier_BB_6xDD) / 4, static_cast<uint16_t>(l->exp_multiplier)}};
send_command_t(l, 0x60, 0x00, cmd); send_command_t(l, 0x60, 0x00, cmd);
} }