Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-09-21 14:51:55 +00:00
Code Issues Projects Releases Packages Wiki Activity

Split GetIsLevelUp to individual versions

Browse source 
static the GameVersion reference as we're excessively using it in the
switch cases, for clearer reading
This commit is contained in:
Kurt 2018-06-12 22:15:06 -07:00
parent b9652a835d
commit 39daa6c65d
4 changed files with 265 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
PKHeX.Core/Legality/Learnset/Learnset.cs
View file

@ -68,6 +68,19 @@ namespace PKHeX.Core
return moves; return moves;
} }
public IList<int> GetUniqueMovesLearned(IEnumerable<int> seed, int maxLevel, int minLevel = 0)
{
int start = Array.FindIndex(Levels, z => z >= minLevel);
int end = Array.FindLastIndex(Levels, z => z <= maxLevel);
var list = new List<int>(seed);
for (int i = start; i <= end; i++)
{
if (!list.Contains(Moves[i]))
list.Add(Moves[i]);
}
return list;
}
/// <summary>Returns the index of the lowest level move if the Pokémon were encountered at the specified level.</summary> /// <summary>Returns the index of the lowest level move if the Pokémon were encountered at the specified level.</summary>
/// <remarks>Helps determine the minimum level an encounter can be at.</remarks> /// <remarks>Helps determine the minimum level an encounter can be at.</remarks>
/// <param name="level">The level the Pokémon was encountered at.</param> /// <param name="level">The level the Pokémon was encountered at.</param>

2
PKHeX.Core/Legality/Moves/LearnInfo.cs
View file

@ -30,5 +30,7 @@ namespace PKHeX.Core
Game = game; Game = game;
Level = lv; Level = lv;
} }
public bool IsLevelUp => Level >= 0;
} }
} }

83
PKHeX.Core/Legality/Moves/LearnLookup.cs Normal file
View file

@ -0,0 +1,83 @@
using System;
using System.Linq;
using static PKHeX.Core.Legal;
namespace PKHeX.Core
{
/// <summary>
/// LevelUp Lookup object
/// </summary>
public class LearnLookup
{
private readonly GameVersion Version;
private readonly PersonalTable Table;
private readonly Learnset[] Learn;
public LearnLookup(PersonalTable table, Learnset[] learn, GameVersion version)
{
Version = version;
Table = table;
Learn = learn;
}
public LearnVersion GetIsLevelUp(int species, int form, int move)
{
int index = Table.GetFormeIndex(species, form);
if (index <= 0)
return LearnNONE;
var lv = Learn[index].GetLevelLearnMove(move);
if (lv >= 0)
return new LearnVersion(lv, Version);
return LearnNONE;
}
public LearnVersion GetIsLevelUp(int species, int form, int move, int max)
{
int index = Table.GetFormeIndex(species, form);
if (index <= 0)
return LearnNONE;
var lv = Learn[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= max)
return new LearnVersion(lv, Version);
return LearnNONE;
}
public LearnVersion GetIsLevelUpMin(int species, int move, int max, int min, int form = 0)
{
int index = Table.GetFormeIndex(species, form);
if (index <= 0)
return LearnNONE;
var lv = Learn[index].GetLevelLearnMove(move, min);
if (lv >= min && lv <= max)
return new LearnVersion(lv, Version);
return LearnNONE;
}
public LearnVersion GetIsLevelUpG1(int species, int move, int max, int min = 0)
{
int index = PersonalTable.RB.GetFormeIndex(species, 0);
if (index == 0)
return LearnNONE;
// No relearner -- have to be learned on levelup
var lv = Learn[index].GetLevelLearnMove(move, min);
if (lv >= 0 && lv <= max)
return new LearnVersion(lv, Version);
if (min >= 1)
return LearnNONE;
var pi = (PersonalInfoG1)Table[index];
var i = Array.IndexOf(pi.Moves, move);
// Check if move was not overwritten by higher level moves before it was encountered
if (i >= 0)
{
var unique = Learn[index].GetUniqueMovesLearned(pi.Moves.Where(z => z != 0), max);
if (unique.Count - i <= 4)
return new LearnVersion(0, Version);
}
return LearnNONE;
}
}
}

366
PKHeX.Core/Legality/Moves/MoveLevelUp.cs
View file

@ -3,169 +3,197 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using static PKHeX.Core.Legal; using static PKHeX.Core.Legal;
using static PKHeX.Core.GameVersion;
namespace PKHeX.Core namespace PKHeX.Core
{ {
internal static class MoveLevelUp internal static class MoveLevelUp
{ {
public static LearnVersion GetIsLevelUpMove(PKM pkm, int species, int minlvlG1, int minlvlG2, int lvl, int form, int Generation, int move, GameVersion Version = GameVersion.Any) private static readonly LearnLookup LearnSM, LearnUSUM,
LearnXY, LearnAO,
LearnBW, LearnB2W2,
LearnDP, LearnPt, LearnHGSS,
LearnRSE, LearnFRLG,
LearnGS, LearnC,
LearnRB, LearnY;
static MoveLevelUp()
{
LearnSM = new LearnLookup(PersonalTable.SM, LevelUpSM, SM);
LearnUSUM = new LearnLookup(PersonalTable.USUM, LevelUpUSUM, USUM);
LearnXY = new LearnLookup(PersonalTable.XY, LevelUpXY, XY);
LearnAO = new LearnLookup(PersonalTable.AO, LevelUpAO, ORAS);
LearnBW = new LearnLookup(PersonalTable.BW, LevelUpBW, BW);
LearnB2W2 = new LearnLookup(PersonalTable.B2W2, LevelUpB2W2, B2W2);
LearnDP = new LearnLookup(PersonalTable.DP, LevelUpDP, DP);
LearnPt = new LearnLookup(PersonalTable.Pt, LevelUpPt, Pt);
LearnHGSS = new LearnLookup(PersonalTable.HGSS, LevelUpHGSS, HGSS);
LearnRSE = new LearnLookup(PersonalTable.RS, LevelUpRS, RSE);
LearnFRLG = new LearnLookup(PersonalTable.LG, LevelUpLG, FRLG);
LearnGS = new LearnLookup(PersonalTable.GS, LevelUpGS, GS);
LearnC = new LearnLookup(PersonalTable.C, LevelUpC, C);
LearnRB = new LearnLookup(PersonalTable.RB, LevelUpRB, RB);
LearnY = new LearnLookup(PersonalTable.Y, LevelUpY, YW);
}
public static LearnVersion GetIsLevelUpMove(PKM pkm, int species, int minlvlG1, int minlvlG2, int lvl, int form, int Generation, int move, GameVersion Version = Any)
{ {
switch (Generation) switch (Generation)
{ {
case 1: return GetIsLevelUp1(species, move, lvl, minlvlG1); case 1: return GetIsLevelUp1(species, move, lvl, minlvlG1, Version);
case 2: return GetIsLevelUp2(species, move, lvl, minlvlG2, pkm.Korean); case 2: return GetIsLevelUp2(species, move, lvl, minlvlG2, pkm.Korean, Version);
case 3: return GetIsLevelUp3(species, move, lvl, form); case 3: return GetIsLevelUp3(species, move, lvl, form, Version);
case 4: return GetIsLevelUp4(species, move, lvl, form); case 4: return GetIsLevelUp4(species, move, lvl, form, Version);
case 5: return GetIsLevelUp5(species, move, lvl, form); case 5: return GetIsLevelUp5(species, move, lvl, form, Version);
case 6: return GetIsLevelUp6(species, move, lvl, form, Version); case 6: return GetIsLevelUp6(species, move, lvl, form, Version);
case 7: return GetIsLevelUp7(species, move, form, Version); case 7: return GetIsLevelUp7(species, move, form, Version);
} }
return LearnNONE; return LearnNONE;
} }
private static LearnVersion GetIsLevelUp1(int species, int move, int max, int min) private static LearnVersion GetIsLevelUp1(int species, int move, int max, int min, GameVersion ver = Any)
{ {
int index = PersonalTable.RB.GetFormeIndex(species, 0); switch (ver)
if (index == 0)
return LearnNONE;
if (min == 1)
{ {
var pi_rb = (PersonalInfoG1)PersonalTable.RB[index]; case Any:
var pi_y = (PersonalInfoG1)PersonalTable.Y[index]; case RBY:
if (pi_rb.Moves.Contains(move)) var first = LearnRB.GetIsLevelUpG1(species, move, max, min);
return new LearnVersion(0, GameVersion.RB); if (first.IsLevelUp)
if (pi_y.Moves.Contains(move)) return first;
return new LearnVersion(0, GameVersion.YW); return LearnY.GetIsLevelUpG1(species, move, max, min);
case RD: case BU: case GN: case RB:
return LearnRB.GetIsLevelUpG1(species, move, max, min);
case YW:
return LearnY.GetIsLevelUpG1(species, move, max, min);
} }
// No relearner -- have to be learned on levelup
var lv = LevelUpRB[index].GetLevelLearnMove(move, min);
if (lv >= 0 && lv <= max)
return new LearnVersion(lv, GameVersion.RB);
// No relearner -- have to be learned on levelup
lv = LevelUpY[index].GetLevelLearnMove(move, min);
if (lv >= 0 && lv <= max)
return new LearnVersion(lv, GameVersion.YW);
return LearnNONE; return LearnNONE;
} }
private static LearnVersion GetIsLevelUp2(int species, int move, int max, int min, bool korean) private static LearnVersion GetIsLevelUp2(int species, int move, int max, int min, bool korean, GameVersion ver = Any)
{ {
if (move > MaxMoveID_1) if (move > MaxMoveID_1)
return LearnNONE; return LearnNONE;
int index = PersonalTable.C.GetFormeIndex(species, 0); // No Korean Crystal
if (index == 0) switch (ver)
return LearnNONE; {
case Any:
// No relearner -- have to be learned on levelup case GSC:
var lv = LevelUpGS[index].GetLevelLearnMove(move, min); var first = LearnGS.GetIsLevelUpMin(species, move, max, min);
if (lv >= 0 && lv <= max) if (first.IsLevelUp || korean)
return new LearnVersion(lv, GameVersion.GS); return first;
return LearnC.GetIsLevelUpMin(species, move, max, min);
if (korean) // No Korean Crystal
return LearnNONE;
// No relearner -- have to be learned on levelup
lv = LevelUpC[index].GetLevelLearnMove(move, min);
if (lv >= 0 && lv <= max)
return new LearnVersion(lv, GameVersion.C);
case GD: case SV: case GS:
return LearnGS.GetIsLevelUpMin(species, move, max, min);
case C when !korean:
return LearnC.GetIsLevelUpMin(species, move, max, min);
}
return LearnNONE; return LearnNONE;
} }
private static LearnVersion GetIsLevelUp3(int species, int move, int lvl, int form) private static LearnVersion GetIsLevelUp3(int species, int move, int lvl, int form, GameVersion ver = Any)
{ {
if (species == 386)
int index = PersonalTable.E.GetFormeIndex(species, 0);
if (index == 0)
return LearnNONE;
if (index == 386)
return GetIsLevelUp3Deoxys(form, move, lvl); return GetIsLevelUp3Deoxys(form, move, lvl);
// Emerald level up table are equals to R/S level up tables // Emerald level up tables are equal to R/S level up tables
var lv = LevelUpE[index].GetLevelLearnMove(move); switch (ver)
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.RSE);
// fire red and leaf green are equals between each other but different than RSE
// Do not use FR Levelup table. It have 67 moves for charmander but Leaf Green moves table is correct
lv = LevelUpLG[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.FRLG);
return LearnNONE;
}
private static LearnVersion GetIsLevelUp4(int species, int move, int lvl, int form)
{
int index = PersonalTable.HGSS.GetFormeIndex(species, form);
if (index == 0)
return LearnNONE;
var lv = LevelUpDP[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.DP);
lv = LevelUpPt[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.Pt);
lv = LevelUpHGSS[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.HGSS);
return LearnNONE;
}
private static LearnVersion GetIsLevelUp5(int species, int form, int move, int lvl)
{
int index1 = PersonalTable.BW.GetFormeIndex(species, form);
int index2 = PersonalTable.B2W2.GetFormeIndex(species, form);
if (index1 == 0 && index2 == 0)
return LearnNONE;
if (index1 != 0)
{ {
var lv = LevelUpBW[index1].GetLevelLearnMove(move); case Any:
if (lv >= 0 && lv <= lvl) var first = LearnRSE.GetIsLevelUp(species, form, move, lvl);
return new LearnVersion(lv, GameVersion.BW); if (first.IsLevelUp)
} return first;
if (index2 != 0) return LearnFRLG.GetIsLevelUp(species, form, move, lvl);
{
var lv = LevelUpB2W2[index2].GetLevelLearnMove(move); case R: case S: case E: case RS: case RSE:
if (lv >= 0 && lv <= lvl) return LearnRSE.GetIsLevelUp(species, form, move, lvl);
return new LearnVersion(lv, GameVersion.B2W2); case FR: case LG: case FRLG:
return LearnFRLG.GetIsLevelUp(species, form, move, lvl);
} }
return LearnNONE; return LearnNONE;
} }
private static LearnVersion GetIsLevelUp6(int species, int move, int lvl, int form, GameVersion ver) private static LearnVersion GetIsLevelUp4(int species, int move, int lvl, int form, GameVersion ver = Any)
{ {
switch (ver) switch (ver)
{ {
case GameVersion.SN: case Any:
case GameVersion.MN: case DPPt:
case GameVersion.SM: var first = LearnDP.GetIsLevelUp(species, form, move, lvl);
return GetIsLevelUp6XY(species, form, move, lvl); if (first.IsLevelUp)
case GameVersion.Any: return first;
case GameVersion.US: var second = LearnPt.GetIsLevelUp(species, form, move, lvl);
case GameVersion.UM: if (second.IsLevelUp)
case GameVersion.USUM: return second;
return GetIsLevelUp6AO(species, form, move, lvl); if (ver == DPPt) // stop here
return LearnNONE;
return LearnHGSS.GetIsLevelUp(species, form, move, lvl);
case D: case P: case DP:
return LearnDP.GetIsLevelUp(species, form, move, lvl);
case Pt:
return LearnPt.GetIsLevelUp(species, form, move, lvl);
case HG: case SS: case HGSS:
return LearnHGSS.GetIsLevelUp(species, form, move, lvl);
} }
return LearnNONE; return LearnNONE;
} }
private static LearnVersion GetIsLevelUp7(int species, int move, int form, GameVersion ver) private static LearnVersion GetIsLevelUp5(int species, int form, int move, int lvl, GameVersion ver = Any)
{ {
switch (ver) switch (ver)
{ {
case GameVersion.SN: case Any:
case GameVersion.MN: var first = LearnBW.GetIsLevelUp(species, form, move, lvl);
case GameVersion.SM: if (first.IsLevelUp)
return GetIsLevelUp7SM(species, form, move); return first;
case GameVersion.Any: return LearnB2W2.GetIsLevelUp(species, form, move, lvl);
case GameVersion.US: case B: case W: case BW:
case GameVersion.UM: return LearnBW.GetIsLevelUp(species, form, move, lvl);
case GameVersion.USUM: case B2: case W2: case B2W2:
return GetIsLevelUp7USUM(species, form, move); return LearnB2W2.GetIsLevelUp(species, form, move, lvl);
}
return LearnNONE;
}
private static LearnVersion GetIsLevelUp6(int species, int move, int lvl, int form, GameVersion ver = Any)
{
switch (ver)
{
case Any:
var first = LearnXY.GetIsLevelUp(species, form, move, lvl);
if (first.IsLevelUp)
return first;
return LearnAO.GetIsLevelUp(species, form, move, lvl);
case X: case Y: case XY:
return LearnXY.GetIsLevelUp(species, form, move, lvl);
case OR: case AS: case ORAS:
return LearnAO.GetIsLevelUp(species, form, move, lvl);
}
return LearnNONE;
}
private static LearnVersion GetIsLevelUp7(int species, int move, int form, GameVersion ver = Any)
{
switch (ver)
{
case Any:
if (species > MaxSpeciesID_7)
return LearnNONE;
var first = LearnSM.GetIsLevelUp(species, form, move);
if (first.IsLevelUp)
return first;
if (species > MaxSpeciesID_7_USUM)
return LearnNONE;
return LearnUSUM.GetIsLevelUp(species, form, move);
case SN: case MN: case SM:
if (species > MaxSpeciesID_7)
return LearnNONE;
return LearnSM.GetIsLevelUp(species, form, move);
case US: case UM: case USUM:
if (species > MaxSpeciesID_7_USUM)
return LearnNONE;
return LearnUSUM.GetIsLevelUp(species, form, move);
} }
return LearnNONE; return LearnNONE;
} }
@ -180,74 +208,22 @@ namespace PKHeX.Core
return new LearnVersion(lv, GetDeoxysGameVersion3(form)); return new LearnVersion(lv, GetDeoxysGameVersion3(form));
return LearnNONE; return LearnNONE;
} }
private static LearnVersion GetIsLevelUp6XY(int species, int form, int move, int lvl)
{
int index = PersonalTable.XY.GetFormeIndex(species, form);
if (index == 0)
return LearnNONE;
var lv = LevelUpXY[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.XY);
return LearnNONE;
}
private static LearnVersion GetIsLevelUp6AO(int species, int form, int move, int lvl)
{
int index = PersonalTable.AO.GetFormeIndex(species, form);
if (index == 0)
return LearnNONE;
var lv = LevelUpAO[index].GetLevelLearnMove(move);
if (lv >= 0 && lv <= lvl)
return new LearnVersion(lv, GameVersion.ORAS);
return GetIsLevelUp7SM(species, form, move);
}
private static LearnVersion GetIsLevelUp7SM(int species, int form, int move)
{
if (species > MaxSpeciesID_7)
return LearnNONE;
int index = PersonalTable.SM.GetFormeIndex(species, form);
if (index == 0)
return LearnNONE;
var lv = LevelUpSM[index].GetLevelLearnMove(move);
if (lv >= 0)
return new LearnVersion(lv, GameVersion.SM);
return LearnNONE;
}
private static LearnVersion GetIsLevelUp7USUM(int species, int form, int move)
{
if (species > MaxSpeciesID_7_USUM)
return LearnNONE;
int index = PersonalTable.USUM.GetFormeIndex(species, form);
if (index == 0)
return LearnNONE;
var lv = LevelUpUSUM[index].GetLevelLearnMove(move);
if (lv >= 0)
return new LearnVersion(lv, GameVersion.USUM);
return GetIsLevelUp7SM(species, form, move);
}
private static GameVersion GetDeoxysGameVersion3(int form) private static GameVersion GetDeoxysGameVersion3(int form)
{ {
switch (form) switch (form)
{ {
case 0: return GameVersion.RS; case 0: return RS;
case 1: return GameVersion.FR; case 1: return FR;
case 2: return GameVersion.LG; case 2: return LG;
case 3: return GameVersion.E; case 3: return E;
default: default:
return GameVersion.Invalid; return Invalid;
} }
} }
private static Learnset GetDeoxysLearn3(int form, GameVersion ver = GameVersion.Any) private static Learnset GetDeoxysLearn3(int form, GameVersion ver = Any)
{ {
if (ver == GameVersion.Any) if (ver == Any)
switch (form) switch (form)
{ {
case 0: return LevelUpRS[386]; // Normal case 0: return LevelUpRS[386]; // Normal
@ -277,7 +253,7 @@ namespace PKHeX.Core
return null; return null;
} }
internal static List<int> GetMovesLevelUp1(int species, int max, int min, GameVersion ver = GameVersion.Any) internal static List<int> GetMovesLevelUp1(int species, int max, int min, GameVersion ver = Any)
{ {
var moves = new List<int>(); var moves = new List<int>();
int index = PersonalTable.RB.GetFormeIndex(species, 0); int index = PersonalTable.RB.GetFormeIndex(species, 0);
@ -286,15 +262,15 @@ namespace PKHeX.Core
switch (ver) switch (ver)
{ {
case GameVersion.Any: case GameVersion.RBY: case Any: case RBY:
AddMovesLevelUp1RBG(moves, max, min, index); AddMovesLevelUp1RBG(moves, max, min, index);
AddMovesLevelUp1Y(moves, max, min, index); AddMovesLevelUp1Y(moves, max, min, index);
return moves; return moves;
case GameVersion.RB: case RB:
case GameVersion.RD: case GameVersion.BU: case GameVersion.GN: case RD: case BU: case GN:
AddMovesLevelUp1RBG(moves, max, min, index); AddMovesLevelUp1RBG(moves, max, min, index);
return moves; return moves;
case GameVersion.Y: case YW:
AddMovesLevelUp1Y(moves, max, min, index); AddMovesLevelUp1Y(moves, max, min, index);
return moves; return moves;
} }
@ -366,18 +342,14 @@ namespace PKHeX.Core
var moves = new List<int>(); var moves = new List<int>();
switch (ver) switch (ver)
{ {
case GameVersion.Any: case Any:
AddMovesLevelUp6XY(moves, species, lvl, form); AddMovesLevelUp6XY(moves, species, lvl, form);
AddMovesLevelUp6AO(moves, species, lvl, form); AddMovesLevelUp6AO(moves, species, lvl, form);
break; break;
case GameVersion.X: case X: case Y: case XY:
case GameVersion.Y:
case GameVersion.XY:
AddMovesLevelUp6XY(moves, species, lvl, form); AddMovesLevelUp6XY(moves, species, lvl, form);
break; break;
case GameVersion.AS: case AS: case OR: case ORAS:
case GameVersion.OR:
case GameVersion.ORAS:
AddMovesLevelUp6AO(moves, species, lvl, form); AddMovesLevelUp6AO(moves, species, lvl, form);
break; break;
} }
@ -416,18 +388,14 @@ namespace PKHeX.Core
var moves = new List<int>(); var moves = new List<int>();
switch (ver) switch (ver)
{ {
case GameVersion.Any: case Any:
AddMovesLevelUp7SM(moves, species, lvl, form, MoveReminder); AddMovesLevelUp7SM(moves, species, lvl, form, MoveReminder);
AddMovesLevelUp7USUM(moves, species, lvl, form, MoveReminder); AddMovesLevelUp7USUM(moves, species, lvl, form, MoveReminder);
break; break;
case GameVersion.SN: case SN: case MN: case SM:
case GameVersion.MN:
case GameVersion.SM:
AddMovesLevelUp7SM(moves, species, lvl, form, MoveReminder); AddMovesLevelUp7SM(moves, species, lvl, form, MoveReminder);
break; break;
case GameVersion.US: case US: case UM: case USUM:
case GameVersion.UM:
case GameVersion.USUM:
AddMovesLevelUp7USUM(moves, species, lvl, form, MoveReminder); AddMovesLevelUp7USUM(moves, species, lvl, form, MoveReminder);
break; break;
} }
@ -456,7 +424,7 @@ namespace PKHeX.Core
public static int[] GetEncounterMoves(PKM pk, int level, GameVersion version) public static int[] GetEncounterMoves(PKM pk, int level, GameVersion version)
{ {
if (GameVersion.RBY.Contains(version)) if (RBY.Contains(version))
return GetEncounterMoves1(pk.Species, level, version); return GetEncounterMoves1(pk.Species, level, version);
return GetEncounterMoves(pk.Species, pk.AltForm, level, version); return GetEncounterMoves(pk.Species, pk.AltForm, level, version);
} }