public void ReadActiveSlot(int box, int slot)
{
var data = Bot.ReadSlot(box, slot);
var pkm = PKMConverter.GetPKMfromBytes(data);
if (pkm != null)
{
Editor.PopulateFields(pkm);
}
}
private bool LoadPKM(PKM pk)
{
pk = PKMConverter.ConvertToType(pk, SaveFileEditor.SAV.PKMType, out _);
if (pk == null)
{
return(false);
}
PKMEditor.PopulateFields(pk);
return(true);
}
private static List <PKM> LoadPKMSaves(string pkmdb, string savdb, string EXTERNAL_SAV, SaveFile SAV)
{
var dbTemp = new ConcurrentBag <PKM>();
var files = Directory.EnumerateFiles(pkmdb, "*", SearchOption.AllDirectories);
var extensions = new HashSet <string>(PKM.Extensions.Select(z => $".{z}"));
Parallel.ForEach(files, file =>
{
FileInfo fi = new FileInfo(file);
if (!extensions.Contains(fi.Extension) || !PKX.IsPKM(fi.Length))
{
return;
}
var data = File.ReadAllBytes(file);
var prefer = PKX.GetPKMFormatFromExtension(fi.Extension, SAV.Generation);
var pk = PKMConverter.GetPKMfromBytes(data, file, prefer);
if (pk?.Species > 0)
{
dbTemp.Add(pk);
}
});
#if LOADALL
if (SaveUtil.GetSavesFromFolder(savdb, false, out IEnumerable <string> result))
{
Parallel.ForEach(result, file =>
{
var sav = SaveUtil.GetVariantSAV(file);
var path = EXTERNAL_SAV + new FileInfo(file).Name;
if (sav.HasBox)
{
foreach (var pk in sav.BoxData)
{
addPKM(pk);
}
}
void addPKM(PKM pk)
{
pk.Identifier = Path.Combine(path, pk.Identifier);
dbTemp.Add(pk);
}
});
}
#endif
// Fetch from save file
var savpkm = SAV.BoxData.Where(pk => pk.Species != 0);
var bakpkm = dbTemp.Where(pk => pk.Species != 0).OrderBy(pk => pk.Identifier);
var db = bakpkm.Concat(savpkm).Where(pk => pk.ChecksumValid && pk.Sanity == 0);
// Prepare Database
return(new List <PKM>(db));
}
private void LoadDatabase()
{
var dbTemp = new ConcurrentBag <PKM>();
var files = Directory.EnumerateFiles(DatabasePath, "*", SearchOption.AllDirectories);
Parallel.ForEach(files, file =>
{
FileInfo fi = new FileInfo(file);
if (!fi.Extension.Contains(".pk") || !PKX.IsPKM(fi.Length))
{
return;
}
var pk = PKMConverter.GetPKMfromBytes(File.ReadAllBytes(file), file, prefer: (fi.Extension.Last() - '0') & 0xF);
if (pk != null)
{
dbTemp.Add(pk);
}
});
#if LOADALL
if (SaveUtil.GetSavesFromFolder(Main.BackupPath, false, out IEnumerable <string> result))
{
Parallel.ForEach(result, file =>
{
var sav = SaveUtil.GetVariantSAV(File.ReadAllBytes(file));
var path = EXTERNAL_SAV + new FileInfo(file).Name;
if (sav.HasBox)
{
foreach (var pk in sav.BoxData)
{
addPKM(pk);
}
}
void addPKM(PKM pk)
{
pk.Identifier = Path.Combine(path, pk.Identifier);
dbTemp.Add(pk);
}
});
}
#endif
// Prepare Database
RawDB = new List <PKM>(dbTemp.OrderBy(pk => pk.Identifier)
.Concat(SAV.BoxData.Where(pk => pk.Species != 0)) // Fetch from save file
.Where(pk => pk.ChecksumValid && pk.Species != 0 && pk.Sanity == 0)
.Distinct());
try
{
BeginInvoke(new MethodInvoker(() => SetResults(RawDB)));
}
catch { /* Window Closed? */ }
}
/// <summary>
/// Imports a <see cref="set"/> to create a new <see cref="PKM"/> with a context of <see cref="tr"/>.
/// </summary>
/// <param name="tr">Source/Destination trainer</param>
/// <param name="set">Set data to import</param>
/// <param name="msg">Result code indicating success or failure</param>
/// <returns>Legalized PKM (hopefully legal)</returns>
public static PKM GetLegalFromSet(this ITrainerInfo tr, IBattleTemplate set, out LegalizationResult msg)
{
var template = PKMConverter.GetBlank(tr.Generation, (GameVersion)tr.Game);
if (template.Version == 0)
{
template.Version = tr.Game;
}
template.ApplySetDetails(set);
return(tr.GetLegalFromSet(set, template, out msg));
}
public bool LoadFolder(string path)
{
Clear();
Files.Clear();
if (!Directory.Exists(path))
{
return(false);
}
var loadedAny = false;
var files = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories);
var matchFiles = LoadUtil.GetFilesOfSize(files, ExpectedSize);
int surpriseBlocked = 0;
foreach (var file in matchFiles)
{
var data = File.ReadAllBytes(file);
var pkm = PKMConverter.GetPKMfromBytes(data);
if (!(pkm is T dest))
{
continue;
}
if (dest.Species == 0 || !new LegalityAnalysis(dest).Valid || !(dest is PK8 pk8))
{
LogUtil.LogInfo("SKIPPED: Provided pk8 is not valid: " + dest.FileName, nameof(PokemonPool <T>));
continue;
}
if (DisallowSurpriseTrade(pk8))
{
LogUtil.LogInfo("Provided pk8 has a special ribbon and can't be Surprise Traded: " + dest.FileName, nameof(PokemonPool <T>));
surpriseBlocked++;
}
if (Settings.ResetHOMETracker)
{
pk8.Tracker = 0;
}
Add(dest);
var fn = Path.GetFileNameWithoutExtension(file);
Files.Add(fn, new LedyRequest <T>(dest, fn));
loadedAny = true;
}
if (surpriseBlocked == Count)
{
LogUtil.LogInfo("Surprise trading will fail; failed to load any compatible files.", nameof(PokemonPool <T>));
}
return(loadedAny);
}
/// <summary>
/// Main function that auto legalizes based on the legality
/// </summary>
/// <remarks>Leverages <see cref="Core"/>'s <see cref="EncounterMovesetGenerator"/> to create a <see cref="PKM"/> from a <see cref="ShowdownSet"/>.</remarks>
/// <param name="dest">Destination for the generated pkm</param>
/// <param name="template">rough pkm that has all the <see cref="set"/> values entered</param>
/// <param name="set">Showdown set object</param>
/// <param name="satisfied">If the final result is satisfactory, otherwise use deprecated bruteforce auto legality functionality</param>
public static PKM GetLegalFromTemplate(this ITrainerInfo dest, PKM template, ShowdownSet set, out bool satisfied)
{
var Form = SanityCheckForm(template, ref set);
template.ApplySetDetails(set);
template.SetRecordFlags(); // Validate TR moves for the encounter
var destType = template.GetType();
var destVer = (GameVersion)dest.Game;
if (destVer <= 0 && dest is SaveFile s)
{
destVer = s.Version;
}
var gamelist = GameUtil.GetVersionsWithinRange(template, template.Format).OrderByDescending(c => c.GetGeneration()).ToArray();
var encounters = EncounterMovesetGenerator.GenerateEncounters(pk: template, moves: set.Moves, gamelist);
foreach (var enc in encounters)
{
var ver = enc is IVersion v ? v.Version : destVer;
var gen = enc is IGeneration g ? g.Generation : dest.Generation;
ITrainerInfo tr = new SimpleTrainerInfo(ver);
if (UseTrainerData)
{
tr = TrainerSettings.GetSavedTrainerData(ver, gen, new SimpleTrainerInfo(ver));
}
var raw = SanityCheckEncounters(enc).ConvertToPKM(tr);
var pk = PKMConverter.ConvertToType(raw, destType, out _);
if (pk == null)
{
continue;
}
ApplySetDetails(pk, set, Form, raw, dest, enc);
if (set.CanGigantamax && pk is IGigantamax gmax)
{
if (!gmax.CanGigantamax)
{
continue;
}
}
var la = new LegalityAnalysis(pk);
if (la.Valid)
{
satisfied = true;
return(pk);
}
Debug.WriteLine(la.Report());
}
satisfied = false;
return(template);
}
public static IEnumerable <T> GetPKMFilesOfType <T>(IEnumerable <string> files)
{
foreach (var file in files)
{
var data = File.ReadAllBytes(file);
var pkm = PKMConverter.GetPKMfromBytes(data);
if (pkm is T dest)
{
yield return(dest);
}
}
}
private static PK8?GetRequest(Download <PKM> dl)
{
if (!dl.Success)
{
return(null);
}
return(dl.Data switch
{
null => null,
PK8 pk8 => pk8,
_ => PKMConverter.ConvertToType(dl.Data, typeof(PK8), out _) as PK8
});
/// <summary>
/// Gets a legal <see cref="PKM"/> from a random in-game encounter's data.
/// </summary>
/// <param name="tr">Trainer Data to use in generating the encounter</param>
/// <param name="species">Species ID to generate</param>
/// <param name="pk">Result legal pkm</param>
/// <returns>True if a valid result was generated, false if the result should be ignored.</returns>
public static bool GetRandomEncounter(this ITrainerInfo tr, int species, out PKM?pk)
{
var blank = PKMConverter.GetBlank(tr.Generation, tr.Game);
pk = GetRandomEncounter(blank, tr, species);
if (pk == null)
{
return(false);
}
pk = PKMConverter.ConvertToType(pk, blank.GetType(), out _);
return(pk != null);
}
/// <summary>
/// Gets a legal <see cref="PKM"/> from a random in-game encounter's data.
/// </summary>
/// <param name="sav">Save File to receive the generated <see cref="PKM"/>.</param>
/// <param name="tr">Trainer Data to use in generating the encounter</param>
/// <param name="species">Species ID to generate</param>
/// <param name="pk">Result legal pkm</param>
/// <returns>True if a valid result was generated, false if the result should be ignored.</returns>
public static bool GetRandomEncounter(this SaveFile sav, ITrainerInfo tr, int species, out PKM?pk)
{
var blank = sav.BlankPKM;
pk = GetRandomEncounter(blank, tr, species);
if (pk == null)
{
return(false);
}
pk = PKMConverter.ConvertToType(pk, sav.PKMType, out _);
return(pk != null);
}
/// <summary>
/// Gets a legal <see cref="PKM"/> from a random in-game encounter's data.
/// </summary>
/// <param name="tr">Trainer Data to use in generating the encounter</param>
/// <param name="species">Species ID to generate</param>
/// <param name="form">Form to generate; if left null, picks first encounter</param>
/// <param name="shiny"></param>
/// <param name="alpha"></param>
/// <param name="attempt"></param>
/// <param name="pk">Result legal pkm</param>
/// <returns>True if a valid result was generated, false if the result should be ignored.</returns>
public static bool GetRandomEncounter(this ITrainerInfo tr, int species, int?form, bool shiny, bool alpha, ref int attempt, out PKM?pk)
{
var blank = PKMConverter.GetBlank(tr.Generation, tr.Game);
pk = GetRandomEncounter(blank, tr, species, form, shiny, alpha, ref attempt);
if (pk == null)
{
return(false);
}
pk = PKMConverter.ConvertToType(pk, blank.GetType(), out _);
return(pk != null);
}
public bool ReadOffset(uint offset)
{
var data = Bot.ReadOffset(offset);
var pkm = PKMConverter.GetPKMfromBytes(data);
// Since data might not actually exist at the user-specified offset, double check that the pkm data is valid.
if (pkm == null || !pkm.ChecksumValid)
{
return(false);
}
Editor.PopulateFields(pkm);
return(true);
}
private async Task Legalize(IAttachment att)
{
var sanitized = $"`{att.Filename.Replace("`", "\\`")}`";
if (!PKX.IsPKM(att.Size))
{
await ReplyAsync($"{sanitized}: Invalid size.").ConfigureAwait(false);
return;
}
string url = att.Url;
// Download the resource and load the bytes into a buffer.
byte[] buffer = await webClient.DownloadDataTaskAsync(url).ConfigureAwait(false);
var pkm = PKMConverter.GetPKMfromBytes(buffer, sanitized.Contains("pk6") ? 6 : 7);
if (pkm == null)
{
await ReplyAsync($"{sanitized}: Invalid pkm attachment.").ConfigureAwait(false);
return;
}
if (new LegalityAnalysis(pkm).Valid)
{
await ReplyAsync($"{sanitized}: Already legal.").ConfigureAwait(false);
return;
}
var legal = pkm.Legalize();
if (legal == null || !new LegalityAnalysis(legal).Valid)
{
await ReplyAsync($"{sanitized}: Unable to legalize.").ConfigureAwait(false);
return;
}
legal.RefreshChecksum();
var tmp = Path.Combine(Path.GetTempPath(), Util.CleanFileName(legal.FileName));
File.WriteAllBytes(tmp, legal.DecryptedPartyData);
var msg = $"Here's your legalized PKM for {sanitized}!";
await Context.Channel.SendFileAsync(tmp, msg).ConfigureAwait(false);
File.Delete(tmp);
}
private void B_Connect_Click(object sender, EventArgs e)
{
try
{
// Enable controls
B_Connect.Enabled = TB_IP.Enabled = TB_Port.Enabled = false;
groupBox1.Enabled = groupBox2.Enabled = groupBox3.Enabled = true;
var ConnectionEstablished = false;
var currver = LiveHeXVersion.SWSH_Rigel1;
var validversions = RamOffsets.GetValidVersions(SAV.SAV);
foreach (LiveHeXVersion ver in validversions)
{
Remote.Bot = new PokeSysBotMini(ver);
Remote.Bot.IP = TB_IP.Text;
Remote.Bot.Port = int.Parse(TB_Port.Text);
Remote.Bot.Connect();
var data = Remote.Bot.ReadSlot(1, 1);
var pkm = PKMConverter.GetPKMfromBytes(data);
if (pkm != null && pkm.ChecksumValid && pkm.Species > -1)
{
ConnectionEstablished = true;
currver = ver;
break;
}
if (Remote.Bot.Connected)
{
Remote.Bot.Disconnect();
}
}
if (!ConnectionEstablished)
{
Remote.Bot = new PokeSysBotMini(currver);
Remote.Bot.IP = TB_IP.Text;
Remote.Bot.Port = int.Parse(TB_Port.Text);
Remote.Bot.Connect();
}
// Load current box
Remote.ReadBox(SAV.CurrentBox);
// Set Trainer Data
SetTrainerData(SAV.SAV, currver);
}
catch (Exception ex)
{
WinFormsUtil.Error(ex.Message);
}
}
public void HiddenPowerTest(int h, int a, int b, int c, int d, int s, MoveType type, int power, Type pkmType)
{
var pkm = PKMConverter.GetBlank(pkmType);
pkm.IV_HP = h;
pkm.IV_ATK = a;
pkm.IV_DEF = b;
pkm.IV_SPA = c;
pkm.IV_SPD = d;
pkm.IV_SPE = s;
pkm.HPType.Should().Be((int)type - 1); // no normal type, down-shift by 1
pkm.HPPower.Should().Be(power);
}
public dynamic CheckLegality([FromForm][Required] IFormFile pokemon, [FromForm] string generation, bool bot)
{
using var memoryStream = new MemoryStream();
pokemon.CopyTo(memoryStream);
PKM pkm;
byte[] data = memoryStream.ToArray();
try
{
if (string.IsNullOrEmpty(generation))
{
pkm = PKMConverter.GetPKMfromBytes(data);
if (pkm == null)
{
throw new System.ArgumentException("Bad data!");
}
generation = Utils.GetGeneration(pkm);
}
else
{
pkm = Utils.GetPKMwithGen(generation, data);
if (pkm == null)
{
throw new System.ArgumentException("Bad generation!");
}
}
}
catch
{
Response.StatusCode = 400;
return("Bad Data Was Provided");
}
if (!Utils.PokemonExistsInGeneration(generation, pkm.Species))
{
Response.StatusCode = 400;
return("Pokemon not in generation!");
}
var la = new LegalityAnalysis(pkm);
if (bot)
{
return(la.Report());
}
return(new { report = la.Report().Replace("\r", string.Empty).Split('\n'), legal = la.Valid });
}
public async Task TradeAsync([Summary("Trade Code")] int code, [Summary("Showdown Set")][Remainder] string content)
{
content = ReusableActions.StripCodeBlock(content);
var set = new ShowdownSet(content);
var template = AutoLegalityWrapper.GetTemplate(set);
if (set.InvalidLines.Count != 0)
{
var msg = $"Unable to parse Showdown Set:\n{string.Join("\n", set.InvalidLines)}";
await ReplyAsync(msg).ConfigureAwait(false);
return;
}
try
{
var sav = AutoLegalityWrapper.GetTrainerInfo <T>();
var pkm = sav.GetLegal(template, out var result);
var la = new LegalityAnalysis(pkm);
var spec = GameInfo.Strings.Species[template.Species];
pkm = PKMConverter.ConvertToType(pkm, typeof(T), out _) ?? pkm;
if (pkm is not T pk || !la.Valid)
{
var reason = result == "Timeout" ? $"That {spec} set took too long to generate." : $"I wasn't able to create a {spec} from that set.";
var imsg = $"Oops! {reason}";
if (result == "Failed")
{
imsg += $"\n{AutoLegalityWrapper.GetLegalizationHint(template, sav, pkm)}";
}
await ReplyAsync(imsg).ConfigureAwait(false);
return;
}
pk.ResetPartyStats();
var sig = Context.User.GetFavor();
await AddTradeToQueueAsync(code, Context.User.Username, pk, sig, Context.User).ConfigureAwait(false);
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
#pragma warning restore CA1031 // Do not catch general exception types
{
LogUtil.LogSafe(ex, nameof(TradeModule <T>));
var msg = $"Oops! An unexpected problem happened with this Showdown Set:\n```{string.Join("\n", set.GetSetLines())}```";
await ReplyAsync(msg).ConfigureAwait(false);
}
}
private static void InitializeTrainerDatabase()
{
var ot = GetEnvOrThrow("PKHEX_DEFAULT_OT");
var trainerId = int.Parse(GetEnvOrThrow("PKHEX_DEFAULT_TID"));
var secretId = int.Parse(GetEnvOrThrow("PKHEX_DEFAULT_SID"));
var languageName = GetEnvOrThrow("PKHEX_DEFAULT_LANGUAGE");
if (!Enum.TryParse <LanguageID>(languageName, true, out var language))
{
throw new Exception($"Invalid default language {languageName}");
}
SaveFile GetFallbackBlank(int generation)
{
var blankSav = SaveUtil.GetBlankSAV(generation, ot);
blankSav.Language = (int)language;
blankSav.TID = trainerId;
blankSav.SID = secretId;
blankSav.OT = ot;
return(blankSav);
}
for (var i = 1; i < PKX.Generation + 1; i++)
{
var versions = GameUtil.GetVersionsInGeneration(i, PKX.Generation);
foreach (var v in versions)
{
var fallback = new SimpleTrainerInfo(v)
{
Language = (int)language,
TID = trainerId,
SID = secretId,
OT = ot,
};
var exist = TrainerSettings.GetSavedTrainerData(v, i, fallback);
if (exist is SimpleTrainerInfo)
{
TrainerSettings.Register(fallback);
}
}
}
var trainer = TrainerSettings.GetSavedTrainerData(PKX.Generation);
PKMConverter.SetPrimaryTrainer(trainer);
}
public string Post()
{
if (Request.ContentType != "application/octet-stream")
{
return(string.Empty);
}
if (Request.Body.Length == 0)
{
return(string.Empty);
}
var ver = Request.Headers["Version"];
if (string.IsNullOrWhiteSpace(ver))
{
return(string.Empty);
}
var parsed = Enum.TryParse <GameVersion>(ver, true, out var game);
if (!parsed)
{
return(string.Empty);
}
var data = new byte[Request.Body.Length];
using (var ms = new MemoryStream(data))
Request.Body.CopyTo(ms);
try
{
var pk = PKMConverter.GetPKMfromBytes(data);
var la = new LegalityAnalysis(pk);
if (la.Valid)
{
return(string.Empty);
}
var legalized = Legalize(pk, game, la);
return(Convert.ToBase64String(legalized.DecryptedBoxData));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(string.Empty);
}
}
public static void HasSmogonSets(Type t, GameVersion game, int species, int form = 0)
{
var blank = PKMConverter.GetBlank(t);
blank.Version = (int)game;
blank.Species = species;
blank.Form = form;
var smogon = new SmogonSetList(blank);
smogon.Valid.Should().BeTrue("Sets should exist for this setup");
var count = smogon.Sets.Count;
count.Should().BeGreaterThan(0, "At least one set should exist");
smogon.SetConfig.Count.Should().Be(count, "Unparsed text should be captured and match result count");
smogon.SetText.Count.Should().Be(count, "Reformatted text should be captured and match result count");
}
/// <summary>
/// Creates PKSM's bank.bin to individual <see cref="PKM"/> files (v1)
/// </summary>
/// <param name="dir">Folder to export all dumped files to</param>
public static int CreateBank(string dir)
{
var files = Directory.GetFiles(dir, "*.p??", SearchOption.TopDirectoryOnly);
var ver = Enum.GetValues(typeof(PKSMBankVersion)).Cast <int>().Max();
var version = BitConverter.GetBytes(ver + 1); // Latest bank version
var pksmsize = GetBankSize((PKSMBankVersion)ver);
var boxcount = (files.Length / 30) + 1;
var bank = new byte[8 + 4 + 4 + (boxcount * pksmsize * 30)];
var ctr = 0;
var magic = new byte[] { 0x50, 0x4B, 0x53, 0x4D, 0x42, 0x41, 0x4E, 0x4B }; // PKSMBANK
magic.CopyTo(bank, 0);
version.CopyTo(bank, 8);
BitConverter.GetBytes(boxcount).CopyTo(bank, 12); // Number of bank boxes.
foreach (var f in files)
{
var pk = PKMConverter.GetPKMfromBytes(File.ReadAllBytes(f));
if (pk == null)
{
continue;
}
if (pk.Species == 0 && pk.Species >= pk.MaxSpeciesID)
{
continue;
}
var ofs = 16 + (ctr * pksmsize);
BitConverter.GetBytes((int)GetPKSMFormat(pk)).CopyTo(bank, ofs);
pk.DecryptedBoxData.CopyTo(bank, ofs + 4);
byte[] temp = Enumerable.Repeat((byte)0xFF, pksmsize - pk.DecryptedBoxData.Length - 8).ToArray();
temp.CopyTo(bank, ofs + pk.DecryptedBoxData.Length + 4);
temp = Enumerable.Repeat((byte)0x00, 4).ToArray();
temp.CopyTo(bank, ofs + pksmsize - 4);
ctr++;
}
var empty = (boxcount * 30) - files.Length;
for (int i = 0; i < empty; i++)
{
var ofs = 16 + (ctr * pksmsize);
byte[] temp = Enumerable.Repeat((byte)0xFF, pksmsize).ToArray();
temp.CopyTo(bank, ofs);
ctr++;
}
File.WriteAllBytes(Path.Combine(dir, "alm.bnk"), bank);
return(ctr - empty);
}
private static Tuple <bool, int, int> SingleSaveTest(this GameVersion s, bool includeforms, bool shiny, ref bool passed)
{
ModLogic.IncludeForms = includeforms;
ModLogic.SetShiny = shiny;
var sav = SaveUtil.GetBlankSAV(s, "ALMUT");
PKMConverter.SetPrimaryTrainer(sav);
var pkms = sav.GenerateLivingDex(out int attempts);
var genned = pkms.Count();
var val = new Tuple <bool, int, int>(genned == attempts, attempts, genned);
if (genned != attempts)
{
passed = false;
}
return(val);
}
// ReSharper disable once UnusedParameter.Local
private static void VerifyAll(string folder, string name, bool isValid)
{
var path = Path.Combine(folder, name);
Directory.Exists(path).Should().BeTrue($"the specified test directory at '{path}' should exist");
var files = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories);
var ctr = 0;
foreach (var file in files)
{
var fi = new FileInfo(file);
fi.Should().NotBeNull($"the test file '{file}' should be a valid file");
PKX.IsPKM(fi.Length).Should().BeTrue($"the test file '{file}' should have a valid file length");
var data = File.ReadAllBytes(file);
var format = PKX.GetPKMFormatFromExtension(file[file.Length - 1], -1);
format.Should().BeLessOrEqualTo(PKX.Generation, "filename is expected to have a valid extension");
ParseSettings.AllowGBCartEra = fi.DirectoryName.Contains("GBCartEra");
ParseSettings.AllowGen1Tradeback = fi.DirectoryName.Contains("1 Tradeback");
var pkm = PKMConverter.GetPKMfromBytes(data, prefer: format);
pkm.Should().NotBeNull($"the PKM '{new FileInfo(file).Name}' should have been loaded");
if (pkm == null)
{
continue;
}
var legality = new LegalityAnalysis(pkm);
if (legality.Valid == isValid)
{
ctr++;
continue;
}
if (isValid)
{
legality.Valid.Should().BeTrue($"because the file '{fi.Directory.Name}\\{fi.Name}' should be Valid");
}
else
{
var invalid = legality.Results.Where(z => !z.Valid);
var msg = string.Join(Environment.NewLine, invalid.Select(z => z.Comment));
legality.Valid.Should().BeTrue($"because the file '{fi.Directory.Name}\\{fi.Name}' should be invalid, but found:{Environment.NewLine}{msg}");
}
}
ctr.Should().BeGreaterThan(0);
}
private static PKM GetPKM(string file, FileInfo fi)
{
fi.Should().NotBeNull($"the test file '{file}' should be a valid file");
PKX.IsPKM(fi.Length).Should().BeTrue($"the test file '{file}' should have a valid file length");
var data = File.ReadAllBytes(file);
var format = PKX.GetPKMFormatFromExtension(file[file.Length - 1], -1);
if (format > 10)
{
format = 6;
}
var pkm = PKMConverter.GetPKMfromBytes(data, prefer: format);
pkm.Should().NotBeNull($"the PKM '{new FileInfo(file).Name}' should have been loaded");
return(pkm);
}
public PKM GetPokemon(NetworkStream ns)
{
try
{
byte[] size = Read_NS_Data(ns, 8);
string dataSizeStr = Encoding.UTF8.GetString(size, 0, size.Length);
int.TryParse(dataSizeStr, out int dataSize);
byte[] msg = Read_NS_Data(ns, dataSize);
var pk = PKMConverter.GetPKMfromBytes(msg);
return(pk);
} catch (Exception e)
{
Console.WriteLine("f**k!");
Console.WriteLine(e.ToString());
return(null);
}
}
/// <summary>
/// Accessible method to lead Fields from PKM
/// The Loading is done in WinForms
/// </summary>
/// <param name="pk">The PKM file</param>
/// <param name="focus">Set input focus to control</param>
/// <param name="skipConversionCheck">Default this to true</param>
public void LoadFieldsFromPKM2(PKM pk, bool focus = true, bool skipConversionCheck = true)
{
if (pk == null)
{
WinFormsUtil.Error("Attempted to load a null file."); return;
}
if (focus)
{
Tab_Main.Focus();
}
if (!skipConversionCheck && !PKMConverter.TryMakePKMCompatible(pk, CurrentPKM, out string c, out pk))
{
WinFormsUtil.Alert(c); return;
}
bool oldInit = FieldsInitialized;
FieldsInitialized = FieldsLoaded = false;
pkm = pk.Clone();
try { GetFieldsfromPKM(); }
finally { FieldsInitialized = oldInit; }
Stats.UpdateIVs(null, null);
UpdatePKRSInfected(null, null);
UpdatePKRSCured(null, null);
if (HaX) // Load original values from pk not pkm
{
MT_Level.Text = (pk.Stat_HPMax != 0 ? pk.Stat_Level : PKX.GetLevel(pk.EXP, pk.Species, pk.AltForm)).ToString();
TB_EXP.Text = pk.EXP.ToString();
MT_Form.Text = pk.AltForm.ToString();
if (pk.Stat_HPMax != 0) // stats present
{
Stats.LoadPartyStats(pk);
}
}
FieldsLoaded = true;
SetMarkings();
UpdateLegality();
UpdateSprite();
LastData = PreparePKM()?.Data;
}
public Legalize Legalize([FromForm][Required] IFormFile pokemon, [FromForm] string version, [FromForm] string generation)
{
using var memoryStream = new MemoryStream();
pokemon.CopyTo(memoryStream);
PKM pkm;
byte[] data = memoryStream.ToArray();
try
{
if (string.IsNullOrEmpty(generation))
{
pkm = PKMConverter.GetPKMfromBytes(data);
if (pkm == null)
{
throw new System.ArgumentException("Bad data!");
}
generation = Utils.GetGeneration(pkm);
}
else
{
pkm = Utils.GetPKMwithGen(generation, data);
if (pkm == null)
{
throw new System.ArgumentException("Bad generation!");
}
}
}
catch
{
Response.StatusCode = 400;
return(null);
}
if (string.IsNullOrEmpty(version))
{
version = Utils.GetGameVersion(pkm).ToString();
}
if (!Utils.PokemonExistsInGeneration(generation, pkm.Species))
{
Response.StatusCode = 400;
return(null);
}
return(new Legalize(pkm, version));
}
private async Task <PKM> ImportFromClipboard()
{
var txt = await DataUtil.GetClipboardText().ConfigureAwait(false);
if (txt == null)
{
return(null);
}
try
{
var data = Convert.FromBase64String(txt);
var pkm = PKMConverter.GetPKMfromBytes(data, VM.SAV.Generation);
if (pkm == null)
{
await UserDialogs.Instance
.AlertAsync("Invalid data in device Clipboard!")
.ConfigureAwait(false);
return(null);
}
var converted = PKMConverter.ConvertToType(pkm, VM.SAV.PKMType, out var c);
if (converted == null)
{
await UserDialogs.Instance
.AlertAsync(c)
.ConfigureAwait(false);
return(null);
}
return(converted);
}
catch
{
await UserDialogs.Instance
.AlertAsync("Invalid data in device Clipboard!")
.ConfigureAwait(false);
return(null);
}
}
private void processFolder(string[] files, List <StringInstruction> Filters, List <StringInstruction> Instructions, string destPath)
{
len = err = ctr = 0;
for (int i = 0; i < files.Length; i++)
{
string file = files[i];
if (!PKX.getIsPKM(new FileInfo(file).Length))
{
b.ReportProgress(i);
continue;
}
byte[] data = File.ReadAllBytes(file);
var pkm = PKMConverter.getPKMfromBytes(data);
if (!pkm.Valid)
{
b.ReportProgress(i);
continue;
}
ModifyResult r = ProcessPKM(pkm, Filters, Instructions);
if (r != ModifyResult.Invalid)
{
len++;
}
if (r == ModifyResult.Error)
{
err++;
}
if (r == ModifyResult.Modified)
{
if (pkm.Species > 0)
{
pkm.RefreshChecksum();
File.WriteAllBytes(Path.Combine(destPath, Path.GetFileName(file)), pkm.DecryptedBoxData);
ctr++;
}
}
b.ReportProgress(i);
}
}
