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); } }