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

386 lines
14 KiB
C#
Raw Normal View History

Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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
{
internal static class MoveTechnicalMachine
{
internal static GameVersion GetIsMachineMove(PKM pkm, int species, int form, int generation, int move, GameVersion ver = GameVersion.Any, bool RemoveTransfer = false)
{
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
if (pkm.IsMovesetRestricted())
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);
default:
return Legal.NONE;
}
}
private static GameVersion GetIsMachine1(int species, int move)
{
for (int i = 0; i < Legal.TMHM_RBY.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
if (Legal.TMHM_RBY[i] != move)
continue;
if (PersonalTable.RB[species].TMHM[i])
return GameVersion.RB;
if (PersonalTable.Y[species].TMHM[i])
return GameVersion.Y;
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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)
{
for (int i = 0; i < Legal.TMHM_GSC.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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 (Legal.TMHM_GSC[i] == move && PersonalTable.C[species].TMHM[i])
return GameVersion.GS;
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return 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)
{
for (int i = 0; i < Legal.TM_3.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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 (Legal.TM_3[i] == move && PersonalTable.E[species].TMHM[i])
return GameVersion.Gen3;
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
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)
{
int x = 0;
foreach (var m in Legal.HM_3)
{
if (m == move && PersonalTable.E[species].TMHM[x + 50])
return GameVersion.Gen3;
x++;
}
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)
{
for (int i = 0; i < Legal.TM_3.Length; i++)
Misc style & minor tweaks Remove move combobox flicker hack (no longer necessary) Add more Array.Empty usages cache mysterygift sizes seal some classes no functionality changes
2018-08-03 03:11:42 +00:00
{
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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 (Legal.TM_4[i] == move && PersonalTable.HGSS.GetFormeEntry(species, form).TMHM[i])
return GameVersion.Gen4;
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
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
if (PersonalTable.HGSS.GetFormeEntry(species, form).TMHM[96])
return GameVersion.HGSS;
break;
case 432: // Defog
if (PersonalTable.Pt.GetFormeEntry(species, form).TMHM[96])
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)
{
{
int i = 0;
foreach (var m in Legal.HM_DPPt)
{
if (m == move)
{
if (PersonalTable.Pt.GetFormeEntry(species, form).TMHM[i + 92])
return GameVersion.DPPt;
break;
}
i++;
}
foreach (var m in Legal.HM_HGSS)
{
if (m == move)
{
if (PersonalTable.HGSS.GetFormeEntry(species, form).TMHM[i + 92])
return GameVersion.HGSS;
break;
}
i++;
}
}
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)
{
for (int i = 0; i < Legal.TMHM_BW.Length; i++)
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 (Legal.TMHM_BW[i] == move)
return PersonalTable.B2W2.GetFormeEntry(species, form).TMHM[i] ? GameVersion.Gen5 : Legal.NONE;
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 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
{
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
for (int i = 0; i < Legal.TMHM_XY.Length; i++)
misc style updates
2018-08-13 02:27:11 +00:00
{
if (Legal.TMHM_XY[i] != move)
continue;
if (PersonalTable.XY.GetFormeEntry(species, form).TMHM[i])
return GameVersion.XY;
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
if (GameVersion.ORAS.Contains(ver))
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
for (int i = 0; i < Legal.TMHM_AO.Length; i++)
misc style updates
2018-08-13 02:27:11 +00:00
{
if (Legal.TMHM_AO[i] != move)
continue;
if (PersonalTable.AO.GetFormeEntry(species, form).TMHM[i])
return GameVersion.ORAS;
break;
}
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return 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)
{
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
if (GameVersion.GG.Contains(ver))
{
for (int i = 0; i < Legal.TMHM_GG.Length; i++)
{
if (Legal.TMHM_GG[i] != move)
continue;
if (PersonalTable.GG.GetFormeEntry(species, form).TMHM[i])
return GameVersion.GG;
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
if (GameVersion.SM.Contains(ver) && species <= Legal.MaxSpeciesID_7)
misc style updates
2018-08-13 02:27:11 +00:00
{
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
for (int i = 0; i < Legal.TMHM_SM.Length; i++)
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 (Legal.TMHM_SM[i] != move)
misc style updates
2018-08-13 02:27:11 +00:00
continue;
if (PersonalTable.SM.GetFormeEntry(species, form).TMHM[i])
return GameVersion.SM;
break;
}
}
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
{
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
for (int i = 0; i < Legal.TMHM_SM.Length; i++)
misc style updates
2018-08-13 02:27:11 +00:00
{
if (Legal.TMHM_SM[i] != move)
continue;
if (PersonalTable.USUM.GetFormeEntry(species, form).TMHM[i])
return GameVersion.USUM;
break;
}
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before checking - faster than full fetch, can be made even faster by optimizing lookups. subject to change :)
2018-06-09 03:10:41 +00:00
return Legal.NONE;
}
internal static IEnumerable<int> GetTMHM(PKM pkm, int species, int form, int generation, GameVersion ver = GameVersion.Any, bool RemoveTransfer = true)
{
misc style updates
2018-08-13 02:27:11 +00:00
var r = new List<int>();
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
if (pkm.IsMovesetRestricted())
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;
}
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)
{
int index = PersonalTable.RB.GetFormeIndex(species, 0);
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)
{
int index = PersonalTable.C.GetFormeIndex(species, 0);
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)
{
int index = PersonalTable.E.GetFormeIndex(species, 0);
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)
{
var pi_hgss = PersonalTable.HGSS.GetFormeEntry(species, form);
var pi_dppt = PersonalTable.Pt.GetFormeEntry(species, form);
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)
{
var pi = PersonalTable.B2W2.GetFormeEntry(species, form);
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
case GameVersion.X:
case GameVersion.Y:
case GameVersion.XY:
AddMachine6XY(r, species, form);
if (ver == GameVersion.Any) // Fall Through
AddMachine6AO(r, species, form);
break;
case GameVersion.AS:
case GameVersion.OR:
case GameVersion.ORAS:
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)
{
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
case GameVersion.GP:
case GameVersion.GE:
case GameVersion.GG:
Treat GameVersion.GO like other GG vers
2018-11-15 01:40:11 +00:00
case GameVersion.GO:
Add move/enc/loc references
2018-11-12 06:49:17 +00:00
AddMachineGG(r, species, form);
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
case GameVersion.SN:
case GameVersion.MN:
case GameVersion.SM:
if (species <= Legal.MaxSpeciesID_7)
AddMachineSM(r, species, form);
return;
case GameVersion.Any:
case GameVersion.US:
case GameVersion.UM:
case GameVersion.USUM:
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
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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)
{
var pi = PersonalTable.XY.GetFormeEntry(species, form);
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)
{
var pi = PersonalTable.AO.GetFormeEntry(species, form);
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;
var pi = PersonalTable.SM.GetFormeEntry(species, form);
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)
{
var pi = PersonalTable.USUM.GetFormeEntry(species, form);
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;
var pi = PersonalTable.GG.GetFormeEntry(species, form);
r.AddRange(Legal.TMHM_GG.Where((_, m) => pi.TMHM[m]));
}
Refactoring pull out some move data fetching to separate class add methods to quickly fetch if the move is learnable via that method eventual plan is this: replace 'fetch all possible moves then look within' move validation with: 'peek if learnable, and get info how' move validation advantages: - returns game the move was learned in and the level (if appropriate) - infinitely less object creation (garbage collection) - only looks for a given move, doesn't have to fetch everything before 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