Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-12-18 16:33:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/PKM/Strings/StringConverter12.cs

758 lines
22 KiB
C#
Raw Normal View History

Set initial capacity for stringbuilder to reduce reallocation Default capacity is 16 so it's rarely an issue, but sometimes we don't need that much. Update xmldoc for more clarity
2021-01-17 01:31:05 +00:00
using System;
using System.Collections.Generic;
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
using System.Text;
namespace PKHeX.Core
{
/// <summary>
/// Logic for converting a <see cref="string"/> for Generation 1 &amp; 2 games.
/// </summary>
public static class StringConverter12
{
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
public static bool GetIsG1Japanese(ReadOnlySpan<char> str) => AllCharsInDictionary(str, U2RBY_J);
public static bool GetIsG1English(ReadOnlySpan<char> str) => AllCharsInDictionary(str, U2RBY_U);
public static bool GetIsG1Japanese(ReadOnlySpan<byte> raw) => AllCharsInDictionary(raw, RBY2U_J);
public static bool GetIsG1English(ReadOnlySpan<byte> raw) => AllCharsInDictionary(raw, RBY2U_U);
Add Stadium2 Support Introducing a new PKM format: SK2 Split ICaughtData2 off of PK2 so it can be shared with SK2 when type-checks occur Add conversion for PK2<->SK2 Split the split-buffer handling for GBPKM to GBPKML (what a name), so that I can reuse shared accessor logic for SK2.
2020-10-03 01:08:40 +00:00
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
private static bool AllCharsInDictionary(ReadOnlySpan<char> c, IReadOnlyDictionary<char, byte> d)
{
foreach (var x in c)
{
if (!d.ContainsKey(x))
return false;
}
return true;
}
Add Stadium2 Support Introducing a new PKM format: SK2 Split ICaughtData2 off of PK2 so it can be shared with SK2 when type-checks occur Add conversion for PK2<->SK2 Split the split-buffer handling for GBPKM to GBPKML (what a name), so that I can reuse shared accessor logic for SK2.
2020-10-03 01:08:40 +00:00
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
private static bool AllCharsInDictionary(ReadOnlySpan<byte> data, IReadOnlyDictionary<byte, char> d)
Add Stadium2 Support Introducing a new PKM format: SK2 Split ICaughtData2 off of PK2 so it can be shared with SK2 when type-checks occur Add conversion for PK2<->SK2 Split the split-buffer handling for GBPKM to GBPKML (what a name), so that I can reuse shared accessor logic for SK2.
2020-10-03 01:08:40 +00:00
{
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
foreach (var c in data)
Add Stadium2 Support Introducing a new PKM format: SK2 Split ICaughtData2 off of PK2 so it can be shared with SK2 when type-checks occur Add conversion for PK2<->SK2 Split the split-buffer handling for GBPKM to GBPKML (what a name), so that I can reuse shared accessor logic for SK2.
2020-10-03 01:08:40 +00:00
{
if (c == 0)
break;
if (!d.ContainsKey(c))
return false;
}
return true;
}
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
Remove linq from list init, manually allocate Add some docs cuz gen1 structures are always spooky gen1 not being exactly same as gen2, and jp != int => 4 different sizes of spookiness
2020-07-22 01:56:41 +00:00
public const byte G1TerminatorCode = 0x50;
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
public const char G1Terminator = '\0';
public const byte G1TradeOTCode = 0x5D;
public const char G1TradeOT = '*';
public const string G1TradeOTStr = "*";
Finish splitting gen1/2 encounter types from parent class Results in a little more code, but each path is less tangled simplify some expressions remove RBDragonair content in favor of a strict filter for catch rate Move gen1 trade trainer names to stringconverter, since pk1/pk2 shouldn't refer to legality classes
2020-07-19 18:32:40 +00:00
public static readonly IReadOnlyList<string> G1TradeOTName = new []
{
string.Empty,
"トレーナー",
"Trainer",
"Dresseur",
"Allenatore",
"Trainer",
string.Empty,
"Entrenador",
"트레이너",
};
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <summary>
/// Checks if the input byte array is definitely of German origin (any ÄÖÜäöü)
/// </summary>
/// <param name="data">Raw string bytes</param>
/// <returns>Indication if the data is from a definitely-german string</returns>
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
public static bool IsG12German(ReadOnlySpan<byte> data)
{
foreach (var b in data)
{
if (b is >= 0xC0 and <= 0xC6)
return true;
}
return false;
}
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <summary>
/// Checks if the input byte array is definitely of German origin (any ÄÖÜäöü)
/// </summary>
Clean up some method signatures rename things to be a little more consistent in naming conventions
2020-06-17 02:46:22 +00:00
/// <param name="value">Input string</param>
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <returns>Indication if the data is from a definitely-german string</returns>
Clean up some method signatures rename things to be a little more consistent in naming conventions
2020-06-17 02:46:22 +00:00
public static bool IsG12German(string value) => IsG12German(SetString1(value, value.Length, false));
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <summary>
/// Converts Generation 1 encoded data into a string.
/// </summary>
Clean up some method signatures rename things to be a little more consistent in naming conventions
2020-06-17 02:46:22 +00:00
/// <param name="data">Encoded data.</param>
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <param name="offset">Offset to read from</param>
/// <param name="count"></param>
/// <param name="jp">Data source is Japanese.</param>
/// <returns>Decoded string.</returns>
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
public static string GetString1(byte[] data, int offset, int count, bool jp) => GetString1(data.AsSpan(offset, count), jp);
/// <summary>
/// Converts Generation 1 encoded data into a string.
/// </summary>
/// <param name="data">Encoded data.</param>
/// <param name="jp">Data source is Japanese.</param>
/// <returns>Decoded string.</returns>
public static string GetString1(ReadOnlySpan<byte> data, bool jp)
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{
var dict = jp ? RBY2U_J : RBY2U_U;
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
var s = new StringBuilder(data.Length);
foreach (var val in data)
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{
if (!dict.TryGetValue(val, out var c)) // Take valid values
break;
Inline some string logic, extract magic values, xmldoc
2021-03-10 05:31:53 +00:00
if (c == G1Terminator) // Stop if Terminator
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
break;
s.Append(c);
}
Use StringConverter api consistently; use stringbuilder when possible Retain a stringbuilder to mutate the string rather than finalizing temporary strings yields some speed improvements (less gen0 string objects allocated)
2021-01-15 06:50:13 +00:00
StringConverter.SanitizeString(s);
return s.ToString();
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
}
/// <summary>
/// Converts a string to Generation 1 encoded data.
/// </summary>
/// <param name="value">Decoded string.</param>
Set initial capacity for stringbuilder to reduce reallocation Default capacity is 16 so it's rarely an issue, but sometimes we don't need that much. Update xmldoc for more clarity
2021-01-17 01:31:05 +00:00
/// <param name="maxLength">Maximum length of the input <see cref="value"/></param>
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <param name="jp">Data destination is Japanese.</param>
Set initial capacity for stringbuilder to reduce reallocation Default capacity is 16 so it's rarely an issue, but sometimes we don't need that much. Update xmldoc for more clarity
2021-01-17 01:31:05 +00:00
/// <param name="padTo">Pad the input <see cref="value"/> to given length</param>
/// <param name="padWith">Pad the input <see cref="value"/> with this character value</param>
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
/// <returns>Encoded data.</returns>
Minor clean Condense some expressions Use less linq Rename some fields
2021-05-29 22:31:47 +00:00
public static byte[] SetString1(string value, int maxLength, bool jp, int padTo = 0, byte padWith = 0)
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{
if (value.StartsWith(G1TradeOTStr)) // Handle "[TRAINER]"
Refactoring Condense some logic
2020-10-07 00:54:17 +00:00
return new[] { G1TradeOTCode, G1TerminatorCode };
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
Set initial capacity for stringbuilder to reduce reallocation Default capacity is 16 so it's rarely an issue, but sometimes we don't need that much. Update xmldoc for more clarity
2021-01-17 01:31:05 +00:00
if (value.Length > maxLength)
Use range/index More in line with modernizing the codebase with latest c# syntax improve web-qr decode speed slightly (no linq skiptake) get money/coin mask without a temporary string (lol performance)
2021-05-14 22:30:55 +00:00
value = value[..maxLength]; // Hard cap
Set initial capacity for stringbuilder to reduce reallocation Default capacity is 16 so it's rarely an issue, but sometimes we don't need that much. Update xmldoc for more clarity
2021-01-17 01:31:05 +00:00
var capacity = Math.Max(value.Length, padTo);
var arr = new List<byte>(capacity);
Split off g7 transporter string handling Add katakana / hiragana sensitive transferring var check = CheckKata("ぐリお") == "ぐりお"; check should be true, dugtrio case !
2020-11-27 23:37:55 +00:00
var dict = jp ? U2RBY_J : U2RBY_U;
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
foreach (char c in value)
{
if (!dict.TryGetValue(c, out byte val))
break;
arr.Add(val);
}
Refactoring Condense some logic
2020-10-07 00:54:17 +00:00
arr.Add(G1TerminatorCode);
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
while (arr.Count < padTo)
Minor clean Condense some expressions Use less linq Rename some fields
2021-05-29 22:31:47 +00:00
arr.Add(padWith);
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
return arr.ToArray();
}
/// <summary>
/// Converts Generation 1 encoded character to string.
/// </summary>
/// <param name="key">Encoded character.</param>
/// <param name="jp">Data source is Japanese.</param>
/// <returns>Decoded string.</returns>
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
public static char GetG1Char(byte key, bool jp)
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{
var dict = jp ? RBY2U_J : RBY2U_U;
if (dict.TryGetValue(key, out var val))
Revise EncounterArea and EncounterType for clarity (#3228) EncounterArea now stores a more specific type'd array for encounter slots. Better iteration and less casting, as the nonspecific `Slots` fetch is rarely referenced. EncounterType renamed to GroundTile to reflect how it actually works in Gen4. Was previously an ambiguous field that was clarified a little; we can describe it a little better now. Keep the GUI the same to not scare the end users. Change Trash Byte properties to get/set a Span. Trash Byte legality checking easier on the garbage collector?
2021-06-30 03:58:06 +00:00
return val;
return G1Terminator;
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
}
#region Gen 1/2 Character Tables
Target type'd new
2020-12-22 01:17:56 +00:00
internal static readonly Dictionary<byte, char> RBY2U_U = new()
{
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{0x50, G1Terminator},
{0x5D, G1TradeOT},
{0x7F, ' '},
{0x80, 'A'},
{0x81, 'B'},
{0x82, 'C'},
{0x83, 'D'},
{0x84, 'E'},
{0x85, 'F'},
{0x86, 'G'},
{0x87, 'H'},
{0x88, 'I'},
{0x89, 'J'},
{0x8A, 'K'},
{0x8B, 'L'},
{0x8C, 'M'},
{0x8D, 'N'},
{0x8E, 'O'},
{0x8F, 'P'},
{0x90, 'Q'},
{0x91, 'R'},
{0x92, 'S'},
{0x93, 'T'},
{0x94, 'U'},
{0x95, 'V'},
{0x96, 'W'},
{0x97, 'X'},
{0x98, 'Y'},
{0x99, 'Z'},
{0x9A, '('},
{0x9B, ')'},
{0x9C, ':'},
{0x9D, ';'},
{0x9E, '['},
{0x9F, ']'},
{0xA0, 'a'},
{0xA1, 'b'},
{0xA2, 'c'},
{0xA3, 'd'},
{0xA4, 'e'},
{0xA5, 'f'},
{0xA6, 'g'},
{0xA7, 'h'},
{0xA8, 'i'},
{0xA9, 'j'},
{0xAA, 'k'},
{0xAB, 'l'},
{0xAC, 'm'},
{0xAD, 'n'},
{0xAE, 'o'},
{0xAF, 'p'},
{0xB0, 'q'},
{0xB1, 'r'},
{0xB2, 's'},
{0xB3, 't'},
{0xB4, 'u'},
{0xB5, 'v'},
{0xB6, 'w'},
{0xB7, 'x'},
{0xB8, 'y'},
{0xB9, 'z'},
Cleanup handle messages for dirty cleaning :)
2019-10-26 19:33:58 +00:00
Add unused character encodings to dictionary Two of the inaccessible keyboard chars are used by Spanish trades, so they aren't completely unused. #2338
2019-06-27 04:16:18 +00:00
// unused characters
{0xBA, 'à'},
{0xBB, 'è'},
{0xBC, 'é'},
{0xBD, 'ù'},
{0xBE, 'À'},
{0xBF, 'Á'}, // Used in Spanish FALCÁN in-game trade, inaccessible from keyboard
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{0xC0, 'Ä'},
{0xC1, 'Ö'},
{0xC2, 'Ü'},
{0xC3, 'ä'},
{0xC4, 'ö'},
{0xC5, 'ü'},
Add unused character encodings to dictionary Two of the inaccessible keyboard chars are used by Spanish trades, so they aren't completely unused. #2338
2019-06-27 04:16:18 +00:00
// unused characters
{0xC6, 'È'},
{0xC7, 'É'},
{0xC8, 'Ì'},
{0xC9, 'Í'}, // Used in Spanish MANÍA in-game trade, inaccessible from keyboard
{0xCA, 'Ñ'},
{0xCB, 'Ò'},
{0xCC, 'Ó'},
{0xCD, 'Ù'},
{0xCE, 'Ú'},
{0xCF, 'á'},
{0xD0, 'ì'},
{0xD1, 'í'},
{0xD2, 'ñ'},
{0xD3, 'ò'},
{0xD4, 'ó'},
{0xD5, 'ú'},
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{0xE0, '’'},
{0xE1, '{'}, /* Pk */
{0xE2, '}'}, /* Mn */
{0xE3, '-'},
{0xE6, '?'},
{0xE7, '!'},
{0xE8, '.'}, // Alias decimal point to .
{0xEF, '♂'},
{0xF1, '×'},
{0xF2, '.'},
{0xF3, '/'},
{0xF4, ','},
{0xF5, '♀'},
{0xF6, '0'},
{0xF7, '1'},
{0xF8, '2'},
{0xF9, '3'},
{0xFA, '4'},
{0xFB, '5'},
{0xFC, '6'},
{0xFD, '7'},
{0xFE, '8'},
Trailing commas No functional change
2021-08-20 20:49:20 +00:00
{0xFF, '9'},
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
};
Target type'd new
2020-12-22 01:17:56 +00:00
private static readonly Dictionary<byte, char> RBY2U_J = new()
{
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{0x05, 'ガ'},
{0x06, 'ギ'},
{0x07, 'グ'},
{0x08, 'ゲ'},
{0x09, 'ゴ'},
{0x0A, 'ザ'},
{0x0B, 'ジ'},
{0x0C, 'ズ'},
{0x0D, 'ゼ'},
{0x0E, 'ゾ'},
{0x0F, 'ダ'},
{0x10, 'ヂ'},
{0x11, 'ヅ'},
{0x12, 'デ'},
{0x13, 'ド'},
{0x19, 'バ'},
{0x1A, 'ビ'},
{0x1B, 'ブ'},
{0x1C, 'ボ'},
{0x26, 'が'},
{0x27, 'ぎ'},
{0x28, 'ぐ'},
{0x29, 'げ'},
{0x2A, 'ご'},
{0x2B, 'ざ'},
{0x2C, 'じ'},
{0x2D, 'ず'},
{0x2E, 'ぜ'},
{0x2F, 'ぞ'},
{0x30, 'だ'},
{0x31, 'ぢ'},
{0x32, 'づ'},
{0x33, 'で'},
{0x34, 'ど'},
{0x3A, 'ば'},
{0x3B, 'び'},
{0x3C, 'ぶ'},
{0x3D, 'ベ'},
{0x3E, 'ぼ'},
{0x40, 'パ'},
{0x41, 'ピ'},
{0x42, 'プ'},
{0x43, 'ポ'},
{0x44, 'ぱ'},
{0x45, 'ぴ'},
{0x46, 'ぷ'},
{0x47, 'ペ'},
{0x48, 'ぽ'},
{0x50, G1Terminator},
{0x5D, G1TradeOT},
{0x7F, ' '},
{0x80, 'ア'},
{0x81, 'イ'},
{0x82, 'ウ'},
{0x83, 'エ'},
{0x84, 'オ'},
{0x85, 'カ'},
{0x86, 'キ'},
{0x87, 'ク'},
{0x88, 'ケ'},
{0x89, 'コ'},
{0x8A, 'サ'},
{0x8B, 'シ'},
{0x8C, 'ス'},
{0x8D, 'セ'},
{0x8E, 'ソ'},
{0x8F, 'タ'},
{0x90, 'チ'},
{0x91, 'ツ'},
{0x92, 'テ'},
{0x93, 'ト'},
{0x94, 'ナ'},
{0x95, 'ニ'},
{0x96, 'ヌ'},
{0x97, 'ネ'},
{0x98, 'ノ'},
{0x99, 'ハ'},
{0x9A, 'ヒ'},
{0x9B, 'フ'},
{0x9C, 'ホ'},
{0x9D, 'マ'},
{0x9E, 'ミ'},
{0x9F, 'ム'},
{0xA0, 'メ'},
{0xA1, 'モ'},
{0xA2, 'ヤ'},
{0xA3, 'ユ'},
{0xA4, 'ヨ'},
{0xA5, 'ラ'},
{0xA6, 'ル'},
{0xA7, 'レ'},
{0xA8, 'ロ'},
{0xA9, 'ワ'},
{0xAA, 'ヲ'},
{0xAB, 'ン'},
{0xAC, 'ッ'},
{0xAD, 'ャ'},
{0xAE, 'ュ'},
{0xAF, 'ョ'},
{0xB0, 'ィ'},
{0xB1, 'あ'},
{0xB2, 'い'},
{0xB3, 'う'},
{0xB4, 'え'},
{0xB5, 'お'},
{0xB6, 'か'},
{0xB7, 'き'},
{0xB8, 'く'},
{0xB9, 'け'},
{0xBA, 'こ'},
{0xBB, 'さ'},
{0xBC, 'し'},
{0xBD, 'す'},
{0xBE, 'せ'},
{0xBF, 'そ'},
{0xC0, 'た'},
{0xC1, 'ち'},
{0xC2, 'つ'},
{0xC3, 'て'},
{0xC4, 'と'},
{0xC5, 'な'},
{0xC6, 'に'},
{0xC7, 'ぬ'},
{0xC8, 'ね'},
{0xC9, 'の'},
{0xCA, 'は'},
{0xCB, 'ひ'},
{0xCC, 'ふ'},
{0xCD, 'へ'},
{0xCE, 'ほ'},
{0xCF, 'ま'},
{0xD0, 'み'},
{0xD1, 'む'},
{0xD2, 'め'},
{0xD3, 'も'},
{0xD4, 'や'},
{0xD5, 'ゆ'},
{0xD6, 'よ'},
{0xD7, 'ら'},
{0xD8, 'リ'},
{0xD9, 'る'},
{0xDA, 'れ'},
{0xDB, 'ろ'},
{0xDC, 'わ'},
{0xDD, 'を'},
{0xDE, 'ん'},
{0xDF, 'っ'},
{0xE0, 'ゃ'},
{0xE1, 'ゅ'},
{0xE2, 'ょ'},
{0xE3, 'ー'},
{0xE6, '?'},
{0xE7, '!'},
{0xE9, 'ァ'},
{0xEA, 'ゥ'},
{0xEB, 'ェ'},
{0xEF, '♂'},
{0xF4, 'ォ'},
{0xF5, '♀'},
{0xF6, '0'},
{0xF7, '1'},
{0xF8, '2'},
{0xF9, '3'},
{0xFA, '4'},
{0xFB, '5'},
{0xFC, '6'},
{0xFD, '7'},
{0xFE, '8'},
Trailing commas No functional change
2021-08-20 20:49:20 +00:00
{0xFF, '9'},
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
};
Target type'd new
2020-12-22 01:17:56 +00:00
internal static readonly Dictionary<char, byte> U2RBY_U = new()
{
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{G1Terminator, 0x50},
{G1TradeOT, 0x5D}, // TRAINER (Localized per ROM)
{' ', 0x7F},
{'A', 0x80},
{'B', 0x81},
{'C', 0x82},
{'D', 0x83},
{'E', 0x84},
{'F', 0x85},
{'G', 0x86},
{'H', 0x87},
{'I', 0x88},
{'J', 0x89},
{'K', 0x8A},
{'L', 0x8B},
{'M', 0x8C},
{'N', 0x8D},
{'O', 0x8E},
{'P', 0x8F},
{'Q', 0x90},
{'R', 0x91},
{'S', 0x92},
{'T', 0x93},
{'U', 0x94},
{'V', 0x95},
{'W', 0x96},
{'X', 0x97},
{'Y', 0x98},
{'Z', 0x99},
{'(', 0x9A},
{')', 0x9B},
{':', 0x9C},
{';', 0x9D},
{'[', 0x9E},
{']', 0x9F},
{'a', 0xA0},
{'b', 0xA1},
{'c', 0xA2},
{'d', 0xA3},
{'e', 0xA4},
{'f', 0xA5},
{'g', 0xA6},
{'h', 0xA7},
{'i', 0xA8},
{'j', 0xA9},
{'k', 0xAA},
{'l', 0xAB},
{'m', 0xAC},
{'n', 0xAD},
{'o', 0xAE},
{'p', 0xAF},
{'q', 0xB0},
{'r', 0xB1},
{'s', 0xB2},
{'t', 0xB3},
{'u', 0xB4},
{'v', 0xB5},
{'w', 0xB6},
{'x', 0xB7},
{'y', 0xB8},
{'z', 0xB9},
Cleanup handle messages for dirty cleaning :)
2019-10-26 19:33:58 +00:00
Add unused character encodings to dictionary Two of the inaccessible keyboard chars are used by Spanish trades, so they aren't completely unused. #2338
2019-06-27 04:16:18 +00:00
// unused characters
{'à', 0xBA},
{'è', 0xBB},
{'é', 0xBC},
{'ù', 0xBD},
{'À', 0xBE},
{'Á', 0xBF}, // Used in Spanish FALCÁN in-game trade, inaccessible from keyboard
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{'Ä', 0xC0},
{'Ö', 0xC1},
{'Ü', 0xC2},
{'ä', 0xC3},
{'ö', 0xC4},
{'ü', 0xC5},
Add unused character encodings to dictionary Two of the inaccessible keyboard chars are used by Spanish trades, so they aren't completely unused. #2338
2019-06-27 04:16:18 +00:00
// unused characters
{'È', 0xC6},
{'É', 0xC7},
{'Ì', 0xC8},
{'Í', 0xC9}, // Used in Spanish MANÍA in-game trade, inaccessible from keyboard
{'Ñ', 0xCA},
{'Ò', 0xCB},
{'Ó', 0xCC},
{'Ù', 0xCD},
{'Ú', 0xCE},
{'á', 0xCF},
{'ì', 0xD0},
{'í', 0xD1},
{'ñ', 0xD2},
{'ò', 0xD3},
{'ó', 0xD4},
{'ú', 0xD5},
Remove '<->’ aliasing Farfetch’d uses the non-vertical apostrophe, still. Showdown is consistent with their usage (in/outputting ’), but we'll keep the '->’ for that sanitization just in case other services/users enter the wrong char. Closes #3185
2021-04-13 00:04:02 +00:00
{'\'', 0xE0}, // Alias ' to ’ for Farfetch’d
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{'’', 0xE0},
{'{', 0xE1}, /* Pk */
{'}', 0xE2}, /* Mn */
{'-', 0xE3},
{'?', 0xE6},
{'!', 0xE7},
{'♂', 0xEF},
{'×', 0xF1},
{'.', 0xF2},
{'/', 0xF3},
{',', 0xF4},
{'♀', 0xF5},
{'0', 0xF6},
{'1', 0xF7},
{'2', 0xF8},
{'3', 0xF9},
{'4', 0xFA},
{'5', 0xFB},
{'6', 0xFC},
{'7', 0xFD},
{'8', 0xFE},
Trailing commas No functional change
2021-08-20 20:49:20 +00:00
{'9', 0xFF},
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
};
Target type'd new
2020-12-22 01:17:56 +00:00
private static readonly Dictionary<char, byte> U2RBY_J = new()
{
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
{'ガ', 0x05},
{'ギ', 0x06},
{'グ', 0x07},
{'ゲ', 0x08},
{'ゴ', 0x09},
{'ザ', 0x0A},
{'ジ', 0x0B},
{'ズ', 0x0C},
{'ゼ', 0x0D},
{'ゾ', 0x0E},
{'ダ', 0x0F},
{'ヂ', 0x10},
{'ヅ', 0x11},
{'デ', 0x12},
{'ド', 0x13},
{'バ', 0x19},
{'ビ', 0x1A},
{'ブ', 0x1B},
{'ボ', 0x1C},
{'が', 0x26},
{'ぎ', 0x27},
{'ぐ', 0x28},
{'げ', 0x29},
{'ご', 0x2A},
{'ざ', 0x2B},
{'じ', 0x2C},
{'ず', 0x2D},
{'ぜ', 0x2E},
{'ぞ', 0x2F},
{'だ', 0x30},
{'ぢ', 0x31},
{'づ', 0x32},
{'で', 0x33},
{'ど', 0x34},
{'ば', 0x3A},
{'び', 0x3B},
{'ぶ', 0x3C},
{'ベ', 0x3D},
{'べ', 0x3D},
{'ぼ', 0x3E},
{'パ', 0x40},
{'ピ', 0x41},
{'プ', 0x42},
{'ポ', 0x43},
{'ぱ', 0x44},
{'ぴ', 0x45},
{'ぷ', 0x46},
{'ぺ', 0x47},
{'ペ', 0x47},
{'ぽ', 0x48},
{G1Terminator, 0x50},
{G1TradeOT, 0x5D}, // トレーナー, (Localized per ROM)
{' ', 0x7F},
{'ア', 0x80},
{'イ', 0x81},
{'ウ', 0x82},
{'エ', 0x83},
{'オ', 0x84},
{'カ', 0x85},
{'キ', 0x86},
{'ク', 0x87},
{'ケ', 0x88},
{'コ', 0x89},
{'サ', 0x8A},
{'シ', 0x8B},
{'ス', 0x8C},
{'セ', 0x8D},
{'ソ', 0x8E},
{'タ', 0x8F},
{'チ', 0x90},
{'ツ', 0x91},
{'テ', 0x92},
{'ト', 0x93},
{'ナ', 0x94},
{'ニ', 0x95},
{'ヌ', 0x96},
{'ネ', 0x97},
{'ノ', 0x98},
{'ハ', 0x99},
{'ヒ', 0x9A},
{'フ', 0x9B},
{'ホ', 0x9C},
{'マ', 0x9D},
{'ミ', 0x9E},
{'ム', 0x9F},
{'メ', 0xA0},
{'モ', 0xA1},
{'ヤ', 0xA2},
{'ユ', 0xA3},
{'ヨ', 0xA4},
{'ラ', 0xA5},
{'ル', 0xA6},
{'レ', 0xA7},
{'ロ', 0xA8},
{'ワ', 0xA9},
{'ヲ', 0xAA},
{'ン', 0xAB},
{'ッ', 0xAC},
{'ャ', 0xAD},
{'ュ', 0xAE},
{'ョ', 0xAF},
{'ィ', 0xB0},
{'あ', 0xB1},
{'い', 0xB2},
{'う', 0xB3},
{'え', 0xB4},
{'お', 0xB5},
{'か', 0xB6},
{'き', 0xB7},
{'く', 0xB8},
{'け', 0xB9},
{'こ', 0xBA},
{'さ', 0xBB},
{'し', 0xBC},
{'す', 0xBD},
{'せ', 0xBE},
{'そ', 0xBF},
{'た', 0xC0},
{'ち', 0xC1},
{'つ', 0xC2},
{'て', 0xC3},
{'と', 0xC4},
{'な', 0xC5},
{'に', 0xC6},
{'ぬ', 0xC7},
{'ね', 0xC8},
{'の', 0xC9},
{'は', 0xCA},
{'ひ', 0xCB},
{'ふ', 0xCC},
{'へ', 0xCD},
{'ヘ', 0xCD}, // Katakana ヘ => Hiragana へ
{'ほ', 0xCE},
{'ま', 0xCF},
{'み', 0xD0},
{'む', 0xD1},
{'め', 0xD2},
{'も', 0xD3},
{'や', 0xD4},
{'ゆ', 0xD5},
{'よ', 0xD6},
{'ら', 0xD7},
{'リ', 0xD8},
{'り', 0xD8},
{'る', 0xD9},
{'れ', 0xDA},
{'ろ', 0xDB},
{'わ', 0xDC},
{'を', 0xDD},
{'ん', 0xDE},
{'っ', 0xDF},
{'ゃ', 0xE0},
{'ゅ', 0xE1},
{'ょ', 0xE2},
{'ー', 0xE3},
{'?', 0xE6},
{'!', 0xE7},
{'ァ', 0xE9},
{'ゥ', 0xEA},
{'ェ', 0xEB},
{'♂', 0xEF},
{'ォ', 0xF4},
{'♀', 0xF5},
{'0', 0xF6},
{'1', 0xF7},
{'2', 0xF8},
{'3', 0xF9},
{'4', 0xFA},
{'5', 0xFB},
{'6', 0xFC},
{'7', 0xFD},
{'8', 0xFE},
Trailing commas No functional change
2021-08-20 20:49:20 +00:00
{'9', 0xFF},
Split StringConverter into smaller pieces reduces loading time (don't have to allocate conversion arrays when launching a gen7 game), and separates things to easier to manage locations reworks gen3 string encode/decode, no longer does 3->4->5 and 5->4->3; instead goes straight to the end result without an intermediary format. String sanitization should probably be broken up rather than reused, oh well.
2019-03-21 04:50:44 +00:00
};
#endregion
}
}
Reference in a new issue Copy permalink