Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-12-19 08:53:28 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/Legality/Moves/MoveTutor.cs

404 lines
16 KiB
C#
Raw Normal View History

Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
using System;
using System.Collections.Generic;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
using static PKHeX.Core.Legal;
namespace PKHeX.Core
{
public static class MoveTutor
{
public static GameVersion GetIsTutorMove(PKM pkm, int species, int form, int generation, int move, bool specialTutors = true)
{
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
return generation switch
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
{
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
1 => GetIsTutor1(pkm, species, move),
2 => GetIsTutor2(pkm, species, move),
3 => GetIsTutor3(species, move),
4 => GetIsTutor4(species, form, move),
5 => GetIsTutor5(pkm, species, form, specialTutors, move),
6 => GetIsTutor6(pkm, species, form, specialTutors, move),
7 => GetIsTutor7(pkm, species, form, specialTutors, move),
8 => GetIsTutor8(pkm, species, form, specialTutors, move),
Trailing commas No functional change
2021-08-20 20:49:20 +00:00
_ => NONE,
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
};
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
private static GameVersion GetIsTutor1(PKM pkm, int species, int move)
{
// Surf Pikachu via Stadium
Minor fixes Replace hardcoded move int with enum val Lillipup->Rockruff personal_swsh: remove pledge bitflags (missed in CT update)
2021-09-06 22:38:32 +00:00
if (move != (int)Move.Surf || ParseSettings.AllowGBCartEra)
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return NONE;
Condense some expressions
2021-08-22 08:26:28 +00:00
if (pkm.Format < 3 && species is (int)Species.Pikachu or (int)Species.Raichu)
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return GameVersion.Stadium;
return NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsTutor2(PKM pkm, int species, int move)
{
Misc parse settings reorg makes it more centralized for defining parsing settings, maybe can have flags to change severity of certain preferential checks
2018-10-06 02:58:30 +00:00
if (!ParseSettings.AllowGen2Crystal(pkm))
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return NONE;
var info = PersonalTable.C[species];
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var tutor = Array.IndexOf(Tutors_GSC, move);
if (tutor != -1 && info.TMHM[57 + tutor])
return GameVersion.C;
return NONE;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsTutor3(int species, int move)
{
// E Tutors (Free)
// E Tutors (BP)
var info = PersonalTable.E[species];
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var e = Array.IndexOf(Tutor_E, move);
if (e != -1 && info.TypeTutors[e])
return GameVersion.E;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
// FRLG Tutors
// Only special tutor moves, normal tutor moves are already included in Emerald data
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var frlg = Array.IndexOf(SpecialTutors_FRLG, move);
if (frlg != -1 && SpecialTutors_Compatibility_FRLG[frlg] == species)
return GameVersion.FRLG;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
// XD
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var xd = Array.IndexOf(SpecialTutors_XD_Exclusive, move);
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
if (xd != -1 && SpecialTutors_Compatibility_XD_Exclusive[xd].AsSpan().IndexOf(species) != -1)
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
return GameVersion.XD;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
// XD (Mew)
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
if (species == (int)Species.Mew && Tutor_3Mew.AsSpan().IndexOf(move) != -1)
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return GameVersion.XD;
return NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsTutor4(int species, int form, int move)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.HGSS[species, form];
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var type = Array.IndexOf(Tutors_4, move);
if (type != -1 && pi.TypeTutors[type])
return GameVersion.Gen4;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var special = Array.IndexOf(SpecialTutors_4, move);
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
if (special != -1 && SpecialTutors_Compatibility_4[special].AsSpan().IndexOf(species) != -1)
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
return GameVersion.HGSS;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsTutor5(PKM pkm, int species, int form, bool specialTutors, int move)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.B2W2[species, form];
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var type = Array.IndexOf(TypeTutor6, move);
if (type != -1 && pi.TypeTutors[type])
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return GameVersion.Gen5;
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedB2W2(species))
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Add elemental tutors Closes #2443 Capture some array references to avoid re-fetching array -- array reference is readonly so it probably won't matter
2019-11-17 19:13:52 +00:00
var tutors = Tutors_B2W2;
for (int i = 0; i < tutors.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var tutor = Array.IndexOf(tutors[i], move);
if (tutor == -1)
continue;
if (pi.SpecialTutors[i][tutor])
return GameVersion.B2W2;
break;
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
}
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsTutor6(PKM pkm, int species, int form, bool specialTutors, int move)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.AO[species, form];
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var type = Array.IndexOf(TypeTutor6, move);
if (type != -1 && pi.TypeTutors[type])
return GameVersion.Gen6;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedORAS(species))
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Add elemental tutors Closes #2443 Capture some array references to avoid re-fetching array -- array reference is readonly so it probably won't matter
2019-11-17 19:13:52 +00:00
var tutors = Tutors_AO;
for (int i = 0; i < tutors.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var tutor = Array.IndexOf(tutors[i], move);
if (tutor == -1)
continue;
if (pi.SpecialTutors[i][tutor])
return GameVersion.ORAS;
break;
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
}
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsTutor7(PKM pkm, int species, int form, bool specialTutors, int move)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.USUM[species, form];
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var type = Array.IndexOf(TypeTutor6, move);
if (type != -1 && pi.TypeTutors[type])
return GameVersion.Gen7;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedUSUM(species))
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
var tutor = Array.IndexOf(Tutors_USUM, move);
if (tutor != -1 && pi.SpecialTutors[0][tutor])
return GameVersion.USUM;
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return NONE;
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
private static GameVersion GetIsTutor8(PKM pkm, int species, int form, bool specialTutors, int move)
{
HOME 2.0.0: Handle conversion behavior & restrictions (#3506) * Revises legality checks to account for traveling between the three game islands (PLA/BDSP/SWSH) * Adds conversion mechanisms between the three formats, as well as flexible conversion options to backfill missing data (thanks GameFreak/ILCA for opting for lossy conversion instead of updating the games). * Adds API abstractions for HOME data storage format (EKH/PKH format 1, aka EH1/PH1). * Revises some APIs for better usage: - `PKM` now exposes a `Context` to indicate the isolation context for legality purposes. - Some method signatures have changed to accept `Context` or `GameVersion` instead of a vague `int` for Generation. - Evolution History is now tracked in the Legality parse for specific contexts, rather than only per generation.
2022-05-31 04:43:52 +00:00
if (pkm is PA8)
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = (PersonalInfoLA)PersonalTable.LA[species, form];
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
if (!pi.IsPresentInGame)
return NONE;
Minor tweaks ShowdownSet: Lessen allocation MoveTutor: Remove boxing by calling the generic method instead of object method Xoro8b: Add more xmldoc, use positive constant instead of inverse negative for parity StadiumUtil: Use built-in endianness reversal methods
2022-05-14 15:28:13 +00:00
var index = Array.IndexOf(MoveShop8_LA, (ushort)move);
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
if (index != -1 && pi.SpecialTutors[0][index])
return GameVersion.PLA;
return NONE;
}
Revise more PB7/PK8->Interface type checks
2022-06-05 04:03:25 +00:00
if (pkm is PB8)
Temp handling for bdsp case
2021-12-10 03:53:43 +00:00
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = (PersonalInfoBDSP)PersonalTable.BDSP[species, form];
Temp handling for bdsp case
2021-12-10 03:53:43 +00:00
if (!pi.IsPresentInGame)
return NONE;
var type = Array.IndexOf(TypeTutor8b, move);
if (type != -1 && pi.TypeTutors[type])
return GameVersion.BDSP;
Minor clean
2020-12-23 17:34:29 +00:00
return NONE;
Temp handling for bdsp case
2021-12-10 03:53:43 +00:00
}
else
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = (PersonalInfoSWSH)PersonalTable.SWSH[species, form];
Temp handling for bdsp case
2021-12-10 03:53:43 +00:00
if (!pi.IsPresentInGame)
return NONE;
var type = Array.IndexOf(TypeTutor8, move);
if (type != -1 && pi.TypeTutors[type])
return GameVersion.SWSH;
Use new switch statements
2020-12-24 01:14:38 +00:00
Temp handling for bdsp case
2021-12-10 03:53:43 +00:00
if (!specialTutors)
return NONE;
Add elemental tutors Closes #2443 Capture some array references to avoid re-fetching array -- array reference is readonly so it probably won't matter
2019-11-17 19:13:52 +00:00
Temp handling for bdsp case
2021-12-10 03:53:43 +00:00
var tutor = Array.IndexOf(Tutors_SWSH_1, move);
if (tutor != -1 && pi.SpecialTutors[0][tutor])
return GameVersion.SWSH;
return NONE;
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
public static IEnumerable<int> GetTutorMoves(PKM pkm, int species, int form, bool specialTutors, int generation)
{
Target type'd new
2020-12-22 01:17:56 +00:00
List<int> moves = new();
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
switch (generation)
{
case 1: AddMovesTutor1(moves, species, pkm.Format); break;
case 2: AddMovesTutor2(moves, species, pkm.Format, pkm.Korean); break;
case 3: AddMovesTutor3(moves, species); break;
case 4: AddMovesTutor4(moves, species, form); break;
case 5: AddMovesTutor5(moves, species, form, pkm, specialTutors); break;
case 6: AddMovesTutor6(moves, species, form, pkm, specialTutors); break;
case 7: AddMovesTutor7(moves, species, form, pkm, specialTutors); break;
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
case 8: AddMovesTutor8(moves, species, form, pkm, specialTutors); break;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
return moves;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
private static void AddMovesTutor1(List<int> moves, int species, int format)
{
Condense some expressions
2021-08-22 08:26:28 +00:00
if (ParseSettings.AllowGBCartEra && format < 3 && species is (int)Species.Pikachu or (int)Species.Raichu) // Surf Pikachu via Stadium
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
moves.Add(57);
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMovesTutor2(List<int> moves, int species, int format, bool korean = false)
{
if (korean)
return;
var pi = PersonalTable.C[species];
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var hmBits = pi.TMHM.AsSpan(57, 3);
for (int i = 0; i < Tutors_GSC.Length; i++)
{
if (hmBits[i])
moves.Add(Tutors_GSC[i]);
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
AddMovesTutor1(moves, species, format);
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMovesTutor3(List<int> moves, int species)
{
// E Tutors (Free)
// E Tutors (BP)
var pi = PersonalTable.E[species];
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddPermittedIndexes(moves, Tutor_E, pi.TypeTutors);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
// FRLG Tutors
// Only special tutor moves, normal tutor moves are already included in Emerald data
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddIfPermitted(moves, SpecialTutors_FRLG, SpecialTutors_Compatibility_FRLG, species);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
// XD
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
for (int i = 0; i < SpecialTutors_XD_Exclusive.Length; i++)
{
var allowed = SpecialTutors_Compatibility_XD_Exclusive[i].AsSpan();
var index = allowed.IndexOf(species);
if (index != -1)
moves.Add(SpecialTutors_XD_Exclusive[i]);
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
// XD (Mew)
Use enum for species comparisons slightly easier to read with named values
2019-12-09 01:39:19 +00:00
if (species == (int)Species.Mew)
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
moves.AddRange(Tutor_3Mew);
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMovesTutor4(List<int> moves, int species, int form)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.HGSS[species, form];
AddPermittedIndexes(moves, Tutors_4, pi.TypeTutors);
for (int i = 0; i < SpecialTutors_4.Length; i++)
{
var allowed = SpecialTutors_Compatibility_4[i].AsSpan();
var index = allowed.IndexOf(species);
if (index != -1)
moves.Add(SpecialTutors_4[i]);
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMovesTutor5(List<int> moves, int species, int form, PKM pkm, bool specialTutors)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.B2W2[species, form];
AddPermittedIndexes(moves, TypeTutor6, pi.TypeTutors);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
if (pkm.InhabitedGeneration(5) && specialTutors)
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddPermittedIndexes(moves, Tutors_B2W2, pi.SpecialTutors);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMovesTutor6(List<int> moves, int species, int form, PKM pkm, bool specialTutors)
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.AO[species, form];
AddPermittedIndexes(moves, TypeTutor6, pi.TypeTutors);
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedORAS(species))
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddPermittedIndexes(moves, Tutors_AO, pi.SpecialTutors);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMovesTutor7(List<int> moves, int species, int form, PKM pkm, bool specialTutors)
{
Replace pkm.GG references with direct version checks No longer tied to met location
2021-01-01 01:45:11 +00:00
if (pkm.Version is (int)GameVersion.GO or (int)GameVersion.GP or (int)GameVersion.GE)
Add references for GG tutoring Only pikachu/eevee forms so far, probably none else
2018-11-11 05:04:48 +00:00
return;
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = PersonalTable.USUM[species, form];
AddPermittedIndexes(moves, TypeTutor6, pi.TypeTutors);
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedUSUM(species))
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddPermittedIndexes(moves, Tutors_USUM, pi.SpecialTutors[0]);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
private static void AddMovesTutor8(List<int> moves, int species, int form, PKM pkm, bool specialTutors)
{
HOME 2.0.0: Handle conversion behavior & restrictions (#3506) * Revises legality checks to account for traveling between the three game islands (PLA/BDSP/SWSH) * Adds conversion mechanisms between the three formats, as well as flexible conversion options to backfill missing data (thanks GameFreak/ILCA for opting for lossy conversion instead of updating the games). * Adds API abstractions for HOME data storage format (EKH/PKH format 1, aka EH1/PH1). * Revises some APIs for better usage: - `PKM` now exposes a `Context` to indicate the isolation context for legality purposes. - Some method signatures have changed to accept `Context` or `GameVersion` instead of a vague `int` for Generation. - Evolution History is now tracked in the Legality parse for specific contexts, rather than only per generation.
2022-05-31 04:43:52 +00:00
if (pkm is PA8)
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = (PersonalInfoLA)PersonalTable.LA[species, form];
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
if (!pi.IsPresentInGame)
return;
More specific primitives for Memories/others
2022-03-06 20:01:47 +00:00
var shop = MoveShop8_LA;
var tutors = pi.SpecialTutors[0];
for (int i = 0; i < shop.Length; i++)
{
if (tutors[i])
moves.Add(shop[i]);
}
Flag SWSH tutor moves
2022-02-09 23:06:14 +00:00
return;
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
}
HOME 2.0.0: Handle conversion behavior & restrictions (#3506) * Revises legality checks to account for traveling between the three game islands (PLA/BDSP/SWSH) * Adds conversion mechanisms between the three formats, as well as flexible conversion options to backfill missing data (thanks GameFreak/ILCA for opting for lossy conversion instead of updating the games). * Adds API abstractions for HOME data storage format (EKH/PKH format 1, aka EH1/PH1). * Revises some APIs for better usage: - `PKM` now exposes a `Context` to indicate the isolation context for legality purposes. - Some method signatures have changed to accept `Context` or `GameVersion` instead of a vague `int` for Generation. - Evolution History is now tracked in the Legality parse for specific contexts, rather than only per generation.
2022-05-31 04:43:52 +00:00
if (pkm is PB8)
Add elemental beam type tutors for BDSP
2021-11-21 00:50:44 +00:00
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = (PersonalInfoBDSP)PersonalTable.BDSP[species, form];
if (pi.IsPresentInGame)
AddPermittedIndexes(moves, TypeTutor8b, pi.TypeTutors);
Add elemental beam type tutors for BDSP
2021-11-21 00:50:44 +00:00
}
else // SWSH
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var pi = (PersonalInfoSWSH)PersonalTable.SWSH[species, form];
Add elemental beam type tutors for BDSP
2021-11-21 00:50:44 +00:00
if (!pi.IsPresentInGame)
return;
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddPermittedIndexes(moves, TypeTutor8, pi.TypeTutors);
Add elemental beam type tutors for BDSP
2021-11-21 00:50:44 +00:00
if (specialTutors)
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
AddPermittedIndexes(moves, Tutors_SWSH_1, pi.SpecialTutors[0]);
Add elemental beam type tutors for BDSP
2021-11-21 00:50:44 +00:00
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
private static void AddIfPermitted(List<int> moves, ReadOnlySpan<int> arrMoves, ReadOnlySpan<int> arrSpecies, int species)
{
var index = arrSpecies.IndexOf(species);
if (index != -1)
moves.Add(arrMoves[index]);
}
private static void AddPermittedIndexes(List<int> moves, int[][] tutors, bool[][] permit)
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
{
for (int i = 0; i < tutors.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Fiddle with tutors: no allocation Besides expanding the move list, no more closures & linq.
2022-06-12 21:02:22 +00:00
var arr = tutors[i];
var per = permit[i];
AddPermittedIndexes(moves, arr, per);
}
}
private static void AddPermittedIndexes(List<int> moves, int[] moveIDs, bool[] permit)
{
for (int i = 0; i < moveIDs.Length; i++)
{
if (permit[i])
moves.Add(moveIDs[i]);
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
internal static void AddSpecialTutorMoves(List<int> r, PKM pkm, int Generation, int species)
{
switch (species)
{
Bake cosplay moves into the encounter template yay records `with` syntax don't bother specifying form6's moves, they're all levelup moves.
2021-02-02 17:40:58 +00:00
case (int)Species.Keldeo:
r.Add((int)Move.SecretSword);
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
break;
use some explicit dex numbers as enum
2019-06-01 17:22:49 +00:00
case (int)Species.Meloetta:
Bake cosplay moves into the encounter template yay records `with` syntax don't bother specifying form6's moves, they're all levelup moves.
2021-02-02 17:40:58 +00:00
r.Add((int)Move.RelicSong);
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
break;
Add references for GG tutoring Only pikachu/eevee forms so far, probably none else
2018-11-11 05:04:48 +00:00
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
case (int)Species.Pikachu when Generation == 7 && pkm.Form == 8:
Add references for GG tutoring Only pikachu/eevee forms so far, probably none else
2018-11-11 05:04:48 +00:00
r.AddRange(Tutor_StarterPikachu);
break;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
case (int)Species.Eevee when Generation == 7 && pkm.Form == 1:
Add references for GG tutoring Only pikachu/eevee forms so far, probably none else
2018-11-11 05:04:48 +00:00
r.AddRange(Tutor_StarterEevee);
break;
Permit Gen7b for GO even if location doesn't match Feeling like the Move fetching needs to shift away from Generation too.
2022-06-08 03:15:32 +00:00
case (int)Species.Pikachu or (int)Species.Raichu when Generation == 7 && !(pkm.LGPE || pkm.GO):
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
r.Add((int)Move.VoltTackle);
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
break;
}
}
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
/// <summary> Rotom Moves that correspond to a specific form (form-0 ignored). </summary>
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
private static readonly int[] RotomMoves = { (int)Move.Overheat, (int)Move.HydroPump, (int)Move.Blizzard, (int)Move.AirSlash, (int)Move.LeafStorm };
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
internal static void AddSpecialFormChangeMoves(List<int> r, PKM pkm, int generation, int species)
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
{
switch (species)
{
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
case (int)Species.Rotom when generation >= 4:
Update legality comparisons for Crown Tundra Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com> Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com>
2020-10-24 18:16:01 +00:00
var formMoves = RotomMoves;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var form = pkm.Form - 1;
Update legality comparisons for Crown Tundra Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com> Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com>
2020-10-24 18:16:01 +00:00
if ((uint)form < formMoves.Length)
r.Add(RotomMoves[form]);
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
break;
Simplify some expressions Search array for index rather than loop and check; gives early-break too -- was O(n) now is O(<~n)
2021-01-13 06:25:30 +00:00
case (int)Species.Zygarde when generation == 7:
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
r.AddRange(ZygardeMoves);
break;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
case (int)Species.Necrozma when pkm.Form == 1: // Sun
Handle form changing for move memories Doesn't invalidate any of the statements made today. ty @Lusamine for identifying these cases.
2021-08-15 03:20:13 +00:00
r.Add((int)Move.SunsteelStrike);
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
break;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
case (int)Species.Necrozma when pkm.Form == 2: // Moon
Handle form changing for move memories Doesn't invalidate any of the statements made today. ty @Lusamine for identifying these cases.
2021-08-15 03:20:13 +00:00
r.Add((int)Move.MoongeistBeam);
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
break;
}
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
}
Reference in a new issue Copy permalink