Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-12-25 20:03:12 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/Legality/Moves/MoveTechnicalMachine.cs

466 lines
18 KiB
C#
Raw Normal View History

Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
using System;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
using System.Collections.Generic;
using System.Linq;
namespace PKHeX.Core
{
Expose move source classes for api purposes Not guaranteeing the method signature will be stable forever, but allows people to reference the public methods inside. Closes #3056
2020-10-27 16:25:33 +00:00
public static class MoveTechnicalMachine
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
{
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
public static GameVersion GetIsMachineMove(PKM pkm, int species, int form, int generation, int move, GameVersion ver = GameVersion.Any, bool RemoveTransfer = false)
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
{
Fix lgpe moveset restriction Closes #2704 Co-Authored-By: BetaLeaf <betaleaf@gmail.com>
2020-02-13 04:25:39 +00:00
if (pkm.IsMovesetRestricted(generation))
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
ver = (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)
{
case 1: return GetIsMachine1(species, move);
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 (pkm.VC1 && move > Legal.MaxMoveID_1)
return Legal.NONE;
return GetIsMachine2(species, 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
case 3: return GetIsMachine3(species, move, pkm.Format, RemoveTransfer);
case 4: return GetIsMachine4(species, move, pkm.Format, RemoveTransfer, form);
case 5: return GetIsMachine5(species, move, form);
case 6: return GetIsMachine6(species, move, form, ver);
case 7: return GetIsMachine7(species, move, form, ver);
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
case 8: return GetIsMachine8(species, move, form, ver);
default:
return Legal.NONE;
}
}
public static GameVersion GetIsRecordMove(PKM pkm, int species, int form, int generation, int move, GameVersion ver = GameVersion.Any, bool allowBit = false)
{
if (pkm.IsMovesetRestricted(generation))
ver = (GameVersion)pkm.Version;
Use new switch statements
2020-12-24 01:14:38 +00:00
return generation switch
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
{
Use new switch statements
2020-12-24 01:14:38 +00:00
8 => GetIsRecord8(pkm, species, move, form, ver, allowBit),
Trailing commas No functional change
2021-08-20 20:49:20 +00:00
_ => Legal.NONE,
Use new switch statements
2020-12-24 01:14:38 +00:00
};
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
private static GameVersion GetIsMachine1(int species, int move)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_RBY, move);
if (index == -1)
return Legal.NONE;
if (PersonalTable.RB.GetFormEntry(species, 0).TMHM[index])
return GameVersion.RB;
if (PersonalTable.Y.GetFormEntry(species, 0).TMHM[index])
return GameVersion.YW;
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 Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine2(int species, int move)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_GSC, move);
if (index != -1 && PersonalTable.C.GetFormEntry(species, 0).TMHM[index])
return GameVersion.GS;
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 Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine3(int species, int move, int format, bool RemoveTransfer)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TM_3, move);
if (index != -1 && PersonalTable.E.GetFormEntry(species, 0).TMHM[index])
return GameVersion.Gen3;
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 (!RemoveTransfer && format <= 3)
return GetIsMachine3HM(species, move);
return Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine3HM(int species, int move)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.HM_3, move);
if (index == -1)
return Legal.NONE;
if (PersonalTable.E.GetFormEntry(species, 0).TMHM[index + 50])
return GameVersion.Gen3;
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 Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine4(int species, int move, int format, bool RemoveTransfer, int form)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
// TM
var index = Array.IndexOf(Legal.TM_4, move);
if (index != -1 && PersonalTable.HGSS.GetFormEntry(species, form).TMHM[index])
return GameVersion.Gen4;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
// HM
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 (RemoveTransfer && format > 4)
return GetIsMachine4HMTransfer(species, move, form);
return GetIsMachine4HM(species, move, 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
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine4HMTransfer(int species, int move, int form)
{
// The combination of both these moves is illegal, it should be checked that the pokemon only learn one
// except if it can learn any of these moves in gen 5 or later
switch (move)
{
case 250: // Whirlpool
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
if (PersonalTable.HGSS.GetFormEntry(species, form).TMHM[96])
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return GameVersion.HGSS;
break;
case 432: // Defog
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
if (PersonalTable.Pt.GetFormEntry(species, form).TMHM[96])
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return GameVersion.DPPt;
break;
}
return Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine4HM(int species, int move, int form)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var dpi = Array.IndexOf(Legal.HM_DPPt, move);
if (dpi != 0 && PersonalTable.Pt.GetFormEntry(species, form).TMHM[92 + dpi])
return GameVersion.DPPt;
Fix gen4 hm indexing
2021-01-26 04:58:56 +00:00
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var gsi = Array.IndexOf(Legal.HM_HGSS, move);
if (gsi != 0 && PersonalTable.HGSS.GetFormEntry(species, form).TMHM[92 + gsi])
return GameVersion.DPPt;
Fix gen4 hm indexing
2021-01-26 04:58:56 +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 Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine5(int species, int move, int form)
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_BW, move);
if (index != -1 && PersonalTable.B2W2.GetFormEntry(species, form).TMHM[index])
return GameVersion.Gen5;
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 Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine6(int species, int move, int form, GameVersion ver)
{
if (GameVersion.XY.Contains(ver))
misc style updates
2018-08-13 02:27:11 +00:00
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_XY, move);
if (index != -1 && PersonalTable.XY.GetFormEntry(species, form).TMHM[index])
return GameVersion.XY;
misc style updates
2018-08-13 02:27:11 +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
if (GameVersion.ORAS.Contains(ver))
misc style updates
2018-08-13 02:27:11 +00:00
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_AO, move);
if (index != -1 && PersonalTable.AO.GetFormEntry(species, form).TMHM[index])
return GameVersion.ORAS;
misc style updates
2018-08-13 02:27:11 +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 Legal.NONE;
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static GameVersion GetIsMachine7(int species, int move, int form, GameVersion ver)
{
Split GO from "GG" gameversion Make Gen7b as the combined ver for that expression
2020-08-07 01:24:20 +00:00
if (GameVersion.Gen7b.Contains(ver))
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_GG, move);
if (index != -1 && PersonalTable.GG.GetFormEntry(species, form).TMHM[index])
return GameVersion.GG;
Add move/enc/loc references
2018-11-12 06:49:17 +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
if (GameVersion.SM.Contains(ver) && species <= Legal.MaxSpeciesID_7)
misc style updates
2018-08-13 02:27:11 +00:00
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_SM, move);
if (index != -1 && PersonalTable.SM.GetFormEntry(species, form).TMHM[index])
return GameVersion.SM;
misc style updates
2018-08-13 02:27:11 +00:00
}
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
if (GameVersion.USUM.Contains(ver) && species <= Legal.MaxSpeciesID_7_USUM)
misc style updates
2018-08-13 02:27:11 +00:00
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Array.IndexOf(Legal.TMHM_SM, move);
if (index != -1 && PersonalTable.USUM.GetFormEntry(species, form).TMHM[index])
return GameVersion.USUM;
misc style updates
2018-08-13 02:27:11 +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 Legal.NONE;
}
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
private static GameVersion GetIsMachine8(int species, int move, int form, GameVersion ver)
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
if (GameVersion.SWSH.Contains(ver))
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Legal.TMHM_SWSH.AsSpan(0, PersonalInfoSWSH.CountTM).IndexOf(move);
if (index != -1 && PersonalTable.SWSH.GetFormEntry(species, form).TMHM[index])
return GameVersion.SWSH;
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
}
Update 21.11.19 - Brilliant Diamond & Shining Pearl (#3289) Big thanks to @SciresM @sora10pls @Lusamine @architdate @ReignOfComputer for testing and contributing code / test cases. Can't add co-authors from the PR menu :( Builds will fail because azure pipelines not yet updated with net6.
2021-11-20 02:23:49 +00:00
if (GameVersion.BDSP.Contains(ver))
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Legal.TMHM_BDSP.AsSpan(0, PersonalInfoBDSP.CountTM).IndexOf(move);
if (index != -1 && PersonalTable.BDSP.GetFormEntry(species, form).TMHM[index])
return GameVersion.BDSP;
Update 21.11.19 - Brilliant Diamond & Shining Pearl (#3289) Big thanks to @SciresM @sora10pls @Lusamine @architdate @ReignOfComputer for testing and contributing code / test cases. Can't add co-authors from the PR menu :( Builds will fail because azure pipelines not yet updated with net6.
2021-11-20 02:23:49 +00:00
}
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
return Legal.NONE;
}
private static GameVersion GetIsRecord8(PKM pkm, int species, int move, int form, GameVersion ver, bool allowBit)
{
if (GameVersion.SWSH.Contains(ver))
{
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
var index = Legal.TMHM_SWSH.AsSpan(PersonalInfoSWSH.CountTM, PersonalInfoSWSH.CountTR).IndexOf(move);
if (index != -1)
Sword/Shield Update
2019-11-16 01:34:18 +00:00
{
if (allowBit)
return GameVersion.SWSH;
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
if (((ITechRecord8)pkm).GetMoveRecordFlag(index))
Sword/Shield Update
2019-11-16 01:34:18 +00:00
return GameVersion.SWSH;
Condense some expressions Getting close to weeding out all the easy inefficiencies to make me finally tackle the "stop gathering all moves instead of checking individual moves" allocation issue.
2022-03-21 06:28:18 +00:00
if (index == 12 && species == (int)Species.Calyrex && form == 0) // TR12
Handle Calyrex TR bug Co-Authored-By: ReignOfComputer <2667537+ReignOfComputer@users.noreply.github.com>
2020-10-24 18:12:25 +00:00
return GameVersion.SWSH; // Agility Calyrex without TR glitch.
Sword/Shield Update
2019-11-16 01:34:18 +00:00
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
return Legal.NONE;
}
Make MoveEgg / MoveTM internal methods public Closes #3031
2020-10-13 18:22:13 +00:00
public static IEnumerable<int> GetTMHM(PKM pkm, int species, int form, int generation, GameVersion ver = GameVersion.Any, bool RemoveTransfer = true)
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 updates
2018-08-13 02:27:11 +00:00
var r = new List<int>();
Fix lgpe moveset restriction Closes #2704 Co-Authored-By: BetaLeaf <betaleaf@gmail.com>
2020-02-13 04:25:39 +00:00
if (pkm.IsMovesetRestricted(generation))
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
ver = (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)
{
case 1: AddMachine1(r, species); break;
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: AddMachine2(r, species);
if (pkm.Format >= 7 && pkm.VC1)
r.RemoveAll(z => z > Legal.MaxMoveID_1);
break;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
case 3: AddMachine3(r, species, pkm.Format, RemoveTransfer); break;
case 4: AddMachine4(r, species, pkm.Format, RemoveTransfer, form); break;
case 5: AddMachine5(r, species, form); break;
case 6: AddMachine6(r, species, form, ver); break;
case 7: AddMachine7(r, species, form, ver); break;
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
case 8: AddMachine8(r, species, form, ver); break;
}
return r.Distinct();
}
public static IEnumerable<int> GetRecords(PKM pkm, int species, int form, int generation)
{
var r = new List<int>();
switch (generation)
{
case 8: AddRecordSWSH(r, species, form, pkm); break;
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
Refactoring where!contains -> except relocate special tutor
2018-06-09 23:04:06 +00:00
return r.Distinct();
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
}
private static void AddMachine1(List<int> r, int species)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
int index = PersonalTable.RB.GetFormIndex(species, 0);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
if (index == 0)
return;
var pi_rb = (PersonalInfoG1)PersonalTable.RB[index];
var pi_y = (PersonalInfoG1)PersonalTable.Y[index];
r.AddRange(Legal.TMHM_RBY.Where((_, m) => pi_rb.TMHM[m]));
r.AddRange(Legal.TMHM_RBY.Where((_, m) => pi_y.TMHM[m]));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine2(List<int> r, int species)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
int index = PersonalTable.C.GetFormIndex(species, 0);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
if (index == 0)
return;
var pi_c = PersonalTable.C[index];
r.AddRange(Legal.TMHM_GSC.Where((_, m) => pi_c.TMHM[m]));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine3(List<int> r, int species, int format, bool RemoveTransfer)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
int index = PersonalTable.E.GetFormIndex(species, 0);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
if (index == 0)
return;
var pi_c = PersonalTable.E[index];
r.AddRange(Legal.TM_3.Where((_, m) => pi_c.TMHM[m]));
if (!RemoveTransfer || format == 3) // HM moves must be removed for 3->4, only give if current format.
r.AddRange(Legal.HM_3.Where((_, m) => pi_c.TMHM[m + 50]));
else if (format > 3) //Remove HM
r.AddRange(Legal.HM_3.Where((_, m) => pi_c.TMHM[m + 50]).Except(Legal.HM_3));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine4(List<int> r, int species, int format, bool RemoveTransfer, int form)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi_hgss = PersonalTable.HGSS.GetFormEntry(species, form);
var pi_dppt = PersonalTable.Pt.GetFormEntry(species, form);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
r.AddRange(Legal.TM_4.Where((_, m) => pi_hgss.TMHM[m]));
if (RemoveTransfer && format > 4)
{
// The combination of both these moves is illegal, it should be checked that the pokemon only learn one
// except if it can learn any of these moves in gen 5 or later
if (pi_hgss.TMHM[96])
r.Add(250); // Whirlpool
if (pi_dppt.TMHM[96])
r.Add(432); // Defog
}
else
{
r.AddRange(Legal.HM_DPPt.Where((_, m) => pi_dppt.TMHM[m + 92]));
r.AddRange(Legal.HM_HGSS.Where((_, m) => pi_hgss.TMHM[m + 92]));
}
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine5(List<int> r, int species, int form)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.B2W2.GetFormEntry(species, form);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
r.AddRange(Legal.TMHM_BW.Where((_, m) => pi.TMHM[m]));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine6(List<int> r, int species, int form, GameVersion ver = GameVersion.Any)
{
switch (ver)
{
case GameVersion.Any: // Start at the top, hit every table
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case GameVersion.X or GameVersion.Y or GameVersion.XY:
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
AddMachine6XY(r, species, form);
if (ver == GameVersion.Any) // Fall Through
AddMachine6AO(r, species, form);
break;
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case GameVersion.AS or GameVersion.OR or GameVersion.ORAS:
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
AddMachine6AO(r, species, form);
break;
}
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine7(List<int> r, int species, int form, GameVersion ver = GameVersion.Any)
{
switch (ver)
{
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case GameVersion.GP or GameVersion.GE or GameVersion.GG or GameVersion.GO:
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
AddMachineGG(r, species, form);
return;
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case GameVersion.SN or GameVersion.MN or GameVersion.SM:
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 <= Legal.MaxSpeciesID_7)
AddMachineSM(r, species, form);
return;
case GameVersion.Any:
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case GameVersion.US or GameVersion.UM or GameVersion.USUM:
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
AddMachineUSUM(r, species, form);
if (ver == GameVersion.Any) // Fall Through
AddMachineSM(r, species, form);
return;
}
}
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
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
private static void AddMachine8(List<int> r, int species, int form, GameVersion ver = GameVersion.Any)
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
switch (ver)
{
case GameVersion.Any:
Condense some switch expressions Should be it for now; exhaustively searched for all that made sense to change
2020-12-25 18:58:33 +00:00
case GameVersion.SW or GameVersion.SH or GameVersion.SWSH:
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
AddMachineSWSH(r, species, form);
Update PKHeX.Core abstractions with latest logic Co-Authored-By: Matt <17801814+sora10pls@users.noreply.github.com> Co-Authored-By: SciresM <8676005+SciresM@users.noreply.github.com> Co-Authored-By: Lusamine <30205550+Lusamine@users.noreply.github.com>
2022-02-05 01:35:15 +00:00
return;
Update 21.11.19 - Brilliant Diamond & Shining Pearl (#3289) Big thanks to @SciresM @sora10pls @Lusamine @architdate @ReignOfComputer for testing and contributing code / test cases. Can't add co-authors from the PR menu :( Builds will fail because azure pipelines not yet updated with net6.
2021-11-20 02:23:49 +00:00
case GameVersion.BD or GameVersion.SP or GameVersion.BDSP:
AddMachineBDSP(r, species, form);
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
return;
}
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine6XY(List<int> r, int species, int form)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.XY.GetFormEntry(species, form);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
r.AddRange(Legal.TMHM_XY.Where((_, m) => pi.TMHM[m]));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachine6AO(List<int> r, int species, int form)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.AO.GetFormEntry(species, form);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
r.AddRange(Legal.TMHM_AO.Where((_, m) => pi.TMHM[m]));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachineSM(List<int> r, int species, int form)
{
if (species > Legal.MaxSpeciesID_7)
return;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.SM.GetFormEntry(species, form);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
r.AddRange(Legal.TMHM_SM.Where((_, m) => pi.TMHM[m]));
}
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
private static void AddMachineUSUM(List<int> r, int species, int form)
{
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.USUM.GetFormEntry(species, form);
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
r.AddRange(Legal.TMHM_SM.Where((_, m) => pi.TMHM[m]));
}
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
private static void AddMachineGG(List<int> r, int species, int form)
{
if (species > Legal.MaxSpeciesID_7b)
return;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.GG.GetFormEntry(species, form);
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
r.AddRange(Legal.TMHM_GG.Where((_, m) => pi.TMHM[m]));
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
private static void AddMachineSWSH(List<int> r, int species, int form)
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
{
if (species > Legal.MaxSpeciesID_8)
return;
Unify concepts with different names AltForm & Form & Forme => Form GenNumber & Generation => Generation Extract out SpeciesForm interface, and re-add IGeneration For those using PKHeX as a dependency, this should be a pretty straightforward manual replacement... GenNumber and AltForm should be quick find-replace`s.
2020-12-11 04:42:30 +00:00
var pi = PersonalTable.SWSH.GetFormEntry(species, form);
Sword/Shield Update
2019-11-16 01:34:18 +00:00
var tmhm = pi.TMHM;
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
for (int i = 0; i < PersonalInfoSWSH.CountTM; i++)
Sword/Shield Update
2019-11-16 01:34:18 +00:00
{
if (!tmhm[i])
continue;
r.Add(Legal.TMHM_SWSH[i]);
}
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
}
Sword/Shield Update
2019-11-16 01:34:18 +00:00
Update 21.11.19 - Brilliant Diamond & Shining Pearl (#3289) Big thanks to @SciresM @sora10pls @Lusamine @architdate @ReignOfComputer for testing and contributing code / test cases. Can't add co-authors from the PR menu :( Builds will fail because azure pipelines not yet updated with net6.
2021-11-20 02:23:49 +00:00
private static void AddMachineBDSP(List<int> r, int species, int form)
{
if (species > Legal.MaxSpeciesID_8b)
return;
var pi = PersonalTable.BDSP.GetFormEntry(species, form);
r.AddRange(Legal.TMHM_BDSP.Where((_, m) => pi.TMHM[m]));
}
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
public static void AddRecordSWSH(List<int> r, int species, int form, PKM pkm)
{
Update 21.11.19 - Brilliant Diamond & Shining Pearl (#3289) Big thanks to @SciresM @sora10pls @Lusamine @architdate @ReignOfComputer for testing and contributing code / test cases. Can't add co-authors from the PR menu :( Builds will fail because azure pipelines not yet updated with net6.
2021-11-20 02:23:49 +00:00
if (pkm is not PK8 pk8)
return;
Permit TR flags for "Can Relearn", split branching for TR checks
2020-12-22 17:10:10 +00:00
var pi = PersonalTable.SWSH.GetFormEntry(species, form);
var tmhm = pi.TMHM;
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
for (int i = 0; i < PersonalInfoSWSH.CountTR; i++)
Sword/Shield Update
2019-11-16 01:34:18 +00:00
{
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
var index = i + PersonalInfoSWSH.CountTM;
if (!tmhm[index])
Sword/Shield Update
2019-11-16 01:34:18 +00:00
continue;
if (!pk8.GetMoveRecordFlag(i))
Handle Calyrex TR bug Co-Authored-By: ReignOfComputer <2667537+ReignOfComputer@users.noreply.github.com>
2020-10-24 18:12:25 +00:00
{
if (i == 12 && species == (int) Species.Calyrex && form == 0) // TR12
{
// Unfuse logic does not check if the currently known TR move has the flag or not.
// Agility can be learned via Level Up while fused, but only via TR when Unfused.
// We'll let Agility be a legal TR move without the flag, only for Calyrex!
}
else
{
continue;
}
}
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
r.Add(Legal.TMHM_SWSH[index]);
Sword/Shield Update
2019-11-16 01:34:18 +00:00
}
Add swsh content placeholders (#2392) placeholder content until real data is dumped
2019-09-23 23:56:47 +00:00
}
Add TR flags to emoveset generator
2021-01-31 05:49:45 +00:00
public static IEnumerable<int> GetAllPossibleRecords(int species, int form)
{
var pi = PersonalTable.SWSH.GetFormEntry(species, form);
var tmhm = pi.TMHM;
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
for (int i = 0; i < PersonalInfoSWSH.CountTM; i++)
Add TR flags to emoveset generator
2021-01-31 05:49:45 +00:00
{
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
var index = i + PersonalInfoSWSH.CountTM;
if (!tmhm[index])
Add TR flags to emoveset generator
2021-01-31 05:49:45 +00:00
continue;
Minor clean Slap on interface for EntreeSlot De-magic some :100: numbers to indicate what they're doing Improve perf of move-match-relearn check Add an "else" as valid is never both values (history verifier)
2021-08-13 22:36:30 +00:00
yield return Legal.TMHM_SWSH[index];
Add TR flags to emoveset generator
2021-01-31 05:49:45 +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
}
Add TR flags to emoveset generator
2021-01-31 05:49:45 +00:00
}
Reference in a new issue Copy permalink