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

527 lines
22 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
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
LearnSWSH = new LearnLookup(PersonalTable.SWSH, LevelUpSWSH, SWSH),
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);
Sword/Shield Update
2019-11-16 01:34:18 +00:00
case 2 when move > MaxMoveID_1 && pkm.LearnMovesNew2Disallowed(): return LearnNONE;
case 2: 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);
Sword/Shield Update
2019-11-16 01:34:18 +00:00
case 7: return GetIsLevelUp7(species, move, form, version); // move reminder can give any move 1-100
case 8: return GetIsLevelUp8(species, move, lvl, 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
{
Use enum for species comparisons slightly easier to read with named values
2019-12-09 01:39:19 +00:00
if (species == (int)Species.Deoxys)
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;
}
Sword/Shield Update
2019-11-16 01:34:18 +00:00
private static LearnVersion GetIsLevelUp8(int species, int move, int lvl, int form, GameVersion ver = Any)
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
switch (ver)
{
case Any:
case SW: case SH:
if (species > MaxSpeciesID_8)
return LearnNONE;
Sword/Shield Update
2019-11-16 01:34:18 +00:00
return LearnSWSH.GetIsLevelUp(species, form, move, lvl);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
return LearnNONE;
}
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 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)
{
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
return form 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
0 => RS,
1 => FR,
2 => LG,
3 => E,
_ => 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
PKHeX.Core Nullable cleanup (#2401) * Handle some nullable cases Refactor MysteryGift into a second abstract class (backed by a byte array, or fake data) Make some classes have explicit constructors instead of { } initialization * Handle bits more obviously without null * Make SaveFile.BAK explicitly readonly again * merge constructor methods to have readonly fields * Inline some properties * More nullable handling * Rearrange box actions define straightforward classes to not have any null properties * Make extrabyte reference array immutable * Move tooltip creation to designer * Rearrange some logic to reduce nesting * Cache generated fonts * Split mystery gift album purpose * Handle more tooltips * Disallow null setters * Don't capture RNG object, only type enum * Unify learnset objects Now have readonly properties which are never null don't new() empty learnsets (>800 Learnset objects no longer created, total of 2400 objects since we also new() a move & level array) optimize g1/2 reader for early abort case * Access rewrite Initialize blocks in a separate object, and get via that object removes a couple hundred "might be null" warnings since blocks are now readonly getters some block references have been relocated, but interfaces should expose all that's needed put HoF6 controls in a groupbox, and disable * Readonly personal data * IVs non nullable for mystery gift * Explicitly initialize forced encounter moves * Make shadow objects readonly & non-null Put murkrow fix in binary data resource, instead of on startup * Assign dex form fetch on constructor Fixes legality parsing edge cases also handle cxd parse for valid; exit before exception is thrown in FrameGenerator * Remove unnecessary null checks * Keep empty value until init SetPouch sets the value to an actual one during load, but whatever * Readonly team lock data * Readonly locks Put locked encounters at bottom (favor unlocked) * Mail readonly data / offset Rearrange some call flow and pass defaults Add fake classes for SaveDataEditor mocking Always party size, no need to check twice in stat editor use a fake save file as initial data for savedata editor, and for gamedata (wow i found a usage) constrain eventwork editor to struct variable types (uint, int, etc), thus preventing null assignment errors
2019-10-17 01:47:31 +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
{
use some explicit dex numbers as enum
2019-06-01 17:22:49 +00:00
const int index = (int)Species.Deoxys;
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
{
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
return form switch
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
{
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
0 => LevelUpRS[index], // Normal
1 => LevelUpFR[index], // Attack
2 => LevelUpLG[index], // Defense
3 => LevelUpE[index], // Speed
_ => 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);
use some explicit dex numbers as enum
2019-06-01 17:22:49 +00:00
return GameData.GetLearnsets(ver)[index];
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;
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
{
PKHeX.Core Nullable cleanup (#2401) * Handle some nullable cases Refactor MysteryGift into a second abstract class (backed by a byte array, or fake data) Make some classes have explicit constructors instead of { } initialization * Handle bits more obviously without null * Make SaveFile.BAK explicitly readonly again * merge constructor methods to have readonly fields * Inline some properties * More nullable handling * Rearrange box actions define straightforward classes to not have any null properties * Make extrabyte reference array immutable * Move tooltip creation to designer * Rearrange some logic to reduce nesting * Cache generated fonts * Split mystery gift album purpose * Handle more tooltips * Disallow null setters * Don't capture RNG object, only type enum * Unify learnset objects Now have readonly properties which are never null don't new() empty learnsets (>800 Learnset objects no longer created, total of 2400 objects since we also new() a move & level array) optimize g1/2 reader for early abort case * Access rewrite Initialize blocks in a separate object, and get via that object removes a couple hundred "might be null" warnings since blocks are now readonly getters some block references have been relocated, but interfaces should expose all that's needed put HoF6 controls in a groupbox, and disable * Readonly personal data * IVs non nullable for mystery gift * Explicitly initialize forced encounter moves * Make shadow objects readonly & non-null Put murkrow fix in binary data resource, instead of on startup * Assign dex form fetch on constructor Fixes legality parsing edge cases also handle cxd parse for valid; exit before exception is thrown in FrameGenerator * Remove unnecessary null checks * Keep empty value until init SetPouch sets the value to an actual one during load, but whatever * Readonly team lock data * Readonly locks Put locked encounters at bottom (favor unlocked) * Mail readonly data / offset Rearrange some call flow and pass defaults Add fake classes for SaveDataEditor mocking Always party size, no need to check twice in stat editor use a fake save file as initial data for savedata editor, and for gamedata (wow i found a usage) constrain eventwork editor to struct variable types (uint, int, etc), thus preventing null assignment errors
2019-10-17 01:47:31 +00:00
1 => GetMovesLevelUp1(species, form, lvl, minlvlG1, version),
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
2 => GetMovesLevelUp2(species, form, lvl, minlvlG2, pkm.Korean, pkm.LearnMovesNew2Disallowed(), version),
3 => GetMovesLevelUp3(species, form, lvl, version),
4 => GetMovesLevelUp4(species, form, lvl, version),
5 => GetMovesLevelUp5(species, form, lvl, version),
6 => GetMovesLevelUp6(species, form, lvl, version),
7 => GetMovesLevelUp7(species, form, lvl, MoveReminder, version),
Sword/Shield Update
2019-11-16 01:34:18 +00:00
8 => GetMovesLevelUp8(species, form, lvl, version),
Remove unnecessary casts
2020-01-07 01:50:18 +00:00
_ => Array.Empty<int>()
Use some c#8 sugar static local functions switch expressions using usings :) nullable next?
2019-10-08 01:40:09 +00:00
};
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
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
Sword/Shield Update
2019-11-16 01:34:18 +00:00
private static List<int> GetMovesLevelUp8(int species, int form, int max, GameVersion ver = Any)
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
Sword/Shield Update
2019-11-16 01:34:18 +00:00
return AddMovesLevelUp8(new List<int>(), ver, species, max, form);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +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
{
Use enum for species comparisons slightly easier to read with named values
2019-12-09 01:39:19 +00:00
if (species == (int)Species.Deoxys)
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 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
Sword/Shield Update
2019-11-16 01:34:18 +00:00
private static List<int> AddMovesLevelUp8(List<int> moves, GameVersion ver, int species, int max, int form)
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
Sword/Shield Update
2019-11-16 01:34:18 +00:00
// Move reminder can NOT teach any level like Gen7
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
switch (ver)
{
case Any:
case SW: case SH: case SWSH:
if (species > MaxSpeciesID_8)
return moves;
return LearnSWSH.AddMoves(moves, species, form, max);
}
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