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

324 lines
13 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 System.Linq;
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),
_ => 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
}
private static GameVersion GetIsTutor1(PKM pkm, int species, int move)
{
// Surf Pikachu via Stadium
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 (move != 57 || 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;
Use enum for species comparisons slightly easier to read with named values
2019-12-09 01:39:19 +00:00
if (pkm.Format < 3 && (species == (int)Species.Pikachu || species == (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);
if (xd != -1 && SpecialTutors_Compatibility_XD_Exclusive[xd].Contains(species))
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)
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 && Tutor_3Mew.Contains(move))
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)
{
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 pi = PersonalTable.HGSS.GetFormEntry(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);
if (special != -1 && SpecialTutors_Compatibility_4[special].Contains(species))
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)
{
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 pi = PersonalTable.B2W2.GetFormEntry(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)
{
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 pi = PersonalTable.AO.GetFormEntry(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)
{
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 pi = PersonalTable.USUM.GetFormEntry(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)
{
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 pi = (PersonalInfoSWSH)PersonalTable.SWSH.GetFormEntry(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(TypeTutor8, move);
if (type != -1 && pi.TypeTutors[type])
return GameVersion.Gen8;
Minor clean
2020-12-23 17:34:29 +00:00
if (!specialTutors)
return NONE;
Use new switch statements
2020-12-24 01:14:38 +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_SWSH_1, move);
if (tutor != -1 && pi.SpecialTutors[0][tutor])
return GameVersion.USUM;
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
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
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
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
}
return moves.Distinct();
}
private static void AddMovesTutor1(List<int> moves, int species, int format)
{
Use enum for species comparisons slightly easier to read with named values
2019-12-09 01:39:19 +00:00
if (ParseSettings.AllowGBCartEra && format < 3 && (species == (int)Species.Pikachu || species == (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];
moves.AddRange(Tutors_GSC.Where((_, i) => pi.TMHM[57 + i]));
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];
moves.AddRange(Tutor_E.Where((_, i) => pi.TypeTutors[i]));
// FRLG Tutors
// Only special tutor moves, normal tutor moves are already included in Emerald data
moves.AddRange(SpecialTutors_FRLG.Where((_, i) => SpecialTutors_Compatibility_FRLG[i] == species));
// XD
moves.AddRange(SpecialTutors_XD_Exclusive.Where((_, i) => SpecialTutors_Compatibility_XD_Exclusive[i].Any(e => e == species)));
// 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)
{
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 pi = PersonalTable.HGSS.GetFormEntry(species, form);
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(Tutors_4.Where((_, i) => pi.TypeTutors[i]));
moves.AddRange(SpecialTutors_4.Where((_, i) => SpecialTutors_Compatibility_4[i].Any(e => e == 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
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)
{
var pi = PersonalTable.B2W2[species];
moves.AddRange(TypeTutor6.Where((_, i) => pi.TypeTutors[i]));
if (pkm.InhabitedGeneration(5) && specialTutors)
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
moves.AddRange(GetTutors(PersonalTable.B2W2.GetFormEntry(species, form), Tutors_B2W2));
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)
{
var pi = PersonalTable.AO[species];
moves.AddRange(TypeTutor6.Where((_, i) => pi.TypeTutors[i]));
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedORAS(species))
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
moves.AddRange(GetTutors(PersonalTable.AO.GetFormEntry(species, form), Tutors_AO));
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;
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 pi = PersonalTable.USUM.GetFormEntry(species, form);
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(TypeTutor6.Where((_, i) => pi.TypeTutors[i]));
Pass species param to exists-in check Closes #2905
2020-06-27 19:04:28 +00:00
if (specialTutors && pkm.HasVisitedUSUM(species))
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
moves.AddRange(GetTutors(pi, Tutors_USUM));
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)
{
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 pi = (PersonalInfoSWSH)PersonalTable.SWSH.GetFormEntry(species, form);
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
if (!pi.IsPresentInGame)
return;
moves.AddRange(TypeTutor8.Where((_, i) => pi.TypeTutors[i]));
Initial Isle of Armor support Co-Authored-By: sciresm <sciresm@users.noreply.github.com> Co-Authored-By: Matt <sora10pls@users.noreply.github.com> Co-Authored-By: Archit Date <architdate@gmail.com>
2020-06-19 23:51:15 +00:00
if (specialTutors)
moves.AddRange(GetTutors(pi, Tutors_SWSH_1));
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
private static IEnumerable<int> GetTutors(PersonalInfo pi, params int[][] tutors)
{
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
{
for (int b = 0; b < tutors[i].Length; b++)
{
if (pi.SpecialTutors[i][b])
yield return tutors[i][b];
}
}
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;
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case (int)Species.Pikachu or (int)Species.Raichu when Generation == 7 && !pkm.GG:
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
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
r.Add(713);
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
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
r.Add(714);
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