Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-11-27 06:20:25 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/Legality/Restrictions/EvolutionRestrictions.cs

221 lines
9.8 KiB
C#
Raw Normal View History

Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
using System;
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
using System.Collections.Generic;
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
using System.Linq;
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
using static PKHeX.Core.Move;
using static PKHeX.Core.Species;
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
namespace PKHeX.Core
{
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
/// <summary>
/// Restriction logic for evolutions that are a little more complex than <see cref="EvolutionMethod"/> can simply check.
/// </summary>
/// <remarks>
/// Currently only checks "is able to know a move required to level up".
/// </remarks>
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
internal static class EvolutionRestrictions
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
/// <summary>
/// List of species that evolve from a previous species having a move while leveling up
/// </summary>
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
private static readonly Dictionary<int, MoveEvolution> SpeciesEvolutionWithMove = new()
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
{(int)Eevee, new(0, 0)}, // FairyMoves
{(int)MimeJr, new(1, (int)Mimic)},
{(int)Bonsly, new(2, (int)Mimic)},
{(int)Aipom, new(3, (int)Mimic)},
{(int)Lickitung, new(4, (int)Rollout)},
{(int)Tangela, new(5, (int)AncientPower)},
{(int)Yanma, new(6, (int)AncientPower)},
{(int)Piloswine, new(7, (int)AncientPower)},
{(int)Steenee, new(8, (int)Stomp)},
{(int)Clobbopus, new(9, (int)Taunt)},
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
};
c#10: readonly record structs Reduces some boilerplate constructors/equality compares
2021-12-05 02:32:35 +00:00
private readonly record struct MoveEvolution(int ReferenceIndex, int Move);
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
private static readonly int[] FairyMoves =
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
(int)SweetKiss,
(int)Charm,
(int)Moonlight,
(int)DisarmingVoice,
(int)DrainingKiss,
(int)CraftyShield,
(int)FlowerShield,
(int)MistyTerrain,
(int)PlayRough,
(int)FairyWind,
(int)Moonblast,
(int)FairyLock,
(int)AromaticMist,
(int)Geomancy,
(int)DazzlingGleam,
(int)BabyDollEyes,
(int)LightofRuin,
(int)TwinkleTackleP,
(int)TwinkleTackleS,
(int)FloralHealing,
(int)GuardianofAlola,
(int)FleurCannon,
(int)NaturesMadness,
(int)LetsSnuggleForever,
(int)SparklySwirl,
(int)MaxStarfall,
(int)Decorate,
(int)SpiritBreak,
(int)StrangeSteam,
(int)MistyExplosion,
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
};
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
/// <summary>
/// Minimum current level for a given species to have learned the evolve-move and be successfully evolved.
/// </summary>
/// <remarks>Having a value of 0 means the move can't be learned.</remarks>
Fix gen8 move threshold evo checks gen7 allows all moves to be reminded; gen8 reverted that. add greedy minlevel return, and reduce array size allocation by 270 bytes
2021-05-16 07:00:29 +00:00
private static readonly byte[][] MinLevelEvolutionWithMove =
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Fix gen8 move threshold evo checks gen7 allows all moves to be reminded; gen8 reverted that. add greedy minlevel return, and reduce array size allocation by 270 bytes
2021-05-16 07:00:29 +00:00
new byte[] { 00, 00, 00, 00, 00, 29, 09, 02, 02 }, // Sylveon (Eevee with Fairy Move)
new byte[] { 00, 00, 00, 00, 18, 15, 15, 02, 32 }, // Mr. Mime (Mime Jr with Mimic)
new byte[] { 00, 00, 00, 00, 17, 17, 15, 02, 16 }, // Sudowoodo (Bonsly with Mimic)
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
new byte[] { 00, 00, 00, 00, 32, 32, 32, 02, 32 }, // Ambipom (Aipom with Double Hit)
Fix gen8 move threshold evo checks gen7 allows all moves to be reminded; gen8 reverted that. add greedy minlevel return, and reduce array size allocation by 270 bytes
2021-05-16 07:00:29 +00:00
new byte[] { 00, 00, 02, 00, 02, 33, 33, 02, 06 }, // Lickilicky (Lickitung with Rollout)
new byte[] { 00, 00, 00, 00, 02, 36, 38, 02, 24 }, // Tangrowth (Tangela with Ancient Power)
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
new byte[] { 00, 00, 00, 00, 02, 33, 33, 02, 33 }, // Yanmega (Yanma with Ancient Power)
Fix gen8 move threshold evo checks gen7 allows all moves to be reminded; gen8 reverted that. add greedy minlevel return, and reduce array size allocation by 270 bytes
2021-05-16 07:00:29 +00:00
new byte[] { 00, 00, 00, 00, 02, 02, 02, 02, 02 }, // Mamoswine (Piloswine with Ancient Power)
new byte[] { 00, 00, 00, 00, 00, 00, 00, 02, 28 }, // Tsareena (Steenee with Stomp)
new byte[] { 00, 00, 00, 00, 00, 00, 00, 00, 35 }, // Grapploct (Clobbopus with Taunt)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
};
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
private static readonly bool[][] CanEggHatchWithEvolveMove =
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
new [] { false, false, true, true, true, true, true, true, true }, // Sylveon (Eevee with Fairy Move)
Minor clean Use some enums, save a few virtual/static fetches
2021-01-16 20:01:40 +00:00
new [] { false, false, false, false, true, true, true, true, true }, // Mr. Mime (Mime Jr with Mimic)
new [] { false, false, false, false, true, true, true, true, true }, // Sudowoodo (Bonsly with Mimic)
new [] { false, false, false, false, true, true, true, true, true }, // Ambipom (Aipom with Double Hit)
new [] { false, false, true, false, true, true, true, true, true }, // Lickilicky (Lickitung with Rollout)
new [] { false, false, false, false, true, true, true, true, true }, // Tangrowth (Tangela with Ancient Power)
new [] { false, false, false, false, true, true, true, true, true }, // Yanmega (Yanma with Ancient Power)
new [] { false, false, true, true, true, true, true, true, true }, // Mamoswine (Piloswine with Ancient Power)
new [] { false, false, false, false, false, false, false, false, false }, // Tsareena (Steenee with Stomp)
new [] { false, false, false, false, false, false, false, false, true }, // Grapploct (Clobbopus with Taunt)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
};
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
/// <summary>
/// Checks if the <see cref="pkm"/> is correctly evolved, assuming it had a known move requirement evolution in its evolution chain.
/// </summary>
/// <returns>True if unnecessary to check or the evolution was valid.</returns>
public static bool IsValidEvolutionWithMove(PKM pkm, LegalInfo info)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
// Known-move evolutions were introduced in Gen4.
if (pkm.Format < 4) // doesn't exist yet!
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
return true;
Update EvolutionRestrictions.cs
2021-05-16 18:12:16 +00:00
// OK if un-evolved from original encounter
int species = pkm.Species;
if (info.EncounterMatch.Species == species)
return true;
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
// Exclude evolution paths that did not require a move w/level-up evolution
var enc = info.EncounterOriginal;
if (!SpeciesEvolutionWithMove.TryGetValue(enc.Species, out var entry))
return true;
var move = entry.Move;
if (move == 0)
{
// Other evolutions are fine.
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
if (pkm.Species != (int)Sylveon)
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
return true;
}
// Check if the move was already known when it was originally encountered.
var gen = info.Generation;
var index = entry.ReferenceIndex;
if (enc is EncounterEgg)
{
if (CanEggHatchWithEvolveMove[index][gen])
{
var result = move == 0 ? IsMoveInherited(pkm, info, FairyMoves) : IsMoveInherited(pkm, info, move);
if (result)
return true;
}
}
else if (enc is IMoveset s)
{
var result = move == 0 ? s.Moves.Any(FairyMoves.Contains) : s.Moves.Contains(move);
if (result)
return true;
}
// Current level must be at least the minimum post-evolution level.
var lvl = GetMinLevelKnowRequiredMove(pkm, gen, index);
return pkm.CurrentLevel >= lvl;
}
private static int GetMinLevelKnowRequiredMove(PKM pkm, int gen, int index)
{
var lvl = GetLevelLearnMove(pkm, gen, index);
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
// If has original met location the minimum evolution level is one level after met level
// Gen 3 pokemon in gen 4 games: minimum level is one level after transfer to generation 4
// VC pokemon: minimum level is one level after transfer to generation 7
// Sylveon: always one level after met level, for gen 4 and 5 eevees in gen 6 games minimum for evolution is one level after transfer to generation 5
Minor tweaks no functional change, readability++ add more xmldoc
2021-06-03 19:04:19 +00:00
if (pkm.HasOriginalMetLocation || (pkm.Format == 4 && gen == 3) || pkm.VC || pkm.Species == (int)Sylveon)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
lvl = Math.Max(pkm.Met_Level + 1, lvl);
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
return lvl;
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
}
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
private static int GetLevelLearnMove(PKM pkm, int gen, int index)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
// Get the minimum level in any generation when the pokemon could learn the evolve move
var levels = MinLevelEvolutionWithMove[index];
var lvl = 101;
Fix gen8 move threshold evo checks gen7 allows all moves to be reminded; gen8 reverted that. add greedy minlevel return, and reduce array size allocation by 270 bytes
2021-05-16 07:00:29 +00:00
var end = pkm.Format;
for (int g = gen; g <= end; g++)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
Fix gen8 move threshold evo checks gen7 allows all moves to be reminded; gen8 reverted that. add greedy minlevel return, and reduce array size allocation by 270 bytes
2021-05-16 07:00:29 +00:00
var l = levels[g];
if (l == 0)
continue;
if (l == 2)
return 2; // true minimum
if (l < lvl)
lvl = l; // best minimum
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
}
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
return lvl;
}
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
private static bool IsMoveInherited(PKM pkm, LegalInfo info, int move)
{
// In 3DS games, the inherited move must be in the relearn moves.
if (info.Generation >= 6)
return pkm.RelearnMoves.Contains(move);
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
// In Pre-3DS games, the move is inherited if it has the move and it can be hatched with the move.
if (pkm.HasMove(move))
return true;
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
return DidLearnAndForget(info);
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
}
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
private static bool IsMoveInherited(PKM pkm, LegalInfo info, int[] moves)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
{
// In 3DS games, the inherited move must be in the relearn moves.
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
if (info.Generation >= 6)
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
return pkm.RelearnMoves.Any(moves.Contains);
// In Pre-3DS games, the move is inherited if it has the move and it can be hatched with the move.
if (pkm.Moves.Any(moves.Contains))
return true;
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
return DidLearnAndForget(info);
}
private static bool DidLearnAndForget(LegalInfo info)
{
// If the pokemon does not currently have the move, it could have been an egg move that was forgotten.
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
// This requires the pokemon to not have 4 other moves identified as egg moves or inherited level up moves.
Clean up know-move-evolution checks Looks like Mr. Rime case wasn't being handled, so I rewrote it. Better performance, less complexity. No need to double-reference the moves. Cache a single Valid evolution result; every parse can reuse that object.
2021-05-16 04:41:04 +00:00
var fromEggCount = info.Moves.Count(m => m.IsEggSource);
return fromEggCount < 4;
Move some static arrays closer to where they're used Split EvolutionRestrictions to its own class Can probably refine things further to clamp down access to these arrays
2020-11-02 21:11:51 +00:00
}
}
}
Reference in a new issue Copy permalink