Leahnaya/Switch-Gift-Data-Manager
1
0
Fork 0
mirror of https://github.com/Manu098vm/Switch-Gift-Data-Manager.git synced 2026-08-22 19:04:40 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

push to github

Browse Source
This commit is contained in:
Manu
2022-11-02 22:49:00 +01:00
parent 79556c3909
commit 75fd9ea7f1
48 changed files with 12281 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
.editorconfig Normal file
View File

@@ -0,0 +1,83 @@
[*.cs]
# Default severity for analyzer diagnostics with category 'Style'
dotnet_analyzer_diagnostic.category-Style.severity = none
csharp_indent_labels = one_less_than_current
csharp_using_directive_placement = outside_namespace:silent
csharp_prefer_simple_using_statement = true:suggestion
csharp_prefer_braces = true:silent
csharp_style_namespace_declarations = block_scoped:silent
csharp_style_prefer_method_group_conversion = true:silent
csharp_style_expression_bodied_methods = false:silent
csharp_style_expression_bodied_constructors = false:silent
csharp_style_expression_bodied_operators = false:silent
csharp_style_expression_bodied_properties = true:silent
csharp_style_expression_bodied_indexers = true:silent
csharp_style_expression_bodied_accessors = true:silent
csharp_style_expression_bodied_lambdas = true:silent
csharp_style_expression_bodied_local_functions = false:silent
csharp_space_around_binary_operators = before_and_after
[*.{cs,vb}]
dotnet_style_operator_placement_when_wrapping = beginning_of_line
tab_width = 4
indent_size = 4
end_of_line = crlf
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
dotnet_style_prefer_auto_properties = true:silent
dotnet_style_object_initializer = true:suggestion
dotnet_style_collection_initializer = true:suggestion
dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
dotnet_style_prefer_conditional_expression_over_assignment = true:silent
dotnet_style_prefer_conditional_expression_over_return = true:silent
dotnet_style_explicit_tuple_names = true:suggestion
[*.{cs,vb}]
#### Naming styles ####
# Naming rules
dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.types_should_be_pascal_case.symbols = types
dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
# Symbol specifications
dotnet_naming_symbols.interface.applicable_kinds = interface
dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
dotnet_naming_symbols.interface.required_modifiers =
dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
dotnet_naming_symbols.types.required_modifiers =
dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
dotnet_naming_symbols.non_field_members.required_modifiers =
# Naming styles
dotnet_naming_style.begins_with_i.required_prefix = I
dotnet_naming_style.begins_with_i.required_suffix =
dotnet_naming_style.begins_with_i.word_separator =
dotnet_naming_style.begins_with_i.capitalization = pascal_case
dotnet_naming_style.pascal_case.required_prefix =
dotnet_naming_style.pascal_case.required_suffix =
dotnet_naming_style.pascal_case.word_separator =
dotnet_naming_style.pascal_case.capitalization = pascal_case
dotnet_naming_style.pascal_case.required_prefix =
dotnet_naming_style.pascal_case.required_suffix =
dotnet_naming_style.pascal_case.word_separator =
dotnet_naming_style.pascal_case.capitalization = pascal_case
dotnet_style_prefer_inferred_tuple_names = true:suggestion

4
.gitignore vendored Normal file
View File

@@ -0,0 +1,4 @@
.git
.vs
**/bin
**/obj

68
README.md Normal file
View File

@@ -0,0 +1,68 @@
# Switch Gift Data Manager
## About
This tool aims to make past Mystery Gift event contents back again in all the Pokémon games for Nintendo Switch.
Since those games won't allow event injection in the SAV file, this tool creates a forged BCAT package, injectable with homebrews like [JKSV](https://github.com/J-D-K/JKSV/releases).
This does not involve hacking the game ROM nor hacking the game SAV.
### Compatible files:
* Let's Go Pikachu and Let's Go Eevee wondercard full files (.wb7full)
* Sword and Shield wondercard files (.wc8)
* Brilliant Diamond and Shining Pearl wondercard files (.wb8)
* Legends Arceus wondercard files (.wa8)
### Compatible games:
* Pokémon Let's Go Pikachu and Eevee
* Pokémon Sword and Shield
* Pokémon Brilliant Diamond and Shining Pearl
* Pokémon Legends Arceus
* A support for Pokémon Scarlet and Violet is planned for the future - no guarantee here - don't ask for eta.
## Disclosure
Neither I nor the Project Pokémon staff takes any responsibility for possible adverse outcomes or bans due to the use of this tool. Use at your own discretion.
## Usage
This paragraph refers to the Windows Form app. The Command Line app usage is similar and should be fairly intuitive.
* Ensure to have the required [.NET 6.0 runtimes](https://dotnet.microsoft.com/en-us/download/dotnet/6.0) correctly installed
* Dump your game's BCAT with [JKSV](https://github.com/J-D-K/JKSV/releases) and keep some copies somewhere safe
* Open the tool and select your game of choice
* Import wondercard files of your choice (by drag & drop or by clicking the `Open Files` button)
* Eventually edit the wondercard id (WCID) if you have duplicated WCs and click `Apply`
* Click the `Save as BCAT Package` button and browse to your dumped BCAT
* A folder called "Forged_BCAT_{Game}" should appear next to your dumped BCAT
* Restore the Forged Bcat with JKSV and enjoy the old events
* When you're done, restore your original BCAT package with JKSV (not doing so may cause sync issues)
If you find any bug or you need support, please write in the relevant topic in the Project Pokémon forums.
Alternatively, feel free to contact me on Discord by DMs (SkyLink98#5946 - **only for bug reports**) or in my [server](https://discord.gg/F9nMfvw9sS).
## Building
* All the Switch Gift Data Manager projects require .NET 6.0.
* .WinForm is a Windows Form application and can only be built in Windows Operating Systems.
* .Core and .CommandLine can be built in any platform OS.
* Use the Debug build configuration when editing or developing code related to the .WinForm project. Build as Release only once the code is complete.
* The .CommandLine project is currently just a simple script that calls the .Core functions and can run in any OS. Feel free to improve it and/or submit a pull request if you'd like :-)
## Credits
* [kwsch](https://github.com/kwsch), [sora10pls](https://github.com/sora10pls) and all the [PKHeX](https://github.com/kwsch/PKHeX) and [pkNX](https://github.com/kwsch/pkNX) devs and contributors
for a lot of offsets and resources
* [PP-theSLAYER](https://github.com/PP-theSLAYER) for his researches in the Sword and Shield fashion block and for the clothing names resources
* All the Project Pokémon Staff and the [Event Gallery](https://github.com/projectpokemon/EventsGallery) contributors for their archival efforts that made this possible
## License
![gplv3-with-text-136x68](https://user-images.githubusercontent.com/52102823/199572700-4e02ed70-74ef-4d67-991e-3168d93aac0d.png)
Copyright © 2022 Manu098vm
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

222
SwitchGiftDataManager.CommandLine/Program.cs Normal file
View File

@@ -0,0 +1,222 @@
using SwitchGiftDataManager.Core;
using Enums;
namespace SwitchGiftDataManager.CommandLine
{
public static class Program
{
public static void Main()
{
var msg = "Switch Gift Data Manager v1.0.0";
Log(msg);
msg = $"{Environment.NewLine}Select your game:{Environment.NewLine}{Environment.NewLine}" +
$"1 - LGPE{Environment.NewLine}" +
$"2 - SWSH{Environment.NewLine}" +
$"3 - BDSP{Environment.NewLine}" +
$"4 - PLA{Environment.NewLine}" +
$"5 - SCVI";
Log(msg);
Games game = (Games)int.Parse(Console.ReadLine()!);
if(game is Games.None || game > Games.SCVI)
{
Log("Invalid input. Aborted.");
Console.ReadKey();
return;
}
else if(game is Games.SCVI)
{
Log("Scarlet and Violet are still not supported by this program. Please wait patiently.");
Console.ReadKey();
return;
}
var bcat = new BCATManager(game);
msg = $"{Environment.NewLine}Enter a valid input path.{Environment.NewLine}{Environment.NewLine}The path can be either:{Environment.NewLine}" +
$"- A direct (full) path to a wondercard file{Environment.NewLine}" +
$"- A (full) path to a folder containing wondercard files";
Log(msg);
var path = Console.ReadLine()!;
if (File.Exists(path))
bcat.TryAddWondercards(File.ReadAllBytes(path));
else if (CheckValidPath(path))
foreach(var file in Directory.GetFiles(path))
if (!bcat.TryAddWondercards(File.ReadAllBytes(file)))
Log($"{file} could not be loaded.");
if (bcat.Count() <= 0)
{
Log("No valid files have been loaded. Aborted.");
Console.ReadKey();
return;
}
bcat.Sort();
Log($"{Environment.NewLine}Enter the source (full) path to your dumped BCAT:");
var sourcepath = Console.ReadLine()!;
if(!CheckValidBcatPath(sourcepath))
{
Log("Not a valid BCAT folder path. Aborted.");
Console.ReadKey();
return;
}
Log($"{Environment.NewLine}Enter a destination (full) path to save the forged BCAT:");
var destpath = Console.ReadLine()!;
if (!CheckValidPath(destpath))
{
Log("Not a valid path. Aborted.");
Console.ReadKey();
return;
}
if (game is not Games.LGPE)
{
msg = $"{Environment.NewLine}Select a build option:{Environment.NewLine}{Environment.NewLine}" +
$"1 - Merge as one file{Environment.NewLine}" +
$"2 - Keep separate files";
Log(msg);
}
var opt = game is not Games.LGPE ? int.Parse(Console.ReadLine()!) : 2;
if(opt < 1 || opt > 2)
{
Log("Invalid input. Aborted.");
Console.ReadKey();
return;
}
destpath = $"{destpath}\\Forged_BCAT_{game}";
CopyDirectory(sourcepath, destpath);
if (opt == 1)
{
try
{
var wcdata = bcat.ConcatenateFiles();
var metadata = bcat.ForgeMetaInfo(wcdata.ToArray());
var metadatapath = $"{destpath}\\directories\\{bcat.GetDefaultBcatFolderName()}";
var wcpath = $"{metadatapath}\\files";
if (Directory.Exists(metadatapath))
DeleteFilesAndDirectory(metadatapath);
Directory.CreateDirectory(wcpath);
File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray());
File.WriteAllBytes($"{wcpath}\\{bcat.GetDefaultBcatFileName()}", wcdata.ToArray());
Log("Done. Press any key to exit...");
Console.ReadKey();
}
catch (Exception)
{
Log("Internal Error. Press any key to exit...");
Console.ReadKey();
}
}
else
{
var metadata = bcat.ForgeMetaInfo();
var metadatapath = $"{destpath}\\directories\\{bcat.GetDefaultBcatFolderName()}";
var wcspath = $"{metadatapath}\\files";
if (Directory.Exists(metadatapath))
DeleteFilesAndDirectory(metadatapath);
Directory.CreateDirectory(wcspath);
File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray());
if (bcat.TrySaveAllWondercards(wcspath))
{
Log("Done. Press any key to exit...");
Console.ReadKey();
}
else
{
Log("Internal error. Press any key to exit...");
Console.ReadKey();
}
}
return;
}
private static bool CheckValidPath(string path)
{
if (string.IsNullOrWhiteSpace(path))
return false;
if (!Directory.Exists(path))
return false;
return true;
}
private static bool CheckValidBcatPath(string path)
{
if (string.IsNullOrWhiteSpace(path))
return false;
if (!Directory.Exists($"{path}\\directories"))
return false;
if (!File.Exists($"{path}\\directories.meta"))
return false;
if (!File.Exists($"{path}\\etag.bin"))
return false;
if (!File.Exists($"{path}\\list.msgpack"))
return false;
if (!File.Exists($"{path}\\na_required"))
return false;
if (!File.Exists($"{path}\\passphrase.bin"))
return false;
return true;
}
static void CopyDirectory(string source, string dest)
{
var dir = new DirectoryInfo(source);
DirectoryInfo[] dirs = dir.GetDirectories();
Directory.CreateDirectory(dest);
foreach (FileInfo file in dir.GetFiles())
{
string targetFilePath = Path.Combine(dest, file.Name);
if (!File.Exists(targetFilePath))
file.CopyTo(targetFilePath);
}
foreach (DirectoryInfo subDir in dirs)
{
string newDestinationDir = Path.Combine(dest, subDir.Name);
CopyDirectory(subDir.FullName, newDestinationDir);
}
}
private static void DeleteFilesAndDirectory(string targetDir)
{
string[] files = Directory.GetFiles(targetDir);
string[] dirs = Directory.GetDirectories(targetDir);
foreach (string file in files)
{
File.SetAttributes(file, FileAttributes.Normal);
File.Delete(file);
}
foreach (string dir in dirs)
DeleteFilesAndDirectory(dir);
Directory.Delete(targetDir, false);
}
private static void Log(string msg) => Console.WriteLine(msg);
}
}

48
SwitchGiftDataManager.CommandLine/SwitchGiftDataManager.CommandLine.csproj Normal file
View File

@@ -0,0 +1,48 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<Authors>Manu098vm</Authors>
<Copyright>Copyright (C) 2022 Manu098vm</Copyright>
<PackageReadmeFile>README.md</PackageReadmeFile>
<PackageTags>pokemon; mystery gift; wondercard; reader; nintendo; bcat; event injection;</PackageTags>
<PackageLicenseFile>LICENSE</PackageLicenseFile>
<Company>Project Pokémon</Company>
<PackageProjectUrl>https://github.com/Manu098vm/Switch-Gift-Data-Manager</PackageProjectUrl>
<RepositoryUrl>https://github.com/Manu098vm/Switch-Gift-Data-Manager</RepositoryUrl>
<RepositoryType>git</RepositoryType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<ItemGroup>
<None Include="..\README.md">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<None Include="..\LICENSE">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SwitchGiftDataManager.Core\SwitchGiftDataManager.Core.csproj">
<Private>True</Private>
<CopyLocalSatelliteAssemblies>True</CopyLocalSatelliteAssemblies>
</ProjectReference>
</ItemGroup>
</Project>

324
SwitchGiftDataManager.Core/Classes/BCATManager/BCATManager.cs Normal file
View File

@@ -0,0 +1,324 @@
using System.Buffers.Binary;
using Enums;
namespace SwitchGiftDataManager.Core
{
public class BCATManager
{
private const int FileNameOffset = 0x00;
private const int UnkOffset = 0x20;
private const int FileSizeOffset = 0x28;
private const int ChecksumOffset = 0x30;
private const int MaxFileNameLength = 0x1F;
private const int WCMetaInfoLength = 0x80;
private const int MetaHeaderLength = 0x04;
private Games Game { get; set; }
private List<Wondercard>? WCList { get; set; }
public BCATManager(Games game)
{
Game = game;
WCList = new();
}
private Wondercard CreateWondercard(ReadOnlySpan<byte> data)
{
return Game switch
{
Games.LGPE => new WB7(data),
Games.SWSH => new WC8(data),
Games.BDSP => new WB8(data),
Games.PLA => new WA8(data),
//Games.SCVI => new WC9(data),
_ => throw new ArgumentOutOfRangeException(),
};
}
public bool TryAddWondercards(ReadOnlySpan<byte> data, bool sort = false)
{
var success = false;
if (Game is not Games.None && WCList is not null)
if (Game is not Games.LGPE || (Game is Games.LGPE && WCList.Count == 0))
{
var game = GetCompatibleGamesFromWC(data);
if (game == Game)
{
var size = (int)Wondercard.GetSize(game);
var qty = data.Length / size;
for (int i = 0; i < qty; i++)
{
var wc = CreateWondercard(data[(i * size)..((i + 1) * size)]);
if (wc.IsValid())
{
WCList.Add(wc);
success = true;
}
}
}
if (sort)
Sort();
}
return success;
}
public void Sort() => WCList!.Sort((x, y) => x.WCID.CompareTo(y.WCID));
public int Count()
{
if (WCList is not null)
return WCList.Count;
return 0;
}
public void RemoveWC(int index)
{
if (WCList is not null && WCList.Count > 0 && WCList.Count >= index - 1)
WCList.RemoveAt(index);
}
public void Reset()
{
if(WCList is not null)
WCList.Clear();
else
WCList = new List<Wondercard>();
}
public void SetWCID(int index, ushort wcid)
{
if (WCList is not null && WCList.Count >= index && WCList.Count >= index)
{
var wc = WCList.ElementAt(index);
wc.SetID(wcid);
wc.UpdateChecksum();
}
}
public ushort GetWCID(int index)
{
if (WCList is not null && WCList.Count >= index && WCList.Count >= index)
return WCList.ElementAt(index).WCID;
return 0;
}
public int GetIndex(ushort wcid)
{
if (WCList is not null && WCList.Count > 0)
return WCList.FindIndex((x) => x.WCID == wcid);
else
throw new IndexOutOfRangeException();
}
public static Games GetCompatibleGamesFromWC(ReadOnlySpan<byte> data)
{
if (data.Length % (int)Wondercard.GetSize(Games.LGPE) == 0)
return Games.LGPE;
else if (data.Length % (int)Wondercard.GetSize(Games.SWSH) == 0)
return Games.SWSH;
else if (data.Length % (int)Wondercard.GetSize(Games.BDSP) == 0)
return Games.BDSP;
else if (data.Length % (int)Wondercard.GetSize(Games.PLA) == 0)
return Games.PLA;
else if (data.Length % (int)Wondercard.GetSize(Games.SCVI) == 0)
return Games.SCVI;
else
return Games.None;
}
public List<string> GetListNames()
{
List<string> list = new();
if (WCList is not null && WCList.Count > 0)
foreach (var wc in WCList)
{
var str = wc.Type!.ToString()!.Equals("Pokemon") ? ((PokemonGift)wc.Content!).GetSpeciesName() : ((List<OtherGift>)wc.Content!)[0].Type!.ToString()!;
list.Add($"{Game} #{wc.WCID}: {str}");
}
return list;
}
public List<string> GetContentToString(int index)
{
var wcid = "";
var el1 = "";
var el2 = "";
var el3 = "";
var el4 = "";
var el5 = "";
if (WCList is not null && WCList.Count > 0 && WCList.Count >= index - 1)
{
var wc = WCList.ElementAt(index);
wcid = wc.WCID.ToString();
var content = wc.Content;
if (content!.GetType() == typeof(PokemonGift))
{
var c = (PokemonGift)content;
el1 = c.ShinyType.ToString();
el2 = c.GetSpeciesName();
el3 = c.PIDType.ToString();
}
else if (content!.GetType() == typeof(List<OtherGift>))
{
foreach (var c in (List<OtherGift>)content)
{
var item = c.GetItemName();
var qty = c.Quantity;
var str = $"{item.Replace("BP", "Battle Points")}";
if (qty != 0x0 && qty != 0xFFFF)
str = $"{str} x{qty}";
if (el1.Equals(""))
el1 = str;
else if (el2.Equals(""))
el2 = str;
else if (el3.Equals(""))
el3 = str;
else if (el4.Equals(""))
el4 = str;
else if (el5.Equals(""))
el5 = str;
}
}
}
return new List<string> { wcid, el1, el2, el3, el4, el5 };
}
public List<ushort>? GetDuplicatedWCID()
{
if (WCList is not null && WCList.Count > 1)
{
var l = WCList.GroupBy(x => x.WCID)
.Where(g => g.Count() > 1)
.Select(y => y.Key)
.ToList();
return l;
}
else
return new List<ushort>();
}
public string GetDefaultBcatFolderName() => GetDefaultBcatFolderName(this.Game);
public string GetDefaultBcatFileName() => GetDefaultBcatFileName(this.Game);
public static string GetDefaultBcatFolderName(Games game)
{
return game switch
{
Games.LGPE => "normal",
Games.SWSH => "normal",
Games.BDSP => "99",
Games.PLA => "normal",
_ => throw new ArgumentOutOfRangeException(),
};
}
public static string GetDefaultBcatFileName(Games game)
{
return game switch
{
Games.SWSH => "distribution_internet",
Games.BDSP => "99",
Games.PLA => "distribution_internet",
_ => throw new ArgumentOutOfRangeException(),
};
}
public bool TrySaveAllWondercards(string path)
{
if (WCList is null || WCList.Count == 0)
return false;
for (int i = 0; i < WCList.Count; i++)
if (!TrySaveWondercard(i, path))
return false;
return true;
}
public bool TrySaveWondercard(int index, string path)
{
try
{
var wc = WCList!.ElementAt(index);
File.WriteAllBytes($"{path}\\{ForgeWcFileName(wc)}", wc.Data!);
return true;
}
catch (Exception)
{
return false;
}
}
public ReadOnlySpan<byte> ConcatenateFiles()
{
var size = (int)Wondercard.GetSize(Game);
var data = new byte[size * WCList!.Count];
foreach (var el in WCList!.Select((wc, i) => new { i, wc }))
el.wc.Data!.CopyTo(data, el.i * size);
return data.AsSpan();
}
private string ForgeWcFileName(Wondercard wc)
{
var type = wc.Type!.ToString()!;
var content = type.Equals("Pokemon") ? $"{((PokemonGift)wc.Content!).GetSpeciesName()}" : type;
var str = $"{wc.WCID:0000}_{content}";
System.Text.StringBuilder sb = new();
foreach (char c in str)
if (c != '\\' && c != '/' && c != ':' && c != '*' && c != '?' && c != '"' && c != '<' && c != '>' && c != '|')
sb.Append(c);
return sb.ToString().ToLower();
}
public ReadOnlySpan<byte> ForgeMetaInfo(object? data = null)
{
if (data is not null && data.GetType() == typeof(byte[]))
{
var fileName = System.Text.Encoding.UTF8.GetBytes(GetDefaultBcatFileName());
var unknown = 0xFFFFFFFF;
var fileSize = (uint)((byte[])data).Length;
var checksum = ChecksumCalculator.CalcReverseMD5((byte[])data);
var metainfo = new byte[WCMetaInfoLength];
fileName.CopyTo(metainfo, FileNameOffset);
BinaryPrimitives.WriteUInt32LittleEndian(metainfo.AsSpan(UnkOffset), unknown);
BinaryPrimitives.WriteUInt32LittleEndian(metainfo.AsSpan(FileSizeOffset), fileSize);
checksum.ToArray().CopyTo(metainfo, ChecksumOffset);
return ForgeMetaInfoHeader(metainfo);
}
else
{
var metainfo = new byte[WCMetaInfoLength * WCList!.Count];
foreach (var el in WCList!.Select((wc, i) => new { i, wc }))
ForgeWcMetaInfo(el.wc).ToArray().CopyTo(metainfo, el.i * WCMetaInfoLength);
return ForgeMetaInfoHeader(metainfo);
}
}
private ReadOnlySpan<byte> ForgeWcMetaInfo(Wondercard wc)
{
var fileName = System.Text.Encoding.UTF8.GetBytes(ForgeWcFileName(wc));
var unknown = 0xFFFFFFFF;
var fileSize = (uint)Wondercard.GetSize(Game);
var checksum = wc.CalcMetaChecksum();
var data = new byte[WCMetaInfoLength];
fileName.CopyTo(data, FileNameOffset);
BinaryPrimitives.WriteUInt32LittleEndian(data.AsSpan(UnkOffset), unknown);
BinaryPrimitives.WriteUInt32LittleEndian(data.AsSpan(FileSizeOffset), fileSize);
checksum.ToArray().CopyTo(data, ChecksumOffset);
return data.AsSpan();
}
private ReadOnlySpan<byte> ForgeMetaInfoHeader(ReadOnlySpan<byte> data)
{
uint header = 0x1;
byte[] filesDotMeta = new byte[data.Length + MetaHeaderLength];
BinaryPrimitives.WriteUInt32LittleEndian(filesDotMeta.AsSpan(), header);
data.ToArray().CopyTo(filesDotMeta, MetaHeaderLength);
return filesDotMeta.AsSpan();
}
}
}

77
SwitchGiftDataManager.Core/Classes/WCManager/ChecksumCalculator.cs Normal file
View File

@@ -0,0 +1,77 @@
using System.Security.Cryptography;
//Credits for the CalcCcittFalse implementation to PNZEmil: https://gist.github.com/tijnkooijmans/10981093?permalink_comment_id=3996072#gistcomment-3996072
namespace SwitchGiftDataManager.Core
{
public static class ChecksumCalculator
{
private const ushort InitialValue = 0xFFFF;
private static readonly ushort[] ccittFalseCrc16Table = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};
public static ushort CalcCcittFalse(ReadOnlySpan<byte> bytes)
{
var crc16 = InitialValue;
var length = bytes.Length;
var byteIndex = 0;
while (length-- > 0)
{
var tableIndex = crc16 >> 8 ^ bytes[byteIndex++];
crc16 = (ushort)(crc16 << 8 ^ ccittFalseCrc16Table[tableIndex]);
}
return crc16;
}
public static Span<byte> CalcReverseMD5(byte[] data)
{
var md5 = MD5.Create().ComputeHash(data);
var tmp1 = md5.AsSpan((md5.Length / 2)..);
tmp1.Reverse();
var tmp2 = md5.AsSpan(0..(md5.Length / 2));
tmp2.Reverse();
var b = new byte[md5.Length];
tmp2.ToArray().CopyTo(b, 0);
tmp1.ToArray().CopyTo(b, tmp1.Length);
return b.AsSpan();
}
}
}

90
SwitchGiftDataManager.Core/Classes/WCManager/GiftData/OtherGift.cs Normal file
View File

@@ -0,0 +1,90 @@
using Enums;
namespace SwitchGiftDataManager.Core
{
public class OtherGift
{
public object? Type { get; set; }
public ushort Item { get; set; }
public ushort Quantity { get; set; }
public ushort Opt { get; set; }
public string GetItemName() => GetItemName(Item, Type!, Opt);
public static string GetItemName(ushort id, object type, ushort opt = 0)
{
var str = "";
if (type.GetType() == typeof(GiftType7))
{
if ((GiftType7)type is GiftType7.Item)
str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id];
else
str = ((GiftType7)type).ToString();
}
else if (type.GetType() == typeof(GiftType8))
{
if ((GiftType8)type is GiftType8.Item)
str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id];
else if ((GiftType8)type is GiftType8.Clothing)
{
var category = (ClothingType8)id;
var description = category switch
{
ClothingType8.Glasses => Properties.Resources.SWSHClothingGlasses.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Hats => Properties.Resources.SWSHClothingHats.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Jackets => Properties.Resources.SWSHClothingJackets.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Tops => Properties.Resources.SWSHClothingTops.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Bags => Properties.Resources.SWSHClothingBags.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Gloves => Properties.Resources.SWSHClothingGloves.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Bottoms => Properties.Resources.SWSHClothingBottoms.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Legwear => Properties.Resources.SWSHClothingLegwear.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8.Shoes => Properties.Resources.SWSHClothingShoes.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
_ => throw new ArgumentOutOfRangeException(),
};
str = $"[{category}] {description}";
}
else
str = ((GiftType8)type).ToString();
}
else if(type.GetType() == typeof(GiftType8B))
{
if ((GiftType8B)type is GiftType8B.Item)
str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id];
else if ((GiftType8B)type is GiftType8B.Clothing)
str = Properties.Resources.BDSPClothing.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id];
else if ((GiftType8B)type is GiftType8B.Underground)
str = Properties.Resources.UndergroundItems.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id];
else
str = ((GiftType8B)type).ToString();
}
else if (type.GetType() == typeof(GiftType8A))
{
if ((GiftType8A)type is GiftType8A.Item)
str = Properties.Resources.Items.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[id];
else if ((GiftType8A)type is GiftType8A.Clothing)
{
var category = (ClothingType8A)id;
var description = category switch
{
ClothingType8A.Heads => Properties.Resources.PLAClothingHeads.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8A.Tops => Properties.Resources.PLAClothingTops.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8A.Bottoms => Properties.Resources.PLAClothingBottoms.Split(new String[] { Environment.NewLine }, StringSplitOptions.None)[opt],
ClothingType8A.Outfit => "",
ClothingType8A.Shoes => "",
ClothingType8A.Glasses => "",
ClothingType8A.Eyes => "",
_ => throw new ArgumentOutOfRangeException(),
};
if(string.IsNullOrWhiteSpace(description))
description = $"{opt:X4}";
str = $"[{category}] {description}";
}
else
str = ((GiftType8A)type).ToString();
}
return str;
}
}
}

39
SwitchGiftDataManager.Core/Classes/WCManager/GiftData/PokemonGift.cs Normal file
View File

@@ -0,0 +1,39 @@
using Enums;
namespace SwitchGiftDataManager.Core
{
public class PokemonGift
{
public ushort Species { get; set; }
public uint PID { get; set; }
public uint TID { get; set; }
public uint SID { get; set; }
public ShinyType ShinyType { get; set; }
public PIDType PIDType { get; set; }
public string GetSpeciesName() => GetSpeciesName(Species);
public bool IsShiny()
{
if (ShinyType is ShinyType.ShinyForced)
return true;
else if (ShinyType is ShinyType.ShinyPossible && PID != 0 && TID != 0 && SID != 0)
return IsShiny(PID, TID, SID);
return false;
}
public static string GetSpeciesName(uint species) => Properties.Resources.Species.Split(new string[] { Environment.NewLine }, StringSplitOptions.None)[species].Replace(",", "");
public static bool IsShiny(uint pid, uint tid, uint sid) => sid != 0 || tid != 0 ? (sid ^ tid ^ (pid >> 16) ^ (pid & 0xFFFF)) < 16 : false;
public static bool IsTIDAbusePossible(uint tid, uint sid, PIDType type)
{
if (type is PIDType.FixedPID)
if (tid == 0)
if (sid == 0)
return true;
return false;
}
}
}

131
SwitchGiftDataManager.Core/Classes/WCManager/WA8.cs Normal file
View File

@@ -0,0 +1,131 @@
using System.Buffers.Binary;
using Enums;
namespace SwitchGiftDataManager.Core
{
internal class WA8 : Wondercard
{
private const int WondercardIDOffset = 0x08;
private const int GiftTypeOffset = 0x0F;
private const int ItemOffset = 0x18;
private const int QuantityOffset = 0x1A;
private const int ClothingOffset = 0x1C;
private const int TIDOffset = 0x18;
private const int SIDOffset = 0x1A;
private const int PIDOffset = 0x24;
private const int SpeciesOffset = 0x238;
private const int ShinyTypeOffset = 0x240;
private const int ChecksumOffset = 0x2C4;
public WA8(ReadOnlySpan<byte> data) : base(data)
{
WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]);
Type = (GiftType8A)Data![GiftTypeOffset];
Content = Type switch
{
GiftType8A.Pokemon => GetPokemon(),
_ => GetItems(),
};
}
private PokemonGift GetPokemon()
{
var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset));
var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset));
var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset));
var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset));
var test = (ShinyType8)Data![ShinyTypeOffset];
var pidtype = (ShinyType8)Data![ShinyTypeOffset] switch
{
ShinyType8.ShinyLocked => PIDType.RandomPID,
ShinyType8.ShinyRandom => PIDType.RandomPID,
ShinyType8.ShinyStar => PIDType.FixedPID,
ShinyType8.ShinySquare => PIDType.FixedPID,
ShinyType8.Fixed => PIDType.FixedPID,
_ => throw new ArgumentOutOfRangeException(),
};
var shinytype = (ShinyType8)Data![ShinyTypeOffset] switch
{
ShinyType8.ShinyLocked => ShinyType.ShinyLocked,
ShinyType8.ShinyRandom => ShinyType.ShinyPossible,
ShinyType8.ShinyStar or ShinyType8.ShinySquare => ShinyType.ShinyForced,
ShinyType8.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced :
PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked,
_ => throw new ArgumentOutOfRangeException(),
};
return new PokemonGift
{
Species = species,
PID = pid,
TID = tid,
SID = sid,
ShinyType = shinytype,
PIDType = pidtype,
};
}
private List<OtherGift> GetItems()
{
List<OtherGift> items = new();
for (int i = 0; i < MaxItemCount; i++)
{
ushort item = 0;
ushort quantity = 0;
ushort opt = 0;
var type = (GiftType8A)Type!;
if (type is GiftType8A.Clothing)
{
item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x08 * i)));
opt = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ClothingOffset + (0x08 * i)));
}
else
{
item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x04 * i)));
quantity = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x04 * i)));
}
var gift = new OtherGift
{
Type = type,
Item = item,
Quantity = quantity,
Opt = opt,
};
if ((type is not GiftType8A.Clothing && gift.Item != 0x00) || (type is GiftType8A.Clothing && opt != 0xFFFF))
items.Add(gift);
}
return items;
}
public override bool IsChecksumValid()
{
if (Data is not null)
{
var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset));
var span = Data.ToArray().AsSpan();
BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0);
var newchecksum = ChecksumCalculator.CalcCcittFalse(span);
if (oldChecksum == newchecksum)
return true;
}
return false;
}
public override void UpdateChecksum()
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0);
var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan());
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum);
}
public override void SetID(ushort wcid)
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid);
WCID = wcid;
UpdateChecksum();
}
}
}

115
SwitchGiftDataManager.Core/Classes/WCManager/WB7.cs Normal file
View File

@@ -0,0 +1,115 @@
using System.Buffers.Binary;
using Enums;
namespace SwitchGiftDataManager.Core
{
internal class WB7 : Wondercard
{
private const int WondercardIDOffset = 0x208;
private const int GiftTypeOffset = 0x259;
private const int ItemOffset = 0x270;
private const int QuantityOffset = 0x272;
private const int TIDOffset = 0x270;
private const int SIDOffset = 0x272;
private const int SpeciesOffset = 0x28A;
private const int ShinyTypeOffset = 0x2AB;
private const int PIDOffset = 0xD4;
private const int ChecksumOffset = 0x202;
public WB7(ReadOnlySpan<byte> data) : base(data)
{
WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]);
Type = (GiftType7)Data![GiftTypeOffset];
Content = Type switch
{
GiftType7.Pokemon => GetPokemon(),
_ => GetItems(),
};
}
private PokemonGift GetPokemon()
{
var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset));
var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset));
var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset));
var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset));
var pidtype = (ShinyType7)Data![ShinyTypeOffset] switch
{
ShinyType7.Fixed => PIDType.FixedPID,
ShinyType7.ShinyRandom => PIDType.RandomPID,
ShinyType7.Shiny => PIDType.RandomPID,
ShinyType7.ShinyLocked => PIDType.RandomPID,
_ => throw new ArgumentOutOfRangeException(),
};
var shinytype = (ShinyType7)Data![ShinyTypeOffset] switch
{
ShinyType7.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced :
PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked,
ShinyType7.ShinyRandom => ShinyType.ShinyPossible,
ShinyType7.Shiny => ShinyType.ShinyForced,
ShinyType7.ShinyLocked => ShinyType.ShinyLocked,
_ => throw new ArgumentOutOfRangeException(),
};
return new PokemonGift
{
Species = species,
PID = pid,
TID = tid,
SID = sid,
ShinyType = shinytype,
PIDType = pidtype,
};
}
private List<OtherGift> GetItems()
{
List<OtherGift> items = new();
for (int i = 0; i < MaxItemCount; i++)
{
var type = (GiftType7)Type!;
var item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x04 * i)));
var quantity = type is GiftType7.BP ? item : BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x04 * i)));
var gift = new OtherGift
{
Type = type,
Item = item,
Quantity = quantity,
};
if (gift.Item != 0)
items.Add(gift);
}
return items;
}
public override bool IsChecksumValid()
{
if (Data is not null)
{
var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset));
var span = Data.ToArray().AsSpan();
BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0);
var newchecksum = ChecksumCalculator.CalcCcittFalse(span);
if (oldChecksum == newchecksum)
return true;
}
return false;
}
public override void UpdateChecksum()
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0);
var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan());
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum);
}
public override void SetID(ushort wcid)
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid);
WCID = wcid;
UpdateChecksum();
}
}
}

117
SwitchGiftDataManager.Core/Classes/WCManager/WB8.cs Normal file
View File

@@ -0,0 +1,117 @@
using System.Buffers.Binary;
using Enums;
namespace SwitchGiftDataManager.Core
{
internal class WB8 : Wondercard
{
private const int WondercardIDOffset = 0x08;
private const int GiftTypeOffset = 0x11;
private const int ItemOffset = 0x20;
private const int QuantityOffset = 0x22;
private const int TIDOffset = 0x20;
private const int SIDOffset = 0x22;
private const int PIDOffset = 0x2C;
private const int SpeciesOffset = 0x288;
private const int ShinyTypeOffset = 0x290;
private const int ChecksumOffset = 0x2D0;
public WB8(ReadOnlySpan<byte> data) : base(data)
{
WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]);
Type = (GiftType8B)Data![GiftTypeOffset];
Content = Type switch
{
GiftType8B.Pokemon => GetPokemon(),
_ => GetItems(),
};
}
private PokemonGift GetPokemon()
{
var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset));
var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset));
var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset));
var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset));
var test = (ShinyType8)Data![ShinyTypeOffset];
var pidtype = (ShinyType8)Data![ShinyTypeOffset] switch
{
ShinyType8.ShinyLocked => PIDType.RandomPID,
ShinyType8.ShinyRandom => PIDType.RandomPID,
ShinyType8.ShinyStar => PIDType.FixedPID,
ShinyType8.ShinySquare => PIDType.FixedPID,
ShinyType8.Fixed => PIDType.FixedPID,
_ => throw new ArgumentOutOfRangeException(),
};
var shinytype = (ShinyType8)Data![ShinyTypeOffset] switch
{
ShinyType8.ShinyLocked => ShinyType.ShinyLocked,
ShinyType8.ShinyRandom => ShinyType.ShinyPossible,
ShinyType8.ShinyStar or ShinyType8.ShinySquare => ShinyType.ShinyForced,
ShinyType8.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced :
PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked,
_ => throw new ArgumentOutOfRangeException(),
};
return new PokemonGift
{
Species = species,
PID = pid,
TID = tid,
SID = sid,
ShinyType = shinytype,
PIDType = pidtype,
};
}
private List<OtherGift> GetItems()
{
List<OtherGift> items = new();
for (int i = 0; i < MaxItemCount; i++)
{
var type = (GiftType8B)Type!;
var item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x10 * i)));
var quantity = type is GiftType8B.BP or GiftType8B.Money ? item : BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x10 * i)));
var gift = new OtherGift
{
Type = Type,
Item = item,
Quantity = quantity,
};
if (gift.Item != 0)
items.Add(gift);
}
return items;
}
public override bool IsChecksumValid()
{
if (Data is not null)
{
var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset));
var span = Data.ToArray().AsSpan();
BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0);
var newchecksum = ChecksumCalculator.CalcCcittFalse(span);
if (oldChecksum == newchecksum)
return true;
}
return false;
}
public override void UpdateChecksum()
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0);
var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan());
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum);
}
public override void SetID(ushort wcid)
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid);
WCID = wcid;
UpdateChecksum();
}
}
}

131
SwitchGiftDataManager.Core/Classes/WCManager/WC8.cs Normal file
View File

@@ -0,0 +1,131 @@
using System.Buffers.Binary;
using Enums;
namespace SwitchGiftDataManager.Core
{
internal class WC8 : Wondercard
{
private const int WondercardIDOffset = 0x08;
private const int GiftTypeOffset = 0x11;
private const int ItemOffset = 0x20;
private const int QuantityOffset = 0x22;
private const int ClothingOffset = 0x24;
private const int TIDOffset = 0x20;
private const int SIDOffset = 0x22;
private const int PIDOffset = 0x2C;
private const int SpeciesOffset = 0x240;
private const int ShinyTypeOffset = 0x248;
private const int ChecksumOffset = 0x2CC;
public WC8(ReadOnlySpan<byte> data) : base(data)
{
WCID = BinaryPrimitives.ReadUInt16LittleEndian(data[WondercardIDOffset..]);
Type = (GiftType8)Data![GiftTypeOffset];
Content = Type switch
{
GiftType8.Pokemon => GetPokemon(),
_ => GetItems(),
};
}
private PokemonGift GetPokemon()
{
var species = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SpeciesOffset));
var pid = BinaryPrimitives.ReadUInt32LittleEndian(Data.AsSpan(PIDOffset));
var tid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(TIDOffset));
var sid = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(SIDOffset));
var test = (ShinyType8)Data![ShinyTypeOffset];
var pidtype = (ShinyType8)Data![ShinyTypeOffset] switch
{
ShinyType8.ShinyLocked => PIDType.RandomPID,
ShinyType8.ShinyRandom => PIDType.RandomPID,
ShinyType8.ShinyStar => PIDType.FixedPID,
ShinyType8.ShinySquare => PIDType.FixedPID,
ShinyType8.Fixed => PIDType.FixedPID,
_ => throw new ArgumentOutOfRangeException(),
};
var shinytype = (ShinyType8)Data![ShinyTypeOffset] switch
{
ShinyType8.ShinyLocked => ShinyType.ShinyLocked,
ShinyType8.ShinyRandom => ShinyType.ShinyPossible,
ShinyType8.ShinyStar or ShinyType8.ShinySquare => ShinyType.ShinyForced,
ShinyType8.Fixed => PokemonGift.IsShiny(pid, tid, sid) ? ShinyType.ShinyForced :
PokemonGift.IsTIDAbusePossible(tid, sid, pidtype) ? ShinyType.ShinyTIDAbuse : ShinyType.ShinyLocked,
_ => throw new ArgumentOutOfRangeException(),
};
return new PokemonGift
{
Species = species,
PID = pid,
TID = tid,
SID = sid,
ShinyType = shinytype,
PIDType = pidtype,
};
}
private List<OtherGift> GetItems()
{
List<OtherGift> items = new();
for (int i = 0; i < MaxItemCount; i++)
{
ushort item = 0;
ushort quantity = 0;
ushort opt = 0;
var type = (GiftType8)Type!;
if (type is GiftType8.Clothing)
{
item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x08 * i)));
opt = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ClothingOffset + (0x08 * i)));
}
else
{
item = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ItemOffset + (0x04 * i)));
quantity = type is GiftType8.BP or GiftType8.Money ? item : BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(QuantityOffset + (0x04 * i)));
}
var gift = new OtherGift
{
Type = type,
Item = item,
Quantity = quantity,
Opt = opt,
};
if (gift.Item != 0x00 && opt != 0xFFFF)
items.Add(gift);
}
return items;
}
public override bool IsChecksumValid()
{
if (Data is not null)
{
var oldChecksum = BinaryPrimitives.ReadUInt16LittleEndian(Data.AsSpan(ChecksumOffset));
var span = Data.ToArray().AsSpan();
BinaryPrimitives.WriteUInt16LittleEndian(span[ChecksumOffset..], 0x0);
var newchecksum = ChecksumCalculator.CalcCcittFalse(span);
if (oldChecksum == newchecksum)
return true;
}
return false;
}
public override void UpdateChecksum()
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), 0x0);
var checksum = ChecksumCalculator.CalcCcittFalse(Data.AsSpan());
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(ChecksumOffset), checksum);
}
public override void SetID(ushort wcid)
{
BinaryPrimitives.WriteUInt16LittleEndian(Data.AsSpan(WondercardIDOffset), wcid);
WCID = wcid;
UpdateChecksum();
}
}
}

64
SwitchGiftDataManager.Core/Classes/WCManager/Wondercard.cs Normal file
View File

@@ -0,0 +1,64 @@
using Enums;
namespace SwitchGiftDataManager.Core
{
internal abstract class Wondercard
{
protected const int MaxItemCount = 5;
public Games Game { get; }
public ushort WCID { get; protected set; }
public object? Type { get; protected set; }
public object? Content { get; protected set; }
public byte[]? Data { get; protected set; }
public Wondercard(ReadOnlySpan<byte> data)
{
Game = (WondercardSize)data.Length switch
{
WondercardSize.WB7 => Games.LGPE,
WondercardSize.WC8 => Games.SWSH,
WondercardSize.WB8 => Games.BDSP,
WondercardSize.WA8 => Games.PLA,
WondercardSize.WC9 => Games.SCVI,
_ => Games.None,
};
Data = data.ToArray();
}
public bool IsValid()
{
if (WCID <= 0)
return false;
if (Content is null)
return false;
if (!IsChecksumValid())
UpdateChecksum();
return true;
}
public ReadOnlySpan<byte> CalcMetaChecksum() => ChecksumCalculator.CalcReverseMD5(Data!);
public abstract bool IsChecksumValid();
public abstract void UpdateChecksum();
public abstract void SetID(ushort wcid);
public static WondercardSize GetSize(Games game)
{
return game switch
{
Games.LGPE => WondercardSize.WB7,
Games.SWSH => WondercardSize.WC8,
Games.BDSP => WondercardSize.WB8,
Games.PLA => WondercardSize.WA8,
Games.SCVI => WondercardSize.WC9,
_ => throw new ArgumentOutOfRangeException(),
};
}
}
}

120
SwitchGiftDataManager.Core/Enums/Enums.cs Normal file
View File

@@ -0,0 +1,120 @@
namespace Enums {
public enum Games : int
{
None = 0,
LGPE = 1,
SWSH = 2,
BDSP = 3,
PLA = 4,
SCVI = 5,
}
public enum WCType
{
Pokemon,
Item,
}
internal enum WondercardSize : ushort
{
WB7 = 0x310,
WC8 = 0x2D0,
WB8 = 0x2DC,
WA8 = 0x2C8,
WC9 = 0x2D1, //Placeholder
}
internal enum GiftType7 : byte
{
Pokemon = 0,
Item = 1,
Bean = 2,
BP = 3,
}
internal enum GiftType8 : byte
{
None = 0,
Pokemon = 1,
Item = 2,
BP = 3,
Clothing = 4,
Money = 5,
}
internal enum GiftType8B : byte
{
None = 0,
Pokemon = 1,
Item = 2,
BP = 3,
Clothing = 4,
Money = 5,
Underground = 6,
}
internal enum GiftType8A : byte
{
None = 0,
Pokemon = 1,
Item = 2,
Clothing = 3,
}
public enum PIDType
{
RandomPID,
FixedPID,
}
public enum ShinyType
{
ShinyLocked,
ShinyPossible,
ShinyForced,
ShinyTIDAbuse,
}
internal enum ShinyType7 : byte
{
Fixed = 0,
ShinyRandom = 1,
Shiny = 2,
ShinyLocked = 3,
}
internal enum ShinyType8 : byte
{
ShinyLocked = 0,
ShinyRandom = 1,
ShinyStar = 2,
ShinySquare = 3,
Fixed = 4,
}
internal enum ClothingType8: byte
{
Glasses = 0x06,
Hats = 0x07,
Jackets = 0x08,
Tops = 0x09,
Bags = 0x0A,
Gloves = 0x0B,
Bottoms = 0x0C,
Legwear = 0x0D,
Shoes = 0x0E,
None = 0xFF,
}
internal enum ClothingType8A: byte
{
Heads = 0x00,
Tops = 0x01,
Bottoms = 0x02,
Outfit = 0x03,
Shoes = 0x5,
Glasses = 0x06,
Eyes = 0x08,
None = 0xFF,
}
}

849
SwitchGiftDataManager.Core/Properties/Resources.Designer.cs generated Normal file
View File

@@ -0,0 +1,849 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace SwitchGiftDataManager.Core.Properties {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SwitchGiftDataManager.Core.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to Tops
///Outerwear
///Pikachu Hoodie Style
///Platinum Style
///Overalls Style
///Eevee Jacket Style
///Cyber Style
///Summer Style
///Winter Style
///Spring Style
///Casual Style
///Leather Jacket Style
///Contest Style
///Gengar Jacket Style
///Everyday Style
///.
/// </summary>
internal static string BDSPClothing {
get {
return ResourceManager.GetString("BDSPClothing", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to None
///Master Ball
///Ultra Ball
///Great Ball
///Poké Ball
///Safari Ball
///Net Ball
///Dive Ball
///Nest Ball
///Repeat Ball
///Timer Ball
///Luxury Ball
///Premier Ball
///Dusk Ball
///Heal Ball
///Quick Ball
///Cherish Ball
///Potion
///Antidote
///Burn Heal
///Ice Heal
///Awakening
///Paralyze Heal
///Full Restore
///Max Potion
///Hyper Potion
///Super Potion
///Full Heal
///Revive
///Max Revive
///Fresh Water
///Soda Pop
///Lemonade
///Moomoo Milk
///Energy Powder
///Energy Root
///Heal Powder
///Revival Herb
///Ether
///Max Ether
///Elixir
///Max Elixir
///Lava Cookie
///Berry Juice [rest of string was truncated]&quot;;.
/// </summary>
internal static string Items {
get {
return ResourceManager.GetString("Items", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to None
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///Fancy Bottoms (Oshawott)
///Fancy Bottoms (Cyndaquil)
///Fancy Bottoms (Rowlet)
///Fancy Bottoms (Typhlosion)
///Fancy Bottoms (Samurott)
///Fancy Bottoms (Decidueye)
///Fancy Bottoms (Gyarados)
///Fancy Bottoms (Cherrim)
///Fancy Bottoms (Seascape)
///Fancy Bottoms (Mountainscape)
///Fancy Bottoms (Townscape)
///Fancy Bottoms (Spiritomb)
///Fancy Bottoms (Honchkrow)
/// [rest of string was truncated]&quot;;.
/// </summary>
internal static string PLAClothingBottoms {
get {
return ResourceManager.GetString("PLAClothingBottoms", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to None
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///Baneful Fox Mask (White lily)
///Baneful Fox Mask (Shiny).
/// </summary>
internal static string PLAClothingHeads {
get {
return ResourceManager.GetString("PLAClothingHeads", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to None
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///
///Fancy Kimono (Oshawott)
///Fancy Kimono (Cyndaquil)
///Fancy Kimono (Rowlet)
///Fancy Kimono (Typhlosion)
///Fancy Kimono (Samurott)
///Fancy Kimono (Decidueye)
///Fancy Kimono (Gyarados)
///Fancy Kimono (Cherrim)
///Fancy Kimono (Seascape)
///Fancy Kimono (Mountainscape)
///Fancy Kimono (Townscape)
///Fancy Kimono (Spiritomb)
///Fancy Kimono (Honchkrow)
///Fancy Kimono [rest of string was truncated]&quot;;.
/// </summary>
internal static string PLAClothingTops {
get {
return ResourceManager.GetString("PLAClothingTops", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to None,
///Bulbasaur,
///Ivysaur,
///Venusaur,
///Charmander,
///Charmeleon,
///Charizard,
///Squirtle,
///Wartortle,
///Blastoise,
///Caterpie,
///Metapod,
///Butterfree,
///Weedle,
///Kakuna,
///Beedrill,
///Pidgey,
///Pidgeotto,
///Pidgeot,
///Rattata,
///Raticate,
///Spearow,
///Fearow,
///Ekans,
///Arbok,
///Pikachu,
///Raichu,
///Sandshrew,
///Sandslash,
///NidoranF,
///Nidorina,
///Nidoqueen,
///NidoranM,
///Nidorino,
///Nidoking,
///Clefairy,
///Clefable,
///Vulpix,
///Ninetales,
///Jigglypuff,
///Wigglytuff,
///Zubat,
///Golbat,
///Oddish,
///Gloom,
///Vileplume,
///Paras,
///Parasect,
///Venon [rest of string was truncated]&quot;;.
/// </summary>
internal static string Species {
get {
return ResourceManager.GetString("Species", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport Travel Bag (Iconic Style)
///Sport Travel Bag (Challenger Kit)
///Sport Travel Bag (Grass Type)
///Sport Travel Bag (Water Type)
///Sport Travel Bag (Fire Type)
///Sport Travel Bag (Ghost Type)
///Sport Travel Bag (Fighting Type)
///Sport Travel Bag (Fairy Type)
///Sport Travel Bag (Rock Type)
///Sport Travel Bag (Ice Type)
///Sport Travel Bag (Dark Type)
///Sport Travel Bag (Dragon Type)
///Sport Travel Bag (Bug Type)
///Sport Travel Bag (Steel Type)
///Sport Travel Bag (Psychic Type)
///Sport Travel Bag (Electric Type)
///Sport Tr [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingBags {
get {
return ResourceManager.GetString("SWSHClothingBags", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport Shorts (Challenger Kit)
///Sport Shorts (Grass Type)
///Sport Shorts (Water Type)
///Sport Shorts (Fire Type)
///Sport Shorts (Ghost Type)
///Sport Shorts (Fighting Type)
///Sport Shorts (Fairy Type)
///Sport Shorts (Rock Type)
///Sport Shorts (Ice Type)
///Sport Shorts (Dark Type)
///Sport Shorts (Dragon Type)
///Sport Shorts (Bug Type)
///Sport Shorts (Steel Type)
///Sport Shorts (Psychic Type)
///Sport Shorts (Electric Type)
///Sport Shorts (Ground Type)
///Sport Shorts (Flying Type)
///Sport Shorts (Normal Type)
///Sport Shorts (Poi [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingBottoms {
get {
return ResourceManager.GetString("SWSHClothingBottoms", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport Sunglasses (Iconic Style)
///Sport Sunglasses (Challenger Kit)
///Sport Sunglasses (Grass Type)
///Sport Sunglasses (Water Type)
///Sport Sunglasses (Fire Type)
///Sport Sunglasses (Ghost Type)
///Sport Sunglasses (Fighting Type)
///Sport Sunglasses (Fairy Type)
///Sport Sunglasses (Rock Type)
///Sport Sunglasses (Ice Type)
///Sport Sunglasses (Dark Type)
///Sport Sunglasses (Dragon Type)
///Sport Sunglasses (Bug Type)
///Sport Sunglasses (Steel Type)
///Sport Sunglasses (Psychic Type)
///Sport Sunglasses (Electric Type)
///Sport Su [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingGlasses {
get {
return ResourceManager.GetString("SWSHClothingGlasses", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to (empty) (Bare)
///Sport Glove (Challenger Kit)
///Sport Glove (Grass Type)
///Sport Glove (Water Type)
///Sport Glove (Fire Type)
///Sport Glove (Ghost Type)
///Sport Glove (Fighting Type)
///Sport Glove (Fairy Type)
///Sport Glove (Rock Type)
///Sport Glove (Ice Type)
///Sport Glove (Dark Type)
///Sport Glove (Dragon Type)
///Sport Glove (Bug Type)
///Sport Glove (Steel Type)
///Sport Glove (Psychic Type)
///Sport Glove (Electric Type)
///Sport Glove (Ground Type)
///Sport Glove (Flying Type)
///Sport Glove (Normal Type)
///Sport Glove (Poison [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingGloves {
get {
return ResourceManager.GetString("SWSHClothingGloves", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport Cap (Iconic Style)
///Sport Cap (Challenger Kit)
///Sport Cap (Grass Type)
///Sport Cap (Water Type)
///Sport Cap (Fire Type)
///Sport Cap (Ghost Type)
///Sport Cap (Fighting Type)
///Sport Cap (Fairy Type)
///Sport Cap (Rock Type)
///Sport Cap (Ice Type)
///Sport Cap (Dark Type)
///Sport Cap (Dragon Type)
///Sport Cap (Bug Type)
///Sport Cap (Steel Type)
///Sport Cap (Psychic Type)
///Sport Cap (Electric Type)
///Sport Cap (Ground Type)
///Sport Cap (Flying Type)
///Sport Cap (Normal Type)
///Sport Cap (Poison Type)
///Scally Cap (White)
/// [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingHats {
get {
return ResourceManager.GetString("SWSHClothingHats", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Tracksuit Jacket (Iconic Style)
///Tracksuit Jacket (Challenger Kit)
///Tracksuit Jacket (Grass Type)
///Tracksuit Jacket (Water Type)
///Tracksuit Jacket (Fire Type)
///Tracksuit Jacket (Ghost Type)
///Tracksuit Jacket (Fighting Type)
///Tracksuit Jacket (Fairy Type)
///Tracksuit Jacket (Rock Type)
///Tracksuit Jacket (Ice Type)
///Tracksuit Jacket (Dark Type)
///Tracksuit Jacket (Dragon Type)
///Tracksuit Jacket (Bug Type)
///Tracksuit Jacket (Steel Type)
///Tracksuit Jacket (Psychic Type)
///Tracksuit Jacket (Electric Type)
///Tracksui [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingJackets {
get {
return ResourceManager.GetString("SWSHClothingJackets", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport Legwear (Challenger Kit)
///Sport Legwear (Grass Type)
///Sport Legwear (Water Type)
///Sport Legwear (Fire Type)
///Sport Legwear (Ghost Type)
///Sport Legwear (Fighting Type)
///Sport Legwear (Fairy Type)
///Sport Legwear (Rock Type)
///Sport Legwear (Ice Type)
///Sport Legwear (Dark Type)
///Sport Legwear (Dragon Type)
///Sport Legwear (Bug Type)
///Sport Legwear (Steel Type)
///Sport Legwear (Psychic Type)
///Sport Legwear (Electric Type)
///Sport Legwear (Ground Type)
///Sport Legwear (Flying Type)
///Sport Legwear (Normal Type)
/// [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingLegwear {
get {
return ResourceManager.GetString("SWSHClothingLegwear", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport High-Tops (Challenger Kit)
///Sport High-Tops (Grass Type)
///Sport High-Tops (Water Type)
///Sport High-Tops (Fire Type)
///Sport High-Tops (Ghost Type)
///Sport High-Tops (Fighting Type)
///Sport High-Tops (Fairy Type)
///Sport High-Tops (Rock Type)
///Sport High-Tops (Ice Type)
///Sport High-Tops (Dark Type)
///Sport High-Tops (Dragon Type)
///Sport High-Tops (Bug Type)
///Sport High-Tops (Steel Type)
///Sport High-Tops (Psychic Type)
///Sport High-Tops (Electric Type)
///Sport High-Tops (Ground Type)
///Sport High-Tops (Flying T [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingShoes {
get {
return ResourceManager.GetString("SWSHClothingShoes", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Sport Top (Challenger Kit)
///Sport Top (Grass Type)
///Sport Top (Water Type)
///Sport Top (Fire Type)
///Sport Top (Ghost Type)
///Sport Top (Fighting Type)
///Sport Top (Fairy Type)
///Sport Top (Rock Type)
///Sport Top (Ice Type)
///Sport Top (Dark Type)
///Sport Top (Dragon Type)
///Sport Top (Bug Type)
///Sport Top (Steel Type)
///Sport Top (Psychic Type)
///Sport Top (Electric Type)
///Sport Top (Ground Type)
///Sport Top (Flying Type)
///Sport Top (Normal Type)
///Sport Top (Poison Type)
///Sport Top (Reigning Champion)
///Sport Top (Pika [rest of string was truncated]&quot;;.
/// </summary>
internal static string SWSHClothingTops {
get {
return ResourceManager.GetString("SWSHClothingTops", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to None
///Red Sphere S
///Blue Sphere S
///Green Sphere S
///Prism Sphere S
///Pale Sphere S
///Red Sphere L
///Blue Sphere L
///Green Sphere L
///Prism Sphere L
///Pale Sphere L
///Revive
///Max Revive
///Red Shard
///Blue Shard
///Yellow Shard
///Green Shard
///Sun Stone
///Moon Stone
///Fire Stone
///Thunder Stone
///Water Stone
///Leaf Stone
///Oval Stone
///Everstone
///Odd Keystone
///Star Piece
///Heart Scale
///Root Fossil
///Claw Fossil
///Helix Fossil
///Dome Fossil
///Old Amber
///Armor Fossil
///Skull Fossil
///Rare Bone
///Light Clay
///Iron Ball
///Icy Rock
///Smooth Rock [rest of string was truncated]&quot;;.
/// </summary>
internal static string UndergroundItems {
get {
return ResourceManager.GetString("UndergroundItems", resourceCulture);
}
}

169
SwitchGiftDataManager.Core/Properties/Resources.resx Normal file
View File

@@ -0,0 +1,169 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="BDSPClothing" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\BDSPClothing.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="Items" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\Items.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="PLAClothingBottoms" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\PLAClothingBottoms.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="PLAClothingHeads" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\PLAClothingHeads.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="PLAClothingTops" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\PLAClothingTops.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="Species" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\Species.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
<data name="SWSHClothingBags" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingBags.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingBottoms" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingBottoms.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingGlasses" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingGlasses.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingGloves" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingGloves.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingHats" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingHats.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingJackets" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingJackets.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingLegwear" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingLegwear.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingShoes" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingShoes.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="SWSHClothingTops" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\SWSHClothingTops.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
</data>
<data name="UndergroundItems" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\UndergroundItems.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
</data>
</root>

15
SwitchGiftDataManager.Core/Resources/BDSPClothing.txt Normal file
View File

@@ -0,0 +1,15 @@
Tops
Outerwear
Pikachu Hoodie Style
Platinum Style
Overalls Style
Eevee Jacket Style
Cyber Style
Summer Style
Winter Style
Spring Style
Casual Style
Leather Jacket Style
Contest Style
Gengar Jacket Style
Everyday Style

1829
SwitchGiftDataManager.Core/Resources/Items.txt Normal file
View File

File diff suppressed because it is too large Load Diff

256
SwitchGiftDataManager.Core/Resources/PLAClothingBottoms.txt Normal file
View File

@@ -0,0 +1,256 @@
None
Fancy Bottoms (Oshawott)
Fancy Bottoms (Cyndaquil)
Fancy Bottoms (Rowlet)
Fancy Bottoms (Typhlosion)
Fancy Bottoms (Samurott)
Fancy Bottoms (Decidueye)
Fancy Bottoms (Gyarados)
Fancy Bottoms (Cherrim)
Fancy Bottoms (Seascape)
Fancy Bottoms (Mountainscape)
Fancy Bottoms (Townscape)
Fancy Bottoms (Spiritomb)
Fancy Bottoms (Honchkrow)
Fancy Bottoms (Garchomp)
Fancy Bottoms (Heatran)
Fancy Bottoms (Cresselia)
Fancy Bottoms (Darkrai)
Fancy Bottoms (Regigigas)
Fancy Bottoms (Shaymin)
Fancy Bottoms (Giratina)
Fancy Bottoms (Wyrdeer)
Fancy Bottoms (Kleavor)
Fancy Bottoms (Ursaluna)
Fancy Bottoms (Basculegion)
Fancy Bottoms (Growlithe)
Fancy Bottoms (Lilligant)
Fancy Bottoms (Electrode)
Fancy Bottoms (Sneasler)
Fancy Bottoms (Avalugg)
Fancy Bottoms (Braviary)
Fancy Bottoms (Pikachu)
Fancy Bottoms (Shinx)
Fancy Bottoms (Buneary)
Fancy Bottoms (Pachirisu)
Fancy Bottoms (Happiny)
Fancy Bottoms (Croagunk)
Fancy Bottoms (Goomy)
Fancy Bottoms (Bidoof)
Fancy Bottoms (Sneasel)
Fancy Bottoms (Mime Jr.)

256
SwitchGiftDataManager.Core/Resources/PLAClothingHeads.txt Normal file
View File

@@ -0,0 +1,256 @@
None
Baneful Fox Mask (White lily)
Baneful Fox Mask (Shiny)

256
SwitchGiftDataManager.Core/Resources/PLAClothingTops.txt Normal file
View File

@@ -0,0 +1,256 @@
None
Fancy Kimono (Oshawott)
Fancy Kimono (Cyndaquil)
Fancy Kimono (Rowlet)
Fancy Kimono (Typhlosion)
Fancy Kimono (Samurott)
Fancy Kimono (Decidueye)
Fancy Kimono (Gyarados)
Fancy Kimono (Cherrim)
Fancy Kimono (Seascape)
Fancy Kimono (Mountainscape)
Fancy Kimono (Townscape)
Fancy Kimono (Spiritomb)
Fancy Kimono (Honchkrow)
Fancy Kimono (Garchomp)
Fancy Kimono (Heatran)
Fancy Kimono (Cresselia)
Fancy Kimono (Darkrai)
Fancy Kimono (Regigigas)
Fancy Kimono (Shaymin)
Fancy Kimono (Giratina)
Fancy Kimono (Wyrdeer)
Fancy Kimono (Kleavor)
Fancy Kimono (Ursaluna)
Fancy Kimono (Basculegion)
Fancy Kimono (Growlithe)
Fancy Kimono (Lilligant)
Fancy Kimono (Electrode)
Fancy Kimono (Sneasler)
Fancy Kimono (Avalugg)
Fancy Kimono (Braviary)
Fancy Kimono (Pikachu)
Fancy Kimono (Shinx)
Fancy Kimono (Buneary)
Fancy Kimono (Pachirisu)
Fancy Kimono (Happiny)
Fancy Kimono (Croagunk)
Fancy Kimono (Goomy)
Fancy Kimono (Bidoof)
Fancy Kimono (Sneasel)
Fancy Kimono (Mime Jr.)

57
SwitchGiftDataManager.Core/Resources/SWSHClothingBags.txt Normal file
View File

@@ -0,0 +1,57 @@
Sport Travel Bag (Iconic Style)
Sport Travel Bag (Challenger Kit)
Sport Travel Bag (Grass Type)
Sport Travel Bag (Water Type)
Sport Travel Bag (Fire Type)
Sport Travel Bag (Ghost Type)
Sport Travel Bag (Fighting Type)
Sport Travel Bag (Fairy Type)
Sport Travel Bag (Rock Type)
Sport Travel Bag (Ice Type)
Sport Travel Bag (Dark Type)
Sport Travel Bag (Dragon Type)
Sport Travel Bag (Bug Type)
Sport Travel Bag (Steel Type)
Sport Travel Bag (Psychic Type)
Sport Travel Bag (Electric Type)
Sport Travel Bag (Ground Type)
Sport Travel Bag (Flying Type)
Sport Travel Bag (Normal Type)
Sport Travel Bag (Poison Type)
Canvas Travel Bag (White)
Canvas Travel Bag (Navy)
Canvas Travel Bag (White/Black)
Canvas Travel Bag (White/Blue)
Canvas Travel Bag (White/Red)
Leather-Trimmed Bag (Brown)
Leather-Trimmed Bag (Sand)
Leather-Trimmed Bag (White)
Leather-Trimmed Bag (Maroon)
Leather-Trimmed Bag (White/Brown)
Leather-Trimmed Bag (White/Black)
Plaid Travel Bag (Cream/Green)
Plaid Travel Bag (Cream/Red)
Plaid Travel Bag (Cream/Monotone)
Plaid Travel Bag (Cream/Pink)
Plaid Travel Bag (Cream/Navy)
Plaid Travel Bag (Cream/Yellow)
Canvas Travel Bag (Leppa Laden)
Canvas Travel Bag (Ball Bonanza)
Canvas Travel Bag (Logo Lined)
Studded Leather Case (White)
Studded Leather Case (Black)
Studded Leather Case (Red)
Studded Leather Case (Caramel)
Studded Leather Case (Blue)
Studded Leather Case (Gold)
Studded Leather Case (Brilliant Black)
Studded Leather Case (Harsh Style)
Dojo Travel Bag (Original Style)
Luxury Travel Bag (Black/Red)
Luxury Travel Bag (Black/White)
Luxury Travel Bag (White/Red)
Luxury Travel Bag (White/Black)
Luxury Travel Bag (White)
Luxury Travel Bag (Black)
Expedition Travel Bag (Original Style)
Gold Travel Bag (Original Style)

94
SwitchGiftDataManager.Core/Resources/SWSHClothingBottoms.txt Normal file
View File

@@ -0,0 +1,94 @@
Sport Shorts (Challenger Kit)
Sport Shorts (Grass Type)
Sport Shorts (Water Type)
Sport Shorts (Fire Type)
Sport Shorts (Ghost Type)
Sport Shorts (Fighting Type)
Sport Shorts (Fairy Type)
Sport Shorts (Rock Type)
Sport Shorts (Ice Type)
Sport Shorts (Dark Type)
Sport Shorts (Dragon Type)
Sport Shorts (Bug Type)
Sport Shorts (Steel Type)
Sport Shorts (Psychic Type)
Sport Shorts (Electric Type)
Sport Shorts (Ground Type)
Sport Shorts (Flying Type)
Sport Shorts (Normal Type)
Sport Shorts (Poison Type)
Sport Shorts (Reigning Champion)
Sport Shorts (Pikachu Kit)
Sport Shorts (Eevee Kit)
Sport Shorts (Ranked Battles)
Sport Shorts (Battle Tower)
Trackie Bottoms (Iconic Style)
Trackie Bottoms (Challenger Kit)
Trackie Bottoms (Grass Type)
Trackie Bottoms (Water Type)
Trackie Bottoms (Fire Type)
Trackie Bottoms (Ghost Type)
Trackie Bottoms (Fighting Type)
Trackie Bottoms (Fairy Type)
Trackie Bottoms (Rock Type)
Trackie Bottoms (Ice Type)
Trackie Bottoms (Dark Type)
Trackie Bottoms (Dragon Type)
Trackie Bottoms (Bug Type)
Trackie Bottoms (Steel Type)
Trackie Bottoms (Psychic Type)
Trackie Bottoms (Electric Type)
Trackie Bottoms (Ground Type)
Trackie Bottoms (Flying Type)
Trackie Bottoms (Normal Type)
Trackie Bottoms (Poison Type)
Skinny Trousers (White)
Skinny Trousers (Black)
Skinny Trousers (Red)
Skinny Trousers (Yellow)
Skinny Trousers (Green)
Skinny Trousers (Blue)
Skinny Trousers (Orange)
Skinny Trousers (Navy)
Skinny Trousers (Purple)
Skinny Trousers (Pink)
Skinny Trousers (Gray)
Skinny Trousers (Tan)
Designer Denim (Light Blue)
Designer Denim (Blue)
Designer Denim (Navy)
Designer Denim (Black)
Designer Denim (Faded Black)
Plaid Trousers (Green)
Plaid Trousers (Red)
Plaid Trousers (Monotone)
Plaid Trousers (Pink)
Plaid Trousers (Navy)
Plaid Trousers (Yellow)
Leather Trousers (White)
Leather Trousers (Black)
Leather Trousers (Red)
Leather Trousers (Caramel)
Leather Trousers (Blue)
(?) ((?))
(?) ((?))
(?) ((?))
Dojo Shorts (Original Style)
Punk Trousers (Faded Black)
Punk Trousers (Light Blue)
Punk Trousers (Red)
Dress Pants (White)
Dress Pants (Black)
Dress Pants (Red)
Dress Pants (Yellow)
Dress Pants (Green)
Dress Pants (Blue)
Dress Pants (Orange)
Dress Pants (Navy)
Dress Pants (Purple)
Dress Pants (Pink)
Dress Pants (Gray)
Dress Pants (Tan)
Expedition Pants (Original Style)
Gold Expedition Pants (Original Style)
Sport Shorts (Galarian Star Tournament)

97
SwitchGiftDataManager.Core/Resources/SWSHClothingGlasses.txt Normal file
View File

@@ -0,0 +1,97 @@
Sport Sunglasses (Iconic Style)
Sport Sunglasses (Challenger Kit)
Sport Sunglasses (Grass Type)
Sport Sunglasses (Water Type)
Sport Sunglasses (Fire Type)
Sport Sunglasses (Ghost Type)
Sport Sunglasses (Fighting Type)
Sport Sunglasses (Fairy Type)
Sport Sunglasses (Rock Type)
Sport Sunglasses (Ice Type)
Sport Sunglasses (Dark Type)
Sport Sunglasses (Dragon Type)
Sport Sunglasses (Bug Type)
Sport Sunglasses (Steel Type)
Sport Sunglasses (Psychic Type)
Sport Sunglasses (Electric Type)
Sport Sunglasses (Ground Type)
Sport Sunglasses (Flying Type)
Sport Sunglasses (Normal Type)
Sport Sunglasses (Poison Type)
Square Eyeglasses (White)
Square Eyeglasses (Black)
Square Eyeglasses (Red)
Square Eyeglasses (Yellow)
Square Eyeglasses (Green)
Square Eyeglasses (Blue)
Square Eyeglasses (Orange)
Square Eyeglasses (Navy)
Square Eyeglasses (Purple)
Square Eyeglasses (Pink)
Square Sunglasses (White/Black)
Square Sunglasses (Black/Black)
Square Sunglasses (Red/Black)
Square Sunglasses (Yellow/Black)
Square Sunglasses (Green/Black)
Square Sunglasses (Blue/Black)
Square Sunglasses (Orange/Black)
Square Sunglasses (Navy/Black)
Square Sunglasses (Purple/Black)
Square Sunglasses (Pink/Black)
Half-Rim Eyeglasses (Black)
Half-Rim Eyeglasses (Silver)
Half-Rim Eyeglasses (Gold)
Half-Rim Eyeglasses (Mottled)
Half-Rim Sunglasses (Black/Gray)
Half-Rim Sunglasses (Black/Blue)
Half-Rim Sunglasses (Black/Purple)
Half-Rim Sunglasses (Black/Pink)
Half-Rim Sunglasses (Black/Yellow)
Half-Rim Sunglasses (Black/Brown)
Half-Rim Sunglasses (Silver/Gray)
Half-Rim Sunglasses (Silver/Blue)
Half-Rim Sunglasses (Silver/Purple)
Half-Rim Sunglasses (Silver/Pink)
Half-Rim Sunglasses (Silver/Yellow)
Half-Rim Sunglasses (Silver/Brown)
Half-Rim Sunglasses (Gold/Gray)
Half-Rim Sunglasses (Gold/Blue)
Half-Rim Sunglasses (Gold/Purple)
Half-Rim Sunglasses (Gold/Pink)
Half-Rim Sunglasses (Gold/Yellow)
Half-Rim Sunglasses (Gold/Brown)
Half-Rim Sunglasses (Mottled/Gray)
Half-Rim Sunglasses (Mottled/Blue)
Half-Rim Sunglasses (Mottled/Purple)
Half-Rim Sunglasses (Mottled/Pink)
Half-Rim Sunglasses (Mottled/Yellow)
Half-Rim Sunglasses (Mottled/Brown)
Round Eyeglasses (Black)
Round Eyeglasses (Metal)
Round Eyeglasses (Mottled)
Round Sunglasses (Black/Yellow)
Round Sunglasses (Black/Blue)
Round Sunglasses (Black/Red)
Round Sunglasses (Black/Black)
Round Sunglasses (Metal/Yellow)
Round Sunglasses (Metal/Blue)
Round Sunglasses (Metal/Red)
Round Sunglasses (Metal/Black)
Round Sunglasses (Mottled/Yellow)
Round Sunglasses (Mottled/Blue)
Round Sunglasses (Mottled/Red)
Round Sunglasses (Mottled/Black)
Wraparound Sunglasses (White)
Wraparound Sunglasses (Black)
Wraparound Sunglasses (Mottled)
Wraparound Sunglasses (Red)
Wraparound Sunglasses (Green)
Wraparound Sunglasses (Blue)
Futuristic Shades (Red)
Futuristic Shades (Yellow)
Futuristic Shades (Blue)
Futuristic Shades (White)
Futuristic Monocle (Red)
Futuristic Monocle (Yellow)
Futuristic Monocle (Blue)
Futuristic Monocle (White)

72
SwitchGiftDataManager.Core/Resources/SWSHClothingGloves.txt Normal file
View File

@@ -0,0 +1,72 @@
(empty) (Bare)
Sport Glove (Challenger Kit)
Sport Glove (Grass Type)
Sport Glove (Water Type)
Sport Glove (Fire Type)
Sport Glove (Ghost Type)
Sport Glove (Fighting Type)
Sport Glove (Fairy Type)
Sport Glove (Rock Type)
Sport Glove (Ice Type)
Sport Glove (Dark Type)
Sport Glove (Dragon Type)
Sport Glove (Bug Type)
Sport Glove (Steel Type)
Sport Glove (Psychic Type)
Sport Glove (Electric Type)
Sport Glove (Ground Type)
Sport Glove (Flying Type)
Sport Glove (Normal Type)
Sport Glove (Poison Type)
Sport Glove (Reigning Champion)
Sport Glove (Pikachu Kit)
Sport Glove (Eevee Kit)
Sport Glove (Ranked Battles)
Sport Glove (Battle Tower)
Sport Glove (Iconic Style)
Simple Gloves (White)
Simple Gloves (Black)
Simple Gloves (Red)
Simple Gloves (Yellow)
Simple Gloves (Green)
Simple Gloves (Blue)
Simple Gloves (Orange)
Simple Gloves (Navy)
Simple Gloves (Purple)
Simple Gloves (Pink)
Simple Gloves (Gray)
Simple Gloves (Tan)
Plaid Gloves (Green)
Plaid Gloves (Red)
Plaid Gloves (Monotone)
Plaid Gloves (Pink)
Plaid Gloves (Navy)
Plaid Gloves (Yellow)
Patterned Gloves (Eternal Sleep)
Patterned Gloves (Mischief Maker)
Patterned Gloves (Gullet Glam)
Leather Palm Glove (White)
Leather Palm Glove (Black)
Leather Palm Glove (Red)
Leather Palm Glove (Caramel)
Leather Palm Glove (Blue)
Leather Palm Glove (Splashy Pink)
Leather Palm Glove (Red Gas)
Leather Palm Glove (Fresh & Blue)
Dojo Gloves (Original Style)
Punk Gloves (Black)
Expedition Gloves (Original Style)
Gold Expedition Gloves (Original Style)
Formal Gloves (White)
Formal Gloves (Black)
Formal Gloves (Red)
Formal Gloves (Yellow)
Formal Gloves (Green)
Formal Gloves (Blue)
Formal Gloves (Orange)
Formal Gloves (Navy)
Formal Gloves (Purple)
Formal Gloves (Pink)
Formal Gloves (Gray)
Formal Gloves (Tan)
Sport Glove (Galarian Star Tournament)

93
SwitchGiftDataManager.Core/Resources/SWSHClothingHats.txt Normal file
View File

@@ -0,0 +1,93 @@
Sport Cap (Iconic Style)
Sport Cap (Challenger Kit)
Sport Cap (Grass Type)
Sport Cap (Water Type)
Sport Cap (Fire Type)
Sport Cap (Ghost Type)
Sport Cap (Fighting Type)
Sport Cap (Fairy Type)
Sport Cap (Rock Type)
Sport Cap (Ice Type)
Sport Cap (Dark Type)
Sport Cap (Dragon Type)
Sport Cap (Bug Type)
Sport Cap (Steel Type)
Sport Cap (Psychic Type)
Sport Cap (Electric Type)
Sport Cap (Ground Type)
Sport Cap (Flying Type)
Sport Cap (Normal Type)
Sport Cap (Poison Type)
Scally Cap (White)
Scally Cap (Black)
Scally Cap (Red)
Scally Cap (Yellow)
Scally Cap (Green)
Scally Cap (Blue)
Scally Cap (Orange)
Scally Cap (Navy)
Scally Cap (Purple)
Scally Cap (Pink)
Scally Cap (Gray)
Scally Cap (Tan)
Knit Cap (White)
Knit Cap (Black)
Knit Cap (Red)
Knit Cap (Yellow)
Knit Cap (Green)
Knit Cap (Blue)
Knit Cap (Orange)
Knit Cap (Navy)
Knit Cap (Purple)
Knit Cap (Pink)
Knit Cap (Gray)
Knit Cap (Tan)
Knit Beret (White)
Knit Beret (Black)
Knit Beret (Red)
Knit Beret (Yellow)
Knit Beret (Green)
Knit Beret (Blue)
Knit Beret (Orange)
Knit Beret (Navy)
Knit Beret (Purple)
Knit Beret (Pink)
Knit Beret (Gray)
Knit Beret (Tan)
Bucket Hat (White)
Bucket Hat (Black)
Bucket Hat (Red)
Bucket Hat (Yellow)
Bucket Hat (Green)
Bucket Hat (Blue)
Bucket Hat (Orange)
Bucket Hat (Navy)
Bucket Hat (Purple)
Bucket Hat (Pink)
Bucket Hat (Gray)
Bucket Hat (Tan)
Trapper Hat (White)
Trapper Hat (Black)
Trapper Hat (Red)
Trapper Hat (Yellow)
Trapper Hat (Green)
Trapper Hat (Blue)
Trapper Hat (Orange)
Trapper Hat (Navy)
Trapper Hat (Purple)
Trapper Hat (Pink)
Trapper Hat (Gray)
Trapper Hat (Tan)
Sport Cap (Leon's Look)
Sport Cap (Hex Nut)
Sport Cap (Stuff Cheeks)
Sport Cap (Dynamax)
Sport Cap (W x F x G)
Hard Hat (Original Style)
Gold Hard Hat (Original Style)
Bucket Hat (Green)
Bucket Hat (Blue)
Bucket Hat (Pink)
Replica State Crown (Original Style)
Replica Gold Crown (Original Style)
Partner Cap (Original Style)

70
SwitchGiftDataManager.Core/Resources/SWSHClothingJackets.txt Normal file
View File

@@ -0,0 +1,70 @@
Tracksuit Jacket (Iconic Style)
Tracksuit Jacket (Challenger Kit)
Tracksuit Jacket (Grass Type)
Tracksuit Jacket (Water Type)
Tracksuit Jacket (Fire Type)
Tracksuit Jacket (Ghost Type)
Tracksuit Jacket (Fighting Type)
Tracksuit Jacket (Fairy Type)
Tracksuit Jacket (Rock Type)
Tracksuit Jacket (Ice Type)
Tracksuit Jacket (Dark Type)
Tracksuit Jacket (Dragon Type)
Tracksuit Jacket (Bug Type)
Tracksuit Jacket (Steel Type)
Tracksuit Jacket (Psychic Type)
Tracksuit Jacket (Electric Type)
Tracksuit Jacket (Ground Type)
Tracksuit Jacket (Flying Type)
Tracksuit Jacket (Normal Type)
Tracksuit Jacket (Poison Type)
Hoodie (White)
Hoodie (Black)
Hoodie (Red)
Hoodie (Yellow)
Hoodie (Green)
Hoodie (Blue)
Hoodie (Orange)
Hoodie (Navy)
Hoodie (Purple)
Hoodie (Pink)
Hoodie (Gray)
Hoodie (Tan)
Hoodie (Gray Greed)
Hoodie (The Champ)
Hoodie (Sunset City)
Satin Varsity Jacket (Bitter Rock)
Satin Varsity Jacket (Shocking Berry)
Varsity Jacket (Green)
Varsity Jacket (Red)
Varsity Jacket (Blue)
Zippered Parka (Lovely Nightmare)
Zippered Parka (Cute Clobbering)
Zippered Parka (Berry Forest)
Motorcycle Jacket (White)
Motorcycle Jacket (Black)
Motorcycle Jacket (Red)
Motorcycle Jacket (Caramel)
Motorcycle Jacket (Blue)
Punk Vest (Faded Black)
Punk Vest (Light Blue)
Punk Vest (Red)
Suit Jacket (White)
Suit Jacket (Black)
Suit Jacket (Red)
Suit Jacket (Yellow)
Suit Jacket (Green)
Suit Jacket (Blue)
Suit Jacket (Orange)
Suit Jacket (Navy)
Suit Jacket (Purple)
Suit Jacket (Pink)
Suit Jacket (Gray)
Suit Jacket (Tan)
Expedition Jacket (Original Style)
Gold Expedition Jacket (Original Style)
Dojo Jacket (Original Style)
Hoodie (W x F x G)
Hoodie (C x L)
Hoodie (Legendary R-D)
Hoodie (Legendary R-E)

93
SwitchGiftDataManager.Core/Resources/SWSHClothingLegwear.txt Normal file
View File

@@ -0,0 +1,93 @@
Sport Legwear (Challenger Kit)
Sport Legwear (Grass Type)
Sport Legwear (Water Type)
Sport Legwear (Fire Type)
Sport Legwear (Ghost Type)
Sport Legwear (Fighting Type)
Sport Legwear (Fairy Type)
Sport Legwear (Rock Type)
Sport Legwear (Ice Type)
Sport Legwear (Dark Type)
Sport Legwear (Dragon Type)
Sport Legwear (Bug Type)
Sport Legwear (Steel Type)
Sport Legwear (Psychic Type)
Sport Legwear (Electric Type)
Sport Legwear (Ground Type)
Sport Legwear (Flying Type)
Sport Legwear (Normal Type)
Sport Legwear (Poison Type)
Sport Legwear (Reigning Champion)
Sport Legwear (Pikachu Kit)
Sport Legwear (Eevee Kit)
Sport Legwear (Ranked Battles)
Sport Legwear (Battle Tower)
Sport Low Crew Socks (Iconic Style)
Sport High Socks (Iconic Style)
Sport Cropped Leggings (Iconic Style)
Sport Compression Tights (Iconic Style)
Trainer Socks (Black)
Low Crew Socks (White)
Low Crew Socks (Black)
Low Crew Socks (Red)
Low Crew Socks (Yellow)
Low Crew Socks (Green)
Low Crew Socks (Blue)
Low Crew Socks (Orange)
Low Crew Socks (Navy)
Low Crew Socks (Purple)
Low Crew Socks (Pink)
Low Crew Socks (Gray)
Low Crew Socks (Tan)
High Socks (White)
High Socks (Black)
High Socks (Red)
High Socks (Yellow)
High Socks (Green)
High Socks (Blue)
High Socks (Orange)
High Socks (Navy)
High Socks (Purple)
High Socks (Pink)
High Socks (Gray)
High Socks (Tan)
Cropped Leggings (White)
Cropped Leggings (Black)
Cropped Leggings (Red)
Cropped Leggings (Yellow)
Cropped Leggings (Green)
Cropped Leggings (Blue)
Cropped Leggings (Orange)
Cropped Leggings (Navy)
Cropped Leggings (Purple)
Cropped Leggings (Pink)
Cropped Leggings (Gray)
Cropped Leggings (Tan)
Compression Tights (White)
Compression Tights (Black)
Compression Tights (Red)
Compression Tights (Yellow)
Compression Tights (Green)
Compression Tights (Blue)
Compression Tights (Orange)
Compression Tights (Navy)
Compression Tights (Purple)
Compression Tights (Pink)
Compression Tights (Gray)
Compression Tights (Tan)
Plaid Socks (Green)
Plaid Socks (Red)
Plaid Socks (Monotone)
Plaid Socks (Pink)
Plaid Socks (Navy)
Plaid Socks (Yellow)
Patterned Leggings (Splashy Pink)
Patterned Leggings (Red Gas)
Patterned Leggings (Fresh & Blue)
Patterned Leggings (Serious Stripes)
(?) (Bare)
Dojo Legwear (Original Style)
Patterned Tights (Leon's Look)
Patterned Tights (W x F x G)
Patterned Tights (C x L)
Sport Legwear (Galarian Star Tournament)

71
SwitchGiftDataManager.Core/Resources/SWSHClothingShoes.txt Normal file
View File

@@ -0,0 +1,71 @@
Sport High-Tops (Challenger Kit)
Sport High-Tops (Grass Type)
Sport High-Tops (Water Type)
Sport High-Tops (Fire Type)
Sport High-Tops (Ghost Type)
Sport High-Tops (Fighting Type)
Sport High-Tops (Fairy Type)
Sport High-Tops (Rock Type)
Sport High-Tops (Ice Type)
Sport High-Tops (Dark Type)
Sport High-Tops (Dragon Type)
Sport High-Tops (Bug Type)
Sport High-Tops (Steel Type)
Sport High-Tops (Psychic Type)
Sport High-Tops (Electric Type)
Sport High-Tops (Ground Type)
Sport High-Tops (Flying Type)
Sport High-Tops (Normal Type)
Sport High-Tops (Poison Type)
Sport High-Tops (Pikachu Kit)
Sport High-Tops (Eevee Kit)
Loafers (Brown)
Loafers (Sand)
Loafers (Black)
Loafers (White)
Loafers (White/Red)
Loafers (Punk Star)
Loafers (Barrier Tiles)
Loafers (Trendy Tread)
Chukka Boots (Brown)
Chukka Boots (Sand)
Chukka Boots (Black)
Casual Trainers (White)
Casual Trainers (Black)
Casual Trainers (Red)
Casual Trainers (Yellow)
Casual Trainers (Green)
Casual Trainers (Blue)
Casual Trainers (Orange)
Casual Trainers (Navy)
Casual Trainers (Purple)
Casual Trainers (Pink)
Casual Trainers (Gray)
Casual Trainers (Tan)
Casual Trainers (Ball Bonanza)
Casual Trainers (Lovely Nightmare)
Casual Trainers (Logo Lined)
Casual Trainers (Leppa Laden)
Casual Trainers (Berry Forest)
Creepers (White)
Creepers (Black)
Creepers (Tan)
Creepers (Splashy Pink)
Creepers (Red Gas)
Creepers (Fresh & Blue)
(?) ((?))
(?) ((?))
(?) ((?))
Dojo Shoes (Original Style)
Punk Boots (Pink)
Punk Boots (Blue)
Punk Boots (Yellow)
Luxury Loafers (Black/Red)
Luxury Loafers (Black/White)
Luxury Loafers (White/Red)
Luxury Loafers (White/Black)
Luxury Loafers (White)
Luxury Loafers (Black)
Hiking Boots (Original Style)
Gold Hiking Boots (Original Style)
(?) (?)

146
SwitchGiftDataManager.Core/Resources/SWSHClothingTops.txt Normal file
View File

@@ -0,0 +1,146 @@
Sport Top (Challenger Kit)
Sport Top (Grass Type)
Sport Top (Water Type)
Sport Top (Fire Type)
Sport Top (Ghost Type)
Sport Top (Fighting Type)
Sport Top (Fairy Type)
Sport Top (Rock Type)
Sport Top (Ice Type)
Sport Top (Dark Type)
Sport Top (Dragon Type)
Sport Top (Bug Type)
Sport Top (Steel Type)
Sport Top (Psychic Type)
Sport Top (Electric Type)
Sport Top (Ground Type)
Sport Top (Flying Type)
Sport Top (Normal Type)
Sport Top (Poison Type)
Sport Top (Reigning Champion)
Sport Top (Pikachu Kit)
Sport Top (Eevee Kit)
Sport Top (Ranked Battles)
Sport Top (Battle Tower)
Sport Sweatshirt (Iconic Style)
Loose Top (White)
Loose Top (Black)
Loose Top (Red)
Loose Top (Yellow)
Loose Top (Green)
Loose Top (Blue)
Loose Top (Orange)
Loose Top (Navy)
Loose Top (Purple)
Loose Top (Pink)
Loose Top (Gray)
Loose Top (Tan)
Loose Top (Poliwag Pop)
Loose Top (Luxury Holiday)
Loose Top (Sea Urchin)
Striped Top (White)
Striped Top (Black)
Striped Top (Red)
Striped Top (Yellow)
Striped Top (Green)
Striped Top (Blue)
Striped Top (Orange)
Striped Top (Navy)
Striped Top (Purple)
Striped Top (Pink)
Striped Top (Gray)
Striped Top (Tan)
Three-Fourths Sleeve Polo (White)
Three-Fourths Sleeve Polo (Black)
Three-Fourths Sleeve Polo (Red)
Three-Fourths Sleeve Polo (Yellow)
Three-Fourths Sleeve Polo (Green)
Three-Fourths Sleeve Polo (Blue)
Three-Fourths Sleeve Polo (Orange)
Three-Fourths Sleeve Polo (Navy)
Three-Fourths Sleeve Polo (Purple)
Three-Fourths Sleeve Polo (Pink)
Three-Fourths Sleeve Polo (Gray)
Three-Fourths Sleeve Polo (Tan)
Faded Sweatshirt (White)
Faded Sweatshirt (Black)
Faded Sweatshirt (Red)
Faded Sweatshirt (Yellow)
Faded Sweatshirt (Green)
Faded Sweatshirt (Blue)
Faded Sweatshirt (Orange)
Faded Sweatshirt (Navy)
Faded Sweatshirt (Purple)
Faded Sweatshirt (Pink)
Faded Sweatshirt (Gray)
Faded Sweatshirt (Tan)
Boatneck Sweatshirt (Eternal Sleep)
Boatneck Sweatshirt (Mischief Maker)
Boatneck Sweatshirt (Gullet Glam)
Torn Top (White)
Torn Top (Black)
Torn Top (Nasty Plot)
Torn Top (Astonished Eevee)
Torn Top (Pikachu Payback)
Torn Top (Night Shade)
Torn Top (Scary Face)
Three-Fourths Sleeve Button-Front Top (White)
Three-Fourths Sleeve Button-Front Top (Black)
Three-Fourths Sleeve Button-Front Top (Maroon)
Three-Fourths Sleeve Button-Front Top (Candy Stripe)
Three-Fourths Sleeve Button-Front Top (Paisley Pattern)
Casual Tee (Chosen Design)
Casual Tee (Nasty Plot)
Casual Tee (Astonished Eevee)
Casual Tee (Pikachu Payback)
Casual Tee (Night Shade)
Casual Tee (Scary Face)
Casual Tee (Arcanine Art)
Casual Tee (Urban Smog)
Casual Tee (Camp Curry)
Casual Tee (Dynamax Band)
Casual Tee (Poke Ball Guy)
Casual Tee (Great Ball Guy)
Casual Tee (Ultra Ball Guy)
Casual Tee (Tumblecube Cute)
(?) ((Face Mannequin))
Dojo Tee (Original Style)
Casual Tee (#7)
Casual Tee (#8)
Casual Tee (#9)
Casual Tee (Festive Feldlands)
Casual Tee (Middelands March)
Casual Tee (Auldlands Amble)
Casual Tee (Ramblin' Rondelands)
Casual Tee (Penguin)
Casual Tee (Cream)
Casual Tee (W x F x G)
Casual Tee (Klara 4-ever)
Casual Tee (Avery 4-ever)
Casual Tee (Great Wave, Greater Dragon)
Casual Tee (The Masterly Mustard)
Vest and Tie Ensemble (White)
Vest and Tie Ensemble (Black)
Vest and Tie Ensemble (Red)
Vest and Tie Ensemble (Yellow)
Vest and Tie Ensemble (Green)
Vest and Tie Ensemble (Blue)
Vest and Tie Ensemble (Orange)
Vest and Tie Ensemble (Navy)
Vest and Tie Ensemble (Purple)
Vest and Tie Ensemble (Pink)
Vest and Tie Ensemble (Gray)
Vest and Tie Ensemble (Tan)
Boatneck Sweatshirt (Poke)
Boatneck Sweatshirt (Bro)
Boatneck Sweatshirt (King)
Boatneck Sweatshirt (Freezington's Fame)
Knit Sweater (Tapping Feet)
Knit Sweater (Rad Applin)
Knit Sweater (Peaceful Pastures)
Cable-Knit Sweater (White)
Cable-Knit Sweater (Black)
Cable-Knit Sweater (Gray)
Cable-Knit Sweater (Maroon)
Cable-Knit Sweater (Navy)
Sport Top (Galarian Star Tournament)

906
SwitchGiftDataManager.Core/Resources/Species.txt Normal file
View File

@@ -0,0 +1,906 @@
None,
Bulbasaur,
Ivysaur,
Venusaur,
Charmander,
Charmeleon,
Charizard,
Squirtle,
Wartortle,
Blastoise,
Caterpie,
Metapod,
Butterfree,
Weedle,
Kakuna,
Beedrill,
Pidgey,
Pidgeotto,
Pidgeot,
Rattata,
Raticate,
Spearow,
Fearow,
Ekans,
Arbok,
Pikachu,
Raichu,
Sandshrew,
Sandslash,
NidoranF,
Nidorina,
Nidoqueen,
NidoranM,
Nidorino,
Nidoking,
Clefairy,
Clefable,
Vulpix,
Ninetales,
Jigglypuff,
Wigglytuff,
Zubat,
Golbat,
Oddish,
Gloom,
Vileplume,
Paras,
Parasect,
Venonat,
Venomoth,
Diglett,
Dugtrio,
Meowth,
Persian,
Psyduck,
Golduck,
Mankey,
Primeape,
Growlithe,
Arcanine,
Poliwag,
Poliwhirl,
Poliwrath,
Abra,
Kadabra,
Alakazam,
Machop,
Machoke,
Machamp,
Bellsprout,
Weepinbell,
Victreebel,
Tentacool,
Tentacruel,
Geodude,
Graveler,
Golem,
Ponyta,
Rapidash,
Slowpoke,
Slowbro,
Magnemite,
Magneton,
Farfetchd,
Doduo,
Dodrio,
Seel,
Dewgong,
Grimer,
Muk,
Shellder,
Cloyster,
Gastly,
Haunter,
Gengar,
Onix,
Drowzee,
Hypno,
Krabby,
Kingler,
Voltorb,
Electrode,
Exeggcute,
Exeggutor,
Cubone,
Marowak,
Hitmonlee,
Hitmonchan,
Lickitung,
Koffing,
Weezing,
Rhyhorn,
Rhydon,
Chansey,
Tangela,
Kangaskhan,
Horsea,
Seadra,
Goldeen,
Seaking,
Staryu,
Starmie,
MrMime,
Scyther,
Jynx,
Electabuzz,
Magmar,
Pinsir,
Tauros,
Magikarp,
Gyarados,
Lapras,
Ditto,
Eevee,
Vaporeon,
Jolteon,
Flareon,
Porygon,
Omanyte,
Omastar,
Kabuto,
Kabutops,
Aerodactyl,
Snorlax,
Articuno,
Zapdos,
Moltres,
Dratini,
Dragonair,
Dragonite,
Mewtwo,
Mew,
Chikorita,
Bayleef,
Meganium,
Cyndaquil,
Quilava,
Typhlosion,
Totodile,
Croconaw,
Feraligatr,
Sentret,
Furret,
Hoothoot,
Noctowl,
Ledyba,
Ledian,
Spinarak,
Ariados,
Crobat,
Chinchou,
Lanturn,
Pichu,
Cleffa,
Igglybuff,
Togepi,
Togetic,
Natu,
Xatu,
Mareep,
Flaaffy,
Ampharos,
Bellossom,
Marill,
Azumarill,
Sudowoodo,
Politoed,
Hoppip,
Skiploom,
Jumpluff,
Aipom,
Sunkern,
Sunflora,
Yanma,
Wooper,
Quagsire,
Espeon,
Umbreon,
Murkrow,
Slowking,
Misdreavus,
Unown,
Wobbuffet,
Girafarig,
Pineco,
Forretress,
Dunsparce,
Gligar,
Steelix,
Snubbull,
Granbull,
Qwilfish,
Scizor,
Shuckle,
Heracross,
Sneasel,
Teddiursa,
Ursaring,
Slugma,
Magcargo,
Swinub,
Piloswine,
Corsola,
Remoraid,
Octillery,
Delibird,
Mantine,
Skarmory,
Houndour,
Houndoom,
Kingdra,
Phanpy,
Donphan,
Porygon2,
Stantler,
Smeargle,
Tyrogue,
Hitmontop,
Smoochum,
Elekid,
Magby,
Miltank,
Blissey,
Raikou,
Entei,
Suicune,
Larvitar,
Pupitar,
Tyranitar,
Lugia,
HoOh,
Celebi,
Treecko,
Grovyle,
Sceptile,
Torchic,
Combusken,
Blaziken,
Mudkip,
Marshtomp,
Swampert,
Poochyena,
Mightyena,
Zigzagoon,
Linoone,
Wurmple,
Silcoon,
Beautifly,
Cascoon,
Dustox,
Lotad,
Lombre,
Ludicolo,
Seedot,
Nuzleaf,
Shiftry,
Taillow,
Swellow,
Wingull,
Pelipper,
Ralts,
Kirlia,
Gardevoir,
Surskit,
Masquerain,
Shroomish,
Breloom,
Slakoth,
Vigoroth,
Slaking,
Nincada,
Ninjask,
Shedinja,
Whismur,
Loudred,
Exploud,
Makuhita,
Hariyama,
Azurill,
Nosepass,
Skitty,
Delcatty,
Sableye,
Mawile,
Aron,
Lairon,
Aggron,
Meditite,
Medicham,
Electrike,
Manectric,
Plusle,
Minun,
Volbeat,
Illumise,
Roselia,
Gulpin,
Swalot,
Carvanha,
Sharpedo,
Wailmer,
Wailord,
Numel,
Camerupt,
Torkoal,
Spoink,
Grumpig,
Spinda,
Trapinch,
Vibrava,
Flygon,
Cacnea,
Cacturne,
Swablu,
Altaria,
Zangoose,
Seviper,
Lunatone,
Solrock,
Barboach,
Whiscash,
Corphish,
Crawdaunt,
Baltoy,
Claydol,
Lileep,
Cradily,
Anorith,
Armaldo,
Feebas,
Milotic,
Castform,
Kecleon,
Shuppet,
Banette,
Duskull,
Dusclops,
Tropius,
Chimecho,
Absol,
Wynaut,
Snorunt,
Glalie,
Spheal,
Sealeo,
Walrein,
Clamperl,
Huntail,
Gorebyss,
Relicanth,
Luvdisc,
Bagon,
Shelgon,
Salamence,
Beldum,
Metang,
Metagross,
Regirock,
Regice,
Registeel,
Latias,
Latios,
Kyogre,
Groudon,
Rayquaza,
Jirachi,
Deoxys,
Turtwig,
Grotle,
Torterra,
Chimchar,
Monferno,
Infernape,
Piplup,
Prinplup,
Empoleon,
Starly,
Staravia,
Staraptor,
Bidoof,
Bibarel,
Kricketot,
Kricketune,
Shinx,
Luxio,
Luxray,
Budew,
Roserade,
Cranidos,
Rampardos,
Shieldon,
Bastiodon,
Burmy,
Wormadam,
Mothim,
Combee,
Vespiquen,
Pachirisu,
Buizel,
Floatzel,
Cherubi,
Cherrim,
Shellos,
Gastrodon,
Ambipom,
Drifloon,
Drifblim,
Buneary,
Lopunny,
Mismagius,
Honchkrow,
Glameow,
Purugly,
Chingling,
Stunky,
Skuntank,
Bronzor,
Bronzong,
Bonsly,
MimeJr,
Happiny,
Chatot,
Spiritomb,
Gible,
Gabite,
Garchomp,
Munchlax,
Riolu,
Lucario,
Hippopotas,
Hippowdon,
Skorupi,
Drapion,
Croagunk,
Toxicroak,
Carnivine,
Finneon,
Lumineon,
Mantyke,
Snover,
Abomasnow,
Weavile,
Magnezone,
Lickilicky,
Rhyperior,
Tangrowth,
Electivire,
Magmortar,
Togekiss,
Yanmega,
Leafeon,
Glaceon,
Gliscor,
Mamoswine,
PorygonZ,
Gallade,
Probopass,
Dusknoir,
Froslass,
Rotom,
Uxie,
Mesprit,
Azelf,
Dialga,
Palkia,
Heatran,
Regigigas,
Giratina,
Cresselia,
Phione,
Manaphy,
Darkrai,
Shaymin,
Arceus,
Victini,
Snivy,
Servine,
Serperior,
Tepig,
Pignite,
Emboar,
Oshawott,
Dewott,
Samurott,
Patrat,
Watchog,
Lillipup,
Herdier,
Stoutland,
Purrloin,
Liepard,
Pansage,
Simisage,
Pansear,
Simisear,
Panpour,
Simipour,
Munna,
Musharna,
Pidove,
Tranquill,
Unfezant,
Blitzle,
Zebstrika,
Roggenrola,
Boldore,
Gigalith,
Woobat,
Swoobat,
Drilbur,
Excadrill,
Audino,
Timburr,
Gurdurr,
Conkeldurr,
Tympole,
Palpitoad,
Seismitoad,
Throh,
Sawk,
Sewaddle,
Swadloon,
Leavanny,
Venipede,
Whirlipede,
Scolipede,
Cottonee,
Whimsicott,
Petilil,
Lilligant,
Basculin,
Sandile,
Krokorok,
Krookodile,
Darumaka,
Darmanitan,
Maractus,
Dwebble,
Crustle,
Scraggy,
Scrafty,
Sigilyph,
Yamask,
Cofagrigus,
Tirtouga,
Carracosta,
Archen,
Archeops,
Trubbish,
Garbodor,
Zorua,
Zoroark,
Minccino,
Cinccino,
Gothita,
Gothorita,
Gothitelle,
Solosis,
Duosion,
Reuniclus,
Ducklett,
Swanna,
Vanillite,
Vanillish,
Vanilluxe,
Deerling,
Sawsbuck,
Emolga,
Karrablast,
Escavalier,
Foongus,
Amoonguss,
Frillish,
Jellicent,
Alomomola,
Joltik,
Galvantula,
Ferroseed,
Ferrothorn,
Klink,
Klang,
Klinklang,
Tynamo,
Eelektrik,
Eelektross,
Elgyem,
Beheeyem,
Litwick,
Lampent,
Chandelure,
Axew,
Fraxure,
Haxorus,
Cubchoo,
Beartic,
Cryogonal,
Shelmet,
Accelgor,
Stunfisk,
Mienfoo,
Mienshao,
Druddigon,
Golett,
Golurk,
Pawniard,
Bisharp,
Bouffalant,
Rufflet,
Braviary,
Vullaby,
Mandibuzz,
Heatmor,
Durant,
Deino,
Zweilous,
Hydreigon,
Larvesta,
Volcarona,
Cobalion,
Terrakion,
Virizion,
Tornadus,
Thundurus,
Reshiram,
Zekrom,
Landorus,
Kyurem,
Keldeo,
Meloetta,
Genesect,
Chespin,
Quilladin,
Chesnaught,
Fennekin,
Braixen,
Delphox,
Froakie,
Frogadier,
Greninja,
Bunnelby,
Diggersby,
Fletchling,
Fletchinder,
Talonflame,
Scatterbug,
Spewpa,
Vivillon,
Litleo,
Pyroar,
Flabébé,
Floette,
Florges,
Skiddo,
Gogoat,
Pancham,
Pangoro,
Furfrou,
Espurr,
Meowstic,
Honedge,
Doublade,
Aegislash,
Spritzee,
Aromatisse,
Swirlix,
Slurpuff,
Inkay,
Malamar,
Binacle,
Barbaracle,
Skrelp,
Dragalge,
Clauncher,
Clawitzer,
Helioptile,
Heliolisk,
Tyrunt,
Tyrantrum,
Amaura,
Aurorus,
Sylveon,
Hawlucha,
Dedenne,
Carbink,
Goomy,
Sliggoo,
Goodra,
Klefki,
Phantump,
Trevenant,
Pumpkaboo,
Gourgeist,
Bergmite,
Avalugg,
Noibat,
Noivern,
Xerneas,
Yveltal,
Zygarde,
Diancie,
Hoopa,
Volcanion,
Rowlet,
Dartrix,
Decidueye,
Litten,
Torracat,
Incineroar,
Popplio,
Brionne,
Primarina,
Pikipek,
Trumbeak,
Toucannon,
Yungoos,
Gumshoos,
Grubbin,
Charjabug,
Vikavolt,
Crabrawler,
Crabominable,
Oricorio,
Cutiefly,
Ribombee,
Rockruff,
Lycanroc,
Wishiwashi,
Mareanie,
Toxapex,
Mudbray,
Mudsdale,
Dewpider,
Araquanid,
Fomantis,
Lurantis,
Morelull,
Shiinotic,
Salandit,
Salazzle,
Stufful,
Bewear,
Bounsweet,
Steenee,
Tsareena,
Comfey,
Oranguru,
Passimian,
Wimpod,
Golisopod,
Sandygast,
Palossand,
Pyukumuku,
TypeNull,
Silvally,
Minior,
Komala,
Turtonator,
Togedemaru,
Mimikyu,
Bruxish,
Drampa,
Dhelmise,
Jangmoo,
Hakamoo,
Kommoo,
TapuKoko,
TapuLele,
TapuBulu,
TapuFini,
Cosmog,
Cosmoem,
Solgaleo,
Lunala,
Nihilego,
Buzzwole,
Pheromosa,
Xurkitree,
Celesteela,
Kartana,
Guzzlord,
Necrozma,
Magearna,
Marshadow,
Poipole,
Naganadel,
Stakataka,
Blacephalon,
Zeraora,
Meltan,
Melmetal,
Grookey,
Thwackey,
Rillaboom,
Scorbunny,
Raboot,
Cinderace,
Sobble,
Drizzile,
Inteleon,
Skwovet,
Greedent,
Rookidee,
Corvisquire,
Corviknight,
Blipbug,
Dottler,
Orbeetle,
Nickit,
Thievul,
Gossifleur,
Eldegoss,
Wooloo,
Dubwool,
Chewtle,
Drednaw,
Yamper,
Boltund,
Rolycoly,
Carkol,
Coalossal,
Applin,
Flapple,
Appletun,
Silicobra,
Sandaconda,
Cramorant,
Arrokuda,
Barraskewda,
Toxel,
Toxtricity,
Sizzlipede,
Centiskorch,
Clobbopus,
Grapploct,
Sinistea,
Polteageist,
Hatenna,
Hattrem,
Hatterene,
Impidimp,
Morgrem,
Grimmsnarl,
Obstagoon,
Perrserker,
Cursola,
Sirfetchd,
MrRime,
Runerigus,
Milcery,
Alcremie,
Falinks,
Pincurchin,
Snom,
Frosmoth,
Stonjourner,
Eiscue,
Indeedee,
Morpeko,
Cufant,
Copperajah,
Dracozolt,
Arctozolt,
Dracovish,
Arctovish,
Duraludon,
Dreepy,
Drakloak,
Dragapult,
Zacian,
Zamazenta,
Eternatus,
Kubfu,
Urshifu,
Zarude,
Regieleki,
Regidrago,
Glastrier,
Spectrier,
Calyrex,
Wyrdeer,
Kleavor,
Ursaluna,
Basculegion,
Sneasler,
Overqwil,
Enamorus,

940
SwitchGiftDataManager.Core/Resources/UndergroundItems.txt Normal file
View File

@@ -0,0 +1,940 @@
None
Red Sphere S
Blue Sphere S
Green Sphere S
Prism Sphere S
Pale Sphere S
Red Sphere L
Blue Sphere L
Green Sphere L
Prism Sphere L
Pale Sphere L
Revive
Max Revive
Red Shard
Blue Shard
Yellow Shard
Green Shard
Sun Stone
Moon Stone
Fire Stone
Thunder Stone
Water Stone
Leaf Stone
Oval Stone
Everstone
Odd Keystone
Star Piece
Heart Scale
Root Fossil
Claw Fossil
Helix Fossil
Dome Fossil
Old Amber
Armor Fossil
Skull Fossil
Rare Bone
Light Clay
Iron Ball
Icy Rock
Smooth Rock
Heat Rock
Damp Rock
Mysterious Shard S
Mysterious Shard L
Hard Stone
Flame Plate
Splash Plate
Zap Plate
Meadow Plate
Icicle Plate
Fist Plate
Toxic Plate
Earth Plate
Sky Plate
Mind Plate
Insect Plate
Stone Plate
Spooky Plate
Draco Plate
Dread Plate
Iron Plate
Pixie Plate
Square Pedestal XS
Square Pedestal S
Square Pedestal M
Square Pedestal L
Round Pedestal XS
Round Pedestal M
Round Pedestal L
Sturdy Pedestal XS
Sturdy Pedestal S
Sturdy Pedestal M
Sturdy Pedestal L
Clear Pedestal XS
Clear Pedestal S
Clear Pedestal M
Clear Pedestal L
Dawn Pedestal L
Dawn Pedestal XL
Night Pedestal L
Night Pedestal XL
Diamond Pedestal L
Diamond Pedestal XL
Pearl Pedestal L
Pearl Pedestal XL
Spin Pedestal XS
Spin Pedestal M
Spin Pedestal L
Spinback Pedestal XS
Spinback Pedestal M
Spinback Pedestal L
Digger Drill
TM01
TM02
TM03
TM04
TM05
TM06
TM07
TM08
TM09
TM10
TM11
TM12
TM13
TM14
TM15
TM16
TM17
TM18
TM19
TM20
TM21
TM22
TM23
TM24
TM25
TM26
TM27
TM28
TM29
TM30
TM31
TM32
TM33
TM34
TM35
TM36
TM37
TM38
TM39
TM40
TM41
TM42
TM43
TM44
TM45
TM46
TM47
TM48
TM49
TM50
TM51
TM52
TM53
TM54
TM55
TM56
TM57
TM58
TM59
TM60
TM61
TM62
TM63
TM64
TM65
TM66
TM67
TM68
TM69
TM70
TM71
TM72
TM73
TM74
TM75
TM76
TM77
TM78
TM79
TM80
TM81
TM82
TM83
TM84
TM85
TM86
TM87
TM88
TM89
TM90
TM91
TM92
Bulbasaur Statue
Ivysaur Statue
Venusaur Statue
Charmander Statue
Charmeleon Statue
Charizard Statue
Squirtle Statue
Wartortle Statue
Blastoise Statue
Pikachu Statue
Nidoqueen Statue
Nidoking Statue
Clefairy Statue
Vulpix Statue
Jigglypuff Statue
Oddish Statue
Meowth Statue
Psyduck Statue
Arcanine Statue
Poliwrath Statue
Alakazam Statue
Machamp Statue
Tentacruel Statue
Geodude Statue
Rapidash Statue
Slowpoke Statue
Farfetch’d Statue
Gengar Statue
Cubone Statue
Lickitung Statue
Weezing Statue
Chansey Statue
Kangaskhan Statue
Seaking Statue
Mr. Mime Statue
Tauros Statue
Magikarp Statue
Gyarados Statue
Lapras Statue
Ditto Statue
Eevee Statue
Vaporeon Statue
Jolteon Statue
Flareon Statue
Porygon Statue
Omastar Statue
Snorlax Statue
Dragonite Statue
Chikorita Statue
Bayleef Statue
Meganium Statue
Cyndaquil Statue
Quilava Statue
Typhlosion Statue
Totodile Statue
Croconaw Statue
Feraligatr Statue
Furret Statue
Noctowl Statue
Crobat Statue
Togepi Statue
Ampharos Statue
Bellossom Statue
Marill Statue
Sudowoodo Statue
Aipom Statue
Sunkern Statue
Quagsire Statue
Espeon Statue
Umbreon Statue
Murkrow Statue
Unown Statue
Wobbuffet Statue
Girafarig Statue
Dunsparce Statue
Steelix Statue
Snubbull Statue
Scizor Statue
Heracross Statue
Magcargo Statue
Octillery Statue
Mantine Statue
Smeargle Statue
Miltank Statue
Tyranitar Statue
Treecko Statue
Grovyle Statue
Sceptile Statue
Torchic Statue
Combusken Statue
Blaziken Statue
Mudkip Statue
Marshtomp Statue
Swampert Statue
Beautifly Statue
Dustox Statue
Ludicolo Statue
Pelipper Statue
Gardevoir Statue
Shroomish Statue
Slaking Statue
Ninjask Statue
Exploud Statue
Skitty Statue
Sableye Statue
Mawile Statue
Aggron Statue
Medicham Statue
Manectric Statue
Plusle Statue
Minun Statue
Volbeat Statue
Illumise Statue
Roselia Statue
Sharpedo Statue
Wailmer Statue
Camerupt Statue
Torkoal Statue
Spinda Statue
Flygon Statue
Cacturne Statue
Altaria Statue
Zangoose Statue
Seviper Statue
Lunatone Statue
Solrock Statue
Whiscash Statue
Claydol Statue
Cradily Statue
Milotic Statue
Castform Statue
Kecleon Statue
Tropius Statue
Chimecho Statue
Absol Statue
Spheal Statue
Clamperl Statue
Relicanth Statue
Luvdisc Statue
Salamence Statue
Metagross Statue
Turtwig Statue
Grotle Statue
Torterra Statue
Chimchar Statue
Monferno Statue
Infernape Statue
Piplup Statue
Prinplup Statue
Empoleon Statue
Staraptor Statue
Bibarel Statue
Kricketot Statue
Luxray Statue
Budew Statue
Roserade Statue
Cranidos Statue
Bastiodon Statue
Burmy Statue
Wormadam Statue
Mothim Statue
Vespiquen Statue
Pachirisu Statue
Floatzel Statue
Cherubi Statue
Gastrodon Statue
Ambipom Statue
Drifloon Statue
Buneary Statue
Mismagius Statue
Honchkrow Statue
Purugly Statue
Skuntank Statue
Bronzong Statue
Happiny Statue
Chatot Statue
Spiritomb Statue
Garchomp Statue
Lucario Statue
Hippowdon Statue
Drapion Statue
Croagunk Statue
Carnivine Statue
Lumineon Statue
Abomasnow Statue
Weavile Statue
Magnezone Statue
Rhyperior Statue
Tangrowth Statue
Electivire Statue
Magmortar Statue
Togekiss Statue
Yanmega Statue
Leafeon Statue
Glaceon Statue
Gliscor Statue
Mamoswine Statue
Porygon-Z Statue
Gallade Statue
Probopass Statue
Dusknoir Statue
Froslass Statue
Rotom Statue
Rotom Statue
Rotom Statue
Rotom Statue
Rotom Statue
Rotom Statue
Articuno Statue
Zapdos Statue
Moltres Statue
Mewtwo Statue
Raikou Statue
Entei Statue
Suicune Statue
Lugia Statue
Ho-Oh Statue
Regirock Statue
Regice Statue
Registeel Statue
Latias Statue
Latios Statue
Kyogre Statue
Groudon Statue
Rayquaza Statue
Bulbasaur Statue 
Ivysaur Statue 
Venusaur Statue 
Charmander Statue 
Charmeleon Statue 
Charizard Statue 
Squirtle Statue 
Wartortle Statue 
Blastoise Statue 
Pikachu Statue 
Nidoqueen Statue 
Nidoking Statue 
Clefairy Statue 
Vulpix Statue 
Jigglypuff Statue 
Oddish Statue 
Meowth Statue 
Psyduck Statue 
Arcanine Statue 
Poliwrath Statue 
Alakazam Statue 
Machamp Statue 
Tentacruel Statue 
Geodude Statue 
Rapidash Statue 
Slowpoke Statue 
Farfetch’d Statue 
Gengar Statue 
Cubone Statue 
Lickitung Statue 
Weezing Statue 
Chansey Statue 
Kangaskhan Statue 
Seaking Statue 
Mr. Mime Statue 
Tauros Statue 
Magikarp Statue 
Gyarados Statue 
Lapras Statue 
Ditto Statue 
Eevee Statue 
Vaporeon Statue 
Jolteon Statue 
Flareon Statue 
Porygon Statue 
Omastar Statue 
Snorlax Statue 
Dragonite Statue 
Chikorita Statue 
Bayleef Statue 
Meganium Statue 
Cyndaquil Statue 
Quilava Statue 
Typhlosion Statue 
Totodile Statue 
Croconaw Statue 
Feraligatr Statue 
Furret Statue 
Noctowl Statue 
Crobat Statue 
Togepi Statue 
Ampharos Statue 
Bellossom Statue 
Marill Statue 
Sudowoodo Statue 
Aipom Statue 
Sunkern Statue 
Quagsire Statue 
Espeon Statue 
Umbreon Statue 
Murkrow Statue 
Unown Statue 
Wobbuffet Statue 
Girafarig Statue 
Dunsparce Statue 
Steelix Statue 
Snubbull Statue 
Scizor Statue 
Heracross Statue 
Magcargo Statue 
Octillery Statue 
Mantine Statue 
Smeargle Statue 
Miltank Statue 
Tyranitar Statue 
Treecko Statue 
Grovyle Statue 
Sceptile Statue 
Torchic Statue 
Combusken Statue 
Blaziken Statue 
Mudkip Statue 
Marshtomp Statue 
Swampert Statue 
Beautifly Statue 
Dustox Statue 
Ludicolo Statue 
Pelipper Statue 
Gardevoir Statue 
Shroomish Statue 
Slaking Statue 
Ninjask Statue 
Exploud Statue 
Skitty Statue 
Sableye Statue 
Mawile Statue 
Aggron Statue 
Medicham Statue 
Manectric Statue 
Plusle Statue 
Minun Statue 
Volbeat Statue 
Illumise Statue 
Roselia Statue 
Sharpedo Statue 
Wailmer Statue 
Camerupt Statue 
Torkoal Statue 
Spinda Statue 
Flygon Statue 
Cacturne Statue 
Altaria Statue 
Zangoose Statue 
Seviper Statue 
Lunatone Statue 
Solrock Statue 
Whiscash Statue 
Claydol Statue 
Cradily Statue 
Milotic Statue 
Castform Statue 
Kecleon Statue 
Tropius Statue 
Chimecho Statue 
Absol Statue 
Spheal Statue 
Clamperl Statue 
Relicanth Statue 
Luvdisc Statue 
Salamence Statue 
Metagross Statue 
Turtwig Statue 
Grotle Statue 
Torterra Statue 
Chimchar Statue 
Monferno Statue 
Infernape Statue 
Piplup Statue 
Prinplup Statue 
Empoleon Statue 
Staraptor Statue 
Bibarel Statue 
Kricketot Statue 
Luxray Statue 
Budew Statue 
Roserade Statue 
Cranidos Statue 
Bastiodon Statue 
Burmy Statue 
Wormadam Statue 
Mothim Statue 
Vespiquen Statue 
Pachirisu Statue 
Floatzel Statue 
Cherubi Statue 
Gastrodon Statue 
Ambipom Statue 
Drifloon Statue 
Buneary Statue 
Mismagius Statue 
Honchkrow Statue 
Purugly Statue 
Skuntank Statue 
Bronzong Statue 
Happiny Statue 
Chatot Statue 
Spiritomb Statue 
Garchomp Statue 
Lucario Statue 
Hippowdon Statue 
Drapion Statue 
Croagunk Statue 
Carnivine Statue 
Lumineon Statue 
Abomasnow Statue 
Weavile Statue 
Magnezone Statue 
Rhyperior Statue 
Tangrowth Statue 
Electivire Statue 
Magmortar Statue 
Togekiss Statue 
Yanmega Statue 
Leafeon Statue 
Glaceon Statue 
Gliscor Statue 
Mamoswine Statue 
Porygon-Z Statue 
Gallade Statue 
Probopass Statue 
Dusknoir Statue 
Froslass Statue 
Rotom Statue 
Rotom Statue 
Rotom Statue 
Rotom Statue 
Rotom Statue 
Rotom Statue 
TM93
TM94
TM95
TM96
TM97
TM98
TM99
TM100
Square Pedestal XL
Round Pedestal XL
Sturdy Pedestal XL
Clear Pedestal XL
Spin Pedestal XL
Spinback Pedestal XL
Giratina Origin Statue

57
SwitchGiftDataManager.Core/SwitchGiftDataManager.Core.csproj Normal file
View File

@@ -0,0 +1,57 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Library</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<Authors>Manu098vm</Authors>
<Copyright>Copyright (C) 2022 Manu098vm</Copyright>
<PackageReadmeFile>README.md</PackageReadmeFile>
<PackageTags>pokemon; mystery gift; wondercard; reader; nintendo; bcat; event injection;</PackageTags>
<PackageLicenseFile>LICENSE</PackageLicenseFile>
<Company>Project Pokémon</Company>
<PackageProjectUrl>https://github.com/Manu098vm/Switch-Gift-Data-Manager</PackageProjectUrl>
<RepositoryUrl>https://github.com/Manu098vm/Switch-Gift-Data-Manager</RepositoryUrl>
<RepositoryType>git</RepositoryType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<ItemGroup>
<None Include="..\.editorconfig" Link=".editorconfig" />
<None Include="..\README.md">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<None Include="..\LICENSE">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<Compile Update="Properties\Resources.Designer.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Update="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
</Project>

385
SwitchGiftDataManager.WinForm/MainWindow.Designer.cs generated Normal file
View File

@@ -0,0 +1,385 @@
namespace SwitchGiftDataManager.WinForm
{
partial class MainWindow
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainWindow));
this.BtnLGPE = new System.Windows.Forms.Button();
this.BtnSWSH = new System.Windows.Forms.Button();
this.BtnBDSP = new System.Windows.Forms.Button();
this.BtnSCVI = new System.Windows.Forms.Button();
this.BtnPLA = new System.Windows.Forms.Button();
this.ListBoxWC = new System.Windows.Forms.ListBox();
this.BtnOpen = new System.Windows.Forms.Button();
this.BtnSave = new System.Windows.Forms.Button();
this.GrpBCAT = new System.Windows.Forms.GroupBox();
this.BtnApply = new System.Windows.Forms.Button();
this.GrpContent = new System.Windows.Forms.GroupBox();
this.LblInfo5 = new System.Windows.Forms.Label();
this.LblInfo4 = new System.Windows.Forms.Label();
this.LblInfo3 = new System.Windows.Forms.Label();
this.LblInfo2 = new System.Windows.Forms.Label();
this.LblInfo1 = new System.Windows.Forms.Label();
this.TxtWCID = new System.Windows.Forms.TextBox();
this.LblWCID = new System.Windows.Forms.Label();
this.ContextMenuStripWC = new System.Windows.Forms.ContextMenuStrip(this.components);
this.BtnRemove = new System.Windows.Forms.ToolStripMenuItem();
this.BtnRemoveAll = new System.Windows.Forms.ToolStripMenuItem();
this.OpenFileDialogWC = new System.Windows.Forms.OpenFileDialog();
this.ToolTipWcid = new System.Windows.Forms.ToolTip(this.components);
this.GrpBCAT.SuspendLayout();
this.GrpContent.SuspendLayout();
this.ContextMenuStripWC.SuspendLayout();
this.SuspendLayout();
//
// BtnLGPE
//
this.BtnLGPE.AccessibleDescription = "";
this.BtnLGPE.AccessibleName = "";
this.BtnLGPE.Cursor = System.Windows.Forms.Cursors.Hand;
this.BtnLGPE.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
this.BtnLGPE.Location = new System.Drawing.Point(5, 12);
this.BtnLGPE.Name = "BtnLGPE";
this.BtnLGPE.Size = new System.Drawing.Size(136, 60);
this.BtnLGPE.TabIndex = 0;
this.BtnLGPE.TabStop = false;
this.BtnLGPE.Text = "LGPE";
this.BtnLGPE.UseVisualStyleBackColor = true;
this.BtnLGPE.Click += new System.EventHandler(this.BtnLGPE_Click);
//
// BtnSWSH
//
this.BtnSWSH.AccessibleDescription = "";
this.BtnSWSH.AccessibleName = "";
this.BtnSWSH.Cursor = System.Windows.Forms.Cursors.Hand;
this.BtnSWSH.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
this.BtnSWSH.Location = new System.Drawing.Point(147, 12);
this.BtnSWSH.Name = "BtnSWSH";
this.BtnSWSH.Size = new System.Drawing.Size(136, 60);
this.BtnSWSH.TabIndex = 1;
this.BtnSWSH.TabStop = false;
this.BtnSWSH.Text = "SWSH";
this.BtnSWSH.UseVisualStyleBackColor = true;
this.BtnSWSH.Click += new System.EventHandler(this.BtnSWSH_Click);
//
// BtnBDSP
//
this.BtnBDSP.AccessibleDescription = "";
this.BtnBDSP.AccessibleName = "";
this.BtnBDSP.Cursor = System.Windows.Forms.Cursors.Hand;
this.BtnBDSP.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
this.BtnBDSP.Location = new System.Drawing.Point(289, 12);
this.BtnBDSP.Name = "BtnBDSP";
this.BtnBDSP.Size = new System.Drawing.Size(136, 60);
this.BtnBDSP.TabIndex = 2;
this.BtnBDSP.TabStop = false;
this.BtnBDSP.Text = "BDSP";
this.BtnBDSP.UseVisualStyleBackColor = true;
this.BtnBDSP.Click += new System.EventHandler(this.BtnBDSP_Click);
//
// BtnSCVI
//
this.BtnSCVI.AccessibleDescription = "";
this.BtnSCVI.AccessibleName = "";
this.BtnSCVI.Cursor = System.Windows.Forms.Cursors.Hand;
this.BtnSCVI.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
this.BtnSCVI.Location = new System.Drawing.Point(573, 12);
this.BtnSCVI.Name = "BtnSCVI";
this.BtnSCVI.Size = new System.Drawing.Size(136, 60);
this.BtnSCVI.TabIndex = 3;
this.BtnSCVI.TabStop = false;
this.BtnSCVI.Text = "SCVI";
this.BtnSCVI.UseVisualStyleBackColor = true;
this.BtnSCVI.Click += new System.EventHandler(this.BtnSCVI_Click);
//
// BtnPLA
//
this.BtnPLA.AccessibleDescription = "";
this.BtnPLA.AccessibleName = "";
this.BtnPLA.Cursor = System.Windows.Forms.Cursors.Hand;
this.BtnPLA.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
this.BtnPLA.Location = new System.Drawing.Point(431, 12);
this.BtnPLA.Name = "BtnPLA";
this.BtnPLA.Size = new System.Drawing.Size(136, 60);
this.BtnPLA.TabIndex = 4;
this.BtnPLA.TabStop = false;
this.BtnPLA.Text = "PLA";
this.BtnPLA.UseVisualStyleBackColor = true;
this.BtnPLA.Click += new System.EventHandler(this.BtnPLA_Click);
//
// ListBoxWC
//
this.ListBoxWC.AllowDrop = true;
this.ListBoxWC.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed;
this.ListBoxWC.FormattingEnabled = true;
this.ListBoxWC.ItemHeight = 20;
this.ListBoxWC.Location = new System.Drawing.Point(7, 96);
this.ListBoxWC.Name = "ListBoxWC";
this.ListBoxWC.Size = new System.Drawing.Size(214, 304);
this.ListBoxWC.TabIndex = 5;
this.ToolTipWcid.SetToolTip(this.ListBoxWC, " Wondercards with duplicated WC ID will not be seen by the" +
" game. ");
this.ListBoxWC.DrawItem += new System.Windows.Forms.DrawItemEventHandler(this.ListBoxWC_DrawItem);
this.ListBoxWC.SelectedIndexChanged += new System.EventHandler(this.ListBoxWC_SelectedIndexChanged);
this.ListBoxWC.MouseUp += new System.Windows.Forms.MouseEventHandler(this.ListBoxWC_MouseUp);
this.ListBoxWC.DragEnter += new DragEventHandler(this.FileDragEnter);
this.ListBoxWC.DragDrop += new DragEventHandler(this.FileDragDrop);
//
// BtnOpen
//
this.BtnOpen.Location = new System.Drawing.Point(7, 26);
this.BtnOpen.Name = "BtnOpen";
this.BtnOpen.Size = new System.Drawing.Size(214, 29);
this.BtnOpen.TabIndex = 6;
this.BtnOpen.Text = "Open Wondercard Files...";
this.BtnOpen.UseVisualStyleBackColor = true;
this.BtnOpen.Click += new System.EventHandler(this.BtnOpen_Click);
//
// BtnSave
//
this.BtnSave.Enabled = false;
this.BtnSave.Location = new System.Drawing.Point(6, 61);
this.BtnSave.Name = "BtnSave";
this.BtnSave.Size = new System.Drawing.Size(214, 29);
this.BtnSave.TabIndex = 7;
this.BtnSave.Text = "Save as BCAT Package...";
this.BtnSave.UseVisualStyleBackColor = true;
this.BtnSave.Click += new System.EventHandler(this.BtnSave_Click);
//
// GrpBCAT
//
this.GrpBCAT.Controls.Add(this.BtnApply);
this.GrpBCAT.Controls.Add(this.GrpContent);
this.GrpBCAT.Controls.Add(this.TxtWCID);
this.GrpBCAT.Controls.Add(this.LblWCID);
this.GrpBCAT.Controls.Add(this.ListBoxWC);
this.GrpBCAT.Controls.Add(this.BtnSave);
this.GrpBCAT.Controls.Add(this.BtnOpen);
this.GrpBCAT.Enabled = false;
this.GrpBCAT.Location = new System.Drawing.Point(5, 78);
this.GrpBCAT.Name = "GrpBCAT";
this.GrpBCAT.Size = new System.Drawing.Size(704, 409);
this.GrpBCAT.TabIndex = 8;
this.GrpBCAT.TabStop = false;
this.GrpBCAT.Text = "BCAT Manager";
//
// BtnApply
//
this.BtnApply.Enabled = false;
this.BtnApply.Location = new System.Drawing.Point(426, 355);
this.BtnApply.Name = "BtnApply";
this.BtnApply.Size = new System.Drawing.Size(97, 32);
this.BtnApply.TabIndex = 11;
this.BtnApply.Text = "Apply";
this.BtnApply.UseVisualStyleBackColor = true;
this.BtnApply.Click += new System.EventHandler(this.BtnApply_Click);
//
// GrpContent
//
this.GrpContent.Controls.Add(this.LblInfo5);
this.GrpContent.Controls.Add(this.LblInfo4);
this.GrpContent.Controls.Add(this.LblInfo3);
this.GrpContent.Controls.Add(this.LblInfo2);
this.GrpContent.Controls.Add(this.LblInfo1);
this.GrpContent.Enabled = false;
this.GrpContent.Location = new System.Drawing.Point(294, 99);
this.GrpContent.Name = "GrpContent";
this.GrpContent.Size = new System.Drawing.Size(358, 250);
this.GrpContent.TabIndex = 10;
this.GrpContent.TabStop = false;
this.GrpContent.Text = "Gift Content";
//
// LblInfo5
//
this.LblInfo5.AutoSize = true;
this.LblInfo5.Location = new System.Drawing.Point(152, 188);
this.LblInfo5.Name = "LblInfo5";
this.LblInfo5.Size = new System.Drawing.Size(49, 20);
this.LblInfo5.TabIndex = 4;
this.LblInfo5.Text = "Info_5";
this.LblInfo5.Visible = false;
this.LblInfo5.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged);
//
// LblInfo4
//
this.LblInfo4.AutoSize = true;
this.LblInfo4.Location = new System.Drawing.Point(152, 153);
this.LblInfo4.Name = "LblInfo4";
this.LblInfo4.Size = new System.Drawing.Size(49, 20);
this.LblInfo4.TabIndex = 3;
this.LblInfo4.Text = "Info_4";
this.LblInfo4.Visible = false;
this.LblInfo4.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged);
//
// LblInfo3
//
this.LblInfo3.AutoSize = true;
this.LblInfo3.Location = new System.Drawing.Point(152, 118);
this.LblInfo3.Name = "LblInfo3";
this.LblInfo3.Size = new System.Drawing.Size(49, 20);
this.LblInfo3.TabIndex = 2;
this.LblInfo3.Text = "Info_3";
this.LblInfo3.Visible = false;
this.LblInfo3.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged);
//
// LblInfo2
//
this.LblInfo2.AutoSize = true;
this.LblInfo2.Location = new System.Drawing.Point(152, 83);
this.LblInfo2.Name = "LblInfo2";
this.LblInfo2.Size = new System.Drawing.Size(49, 20);
this.LblInfo2.TabIndex = 1;
this.LblInfo2.Text = "Info_2";
this.LblInfo2.Visible = false;
this.LblInfo2.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged);
//
// LblInfo1
//
this.LblInfo1.AutoSize = true;
this.LblInfo1.Location = new System.Drawing.Point(152, 48);
this.LblInfo1.Name = "LblInfo1";
this.LblInfo1.Size = new System.Drawing.Size(49, 20);
this.LblInfo1.TabIndex = 0;
this.LblInfo1.Text = "Info_1";
this.LblInfo1.Visible = false;
this.LblInfo1.SizeChanged += new System.EventHandler(this.LblInfo_SizeChanged);
//
// TxtWCID
//
this.TxtWCID.Enabled = false;
this.TxtWCID.Location = new System.Drawing.Point(435, 63);
this.TxtWCID.MaxLength = 4;
this.TxtWCID.Name = "TxtWCID";
this.TxtWCID.Size = new System.Drawing.Size(115, 27);
this.TxtWCID.TabIndex = 9;
this.TxtWCID.TextChanged += new System.EventHandler(this.TxtWCID_TextChanged);
this.TxtWCID.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.TxtWCID_KeyPress);
//
// LblWCID
//
this.LblWCID.AutoSize = true;
this.LblWCID.Enabled = false;
this.LblWCID.Location = new System.Drawing.Point(375, 66);
this.LblWCID.Name = "LblWCID";
this.LblWCID.Size = new System.Drawing.Size(54, 20);
this.LblWCID.TabIndex = 8;
this.LblWCID.Text = "WC ID:";
//
// ContextMenuStripWC
//
this.ContextMenuStripWC.ImageScalingSize = new System.Drawing.Size(20, 20);
this.ContextMenuStripWC.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.BtnRemove,
this.BtnRemoveAll});
this.ContextMenuStripWC.Name = "ConextMenuStripWC";
this.ContextMenuStripWC.Size = new System.Drawing.Size(155, 52);
this.ContextMenuStripWC.Text = "Remove";
//
// BtnRemove
//
this.BtnRemove.Name = "BtnRemove";
this.BtnRemove.Size = new System.Drawing.Size(154, 24);
this.BtnRemove.Text = "Remove";
this.BtnRemove.Click += new System.EventHandler(this.BtnRemove_Click);
//
// BtnRemoveAll
//
this.BtnRemoveAll.Name = "BtnRemoveAll";
this.BtnRemoveAll.Size = new System.Drawing.Size(154, 24);
this.BtnRemoveAll.Text = "Remove All";
this.BtnRemoveAll.Click += new System.EventHandler(this.BtnRemoveAll_Click);
//
// OpenFileDialogWC
//
this.OpenFileDialogWC.Multiselect = true;
//
// ToolTipWcid
//
this.ToolTipWcid.AutoPopDelay = 100000;
this.ToolTipWcid.InitialDelay = 500;
this.ToolTipWcid.OwnerDraw = true;
this.ToolTipWcid.ReshowDelay = 100;
this.ToolTipWcid.UseAnimation = false;
this.ToolTipWcid.UseFading = false;
this.ToolTipWcid.Draw += new System.Windows.Forms.DrawToolTipEventHandler(this.ToolTipWcid_Draw);
//
// MainWindow
//
this.AllowDrop = true;
this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 20F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(715, 495);
this.Controls.Add(this.GrpBCAT);
this.Controls.Add(this.BtnPLA);
this.Controls.Add(this.BtnSCVI);
this.Controls.Add(this.BtnBDSP);
this.Controls.Add(this.BtnSWSH);
this.Controls.Add(this.BtnLGPE);
this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
this.MaximizeBox = false;
this.MinimizeBox = false;
this.Name = "MainWindow";
this.Text = "Switch Gift Data Manager v1.0.0";
this.GrpBCAT.ResumeLayout(false);
this.GrpBCAT.PerformLayout();
this.GrpContent.ResumeLayout(false);
this.GrpContent.PerformLayout();
this.ContextMenuStripWC.ResumeLayout(false);
this.ResumeLayout(false);
this.DragEnter += new DragEventHandler(this.FileDragEnter);
this.DragDrop += new DragEventHandler(this.FileDragDrop);
}
#endregion
private Button BtnLGPE;
private Button BtnSWSH;
private Button BtnBDSP;
private Button BtnSCVI;
private Button BtnPLA;
private ListBox ListBoxWC;
private Button BtnOpen;
private Button BtnSave;
private GroupBox GrpBCAT;
private Button BtnApply;
private GroupBox GrpContent;
private TextBox TxtWCID;
private Label LblWCID;
private ContextMenuStrip ContextMenuStripWC;
private ToolStripMenuItem BtnRemove;
private Label LblInfo5;
private Label LblInfo4;
private Label LblInfo3;
private Label LblInfo2;
private Label LblInfo1;
private OpenFileDialog OpenFileDialogWC;
private ToolStripMenuItem BtnRemoveAll;
private ToolTip ToolTipWcid;
}
}

404
SwitchGiftDataManager.WinForm/MainWindow.cs Normal file
View File

@@ -0,0 +1,404 @@
using System.Text.RegularExpressions;
using SwitchGiftDataManager.Core;
using Enums;
namespace SwitchGiftDataManager.WinForm
{
public partial class MainWindow : Form
{
private Games CurrentGame = Games.None;
private BCATManager PackageLGPE = new (Games.LGPE);
private BCATManager PackageSWSH = new (Games.SWSH);
private BCATManager PackageBDSP = new (Games.BDSP);
private BCATManager PackagePLA = new (Games.PLA);
private BCATManager PackageSCVI = new (Games.SCVI);
private List<ushort> Duplicated = new List<ushort>();
public MainWindow() => InitializeComponent();
private void ChangeGame(Games game)
{
GrpBCAT.Enabled = true;
CurrentGame = game;
RestoreMenu();
EditFileFilter();
EditGameButton();
UpdateWCList();
ListBoxWC.SelectedIndex = -1;
DisableContent();
}
private void RestoreMenu()
{
BtnLGPE.Enabled = true;
BtnSWSH.Enabled = true;
BtnBDSP.Enabled = true;
BtnPLA.Enabled = true;
BtnSCVI.Enabled = true;
BtnLGPE.Font = new Font(BtnLGPE.Font.Name, BtnLGPE.Font.Size, FontStyle.Regular);
BtnSWSH.Font = new Font(BtnSWSH.Font.Name, BtnSWSH.Font.Size, FontStyle.Regular);
BtnBDSP.Font = new Font(BtnBDSP.Font.Name, BtnBDSP.Font.Size, FontStyle.Regular);
BtnPLA.Font = new Font(BtnPLA.Font.Name, BtnPLA.Font.Size, FontStyle.Regular);
BtnSCVI.Font = new Font(BtnSCVI.Font.Name, BtnSCVI.Font.Size, FontStyle.Regular);
}
private void EditFileFilter()
{
OpenFileDialogWC.Filter = CurrentGame switch
{
Games.LGPE => "wb7full files (*.wb7full)|*.wb7full|All files (*.*)|*.*",
Games.SWSH => "wc8 files (*.wc8)|*.wc8|All files (*.*)|*.*",
Games.BDSP => "wb8 files (*.wb8)|*.wb8|All files (*.*)|*.*",
Games.PLA => "wa8 files (*.wa8)|*.wa8|All files (*.*)|*.*",
Games.SCVI => "wc9 files (*.wc9)|*.wc9|All files (*.*)|*.*",
_ => "All files (*.*)|*.*",
};
}
private void EditGameButton()
{
Button btn = CurrentGame switch
{
Games.LGPE => BtnLGPE,
Games.SWSH => BtnSWSH,
Games.BDSP => BtnBDSP,
Games.PLA => BtnPLA,
Games.SCVI => BtnSCVI,
_ => throw new ArgumentOutOfRangeException(),
};
EditSelectedButton(btn);
}
private void EditSelectedButton(Button btn)
{
btn.Font = new Font(btn.Font.Name, btn.Font.Size, FontStyle.Bold);
btn.Enabled = false;
}
private void UpdateWCList()
{
if (ListBoxWC.Items.Count > 0)
ListBoxWC.Items.Clear();
var list = CurrentGame switch
{
Games.LGPE => PackageLGPE.GetListNames(),
Games.SWSH => PackageSWSH.GetListNames(),
Games.BDSP => PackageBDSP.GetListNames(),
Games.PLA => PackagePLA.GetListNames(),
Games.SCVI => PackageSCVI.GetListNames(),
_ => throw new ArgumentOutOfRangeException(),
};
UpdateDuplicatedList();
foreach (var el in list)
ListBoxWC.Items.Add(el);
if (ListBoxWC.Items.Count > 0)
BtnSave.Enabled = true;
else
BtnSave.Enabled = false;
}
private void UpdateDuplicatedList()
{
var list = GetCurrentList().GetDuplicatedWCID();
if (list != null)
Duplicated = list;
else
Duplicated = new List<ushort> { 0 };
}
private BCATManager GetCurrentList()
{
return CurrentGame switch
{
Games.LGPE => PackageLGPE,
Games.SWSH => PackageSWSH,
Games.BDSP => PackageBDSP,
Games.PLA => PackagePLA,
Games.SCVI => PackageSCVI,
_ => throw new ArgumentOutOfRangeException(),
};
}
private void LoadLocalFiles(string[] files)
{
DisableContent();
var list = GetCurrentList();
var errList = new List<string>();
foreach (var path in files)
{
var data = File.ReadAllBytes(path);
var success = list.TryAddWondercards(data.AsSpan());
if (!success)
{
if (errList.Count == 0)
if (CurrentGame is Games.LGPE && list.Count() >= 1)
errList.Add("LGPE only supports one (1) wondercard at a time. Aborted file(s):\n");
else
errList.Add($"Attempted to load invalid files. Aborted file(s):\n");
errList.Add($"- {Path.GetFileName(path)}");
}
}
if (errList.Count > 0)
{
var msg = "";
foreach (var err in errList)
msg = $"{msg}\n{err}";
MessageBox.Show(msg);
}
list.Sort();
UpdateWCList();
}
private void BtnLGPE_Click(object sender, EventArgs e) => ChangeGame(Games.LGPE);
private void BtnSWSH_Click(object sender, EventArgs e) => ChangeGame(Games.SWSH);
private void BtnBDSP_Click(object sender, EventArgs e) => ChangeGame(Games.BDSP);
private void BtnPLA_Click(object sender, EventArgs e) => ChangeGame(Games.PLA);
private void BtnSCVI_Click(object sender, EventArgs e) //=> ChangeGame(Games.SCVI);
{
ChangeGame(Games.SCVI);
GrpBCAT.Enabled = false;
MessageBox.Show("Scarlet and Violet features still not available.");
}
private void BtnSave_Click(object sender, EventArgs e) => new SaveWindow(GetCurrentList(), CurrentGame).Show();
private void BtnApply_Click(object sender, EventArgs e)
{
try
{
var list = GetCurrentList();
var wcid = UInt16.Parse(TxtWCID.Text);
var index = list.GetIndex(wcid);
if (index == -1)
{
list.SetWCID(ListBoxWC.SelectedIndex, wcid);
list.Sort();
UpdateWCList();
ListBoxWC.SelectedIndex = list.GetIndex(wcid);
BtnApply.Enabled = false;
}
else
{
MessageBox.Show($"WCID {wcid} already exists.");
return;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
return;
}
}
private void BtnRemove_Click(object sender, EventArgs e)
{
var list = GetCurrentList();
list.RemoveWC(ListBoxWC.SelectedIndex);
ListBoxWC.SelectedIndex = -1;
DisableContent();
UpdateWCList();
}
private void BtnRemoveAll_Click(object sender, EventArgs e)
{
var list = GetCurrentList();
list.Reset();
ListBoxWC.SelectedIndex = -1;
DisableContent();
UpdateWCList();
}
private void BtnOpen_Click(object sender, EventArgs e)
{
if (OpenFileDialogWC.ShowDialog() == DialogResult.OK)
LoadLocalFiles(OpenFileDialogWC.FileNames);
}
void FileDragEnter(object sender, DragEventArgs e)
{
if(e.Data is not null && CurrentGame is not (Games.None or Games.SCVI))
if (e.Data.GetDataPresent(DataFormats.FileDrop))
e.Effect = DragDropEffects.Copy;
}
void FileDragDrop(object sender, DragEventArgs e)
{
if (e.Data is not null && CurrentGame is not (Games.None or Games.SCVI))
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
LoadLocalFiles(files);
}
}
private void TxtWCID_KeyPress(object sender, KeyPressEventArgs e)
{
if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar))
e.Handled = true;
}
private void TxtWCID_TextChanged(object sender, EventArgs e)
{
if (!TxtWCID.Text.Equals(""))
{
var list = GetCurrentList();
var newWcid = UInt16.Parse(TxtWCID.Text);
var oldWcid = list.GetWCID(ListBoxWC.SelectedIndex);
if (oldWcid > 0 && newWcid > 0 && newWcid != oldWcid)
BtnApply.Enabled = true;
else
BtnApply.Enabled = false;
}
}
private void ToolTipWcid_Draw(object sender, DrawToolTipEventArgs e)
{
Point screenPosition = ListBox.MousePosition;
Point listBoxClientAreaPosition = ListBoxWC.PointToClient(screenPosition);
int hoveredIndex = ListBoxWC.IndexFromPoint(listBoxClientAreaPosition);
if (hoveredIndex > -1)
{
var str = ListBoxWC.Items[hoveredIndex].ToString()!;
if (str.Contains('\u26A0'))
{
var msg = "Wondercards with duplicated identifiers may cause issues and will not be seen by the game.";
e.DrawBackground();
Graphics g = e.Graphics;
g.DrawString(msg, e.Font!, new SolidBrush(Color.Black), new PointF(e.Bounds.X, e.Bounds.Y));
}
else if (str.Contains('\u2757'))
{
var msg = "Wondercard count is above the maximum allowed, or the WCID is over the maximum allowed.";
e.DrawBackground();
Graphics g = e.Graphics;
g.DrawString(msg, e.Font!, new SolidBrush(Color.Black), new PointF(e.Bounds.X, e.Bounds.Y));
}
else
{
ToolTipWcid.Hide(ListBoxWC);
}
}
else
ToolTipWcid.Hide(ListBoxWC);
}
private void ListBoxWC_MouseUp(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Right)
{
var index = ListBoxWC.IndexFromPoint(e.X, e.Y);
if (index >= 0)
{
ListBoxWC.SelectedIndex = index;
ContextMenuStripWC.Show(Cursor.Position);
}
}
}
private void ListBoxWC_SelectedIndexChanged(object sender, EventArgs e)
{
if (ListBoxWC.SelectedIndex > -1)
{
var list = GetCurrentList();
var content = list.GetContentToString(ListBoxWC.SelectedIndex);
var nItem = content.Count();
if (nItem >= 1)
LblInfo1.Text = content.ElementAt(1);
if (nItem >= 2)
LblInfo2.Text = content.ElementAt(2);
if (nItem >= 3)
LblInfo3.Text = content.ElementAt(3);
if (nItem >= 4)
LblInfo4.Text = content.ElementAt(4);
if (nItem >= 5)
LblInfo5.Text = content.ElementAt(5);
TxtWCID.Text = content.ElementAt(0);
EnableContent();
}
else
DisableContent();
}
private void ListBoxWC_DrawItem(object sender, DrawItemEventArgs e)
{
if (e.Index > -1)
{
e.DrawBackground();
Graphics g = e.Graphics;
var curr = ((ListBox)sender).Items[e.Index].ToString()!;
var wcid = UInt16.Parse(Regex.Match(curr, @"(?<=\#)(.*?)(?=\:)").Groups[1].Value);
var handled = false;
if ((CurrentGame is Games.BDSP && wcid >= 2048) || (CurrentGame is Games.SWSH && e.Index >= 129))
{
if(!curr.Contains('\u2757'))
((ListBox)sender).Items[e.Index] = $"{curr} \u2757";
g.FillRectangle(new SolidBrush(Color.IndianRed), e.Bounds);
g.DrawString(((ListBox)sender).Items[e.Index].ToString(), e.Font!, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y));
handled = true;
}
foreach (var d in Duplicated)
{
if (d == wcid)
{
if (!curr.Contains('\u26A0'))
((ListBox)sender).Items[e.Index] = $"{curr} \u26A0";
g.FillRectangle(new SolidBrush(Color.Orange), e.Bounds);
g.DrawString(((ListBox)sender).Items[e.Index].ToString(), e.Font!, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y));
handled = true;
}
}
if(!handled)
g.DrawString(curr, e.Font!, new SolidBrush(e.ForeColor), new PointF(e.Bounds.X, e.Bounds.Y));
}
}
private void LblInfo_SizeChanged(object sender, EventArgs e)
{
var lbl = (Label)sender;
lbl.Left = (GrpContent.Width - lbl.Width) / 2;
}
private void EnableContent()
{
TxtWCID.Enabled = true;
LblWCID.Enabled = true;
LblInfo1.Visible = true;
LblInfo2.Visible = true;
LblInfo3.Visible = true;
LblInfo4.Visible = true;
LblInfo5.Visible = true;
GrpContent.Enabled = true;
}
private void DisableContent()
{
TxtWCID.Text = "";
TxtWCID.Enabled = false;
LblWCID.Enabled = false;
LblInfo1.Text = "";
LblInfo1.Visible = false;
LblInfo2.Text = "";
LblInfo2.Visible = false;
LblInfo3.Text = "";
LblInfo3.Visible = false;
LblInfo4.Text = "";
LblInfo4.Visible = false;
LblInfo5.Text = "";
LblInfo5.Visible = false;
GrpContent.Enabled = false;
BtnApply.Enabled = false;
}
}
}

1392
SwitchGiftDataManager.WinForm/MainWindow.resx Normal file
View File

File diff suppressed because it is too large Load Diff

17
SwitchGiftDataManager.WinForm/Program.cs Normal file
View File

@@ -0,0 +1,17 @@
namespace SwitchGiftDataManager.WinForm
{
internal static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
// To customize application configuration such as set high DPI settings or default font,
// see https://aka.ms/applicationconfiguration.
ApplicationConfiguration.Initialize();
Application.Run(new MainWindow());
}
}
}

83
SwitchGiftDataManager.WinForm/Properties/Resources.Designer.cs generated Normal file
View File

@@ -0,0 +1,83 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace SwitchGiftDataManager.WinForm.Properties {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class Resources {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal Resources() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SwitchGiftDataManager.WinForm.Properties.Resources", typeof(Resources).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
/// </summary>
internal static System.Drawing.Icon icon {
get {
object obj = ResourceManager.GetObject("icon", resourceCulture);
return ((System.Drawing.Icon)(obj));
}
}
/// <summary>
/// Looks up a localized resource of type System.Drawing.Bitmap.
/// </summary>
internal static System.Drawing.Bitmap icon1 {
get {
object obj = ResourceManager.GetObject("icon1", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
}
}

127
SwitchGiftDataManager.WinForm/Properties/Resources.resx Normal file
View File

@@ -0,0 +1,127 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="icon" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\icon.ico;System.Drawing.Icon, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="icon1" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\icon.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
</root>

BIN
SwitchGiftDataManager.WinForm/Resources/icon.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 77 KiB

BIN
SwitchGiftDataManager.WinForm/Resources/icon.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 107 KiB

201
SwitchGiftDataManager.WinForm/SaveWindow.Designer.cs generated Normal file
View File

@@ -0,0 +1,201 @@
namespace SwitchGiftDataManager.WinForm
{
partial class SaveWindow
{
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(SaveWindow));
this.GrpBuild = new System.Windows.Forms.GroupBox();
this.RadioUnique = new System.Windows.Forms.RadioButton();
this.RadioMultiple = new System.Windows.Forms.RadioButton();
this.TxtDestPath = new System.Windows.Forms.TextBox();
this.BtnPath = new System.Windows.Forms.Button();
this.GrpDest = new System.Windows.Forms.GroupBox();
this.BtnCancel = new System.Windows.Forms.Button();
this.BtnSave = new System.Windows.Forms.Button();
this.FolderBrowser = new System.Windows.Forms.FolderBrowserDialog();
this.groupBox2 = new System.Windows.Forms.GroupBox();
this.BtnSrcBrowse = new System.Windows.Forms.Button();
this.TxtSourcePath = new System.Windows.Forms.TextBox();
this.GrpBuild.SuspendLayout();
this.GrpDest.SuspendLayout();
this.groupBox2.SuspendLayout();
this.SuspendLayout();
//
// GrpBuild
//
this.GrpBuild.Controls.Add(this.RadioUnique);
this.GrpBuild.Controls.Add(this.RadioMultiple);
this.GrpBuild.Location = new System.Drawing.Point(12, 12);
this.GrpBuild.Name = "GrpBuild";
this.GrpBuild.Size = new System.Drawing.Size(458, 58);
this.GrpBuild.TabIndex = 0;
this.GrpBuild.TabStop = false;
this.GrpBuild.Text = "Build Method";
//
// RadioUnique
//
this.RadioUnique.AutoSize = true;
this.RadioUnique.Location = new System.Drawing.Point(238, 26);
this.RadioUnique.Name = "RadioUnique";
this.RadioUnique.Size = new System.Drawing.Size(156, 24);
this.RadioUnique.TabIndex = 1;
this.RadioUnique.Text = "Keep separate files";
this.RadioUnique.UseVisualStyleBackColor = true;
//
// RadioMultiple
//
this.RadioMultiple.AutoSize = true;
this.RadioMultiple.Checked = true;
this.RadioMultiple.Location = new System.Drawing.Point(76, 26);
this.RadioMultiple.Name = "RadioMultiple";
this.RadioMultiple.Size = new System.Drawing.Size(145, 24);
this.RadioMultiple.TabIndex = 0;
this.RadioMultiple.TabStop = true;
this.RadioMultiple.Text = "Merge as one file";
this.RadioMultiple.UseVisualStyleBackColor = true;
//
// TxtDestPath
//
this.TxtDestPath.Location = new System.Drawing.Point(6, 26);
this.TxtDestPath.Name = "TxtDestPath";
this.TxtDestPath.Size = new System.Drawing.Size(358, 27);
this.TxtDestPath.TabIndex = 1;
//
// BtnPath
//
this.BtnPath.Location = new System.Drawing.Point(370, 26);
this.BtnPath.Name = "BtnPath";
this.BtnPath.Size = new System.Drawing.Size(82, 29);
this.BtnPath.TabIndex = 2;
this.BtnPath.Text = "Browse";
this.BtnPath.UseVisualStyleBackColor = true;
this.BtnPath.Click += new System.EventHandler(this.BtnPath_Click);
//
// GrpDest
//
this.GrpDest.Controls.Add(this.TxtDestPath);
this.GrpDest.Controls.Add(this.BtnPath);
this.GrpDest.Location = new System.Drawing.Point(12, 153);
this.GrpDest.Name = "GrpDest";
this.GrpDest.Size = new System.Drawing.Size(458, 66);
this.GrpDest.TabIndex = 3;
this.GrpDest.TabStop = false;
this.GrpDest.Text = "Destination BCAT Path";
//
// BtnCancel
//
this.BtnCancel.Location = new System.Drawing.Point(99, 225);
this.BtnCancel.Name = "BtnCancel";
this.BtnCancel.Size = new System.Drawing.Size(125, 29);
this.BtnCancel.TabIndex = 4;
this.BtnCancel.Text = "Cancel";
this.BtnCancel.UseVisualStyleBackColor = true;
this.BtnCancel.Click += new System.EventHandler(this.BtnCancel_Click);
//
// BtnSave
//
this.BtnSave.Location = new System.Drawing.Point(250, 225);
this.BtnSave.Name = "BtnSave";
this.BtnSave.Size = new System.Drawing.Size(125, 29);
this.BtnSave.TabIndex = 5;
this.BtnSave.Text = "Save";
this.BtnSave.UseVisualStyleBackColor = true;
this.BtnSave.Click += new System.EventHandler(this.BtnSave_Click);
//
// groupBox2
//
this.groupBox2.Controls.Add(this.BtnSrcBrowse);
this.groupBox2.Controls.Add(this.TxtSourcePath);
this.groupBox2.Location = new System.Drawing.Point(12, 76);
this.groupBox2.Name = "groupBox2";
this.groupBox2.Size = new System.Drawing.Size(458, 66);
this.groupBox2.TabIndex = 6;
this.groupBox2.TabStop = false;
this.groupBox2.Text = "Source BCAT Path";
//
// BtnSrcBrowse
//
this.BtnSrcBrowse.Location = new System.Drawing.Point(370, 26);
this.BtnSrcBrowse.Name = "BtnSrcBrowse";
this.BtnSrcBrowse.Size = new System.Drawing.Size(82, 27);
this.BtnSrcBrowse.TabIndex = 1;
this.BtnSrcBrowse.Text = "Browse";
this.BtnSrcBrowse.UseVisualStyleBackColor = true;
this.BtnSrcBrowse.Click += new System.EventHandler(this.BtnSrcBrowse_Click);
//
// TxtSourcePath
//
this.TxtSourcePath.Location = new System.Drawing.Point(6, 26);
this.TxtSourcePath.Name = "TxtSourcePath";
this.TxtSourcePath.Size = new System.Drawing.Size(358, 27);
this.TxtSourcePath.TabIndex = 0;
//
// SaveWindow
//
this.AcceptButton = this.BtnSave;
this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 20F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.CancelButton = this.BtnCancel;
this.ClientSize = new System.Drawing.Size(483, 261);
this.Controls.Add(this.groupBox2);
this.Controls.Add(this.BtnSave);
this.Controls.Add(this.BtnCancel);
this.Controls.Add(this.GrpDest);
this.Controls.Add(this.GrpBuild);
this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon")));
this.MaximizeBox = false;
this.MinimizeBox = false;
this.Name = "SaveWindow";
this.ShowInTaskbar = false;
this.Text = "Save BCAT Package";
this.GrpBuild.ResumeLayout(false);
this.GrpBuild.PerformLayout();
this.GrpDest.ResumeLayout(false);
this.GrpDest.PerformLayout();
this.groupBox2.ResumeLayout(false);
this.groupBox2.PerformLayout();
this.ResumeLayout(false);
}
#endregion
private GroupBox GrpBuild;
private RadioButton RadioUnique;
private RadioButton RadioMultiple;
private TextBox TxtDestPath;
private Button BtnPath;
private GroupBox GrpDest;
private Button BtnCancel;
private Button BtnSave;
private FolderBrowserDialog FolderBrowser;
private GroupBox groupBox2;
private Button BtnSrcBrowse;
private TextBox TxtSourcePath;
}
}

186
SwitchGiftDataManager.WinForm/SaveWindow.cs Normal file
View File

@@ -0,0 +1,186 @@
using System.IO;
using SwitchGiftDataManager.Core;
using Enums;
namespace SwitchGiftDataManager.WinForm
{
public partial class SaveWindow : Form
{
private BCATManager Package;
private Games Game;
public SaveWindow(BCATManager bcat, Games game)
{
InitializeComponent();
Package = bcat;
Game = game;
if(Game is Games.LGPE)
{
RadioUnique.Checked = true;
RadioMultiple.Enabled = false;
}
}
private void BtnCancel_Click(object sender, EventArgs e) => this.Close();
private void BtnSrcBrowse_Click(object sender, EventArgs e)
{
if(FolderBrowser.ShowDialog() == DialogResult.OK)
{
TxtSourcePath.Text = FolderBrowser.SelectedPath;
TxtDestPath.Text = Path.GetDirectoryName(FolderBrowser.SelectedPath);
}
}
private void BtnPath_Click(object sender, EventArgs e)
{
if (FolderBrowser.ShowDialog() == DialogResult.OK)
TxtDestPath.Text = FolderBrowser.SelectedPath;
}
private void BtnSave_Click(object sender, EventArgs e)
{
if(!RadioUnique.Checked && !RadioMultiple.Checked)
{
MessageBox.Show("Select a Build Method.");
return;
}
if (!CheckValidBcatPath(TxtSourcePath.Text))
{
MessageBox.Show("Invalid BCAT source path");
return;
}
if (!CheckValidPath(TxtDestPath.Text))
{
MessageBox.Show("Invalid destination path.");
return;
}
var path = $"{TxtDestPath.Text}\\Forged_BCAT_{Game}";
CopyDirectory(TxtSourcePath.Text, path);
if (RadioMultiple.Checked)
{
try
{
var wcdata = Package.ConcatenateFiles();
var metadata = Package.ForgeMetaInfo(wcdata.ToArray());
var metadatapath = $"{path}\\directories\\{Package.GetDefaultBcatFolderName()}";
var wcpath = $"{metadatapath}\\files";
if (Directory.Exists(metadatapath))
DeleteFilesAndDirectory(metadatapath);
Directory.CreateDirectory(wcpath);
File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray());
File.WriteAllBytes($"{wcpath}\\{Package.GetDefaultBcatFileName()}", wcdata.ToArray());
MessageBox.Show("Done");
this.Close();
}
catch (Exception)
{
MessageBox.Show("Internal Error");
this.Close();
}
}
else
{
var metadata = Package.ForgeMetaInfo();
var metadatapath = $"{path}\\directories\\{Package.GetDefaultBcatFolderName()}";
var wcspath = $"{metadatapath}\\files";
if (Directory.Exists(metadatapath))
DeleteFilesAndDirectory(metadatapath);
Directory.CreateDirectory(wcspath);
File.WriteAllBytes($"{metadatapath}\\files.meta", metadata.ToArray());
if (Package.TrySaveAllWondercards(wcspath))
{
MessageBox.Show("Done.");
this.Close();
}
else
{
MessageBox.Show("Internal error.");
this.Close();
}
}
}
private bool CheckValidBcatPath(string path)
{
if (string.IsNullOrWhiteSpace(path))
return false;
if (!Directory.Exists($"{path}\\directories"))
return false;
if (!File.Exists($"{path}\\directories.meta"))
return false;
if (!File.Exists($"{path}\\etag.bin"))
return false;
if (!File.Exists($"{path}\\list.msgpack"))
return false;
if (!File.Exists($"{path}\\na_required"))
return false;
if (!File.Exists($"{path}\\passphrase.bin"))
return false;
return true;
}
private bool CheckValidPath(string path)
{
if(string.IsNullOrWhiteSpace(path))
return false;
if (!Directory.Exists(path))
return false;
return true;
}
private static void CopyDirectory(string source, string dest)
{
var dir = new DirectoryInfo(source);
DirectoryInfo[] dirs = dir.GetDirectories();
Directory.CreateDirectory(dest);
foreach (FileInfo file in dir.GetFiles())
{
string targetFilePath = Path.Combine(dest, file.Name);
if(!File.Exists(targetFilePath))
file.CopyTo(targetFilePath);
}
foreach (DirectoryInfo subDir in dirs)
{
string newDestinationDir = Path.Combine(dest, subDir.Name);
CopyDirectory(subDir.FullName, newDestinationDir);
}
}
private void DeleteFilesAndDirectory(string targetDir)
{
string[] files = Directory.GetFiles(targetDir);
string[] dirs = Directory.GetDirectories(targetDir);
foreach (string file in files)
{
File.SetAttributes(file, FileAttributes.Normal);
File.Delete(file);
}
foreach (string dir in dirs)
DeleteFilesAndDirectory(dir);
Directory.Delete(targetDir, false);
}
}
}

1386
SwitchGiftDataManager.WinForm/SaveWindow.resx Normal file
View File

File diff suppressed because it is too large Load Diff

83
SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj Normal file
View File

@@ -0,0 +1,83 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>net6.0-windows</TargetFramework>
<Nullable>enable</Nullable>
<UseWindowsForms>true</UseWindowsForms>
<ImplicitUsings>enable</ImplicitUsings>
<PackageIcon>Resources\icon.png</PackageIcon>
<ApplicationIcon>Resources\icon.ico</ApplicationIcon>
<Authors>Manu098vm</Authors>
<AssemblyName>$(MSBuildProjectName)</AssemblyName>
<Copyright>Copyright (C) 2022 Manu098vm</Copyright>
<PackageReadmeFile>README.md</PackageReadmeFile>
<PackageTags>pokemon; mystery gift; wondercard; reader; nintendo; bcat; event injection;</PackageTags>
<PackageLicenseFile>LICENSE</PackageLicenseFile>
<Company>Project Pokémon</Company>
<PackageProjectUrl>https://github.com/Manu098vm/Switch-Gift-Data-Manager</PackageProjectUrl>
<RepositoryUrl>https://github.com/Manu098vm/Switch-Gift-Data-Manager</RepositoryUrl>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>embedded</DebugType>
<Optimize>True</Optimize>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>embedded</DebugType>
</PropertyGroup>
<ItemGroup>
<None Include="..\README.md">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<None Include="..\LICENSE">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SwitchGiftDataManager.Core\SwitchGiftDataManager.Core.csproj">
<Private>True</Private>
<CopyLocalSatelliteAssemblies>True</CopyLocalSatelliteAssemblies>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Compile Update="Properties\Resources.Designer.cs">
<DesignTime>True</DesignTime>
<AutoGen>True</AutoGen>
<DependentUpon>Resources.resx</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Update="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<None Update="Resources\icon.png">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="$(ConfigurationName) == Release">
<Move SourceFiles="$(OUTDIR)\SwitchGiftDataManager.WinForm.exe" DestinationFiles="$(OUTDIR)\Switch Gift Data Manager.exe" />
</Target>
<Target Name="PostClean" AfterTargets="Clean" Condition="$(ConfigurationName) == Release">
<RemoveDir Directories="$(TargetDir)" />
<RemoveDir Directories="$(ProjectDir)$(BaseIntermediateOutputPath)" />
</Target>
</Project>

11
SwitchGiftDataManager.WinForm/SwitchGiftDataManager.WinForm.csproj.user Normal file
View File

@@ -0,0 +1,11 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Compile Update="MainWindow.cs">
<SubType>Form</SubType>
</Compile>
<Compile Update="SaveWindow.cs">
<SubType>Form</SubType>
</Compile>
</ItemGroup>
</Project>

47
SwitchGiftDataManager.sln Normal file
View File

@@ -0,0 +1,47 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.2.32602.215
MinimumVisualStudioVersion = 10.0.40219.1
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SwitchGiftDataManager.Core", "SwitchGiftDataManager.Core\SwitchGiftDataManager.Core.csproj", "{40C66FF0-A353-46EA-B958-24586D4DD19D}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SwitchGiftDataManager.WinForm", "SwitchGiftDataManager.WinForm\SwitchGiftDataManager.WinForm.csproj", "{6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}"
ProjectSection(ProjectDependencies) = postProject
{40C66FF0-A353-46EA-B958-24586D4DD19D} = {40C66FF0-A353-46EA-B958-24586D4DD19D}
EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C228A89E-40A6-44D8-B4D2-E86AE8E84C3F}"
ProjectSection(SolutionItems) = preProject
.editorconfig = .editorconfig
LICENSE = LICENSE
README.md = README.md
EndProjectSection
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SwitchGiftDataManager.CommandLine", "SwitchGiftDataManager.CommandLine\SwitchGiftDataManager.CommandLine.csproj", "{61B325BA-48B8-425F-BA22-505453B8A9A9}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{40C66FF0-A353-46EA-B958-24586D4DD19D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{40C66FF0-A353-46EA-B958-24586D4DD19D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{40C66FF0-A353-46EA-B958-24586D4DD19D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{40C66FF0-A353-46EA-B958-24586D4DD19D}.Release|Any CPU.Build.0 = Release|Any CPU
{6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6716CC9C-FE4B-4CF6-B02D-CC47182A2EC8}.Release|Any CPU.Build.0 = Release|Any CPU
{61B325BA-48B8-425F-BA22-505453B8A9A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{61B325BA-48B8-425F-BA22-505453B8A9A9}.Debug|Any CPU.Build.0 = Debug|Any CPU
{61B325BA-48B8-425F-BA22-505453B8A9A9}.Release|Any CPU.ActiveCfg = Release|Any CPU
{61B325BA-48B8-425F-BA22-505453B8A9A9}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {01702004-A955-4F4E-851F-66A6BE55BB42}
EndGlobalSection
EndGlobal