Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-11-23 20:43:07 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/PKM/Strings/StringConverter2KOR.cs

575 lines
81 KiB
C#
Raw Normal View History

Update from .NET Framework 4.6 to .NET 7 (#3729) Updates from net46->net7, dropping support for mono in favor of using the latest runtime (along with the performance/API improvements). Releases will be posted as 64bit only for now. Refactors a good amount of internal API methods to be more performant and more customizable for future updates & fixes. Adds functionality for Batch Editor commands to `>`, `<` and <=/>= TID/SID properties renamed to TID16/SID16 for clarity; other properties exposed for Gen7 / display variants. Main window has a new layout to account for DPI scaling (8 point grid) Fixed: Tatsugiri and Paldean Tauros now output Showdown form names as Showdown expects Changed: Gen9 species now interact based on the confirmed National Dex IDs (closes #3724) Fixed: Pokedex set all no longer clears species with unavailable non-base forms (closes #3720) Changed: Hyper Training suggestions now apply for level 50 in SV. (closes #3714) Fixed: B2/W2 hatched egg met locations exclusive to specific versions are now explicitly checked (closes #3691) Added: Properties for ribbon/mark count (closes #3659) Fixed: Traded SV eggs are now checked correctly (closes #3692)
2023-01-22 04:02:33 +00:00
using System;
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.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 static PKHeX.Core.StringConverter12;
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
namespace PKHeX.Core;
/// <summary>
/// Logic for converting a <see cref="string"/> for Generation 2 Korean Gold/Silver.
/// </summary>
public static class StringConverter2KOR
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>
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// Checks if any of the characters inside <see cref="str"/> are from the special Korean codepoint pages.
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>
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
public static bool GetIsG2Korean(ReadOnlySpan<char> str)
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
{
Update from .NET Framework 4.6 to .NET 7 (#3729) Updates from net46->net7, dropping support for mono in favor of using the latest runtime (along with the performance/API improvements). Releases will be posted as 64bit only for now. Refactors a good amount of internal API methods to be more performant and more customizable for future updates & fixes. Adds functionality for Batch Editor commands to `>`, `<` and <=/>= TID/SID properties renamed to TID16/SID16 for clarity; other properties exposed for Gen7 / display variants. Main window has a new layout to account for DPI scaling (8 point grid) Fixed: Tatsugiri and Paldean Tauros now output Showdown form names as Showdown expects Changed: Gen9 species now interact based on the confirmed National Dex IDs (closes #3724) Fixed: Pokedex set all no longer clears species with unavailable non-base forms (closes #3720) Changed: Hyper Training suggestions now apply for level 50 in SV. (closes #3714) Fixed: B2/W2 hatched egg met locations exclusive to specific versions are now explicitly checked (closes #3691) Added: Properties for ribbon/mark count (closes #3659) Fixed: Traded SV eggs are now checked correctly (closes #3692)
2023-01-22 04:02:33 +00:00
var all = U2GSC_KOR;
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
foreach (var c in str)
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
{
Update from .NET Framework 4.6 to .NET 7 (#3729) Updates from net46->net7, dropping support for mono in favor of using the latest runtime (along with the performance/API improvements). Releases will be posted as 64bit only for now. Refactors a good amount of internal API methods to be more performant and more customizable for future updates & fixes. Adds functionality for Batch Editor commands to `>`, `<` and <=/>= TID/SID properties renamed to TID16/SID16 for clarity; other properties exposed for Gen7 / display variants. Main window has a new layout to account for DPI scaling (8 point grid) Fixed: Tatsugiri and Paldean Tauros now output Showdown form names as Showdown expects Changed: Gen9 species now interact based on the confirmed National Dex IDs (closes #3724) Fixed: Pokedex set all no longer clears species with unavailable non-base forms (closes #3720) Changed: Hyper Training suggestions now apply for level 50 in SV. (closes #3714) Fixed: B2/W2 hatched egg met locations exclusive to specific versions are now explicitly checked (closes #3691) Added: Properties for ribbon/mark count (closes #3659) Fixed: Traded SV eggs are now checked correctly (closes #3692)
2023-01-22 04:02:33 +00:00
bool any = false;
foreach (var dict in all)
{
if (!dict.ContainsKey(c))
continue;
any = true;
break;
}
if (!any)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
return false;
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
}
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
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
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <summary>
/// Converts Generation 2 Korean encoded data into a string.
/// </summary>
/// <param name="data">Encoded data.</param>
/// <returns>Decoded string.</returns>
public static string GetString(ReadOnlySpan<byte> data)
{
Span<char> result = stackalloc char[data.Length];
int length = LoadString(data, result);
Update from .NET Framework 4.6 to .NET 7 (#3729) Updates from net46->net7, dropping support for mono in favor of using the latest runtime (along with the performance/API improvements). Releases will be posted as 64bit only for now. Refactors a good amount of internal API methods to be more performant and more customizable for future updates & fixes. Adds functionality for Batch Editor commands to `>`, `<` and <=/>= TID/SID properties renamed to TID16/SID16 for clarity; other properties exposed for Gen7 / display variants. Main window has a new layout to account for DPI scaling (8 point grid) Fixed: Tatsugiri and Paldean Tauros now output Showdown form names as Showdown expects Changed: Gen9 species now interact based on the confirmed National Dex IDs (closes #3724) Fixed: Pokedex set all no longer clears species with unavailable non-base forms (closes #3720) Changed: Hyper Training suggestions now apply for level 50 in SV. (closes #3714) Fixed: B2/W2 hatched egg met locations exclusive to specific versions are now explicitly checked (closes #3691) Added: Properties for ribbon/mark count (closes #3659) Fixed: Traded SV eggs are now checked correctly (closes #3692)
2023-01-22 04:02:33 +00:00
return new string(result[..length]);
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
}
Update from .NET Framework 4.6 to .NET 7 (#3729) Updates from net46->net7, dropping support for mono in favor of using the latest runtime (along with the performance/API improvements). Releases will be posted as 64bit only for now. Refactors a good amount of internal API methods to be more performant and more customizable for future updates & fixes. Adds functionality for Batch Editor commands to `>`, `<` and <=/>= TID/SID properties renamed to TID16/SID16 for clarity; other properties exposed for Gen7 / display variants. Main window has a new layout to account for DPI scaling (8 point grid) Fixed: Tatsugiri and Paldean Tauros now output Showdown form names as Showdown expects Changed: Gen9 species now interact based on the confirmed National Dex IDs (closes #3724) Fixed: Pokedex set all no longer clears species with unavailable non-base forms (closes #3720) Changed: Hyper Training suggestions now apply for level 50 in SV. (closes #3714) Fixed: B2/W2 hatched egg met locations exclusive to specific versions are now explicitly checked (closes #3691) Added: Properties for ribbon/mark count (closes #3659) Fixed: Traded SV eggs are now checked correctly (closes #3692)
2023-01-22 04:02:33 +00:00
/// <inheritdoc cref="GetString(ReadOnlySpan{byte})"/>
/// <param name="data">Encoded data</param>
/// <param name="result">Decoded character result buffer</param>
/// <returns>Character count loaded.</returns>
public static int LoadString(ReadOnlySpan<byte> data, Span<char> result)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
Misc enc template tweaks Skip string fetch for Trade1 Set gender for Trade8 Add record to wrap Gen8 raid generate params, return & use bool for filtering results, fallback to unrestricted if none succeed Fix gender comparison for Entree5 slot Simplify gen2 ResetKey fetch (byte sum of Money/ID/OT(used) Closes #3970 by filtering gender inside the method like Encounter9RNG with an early return Adds IV filtering inside the method with an early return like Encounter9RNG
2023-08-30 05:22:23 +00:00
if (data[0] == G1TradeOTCode) // In-game Trade
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
{
Fix incorrect g1 trade trainer char reference
2022-01-08 04:52:26 +00:00
result[0] = G1TradeOT;
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
return 1;
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
}
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
int i = 0;
int ctr = 0;
for (; i < data.Length; 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
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
var value = data[i];
var table = value <= 0xB ? GSC2U_KOR[value] : RBY2U_U;
if (value is <= 0xB and not 0)
value = data[++i];
if (!table.TryGetValue(value, out var c)) // Take valid values
break;
if (c == G1Terminator) // Stop if Terminator
break;
result[ctr++] = c;
}
return ctr;
}
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
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <summary>
/// Converts a string to Generation 1 encoded data.
/// </summary>
Add xmldoc
2022-01-08 17:54:32 +00:00
/// <param name="destBuffer">Span of bytes to write encoded string data</param>
Fix kor string writes Was writing kor string, then writing en after (all terminators). Make method signature match other SetString, with write buffer as first arg Closes #3440
2022-02-18 07:11:13 +00:00
/// <param name="value">Decoded string.</param>
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <param name="maxLength">Maximum length of the input <see cref="value"/></param>
Add xmldoc
2022-01-08 17:54:32 +00:00
/// <param name="option">Buffer pre-formatting option</param>
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <returns>Encoded data.</returns>
Fix kor string writes Was writing kor string, then writing en after (all terminators). Make method signature match other SetString, with write buffer as first arg Closes #3440
2022-02-18 07:11:13 +00:00
public static int SetString(Span<byte> destBuffer, ReadOnlySpan<char> value, int maxLength,
StringConverterOption option = StringConverterOption.Clear50)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
if (option is StringConverterOption.ClearZero)
destBuffer.Clear();
else if (option is StringConverterOption.Clear50)
destBuffer.Fill(G1TerminatorCode);
if (value.Length != 0 && value[0] == G1TradeOT) // Handle "[TRAINER]"
{
destBuffer[0] = G1TradeOTCode;
destBuffer[1] = G1TerminatorCode;
return 2;
}
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
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
if (value.Length > maxLength)
value = value[..maxLength]; // Hard cap
var kor = U2GSC_KOR;
var dict = U2RBY_U;
int ctr = 0;
foreach (var c in value)
{
var koreanChar = false;
// although the 0x00 and 0x0B dictionaries are identical, the game only uses 0x0B.
for (byte t = 1; t < kor.Length; t++)
{
var table = kor[t];
if (!table.TryGetValue(c, out byte val))
continue;
koreanChar = true;
if (ctr + 2 > destBuffer.Length)
break; // adding 2 characters will overflow requested buffer cap
destBuffer[ctr++] = t;
destBuffer[ctr++] = val;
break;
}
if (!koreanChar)
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
{
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
if (!dict.TryGetValue(c, out byte val))
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;
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
destBuffer[ctr++] = val;
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
}
}
Fix kor string writes Was writing kor string, then writing en after (all terminators). Make method signature match other SetString, with write buffer as first arg Closes #3440
2022-02-18 07:11:13 +00:00
if (ctr < value.Length)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
destBuffer[ctr++] = G1TerminatorCode;
return ctr;
}
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
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <summary>
/// Localizes a Gen4+ Korean species name to the localization used in Generation 2 Gold/Silver
/// </summary>
Minor optimizations Only fetch egg moves when using them Localize KOR gen2 string directly instead of switch expression Remap FRE gen4 chars directly, hot path instead of dictionary lookup Uppercase chars in place
2023-03-22 00:20:13 +00:00
/// <param name="species">Species ID</param>
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <param name="nick">Generation 4 Species Name</param>
/// <returns>Localized Name for Generation 2</returns>
Minor optimizations Only fetch egg moves when using them Localize KOR gen2 string directly instead of switch expression Remap FRE gen4 chars directly, hot path instead of dictionary lookup Uppercase chars in place
2023-03-22 00:20:13 +00:00
public static void LocalizeKOR2(ushort species, ref string nick)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
Minor optimizations Only fetch egg moves when using them Localize KOR gen2 string directly instead of switch expression Remap FRE gen4 chars directly, hot path instead of dictionary lookup Uppercase chars in place
2023-03-22 00:20:13 +00:00
if (species == 61) // Poliwhirl
nick = "수륙챙이"; // "슈륙챙이" in future games
else if (species == 114) // Tangela
nick = "덩구리"; // "덩쿠리" in future games
}
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
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
#region Gen 2 Korean Character Tables
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_0 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'ㄱ', 0x00}, {'ㄴ', 0x01}, {'ㄷ', 0x02}, {'ㄹ', 0x03}, {'ㅁ', 0x04}, {'ㅂ', 0x05}, {'ㅅ', 0x06}, {'ㅇ', 0x07}, {'ㅈ', 0x08}, {'ㅊ', 0x09}, {'ㅋ', 0x0A}, {'ㅌ', 0x0B}, {'ㅍ', 0x0C}, {'ㅎ', 0x0D}, {'ㄲ', 0x0E}, {'ㄸ', 0x0F},
{'ㅃ', 0x10}, {'ㅆ', 0x11}, {'ㅉ', 0x12},
{'ㅏ', 0x20}, {'ㅑ', 0x21}, {'ㅓ', 0x22}, {'ㅕ', 0x23}, {'ㅗ', 0x24}, {'ㅛ', 0x25}, {'ㅜ', 0x26}, {'ㅠ', 0x27}, {'ㅡ', 0x28}, {'ㅣ', 0x29}, {'ㅐ', 0x2A}, {'ㅒ', 0x2B}, {'ㅔ', 0x2C}, {'ㅖ', 0x2D}, {'ㅘ', 0x2E}, {'ㅙ', 0x2F},
{'ㅚ', 0x30}, {'ㅝ', 0x31}, {'ㅞ', 0x32}, {'ㅟ', 0x33}, {'ㅢ', 0x34}, {'_', 0x3E}, {'—', 0x3F},
{'「', 0x60}, {'」', 0x61}, {'『', 0x62}, {'』', 0x63}, {'(', 0x64}, {')', 0x65}, {'!', 0x66}, {'?', 0x67}, {'-', 0x68}, {'~', 0x69}, {'…', 0x6A}, {',', 0x6B}, {'.', 0x6C}, // . is 0x6D for bank
{'０', 0xF0}, {'１', 0xF1}, {'２', 0xF2}, {'３', 0xF3}, {'４', 0xF4}, {'５', 0xF5}, {'６', 0xF6}, {'７', 0xF7}, {'８', 0xF8}, {'９', 0xF9},
{'\u3000', 0xFF},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_1 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'가', 0x01}, {'각', 0x02}, {'간', 0x03}, {'갇', 0x04}, {'갈', 0x05}, {'갉', 0x06}, {'갊', 0x07}, {'감', 0x08}, {'갑', 0x09}, {'값', 0x0A}, {'갓', 0x0B}, {'갔', 0x0C}, {'강', 0x0D}, {'갖', 0x0E}, {'갗', 0x0F},
{'같', 0x10}, {'갚', 0x11}, {'갛', 0x12}, {'개', 0x13}, {'객', 0x14}, {'갠', 0x15}, {'갤', 0x16}, {'갬', 0x17}, {'갭', 0x18}, {'갯', 0x19}, {'갰', 0x1A}, {'갱', 0x1B}, {'갸', 0x1C}, {'갹', 0x1D}, {'갼', 0x1E}, {'걀', 0x1F},
{'걋', 0x20}, {'걍', 0x21}, {'걔', 0x22}, {'걘', 0x23}, {'걜', 0x24}, {'거', 0x25}, {'걱', 0x26}, {'건', 0x27}, {'걷', 0x28}, {'걸', 0x29}, {'걺', 0x2A}, {'검', 0x2B}, {'겁', 0x2C}, {'것', 0x2D}, {'겄', 0x2E}, {'겅', 0x2F},
{'겆', 0x30}, {'겉', 0x31}, {'겊', 0x32}, {'겋', 0x33}, {'게', 0x34}, {'겐', 0x35}, {'겔', 0x36}, {'겜', 0x37}, {'겝', 0x38}, {'겟', 0x39}, {'겠', 0x3A}, {'겡', 0x3B}, {'겨', 0x3C}, {'격', 0x3D}, {'겪', 0x3E}, {'견', 0x3F},
{'겯', 0x40}, {'결', 0x41}, {'겹', 0x42}, {'겸', 0x43}, {'겻', 0x44}, {'겼', 0x45}, {'경', 0x46}, {'곁', 0x47}, {'계', 0x48}, {'곈', 0x49}, {'곌', 0x4A}, {'곕', 0x4B}, {'곗', 0x4C}, {'고', 0x4D}, {'곡', 0x4E}, {'곤', 0x4F},
{'곧', 0x60}, {'골', 0x61}, {'곪', 0x62}, {'곬', 0x63}, {'곯', 0x64}, {'곰', 0x65}, {'곱', 0x66}, {'곳', 0x67}, {'공', 0x68}, {'곶', 0x69}, {'과', 0x6A}, {'곽', 0x6B}, {'관', 0x6C}, {'괄', 0x6D}, {'괆', 0x6E},
{'괌', 0x71}, {'괍', 0x72}, {'괏', 0x73}, {'광', 0x74}, {'괘', 0x75}, {'괜', 0x76}, {'괠', 0x77}, {'괩', 0x78}, {'괬', 0x79}, {'괭', 0x7A}, {'괴', 0x7B}, {'괵', 0x7C}, {'괸', 0x7D}, {'괼', 0x7E}, {'괻', 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},
{'깹', 0xD1}, {'깻', 0xD2}, {'깼', 0xD3}, {'깽', 0xD4}, {'꺄', 0xD5}, {'꺅', 0xD6}, {'꺌', 0xD7}, {'꺼', 0xD8}, {'꺽', 0xD9}, {'꺾', 0xDA}, {'껀', 0xDB}, {'껄', 0xDC}, {'껌', 0xDD}, {'껍', 0xDE}, {'껏', 0xDF},
{'껐', 0xE0}, {'껑', 0xE1}, {'께', 0xE2}, {'껙', 0xE3}, {'껜', 0xE4}, {'껨', 0xE5}, {'껫', 0xE6}, {'껭', 0xE7}, {'껴', 0xE8}, {'껸', 0xE9}, {'껼', 0xEA}, {'꼇', 0xEB}, {'꼈', 0xEC}, {'꼍', 0xED}, {'꼐', 0xEE}, {'꼬', 0xEF},
{'꼭', 0xF0}, {'꼰', 0xF1}, {'꼲', 0xF2}, {'꼴', 0xF3}, {'꼼', 0xF4}, {'꼽', 0xF5}, {'꼿', 0xF6}, {'꽁', 0xF7}, {'꽂', 0xF8}, {'꽃', 0xF9}, {'꽈', 0xFA}, {'꽉', 0xFB}, {'꽐', 0xFC}, {'꽜', 0xFD}, {'꽝', 0xFE}, {'꽤', 0xFF},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_2 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'꽥', 0x00}, {'꽹', 0x01}, {'꾀', 0x02}, {'꾄', 0x03}, {'꾈', 0x04}, {'꾐', 0x05}, {'꾑', 0x06}, {'꾕', 0x07}, {'꾜', 0x08}, {'꾸', 0x09}, {'꾹', 0x0A}, {'꾼', 0x0B}, {'꿀', 0x0C}, {'꿇', 0x0D}, {'꿈', 0x0E}, {'꿉', 0x0F},
{'꿋', 0x10}, {'꿍', 0x11}, {'꿎', 0x12}, {'꿔', 0x13}, {'꿜', 0x14}, {'꿨', 0x15}, {'꿩', 0x16}, {'꿰', 0x17}, {'꿱', 0x18}, {'꿴', 0x19}, {'꿸', 0x1A}, {'뀀', 0x1B}, {'뀁', 0x1C}, {'뀄', 0x1D}, {'뀌', 0x1E}, {'뀐', 0x1F},
{'뀔', 0x20}, {'뀜', 0x21}, {'뀝', 0x22}, {'뀨', 0x23}, {'끄', 0x24}, {'끅', 0x25}, {'끈', 0x26}, {'끊', 0x27}, {'끌', 0x28}, {'끎', 0x29}, {'끓', 0x2A}, {'끔', 0x2B}, {'끕', 0x2C}, {'끗', 0x2D}, {'끙', 0x2E},
{'끝', 0x31}, {'끼', 0x32}, {'끽', 0x33}, {'낀', 0x34}, {'낄', 0x35}, {'낌', 0x36}, {'낍', 0x37}, {'낏', 0x38}, {'낑', 0x39}, {'나', 0x3A}, {'낙', 0x3B}, {'낚', 0x3C}, {'난', 0x3D}, {'낟', 0x3E}, {'날', 0x3F},
{'낡', 0x40}, {'낢', 0x41}, {'남', 0x42}, {'납', 0x43}, {'낫', 0x44}, {'났', 0x45}, {'낭', 0x46}, {'낮', 0x47}, {'낯', 0x48}, {'낱', 0x49}, {'낳', 0x4A}, {'내', 0x4B}, {'낵', 0x4C}, {'낸', 0x4D}, {'낼', 0x4E}, {'냄', 0x4F},
{'냅', 0x60}, {'냇', 0x61}, {'냈', 0x62}, {'냉', 0x63}, {'냐', 0x64}, {'냑', 0x65}, {'냔', 0x66}, {'냘', 0x67}, {'냠', 0x68}, {'냥', 0x69}, {'너', 0x6A}, {'넉', 0x6B}, {'넋', 0x6C}, {'넌', 0x6D}, {'널', 0x6E}, {'넒', 0x6F},
{'넓', 0x70}, {'넘', 0x71}, {'넙', 0x72}, {'넛', 0x73}, {'넜', 0x74}, {'넝', 0x75}, {'넣', 0x76}, {'네', 0x77}, {'넥', 0x78}, {'넨', 0x79}, {'넬', 0x7A}, {'넴', 0x7B}, {'넵', 0x7C}, {'넷', 0x7D}, {'넸', 0x7E}, {'넹', 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},
{'뇟', 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}, {'답', 0xE4}, {'닷', 0xE5}, {'닸', 0xE6}, {'당', 0xE7}, {'닺', 0xE8}, {'닻', 0xE9}, {'닿', 0xEA}, {'대', 0xEB}, {'댁', 0xEC}, {'댄', 0xED}, {'댈', 0xEE}, {'댐', 0xEF},
{'댑', 0xF0}, {'댓', 0xF1}, {'댔', 0xF2}, {'댕', 0xF3}, {'더', 0xF5}, {'덕', 0xF6}, {'덖', 0xF7}, {'던', 0xF8}, {'덛', 0xF9}, {'덜', 0xFA}, {'덞', 0xFB}, {'덟', 0xFC}, {'덤', 0xFD}, {'덥', 0xFE},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_3 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'덧', 0x01}, {'덩', 0x02}, {'덫', 0x03}, {'덮', 0x04}, {'데', 0x05}, {'덱', 0x06}, {'덴', 0x07}, {'델', 0x08}, {'뎀', 0x09}, {'뎁', 0x0A}, {'뎃', 0x0B}, {'뎄', 0x0C}, {'뎅', 0x0D}, {'뎌', 0x0E}, {'뎐', 0x0F},
{'뎔', 0x10}, {'뎠', 0x11}, {'뎡', 0x12}, {'뎨', 0x13}, {'뎬', 0x14}, {'도', 0x15}, {'독', 0x16}, {'돈', 0x17}, {'돋', 0x18}, {'돌', 0x19}, {'돎', 0x1A}, {'돔', 0x1C}, {'돕', 0x1D}, {'돗', 0x1E}, {'동', 0x1F},
{'돛', 0x20}, {'돝', 0x21}, {'돠', 0x22}, {'돤', 0x23}, {'돨', 0x24}, {'돼', 0x25}, {'됐', 0x26}, {'되', 0x27}, {'된', 0x28}, {'될', 0x29}, {'됨', 0x2A}, {'됩', 0x2B}, {'됫', 0x2C}, {'됴', 0x2D}, {'두', 0x2E}, {'둑', 0x2F},
{'둔', 0x30}, {'둘', 0x31}, {'둠', 0x32}, {'둡', 0x33}, {'둣', 0x34}, {'둥', 0x35}, {'둬', 0x36}, {'뒀', 0x37}, {'뒈', 0x38}, {'뒝', 0x39}, {'뒤', 0x3A}, {'뒨', 0x3B}, {'뒬', 0x3C}, {'뒵', 0x3D}, {'뒷', 0x3E}, {'뒹', 0x3F},
{'듀', 0x40}, {'듄', 0x41}, {'듈', 0x42}, {'듐', 0x43}, {'듕', 0x44}, {'드', 0x45}, {'득', 0x46}, {'든', 0x47}, {'듣', 0x48}, {'들', 0x49}, {'듦', 0x4A}, {'듬', 0x4B}, {'듭', 0x4C}, {'듯', 0x4D}, {'등', 0x4E}, {'듸', 0x4F},
{'디', 0x60}, {'딕', 0x61}, {'딘', 0x62}, {'딛', 0x63}, {'딜', 0x64}, {'딤', 0x65}, {'딥', 0x66}, {'딧', 0x67}, {'딨', 0x68}, {'딩', 0x69}, {'딪', 0x6A}, {'따', 0x6B}, {'딱', 0x6C}, {'딴', 0x6D}, {'딸', 0x6E},
{'땀', 0x71}, {'땁', 0x72}, {'땃', 0x73}, {'땄', 0x74}, {'땅', 0x75}, {'땋', 0x76}, {'때', 0x77}, {'땍', 0x78}, {'땐', 0x79}, {'땔', 0x7A}, {'땜', 0x7B}, {'땝', 0x7C}, {'땟', 0x7D}, {'땠', 0x7E}, {'땡', 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},
{'뢔', 0xD0}, {'래', 0xD1}, {'랙', 0xD2}, {'랜', 0xD3}, {'랠', 0xD4}, {'램', 0xD5}, {'랩', 0xD6}, {'랫', 0xD7}, {'랬', 0xD8}, {'랭', 0xD9}, {'랴', 0xDA}, {'략', 0xDB}, {'랸', 0xDC}, {'럇', 0xDD}, {'량', 0xDE}, {'러', 0xDF},
{'럭', 0xE0}, {'런', 0xE1}, {'럴', 0xE2}, {'럼', 0xE3}, {'럽', 0xE4}, {'럿', 0xE5}, {'렀', 0xE6}, {'렁', 0xE7}, {'렇', 0xE8}, {'레', 0xE9}, {'렉', 0xEA}, {'렌', 0xEB}, {'렐', 0xEC}, {'렘', 0xED}, {'렙', 0xEE}, {'렛', 0xEF},
{'렝', 0xF0}, {'려', 0xF1}, {'력', 0xF2}, {'련', 0xF3}, {'렬', 0xF4}, {'렴', 0xF5}, {'렵', 0xF6}, {'렷', 0xF7}, {'렸', 0xF8}, {'령', 0xF9}, {'례', 0xFA}, {'롄', 0xFB}, {'롑', 0xFC}, {'롓', 0xFD}, {'로', 0xFE}, {'록', 0xFF},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_4 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'론', 0x00}, {'롤', 0x01}, {'롬', 0x02}, {'롭', 0x03}, {'롯', 0x04}, {'롱', 0x05}, {'롸', 0x06}, {'롼', 0x07}, {'뢍', 0x08}, {'뢨', 0x09}, {'뢰', 0x0A}, {'뢴', 0x0B}, {'뢸', 0x0C}, {'룀', 0x0D}, {'룁', 0x0E}, {'룃', 0x0F},
{'룅', 0x10}, {'료', 0x11}, {'룐', 0x12}, {'룔', 0x13}, {'룝', 0x14}, {'룟', 0x15}, {'룡', 0x16}, {'루', 0x17}, {'룩', 0x18}, {'룬', 0x19}, {'룰', 0x1A}, {'룸', 0x1B}, {'룹', 0x1C}, {'룻', 0x1D}, {'룽', 0x1E}, {'뤄', 0x1F},
{'뤘', 0x20}, {'뤠', 0x21}, {'뤼', 0x22}, {'뤽', 0x23}, {'륀', 0x24}, {'륄', 0x25}, {'륌', 0x26}, {'륏', 0x27}, {'륑', 0x28}, {'류', 0x29}, {'륙', 0x2A}, {'륜', 0x2B}, {'률', 0x2C}, {'륨', 0x2D}, {'륩', 0x2E},
{'륫', 0x31}, {'륭', 0x32}, {'르', 0x33}, {'륵', 0x34}, {'른', 0x35}, {'를', 0x36}, {'름', 0x37}, {'릅', 0x38}, {'릇', 0x39}, {'릉', 0x3A}, {'릊', 0x3B}, {'릍', 0x3C}, {'릎', 0x3D}, {'리', 0x3E}, {'릭', 0x3F},
{'린', 0x40}, {'릴', 0x41}, {'림', 0x42}, {'립', 0x43}, {'릿', 0x44}, {'링', 0x45}, {'마', 0x46}, {'막', 0x47}, {'만', 0x48}, {'많', 0x49}, {'맏', 0x4A}, {'말', 0x4B}, {'맑', 0x4C}, {'맒', 0x4D}, {'맘', 0x4E}, {'맙', 0x4F},
{'맛', 0x60}, {'망', 0x61}, {'맞', 0x62}, {'맡', 0x63}, {'맣', 0x64}, {'매', 0x65}, {'맥', 0x66}, {'맨', 0x67}, {'맬', 0x68}, {'맴', 0x69}, {'맵', 0x6A}, {'맷', 0x6B}, {'맸', 0x6C}, {'맹', 0x6D}, {'맺', 0x6E}, {'먀', 0x6F},
{'먁', 0x70}, {'먈', 0x71}, {'먕', 0x72}, {'머', 0x73}, {'먹', 0x74}, {'먼', 0x75}, {'멀', 0x76}, {'멂', 0x77}, {'멈', 0x78}, {'멉', 0x79}, {'멋', 0x7A}, {'멍', 0x7B}, {'멎', 0x7C}, {'멓', 0x7D}, {'메', 0x7E}, {'멕', 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},
{'묀', 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}, {'밥', 0xE4}, {'밧', 0xE5}, {'방', 0xE6}, {'밭', 0xE7}, {'배', 0xE8}, {'백', 0xE9}, {'밴', 0xEA}, {'밸', 0xEB}, {'뱀', 0xEC}, {'뱁', 0xED}, {'뱃', 0xEE}, {'뱄', 0xEF},
{'뱅', 0xF0}, {'뱉', 0xF1}, {'뱌', 0xF2}, {'뱍', 0xF3}, {'뱐', 0xF4}, {'뱝', 0xF5}, {'버', 0xF6}, {'벅', 0xF7}, {'번', 0xF8}, {'벋', 0xF9}, {'벌', 0xFA}, {'벎', 0xFB}, {'범', 0xFC}, {'법', 0xFD}, {'벗', 0xFE},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_5 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'벙', 0x01}, {'벚', 0x02}, {'베', 0x03}, {'벡', 0x04}, {'벤', 0x05}, {'벧', 0x06}, {'벨', 0x07}, {'벰', 0x08}, {'벱', 0x09}, {'벳', 0x0A}, {'벴', 0x0B}, {'벵', 0x0C}, {'벼', 0x0D}, {'벽', 0x0E}, {'변', 0x0F},
{'별', 0x10}, {'볍', 0x11}, {'볏', 0x12}, {'볐', 0x13}, {'병', 0x14}, {'볕', 0x15}, {'볘', 0x16}, {'볜', 0x17}, {'보', 0x18}, {'복', 0x19}, {'볶', 0x1A}, {'본', 0x1B}, {'볼', 0x1C}, {'봄', 0x1D}, {'봅', 0x1E}, {'봇', 0x1F},
{'봉', 0x20}, {'봐', 0x21}, {'봔', 0x22}, {'봤', 0x23}, {'봬', 0x24}, {'뵀', 0x25}, {'뵈', 0x26}, {'뵉', 0x27}, {'뵌', 0x28}, {'뵐', 0x29}, {'뵘', 0x2A}, {'뵙', 0x2B}, {'뵤', 0x2C}, {'뵨', 0x2D}, {'부', 0x2E}, {'북', 0x2F},
{'분', 0x30}, {'붇', 0x31}, {'불', 0x32}, {'붉', 0x33}, {'붊', 0x34}, {'붐', 0x35}, {'붑', 0x36}, {'붓', 0x37}, {'붕', 0x38}, {'붙', 0x39}, {'붚', 0x3A}, {'붜', 0x3B}, {'붤', 0x3C}, {'붰', 0x3D}, {'붸', 0x3E}, {'뷔', 0x3F},
{'뷕', 0x40}, {'뷘', 0x41}, {'뷜', 0x42}, {'뷩', 0x43}, {'뷰', 0x44}, {'뷴', 0x45}, {'뷸', 0x46}, {'븀', 0x47}, {'븃', 0x48}, {'븅', 0x49}, {'브', 0x4A}, {'븍', 0x4B}, {'븐', 0x4C}, {'블', 0x4D}, {'븜', 0x4E}, {'븝', 0x4F},
{'븟', 0x60}, {'비', 0x61}, {'빅', 0x62}, {'빈', 0x63}, {'빌', 0x64}, {'빎', 0x65}, {'빔', 0x66}, {'빕', 0x67}, {'빗', 0x68}, {'빙', 0x69}, {'빚', 0x6A}, {'빛', 0x6B}, {'빠', 0x6C}, {'빡', 0x6D}, {'빤', 0x6E},
{'빨', 0x71}, {'빪', 0x72}, {'빰', 0x73}, {'빱', 0x74}, {'빳', 0x75}, {'빴', 0x76}, {'빵', 0x77}, {'빻', 0x78}, {'빼', 0x79}, {'빽', 0x7A}, {'뺀', 0x7B}, {'뺄', 0x7C}, {'뺌', 0x7D}, {'뺍', 0x7E}, {'뺏', 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},
{'샥', 0xD1}, {'샨', 0xD2}, {'샬', 0xD3}, {'샴', 0xD4}, {'샵', 0xD5}, {'샷', 0xD6}, {'샹', 0xD7}, {'섀', 0xD8}, {'섄', 0xD9}, {'섈', 0xDA}, {'섐', 0xDB}, {'섕', 0xDC}, {'서', 0xDD}, {'석', 0xDE}, {'섞', 0xDF},
{'섟', 0xE0}, {'선', 0xE1}, {'섣', 0xE2}, {'설', 0xE3}, {'섦', 0xE4}, {'섧', 0xE5}, {'섬', 0xE6}, {'섭', 0xE7}, {'섯', 0xE8}, {'섰', 0xE9}, {'성', 0xEA}, {'섶', 0xEB}, {'세', 0xEC}, {'섹', 0xED}, {'센', 0xEE}, {'셀', 0xEF},
{'셈', 0xF0}, {'셉', 0xF1}, {'셋', 0xF2}, {'셌', 0xF3}, {'셍', 0xF4}, {'셔', 0xF5}, {'셕', 0xF6}, {'션', 0xF7}, {'셜', 0xF8}, {'셤', 0xF9}, {'셥', 0xFA}, {'셧', 0xFB}, {'셨', 0xFC}, {'셩', 0xFD}, {'셰', 0xFE}, {'셴', 0xFF},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_6 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'셸', 0x00}, {'솅', 0x01}, {'소', 0x02}, {'속', 0x03}, {'솎', 0x04}, {'손', 0x05}, {'솔', 0x06}, {'솖', 0x07}, {'솜', 0x08}, {'솝', 0x09}, {'솟', 0x0A}, {'송', 0x0B}, {'솥', 0x0C}, {'솨', 0x0D}, {'솩', 0x0E}, {'솬', 0x0F},
{'솰', 0x10}, {'솽', 0x11}, {'쇄', 0x12}, {'쇈', 0x13}, {'쇌', 0x14}, {'쇔', 0x15}, {'쇗', 0x16}, {'쇘', 0x17}, {'쇠', 0x18}, {'쇤', 0x19}, {'쇨', 0x1A}, {'쇰', 0x1B}, {'쇱', 0x1C}, {'쇳', 0x1D}, {'쇼', 0x1E}, {'쇽', 0x1F},
{'숀', 0x20}, {'숄', 0x21}, {'숌', 0x22}, {'숍', 0x23}, {'숏', 0x24}, {'숑', 0x25}, {'수', 0x26}, {'숙', 0x27}, {'순', 0x28}, {'숟', 0x29}, {'술', 0x2A}, {'숨', 0x2B}, {'숩', 0x2C}, {'숫', 0x2D}, {'숭', 0x2E}, {'쌰', 0x2F},
{'쎼', 0x30}, {'숯', 0x31}, {'숱', 0x32}, {'숲', 0x33}, {'숴', 0x34}, {'쉈', 0x35}, {'쉐', 0x36}, {'쉑', 0x37}, {'쉔', 0x38}, {'쉘', 0x39}, {'쉠', 0x3A}, {'쉥', 0x3B}, {'쉬', 0x3C}, {'쉭', 0x3D}, {'쉰', 0x3E}, {'쉴', 0x3F},
{'쉼', 0x40}, {'쉽', 0x41}, {'쉿', 0x42}, {'슁', 0x43}, {'슈', 0x44}, {'슉', 0x45}, {'슐', 0x46}, {'슘', 0x47}, {'슛', 0x48}, {'슝', 0x49}, {'스', 0x4A}, {'슥', 0x4B}, {'슨', 0x4C}, {'슬', 0x4D}, {'슭', 0x4E}, {'슴', 0x4F},
{'습', 0x60}, {'슷', 0x61}, {'승', 0x62}, {'시', 0x63}, {'식', 0x64}, {'신', 0x65}, {'싣', 0x66}, {'실', 0x67}, {'싫', 0x68}, {'심', 0x69}, {'십', 0x6A}, {'싯', 0x6B}, {'싱', 0x6C}, {'싶', 0x6D}, {'싸', 0x6E}, {'싹', 0x6F},
{'싻', 0x70}, {'싼', 0x71}, {'쌀', 0x72}, {'쌈', 0x73}, {'쌉', 0x74}, {'쌌', 0x75}, {'쌍', 0x76}, {'쌓', 0x77}, {'쌔', 0x78}, {'쌕', 0x79}, {'쌘', 0x7A}, {'쌜', 0x7B}, {'쌤', 0x7C}, {'쌥', 0x7D}, {'쌨', 0x7E}, {'쌩', 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},
{'쓔', 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}, {'얌', 0xE4}, {'얍', 0xE5}, {'얏', 0xE6}, {'양', 0xE7}, {'얕', 0xE8}, {'얗', 0xE9}, {'얘', 0xEA}, {'얜', 0xEB}, {'얠', 0xEC}, {'얩', 0xED}, {'어', 0xEE}, {'억', 0xEF},
{'언', 0xF0}, {'얹', 0xF1}, {'얻', 0xF2}, {'얼', 0xF3}, {'얽', 0xF4}, {'얾', 0xF5}, {'엄', 0xF6}, {'업', 0xF7}, {'없', 0xF8}, {'엇', 0xF9}, {'었', 0xFA}, {'엉', 0xFB}, {'엊', 0xFC}, {'엌', 0xFD}, {'엎', 0xFE},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_7 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'에', 0x01}, {'엑', 0x02}, {'엔', 0x03}, {'엘', 0x04}, {'엠', 0x05}, {'엡', 0x06}, {'엣', 0x07}, {'엥', 0x08}, {'여', 0x09}, {'역', 0x0A}, {'엮', 0x0B}, {'연', 0x0C}, {'열', 0x0D}, {'엶', 0x0E}, {'엷', 0x0F},
{'염', 0x10}, {'엽', 0x11}, {'엾', 0x12}, {'엿', 0x13}, {'였', 0x14}, {'영', 0x15}, {'옅', 0x16}, {'옆', 0x17}, {'옇', 0x18}, {'예', 0x19}, {'옌', 0x1A}, {'옐', 0x1B}, {'옘', 0x1C}, {'옙', 0x1D}, {'옛', 0x1E}, {'옜', 0x1F},
{'오', 0x20}, {'옥', 0x21}, {'온', 0x22}, {'올', 0x23}, {'옭', 0x24}, {'옮', 0x25}, {'옰', 0x26}, {'옳', 0x27}, {'옴', 0x28}, {'옵', 0x29}, {'옷', 0x2A}, {'옹', 0x2B}, {'옻', 0x2C}, {'와', 0x2D}, {'왁', 0x2E}, {'완', 0x2F},
{'왈', 0x30}, {'왐', 0x31}, {'왑', 0x32}, {'왓', 0x33}, {'왔', 0x34}, {'왕', 0x35}, {'왜', 0x36}, {'왝', 0x37}, {'왠', 0x38}, {'왬', 0x39}, {'왯', 0x3A}, {'왱', 0x3B}, {'외', 0x3C}, {'왹', 0x3D}, {'왼', 0x3E}, {'욀', 0x3F},
{'욈', 0x40}, {'욉', 0x41}, {'욋', 0x42}, {'욍', 0x43}, {'요', 0x44}, {'욕', 0x45}, {'욘', 0x46}, {'욜', 0x47}, {'욤', 0x48}, {'욥', 0x49}, {'욧', 0x4A}, {'용', 0x4B}, {'우', 0x4C}, {'욱', 0x4D}, {'운', 0x4E}, {'울', 0x4F},
{'욹', 0x60}, {'욺', 0x61}, {'움', 0x62}, {'웁', 0x63}, {'웃', 0x64}, {'웅', 0x65}, {'워', 0x66}, {'웍', 0x67}, {'원', 0x68}, {'월', 0x69}, {'웜', 0x6A}, {'웝', 0x6B}, {'웠', 0x6C}, {'웡', 0x6D}, {'웨', 0x6E},
{'웩', 0x71}, {'웬', 0x72}, {'웰', 0x73}, {'웸', 0x74}, {'웹', 0x75}, {'웽', 0x76}, {'위', 0x77}, {'윅', 0x78}, {'윈', 0x79}, {'윌', 0x7A}, {'윔', 0x7B}, {'윕', 0x7C}, {'윗', 0x7D}, {'윙', 0x7E}, {'유', 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},
{'점', 0xD1}, {'접', 0xD2}, {'젓', 0xD3}, {'정', 0xD4}, {'젖', 0xD5}, {'제', 0xD6}, {'젝', 0xD7}, {'젠', 0xD8}, {'젤', 0xD9}, {'젬', 0xDA}, {'젭', 0xDB}, {'젯', 0xDC}, {'젱', 0xDD}, {'져', 0xDE}, {'젼', 0xDF},
{'졀', 0xE0}, {'졈', 0xE1}, {'졉', 0xE2}, {'졌', 0xE3}, {'졍', 0xE4}, {'졔', 0xE5}, {'조', 0xE6}, {'족', 0xE7}, {'존', 0xE8}, {'졸', 0xE9}, {'졺', 0xEA}, {'좀', 0xEB}, {'좁', 0xEC}, {'좃', 0xED}, {'종', 0xEE}, {'좆', 0xEF},
{'좇', 0xF0}, {'좋', 0xF1}, {'좌', 0xF2}, {'좍', 0xF3}, {'좔', 0xF4}, {'좝', 0xF5}, {'좟', 0xF6}, {'좡', 0xF7}, {'좨', 0xF8}, {'좼', 0xF9}, {'좽', 0xFA}, {'죄', 0xFB}, {'죈', 0xFC}, {'죌', 0xFD}, {'죔', 0xFE}, {'죕', 0xFF},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_8 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'죗', 0x00}, {'죙', 0x01}, {'죠', 0x02}, {'죡', 0x03}, {'죤', 0x04}, {'죵', 0x05}, {'주', 0x06}, {'죽', 0x07}, {'준', 0x08}, {'줄', 0x09}, {'줅', 0x0A}, {'줆', 0x0B}, {'줌', 0x0C}, {'줍', 0x0D}, {'줏', 0x0E}, {'중', 0x0F},
{'줘', 0x10}, {'줬', 0x11}, {'줴', 0x12}, {'쥐', 0x13}, {'쥑', 0x14}, {'쥔', 0x15}, {'쥘', 0x16}, {'쥠', 0x17}, {'쥡', 0x18}, {'쥣', 0x19}, {'쥬', 0x1A}, {'쥰', 0x1B}, {'쥴', 0x1C}, {'쥼', 0x1D}, {'즈', 0x1E}, {'즉', 0x1F},
{'즌', 0x20}, {'즐', 0x21}, {'즘', 0x22}, {'즙', 0x23}, {'즛', 0x24}, {'증', 0x25}, {'지', 0x26}, {'직', 0x27}, {'진', 0x28}, {'짇', 0x29}, {'질', 0x2A}, {'짊', 0x2B}, {'짐', 0x2C}, {'집', 0x2D}, {'짓', 0x2E},
{'쬬', 0x30}, {'징', 0x31}, {'짖', 0x32}, {'짙', 0x33}, {'짚', 0x34}, {'짜', 0x35}, {'짝', 0x36}, {'짠', 0x37}, {'짢', 0x38}, {'짤', 0x39}, {'짧', 0x3A}, {'짬', 0x3B}, {'짭', 0x3C}, {'짯', 0x3D}, {'짰', 0x3E}, {'짱', 0x3F},
{'째', 0x40}, {'짹', 0x41}, {'짼', 0x42}, {'쨀', 0x43}, {'쨈', 0x44}, {'쨉', 0x45}, {'쨋', 0x46}, {'쨌', 0x47}, {'쨍', 0x48}, {'쨔', 0x49}, {'쨘', 0x4A}, {'쨩', 0x4B}, {'쩌', 0x4C}, {'쩍', 0x4D}, {'쩐', 0x4E}, {'쩔', 0x4F},
{'쩜', 0x60}, {'쩝', 0x61}, {'쩟', 0x62}, {'쩠', 0x63}, {'쩡', 0x64}, {'쩨', 0x65}, {'쩽', 0x66}, {'쪄', 0x67}, {'쪘', 0x68}, {'쪼', 0x69}, {'쪽', 0x6A}, {'쫀', 0x6B}, {'쫄', 0x6C}, {'쫌', 0x6D}, {'쫍', 0x6E}, {'쫏', 0x6F},
{'쫑', 0x70}, {'쫓', 0x71}, {'쫘', 0x72}, {'쫙', 0x73}, {'쫠', 0x74}, {'쫬', 0x75}, {'쫴', 0x76}, {'쬈', 0x77}, {'쬐', 0x78}, {'쬔', 0x79}, {'쬘', 0x7A}, {'쬠', 0x7B}, {'쬡', 0x7C}, {'쭁', 0x7D}, {'쭈', 0x7E}, {'쭉', 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},
{'찼', 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}, {'춥', 0xE4}, {'춧', 0xE5}, {'충', 0xE6}, {'춰', 0xE7}, {'췄', 0xE8}, {'췌', 0xE9}, {'췐', 0xEA}, {'취', 0xEB}, {'췬', 0xEC}, {'췰', 0xED}, {'췸', 0xEE}, {'췹', 0xEF},
{'췻', 0xF0}, {'췽', 0xF1}, {'츄', 0xF2}, {'츈', 0xF3}, {'츌', 0xF4}, {'츔', 0xF5}, {'츙', 0xF6}, {'츠', 0xF7}, {'측', 0xF8}, {'츤', 0xF9}, {'츨', 0xFA}, {'츰', 0xFB}, {'츱', 0xFC}, {'츳', 0xFD}, {'층', 0xFE},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_9 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'치', 0x01}, {'칙', 0x02}, {'친', 0x03}, {'칟', 0x04}, {'칠', 0x05}, {'칡', 0x06}, {'침', 0x07}, {'칩', 0x08}, {'칫', 0x09}, {'칭', 0x0A}, {'카', 0x0B}, {'칵', 0x0C}, {'칸', 0x0D}, {'칼', 0x0E}, {'캄', 0x0F},
{'캅', 0x10}, {'캇', 0x11}, {'캉', 0x12}, {'캐', 0x13}, {'캑', 0x14}, {'캔', 0x15}, {'캘', 0x16}, {'캠', 0x17}, {'캡', 0x18}, {'캣', 0x19}, {'캤', 0x1A}, {'캥', 0x1B}, {'캬', 0x1C}, {'캭', 0x1D}, {'컁', 0x1E}, {'커', 0x1F},
{'컥', 0x20}, {'컨', 0x21}, {'컫', 0x22}, {'컬', 0x23}, {'컴', 0x24}, {'컵', 0x25}, {'컷', 0x26}, {'컸', 0x27}, {'컹', 0x28}, {'케', 0x29}, {'켁', 0x2A}, {'켄', 0x2B}, {'켈', 0x2C}, {'켐', 0x2D}, {'켑', 0x2E}, {'켓', 0x2F},
{'켕', 0x30}, {'켜', 0x31}, {'켠', 0x32}, {'켤', 0x33}, {'켬', 0x34}, {'켭', 0x35}, {'켯', 0x36}, {'켰', 0x37}, {'켱', 0x38}, {'켸', 0x39}, {'코', 0x3A}, {'콕', 0x3B}, {'콘', 0x3C}, {'콜', 0x3D}, {'콤', 0x3E}, {'콥', 0x3F},
{'콧', 0x40}, {'콩', 0x41}, {'콰', 0x42}, {'콱', 0x43}, {'콴', 0x44}, {'콸', 0x45}, {'쾀', 0x46}, {'쾅', 0x47}, {'쾌', 0x48}, {'쾡', 0x49}, {'쾨', 0x4A}, {'쾰', 0x4B}, {'쿄', 0x4C}, {'쿠', 0x4D}, {'쿡', 0x4E}, {'쿤', 0x4F},
{'쿨', 0x60}, {'쿰', 0x61}, {'쿱', 0x62}, {'쿳', 0x63}, {'쿵', 0x64}, {'쿼', 0x65}, {'퀀', 0x66}, {'퀄', 0x67}, {'퀑', 0x68}, {'퀘', 0x69}, {'퀭', 0x6A}, {'퀴', 0x6B}, {'퀵', 0x6C}, {'퀸', 0x6D}, {'퀼', 0x6E},
{'큄', 0x71}, {'큅', 0x72}, {'큇', 0x73}, {'큉', 0x74}, {'큐', 0x75}, {'큔', 0x76}, {'큘', 0x77}, {'큠', 0x78}, {'크', 0x79}, {'큭', 0x7A}, {'큰', 0x7B}, {'클', 0x7C}, {'큼', 0x7D}, {'큽', 0x7E}, {'킁', 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},
{'퉤', 0xD1}, {'튀', 0xD2}, {'튁', 0xD3}, {'튄', 0xD4}, {'튈', 0xD5}, {'튐', 0xD6}, {'튑', 0xD7}, {'튕', 0xD8}, {'튜', 0xD9}, {'튠', 0xDA}, {'튤', 0xDB}, {'튬', 0xDC}, {'튱', 0xDD}, {'트', 0xDE}, {'특', 0xDF},
{'튼', 0xE0}, {'튿', 0xE1}, {'틀', 0xE2}, {'틂', 0xE3}, {'틈', 0xE4}, {'틉', 0xE5}, {'틋', 0xE6}, {'틔', 0xE7}, {'틘', 0xE8}, {'틜', 0xE9}, {'틤', 0xEA}, {'틥', 0xEB}, {'티', 0xEC}, {'틱', 0xED}, {'틴', 0xEE}, {'틸', 0xEF},
{'팀', 0xF0}, {'팁', 0xF1}, {'팃', 0xF2}, {'팅', 0xF3}, {'파', 0xF4}, {'팍', 0xF5}, {'팎', 0xF6}, {'판', 0xF7}, {'팔', 0xF8}, {'팖', 0xF9}, {'팜', 0xFA}, {'팝', 0xFB}, {'팟', 0xFC}, {'팠', 0xFD}, {'팡', 0xFE}, {'팥', 0xFF},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<char, byte> U2GSC_KOR_A = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{'패', 0x00}, {'팩', 0x01}, {'팬', 0x02}, {'팰', 0x03}, {'팸', 0x04}, {'팹', 0x05}, {'팻', 0x06}, {'팼', 0x07}, {'팽', 0x08}, {'퍄', 0x09}, {'퍅', 0x0A}, {'퍼', 0x0B}, {'퍽', 0x0C}, {'펀', 0x0D}, {'펄', 0x0E}, {'펌', 0x0F},
{'펍', 0x10}, {'펏', 0x11}, {'펐', 0x12}, {'펑', 0x13}, {'페', 0x14}, {'펙', 0x15}, {'펜', 0x16}, {'펠', 0x17}, {'펨', 0x18}, {'펩', 0x19}, {'펫', 0x1A}, {'펭', 0x1B}, {'펴', 0x1C}, {'편', 0x1D}, {'펼', 0x1E}, {'폄', 0x1F},
{'폅', 0x20}, {'폈', 0x21}, {'평', 0x22}, {'폐', 0x23}, {'폘', 0x24}, {'폡', 0x25}, {'폣', 0x26}, {'포', 0x27}, {'폭', 0x28}, {'폰', 0x29}, {'폴', 0x2A}, {'폼', 0x2B}, {'폽', 0x2C}, {'폿', 0x2D}, {'퐁', 0x2E},
{'퐈', 0x31}, {'퐝', 0x32}, {'푀', 0x33}, {'푄', 0x34}, {'표', 0x35}, {'푠', 0x36}, {'푤', 0x37}, {'푭', 0x38}, {'푯', 0x39}, {'푸', 0x3A}, {'푹', 0x3B}, {'푼', 0x3C}, {'푿', 0x3D}, {'풀', 0x3E}, {'풂', 0x3F},
{'품', 0x40}, {'풉', 0x41}, {'풋', 0x42}, {'풍', 0x43}, {'풔', 0x44}, {'풩', 0x45}, {'퓌', 0x46}, {'퓐', 0x47}, {'퓔', 0x48}, {'퓜', 0x49}, {'퓟', 0x4A}, {'퓨', 0x4B}, {'퓬', 0x4C}, {'퓰', 0x4D}, {'퓸', 0x4E}, {'퓻', 0x4F},
{'퓽', 0x60}, {'프', 0x61}, {'픈', 0x62}, {'플', 0x63}, {'픔', 0x64}, {'픕', 0x65}, {'픗', 0x66}, {'피', 0x67}, {'픽', 0x68}, {'핀', 0x69}, {'필', 0x6A}, {'핌', 0x6B}, {'핍', 0x6C}, {'핏', 0x6D}, {'핑', 0x6E}, {'하', 0x6F},
{'학', 0x70}, {'한', 0x71}, {'할', 0x72}, {'핥', 0x73}, {'함', 0x74}, {'합', 0x75}, {'핫', 0x76}, {'항', 0x77}, {'해', 0x78}, {'핵', 0x79}, {'핸', 0x7A}, {'핼', 0x7B}, {'햄', 0x7C}, {'햅', 0x7D}, {'햇', 0x7E}, {'했', 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},
{'혤', 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}, {'흉', 0xE4}, {'흐', 0xE5}, {'흑', 0xE6}, {'흔', 0xE7}, {'흖', 0xE8}, {'흗', 0xE9}, {'흘', 0xEA}, {'흙', 0xEB}, {'흠', 0xEC}, {'흡', 0xED}, {'흣', 0xEE}, {'흥', 0xEF},
{'흩', 0xF0}, {'희', 0xF1}, {'흰', 0xF2}, {'흴', 0xF3}, {'흼', 0xF4}, {'흽', 0xF5}, {'힁', 0xF6}, {'히', 0xF7}, {'힉', 0xF8}, {'힌', 0xF9}, {'힐', 0xFA}, {'힘', 0xFB}, {'힙', 0xFC}, {'힛', 0xFD}, {'힝', 0xFE},
};
private static readonly Dictionary<char, byte> U2GSC_KOR_B = U2GSC_KOR_0;
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_0 = new(80)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x00, 'ㄱ'}, {0x01, 'ㄴ'}, {0x02, 'ㄷ'}, {0x03, 'ㄹ'}, {0x04, 'ㅁ'}, {0x05, 'ㅂ'}, {0x06, 'ㅅ'}, {0x07, 'ㅇ'}, {0x08, 'ㅈ'}, {0x09, 'ㅊ'}, {0x0A, 'ㅋ'}, {0x0B, 'ㅌ'}, {0x0C, 'ㅍ'}, {0x0D, 'ㅎ'}, {0x0E, 'ㄲ'}, {0x0F, 'ㄸ'},
{0x10, 'ㅃ'}, {0x11, 'ㅆ'}, {0x12, 'ㅉ'},
{0x20, 'ㅏ'}, {0x21, 'ㅑ'}, {0x22, 'ㅓ'}, {0x23, 'ㅕ'}, {0x24, 'ㅗ'}, {0x25, 'ㅛ'}, {0x26, 'ㅜ'}, {0x27, 'ㅠ'}, {0x28, 'ㅡ'}, {0x29, 'ㅣ'}, {0x2A, 'ㅐ'}, {0x2B, 'ㅒ'}, {0x2C, 'ㅔ'}, {0x2D, 'ㅖ'}, {0x2E, 'ㅘ'}, {0x2F, 'ㅙ'},
{0x30, 'ㅚ'}, {0x31, 'ㅝ'}, {0x32, 'ㅞ'}, {0x33, 'ㅟ'}, {0x34, 'ㅢ'}, {0x3E, '_'}, {0x3F, '—'},
{0x60, '「'}, {0x61, '」'}, {0x62, '『'}, {0x63, '』'}, {0x64, '('}, {0x65, ')'}, {0x66, '!'}, {0x67, '?'}, {0x68, '-'}, {0x69, '~'}, {0x6A, '…'}, {0x6B, ','}, {0x6C, '.'}, // . is 0x6D for bank
{0xF0, '０'}, {0xF1, '１'}, {0xF2, '２'}, {0xF3, '３'}, {0xF4, '４'}, {0xF5, '５'}, {0xF6, '６'}, {0xF7, '７'}, {0xF8, '８'}, {0xF9, '９'},
{0xFF, '\u3000'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_1 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x01, '가'}, {0x02, '각'}, {0x03, '간'}, {0x04, '갇'}, {0x05, '갈'}, {0x06, '갉'}, {0x07, '갊'}, {0x08, '감'}, {0x09, '갑'}, {0x0A, '값'}, {0x0B, '갓'}, {0x0C, '갔'}, {0x0D, '강'}, {0x0E, '갖'}, {0x0F, '갗'},
{0x10, '같'}, {0x11, '갚'}, {0x12, '갛'}, {0x13, '개'}, {0x14, '객'}, {0x15, '갠'}, {0x16, '갤'}, {0x17, '갬'}, {0x18, '갭'}, {0x19, '갯'}, {0x1A, '갰'}, {0x1B, '갱'}, {0x1C, '갸'}, {0x1D, '갹'}, {0x1E, '갼'}, {0x1F, '걀'},
{0x20, '걋'}, {0x21, '걍'}, {0x22, '걔'}, {0x23, '걘'}, {0x24, '걜'}, {0x25, '거'}, {0x26, '걱'}, {0x27, '건'}, {0x28, '걷'}, {0x29, '걸'}, {0x2A, '걺'}, {0x2B, '검'}, {0x2C, '겁'}, {0x2D, '것'}, {0x2E, '겄'}, {0x2F, '겅'},
{0x30, '겆'}, {0x31, '겉'}, {0x32, '겊'}, {0x33, '겋'}, {0x34, '게'}, {0x35, '겐'}, {0x36, '겔'}, {0x37, '겜'}, {0x38, '겝'}, {0x39, '겟'}, {0x3A, '겠'}, {0x3B, '겡'}, {0x3C, '겨'}, {0x3D, '격'}, {0x3E, '겪'}, {0x3F, '견'},
{0x40, '겯'}, {0x41, '결'}, {0x42, '겹'}, {0x43, '겸'}, {0x44, '겻'}, {0x45, '겼'}, {0x46, '경'}, {0x47, '곁'}, {0x48, '계'}, {0x49, '곈'}, {0x4A, '곌'}, {0x4B, '곕'}, {0x4C, '곗'}, {0x4D, '고'}, {0x4E, '곡'}, {0x4F, '곤'},
{0x60, '곧'}, {0x61, '골'}, {0x62, '곪'}, {0x63, '곬'}, {0x64, '곯'}, {0x65, '곰'}, {0x66, '곱'}, {0x67, '곳'}, {0x68, '공'}, {0x69, '곶'}, {0x6A, '과'}, {0x6B, '곽'}, {0x6C, '관'}, {0x6D, '괄'}, {0x6E, '괆'},
{0x71, '괌'}, {0x72, '괍'}, {0x73, '괏'}, {0x74, '광'}, {0x75, '괘'}, {0x76, '괜'}, {0x77, '괠'}, {0x78, '괩'}, {0x79, '괬'}, {0x7A, '괭'}, {0x7B, '괴'}, {0x7C, '괵'}, {0x7D, '괸'}, {0x7E, '괼'}, {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, '깸'},
{0xD1, '깹'}, {0xD2, '깻'}, {0xD3, '깼'}, {0xD4, '깽'}, {0xD5, '꺄'}, {0xD6, '꺅'}, {0xD7, '꺌'}, {0xD8, '꺼'}, {0xD9, '꺽'}, {0xDA, '꺾'}, {0xDB, '껀'}, {0xDC, '껄'}, {0xDD, '껌'}, {0xDE, '껍'}, {0xDF, '껏'},
{0xE0, '껐'}, {0xE1, '껑'}, {0xE2, '께'}, {0xE3, '껙'}, {0xE4, '껜'}, {0xE5, '껨'}, {0xE6, '껫'}, {0xE7, '껭'}, {0xE8, '껴'}, {0xE9, '껸'}, {0xEA, '껼'}, {0xEB, '꼇'}, {0xEC, '꼈'}, {0xED, '꼍'}, {0xEE, '꼐'}, {0xEF, '꼬'},
{0xF0, '꼭'}, {0xF1, '꼰'}, {0xF2, '꼲'}, {0xF3, '꼴'}, {0xF4, '꼼'}, {0xF5, '꼽'}, {0xF6, '꼿'}, {0xF7, '꽁'}, {0xF8, '꽂'}, {0xF9, '꽃'}, {0xFA, '꽈'}, {0xFB, '꽉'}, {0xFC, '꽐'}, {0xFD, '꽜'}, {0xFE, '꽝'}, {0xFF, '꽤'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_2 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x00, '꽥'}, {0x01, '꽹'}, {0x02, '꾀'}, {0x03, '꾄'}, {0x04, '꾈'}, {0x05, '꾐'}, {0x06, '꾑'}, {0x07, '꾕'}, {0x08, '꾜'}, {0x09, '꾸'}, {0x0A, '꾹'}, {0x0B, '꾼'}, {0x0C, '꿀'}, {0x0D, '꿇'}, {0x0E, '꿈'}, {0x0F, '꿉'},
{0x10, '꿋'}, {0x11, '꿍'}, {0x12, '꿎'}, {0x13, '꿔'}, {0x14, '꿜'}, {0x15, '꿨'}, {0x16, '꿩'}, {0x17, '꿰'}, {0x18, '꿱'}, {0x19, '꿴'}, {0x1A, '꿸'}, {0x1B, '뀀'}, {0x1C, '뀁'}, {0x1D, '뀄'}, {0x1E, '뀌'}, {0x1F, '뀐'},
{0x20, '뀔'}, {0x21, '뀜'}, {0x22, '뀝'}, {0x23, '뀨'}, {0x24, '끄'}, {0x25, '끅'}, {0x26, '끈'}, {0x27, '끊'}, {0x28, '끌'}, {0x29, '끎'}, {0x2A, '끓'}, {0x2B, '끔'}, {0x2C, '끕'}, {0x2D, '끗'}, {0x2E, '끙'},
{0x31, '끝'}, {0x32, '끼'}, {0x33, '끽'}, {0x34, '낀'}, {0x35, '낄'}, {0x36, '낌'}, {0x37, '낍'}, {0x38, '낏'}, {0x39, '낑'}, {0x3A, '나'}, {0x3B, '낙'}, {0x3C, '낚'}, {0x3D, '난'}, {0x3E, '낟'}, {0x3F, '날'},
{0x40, '낡'}, {0x41, '낢'}, {0x42, '남'}, {0x43, '납'}, {0x44, '낫'}, {0x45, '났'}, {0x46, '낭'}, {0x47, '낮'}, {0x48, '낯'}, {0x49, '낱'}, {0x4A, '낳'}, {0x4B, '내'}, {0x4C, '낵'}, {0x4D, '낸'}, {0x4E, '낼'}, {0x4F, '냄'},
{0x60, '냅'}, {0x61, '냇'}, {0x62, '냈'}, {0x63, '냉'}, {0x64, '냐'}, {0x65, '냑'}, {0x66, '냔'}, {0x67, '냘'}, {0x68, '냠'}, {0x69, '냥'}, {0x6A, '너'}, {0x6B, '넉'}, {0x6C, '넋'}, {0x6D, '넌'}, {0x6E, '널'}, {0x6F, '넒'},
{0x70, '넓'}, {0x71, '넘'}, {0x72, '넙'}, {0x73, '넛'}, {0x74, '넜'}, {0x75, '넝'}, {0x76, '넣'}, {0x77, '네'}, {0x78, '넥'}, {0x79, '넨'}, {0x7A, '넬'}, {0x7B, '넴'}, {0x7C, '넵'}, {0x7D, '넷'}, {0x7E, '넸'}, {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, '뇝'},
{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, '담'}, {0xE4, '답'}, {0xE5, '닷'}, {0xE6, '닸'}, {0xE7, '당'}, {0xE8, '닺'}, {0xE9, '닻'}, {0xEA, '닿'}, {0xEB, '대'}, {0xEC, '댁'}, {0xED, '댄'}, {0xEE, '댈'}, {0xEF, '댐'},
{0xF0, '댑'}, {0xF1, '댓'}, {0xF2, '댔'}, {0xF3, '댕'}, {0xF5, '더'}, {0xF6, '덕'}, {0xF7, '덖'}, {0xF8, '던'}, {0xF9, '덛'}, {0xFA, '덜'}, {0xFB, '덞'}, {0xFC, '덟'}, {0xFD, '덤'}, {0xFE, '덥'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_3 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x01, '덧'}, {0x02, '덩'}, {0x03, '덫'}, {0x04, '덮'}, {0x05, '데'}, {0x06, '덱'}, {0x07, '덴'}, {0x08, '델'}, {0x09, '뎀'}, {0x0A, '뎁'}, {0x0B, '뎃'}, {0x0C, '뎄'}, {0x0D, '뎅'}, {0x0E, '뎌'}, {0x0F, '뎐'},
{0x10, '뎔'}, {0x11, '뎠'}, {0x12, '뎡'}, {0x13, '뎨'}, {0x14, '뎬'}, {0x15, '도'}, {0x16, '독'}, {0x17, '돈'}, {0x18, '돋'}, {0x19, '돌'}, {0x1A, '돎'}, {0x1C, '돔'}, {0x1D, '돕'}, {0x1E, '돗'}, {0x1F, '동'},
{0x20, '돛'}, {0x21, '돝'}, {0x22, '돠'}, {0x23, '돤'}, {0x24, '돨'}, {0x25, '돼'}, {0x26, '됐'}, {0x27, '되'}, {0x28, '된'}, {0x29, '될'}, {0x2A, '됨'}, {0x2B, '됩'}, {0x2C, '됫'}, {0x2D, '됴'}, {0x2E, '두'}, {0x2F, '둑'},
{0x30, '둔'}, {0x31, '둘'}, {0x32, '둠'}, {0x33, '둡'}, {0x34, '둣'}, {0x35, '둥'}, {0x36, '둬'}, {0x37, '뒀'}, {0x38, '뒈'}, {0x39, '뒝'}, {0x3A, '뒤'}, {0x3B, '뒨'}, {0x3C, '뒬'}, {0x3D, '뒵'}, {0x3E, '뒷'}, {0x3F, '뒹'},
{0x40, '듀'}, {0x41, '듄'}, {0x42, '듈'}, {0x43, '듐'}, {0x44, '듕'}, {0x45, '드'}, {0x46, '득'}, {0x47, '든'}, {0x48, '듣'}, {0x49, '들'}, {0x4A, '듦'}, {0x4B, '듬'}, {0x4C, '듭'}, {0x4D, '듯'}, {0x4E, '등'}, {0x4F, '듸'},
{0x60, '디'}, {0x61, '딕'}, {0x62, '딘'}, {0x63, '딛'}, {0x64, '딜'}, {0x65, '딤'}, {0x66, '딥'}, {0x67, '딧'}, {0x68, '딨'}, {0x69, '딩'}, {0x6A, '딪'}, {0x6B, '따'}, {0x6C, '딱'}, {0x6D, '딴'}, {0x6E, '딸'},
{0x71, '땀'}, {0x72, '땁'}, {0x73, '땃'}, {0x74, '땄'}, {0x75, '땅'}, {0x76, '땋'}, {0x77, '때'}, {0x78, '땍'}, {0x79, '땐'}, {0x7A, '땔'}, {0x7B, '땜'}, {0x7C, '땝'}, {0x7D, '땟'}, {0x7E, '땠'}, {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, '랗'},
{0xD0, '뢔'}, {0xD1, '래'}, {0xD2, '랙'}, {0xD3, '랜'}, {0xD4, '랠'}, {0xD5, '램'}, {0xD6, '랩'}, {0xD7, '랫'}, {0xD8, '랬'}, {0xD9, '랭'}, {0xDA, '랴'}, {0xDB, '략'}, {0xDC, '랸'}, {0xDD, '럇'}, {0xDE, '량'}, {0xDF, '러'},
{0xE0, '럭'}, {0xE1, '런'}, {0xE2, '럴'}, {0xE3, '럼'}, {0xE4, '럽'}, {0xE5, '럿'}, {0xE6, '렀'}, {0xE7, '렁'}, {0xE8, '렇'}, {0xE9, '레'}, {0xEA, '렉'}, {0xEB, '렌'}, {0xEC, '렐'}, {0xED, '렘'}, {0xEE, '렙'}, {0xEF, '렛'},
{0xF0, '렝'}, {0xF1, '려'}, {0xF2, '력'}, {0xF3, '련'}, {0xF4, '렬'}, {0xF5, '렴'}, {0xF6, '렵'}, {0xF7, '렷'}, {0xF8, '렸'}, {0xF9, '령'}, {0xFA, '례'}, {0xFB, '롄'}, {0xFC, '롑'}, {0xFD, '롓'}, {0xFE, '로'}, {0xFF, '록'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_4 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x00, '론'}, {0x01, '롤'}, {0x02, '롬'}, {0x03, '롭'}, {0x04, '롯'}, {0x05, '롱'}, {0x06, '롸'}, {0x07, '롼'}, {0x08, '뢍'}, {0x09, '뢨'}, {0x0A, '뢰'}, {0x0B, '뢴'}, {0x0C, '뢸'}, {0x0D, '룀'}, {0x0E, '룁'}, {0x0F, '룃'},
{0x10, '룅'}, {0x11, '료'}, {0x12, '룐'}, {0x13, '룔'}, {0x14, '룝'}, {0x15, '룟'}, {0x16, '룡'}, {0x17, '루'}, {0x18, '룩'}, {0x19, '룬'}, {0x1A, '룰'}, {0x1B, '룸'}, {0x1C, '룹'}, {0x1D, '룻'}, {0x1E, '룽'}, {0x1F, '뤄'},
{0x20, '뤘'}, {0x21, '뤠'}, {0x22, '뤼'}, {0x23, '뤽'}, {0x24, '륀'}, {0x25, '륄'}, {0x26, '륌'}, {0x27, '륏'}, {0x28, '륑'}, {0x29, '류'}, {0x2A, '륙'}, {0x2B, '륜'}, {0x2C, '률'}, {0x2D, '륨'}, {0x2E, '륩'},
{0x31, '륫'}, {0x32, '륭'}, {0x33, '르'}, {0x34, '륵'}, {0x35, '른'}, {0x36, '를'}, {0x37, '름'}, {0x38, '릅'}, {0x39, '릇'}, {0x3A, '릉'}, {0x3B, '릊'}, {0x3C, '릍'}, {0x3D, '릎'}, {0x3E, '리'}, {0x3F, '릭'},
{0x40, '린'}, {0x41, '릴'}, {0x42, '림'}, {0x43, '립'}, {0x44, '릿'}, {0x45, '링'}, {0x46, '마'}, {0x47, '막'}, {0x48, '만'}, {0x49, '많'}, {0x4A, '맏'}, {0x4B, '말'}, {0x4C, '맑'}, {0x4D, '맒'}, {0x4E, '맘'}, {0x4F, '맙'},
{0x60, '맛'}, {0x61, '망'}, {0x62, '맞'}, {0x63, '맡'}, {0x64, '맣'}, {0x65, '매'}, {0x66, '맥'}, {0x67, '맨'}, {0x68, '맬'}, {0x69, '맴'}, {0x6A, '맵'}, {0x6B, '맷'}, {0x6C, '맸'}, {0x6D, '맹'}, {0x6E, '맺'}, {0x6F, '먀'},
{0x70, '먁'}, {0x71, '먈'}, {0x72, '먕'}, {0x73, '머'}, {0x74, '먹'}, {0x75, '먼'}, {0x76, '멀'}, {0x77, '멂'}, {0x78, '멈'}, {0x79, '멉'}, {0x7A, '멋'}, {0x7B, '멍'}, {0x7C, '멎'}, {0x7D, '멓'}, {0x7E, '메'}, {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, '뫼'},
{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, '밤'}, {0xE4, '밥'}, {0xE5, '밧'}, {0xE6, '방'}, {0xE7, '밭'}, {0xE8, '배'}, {0xE9, '백'}, {0xEA, '밴'}, {0xEB, '밸'}, {0xEC, '뱀'}, {0xED, '뱁'}, {0xEE, '뱃'}, {0xEF, '뱄'},
{0xF0, '뱅'}, {0xF1, '뱉'}, {0xF2, '뱌'}, {0xF3, '뱍'}, {0xF4, '뱐'}, {0xF5, '뱝'}, {0xF6, '버'}, {0xF7, '벅'}, {0xF8, '번'}, {0xF9, '벋'}, {0xFA, '벌'}, {0xFB, '벎'}, {0xFC, '범'}, {0xFD, '법'}, {0xFE, '벗'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_5 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x01, '벙'}, {0x02, '벚'}, {0x03, '베'}, {0x04, '벡'}, {0x05, '벤'}, {0x06, '벧'}, {0x07, '벨'}, {0x08, '벰'}, {0x09, '벱'}, {0x0A, '벳'}, {0x0B, '벴'}, {0x0C, '벵'}, {0x0D, '벼'}, {0x0E, '벽'}, {0x0F, '변'},
{0x10, '별'}, {0x11, '볍'}, {0x12, '볏'}, {0x13, '볐'}, {0x14, '병'}, {0x15, '볕'}, {0x16, '볘'}, {0x17, '볜'}, {0x18, '보'}, {0x19, '복'}, {0x1A, '볶'}, {0x1B, '본'}, {0x1C, '볼'}, {0x1D, '봄'}, {0x1E, '봅'}, {0x1F, '봇'},
{0x20, '봉'}, {0x21, '봐'}, {0x22, '봔'}, {0x23, '봤'}, {0x24, '봬'}, {0x25, '뵀'}, {0x26, '뵈'}, {0x27, '뵉'}, {0x28, '뵌'}, {0x29, '뵐'}, {0x2A, '뵘'}, {0x2B, '뵙'}, {0x2C, '뵤'}, {0x2D, '뵨'}, {0x2E, '부'}, {0x2F, '북'},
{0x30, '분'}, {0x31, '붇'}, {0x32, '불'}, {0x33, '붉'}, {0x34, '붊'}, {0x35, '붐'}, {0x36, '붑'}, {0x37, '붓'}, {0x38, '붕'}, {0x39, '붙'}, {0x3A, '붚'}, {0x3B, '붜'}, {0x3C, '붤'}, {0x3D, '붰'}, {0x3E, '붸'}, {0x3F, '뷔'},
{0x40, '뷕'}, {0x41, '뷘'}, {0x42, '뷜'}, {0x43, '뷩'}, {0x44, '뷰'}, {0x45, '뷴'}, {0x46, '뷸'}, {0x47, '븀'}, {0x48, '븃'}, {0x49, '븅'}, {0x4A, '브'}, {0x4B, '븍'}, {0x4C, '븐'}, {0x4D, '블'}, {0x4E, '븜'}, {0x4F, '븝'},
{0x60, '븟'}, {0x61, '비'}, {0x62, '빅'}, {0x63, '빈'}, {0x64, '빌'}, {0x65, '빎'}, {0x66, '빔'}, {0x67, '빕'}, {0x68, '빗'}, {0x69, '빙'}, {0x6A, '빚'}, {0x6B, '빛'}, {0x6C, '빠'}, {0x6D, '빡'}, {0x6E, '빤'},
{0x71, '빨'}, {0x72, '빪'}, {0x73, '빰'}, {0x74, '빱'}, {0x75, '빳'}, {0x76, '빴'}, {0x77, '빵'}, {0x78, '빻'}, {0x79, '빼'}, {0x7A, '빽'}, {0x7B, '뺀'}, {0x7C, '뺄'}, {0x7D, '뺌'}, {0x7E, '뺍'}, {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, '샤'},
{0xD1, '샥'}, {0xD2, '샨'}, {0xD3, '샬'}, {0xD4, '샴'}, {0xD5, '샵'}, {0xD6, '샷'}, {0xD7, '샹'}, {0xD8, '섀'}, {0xD9, '섄'}, {0xDA, '섈'}, {0xDB, '섐'}, {0xDC, '섕'}, {0xDD, '서'}, {0xDE, '석'}, {0xDF, '섞'},
{0xE0, '섟'}, {0xE1, '선'}, {0xE2, '섣'}, {0xE3, '설'}, {0xE4, '섦'}, {0xE5, '섧'}, {0xE6, '섬'}, {0xE7, '섭'}, {0xE8, '섯'}, {0xE9, '섰'}, {0xEA, '성'}, {0xEB, '섶'}, {0xEC, '세'}, {0xED, '섹'}, {0xEE, '센'}, {0xEF, '셀'},
{0xF0, '셈'}, {0xF1, '셉'}, {0xF2, '셋'}, {0xF3, '셌'}, {0xF4, '셍'}, {0xF5, '셔'}, {0xF6, '셕'}, {0xF7, '션'}, {0xF8, '셜'}, {0xF9, '셤'}, {0xFA, '셥'}, {0xFB, '셧'}, {0xFC, '셨'}, {0xFD, '셩'}, {0xFE, '셰'}, {0xFF, '셴'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_6 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x00, '셸'}, {0x01, '솅'}, {0x02, '소'}, {0x03, '속'}, {0x04, '솎'}, {0x05, '손'}, {0x06, '솔'}, {0x07, '솖'}, {0x08, '솜'}, {0x09, '솝'}, {0x0A, '솟'}, {0x0B, '송'}, {0x0C, '솥'}, {0x0D, '솨'}, {0x0E, '솩'}, {0x0F, '솬'},
{0x10, '솰'}, {0x11, '솽'}, {0x12, '쇄'}, {0x13, '쇈'}, {0x14, '쇌'}, {0x15, '쇔'}, {0x16, '쇗'}, {0x17, '쇘'}, {0x18, '쇠'}, {0x19, '쇤'}, {0x1A, '쇨'}, {0x1B, '쇰'}, {0x1C, '쇱'}, {0x1D, '쇳'}, {0x1E, '쇼'}, {0x1F, '쇽'},
{0x20, '숀'}, {0x21, '숄'}, {0x22, '숌'}, {0x23, '숍'}, {0x24, '숏'}, {0x25, '숑'}, {0x26, '수'}, {0x27, '숙'}, {0x28, '순'}, {0x29, '숟'}, {0x2A, '술'}, {0x2B, '숨'}, {0x2C, '숩'}, {0x2D, '숫'}, {0x2E, '숭'}, {0x2F, '쌰'},
{0x30, '쎼'}, {0x31, '숯'}, {0x32, '숱'}, {0x33, '숲'}, {0x34, '숴'}, {0x35, '쉈'}, {0x36, '쉐'}, {0x37, '쉑'}, {0x38, '쉔'}, {0x39, '쉘'}, {0x3A, '쉠'}, {0x3B, '쉥'}, {0x3C, '쉬'}, {0x3D, '쉭'}, {0x3E, '쉰'}, {0x3F, '쉴'},
{0x40, '쉼'}, {0x41, '쉽'}, {0x42, '쉿'}, {0x43, '슁'}, {0x44, '슈'}, {0x45, '슉'}, {0x46, '슐'}, {0x47, '슘'}, {0x48, '슛'}, {0x49, '슝'}, {0x4A, '스'}, {0x4B, '슥'}, {0x4C, '슨'}, {0x4D, '슬'}, {0x4E, '슭'}, {0x4F, '슴'},
{0x60, '습'}, {0x61, '슷'}, {0x62, '승'}, {0x63, '시'}, {0x64, '식'}, {0x65, '신'}, {0x66, '싣'}, {0x67, '실'}, {0x68, '싫'}, {0x69, '심'}, {0x6A, '십'}, {0x6B, '싯'}, {0x6C, '싱'}, {0x6D, '싶'}, {0x6E, '싸'}, {0x6F, '싹'},
{0x70, '싻'}, {0x71, '싼'}, {0x72, '쌀'}, {0x73, '쌈'}, {0x74, '쌉'}, {0x75, '쌌'}, {0x76, '쌍'}, {0x77, '쌓'}, {0x78, '쌔'}, {0x79, '쌕'}, {0x7A, '쌘'}, {0x7B, '쌜'}, {0x7C, '쌤'}, {0x7D, '쌥'}, {0x7E, '쌨'}, {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, '쐰'},
{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, '얇'}, {0xE4, '얌'}, {0xE5, '얍'}, {0xE6, '얏'}, {0xE7, '양'}, {0xE8, '얕'}, {0xE9, '얗'}, {0xEA, '얘'}, {0xEB, '얜'}, {0xEC, '얠'}, {0xED, '얩'}, {0xEE, '어'}, {0xEF, '억'},
{0xF0, '언'}, {0xF1, '얹'}, {0xF2, '얻'}, {0xF3, '얼'}, {0xF4, '얽'}, {0xF5, '얾'}, {0xF6, '엄'}, {0xF7, '업'}, {0xF8, '없'}, {0xF9, '엇'}, {0xFA, '었'}, {0xFB, '엉'}, {0xFC, '엊'}, {0xFD, '엌'}, {0xFE, '엎'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_7 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x01, '에'}, {0x02, '엑'}, {0x03, '엔'}, {0x04, '엘'}, {0x05, '엠'}, {0x06, '엡'}, {0x07, '엣'}, {0x08, '엥'}, {0x09, '여'}, {0x0A, '역'}, {0x0B, '엮'}, {0x0C, '연'}, {0x0D, '열'}, {0x0E, '엶'}, {0x0F, '엷'},
{0x10, '염'}, {0x11, '엽'}, {0x12, '엾'}, {0x13, '엿'}, {0x14, '였'}, {0x15, '영'}, {0x16, '옅'}, {0x17, '옆'}, {0x18, '옇'}, {0x19, '예'}, {0x1A, '옌'}, {0x1B, '옐'}, {0x1C, '옘'}, {0x1D, '옙'}, {0x1E, '옛'}, {0x1F, '옜'},
{0x20, '오'}, {0x21, '옥'}, {0x22, '온'}, {0x23, '올'}, {0x24, '옭'}, {0x25, '옮'}, {0x26, '옰'}, {0x27, '옳'}, {0x28, '옴'}, {0x29, '옵'}, {0x2A, '옷'}, {0x2B, '옹'}, {0x2C, '옻'}, {0x2D, '와'}, {0x2E, '왁'}, {0x2F, '완'},
{0x30, '왈'}, {0x31, '왐'}, {0x32, '왑'}, {0x33, '왓'}, {0x34, '왔'}, {0x35, '왕'}, {0x36, '왜'}, {0x37, '왝'}, {0x38, '왠'}, {0x39, '왬'}, {0x3A, '왯'}, {0x3B, '왱'}, {0x3C, '외'}, {0x3D, '왹'}, {0x3E, '왼'}, {0x3F, '욀'},
{0x40, '욈'}, {0x41, '욉'}, {0x42, '욋'}, {0x43, '욍'}, {0x44, '요'}, {0x45, '욕'}, {0x46, '욘'}, {0x47, '욜'}, {0x48, '욤'}, {0x49, '욥'}, {0x4A, '욧'}, {0x4B, '용'}, {0x4C, '우'}, {0x4D, '욱'}, {0x4E, '운'}, {0x4F, '울'},
{0x60, '욹'}, {0x61, '욺'}, {0x62, '움'}, {0x63, '웁'}, {0x64, '웃'}, {0x65, '웅'}, {0x66, '워'}, {0x67, '웍'}, {0x68, '원'}, {0x69, '월'}, {0x6A, '웜'}, {0x6B, '웝'}, {0x6C, '웠'}, {0x6D, '웡'}, {0x6E, '웨'},
{0x71, '웩'}, {0x72, '웬'}, {0x73, '웰'}, {0x74, '웸'}, {0x75, '웹'}, {0x76, '웽'}, {0x77, '위'}, {0x78, '윅'}, {0x79, '윈'}, {0x7A, '윌'}, {0x7B, '윔'}, {0x7C, '윕'}, {0x7D, '윗'}, {0x7E, '윙'}, {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, '젊'},
{0xD1, '점'}, {0xD2, '접'}, {0xD3, '젓'}, {0xD4, '정'}, {0xD5, '젖'}, {0xD6, '제'}, {0xD7, '젝'}, {0xD8, '젠'}, {0xD9, '젤'}, {0xDA, '젬'}, {0xDB, '젭'}, {0xDC, '젯'}, {0xDD, '젱'}, {0xDE, '져'}, {0xDF, '젼'},
{0xE0, '졀'}, {0xE1, '졈'}, {0xE2, '졉'}, {0xE3, '졌'}, {0xE4, '졍'}, {0xE5, '졔'}, {0xE6, '조'}, {0xE7, '족'}, {0xE8, '존'}, {0xE9, '졸'}, {0xEA, '졺'}, {0xEB, '좀'}, {0xEC, '좁'}, {0xED, '좃'}, {0xEE, '종'}, {0xEF, '좆'},
{0xF0, '좇'}, {0xF1, '좋'}, {0xF2, '좌'}, {0xF3, '좍'}, {0xF4, '좔'}, {0xF5, '좝'}, {0xF6, '좟'}, {0xF7, '좡'}, {0xF8, '좨'}, {0xF9, '좼'}, {0xFA, '좽'}, {0xFB, '죄'}, {0xFC, '죈'}, {0xFD, '죌'}, {0xFE, '죔'}, {0xFF, '죕'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_8 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x00, '죗'}, {0x01, '죙'}, {0x02, '죠'}, {0x03, '죡'}, {0x04, '죤'}, {0x05, '죵'}, {0x06, '주'}, {0x07, '죽'}, {0x08, '준'}, {0x09, '줄'}, {0x0A, '줅'}, {0x0B, '줆'}, {0x0C, '줌'}, {0x0D, '줍'}, {0x0E, '줏'}, {0x0F, '중'},
{0x10, '줘'}, {0x11, '줬'}, {0x12, '줴'}, {0x13, '쥐'}, {0x14, '쥑'}, {0x15, '쥔'}, {0x16, '쥘'}, {0x17, '쥠'}, {0x18, '쥡'}, {0x19, '쥣'}, {0x1A, '쥬'}, {0x1B, '쥰'}, {0x1C, '쥴'}, {0x1D, '쥼'}, {0x1E, '즈'}, {0x1F, '즉'},
{0x20, '즌'}, {0x21, '즐'}, {0x22, '즘'}, {0x23, '즙'}, {0x24, '즛'}, {0x25, '증'}, {0x26, '지'}, {0x27, '직'}, {0x28, '진'}, {0x29, '짇'}, {0x2A, '질'}, {0x2B, '짊'}, {0x2C, '짐'}, {0x2D, '집'}, {0x2E, '짓'},
{0x30, '쬬'}, {0x31, '징'}, {0x32, '짖'}, {0x33, '짙'}, {0x34, '짚'}, {0x35, '짜'}, {0x36, '짝'}, {0x37, '짠'}, {0x38, '짢'}, {0x39, '짤'}, {0x3A, '짧'}, {0x3B, '짬'}, {0x3C, '짭'}, {0x3D, '짯'}, {0x3E, '짰'}, {0x3F, '짱'},
{0x40, '째'}, {0x41, '짹'}, {0x42, '짼'}, {0x43, '쨀'}, {0x44, '쨈'}, {0x45, '쨉'}, {0x46, '쨋'}, {0x47, '쨌'}, {0x48, '쨍'}, {0x49, '쨔'}, {0x4A, '쨘'}, {0x4B, '쨩'}, {0x4C, '쩌'}, {0x4D, '쩍'}, {0x4E, '쩐'}, {0x4F, '쩔'},
{0x60, '쩜'}, {0x61, '쩝'}, {0x62, '쩟'}, {0x63, '쩠'}, {0x64, '쩡'}, {0x65, '쩨'}, {0x66, '쩽'}, {0x67, '쪄'}, {0x68, '쪘'}, {0x69, '쪼'}, {0x6A, '쪽'}, {0x6B, '쫀'}, {0x6C, '쫄'}, {0x6D, '쫌'}, {0x6E, '쫍'}, {0x6F, '쫏'},
{0x70, '쫑'}, {0x71, '쫓'}, {0x72, '쫘'}, {0x73, '쫙'}, {0x74, '쫠'}, {0x75, '쫬'}, {0x76, '쫴'}, {0x77, '쬈'}, {0x78, '쬐'}, {0x79, '쬔'}, {0x7A, '쬘'}, {0x7B, '쬠'}, {0x7C, '쬡'}, {0x7D, '쭁'}, {0x7E, '쭈'}, {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, '찻'},
{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, '춤'}, {0xE4, '춥'}, {0xE5, '춧'}, {0xE6, '충'}, {0xE7, '춰'}, {0xE8, '췄'}, {0xE9, '췌'}, {0xEA, '췐'}, {0xEB, '취'}, {0xEC, '췬'}, {0xED, '췰'}, {0xEE, '췸'}, {0xEF, '췹'},
{0xF0, '췻'}, {0xF1, '췽'}, {0xF2, '츄'}, {0xF3, '츈'}, {0xF4, '츌'}, {0xF5, '츔'}, {0xF6, '츙'}, {0xF7, '츠'}, {0xF8, '측'}, {0xF9, '츤'}, {0xFA, '츨'}, {0xFB, '츰'}, {0xFC, '츱'}, {0xFD, '츳'}, {0xFE, '층'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_9 = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x01, '치'}, {0x02, '칙'}, {0x03, '친'}, {0x04, '칟'}, {0x05, '칠'}, {0x06, '칡'}, {0x07, '침'}, {0x08, '칩'}, {0x09, '칫'}, {0x0A, '칭'}, {0x0B, '카'}, {0x0C, '칵'}, {0x0D, '칸'}, {0x0E, '칼'}, {0x0F, '캄'},
{0x10, '캅'}, {0x11, '캇'}, {0x12, '캉'}, {0x13, '캐'}, {0x14, '캑'}, {0x15, '캔'}, {0x16, '캘'}, {0x17, '캠'}, {0x18, '캡'}, {0x19, '캣'}, {0x1A, '캤'}, {0x1B, '캥'}, {0x1C, '캬'}, {0x1D, '캭'}, {0x1E, '컁'}, {0x1F, '커'},
{0x20, '컥'}, {0x21, '컨'}, {0x22, '컫'}, {0x23, '컬'}, {0x24, '컴'}, {0x25, '컵'}, {0x26, '컷'}, {0x27, '컸'}, {0x28, '컹'}, {0x29, '케'}, {0x2A, '켁'}, {0x2B, '켄'}, {0x2C, '켈'}, {0x2D, '켐'}, {0x2E, '켑'}, {0x2F, '켓'},
{0x30, '켕'}, {0x31, '켜'}, {0x32, '켠'}, {0x33, '켤'}, {0x34, '켬'}, {0x35, '켭'}, {0x36, '켯'}, {0x37, '켰'}, {0x38, '켱'}, {0x39, '켸'}, {0x3A, '코'}, {0x3B, '콕'}, {0x3C, '콘'}, {0x3D, '콜'}, {0x3E, '콤'}, {0x3F, '콥'},
{0x40, '콧'}, {0x41, '콩'}, {0x42, '콰'}, {0x43, '콱'}, {0x44, '콴'}, {0x45, '콸'}, {0x46, '쾀'}, {0x47, '쾅'}, {0x48, '쾌'}, {0x49, '쾡'}, {0x4A, '쾨'}, {0x4B, '쾰'}, {0x4C, '쿄'}, {0x4D, '쿠'}, {0x4E, '쿡'}, {0x4F, '쿤'},
{0x60, '쿨'}, {0x61, '쿰'}, {0x62, '쿱'}, {0x63, '쿳'}, {0x64, '쿵'}, {0x65, '쿼'}, {0x66, '퀀'}, {0x67, '퀄'}, {0x68, '퀑'}, {0x69, '퀘'}, {0x6A, '퀭'}, {0x6B, '퀴'}, {0x6C, '퀵'}, {0x6D, '퀸'}, {0x6E, '퀼'},
{0x71, '큄'}, {0x72, '큅'}, {0x73, '큇'}, {0x74, '큉'}, {0x75, '큐'}, {0x76, '큔'}, {0x77, '큘'}, {0x78, '큠'}, {0x79, '크'}, {0x7A, '큭'}, {0x7B, '큰'}, {0x7C, '클'}, {0x7D, '큼'}, {0x7E, '큽'}, {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, '퉜'},
{0xD1, '퉤'}, {0xD2, '튀'}, {0xD3, '튁'}, {0xD4, '튄'}, {0xD5, '튈'}, {0xD6, '튐'}, {0xD7, '튑'}, {0xD8, '튕'}, {0xD9, '튜'}, {0xDA, '튠'}, {0xDB, '튤'}, {0xDC, '튬'}, {0xDD, '튱'}, {0xDE, '트'}, {0xDF, '특'},
{0xE0, '튼'}, {0xE1, '튿'}, {0xE2, '틀'}, {0xE3, '틂'}, {0xE4, '틈'}, {0xE5, '틉'}, {0xE6, '틋'}, {0xE7, '틔'}, {0xE8, '틘'}, {0xE9, '틜'}, {0xEA, '틤'}, {0xEB, '틥'}, {0xEC, '티'}, {0xED, '틱'}, {0xEE, '틴'}, {0xEF, '틸'},
{0xF0, '팀'}, {0xF1, '팁'}, {0xF2, '팃'}, {0xF3, '팅'}, {0xF4, '파'}, {0xF5, '팍'}, {0xF6, '팎'}, {0xF7, '판'}, {0xF8, '팔'}, {0xF9, '팖'}, {0xFA, '팜'}, {0xFB, '팝'}, {0xFC, '팟'}, {0xFD, '팠'}, {0xFE, '팡'}, {0xFF, '팥'},
};
Pre-allocate some dictionary sizes Skips the bucket array resizing steps a 256 key dict will garbage 5KB; StringConverter2KOR wastes 100KB of garbage. Zukan7b: save 144 bytes and eliminate cctor
2023-03-05 04:00:27 +00:00
private static readonly Dictionary<byte, char> GSC2U_KOR_A = new(256)
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
{
{0x00, '패'}, {0x01, '팩'}, {0x02, '팬'}, {0x03, '팰'}, {0x04, '팸'}, {0x05, '팹'}, {0x06, '팻'}, {0x07, '팼'}, {0x08, '팽'}, {0x09, '퍄'}, {0x0A, '퍅'}, {0x0B, '퍼'}, {0x0C, '퍽'}, {0x0D, '펀'}, {0x0E, '펄'}, {0x0F, '펌'},
{0x10, '펍'}, {0x11, '펏'}, {0x12, '펐'}, {0x13, '펑'}, {0x14, '페'}, {0x15, '펙'}, {0x16, '펜'}, {0x17, '펠'}, {0x18, '펨'}, {0x19, '펩'}, {0x1A, '펫'}, {0x1B, '펭'}, {0x1C, '펴'}, {0x1D, '편'}, {0x1E, '펼'}, {0x1F, '폄'},
{0x20, '폅'}, {0x21, '폈'}, {0x22, '평'}, {0x23, '폐'}, {0x24, '폘'}, {0x25, '폡'}, {0x26, '폣'}, {0x27, '포'}, {0x28, '폭'}, {0x29, '폰'}, {0x2A, '폴'}, {0x2B, '폼'}, {0x2C, '폽'}, {0x2D, '폿'}, {0x2E, '퐁'},
{0x31, '퐈'}, {0x32, '퐝'}, {0x33, '푀'}, {0x34, '푄'}, {0x35, '표'}, {0x36, '푠'}, {0x37, '푤'}, {0x38, '푭'}, {0x39, '푯'}, {0x3A, '푸'}, {0x3B, '푹'}, {0x3C, '푼'}, {0x3D, '푿'}, {0x3E, '풀'}, {0x3F, '풂'},
{0x40, '품'}, {0x41, '풉'}, {0x42, '풋'}, {0x43, '풍'}, {0x44, '풔'}, {0x45, '풩'}, {0x46, '퓌'}, {0x47, '퓐'}, {0x48, '퓔'}, {0x49, '퓜'}, {0x4A, '퓟'}, {0x4B, '퓨'}, {0x4C, '퓬'}, {0x4D, '퓰'}, {0x4E, '퓸'}, {0x4F, '퓻'},
{0x60, '퓽'}, {0x61, '프'}, {0x62, '픈'}, {0x63, '플'}, {0x64, '픔'}, {0x65, '픕'}, {0x66, '픗'}, {0x67, '피'}, {0x68, '픽'}, {0x69, '핀'}, {0x6A, '필'}, {0x6B, '핌'}, {0x6C, '핍'}, {0x6D, '핏'}, {0x6E, '핑'}, {0x6F, '하'},
{0x70, '학'}, {0x71, '한'}, {0x72, '할'}, {0x73, '핥'}, {0x74, '함'}, {0x75, '합'}, {0x76, '핫'}, {0x77, '항'}, {0x78, '해'}, {0x79, '핵'}, {0x7A, '핸'}, {0x7B, '핼'}, {0x7C, '햄'}, {0x7D, '햅'}, {0x7E, '햇'}, {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, '혠'},
{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, '흇'}, {0xE4, '흉'}, {0xE5, '흐'}, {0xE6, '흑'}, {0xE7, '흔'}, {0xE8, '흖'}, {0xE9, '흗'}, {0xEA, '흘'}, {0xEB, '흙'}, {0xEC, '흠'}, {0xED, '흡'}, {0xEE, '흣'}, {0xEF, '흥'},
{0xF0, '흩'}, {0xF1, '희'}, {0xF2, '흰'}, {0xF3, '흴'}, {0xF4, '흼'}, {0xF5, '흽'}, {0xF6, '힁'}, {0xF7, '히'}, {0xF8, '힉'}, {0xF9, '힌'}, {0xFA, '힐'}, {0xFB, '힘'}, {0xFC, '힙'}, {0xFD, '힛'}, {0xFE, '힝'},
};
private static readonly Dictionary<byte, char> GSC2U_KOR_B = GSC2U_KOR_0;
/// <summary> Unicode codepoint => Gen2 value dictionary pages. </summary>
private static readonly Dictionary<char, byte>[] U2GSC_KOR =
{
U2GSC_KOR_0, U2GSC_KOR_1, U2GSC_KOR_2, U2GSC_KOR_3,
U2GSC_KOR_4, U2GSC_KOR_5, U2GSC_KOR_6, U2GSC_KOR_7,
U2GSC_KOR_8, U2GSC_KOR_9, U2GSC_KOR_A, U2GSC_KOR_B,
};
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
Refactoring: Span-based value writes and method signatures (#3361) Existing `get`/`set` logic is flawed in that it doesn't work on Big Endian operating systems, and it allocates heap objects when it doesn't need to. `System.Buffers.Binary.BinaryPrimitives` in the `System.Memory` NuGet package provides both Little Endian and Big Endian methods to read and write data; all the `get`/`set` operations have been reworked to use this new API. This removes the need for PKHeX's manual `BigEndian` class, as all functions are already covered by the BinaryPrimitives API. The `StringConverter` has now been rewritten to accept a Span to read from & write to, no longer requiring a temporary StringBuilder. Other Fixes included: - The Super Training UI for Gen6 has been reworked according to the latest block structure additions. - Cloning a Stadium2 Save File now works correctly (opening from the Folder browser list). - Checksum & Sanity properties removed from parent PKM class, and is now implemented via interface.
2022-01-03 05:35:59 +00:00
/// <summary> Gen2 value => Unicode codepoint dictionary pages. </summary>
private static readonly Dictionary<byte, char>[] GSC2U_KOR =
{
GSC2U_KOR_0, GSC2U_KOR_1, GSC2U_KOR_2, GSC2U_KOR_3,
GSC2U_KOR_4, GSC2U_KOR_5, GSC2U_KOR_6, GSC2U_KOR_7,
GSC2U_KOR_8, GSC2U_KOR_9, GSC2U_KOR_A, GSC2U_KOR_B,
};
#endregion
Inline some string logic, extract magic values, xmldoc
2021-03-10 05:31:53 +00:00
}
Reference in a new issue Copy permalink