mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-08-22 07:04:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix jak 2 text encoding/decoding + minor decomp type fixes (#2476)

Browse Source 
Now all text in all non-Korean languages is built correctly.
This commit is contained in:
ManDude
2023-04-14 02:09:12 +01:00
committed by GitHub
parent 1f4872b25d
commit 7d11c6e100
28 changed files with 1906 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/util/FontUtils.cpp
+524 -167
View File
@@ -56,7 +56,6 @@ GameTextFontBank::GameTextFontBank(GameTextVersion version,
std::sort(
m_replace_info->begin(), m_replace_info->end(),
[](const ReplaceInfo& a, const ReplaceInfo& b) { return a.from.size() > b.from.size(); });
(void)m_version;
}
/*!
@@ -105,62 +104,170 @@ const EncodeInfo* GameTextFontBank::find_encode_to_game(const std::string& in, i
return best_info;
}
/*!
* Finds a remap info that best matches the byte sequence (is the longest match).
*/
const ReplaceInfo* GameTextFontBank::find_replace_to_utf8(const std::string& in, int off) const {
const ReplaceInfo* best_info = nullptr;
for (auto& info : *m_replace_info) {
if (info.from.empty() || in.size() - off < info.from.size())
continue;
bool found = true;
for (int i = 0; found && i < (int)info.from.size(); ++i) {
if (in.at(i + off) != info.from.at(i)) {
found = false;
}
}
if (found && (!best_info || info.to.length() > best_info->to.length())) {
best_info = &info;
}
}
return best_info;
}
/*!
* Finds a remap info that best matches the character sequence (is the longest match).
*/
const ReplaceInfo* GameTextFontBank::find_replace_to_game(const std::string& in, int off) const {
const ReplaceInfo* best_info = nullptr;
for (auto& info : *m_replace_info) {
if (info.to.length() == 0 || in.size() - off < info.to.size())
continue;
bool found = true;
for (int i = 0; found && i < (int)info.to.length(); ++i) {
if (in.at(i + off) != info.to.at(i)) {
found = false;
}
}
if (found && (!best_info || info.to.length() > best_info->to.length())) {
best_info = &info;
}
}
return best_info;
}
/*!
* Try to replace specific substrings with better variants.
* These are for hiding confusing text transforms.
*/
std::string GameTextFontBank::replace_to_utf8(std::string& str) const {
for (auto& info : *m_replace_info) {
auto pos = str.find(info.from);
while (pos != std::string::npos) {
str.replace(pos, info.from.size(), info.to);
pos = str.find(info.from, pos + info.to.size());
std::string newstr;
for (int i = 0; i < (int)str.length();) {
auto remap = find_replace_to_utf8(str, i);
if (!remap) {
newstr.push_back(str.at(i));
i += 1;
} else {
for (auto b : remap->to) {
newstr.push_back(b);
}
i += remap->from.length();
}
}
str = newstr;
return str;
}
std::string GameTextFontBank::replace_to_game(std::string& str) const {
for (auto& info : *m_replace_info) {
if (info.to.empty()) {
// Skip empty replacements, else it's an infinite loop
continue;
}
auto pos = str.find(info.to);
while (pos != std::string::npos) {
str.replace(pos, info.to.size(), info.from);
pos = str.find(info.to, pos + info.from.size());
std::string newstr;
for (int i = 0; i < (int)str.length();) {
auto remap = find_replace_to_game(str, i);
if (!remap) {
newstr.push_back(str.at(i));
i += 1;
} else {
for (auto b : remap->from) {
newstr.push_back(b);
}
i += remap->to.length();
}
}
str = newstr;
return str;
}
std::string GameTextFontBank::encode_utf8_to_game(std::string& str) const {
std::string new_str;
std::string newstr;
for (int i = 0; i < (int)str.length();) {
auto remap = find_encode_to_game(str, i);
if (!remap) {
new_str.push_back(str.at(i));
newstr.push_back(str.at(i));
i += 1;
} else {
for (auto b : remap->bytes) {
new_str.push_back(b);
newstr.push_back(b);
}
i += remap->chars.length();
}
}
str = new_str;
str = newstr;
return str;
}
/*!
* Turn a normal readable string into a string readable in the Jak 1 font encoding.
* Turn a normal readable string into a string readable in the in-game font encoding and converts
* \cXX escape sequences
*/
std::string GameTextFontBank::convert_utf8_to_game(std::string str) const {
replace_to_game(str);
encode_utf8_to_game(str);
return str;
std::string GameTextFontBank::convert_utf8_to_game(std::string str, bool escape) const {
std::string newstr;
if (escape) {
for (size_t i = 0; i < str.size(); ++i) {
auto c = str.at(i);
if (c == '"') {
newstr.push_back('"');
i += 1;
} else if (c == '\\') {
if (i + 1 >= str.size()) {
throw std::runtime_error("incomplete string escape code");
}
auto p = str.at(i + 1);
if (p == 'c') {
if (i + 3 >= str.size()) {
throw std::runtime_error("incomplete string escape code");
}
auto first = str.at(i + 2);
auto second = str.at(i + 3);
if (!hex_char(first) || !hex_char(second)) {
throw std::runtime_error("invalid character escape hex number");
}
char hex_num[3] = {first, second, '\0'};
std::size_t end = 0;
auto value = std::stoul(hex_num, &end, 16);
if (end != 2) {
throw std::runtime_error("invalid character escape");
}
ASSERT(value < 256);
newstr.push_back(char(value));
i += 3;
} else if (p == '"' || p == '\\') {
newstr.push_back(p);
i += 1;
} else {
throw std::runtime_error(
fmt::format("unknown string escape code '{}' (0x{:x})", p, u32(p)));
}
} else {
newstr.push_back(c);
}
}
} else {
newstr = str;
}
replace_to_game(newstr);
encode_utf8_to_game(newstr);
return newstr;
}
bool GameTextFontBank::valid_char_range(const char in) const {
@@ -176,83 +283,48 @@ bool GameTextFontBank::valid_char_range(const char in) const {
return false;
}
/*!
* Turn a normal readable string into a string readable in the in-game font encoding and converts
* \cXX escape sequences
*/
std::string GameTextFontBank::convert_utf8_to_game_with_escape(const std::string& str) const {
std::string newstr;
for (size_t i = 0; i < str.size(); ++i) {
auto c = str.at(i);
if (c == '"') {
newstr.push_back('"');
i += 1;
} else if (c == '\\') {
if (i + 1 >= str.size()) {
throw std::runtime_error("incomplete string escape code");
}
auto p = str.at(i + 1);
if (p == 'c') {
if (i + 3 >= str.size()) {
throw std::runtime_error("incomplete string escape code");
}
auto first = str.at(i + 2);
auto second = str.at(i + 3);
if (!hex_char(first) || !hex_char(second)) {
throw std::runtime_error("invalid character escape hex number");
}
char hex_num[3] = {first, second, '\0'};
std::size_t end = 0;
auto value = std::stoul(hex_num, &end, 16);
if (end != 2) {
throw std::runtime_error("invalid character escape");
}
ASSERT(value < 256);
newstr.push_back(char(value));
i += 3;
} else if (p == '"') {
newstr.push_back(p);
i += 1;
} else {
throw std::runtime_error("unknown string escape code");
}
} else {
newstr.push_back(c);
}
}
replace_to_game(newstr);
encode_utf8_to_game(newstr);
return newstr;
}
/*!
* Convert a string from the game-text font encoding to something normal.
* Unprintable characters become escape sequences, including tab and newline.
*/
std::string GameTextFontBank::convert_game_to_utf8(const char* in) const {
std::string temp;
std::string result;
std::string test = in;
if (test.find("America") != std::string::npos) {
printf("");
}
while (*in) {
auto remap = find_encode_to_utf8(in);
if (remap != nullptr) {
result.append(remap->chars);
temp.append(remap->chars);
in += remap->bytes.size() - 1;
} else if (valid_char_range(*in)) {
result.push_back(*in);
} else if (*in == '\n') {
result += "\\n";
} else if (*in == '\t') {
result += "\\t";
} else if (*in == '\\') {
result += "\\\\";
} else if (*in == '"') {
result += "\\\"";
} else if (valid_char_range(*in) || *in == '\n' || *in == '\t' || *in == '\\' || *in == '\"') {
temp.push_back(*in);
} else {
result += fmt::format("\\c{:02x}", uint8_t(*in));
temp += fmt::format("\\c{:02x}", uint8_t(*in));
}
in++;
}
replace_to_utf8(temp);
for (int i = 0; i < temp.length(); ++i) {
auto c = temp.at(i);
if (c == '\n') {
result += "\\n";
} else if (c == '\t') {
result += "\\t";
} else if (c == '\\') {
if (i < temp.length() - 1 && temp.at(i + 1) == 'c') {
result.push_back(c);
} else {
result += "\\\\";
}
} else if (c == '"') {
result += "\\\"";
} else {
result.push_back(c);
}
}
return replace_to_utf8(result);
}
@@ -848,13 +920,13 @@ GameTextFontBank g_font_bank_jak1_v2(GameTextVersion::JAK1_V2,
static std::unordered_set<char> s_passthrus_jak2 = {'~', ' ', ',', '.', '-', '+', '(', ')',
'!', ':', '?', '=', '%', '*', '/', '#',
';', '<', '>', '@', '[', '_'};
';', '<', '>', '@', '[', '_', ']'};
static std::vector<ReplaceInfo> s_replace_info_jak2 = {
// other
{"A~Y~-21H~-5Vº~Z", "Å"},
{"N~Y~-6Hº~Z~+10H", "Nº"},
{"~+4VÇ~-4V", "ç"},
{"~+4Vç~-4V", ",c"},
// tildes
{"N~Y~-22H~-4V<TIL>~Z", "Ñ"},
@@ -968,9 +1040,6 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
{",~+8H", "、"},
{"~+8H ", "　"},
// (hack) special case kanji
{"~~", "世"},
// playstation buttons
// - face
{"~Y~22L<~Z~Y~27L*~Z~Y~1L>~Z~Y~23L[~Z~+26H", "<PAD_X>"},
@@ -978,47 +1047,73 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
{"~Y~22L<~Z~Y~25L@~Z~Y~1L>~Z~Y~23L[~Z~+26H", "<PAD_CIRCLE>"},
{"~Y~22L<~Z~Y~24L#~Z~Y~1L>~Z~Y~23L[~Z~+26H", "<PAD_SQUARE>"},
// - dpad
{"~Y~22L<SYM7>~Z~3L~+17H~-13V<SYM8>~Z~22L~+17H~+14V<SYM9>~Z~22L~+32H<SYM10>~Z~+56H",
{"~Y~22L<PAD_PART_DPAD_L>~Z~3L~+17H~-13V<PAD_PART_DPAD_U>~Z~22L~+17H~+14V<PAD_PART_DPAD_D>~Z~"
"22L~+32H<PAD_PART_DPAD_R>~Z~+56H",
"<PAD_DPAD_UP>"},
{"~Y~22L<SYM7>~Z~3L~+17H~-13V<SYM8>~Z~3L~+17H~+14V<SYM9>~Z~22L~+32H<SYM10>~Z~+56H",
{"~Y~22L<PAD_PART_DPAD_L>~Z~3L~+17H~-13V<PAD_PART_DPAD_U>~Z~3L~+17H~+14V<PAD_PART_DPAD_D>~Z~"
"22L~+32H<PAD_PART_DPAD_R>~Z~+56H",
"<PAD_DPAD_DOWN>"},
{"~Y~22L<SYM7>~Z~22L~+17H~-13V<SYM8>~Z~22L~+17H~+14V<SYM9>~Z~22L~+32H<SYM10>~Z~+56H",
{"~Y~22L<PAD_PART_DPAD_L>~Z~22L~+17H~-13V<PAD_PART_DPAD_U>~Z~22L~+17H~+14V<PAD_PART_DPAD_D>~Z~"
"22L~+32H<PAD_PART_DPAD_R>~Z~+56H",
"<PAD_DPAD_ANY>"},
// - shoulder
{"~Y~22L~-2H~-12V<SYM1><SYM2>~Z~22L~-2H~+17V<SYM3><SYM4>~Z~1L~+4H~+3V<SYM5>~Z~+38H",
{"~Y~22L~-2H~-12V<PAD_PART_SHOULDER_TOP_LEFT><PAD_PART_SHOULDER_TOP_RIGHT>~Z~22L~-2H~+17V<PAD_"
"PART_SHOULDER_BOTTOM_LEFT><PAD_PART_SHOULDER_BOTTOM_RIGHT>~Z~1L~+4H~+3V<PAD_PART_L1_NAME>~Z~+"
"38H",
"<PAD_L1>"},
{"~Y~22L~-2H~-12V<SYM1><SYM2>~Z~22L~-2H~+17V<SYM3><SYM4>~Z~1L~+6H~+3V<SYM6>~Z~+38H",
{"~Y~22L~-2H~-12V<PAD_PART_SHOULDER_TOP_LEFT><PAD_PART_SHOULDER_TOP_RIGHT>~Z~22L~-2H~+17V<PAD_"
"PART_SHOULDER_BOTTOM_LEFT><PAD_PART_SHOULDER_BOTTOM_RIGHT>~Z~1L~+6H~+3V<PAD_PART_R1_NAME>~Z~+"
"38H",
"<PAD_R1>"},
{"~Y~22L~-2H~-6V<SYM11><SYM12>~Z~22L~-2H~+16V<SYM15><SYM14>~Z~1L~+5H~-2V<SYM13>~Z~+38H",
{"~Y~22L~-2H~-6V<PAD_PART_TRIGGER_TOP_LEFT><PAD_PART_TRIGGER_TOP_RIGHT>~Z~22L~-2H~+16V<PAD_"
"PART_TRIGGER_BOTTOM_LEFT><PAD_PART_TRIGGER_BOTTOM_RIGHT>~Z~1L~+5H~-2V<PAD_PART_R2_NAME>~Z~+"
"38H",
"<PAD_R2>"},
{"~Y~22L~-2H~-6V<SYM11><SYM12>~Z~22L~-2H~+16V<SYM15><SYM14>~Z~1L~+5H~-2V<SYM22>~Z~+38H",
{"~Y~22L~-2H~-6V<PAD_PART_TRIGGER_TOP_LEFT><PAD_PART_TRIGGER_TOP_RIGHT>~Z~22L~-2H~+16V<PAD_"
"PART_TRIGGER_BOTTOM_LEFT><PAD_PART_TRIGGER_BOTTOM_RIGHT>~Z~1L~+5H~-2V<PAD_PART_L2_NAME>~Z~+"
"38H",
"<PAD_L2>"},
// - analog
{"~1L~+8H~Y<SYM16>~Z~6L~-16H<SYM21>~Z~+16h~6L<SYM20>~Z~6L~-15V<SYM24>~Z~+13V~6L<SYM28>~Z~-10H~+"
"9V~"
"6L<SYM17>~Z~+10H~+9V~6L<SYM31>~Z~-10H~-11V~6L<SYM23>~Z~+10H~-11V~6L<SYM29>~Z~+32H",
{"~1L~+8H~Y<PAD_PART_STICK>~Z~6L~-16H<PAD_PART_STICK_LEFT>~Z~+16h~6L<PAD_PART_STICK_RIGHT>~Z~"
"6L~-15V<PAD_PART_STICK_DOWN>~Z~+13V~6L<PAD_PART_STICK_UP>~Z~-10H~+9V~6L<PAD_PART_STICK_UP_"
"LEFT>~Z~+10H~+9V~6L<PAD_PART_STICK_UP_RIGHT>~Z~-10H~-11V~6L<PAD_PART_STICK_DOWN_LEFT>~Z~+10H~"
"-11V~6L<PAD_PART_STICK_DOWN_RIGHT>~Z~+32H",
"<PAD_ANALOG_ANY>"},
{"~Y~1L~+8H<SYM16>~Z~6L~-8H<SYM21>~Z~+24H~6L<SYM20>~Z~+40H", "<PAD_ANALOG_LEFT_RIGHT>"},
{"~Y~1L<SYM16>~Z~6L~-15V<SYM24>~Z~+13V~6L<SYM28>~Z~+26H", "<PAD_ANALOG_UP_DOWN>"},
{"~Y~1L~+8H<PAD_PART_STICK>~Z~6L~-8H<PAD_PART_STICK_LEFT>~Z~+24H~6L<PAD_PART_STICK_RIGHT>~Z~+"
"40H",
"<PAD_ANALOG_LEFT_RIGHT>"},
{"~Y~1L<PAD_PART_STICK>~Z~6L~-15V<PAD_PART_STICK_DOWN>~Z~+13V~6L<PAD_PART_STICK_UP>~Z~+26H",
"<PAD_ANALOG_UP_DOWN>"},
// icons
{"~Y~6L<~Z~Y~1L>~Z~Y~23L[~Z~+26H", "<ICON_MISSION_COMPLETE>"},
{"~Y~3L<~Z~Y~1L>~Z~Y~23L[~Z~+26H", "<ICON_MISSION_TODO>"},
// flags
{"~Y~6L<SYM18>~Z~+15H~1L<SYM18>~Z~+30H~3L<SYM18>~Z~+45H", "<FLAG_ITALIAN>"},
{"~Y~5L<SYM19>~Z~3L<SYM32>~<SYM26>~-1H~Y~5L<SYM19>~Z~3L<SYM32>~Z~+26H", "<FLAG_SPAIN>"},
{"~Y~39L~~~Z~3L<SYM33>~Z~5L<SYM25>~<SYM26>~-1H~Y~39L~~~Z~3L<SYM33>~Z~5L<SYM25>~Z~+26H",
{"~Y~6L<FLAG_PART_VERT_STRIPE_LARGE>~Z~+15H~1L<FLAG_PART_VERT_STRIPE_LARGE>~Z~+30H~3L<FLAG_"
"PART_VERT_STRIPE_LARGE>~Z~+45H",
"<FLAG_ITALIAN>"},
{"~Y~5L<FLAG_PART_FILL>~Z~3L<FLAG_PART_TOP_BOTTOM_STRIPE>~]~-1H~Y~5L<FLAG_PART_FILL>~Z~3L<FLAG_"
"PART_TOP_BOTTOM_STRIPE>~Z~+26H",
"<FLAG_SPAIN>"},
{"~Y~39L~~~Z~3L<FLAG_PART_HORZ_TRIPE_MIDDLE>~Z~5L<FLAG_PART_HORZ_TRIPE_BOTTOM>~]~-1H~Y~39L~~~Z~"
"3L<FLAG_PART_HORZ_TRIPE_MIDDLE>~Z~5L<FLAG_PART_HORZ_TRIPE_BOTTOM>~Z~+26H",
"<FLAG_GERMAN>"},
{"~Y~7L<SYM18>~Z~+15H~1L<SYM18>~Z~+30H~3L<SYM18>~Z~+47H", "<FLAG_FRANCE>"},
{"~Y~1L<SYM19>~Z~3L<SYM34>~Z~7L<SYM37>~<SYM26>~-1H~Y~1L<SYM19>~Z~3L<SYM30>~Z~7L<SYM42>~Z~+26H",
"<FLAG_USA>"},
{"~Y~1L<SYM19>~Z~3L<SYM35>~Z~7L<SYM38>~<SYM26>~-1H~Y~1L<SYM19>~Z~3L<SYM40>~Z~+26H",
{"~Y~7L<FLAG_PART_VERT_STRIPE_LARGE>~Z~+15H~1L<FLAG_PART_VERT_STRIPE_LARGE>~Z~+30H~3L<FLAG_"
"PART_VERT_STRIPE_LARGE>~Z~+47H",
"<FLAG_FRANCE>"},
{"~Y~1L<FLAG_PART_FILL>~Z~3L<FLAG_PART_UK_CROSS_LEFT>~Z~7L<FLAG_PART_UK_FILL_LEFT>~]~-1H~Y~1L<"
"FLAG_PART_FILL>~Z~3L<FLAG_PART_UK_CROSS_RIGHT>~Z~7L<FLAG_PART_UK_FILL_RIGHT>~Z~+26H",
"<FLAG_UK>"},
{"~Y~1L<SYM19>~Z~39L<SYM36>~<SYM26>~-1H~Y~1L<SYM19>~Z~39L<SYM39>~Z~-11H~7L<SYM41>~Z~-11H~3L<"
"SYM43>~Z~+26H",
{"~Y~1L<FLAG_PART_FILL>~Z~3L<FLAG_PART_USA_STRIPES_LEFT>~Z~7L<FLAG_PART_USA_STARS>~]~-"
"1H~Y~1L<FLAG_PART_FILL>~Z~3L<FLAG_PART_USA_STRIPES_RIGHT>~Z~+26H",
"<FLAG_USA>"},
{"~Y~1L<FLAG_PART_FILL>~Z~39L<FLAG_PART_KOREA_TRIGRAMS_LEFT>~]~-1H~Y~1L<FLAG_PART_FILL>~Z~39L<"
"FLAG_PART_KOREA_TRIGRAMS_RIGHT>~Z~-11H~7L<FLAG_PART_KOREA_CIRCLE_FILL>~Z~-11H~3L<"
"FLAG_PART_KOREA_CIRCLE_TOP>~Z~+26H",
"<FLAG_KOREA>"},
{"~Y~1L<SYM19>~<SYM26>~-1H~Y~1L<SYM19>~Z~-11H~3L<SYM27>~Z~+26H", "<FLAG_JAPAN>"},
{"~Y~1L<FLAG_PART_FILL>~]~-1H~Y~1L<FLAG_PART_FILL>~Z~-11H~3L<FLAG_PART_JAPAN_SUN>~Z~+26H",
"<FLAG_JAPAN>"},
// weird stuff
// - descenders
@@ -1028,10 +1123,11 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
{"~+7Vq~-7V", "q"},
{"~+1Vj~-1V", "j"},
{"\\\\\\\\", "\\n"}, // wtf happened here!?
{"\\\\",
"~%"}, // this is 2 slashes, duplicated because we use an escape sequence when decompiling
// - symbols and ligatures
{"~-4H~-3V\\c19~+3V~-4H",
{"~-4H~-3V<SOMETHING>~+3V~-4H",
"<SUPERSCRIPT_QUOTE>"}, // used for the 4<__> place in spanish. the 5th uses the same
// character but looks different...?
{"~Y~-6Hº~Z~+10H", "°"},
@@ -1041,7 +1137,6 @@ static std::vector<ReplaceInfo> s_replace_info_jak2 = {
{"~[~32L", "<COLOR_DEFAULT>"}};
static std::vector<EncodeInfo> s_encode_info_jak2 = {
{"_", {0x03}}, // large space
{"ˇ", {0x10}}, // caron
{"`", {0x11}}, // grave accent
{"'", {0x12}}, // apostrophe
@@ -1051,59 +1146,64 @@ static std::vector<EncodeInfo> s_encode_info_jak2 = {
{"º", {0x16}}, // numero/overring
{"¡", {0x17}}, // inverted exclamation mark
{"¿", {0x18}}, // inverted question mark
{"ç", {0x1d}}, // c-cedilla
{"Ç", {0x1e}}, // c-cedilla
{"ß", {0x1f}}, // eszett
{"<SOMETHING>", {0x19}},
{"ç", {0x1d}}, // c-cedilla
{"Ç", {0x1e}}, // c-cedilla
{"ß", {0x1f}}, // eszett
{"œ", {0x5e}}, // ligature o+e
// Re-purposed japanese/korean symbols that are used as part of drawing icons/flags/pad buttons
// TODO - japanese and korean encodings
{"<SYM26>", {0x5d}},
{"<SYM33>", {0x7f}},
{"<SYM25>", {0x80}},
{"<SYM18>", {0x81}},
{"<FLAG_PART_HORZ_TRIPE_MIDDLE>", {0x7f}},
{"<FLAG_PART_HORZ_TRIPE_BOTTOM>", {0x80}},
{"<FLAG_PART_VERT_STRIPE_LARGE>", {0x81}},
{"<FLAG_PART_VERT_STRIPE_RIGHT>", {0x82}},
{"<FLAG_PART_VERT_STRIPE_LEFT>", {0x83}},
{"<FLAG_PART_VERT_STRIPE_MIDDLE>", {0x84}},
{"<FLAG_PART_FILL>", {0x85}},
{"<FLAG_PART_JAPAN_SUN>", {0x86}},
{"<FLAG_PART_KOREA_TRIGRAMS_LEFT>", {0x87}},
{"<FLAG_PART_KOREA_TRIGRAMS_RIGHT>", {0x88}},
{"<FLAG_PART_KOREA_CIRCLE_TOP>", {0x89}},
{"<FLAG_PART_KOREA_CIRCLE_FILL>", {0x8a}},
{"<FLAG_PART_TOP_BOTTOM_STRIPE>", {0x8b}},
{"<FLAG_PART_UK_CROSS_LEFT>", {0x8c}},
{"<FLAG_PART_UK_CROSS_RIGHT>", {0x8d}},
{"<FLAG_PART_UK_FILL_LEFT>", {0x8e}},
{"<FLAG_PART_UK_FILL_RIGHT>", {0x8f}},
{"<FLAG_PART_USA_STRIPES_RIGHT>", {0x90}},
{"<PAD_PART_STICK>", {0x91}},
{"<PAD_PART_SELECT>", {0x92}},
{"<PAD_PART_TRIGGER_BACK>", {0x93}},
{"<PAD_PART_R1_NAME>", {0x94}},
{"<PAD_PART_L1_NAME>", {0x95}},
{"<PAD_PART_R2_NAME>", {0x96}},
{"<PAD_PART_L2_NAME>", {0x97}},
{"<PAD_PART_STICK_UP>", {0x98}},
{"<PAD_PART_STICK_UP_RIGHT>", {0x99}},
{"<FLAG_PART_USA_STRIPES_LEFT>", {0x9a}},
{"<FLAG_PART_USA_STARS>", {0x9b}},
{"<PAD_PART_STICK_DOWN>", {0x9c}},
{"<PAD_PART_STICK_DOWN_LEFT>", {0x9d}},
{"<PAD_PART_STICK_LEFT>", {0x9e}},
{"<PAD_PART_STICK_UP_LEFT>", {0x9f}},
{"<PAD_PART_DPAD_D>", {0xa0}},
{"<PAD_PART_DPAD_L>", {0xa1}},
{"<PAD_PART_DPAD_U>", {0xa2}},
{"<PAD_PART_DPAD_R>", {0xa3}},
{"<PAD_PART_STICK_RIGHT>", {0xa4}},
{"<PAD_PART_STICK_DOWN_RIGHT>", {0xa5}},
{"<PAD_PART_SHOULDER_TOP_LEFT>", {0xa6}},
{"<PAD_PART_SHOULDER_TOP_RIGHT>", {0xa7}},
{"<PAD_PART_TRIGGER_TOP_LEFT>", {0xa8}},
{"<PAD_PART_TRIGGER_TOP_RIGHT>", {0xa9}},
{"<PAD_PART_TRIGGER_SHIM1>", {0xaa}},
{"<PAD_PART_TRIGGER_SHIM2>", {0xab}},
{"<PAD_PART_SHOULDER_SHIM2>", {0xac}},
{"<SYM19>", {0x85}},
{"<SYM27>", {0x86}},
{"<SYM36>", {0x87}},
{"<SYM39>", {0x88}},
{"<SYM43>", {0x89}},
{"<SYM41>", {0x8a}},
{"<SYM32>", {0x8b}},
{"<SYM34>", {0x8c}},
{"<SYM30>", {0x8d}},
{"<SYM37>", {0x8e}},
{"<SYM42>", {0x8f}},
{"<SYM40>", {0x90}},
{"<SYM16>", {0x91}},
{"<SYM6>", {0x94}},
{"<SYM5>", {0x95}},
{"<SYM13>", {0x96}},
{"<SYM22>", {0x97}},
{"<SYM28>", {0x98}},
{"<SYM31>", {0x99}},
{"<SYM35>", {0x9a}},
{"<SYM38>", {0x9b}},
{"<SYM24>", {0x9c}},
{"<SYM23>", {0x9d}},
{"<SYM21>", {0x9e}},
{"<SYM17>", {0x9f}},
{"<SYM9>", {0xa0}},
{"<SYM7>", {0xa1}},
{"<SYM8>", {0xa2}},
{"<SYM10>", {0xa3}},
{"<SYM20>", {0xa4}},
{"<SYM29>", {0xa5}},
{"<SYM1>", {0xa6}},
{"<SYM2>", {0xa7}},
{"<SYM11>", {0xa8}},
{"<SYM12>", {0xa9}},
{"<SYM3>", {0xb0}},
{"<SYM4>", {0xb1}},
{"<SYM14>", {0xb3}},
{"<SYM15>", {0xb2}},
{"<PAD_PART_SHOULDER_BOTTOM_LEFT>", {0xb0}},
{"<PAD_PART_SHOULDER_BOTTOM_RIGHT>", {0xb1}},
{"<PAD_PART_TRIGGER_BOTTOM_LEFT>", {0xb2}},
{"<PAD_PART_TRIGGER_BOTTOM_RIGHT>", {0xb3}},
// {"入", {1, 0x00}},
// {"年", {1, 0x01}},
// punctuation
@@ -1459,7 +1559,7 @@ static std::vector<EncodeInfo> s_encode_info_jak2 = {
{"予", {2, 0x83}},
{"用", {2, 0x84}},
{"落", {2, 0x85}},
// {"録", {2, 0x86}},
{"緑", {2, 0x86}},
{"封", {2, 0x88}},
{"印", {2, 0x89}},
@@ -1467,6 +1567,263 @@ static std::vector<EncodeInfo> s_encode_info_jak2 = {
{"最", {2, 0x8b}},
{"刻", {2, 0x8c}},
{"足", {2, 0x8d}},
{"<K300>", {3, 0x00}},
{"<K301>", {3, 0x01}},
{"<K302>", {3, 0x02}},
{"<K303>", {3, 0x03}},
{"<K304>", {3, 0x04}},
{"<K305>", {3, 0x05}},
{"<K306>", {3, 0x06}},
{"<K307>", {3, 0x07}},
{"<K308>", {3, 0x08}},
{"<K309>", {3, 0x09}},
{"<K30a>", {3, 0x0a}},
{"<K30b>", {3, 0x0b}},
{"<K30c>", {3, 0x0c}},
{"<K30d>", {3, 0x0d}},
{"<K30e>", {3, 0x0e}},
{"<K30f>", {3, 0x0f}},
{"<K310>", {3, 0x10}},
{"<K311>", {3, 0x11}},
{"<K312>", {3, 0x12}},
{"<K313>", {3, 0x13}},
{"<K314>", {3, 0x14}},
{"<K315>", {3, 0x15}},
{"<K316>", {3, 0x16}},
{"<K317>", {3, 0x17}},
{"<K318>", {3, 0x18}},
{"<K319>", {3, 0x19}},
{"<K31a>", {3, 0x1a}},
{"<K31b>", {3, 0x1b}},
{"<K31c>", {3, 0x1c}},
{"<K31d>", {3, 0x1d}},
{"<K31e>", {3, 0x1e}},
{"<K31f>", {3, 0x1f}},
{"<K320>", {3, 0x20}},
{"<K321>", {3, 0x21}},
{"<K322>", {3, 0x22}},
{"<K323>", {3, 0x23}},
{"<K324>", {3, 0x24}},
{"<K325>", {3, 0x25}},
{"<K326>", {3, 0x26}},
{"<K327>", {3, 0x27}},
{"<K328>", {3, 0x28}},
{"<K329>", {3, 0x29}},
{"<K32a>", {3, 0x2a}},
{"<K32b>", {3, 0x2b}},
{"<K32c>", {3, 0x2c}},
{"<K32d>", {3, 0x2d}},
{"<K32e>", {3, 0x2e}},
{"<K32f>", {3, 0x2f}},
{"<K330>", {3, 0x30}},
{"<K331>", {3, 0x31}},
{"<K332>", {3, 0x32}},
{"<K333>", {3, 0x33}},
{"<K334>", {3, 0x34}},
{"<K335>", {3, 0x35}},
{"<K336>", {3, 0x36}},
{"<K337>", {3, 0x37}},
{"<K338>", {3, 0x38}},
{"<K339>", {3, 0x39}},
{"<K33a>", {3, 0x3a}},
{"<K33b>", {3, 0x3b}},
{"<K33c>", {3, 0x3c}},
{"<K33d>", {3, 0x3d}},
{"<K33e>", {3, 0x3e}},
{"<K33f>", {3, 0x3f}},
{"<K340>", {3, 0x40}},
{"<K341>", {3, 0x41}},
{"<K342>", {3, 0x42}},
{"<K343>", {3, 0x43}},
{"<K344>", {3, 0x44}},
{"<K345>", {3, 0x45}},
{"<K346>", {3, 0x46}},
{"<K347>", {3, 0x47}},
{"<K348>", {3, 0x48}},
{"<K349>", {3, 0x49}},
{"<K34a>", {3, 0x4a}},
{"<K34b>", {3, 0x4b}},
{"<K34c>", {3, 0x4c}},
{"<K34d>", {3, 0x4d}},
{"<K34e>", {3, 0x4e}},
{"<K34f>", {3, 0x4f}},
{"<K350>", {3, 0x50}},
{"<K351>", {3, 0x51}},
{"<K352>", {3, 0x52}},
{"<K353>", {3, 0x53}},
{"<K354>", {3, 0x54}},
{"<K355>", {3, 0x55}},
{"<K356>", {3, 0x56}},
{"<K357>", {3, 0x57}},
{"<K358>", {3, 0x58}},
{"<K359>", {3, 0x59}},
{"<K35a>", {3, 0x5a}},
{"<K35b>", {3, 0x5b}},
{"<K35c>", {3, 0x5c}},
{"<K35d>", {3, 0x5d}},
{"<K35e>", {3, 0x5e}},
{"<K35f>", {3, 0x5f}},
{"<K360>", {3, 0x60}},
{"<K361>", {3, 0x61}},
{"<K362>", {3, 0x62}},
{"<K363>", {3, 0x63}},
{"<K364>", {3, 0x64}},
{"<K365>", {3, 0x65}},
{"<K366>", {3, 0x66}},
{"<K367>", {3, 0x67}},
{"<K368>", {3, 0x68}},
{"<K369>", {3, 0x69}},
{"<K36a>", {3, 0x6a}},
{"<K36b>", {3, 0x6b}},
{"<K36c>", {3, 0x6c}},
{"<K36d>", {3, 0x6d}},
{"<K36e>", {3, 0x6e}},
{"<K36f>", {3, 0x6f}},
{"<K370>", {3, 0x70}},
{"<K371>", {3, 0x71}},
{"<K372>", {3, 0x72}},
{"<K373>", {3, 0x73}},
{"<K374>", {3, 0x74}},
{"<K375>", {3, 0x75}},
{"<K376>", {3, 0x76}},
{"<K377>", {3, 0x77}},
{"<K378>", {3, 0x78}},
{"<K379>", {3, 0x79}},
{"<K37a>", {3, 0x7a}},
{"<K37b>", {3, 0x7b}},
{"<K37c>", {3, 0x7c}},
{"<K37d>", {3, 0x7d}},
{"<K37e>", {3, 0x7e}},
{"<K37f>", {3, 0x7f}},
{"<K380>", {3, 0x80}},
{"<K381>", {3, 0x81}},
{"<K382>", {3, 0x82}},
{"<K383>", {3, 0x83}},
{"<K384>", {3, 0x84}},
{"<K385>", {3, 0x85}},
{"<K386>", {3, 0x86}},
{"<K387>", {3, 0x87}},
{"<K388>", {3, 0x88}},
{"<K389>", {3, 0x89}},
{"<K38a>", {3, 0x8a}},
{"<K38b>", {3, 0x8b}},
{"<K38c>", {3, 0x8c}},
{"<K38d>", {3, 0x8d}},
{"<K38e>", {3, 0x8e}},
{"<K38f>", {3, 0x8f}},
{"<K390>", {3, 0x90}},
{"<K391>", {3, 0x91}},
{"<K392>", {3, 0x92}},
{"<K393>", {3, 0x93}},
{"<K394>", {3, 0x94}},
{"<K395>", {3, 0x95}},
{"<K396>", {3, 0x96}},
{"<K397>", {3, 0x97}},
{"<K398>", {3, 0x98}},
{"<K399>", {3, 0x99}},
{"<K39a>", {3, 0x9a}},
{"<K39b>", {3, 0x9b}},
{"<K39c>", {3, 0x9c}},
{"<K39d>", {3, 0x9d}},
{"<K39e>", {3, 0x9e}},
{"<K39f>", {3, 0x9f}},
{"<K3a0>", {3, 0xa0}},
{"<K3a1>", {3, 0xa1}},
{"<K3a2>", {3, 0xa2}},
{"<K3a3>", {3, 0xa3}},
{"<K3a4>", {3, 0xa4}},
{"<K3a5>", {3, 0xa5}},
{"<K3a6>", {3, 0xa6}},
{"<K3a7>", {3, 0xa7}},
{"<K3a8>", {3, 0xa8}},
{"<K3a9>", {3, 0xa9}},
{"<K3aa>", {3, 0xaa}},
{"<K3ab>", {3, 0xab}},
{"<K3ac>", {3, 0xac}},
{"<K3ad>", {3, 0xad}},
{"<K3ae>", {3, 0xae}},
{"<K3af>", {3, 0xaf}},
{"<K3b0>", {3, 0xb0}},
{"<K3b1>", {3, 0xb1}},
{"<K3b2>", {3, 0xb2}},
{"<K3b3>", {3, 0xb3}},
{"<K3b4>", {3, 0xb4}},
{"<K3b5>", {3, 0xb5}},
{"<K3b6>", {3, 0xb6}},
{"<K3b7>", {3, 0xb7}},
{"<K3b8>", {3, 0xb8}},
{"<K3b9>", {3, 0xb9}},
{"<K3ba>", {3, 0xba}},
{"<K3bb>", {3, 0xbb}},
{"<K3bc>", {3, 0xbc}},
{"<K3bd>", {3, 0xbd}},
{"<K3be>", {3, 0xbe}},
{"<K3bf>", {3, 0xbf}},
{"<K3c0>", {3, 0xc0}},
{"<K3c1>", {3, 0xc1}},
{"<K3c2>", {3, 0xc2}},
{"<K3c3>", {3, 0xc3}},
{"<K3c4>", {3, 0xc4}},
{"<K3c5>", {3, 0xc5}},
{"<K3c6>", {3, 0xc6}},
{"<K3c7>", {3, 0xc7}},
{"<K3c8>", {3, 0xc8}},
{"<K3c9>", {3, 0xc9}},
{"<K3ca>", {3, 0xca}},
{"<K3cb>", {3, 0xcb}},
{"<K3cc>", {3, 0xcc}},
{"<K3cd>", {3, 0xcd}},
{"<K3ce>", {3, 0xce}},
{"<K3cf>", {3, 0xcf}},
{"<K3d0>", {3, 0xd0}},
{"<K3d1>", {3, 0xd1}},
{"<K3d2>", {3, 0xd2}},
{"<K3d3>", {3, 0xd3}},
{"<K3d4>", {3, 0xd4}},
{"<K3d5>", {3, 0xd5}},
{"<K3d6>", {3, 0xd6}},
{"<K3d7>", {3, 0xd7}},
{"<K3d8>", {3, 0xd8}},
{"<K3d9>", {3, 0xd9}},
{"<K3da>", {3, 0xda}},
{"<K3db>", {3, 0xdb}},
{"<K3dc>", {3, 0xdc}},
{"<K3dd>", {3, 0xdd}},
{"<K3de>", {3, 0xde}},
{"<K3df>", {3, 0xdf}},
{"<K3e0>", {3, 0xe0}},
{"<K3e1>", {3, 0xe1}},
{"<K3e2>", {3, 0xe2}},
{"<K3e3>", {3, 0xe3}},
{"<K3e4>", {3, 0xe4}},
{"<K3e5>", {3, 0xe5}},
{"<K3e6>", {3, 0xe6}},
{"<K3e7>", {3, 0xe7}},
{"<K3e8>", {3, 0xe8}},
{"<K3e9>", {3, 0xe9}},
{"<K3ea>", {3, 0xea}},
{"<K3eb>", {3, 0xeb}},
{"<K3ec>", {3, 0xec}},
{"<K3ed>", {3, 0xed}},
{"<K3ee>", {3, 0xee}},
{"<K3ef>", {3, 0xef}},
{"<K3f0>", {3, 0xf0}},
{"<K3f1>", {3, 0xf1}},
{"<K3f2>", {3, 0xf2}},
{"<K3f3>", {3, 0xf3}},
{"<K3f4>", {3, 0xf4}},
{"<K3f5>", {3, 0xf5}},
{"<K3f6>", {3, 0xf6}},
{"<K3f7>", {3, 0xf7}},
{"<K3f8>", {3, 0xf8}},
{"<K3f9>", {3, 0xf9}},
{"<K3fa>", {3, 0xfa}},
{"<K3fb>", {3, 0xfb}},
{"<K3fc>", {3, 0xfc}},
{"<K3fd>", {3, 0xfd}},
{"<K3fe>", {3, 0xfe}},
{"<K3ff>", {3, 0xff}},
};
GameTextFontBank g_font_bank_jak2(GameTextVersion::JAK2,