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

737 lines
21 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.Linq;
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
{
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
public static bool GetIsG1Japanese(string str) => AllCharsInDictionary(str, U2RBY_J);
public static bool GetIsG1English(string str) => AllCharsInDictionary(str, U2RBY_U);
Add flexibility for SK2 imports Check language character table for English vs Japanese when loading for a destination
2020-10-04 17:25:34 +00:00
public static bool GetIsG1Japanese(byte[] data, int start, int length) => AllCharsInDictionary(data, start, length, RBY2U_J);
public static bool GetIsG1English(byte[] data, int start, int length) => AllCharsInDictionary(data, start, length, 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
Add flexibility for SK2 imports Check language character table for English vs Japanese when loading for a destination
2020-10-04 17:25:34 +00:00
private static bool AllCharsInDictionary(IEnumerable<char> c, IReadOnlyDictionary<char, byte> d) => c.All(d.ContainsKey);
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
private static bool AllCharsInDictionary(IReadOnlyList<byte> data, int start, int length, IReadOnlyDictionary<byte, char> d)
{
for (int i = start; i < start + length; i++)
{
var c = data[i];
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>
Simplify some repeated comparisons with expressions Less prone for bugs since it uses the same value for all comparisons without re-specifying
2020-12-29 08:37:59 +00:00
public static bool IsG12German(IEnumerable<byte> data) => data.Any(z => z is >= 0xC0 and <= 0xC6);
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>
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 string GetString1(byte[] data, int offset, int count, 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;
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 s = new StringBuilder(count);
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
for (int i = 0; i < count; i++)
{
Clean up some method signatures rename things to be a little more consistent in naming conventions
2020-06-17 02:46:22 +00:00
var val = data[offset + i];
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>
public static string GetG1Char(byte key, bool jp)
{
var dict = jp ? RBY2U_J : RBY2U_U;
if (dict.TryGetValue(key, out var val))
return val.ToString();
return string.Empty;
}
#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'},
{0xFF, '9'}
};
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'},
{0xFF, '9'}
};
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},
{'9', 0xFF}
};
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},
{'9', 0xFF}
};
#endregion
}
}
Reference in a new issue Copy permalink