Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-11-23 20:43:07 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/Legality/Moves/MoveLevelUp.cs

491 lines
20 KiB
C#
Raw Normal View History

Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +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;
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
using static PKHeX.Core.GameVersion;
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
namespace PKHeX.Core
{
internal static class MoveLevelUp
{
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
private static readonly LearnLookup
Misc refactoring remove some null usages, return an empty array instead reduce as arg
2019-02-02 07:08:03 +00:00
LearnSM = new LearnLookup(PersonalTable.SM, LevelUpSM, SM),
LearnUSUM = new LearnLookup(PersonalTable.USUM, LevelUpUSUM, USUM),
LearnGG = new LearnLookup(PersonalTable.GG, LevelUpGG, GG),
LearnXY = new LearnLookup(PersonalTable.XY, LevelUpXY, XY),
LearnAO = new LearnLookup(PersonalTable.AO, LevelUpAO, ORAS),
LearnBW = new LearnLookup(PersonalTable.BW, LevelUpBW, BW),
LearnB2W2 = new LearnLookup(PersonalTable.B2W2, LevelUpB2W2, B2W2),
LearnDP = new LearnLookup(PersonalTable.DP, LevelUpDP, DP),
LearnPt = new LearnLookup(PersonalTable.Pt, LevelUpPt, Pt),
LearnHGSS = new LearnLookup(PersonalTable.HGSS, LevelUpHGSS, HGSS),
LearnRSE = new LearnLookup(PersonalTable.RS, LevelUpRS, RSE),
LearnFRLG = new LearnLookup(PersonalTable.LG, LevelUpLG, FRLG),
LearnGS = new LearnLookup(PersonalTable.GS, LevelUpGS, GS),
LearnC = new LearnLookup(PersonalTable.C, LevelUpC, C),
LearnRB = new LearnLookup(PersonalTable.RB, LevelUpRB, RB),
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
LearnY = new LearnLookup(PersonalTable.Y, LevelUpY, YW);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
public static LearnVersion GetIsLevelUpMove(PKM pkm, int species, int form, int lvl, int generation, int move, int minlvlG1, int minlvlG2, GameVersion version = Any)
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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (pkm.IsMovesetRestricted())
version = (GameVersion)pkm.Version;
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
switch (generation)
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 altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
case 1: return GetIsLevelUp1(species, move, lvl, form, minlvlG1, version);
Reject moves introduced by gsc in pk1/vc1 cases Closes #2005 (no tutor moves are new moves, just beam moves)
2018-06-15 01:52:43 +00:00
case 2: if (move > MaxMoveID_1 && pkm.LearnMovesNew2Disallowed()) return LearnNONE;
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return GetIsLevelUp2(species, move, lvl, form, minlvlG2, pkm.Korean, version);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case 3: return GetIsLevelUp3(species, move, lvl, form, version);
case 4: return GetIsLevelUp4(species, move, lvl, form, version);
case 5: return GetIsLevelUp5(species, move, lvl, form, version);
case 6: return GetIsLevelUp6(species, move, lvl, form, version);
case 7: return GetIsLevelUp7(species, move, form, version);
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 LearnNONE;
}
Refactoring continued simplification core.cs is pretty much the following: misc one-off junk moveset fetch encounter table fetch evo chain fetch might eventually move things around a bit further for cleanliness so that misc meta junk is the only thing that remains in core.
2018-06-19 04:56:30 +00:00
public static LearnVersion GetIsLevelUp1(int species, int move, int max, int form, int min, GameVersion ver = Any)
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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (move > MaxMoveID_1)
return LearnNONE;
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
switch (ver)
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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case Any: case RBY:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
var first = LearnRB.GetIsLevelUpG1(species, form, move, max, min);
Refactoring continued simplification core.cs is pretty much the following: misc one-off junk moveset fetch encounter table fetch evo chain fetch might eventually move things around a bit further for cleanliness so that misc meta junk is the only thing that remains in core.
2018-06-19 04:56:30 +00:00
var second = LearnY.GetIsLevelUpG1(species, form, move, max, min);
if (!first.IsLevelUp)
return second;
if (!second.IsLevelUp)
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
return first;
Refactoring continued simplification core.cs is pretty much the following: misc one-off junk moveset fetch encounter table fetch evo chain fetch might eventually move things around a bit further for cleanliness so that misc meta junk is the only thing that remains in core.
2018-06-19 04:56:30 +00:00
return first.Level > second.Level ? second : first;
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case RD: case BU: case GN: case RB:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnRB.GetIsLevelUpG1(species, form, move, max, min);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case YW:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnY.GetIsLevelUpG1(species, form, move, max, min);
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 LearnNONE;
}
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 altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
private static LearnVersion GetIsLevelUp2(int species, int move, int max, int form, int min, bool korean, GameVersion ver = Any)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
// No Korean Crystal
switch (ver)
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case Any: case GSC:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
var first = LearnGS.GetIsLevelUpMin(species, move, max, min, form);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
if (first.IsLevelUp || korean)
return first;
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnC.GetIsLevelUpMin(species, move, max, min, form);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case GD: case SV: case GS:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnGS.GetIsLevelUpMin(species, move, max, min, form);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case C when !korean:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnC.GetIsLevelUpMin(species, move, max, min, form);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +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 LearnNONE;
}
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
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
private static LearnVersion GetIsLevelUp3(int species, int move, int lvl, int form, GameVersion ver = Any)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
if (species == 386)
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 GetIsLevelUp3Deoxys(form, move, lvl);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
// Emerald level up tables are equal to R/S level up tables
switch (ver)
{
case Any:
var first = LearnRSE.GetIsLevelUp(species, form, move, lvl);
if (first.IsLevelUp)
return first;
return LearnFRLG.GetIsLevelUp(species, form, move, lvl);
case R: case S: case E: case RS: case RSE:
return LearnRSE.GetIsLevelUp(species, form, move, lvl);
case FR: case LG: case FRLG:
return LearnFRLG.GetIsLevelUp(species, form, move, lvl);
}
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 LearnNONE;
}
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
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
private static LearnVersion GetIsLevelUp4(int species, int move, int lvl, int form, GameVersion ver = Any)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
switch (ver)
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case Any: case DPPt:
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
var first = LearnDP.GetIsLevelUp(species, form, move, lvl);
if (first.IsLevelUp)
return first;
var second = LearnPt.GetIsLevelUp(species, form, move, lvl);
if (second.IsLevelUp)
return second;
if (ver == DPPt) // stop here
return LearnNONE;
return LearnHGSS.GetIsLevelUp(species, form, move, lvl);
case D: case P: case DP:
return LearnDP.GetIsLevelUp(species, form, move, lvl);
case Pt:
return LearnPt.GetIsLevelUp(species, form, move, lvl);
case HG: case SS: case HGSS:
return LearnHGSS.GetIsLevelUp(species, form, move, lvl);
}
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 LearnNONE;
}
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
Misc refactoring remove some null usages, return an empty array instead reduce as arg
2019-02-02 07:08:03 +00:00
private static LearnVersion GetIsLevelUp5(int species, int move, int lvl, int form, GameVersion ver = Any)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
switch (ver)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case Any:
var first = LearnBW.GetIsLevelUp(species, form, move, lvl);
Copy addmoves special case to individual fetch see prior commits
2018-08-04 17:05:47 +00:00
if (first.IsLevelUp && species != 646) // Kyurem moves are same for both versions, but forme movepool not present.
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
return first;
return LearnB2W2.GetIsLevelUp(species, form, move, lvl);
case B: case W: case BW:
return LearnBW.GetIsLevelUp(species, form, move, lvl);
case B2: case W2: case B2W2:
return LearnB2W2.GetIsLevelUp(species, form, move, lvl);
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 LearnNONE;
}
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
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
private static LearnVersion GetIsLevelUp6(int species, int move, int lvl, int form, GameVersion ver = Any)
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 (ver)
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case Any:
var first = LearnXY.GetIsLevelUp(species, form, move, lvl);
if (first.IsLevelUp)
return first;
return LearnAO.GetIsLevelUp(species, form, move, lvl);
case X: case Y: case XY:
return LearnXY.GetIsLevelUp(species, form, move, lvl);
case OR: case AS: case ORAS:
return LearnAO.GetIsLevelUp(species, form, move, lvl);
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 LearnNONE;
}
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
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
private static LearnVersion GetIsLevelUp7(int species, int move, int form, GameVersion ver = Any)
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 (ver)
{
Treat GameVersion.GO like other GG vers
2018-11-15 01:40:11 +00:00
case GP: case GE: case GG: case GO:
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
return LearnGG.GetIsLevelUp(species, form, move);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case Any:
if (species > MaxSpeciesID_7)
return LearnNONE;
var first = LearnSM.GetIsLevelUp(species, form, move);
if (first.IsLevelUp)
return first;
if (species > MaxSpeciesID_7_USUM)
return LearnNONE;
return LearnUSUM.GetIsLevelUp(species, form, move);
case SN: case MN: case SM:
if (species > MaxSpeciesID_7)
return LearnNONE;
return LearnSM.GetIsLevelUp(species, form, move);
case US: case UM: case USUM:
if (species > MaxSpeciesID_7_USUM)
return LearnNONE;
return LearnUSUM.GetIsLevelUp(species, form, 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 LearnNONE;
}
private static LearnVersion GetIsLevelUp3Deoxys(int form, int move, int lvl)
{
var moveset = GetDeoxysLearn3(form);
if (moveset == null)
return LearnNONE;
var lv = moveset.GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GetDeoxysGameVersion3(form));
return LearnNONE;
}
private static GameVersion GetDeoxysGameVersion3(int form)
{
switch (form)
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case 0: return RS;
case 1: return FR;
case 2: return LG;
case 3: return 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
default:
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
return Invalid;
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
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
private static Learnset GetDeoxysLearn3(int form, GameVersion ver = Any)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
if (ver == Any)
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
switch (form)
{
case 0: return LevelUpRS[386]; // Normal
case 1: return LevelUpFR[386]; // Attack
case 2: return LevelUpLG[386]; // Defense
case 3: return LevelUpE[386]; // Speed
default: return null;
}
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
Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +00:00
var gen = ver.GetGeneration();
if (gen != 3)
return GetDeoxysLearn3(form);
return GameData.GetLearnsets(ver)[386];
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 continued reduction in Core size, simplify/clean up usages
2018-06-10 21:45:25 +00:00
public static IEnumerable<int> GetMovesLevelUp(PKM pkm, int species, int minlvlG1, int minlvlG2, int lvl, int form, GameVersion version, bool MoveReminder, int Generation)
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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (pkm.IsMovesetRestricted())
version = (GameVersion)pkm.Version;
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)
{
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
case 1: return GetMovesLevelUp1(species, form, lvl, minlvlG1, version);
case 2: return GetMovesLevelUp2(species, form, lvl, minlvlG2, pkm.Korean, pkm.LearnMovesNew2Disallowed(), version);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case 3: return GetMovesLevelUp3(species, form, lvl, version);
case 4: return GetMovesLevelUp4(species, form, lvl, version);
case 5: return GetMovesLevelUp5(species, form, lvl, version);
case 6: return GetMovesLevelUp6(species, form, lvl, version);
case 7: return GetMovesLevelUp7(species, form, lvl, MoveReminder, version);
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
}
Continued refactoring removing null results as indicators of no data (c# 8 sooooon)
2019-02-02 07:26:43 +00:00
return Array.Empty<int>();
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
}
Reject moves introduced by gsc in pk1/vc1 cases Closes #2005 (no tutor moves are new moves, just beam moves)
2018-06-15 01:52:43 +00:00
private static bool LearnMovesNew2Disallowed(this PKM pkm) => pkm.Format == 1 || (pkm.Format >= 7 && pkm.VC);
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
internal static List<int> GetMovesLevelUp1(int species, int form, int max, int min, GameVersion ver = Any)
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 altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return AddMovesLevelUp1(new List<int>(), ver, species, form, max, min);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +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
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
private static List<int> GetMovesLevelUp2(int species, int form, int max, int min, bool korean, bool removeNewGSCMoves, GameVersion ver = Any)
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
{
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
var moves = AddMovesLevelUp2(new List<int>(), ver, species, form, max, min, korean);
Reject moves introduced by gsc in pk1/vc1 cases Closes #2005 (no tutor moves are new moves, just beam moves)
2018-06-15 01:52:43 +00:00
if (removeNewGSCMoves)
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
moves.RemoveAll(m => m > MaxMoveID_1);
return moves;
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> GetMovesLevelUp3(int species, int form, int max, GameVersion ver = Any)
{
return AddMovesLevelUp3(new List<int>(), ver, species, max, form);
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> GetMovesLevelUp4(int species, int form, int max, GameVersion ver = Any)
{
return AddMovesLevelUp4(new List<int>(), ver, species, max, form);
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> GetMovesLevelUp5(int species, int form, int max, GameVersion ver = Any)
{
return AddMovesLevelUp5(new List<int>(), ver, species, max, form);
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> GetMovesLevelUp6(int species, int form, int max, GameVersion ver = Any)
{
return AddMovesLevelUp6(new List<int>(), ver, species, max, form);
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> GetMovesLevelUp7(int species, int form, int max, bool MoveReminder, GameVersion ver = Any)
{
return AddMovesLevelUp7(new List<int>(), ver, species, max, form, MoveReminder);
}
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 altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
private static List<int> AddMovesLevelUp1(List<int> moves, GameVersion ver, int species, int form, int max, int min)
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
{
Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +00:00
switch (ver)
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
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case Any: case RBY:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
LearnRB.AddMoves1(moves, species, form, max, min);
return LearnY.AddMoves1(moves, species, form, max, min);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case RD: case BU: case GN: case RB:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnRB.AddMoves1(moves, species, form, max, min);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case YW:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnY.AddMoves1(moves, species, form, max, min);
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;
}
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 altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
private static List<int> AddMovesLevelUp2(List<int> moves, GameVersion ver, int species, int form, int max, int min, bool korean)
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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
switch (ver)
{
case Any: case GSC:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
LearnGS.AddMoves(moves, species, form, max, min);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (korean)
return moves;
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnC.AddMoves(moves, species, form, max, min);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case GD: case SV: case GS:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnGS.AddMoves(moves, species, form, max, min);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case C when !korean:
Add altform permissive checks for gen1/2 Should always be zero, but necessary for regional variant evolutions needing to be excluded #2018 (not fixed yet)
2018-06-18 04:54:04 +00:00
return LearnC.AddMoves(moves, species, form, max, min);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +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
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> AddMovesLevelUp3(List<int> moves, GameVersion ver, int species, int max, int 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
{
if (species == 386)
{
Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +00:00
var learn = GetDeoxysLearn3(form, ver);
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 (learn != null)
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
moves.AddRange(learn.GetMoves(max));
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;
}
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
// Emerald level up tables are equal to R/S level up tables
switch (ver)
{
case Any:
LearnRSE.AddMoves(moves, species, form, max);
return LearnFRLG.AddMoves(moves, species, form, max);
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case R: case S: case E: case RS: case RSE:
return LearnRSE.AddMoves(moves, species, form, max);
case FR: case LG: case FRLG:
return LearnFRLG.AddMoves(moves, species, form, max);
}
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;
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> AddMovesLevelUp4(List<int> moves, GameVersion ver, int species, int max, int 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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
switch (ver)
{
case Any: case DPPt:
LearnDP.AddMoves(moves, species, form, max);
LearnPt.AddMoves(moves, species, form, max);
if (ver == DPPt) // stop here
return moves;
return LearnHGSS.AddMoves(moves, species, form, max);
case D: case P: case DP:
return LearnDP.AddMoves(moves, species, form, max);
case Pt:
return LearnPt.AddMoves(moves, species, form, max);
case HG: case SS: case HGSS:
return LearnHGSS.AddMoves(moves, species, form, max);
}
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;
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> AddMovesLevelUp5(List<int> moves, GameVersion ver, int species, int max, int 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
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
switch (ver)
{
case Any:
Allow bw movepool except for kyurem workaround provided for kyurem movepool (which is same bw-b2w2) but the AddMoves logic with form != 0 points to the form == 0 data Closes #2085
2018-08-03 14:46:53 +00:00
if (species != 646) // Kyurem moves are same for both versions, but forme movepool not present.
Misc clean
2019-02-02 18:19:41 +00:00
LearnBW.AddMoves(moves, species, form, max);
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
return LearnB2W2.AddMoves(moves, species, form, max);
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
case B: case W: case BW:
return LearnBW.AddMoves(moves, species, form, max);
case B2: case W2: case B2W2:
return LearnB2W2.AddMoves(moves, species, form, max);
}
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;
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> AddMovesLevelUp6(List<int> moves, GameVersion ver, int species, int max, int 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
{
switch (ver)
{
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case Any:
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
LearnXY.AddMoves(moves, species, form, max);
return LearnAO.AddMoves(moves, species, form, max);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case X: case Y: case XY:
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
return LearnXY.AddMoves(moves, species, form, max);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case AS: case OR: case ORAS:
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
return LearnAO.AddMoves(moves, species, form, max);
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;
}
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
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
private static List<int> AddMovesLevelUp7(List<int> moves, GameVersion ver, int species, int max, int form, bool MoveReminder)
Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +00:00
{
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (MoveReminder)
max = 100; // Move reminder can teach any level in movepool now!
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 (ver)
{
Treat GameVersion.GO like other GG vers
2018-11-15 01:40:11 +00:00
case GP: case GE: case GG: case GO:
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
return LearnGG.AddMoves(moves, species, form, max);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case Any:
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (species > MaxSpeciesID_7_USUM)
return moves;
LearnUSUM.AddMoves(moves, species, form, max);
if (species > MaxSpeciesID_7)
return moves;
return LearnSM.AddMoves(moves, species, form, max);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case SN: case MN: case SM:
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (species > MaxSpeciesID_7)
return moves;
return LearnSM.AddMoves(moves, species, form, max);
Split GetIsLevelUp to individual versions static the GameVersion reference as we're excessively using it in the switch cases, for clearer reading
2018-06-13 05:15:06 +00:00
case US: case UM: case USUM:
Tidy up MoveLevelUp use the Learn objects from prior commits for adding a range of moves
2018-06-14 05:03:58 +00:00
if (species > MaxSpeciesID_7_USUM)
return moves;
LearnUSUM.AddMoves(moves, species, form, max);
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
break;
}
return moves;
}
Refactoring fix b2w2 egg base levelup reference (not bw, b2w2!), doesn't really matter much except for better indication (possibly?) remove some unnecessary linq ToArray() calls continue relocating code out of Core
2018-06-11 00:55:03 +00:00
public static int[] GetEncounterMoves(PKM pk, int level, GameVersion version)
{
Add missing learn/personal references for pairs Closes #2019
2018-06-18 03:49:03 +00:00
if (version <= 0)
version = (GameVersion)pk.Version;
Refactoring fix b2w2 egg base levelup reference (not bw, b2w2!), doesn't really matter much except for better indication (possibly?) remove some unnecessary linq ToArray() calls continue relocating code out of Core
2018-06-11 00:55:03 +00:00
return GetEncounterMoves(pk.Species, pk.AltForm, level, version);
}
Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +00:00
private static int[] GetEncounterMoves1(int species, int level, GameVersion version)
{
var learn = GameData.GetLearnsets(version);
var table = GameData.GetPersonal(version);
var index = table.GetFormeIndex(species, 0);
var lvl0 = (int[])((PersonalInfoG1) table[index]).Moves.Clone();
int start = Math.Max(0, Array.FindIndex(lvl0, z => z == 0));
return learn[index].GetEncounterMoves(level, lvl0, start);
}
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 remove some unneeded logic moves in gen1/2 can be reordered, sequence match should be intersect (full) contains match.
2018-06-19 02:57:32 +00:00
private static int[] GetEncounterMoves2(int species, int level, GameVersion version)
{
var learn = GameData.GetLearnsets(version);
var table = GameData.GetPersonal(version);
var index = table.GetFormeIndex(species, 0);
var lvl0 = learn[species].GetEncounterMoves(1);
int start = Math.Max(0, Array.FindIndex(lvl0, z => z == 0));
return learn[index].GetEncounterMoves(level, lvl0, start);
}
Add special handling for gen1 encounter move fetch Begin splitting of GetMovesLevelUp per-gen into per-version
2018-06-13 01:35:56 +00:00
Refactoring fix b2w2 egg base levelup reference (not bw, b2w2!), doesn't really matter much except for better indication (possibly?) remove some unnecessary linq ToArray() calls continue relocating code out of Core
2018-06-11 00:55:03 +00:00
public static int[] GetEncounterMoves(int species, int form, int level, GameVersion version)
{
Refactoring remove some unneeded logic moves in gen1/2 can be reordered, sequence match should be intersect (full) contains match.
2018-06-19 02:57:32 +00:00
if (RBY.Contains(version))
return GetEncounterMoves1(species, level, version);
if (GSC.Contains(version))
return GetEncounterMoves2(species, level, version);
Refactoring fix b2w2 egg base levelup reference (not bw, b2w2!), doesn't really matter much except for better indication (possibly?) remove some unnecessary linq ToArray() calls continue relocating code out of Core
2018-06-11 00:55:03 +00:00
var learn = GameData.GetLearnsets(version);
var table = GameData.GetPersonal(version);
var index = table.GetFormeIndex(species, form);
return learn[index].GetEncounterMoves(level);
}
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