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

further improve quest assembler/disassembler matching

Browse Source
This commit is contained in:
Martin Michelsen
2025-11-26 22:33:50 -08:00
parent a783177420
commit bd1cdfdb97
16 changed files with 342 additions and 347 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Client.cc
+1 -1
View File
@@ -424,7 +424,7 @@ bool Client::can_play_quest(
if (!q->has_version_any_language(this->version())) {
return false;
}
if (num_players > q->meta.max_players) {
if ((q->meta.max_players > 0) && (num_players > q->meta.max_players)) {
return false;
}
return this->evaluate_quest_availability_expression(
src/Main.cc
+33 -33
View File
@@ -1576,7 +1576,7 @@ Action a_encode_qst(
}
auto vq = make_shared<VersionedQuest>();
vq->version = version;
vq->meta.version = version;
vq->bin_contents = bin_data;
vq->dat_contents = dat_data;
vq->pvr_contents = pvr_data;
@@ -3152,8 +3152,8 @@ Action a_check_quest_reassembly(
for (const auto& [_, q] : s->quest_index->quests_by_number) {
for (const auto& [_, vq] : q->versions) {
auto decompressed_bin = prs_decompress(*vq->bin_contents);
auto disassembled = disassemble_quest_script(decompressed_bin.data(), decompressed_bin.size(), vq->version, vq->language, vq->map_file, false, false);
auto reassembly = disassemble_quest_script(decompressed_bin.data(), decompressed_bin.size(), vq->version, vq->language, vq->map_file, true, false);
auto disassembled = disassemble_quest_script(decompressed_bin.data(), decompressed_bin.size(), vq->meta.version, vq->meta.language, vq->map_file, false, false);
auto reassembly = disassemble_quest_script(decompressed_bin.data(), decompressed_bin.size(), vq->meta.version, vq->meta.language, vq->map_file, true, false);
string include_dir = phosg::dirname(vq->bin_filename());
AssembledQuestScript assembled;
try {
@@ -3162,44 +3162,44 @@ Action a_check_quest_reassembly(
{"system/quests/includes"},
{"system/quests/includes", "system/client-functions/System"},
false);
if (vq->json_contents) {
assembled.meta.apply_json_overrides(*vq->json_contents);
}
if (assembled.data != decompressed_bin) {
throw std::runtime_error("Reassembled quest script does not match original");
}
if (assembled.quest_number != vq->meta.quest_number) {
throw std::runtime_error(std::format("Reassembled quest number {} does not match original ({})",
assembled.quest_number, vq->meta.quest_number));
// Don't check quest number, since we override it based on the filename
if (assembled.meta.version != vq->meta.version) {
throw std::runtime_error(std::format("Reassembled quest version ({}) does not match original ({})",
phosg::name_for_enum(assembled.meta.version), phosg::name_for_enum(vq->meta.version)));
}
if (assembled.version != vq->version) {
throw std::runtime_error(std::format("Reassembled quest version {} does not match original ({})",
phosg::name_for_enum(assembled.version), phosg::name_for_enum(vq->version)));
if (assembled.meta.language != vq->meta.language) {
throw std::runtime_error(std::format("Reassembled quest language ({}) does not match original ({})",
name_for_language(assembled.meta.language), name_for_language(vq->meta.language)));
}
if (assembled.language != vq->language) {
throw std::runtime_error(std::format("Reassembled quest language {} does not match original ({})",
name_for_language(assembled.language), name_for_language(vq->language)));
if (assembled.meta.episode != vq->meta.episode) {
throw std::runtime_error(std::format("Reassembled quest episode ({}) does not match original ({})",
name_for_episode(assembled.meta.episode), name_for_episode(vq->meta.episode)));
}
if (assembled.episode != vq->meta.episode) {
throw std::runtime_error(std::format("Reassembled quest episode {} does not match original ({})",
name_for_episode(assembled.episode), name_for_episode(vq->meta.episode)));
if (assembled.meta.joinable != vq->meta.joinable) {
throw std::runtime_error(std::format("Reassembled quest joinable ({}) does not match original ({})",
assembled.meta.joinable, vq->meta.joinable));
}
if (assembled.joinable != vq->meta.joinable) {
throw std::runtime_error(std::format("Reassembled quest joinable {} does not match original ({})",
assembled.joinable, vq->meta.joinable));
if (assembled.meta.max_players != vq->meta.max_players) {
throw std::runtime_error(std::format("Reassembled quest max_players ({}) does not match original ({})",
assembled.meta.max_players, vq->meta.max_players));
}
if (assembled.max_players != vq->meta.max_players) {
throw std::runtime_error(std::format("Reassembled quest max_players {} does not match original ({})",
assembled.max_players, vq->meta.max_players));
if (assembled.meta.name != vq->meta.name) {
throw std::runtime_error(std::format("Reassembled quest name ({}) does not match original ({})",
assembled.meta.name, vq->meta.name));
}
if (assembled.name != vq->meta.name) {
throw std::runtime_error(std::format("Reassembled quest name \"{}\" does not match original (\"{}\")",
assembled.name, vq->meta.name));
if (assembled.meta.short_description != vq->meta.short_description) {
throw std::runtime_error(std::format("Reassembled quest short description ({}) does not match original ({})",
assembled.meta.short_description, vq->meta.short_description));
}
if (assembled.short_description != vq->meta.short_description) {
throw std::runtime_error(std::format("Reassembled quest short description \"{}\" does not match original (\"{}\")",
assembled.short_description, vq->meta.short_description));
}
if (assembled.long_description != vq->meta.long_description) {
throw std::runtime_error(std::format("Reassembled quest long description \"{}\" does not match original (\"{}\")",
assembled.long_description, vq->meta.long_description));
if (assembled.meta.long_description != vq->meta.long_description) {
throw std::runtime_error(std::format("Reassembled quest long description ({}) does not match original ({})",
assembled.meta.long_description, vq->meta.long_description));
}
} catch (const std::exception& e) {
phosg::log_error_f("================ DISASSEMBLY:");
@@ -3210,10 +3210,10 @@ Action a_check_quest_reassembly(
phosg::log_error_f("================ BINDIFF:");
phosg::print_binary_diff(stderr, decompressed_bin.data(), decompressed_bin.size(), assembled.data.data(), assembled.data.size(), isatty(fileno(stderr)), 3, 0);
}
phosg::log_info_f("... {} {} {} ({}) FAILED", phosg::name_for_enum(vq->version), name_for_language(vq->language), vq->bin_filename(), vq->meta.name);
phosg::log_info_f("... {} {} {} ({}) FAILED", phosg::name_for_enum(vq->meta.version), name_for_language(vq->meta.language), vq->bin_filename(), vq->meta.name);
throw;
}
phosg::log_info_f("... {} {} {} ({}) OK", phosg::name_for_enum(vq->version), name_for_language(vq->language), vq->bin_filename(), vq->meta.name);
phosg::log_info_f("... {} {} {} ({}) OK", phosg::name_for_enum(vq->meta.version), name_for_language(vq->meta.language), vq->bin_filename(), vq->meta.name);
}
}
});
src/Map.cc
+2 -2
View File
@@ -4583,7 +4583,7 @@ shared_ptr<SuperMap::Enemy> SuperMap::add_enemy_and_children(
case 0x00FD: // TObjNpcNgcBase
case 0x00FE: // TObjNpcNgcBase
case 0x00FF: // TObjNpcNgcBase
case 0x0100: // Unknown NPC
case 0x0100: // Momoka
// All of these have a default child count of zero
add(EnemyType::NON_ENEMY_NPC);
break;
@@ -4923,7 +4923,7 @@ shared_ptr<SuperMap::Enemy> SuperMap::add_enemy_and_children(
case 0x00C4: // TBoss3VoloptCore or subclass
case 0x00C6: // TBoss3VoloptMonitor
case 0x00C7: // TBoss3VoloptHiraisin
case 0x0118:
case 0x0118: // __QUEST_NPC__
add(EnemyType::UNKNOWN);
break;
src/Quest.cc
+32 -103
View File
@@ -200,10 +200,10 @@ void VersionedQuest::assert_valid() const {
if (this->meta.quest_number == 0xFFFFFFFF) {
throw runtime_error("quest number is not set");
}
if (this->version == Version::UNKNOWN) {
if (this->meta.version == Version::UNKNOWN) {
throw runtime_error("version is not set");
}
if (this->language == Language::UNKNOWN) {
if (this->meta.language == Language::UNKNOWN) {
throw runtime_error("language is not set");
}
switch (this->meta.episode) {
@@ -216,7 +216,7 @@ void VersionedQuest::assert_valid() const {
}
break;
case Episode::EP2:
if (is_v1_or_v2(this->version)) {
if (is_v1_or_v2(this->meta.version)) {
throw runtime_error("v1 or v2 quest specifies Episode 2");
}
for (size_t floor = 0; floor < this->meta.area_for_floor.size(); floor++) {
@@ -227,7 +227,7 @@ void VersionedQuest::assert_valid() const {
}
break;
case Episode::EP3:
if (!is_ep3(this->version)) {
if (!is_ep3(this->meta.version)) {
throw runtime_error("non-Ep3 quest specifies Episode 3");
}
for (size_t floor = 0; floor < this->meta.area_for_floor.size(); floor++) {
@@ -237,7 +237,7 @@ void VersionedQuest::assert_valid() const {
}
break;
case Episode::EP4:
if (!is_v4(this->version)) {
if (!is_v4(this->meta.version)) {
throw runtime_error("non-v4 quest specifies Episode 4");
}
for (size_t floor = 0; floor < this->meta.area_for_floor.size(); floor++) {
@@ -252,9 +252,6 @@ void VersionedQuest::assert_valid() const {
default:
throw runtime_error("episode is not valid");
}
if (this->meta.max_players == 0) {
throw runtime_error("max players is not set");
}
if (!this->bin_contents) {
throw runtime_error("bin file is missing");
}
@@ -264,12 +261,6 @@ void VersionedQuest::assert_valid() const {
if (!this->map_file) {
throw runtime_error("parsed map file is missing");
}
if (this->meta.common_item_set_name.empty() != !this->meta.common_item_set) {
throw runtime_error("common item set name/pointer mismatch");
}
if (this->meta.rare_item_set_name.empty() != !this->meta.rare_item_set) {
throw runtime_error("rare item set name/pointer mismatch");
}
if (this->meta.allowed_drop_modes &&
!(this->meta.allowed_drop_modes & (1 << static_cast<size_t>(this->meta.default_drop_mode)))) {
throw runtime_error("default drop mode is not allowed");
@@ -290,7 +281,7 @@ string VersionedQuest::pvr_filename() const {
string VersionedQuest::xb_filename() const {
return std::format("quest{}_{}.dat",
this->meta.quest_number, static_cast<char>(tolower(char_for_language(this->language))));
this->meta.quest_number, static_cast<char>(tolower(char_for_language(this->meta.language))));
}
string VersionedQuest::encode_qst() const {
@@ -301,8 +292,8 @@ string VersionedQuest::encode_qst() const {
files.emplace(std::format("quest{}.pvr", this->meta.quest_number), this->pvr_contents);
}
string xb_filename = std::format("quest{}_{}.dat",
this->meta.quest_number, static_cast<char>(tolower(char_for_language(language))));
return encode_qst_file(files, this->meta.name, this->meta.quest_number, xb_filename, this->version, this->is_dlq_encoded);
this->meta.quest_number, static_cast<char>(tolower(char_for_language(this->meta.language))));
return encode_qst_file(files, this->meta.name, this->meta.quest_number, xb_filename, this->meta.version, this->is_dlq_encoded);
}
Quest::Quest(shared_ptr<const VersionedQuest> initial_version)
@@ -314,8 +305,8 @@ phosg::JSON Quest::json() const {
auto versions_json = phosg::JSON::list();
for (const auto& [_, vq] : this->versions) {
versions_json.emplace_back(phosg::JSON::dict({
{"Version", phosg::name_for_enum(vq->version)},
{"Language", ::name_for_language(vq->language)},
{"Version", phosg::name_for_enum(vq->meta.version)},
{"Language", ::name_for_language(vq->meta.language)},
{"Name", vq->meta.name},
{"ShortDescription", vq->meta.short_description},
{"LongDescription", vq->meta.long_description},
@@ -357,9 +348,9 @@ void Quest::add_version(shared_ptr<const VersionedQuest> vq) {
if (this->meta.create_item_mask_entries.empty()) {
this->meta.create_item_mask_entries = vq->meta.create_item_mask_entries;
}
this->versions.emplace(this->versions_key(vq->version, vq->language), vq);
this->versions.emplace(this->versions_key(vq->meta.version, vq->meta.language), vq);
size_t lang_index = static_cast<size_t>(vq->language);
size_t lang_index = static_cast<size_t>(vq->meta.language);
auto& name_by_language = this->names_by_language.at(lang_index);
if (name_by_language.empty()) {
name_by_language = vq->meta.name;
@@ -435,12 +426,7 @@ shared_ptr<const VersionedQuest> Quest::version(Version v, Language language) co
return it->second;
}
QuestIndex::QuestIndex(
const string& directory,
shared_ptr<const QuestCategoryIndex> category_index,
const unordered_map<string, shared_ptr<const CommonItemSet>>& common_item_sets,
const unordered_map<string, shared_ptr<const RareItemSet>>& rare_item_sets,
bool raise_on_any_failure)
QuestIndex::QuestIndex(const string& directory, shared_ptr<const QuestCategoryIndex> category_index, bool raise_on_any_failure)
: directory(directory),
category_index(category_index) {
@@ -600,6 +586,7 @@ QuestIndex::QuestIndex(
// All quests have a bin file (even in Episode 3, though its format is
// different), so we use bin_files as the primary list of all quests that
// should be indexed
unordered_map<const FileData*, shared_ptr<const phosg::JSON>> parsed_json_files;
for (auto& [basename, entry] : bin_files) {
try {
auto vq = make_shared<VersionedQuest>();
@@ -625,9 +612,9 @@ QuestIndex::QuestIndex(
vq->meta.category_id = categories.at(basename);
if (entry.assembled) {
vq->meta.quest_number = entry.assembled->quest_number;
vq->version = entry.assembled->version;
vq->language = entry.assembled->language;
vq->meta.quest_number = entry.assembled->meta.quest_number;
vq->meta.version = entry.assembled->meta.version;
vq->meta.language = entry.assembled->meta.language;
} else {
// Get the number from the first token
if (quest_number_token.empty()) {
@@ -650,30 +637,17 @@ QuestIndex::QuestIndex(
{"xb", Version::XB_V3},
{"bb", Version::BB_V4},
});
vq->version = name_to_version.at(version_token);
vq->meta.version = name_to_version.at(version_token);
// Get the language from the last token
if (language_token.size() != 1) {
throw runtime_error("language token is not a single character");
}
vq->language = language_for_char(language_token[0]);
vq->meta.language = language_for_char(language_token[0]);
}
auto bin_decompressed = prs_decompress(*entry.data);
populate_quest_metadata_from_script(vq->meta, bin_decompressed.data(), bin_decompressed.size(), vq->version, vq->language);
// If the quest was assembled (that is, if it came from a .bin.txt file),
// the metadata from the source file overrides any automatically-detected
// values from above
if (entry.assembled) {
vq->meta.quest_number = entry.assembled->quest_number;
vq->meta.episode = entry.assembled->episode;
vq->meta.joinable = entry.assembled->joinable;
vq->meta.max_players = entry.assembled->max_players;
vq->meta.name = entry.assembled->name;
vq->meta.short_description = entry.assembled->short_description;
vq->meta.long_description = entry.assembled->long_description;
}
populate_quest_metadata_from_script(vq->meta, bin_decompressed.data(), bin_decompressed.size(), vq->meta.version, vq->meta.language);
// Find the corresponding dat and pvr files with the same basename as the
// bin file; if not found, look for them without the language suffix
@@ -722,57 +696,13 @@ QuestIndex::QuestIndex(
}
}
if (json_filedata) {
auto metadata_json = phosg::JSON::parse(*json_filedata->data);
try {
vq->meta.description_flag = metadata_json.at("DescriptionFlag").as_int();
} catch (const out_of_range&) {
}
try {
vq->meta.available_expression = make_shared<IntegralExpression>(metadata_json.get_string("AvailableIf"));
} catch (const out_of_range&) {
}
try {
vq->meta.enabled_expression = make_shared<IntegralExpression>(metadata_json.get_string("EnabledIf"));
} catch (const out_of_range&) {
}
try {
vq->meta.allow_start_from_chat_command = metadata_json.get_bool("AllowStartFromChatCommand");
} catch (const out_of_range&) {
}
try {
vq->meta.joinable = metadata_json.get_bool("Joinable");
} catch (const out_of_range&) {
}
try {
vq->meta.lock_status_register = metadata_json.get_int("LockStatusRegister");
} catch (const out_of_range&) {
}
try {
vq->meta.enemy_exp_overrides = QuestMetadata::parse_enemy_exp_overrides(metadata_json.at("EnemyEXPOverrides"));
} catch (const out_of_range&) {
}
try {
vq->meta.common_item_set_name = metadata_json.at("CommonItemSetName").as_string();
} catch (const out_of_range&) {
}
if (!vq->meta.common_item_set_name.empty()) {
vq->meta.common_item_set = common_item_sets.at(vq->meta.common_item_set_name);
}
try {
vq->meta.rare_item_set_name = metadata_json.at("RareItemSetName").as_string();
} catch (const out_of_range&) {
}
if (!vq->meta.rare_item_set_name.empty()) {
vq->meta.rare_item_set = rare_item_sets.at(vq->meta.rare_item_set_name);
}
try {
vq->meta.allowed_drop_modes = metadata_json.at("AllowedDropModes").as_int();
} catch (const out_of_range&) {
}
try {
vq->meta.default_drop_mode = phosg::enum_for_name<ServerDropMode>(metadata_json.at("DefaultDropMode").as_string());
vq->json_contents = parsed_json_files.at(json_filedata);
} catch (const out_of_range&) {
vq->json_contents = make_shared<phosg::JSON>(phosg::JSON::parse(*json_filedata->data));
parsed_json_files.emplace(json_filedata, vq->json_contents);
}
vq->meta.apply_json_overrides(*vq->json_contents);
}
vq->assert_valid();
@@ -793,8 +723,8 @@ QuestIndex::QuestIndex(
q_it->second->add_version(vq);
static_game_data_log.debug_f("({}) Added {} {} version of quest {} ({})",
filenames_str,
phosg::name_for_enum(vq->version),
char_for_language(vq->language),
phosg::name_for_enum(vq->meta.version),
char_for_language(vq->meta.language),
vq->meta.quest_number,
vq->meta.name);
} else {
@@ -804,8 +734,8 @@ QuestIndex::QuestIndex(
this->quests_by_category_id_and_number[q->meta.category_id].emplace(vq->meta.quest_number, q);
static_game_data_log.debug_f("({}) Created {} {} quest {} ({}) ({}, {} ({}), {})",
filenames_str,
phosg::name_for_enum(vq->version),
char_for_language(vq->language),
phosg::name_for_enum(vq->meta.version),
char_for_language(vq->meta.language),
vq->meta.quest_number,
vq->meta.name,
name_for_episode(vq->meta.episode),
@@ -956,13 +886,12 @@ shared_ptr<VersionedQuest> VersionedQuest::create_download_quest(Language overri
string decompressed_bin = prs_decompress(*this->bin_contents);
void* data_ptr = decompressed_bin.data();
switch (this->version) {
switch (this->meta.version) {
case Version::DC_NTE:
if (decompressed_bin.size() < sizeof(PSOQuestHeaderDCNTE)) {
throw runtime_error("bin file is too small for header");
}
// There's no known language field in this version, so we don't write
// anything here
// There's no known language field in this version, so we don't write anything here
break;
case Version::DC_11_2000:
case Version::DC_V1:
@@ -986,11 +915,11 @@ shared_ptr<VersionedQuest> VersionedQuest::create_download_quest(Language overri
case Version::GC_NTE:
case Version::GC_V3:
case Version::XB_V3:
if (decompressed_bin.size() < sizeof(PSOQuestHeaderGC)) {
if (decompressed_bin.size() < sizeof(PSOQuestHeaderV3)) {
throw runtime_error("bin file is too small for header");
}
if (override_language != Language::UNKNOWN) {
reinterpret_cast<PSOQuestHeaderGC*>(data_ptr)->language = override_language;
reinterpret_cast<PSOQuestHeaderV3*>(data_ptr)->language = override_language;
}
break;
case Version::BB_V4:
src/Quest.hh
+2 -8
View File
@@ -71,12 +71,11 @@ struct VersionedQuest {
// Most of these default values are intentionally invalid; we use these
// values to check if each field was parsed during quest indexing.
Version version = Version::UNKNOWN;
Language language = Language::UNKNOWN;
std::shared_ptr<const std::string> bin_contents;
std::shared_ptr<const std::string> dat_contents;
std::shared_ptr<const MapFile> map_file;
std::shared_ptr<const std::string> pvr_contents;
std::shared_ptr<const phosg::JSON> json_contents;
bool is_dlq_encoded = false;
void assert_valid() const;
@@ -132,12 +131,7 @@ struct QuestIndex {
std::map<std::string, std::shared_ptr<Quest>> quests_by_name;
std::map<uint32_t, std::map<uint32_t, std::shared_ptr<Quest>>> quests_by_category_id_and_number;
QuestIndex(
const std::string& directory,
std::shared_ptr<const QuestCategoryIndex> category_index,
const std::unordered_map<std::string, std::shared_ptr<const CommonItemSet>>& common_item_sets,
const std::unordered_map<std::string, std::shared_ptr<const RareItemSet>>& rare_item_sets,
bool raise_on_any_failure);
QuestIndex(const std::string& directory, std::shared_ptr<const QuestCategoryIndex> category_index, bool raise_on_any_failure);
phosg::JSON json() const;
std::shared_ptr<const Quest> get(uint32_t quest_number) const;
src/QuestMetadata.cc
+52 -10
View File
@@ -2,6 +2,53 @@
using namespace std;
void QuestMetadata::apply_json_overrides(const phosg::JSON& json) {
try {
this->description_flag = json.at("DescriptionFlag").as_int();
} catch (const out_of_range&) {
}
try {
this->available_expression = make_shared<IntegralExpression>(json.get_string("AvailableIf"));
} catch (const out_of_range&) {
}
try {
this->enabled_expression = make_shared<IntegralExpression>(json.get_string("EnabledIf"));
} catch (const out_of_range&) {
}
try {
this->allow_start_from_chat_command = json.get_bool("AllowStartFromChatCommand");
} catch (const out_of_range&) {
}
try {
this->joinable = json.get_bool("Joinable");
} catch (const out_of_range&) {
}
try {
this->lock_status_register = json.get_int("LockStatusRegister");
} catch (const out_of_range&) {
}
try {
this->enemy_exp_overrides = QuestMetadata::parse_enemy_exp_overrides(json.at("EnemyEXPOverrides"));
} catch (const out_of_range&) {
}
try {
this->common_item_set_name = json.at("CommonItemSetName").as_string();
} catch (const out_of_range&) {
}
try {
this->rare_item_set_name = json.at("RareItemSetName").as_string();
} catch (const out_of_range&) {
}
try {
this->allowed_drop_modes = json.at("AllowedDropModes").as_int();
} catch (const out_of_range&) {
}
try {
this->default_drop_mode = phosg::enum_for_name<ServerDropMode>(json.at("DefaultDropMode").as_string());
} catch (const out_of_range&) {
}
}
void QuestMetadata::assign_default_areas(Version version, Episode episode) {
for (size_t z = 0; z < 0x12; z++) {
this->area_for_floor[z] = SetDataTableBase::default_area_for_floor(version, episode, z);
@@ -34,10 +81,11 @@ void QuestMetadata::assert_compatible(const QuestMetadata& other) const {
"quest version has a different joinability state (existing: {}, new: {})",
this->joinable ? "true" : "false", other.joinable ? "true" : "false"));
}
if (this->max_players != other.max_players) {
bool this_has_player_limit = (this->max_players != 0) && (this->max_players != 4);
bool other_has_player_limit = (other.max_players != 0) && (other.max_players != 4);
if ((this_has_player_limit || other_has_player_limit) && (this->max_players != other.max_players)) {
throw runtime_error(std::format(
"quest version has a different maximum player count (existing: {}, new: {})",
this->max_players, other.max_players));
"quest version has a different maximum player count (existing: {}, new: {})", this->max_players, other.max_players));
}
if (this->lock_status_register != other.lock_status_register) {
throw runtime_error(std::format(
@@ -136,17 +184,11 @@ void QuestMetadata::assert_compatible(const QuestMetadata& other) const {
"quest version has different common table name (existing: {}, new: {})",
this->common_item_set_name, other.common_item_set_name));
}
if (this->common_item_set != other.common_item_set) {
throw runtime_error("quest version has different common table");
}
if (this->rare_item_set_name != other.rare_item_set_name) {
throw runtime_error(std::format(
"quest version has different rare table name (existing: {}, new: {})",
this->rare_item_set_name, other.rare_item_set_name));
}
if (this->rare_item_set != other.rare_item_set) {
throw runtime_error("quest version has different rare table");
}
if (this->allowed_drop_modes != other.allowed_drop_modes) {
throw runtime_error(format("quest version has different allowed drop modes (existing: {:02X}, new: {:02X})",
this->allowed_drop_modes, other.allowed_drop_modes));
@@ -182,7 +224,7 @@ phosg::JSON QuestMetadata::json() const {
{"Episode", name_for_episode(this->episode)},
{"FloorAssignments", std::move(floors_json)},
{"Joinable", this->joinable},
{"MaxPlayers", this->max_players},
{"MaxPlayers", this->max_players ? 4 : this->max_players},
{"BattleRules", this->battle_rules ? this->battle_rules->json() : phosg::JSON(nullptr)},
{"ChallengeTemplateIndex", (this->challenge_template_index >= 0) ? this->challenge_template_index : phosg::JSON(nullptr)},
{"ChallengeEXPMultiplier", (this->challenge_exp_multiplier >= 0) ? this->challenge_exp_multiplier : phosg::JSON(nullptr)},
src/QuestMetadata.hh
+16 -4
View File
@@ -22,6 +22,9 @@ struct QuestMetadata {
// is used in both the Quest and VersionedQuest structures; in Quest, the
// name and description are used only internally.
Version version;
Language language;
// Fields that must match across all quest versions
uint32_t category_id = 0xFFFFFFFF;
uint32_t quest_number = 0xFFFFFFFF;
@@ -38,8 +41,6 @@ struct QuestMetadata {
std::shared_ptr<const IntegralExpression> enabled_expression;
std::string common_item_set_name; // blank = use default
std::string rare_item_set_name; // blank = use default
std::shared_ptr<const CommonItemSet> common_item_set;
std::shared_ptr<const RareItemSet> rare_item_set;
uint8_t allowed_drop_modes = 0x00; // 0 = use server default
ServerDropMode default_drop_mode = ServerDropMode::CLIENT; // Ignored if allowed_drop_modes == 0
bool allow_start_from_chat_command = false;
@@ -47,7 +48,6 @@ struct QuestMetadata {
std::unordered_map<uint32_t, uint32_t> enemy_exp_overrides;
// Extra header fields (only used on BB)
std::shared_ptr<parray<uint8_t, 0x94>> bb_unknown_a5;
struct CreateItemMask {
struct Range {
uint8_t min = 0x00;
@@ -74,19 +74,31 @@ struct QuestMetadata {
};
std::vector<CreateItemMask> create_item_mask_entries;
// Unknown header fields. These are not used by the client, so they are not required to match across quest versions;
// however, we still parse them in case we later discover that they had some server-side meaning.
uint16_t header_unknown_a1 = 0xFFFF; // All versions
uint16_t header_unknown_a2 = 0xFFFF; // All versions
uint8_t header_unknown_a3 = 0; // DCv1 - V3
uint8_t header_unknown_a4 = 0; // BB only
uint16_t header_unknown_a6 = 0; // BB only
int16_t header_episode = -1; // -1 = unspecified; BB only; newserv uses script analysis instead
int16_t header_language = -1; // -1 = unspecified; DCv1 and later; newserv uses the filename instead
std::shared_ptr<parray<uint8_t, 0x94>> header_unknown_a5; // BB only; null for non-BB quests
// Fields that may be different across quest versions (and are only used on VersionedQuest, not Quest)
std::string name;
std::string short_description;
std::string long_description;
size_t text_offset;
size_t label_table_offset;
Language language;
static std::unordered_map<uint32_t, uint32_t> parse_enemy_exp_overrides(const phosg::JSON& json);
static inline uint32_t exp_override_key(Difficulty difficulty, uint8_t floor, EnemyType enemy_type) {
return (static_cast<uint32_t>(difficulty) << 24) | (static_cast<uint32_t>(floor) << 16) | static_cast<uint32_t>(enemy_type);
}
void apply_json_overrides(const phosg::JSON& json);
void assign_default_areas(Version version, Episode episode);
void assert_compatible(const QuestMetadata& other) const;
phosg::JSON json() const;
src/QuestScript.cc
+192 -163
View File
@@ -2251,7 +2251,7 @@ static const QuestScriptOpcodeDefinition opcode_defs[] = {
// regsE[0-2] = result point (x, y, z as floats)
// regsE[3] = result code (0 = failed, 1 = success)
// labelF = control point entries (array of valueA VectorXYZTF structures)
{0xF8DB, "get_vector_from_path", "unknownF8DB", {I32, FLOAT32, FLOAT32, I32, {W_REG_SET_FIXED, 4}, SCRIPT16}, F_V3_V4 | F_ARGS},
{0xF8DB, "get_vector_from_path", "unknownF8DB", {I32, FLOAT32, FLOAT32, I32, {W_REG_SET_FIXED, 4}, {LABEL16, Arg::DataType::VECTOR4F_LIST}}, F_V3_V4 | F_ARGS},
// Same as npc_text, but only applies to a specific player slot.
// valueA = client ID
@@ -3030,59 +3030,43 @@ std::string disassemble_quest_script(
QuestMetadata meta;
populate_quest_metadata_from_script(meta, bin_data, bin_size, version, language);
switch (version) {
case Version::DC_NTE:
lines.emplace_back(".name " + escape_string(meta.name));
break;
case Version::DC_11_2000:
case Version::DC_V1:
case Version::DC_V2:
lines.emplace_back(std::format(".quest_num {}", meta.quest_number));
lines.emplace_back(std::format(".language {}", char_for_language(meta.language)));
lines.emplace_back(".name " + escape_string(meta.name));
lines.emplace_back(".short_desc " + escape_string(meta.short_description));
lines.emplace_back(".long_desc " + escape_string(meta.long_description));
break;
case Version::PC_NTE:
case Version::PC_V2:
lines.emplace_back(std::format(".quest_num {}", meta.quest_number));
lines.emplace_back(std::format(".language {}", char_for_language(meta.language)));
lines.emplace_back(".name " + escape_string(meta.name));
lines.emplace_back(".short_desc " + escape_string(meta.short_description));
lines.emplace_back(".long_desc " + escape_string(meta.long_description));
break;
case Version::GC_NTE:
case Version::GC_V3:
case Version::GC_EP3_NTE:
case Version::GC_EP3:
case Version::XB_V3:
lines.emplace_back(std::format(".quest_num {}", meta.quest_number));
lines.emplace_back(std::format(".episode {}", token_name_for_episode(meta.episode)));
lines.emplace_back(std::format(".language {}", char_for_language(meta.language)));
lines.emplace_back(".name " + escape_string(meta.name));
lines.emplace_back(".short_desc " + escape_string(meta.short_description));
lines.emplace_back(".long_desc " + escape_string(meta.long_description));
break;
case Version::BB_V4:
lines.emplace_back(std::format(".quest_num {}", meta.quest_number));
lines.emplace_back(std::format(".episode {}", token_name_for_episode(meta.episode)));
lines.emplace_back(std::format(".language {}", char_for_language(meta.language)));
lines.emplace_back(std::format(".max_players {}", meta.max_players));
if (meta.joinable) {
lines.emplace_back(".joinable");
}
lines.emplace_back(std::format(".name {}", escape_string(meta.name)));
lines.emplace_back(std::format(".short_desc {}", escape_string(meta.short_description)));
lines.emplace_back(std::format(".long_desc {}", escape_string(meta.long_description)));
if (meta.bb_unknown_a5) {
lines.emplace_back(std::format(".bb_unknown_a5 {}", phosg::format_data_string(meta.bb_unknown_a5->data(), meta.bb_unknown_a5->size())));
}
for (const auto& mask : meta.create_item_mask_entries) {
lines.emplace_back(std::format(".allow_create_item {}", mask.str()));
}
break;
default:
throw logic_error("invalid quest version");
if (version != Version::DC_NTE) {
lines.emplace_back(std::format(".quest_num {}", meta.quest_number));
}
lines.emplace_back(".name " + escape_string(meta.name));
if (version != Version::DC_NTE) {
lines.emplace_back(std::format(".short_desc {}", escape_string(meta.short_description)));
lines.emplace_back(std::format(".long_desc {}", escape_string(meta.long_description)));
}
if (!is_v1_or_v2(version) || (version == Version::GC_NTE)) {
lines.emplace_back(std::format(".episode {}", token_name_for_episode(meta.episode)));
lines.emplace_back(std::format(".header_episode 0x{:02X}", meta.header_episode));
}
lines.emplace_back(std::format(".language {}", char_for_language(meta.language)));
if (!is_pre_v1(version) && !is_v4(version) && (static_cast<uint8_t>(meta.language) != meta.header_language)) {
lines.emplace_back(std::format(".header_language 0x{:02X}", meta.header_language));
}
if (is_v4(version)) {
lines.emplace_back(std::format(".max_players {}", meta.max_players));
if (meta.joinable) {
lines.emplace_back(".joinable");
}
for (const auto& mask : meta.create_item_mask_entries) {
lines.emplace_back(std::format(".allow_create_item {}", mask.str()));
}
}
lines.emplace_back(std::format(".header_unknown_a1 0x{:04X}", meta.header_unknown_a1));
lines.emplace_back(std::format(".header_unknown_a2 0x{:04X}", meta.header_unknown_a2));
if (!is_pre_v1(version) && !is_v4(version)) {
lines.emplace_back(std::format(".header_unknown_a3 0x{:02X}", meta.header_unknown_a3));
}
if (is_v4(version)) {
lines.emplace_back(std::format(".header_unknown_a4 0x{:02X}", meta.header_unknown_a4));
if (meta.header_unknown_a5) {
auto formatted = phosg::format_data_string(meta.header_unknown_a5->data(), meta.header_unknown_a5->size());
lines.emplace_back(std::format(".header_unknown_a5 {}", formatted));
}
lines.emplace_back(std::format(".header_unknown_a6 0x{:04X}", meta.header_unknown_a6));
}
lines.emplace_back();
@@ -3218,6 +3202,7 @@ std::string disassemble_quest_script(
}
}
if (fs.enemy_sets) {
uint8_t area = meta.area_for_floor.at(floor);
for (size_t z = 0; z < fs.enemy_set_count; z++) {
// Only NPCs use script labels; no other enemies do
const auto& ene_set = fs.enemy_sets[z];
@@ -3227,9 +3212,9 @@ std::string disassemble_quest_script(
((ene_set.base_type >= 0x002B) && (ene_set.base_type <= 0x002D)) ||
((ene_set.base_type >= 0x0030) && (ene_set.base_type <= 0x0033)) ||
((ene_set.base_type >= 0x0045) && (ene_set.base_type <= 0x0047)) ||
((ene_set.base_type >= 0x00D0) && (ene_set.base_type <= 0x00D7)) ||
((ene_set.base_type >= 0x00D0) && (ene_set.base_type <= 0x00D7) && (area == 0)) ||
((ene_set.base_type >= 0x00F0) && (ene_set.base_type <= 0x0100)) ||
((ene_set.base_type >= 0x0110) && (ene_set.base_type <= 0x0112)) ||
((ene_set.base_type >= 0x0110) && (ene_set.base_type <= 0x0112) && (area == 0)) ||
(ene_set.base_type == 0x00A9) ||
(ene_set.base_type == 0x0118)) &&
(ene_set.param5 > 0) && (ene_set.param5 < label_table.size())) {
@@ -3553,12 +3538,20 @@ std::string disassemble_quest_script(
break;
}
case Type::R_REG:
case Type::W_REG: {
uint8_t reg = label_r.get_u8();
case Type::R_REG32:
case Type::W_REG:
case Type::W_REG32: {
uint32_t reg = ((arg.type == Type::R_REG32) || (arg.type == Type::W_REG32))
? label_r.get_u32l()
: label_r.get_u8();
if (def->flags & F_PUSH_ARG) {
arg_stack_values.emplace_back((def->opcode == 0x004C) ? ArgStackValue::Type::REG_PTR : ArgStackValue::Type::REG, reg);
}
dasm_arg = std::format("r{}", reg);
if (reg > 0xFF) {
dasm_arg = std::format("r{} /* warning: register number out of range */", reg);
} else {
dasm_arg = std::format("r{}", reg);
}
break;
}
case Type::R_REG_SET: {
@@ -4257,17 +4250,7 @@ AssembledQuestScript assemble_quest_script(
}
// Collect metadata directives
Version quest_version = Version::UNKNOWN;
string quest_name;
string quest_short_desc;
string quest_long_desc;
int64_t quest_num = -1;
Language quest_language = Language::ENGLISH;
Episode quest_episode = Episode::EP1;
uint8_t quest_max_players = 4;
bool quest_joinable = false;
std::shared_ptr<parray<uint8_t, 0x94>> bb_unknown_a5;
std::vector<QuestMetadata::CreateItemMask> create_item_mask_entries;
AssembledQuestScript ret;
for (const auto& line : lines) {
if (line.text.empty()) {
continue;
@@ -4279,15 +4262,18 @@ AssembledQuestScript assemble_quest_script(
} else if (line.text.starts_with(".version ")) {
string name = line.text.substr(9);
phosg::strip_leading_whitespace(name);
quest_version = phosg::enum_for_name<Version>(name);
ret.meta.version = phosg::enum_for_name<Version>(name);
if ((ret.meta.episode == Episode::NONE) && is_v1_or_v2(ret.meta.version) && (ret.meta.version != Version::GC_NTE)) {
ret.meta.episode = Episode::EP1;
}
} else if (line.text.starts_with(".name ")) {
quest_name = phosg::parse_data_string(line.text.substr(6));
ret.meta.name = phosg::parse_data_string(line.text.substr(6));
} else if (line.text.starts_with(".short_desc ")) {
quest_short_desc = phosg::parse_data_string(line.text.substr(12));
ret.meta.short_description = phosg::parse_data_string(line.text.substr(12));
} else if (line.text.starts_with(".long_desc ")) {
quest_long_desc = phosg::parse_data_string(line.text.substr(11));
ret.meta.long_description = phosg::parse_data_string(line.text.substr(11));
} else if (line.text.starts_with(".allow_create_item ")) {
if (create_item_mask_entries.size() >= 0x40) {
if (ret.meta.create_item_mask_entries.size() >= 0x40) {
throw std::runtime_error("too many .allow_create_item directives; at most 64 are allowed");
}
@@ -4295,42 +4281,56 @@ AssembledQuestScript assemble_quest_script(
phosg::strip_whitespace(args_str);
QuestMetadata::CreateItemMask mask(line.text.substr(19));
create_item_mask_entries.emplace_back(mask);
ret.meta.create_item_mask_entries.emplace_back(mask);
} else if (line.text.starts_with(".quest_num ")) {
quest_num = stoul(line.text.substr(11), nullptr, 0);
ret.meta.quest_number = stoul(line.text.substr(11), nullptr, 0);
} else if (line.text.starts_with(".language ")) {
auto code = line.text.substr(10);
if (code.size() != 1) {
throw runtime_error(".language directive argument is invalid");
}
quest_language = language_for_char(code[0]);
ret.meta.language = language_for_char(code[0]);
} else if (line.text.starts_with(".episode ")) {
quest_episode = episode_for_token_name(line.text.substr(9));
ret.meta.episode = episode_for_token_name(line.text.substr(9));
} else if (line.text.starts_with(".max_players ")) {
quest_max_players = stoul(line.text.substr(12), nullptr, 0);
ret.meta.max_players = stoul(line.text.substr(12), nullptr, 0);
} else if (line.text.starts_with(".joinable ")) {
quest_joinable = true;
} else if (line.text.starts_with(".bb_unknown_a5 ")) {
std::string data = phosg::parse_data_string(line.text.substr(15));
ret.meta.joinable = true;
} else if (line.text.starts_with(".header_language ")) {
ret.meta.header_language = stoul(line.text.substr(17), nullptr, 0);
} else if (line.text.starts_with(".header_episode ")) {
ret.meta.header_episode = stoul(line.text.substr(16), nullptr, 0);
} else if (line.text.starts_with(".header_unknown_a1 ")) {
ret.meta.header_unknown_a1 = stoul(line.text.substr(19), nullptr, 0);
} else if (line.text.starts_with(".header_unknown_a2 ")) {
ret.meta.header_unknown_a2 = stoul(line.text.substr(19), nullptr, 0);
} else if (line.text.starts_with(".header_unknown_a3 ")) {
ret.meta.header_unknown_a3 = stoul(line.text.substr(19), nullptr, 0);
} else if (line.text.starts_with(".header_unknown_a4 ")) {
ret.meta.header_unknown_a4 = stoul(line.text.substr(19), nullptr, 0);
} else if (line.text.starts_with(".header_unknown_a6 ")) {
ret.meta.header_unknown_a6 = stoul(line.text.substr(19), nullptr, 0);
} else if (line.text.starts_with(".header_unknown_a5 ")) {
std::string data = phosg::parse_data_string(line.text.substr(19));
if (data.size() != 0x94) {
throw std::runtime_error(".bb_unknown_a5 directive must specify 0x94 bytes of data");
throw std::runtime_error(".header_unknown_a5 directive must specify 0x94 bytes of data");
}
bb_unknown_a5 = std::make_shared<parray<uint8_t, 0x94>>();
ret.meta.header_unknown_a5 = std::make_shared<parray<uint8_t, 0x94>>();
for (size_t z = 0; z < 0x94; z++) {
bb_unknown_a5->at(z) = static_cast<uint8_t>(data[z]);
ret.meta.header_unknown_a5->at(z) = static_cast<uint8_t>(data[z]);
}
}
}
});
}
if (quest_version == Version::PC_PATCH || quest_version == Version::BB_PATCH || quest_version == Version::UNKNOWN) {
if (ret.meta.version == Version::PC_PATCH || ret.meta.version == Version::BB_PATCH || ret.meta.version == Version::UNKNOWN) {
throw runtime_error(".version directive is missing or invalid");
}
if (quest_num < 0) {
if (ret.meta.quest_number < 0) {
throw runtime_error(".quest_num directive is missing or invalid");
}
if (quest_name.empty()) {
if (ret.meta.name.empty()) {
throw runtime_error(".name directive is missing or invalid");
}
@@ -4488,8 +4488,8 @@ AssembledQuestScript assemble_quest_script(
throw runtime_error("data not found for native include: " + filename);
};
bool version_has_args = F_HAS_ARGS & v_flag(quest_version);
const auto& opcodes = opcodes_by_name_for_version(quest_version);
bool version_has_args = F_HAS_ARGS & v_flag(ret.meta.version);
const auto& opcodes = opcodes_by_name_for_version(ret.meta.version);
phosg::StringWriter code_w;
for (const auto& line : lines) {
wrap_exceptions_with_line_ref(line, [&]() -> void {
@@ -4509,11 +4509,11 @@ AssembledQuestScript assemble_quest_script(
code_w.write(phosg::parse_data_string(line.text.substr(6)));
} else if (line.text.starts_with(".cstr ")) {
string data = phosg::parse_data_string(line.text.substr(6));
if (uses_utf16(quest_version)) {
if (uses_utf16(ret.meta.version)) {
code_w.write(tt_utf8_to_utf16(data));
code_w.put_u16l(0);
} else {
code_w.write((quest_language == Language::JAPANESE) ? tt_utf8_to_sega_sjis(data) : tt_utf8_to_8859(data));
code_w.write((ret.meta.language == Language::JAPANESE) ? tt_utf8_to_sega_sjis(data) : tt_utf8_to_8859(data));
code_w.put_u8(0);
}
} else if (line.text.starts_with(".zero ")) {
@@ -4538,11 +4538,11 @@ AssembledQuestScript assemble_quest_script(
phosg::strip_whitespace(filename);
string native_text = get_native_include(filename);
string code;
if (is_ppc(quest_version)) {
if (is_ppc(ret.meta.version)) {
code = std::move(ResourceDASM::PPC32Emulator::assemble(native_text).code);
} else if (is_x86(quest_version)) {
} else if (is_x86(ret.meta.version)) {
code = std::move(ResourceDASM::X86Emulator::assemble(native_text).code);
} else if (is_sh4(quest_version)) {
} else if (is_sh4(ret.meta.version)) {
code = std::move(ResourceDASM::SH4Emulator::assemble(native_text).code);
} else {
throw runtime_error("unknown architecture");
@@ -4603,7 +4603,7 @@ AssembledQuestScript assemble_quest_script(
try {
auto add_cstr = [&](const string& text, bool bin) -> void {
switch (quest_version) {
switch (ret.meta.version) {
case Version::DC_NTE:
code_w.write(bin ? text : tt_utf8_to_sega_sjis(text));
code_w.put_u8(0);
@@ -4616,7 +4616,7 @@ AssembledQuestScript assemble_quest_script(
case Version::GC_EP3_NTE:
case Version::GC_EP3:
case Version::XB_V3:
code_w.write(bin ? text : ((quest_language == Language::JAPANESE) ? tt_utf8_to_sega_sjis(text) : tt_utf8_to_8859(text)));
code_w.write(bin ? text : ((ret.meta.language == Language::JAPANESE) ? tt_utf8_to_sega_sjis(text) : tt_utf8_to_8859(text)));
code_w.put_u8(0);
break;
case Version::PC_NTE:
@@ -4715,9 +4715,9 @@ AssembledQuestScript assemble_quest_script(
size_t label_index;
auto it = labels_by_name.find(name);
if (it == labels_by_name.end()) {
if (strict) {
if (strict || !name.starts_with("label")) {
throw runtime_error("label not defined: " + name);
} else if (name.starts_with("label")) {
} else {
size_t used_chars;
label_index = std::stoul(name.substr(5), &used_chars, 16);
if (used_chars != name.size() - 5) {
@@ -4831,8 +4831,12 @@ AssembledQuestScript assemble_quest_script(
}
});
}
while (code_w.size() & 3) {
code_w.put_u8(0);
// Allow label table to be misaligned on x86 architectures in non-strict mode (some official quests do this)
if (strict || !is_x86(ret.meta.version)) {
while (code_w.size() & 3) {
code_w.put_u8(0);
}
}
// Assign all register numbers and patch the code section if needed
@@ -4871,43 +4875,55 @@ AssembledQuestScript assemble_quest_script(
}
// Generate header
auto set_basic_header_fields = [&]<typename HeaderT>(HeaderT& header) -> void {
ret.meta.text_offset = sizeof(header);
ret.meta.label_table_offset = ret.meta.text_offset + code_w.size();
header.text_offset = ret.meta.text_offset;
header.label_table_offset = ret.meta.label_table_offset;
header.size = ret.meta.label_table_offset + label_table.size() * sizeof(label_table[0]);
header.unknown_a1 = ret.meta.header_unknown_a1;
header.unknown_a2 = ret.meta.header_unknown_a2;
};
phosg::StringWriter w;
switch (quest_version) {
switch (ret.meta.version) {
case Version::DC_NTE: {
PSOQuestHeaderDCNTE header;
header.text_offset = sizeof(header);
header.label_table_offset = sizeof(header) + code_w.size();
header.size = header.label_table_offset + label_table.size() * sizeof(label_table[0]);
header.name.encode(quest_name, Language::JAPANESE);
set_basic_header_fields(header);
header.name.encode(ret.meta.name, Language::JAPANESE);
w.put(header);
break;
}
case Version::DC_11_2000:
case Version::DC_11_2000: {
PSOQuestHeaderDC112000 header;
set_basic_header_fields(header);
header.name.encode(ret.meta.name, ret.meta.language);
header.short_description.encode(ret.meta.short_description, ret.meta.language);
header.long_description.encode(ret.meta.long_description, ret.meta.language);
break;
}
case Version::DC_V1:
case Version::DC_V2: {
PSOQuestHeaderDC header;
header.text_offset = sizeof(header);
header.label_table_offset = sizeof(header) + code_w.size();
header.size = header.label_table_offset + label_table.size() * sizeof(label_table[0]);
header.language = quest_language;
header.quest_number = quest_num;
header.name.encode(quest_name, quest_language);
header.short_description.encode(quest_short_desc, quest_language);
header.long_description.encode(quest_long_desc, quest_language);
set_basic_header_fields(header);
header.language = (ret.meta.header_language >= 0) ? static_cast<Language>(ret.meta.header_language) : ret.meta.language;
header.unknown_a3 = ret.meta.header_unknown_a3;
header.quest_number = ret.meta.quest_number;
header.name.encode(ret.meta.name, ret.meta.language);
header.short_description.encode(ret.meta.short_description, ret.meta.language);
header.long_description.encode(ret.meta.long_description, ret.meta.language);
w.put(header);
break;
}
case Version::PC_NTE:
case Version::PC_V2: {
PSOQuestHeaderPC header;
header.text_offset = sizeof(header);
header.label_table_offset = sizeof(header) + code_w.size();
header.size = header.label_table_offset + label_table.size() * sizeof(label_table[0]);
header.language = quest_language;
header.quest_number = quest_num;
header.name.encode(quest_name, quest_language);
header.short_description.encode(quest_short_desc, quest_language);
header.long_description.encode(quest_long_desc, quest_language);
set_basic_header_fields(header);
header.language = (ret.meta.header_language >= 0) ? static_cast<Language>(ret.meta.header_language) : ret.meta.language;
header.unknown_a3 = ret.meta.header_unknown_a3;
header.quest_number = ret.meta.quest_number;
header.name.encode(ret.meta.name, ret.meta.language);
header.short_description.encode(ret.meta.short_description, ret.meta.language);
header.long_description.encode(ret.meta.long_description, ret.meta.language);
w.put(header);
break;
}
@@ -4916,43 +4932,44 @@ AssembledQuestScript assemble_quest_script(
case Version::GC_EP3_NTE:
case Version::GC_EP3:
case Version::XB_V3: {
PSOQuestHeaderGC header;
header.text_offset = sizeof(header);
header.label_table_offset = sizeof(header) + code_w.size();
header.size = header.label_table_offset + label_table.size() * sizeof(label_table[0]);
header.language = quest_language;
header.quest_number = quest_num;
header.name.encode(quest_name, quest_language);
header.short_description.encode(quest_short_desc, quest_language);
header.long_description.encode(quest_long_desc, quest_language);
PSOQuestHeaderV3 header;
set_basic_header_fields(header);
header.language = (ret.meta.header_language >= 0) ? static_cast<Language>(ret.meta.header_language) : ret.meta.language;
header.unknown_a3 = ret.meta.header_unknown_a3;
header.quest_number = ret.meta.quest_number;
header.name.encode(ret.meta.name, ret.meta.language);
header.short_description.encode(ret.meta.short_description, ret.meta.language);
header.long_description.encode(ret.meta.long_description, ret.meta.language);
w.put(header);
break;
}
case Version::BB_V4: {
PSOQuestHeaderBB header;
header.text_offset = sizeof(header);
header.label_table_offset = sizeof(header) + code_w.size();
header.size = header.label_table_offset + label_table.size() * sizeof(label_table[0]);
header.quest_number = quest_num;
if (quest_episode == Episode::EP4) {
set_basic_header_fields(header);
header.quest_number = ret.meta.quest_number;
header.unknown_a6 = ret.meta.header_unknown_a6;
if (ret.meta.header_episode >= 0) {
header.episode = ret.meta.header_episode;
} else if (ret.meta.episode == Episode::EP4) {
header.episode = 2;
} else if (quest_episode == Episode::EP2) {
} else if (ret.meta.episode == Episode::EP2) {
header.episode = 1;
} else {
header.episode = 0;
}
header.max_players = (quest_max_players == 4) ? 0 : quest_max_players;
header.joinable = quest_joinable ? 1 : 0;
header.name.encode(quest_name, quest_language);
header.short_description.encode(quest_short_desc, quest_language);
header.long_description.encode(quest_long_desc, quest_language);
if (bb_unknown_a5) {
header.unknown_a5 = *bb_unknown_a5;
header.max_players = ret.meta.max_players;
header.joinable = ret.meta.joinable ? 1 : 0;
header.unknown_a4 = ret.meta.header_unknown_a4;
header.name.encode(ret.meta.name, ret.meta.language);
header.short_description.encode(ret.meta.short_description, ret.meta.language);
header.long_description.encode(ret.meta.long_description, ret.meta.language);
if (ret.meta.header_unknown_a5) {
header.unknown_a5 = *ret.meta.header_unknown_a5;
} else {
header.unknown_a5.clear(0);
}
for (size_t z = 0; z < create_item_mask_entries.size(); z++) {
header.create_item_mask_entries[z] = create_item_mask_entries[z];
for (size_t z = 0; z < ret.meta.create_item_mask_entries.size(); z++) {
header.create_item_mask_entries[z] = ret.meta.create_item_mask_entries[z];
}
w.put(header);
break;
@@ -4962,18 +4979,9 @@ AssembledQuestScript assemble_quest_script(
}
w.write(code_w.str());
w.write(label_table.data(), label_table.size() * sizeof(label_table[0]));
return AssembledQuestScript{
.data = std::move(w.str()),
.quest_number = quest_num,
.version = quest_version,
.language = quest_language,
.episode = quest_episode,
.joinable = quest_joinable,
.max_players = quest_max_players,
.name = quest_name,
.short_description = quest_short_desc,
.long_description = quest_long_desc,
};
ret.data = std::move(w.str());
return ret;
}
void populate_quest_metadata_from_script(
@@ -4984,6 +4992,8 @@ void populate_quest_metadata_from_script(
switch (version) {
case Version::DC_NTE: {
const auto& header = r.get<PSOQuestHeaderDCNTE>();
meta.header_unknown_a1 = header.unknown_a1;
meta.header_unknown_a2 = header.unknown_a2;
meta.episode = Episode::EP1;
meta.max_players = 4;
meta.name = header.name.decode(language);
@@ -4997,6 +5007,8 @@ void populate_quest_metadata_from_script(
}
case Version::DC_11_2000: {
const auto& header = r.get<PSOQuestHeaderDC112000>();
meta.header_unknown_a1 = header.unknown_a1;
meta.header_unknown_a2 = header.unknown_a2;
meta.episode = Episode::EP1;
meta.max_players = 4;
meta.language = (language == Language::UNKNOWN) ? Language::JAPANESE : language;
@@ -5013,6 +5025,10 @@ void populate_quest_metadata_from_script(
case Version::DC_V1:
case Version::DC_V2: {
const auto& header = r.get<PSOQuestHeaderDC>();
meta.header_language = static_cast<uint8_t>(header.language);
meta.header_unknown_a1 = header.unknown_a1;
meta.header_unknown_a2 = header.unknown_a2;
meta.header_unknown_a3 = header.unknown_a3;
meta.episode = Episode::EP1;
meta.max_players = 4;
meta.language = (language != Language::UNKNOWN) ? language : ((static_cast<size_t>(header.language) < 5) ? header.language : Language::ENGLISH);
@@ -5029,6 +5045,10 @@ void populate_quest_metadata_from_script(
case Version::PC_NTE:
case Version::PC_V2: {
const auto& header = r.get<PSOQuestHeaderPC>();
meta.header_language = static_cast<uint8_t>(header.language);
meta.header_unknown_a1 = header.unknown_a1;
meta.header_unknown_a2 = header.unknown_a2;
meta.header_unknown_a3 = header.unknown_a3;
meta.episode = Episode::EP1;
meta.max_players = 4;
if (meta.quest_number == 0xFFFFFFFF) {
@@ -5051,7 +5071,11 @@ void populate_quest_metadata_from_script(
// same as Episode 3 maps and download quests. Quest scripts (handled
// here) are only used offline in story mode, but can be disassembled
// with disassemble_quest_script, hence we need to be able to parse them.
const auto& header = r.get<PSOQuestHeaderGC>();
const auto& header = r.get<PSOQuestHeaderV3>();
meta.header_language = static_cast<uint8_t>(header.language);
meta.header_unknown_a1 = header.unknown_a1;
meta.header_unknown_a2 = header.unknown_a2;
meta.header_unknown_a3 = header.unknown_a3;
meta.episode = Episode::EP1;
meta.max_players = 4;
if (meta.quest_number == 0xFFFFFFFF) {
@@ -5067,9 +5091,14 @@ void populate_quest_metadata_from_script(
}
case Version::BB_V4: {
const auto& header = r.get<PSOQuestHeaderBBBase>();
meta.header_episode = header.episode;
meta.header_unknown_a1 = header.unknown_a1;
meta.header_unknown_a2 = header.unknown_a2;
meta.header_unknown_a4 = header.unknown_a4;
meta.header_unknown_a6 = header.unknown_a6;
meta.episode = episode_for_quest_episode_number(header.episode);
meta.joinable |= header.joinable;
meta.max_players = header.max_players ? header.max_players : 4;
meta.max_players = header.max_players;
if (meta.quest_number == 0xFFFFFFFF) {
meta.quest_number = header.quest_number;
}
@@ -5084,7 +5113,7 @@ void populate_quest_metadata_from_script(
(header.label_table_offset >= sizeof(PSOQuestHeaderBB))) {
r.go(0);
const auto& header = r.get<PSOQuestHeaderBB>();
meta.bb_unknown_a5 = std::make_shared<parray<uint8_t, 0x94>>(header.unknown_a5);
meta.header_unknown_a5 = std::make_shared<parray<uint8_t, 0x94>>(header.unknown_a5);
for (size_t z = 0; z < header.create_item_mask_entries.size(); z++) {
const auto& item = header.create_item_mask_entries[z];
if (!item.is_valid()) {
src/QuestScript.hh
+4 -14
View File
@@ -62,9 +62,7 @@ struct PSOQuestHeaderPC {
/* 0394 */
} __packed_ws__(PSOQuestHeaderPC, 0x394);
// TODO: Is the XB quest header format the same as on GC? If not, make a
// separate struct; if so, rename this struct to V3.
struct PSOQuestHeaderGC {
struct PSOQuestHeaderV3 {
/* 0000 */ le_uint32_t text_offset = 0;
/* 0004 */ le_uint32_t label_table_offset = 0;
/* 0008 */ le_uint32_t size = 0;
@@ -81,7 +79,7 @@ struct PSOQuestHeaderGC {
/* 0034 */ pstring<TextEncoding::MARKED, 0x80> short_description;
/* 00B4 */ pstring<TextEncoding::MARKED, 0x120> long_description;
/* 01D4 */
} __packed_ws__(PSOQuestHeaderGC, 0x1D4);
} __packed_ws__(PSOQuestHeaderV3, 0x1D4);
struct CreateItemMaskEntry {
parray<le_int32_t, 12> data1_fields;
@@ -104,7 +102,7 @@ struct PSOQuestHeaderBBBase {
/* 000C */ le_uint16_t unknown_a1 = 0xFFFF;
/* 000E */ le_uint16_t unknown_a2 = 0xFFFF;
/* 0010 */ le_uint16_t quest_number = 0; // 0xFFFF for challenge quests
/* 0012 */ le_uint16_t unknown_a3 = 0;
/* 0012 */ le_uint16_t unknown_a6 = 0;
/* 0014 */ uint8_t episode = 0; // 0 = Ep1, 1 = Ep2, 2 = Ep4
/* 0015 */ uint8_t max_players = 0; // 0 means no limit (that is, 4)
/* 0016 */ uint8_t joinable = 0;
@@ -136,15 +134,7 @@ std::string disassemble_quest_script(
struct AssembledQuestScript {
std::string data;
int64_t quest_number = -1;
Version version = Version::UNKNOWN;
Language language = Language::UNKNOWN;
Episode episode = Episode::NONE;
bool joinable = false;
uint8_t max_players = 4;
std::string name;
std::string short_description;
std::string long_description;
QuestMetadata meta;
};
AssembledQuestScript assemble_quest_script(
const std::string& text,
src/ReceiveCommands.cc
+3 -3
View File
@@ -363,7 +363,7 @@ static asio::awaitable<void> on_login_complete(shared_ptr<Client> c) {
lobby_data.guild_card_number = c->login->account->account_id;
send_command_t(c, 0x64, 0x01, cmd);
} else {
c->log.info_f("Sending {} version of quest \"{}\"", name_for_language(vq->language), vq->meta.name);
c->log.info_f("Sending {} version of quest \"{}\"", name_for_language(vq->meta.language), vq->meta.name);
string bin_filename = vq->bin_filename();
string dat_filename = vq->dat_filename();
string xb_filename = vq->xb_filename();
@@ -2495,7 +2495,7 @@ void set_lobby_quest(shared_ptr<Lobby> l, shared_ptr<const Quest> q, bool substi
lc->channel->disconnect();
break;
}
lc->log.info_f("Sending {} version of quest \"{}\"", name_for_language(vq->language), vq->meta.name);
lc->log.info_f("Sending {} version of quest \"{}\"", name_for_language(vq->meta.language), vq->meta.name);
string bin_filename = vq->bin_filename();
string dat_filename = vq->dat_filename();
@@ -4979,7 +4979,7 @@ static asio::awaitable<void> on_6F(shared_ptr<Client> c, Channel::Message& msg)
if (!vq) {
throw std::logic_error("cannot find patch enable quest version after it was previously found during login");
}
c->log.info_f("Sending {} version of quest \"{}\"", name_for_language(vq->language), vq->meta.name);
c->log.info_f("Sending {} version of quest \"{}\"", name_for_language(vq->meta.language), vq->meta.name);
string bin_filename = vq->bin_filename();
string dat_filename = vq->dat_filename();
string xb_filename = vq->xb_filename();
src/ServerState.cc
+5 -6
View File
@@ -508,8 +508,8 @@ ItemData ServerState::parse_item_description(Version version, const string& desc
}
shared_ptr<const CommonItemSet> ServerState::common_item_set(Version logic_version, shared_ptr<const Quest> q) const {
if (q && q->meta.common_item_set) {
return q->meta.common_item_set;
if (q && !q->meta.common_item_set_name.empty()) {
return this->common_item_sets.at(q->meta.common_item_set_name);
} else if (is_v1_or_v2(logic_version) && (logic_version != Version::GC_NTE)) {
// TODO: We should probably have a v1 common item set at some point too
return this->common_item_sets.at("common-table-v1-v2");
@@ -521,8 +521,8 @@ shared_ptr<const CommonItemSet> ServerState::common_item_set(Version logic_versi
}
shared_ptr<const RareItemSet> ServerState::rare_item_set(Version logic_version, shared_ptr<const Quest> q) const {
if (q && q->meta.rare_item_set) {
return q->meta.rare_item_set;
if (q && !q->meta.rare_item_set_name.empty()) {
return this->rare_item_sets.at(q->meta.rare_item_set_name);
} else if (is_v1(logic_version)) {
return this->rare_item_sets.at("rare-table-v1");
} else if (is_v2(logic_version) && (logic_version != Version::GC_NTE)) {
@@ -2150,8 +2150,7 @@ void ServerState::load_ep3_tournament_state() {
void ServerState::load_quest_index(bool raise_on_any_failure) {
config_log.info_f("Collecting quests");
this->quest_index = make_shared<QuestIndex>(
"system/quests", this->quest_category_index, this->common_item_sets, this->rare_item_sets, raise_on_any_failure);
this->quest_index = make_shared<QuestIndex>("system/quests", this->quest_category_index, raise_on_any_failure);
}
void ServerState::compile_functions(bool raise_on_any_failure) {
system/quests/download/q000-gc-e.bin
BIN
View File
Binary file not shown.
system/quests/download/q072-gc-e.bin
BIN
View File
Binary file not shown.
system/quests/events/q073-bb-e.bin
BIN
View File
Binary file not shown.
system/quests/retrieval/q087-gc-j.bin
BIN
View File
Binary file not shown.
system/quests/retrieval/q138-gc-s.bin
BIN
View File
Binary file not shown.