Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
using System;
|
2021-04-05 01:30:01 +00:00
|
|
|
using System.Runtime.CompilerServices;
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
using System.Runtime.InteropServices;
|
2021-04-05 01:30:01 +00:00
|
|
|
using static PKHeX.Core.EggSource5;
|
|
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
namespace PKHeX.Core;
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Inheritance logic for Generation 5.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>Refer to <see cref="EggSource5"/> for inheritance ordering.</remarks>
|
|
|
|
|
public static class MoveBreed5
|
2021-04-05 01:30:01 +00:00
|
|
|
{
|
2022-06-18 18:04:24 +00:00
|
|
|
private const int level = 1;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
/// <inheritdoc cref="MoveBreed.Validate"/>
|
|
|
|
|
public static bool Validate(int species, GameVersion version, ReadOnlySpan<int> moves, Span<byte> origins)
|
2022-06-18 18:04:24 +00:00
|
|
|
{
|
|
|
|
|
var count = moves.IndexOf(0);
|
|
|
|
|
if (count == 0)
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
return false;
|
2022-06-18 18:04:24 +00:00
|
|
|
if (count == -1)
|
|
|
|
|
count = moves.Length;
|
|
|
|
|
|
|
|
|
|
var learn = GameData.GetLearnsets(version);
|
|
|
|
|
var table = GameData.GetPersonal(version);
|
|
|
|
|
var learnset = learn[species];
|
|
|
|
|
var pi = table[species];
|
|
|
|
|
var egg = Legal.EggMovesBW[species].Moves;
|
|
|
|
|
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
var actual = MemoryMarshal.Cast<byte, EggSource5>(origins);
|
2022-06-18 18:04:24 +00:00
|
|
|
Span<byte> possible = stackalloc byte[count];
|
|
|
|
|
var value = new BreedInfo<EggSource5>(actual, possible, learnset, moves, level);
|
|
|
|
|
if (species is (int)Species.Pichu && moves[count - 1] is (int)Move.VoltTackle)
|
|
|
|
|
actual[--count] = VoltTackle;
|
|
|
|
|
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
bool valid;
|
2022-06-18 18:04:24 +00:00
|
|
|
if (count == 0)
|
|
|
|
|
{
|
|
|
|
|
valid = VerifyBaseMoves(value);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
bool inherit = Breeding.GetCanInheritMoves(species);
|
|
|
|
|
MarkMovesForOrigin(value, egg, count, inherit, pi);
|
|
|
|
|
valid = RecurseMovesForOrigin(value, count - 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!valid)
|
|
|
|
|
CleanResult(actual, possible);
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
return valid;
|
2022-06-18 18:04:24 +00:00
|
|
|
}
|
2021-04-05 01:30:01 +00:00
|
|
|
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
private static void CleanResult(Span<EggSource5> valueActual, Span<byte> valuePossible)
|
2022-06-18 18:04:24 +00:00
|
|
|
{
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
for (int i = 0; i < valuePossible.Length; i++)
|
2021-04-08 22:58:09 +00:00
|
|
|
{
|
2022-06-18 18:04:24 +00:00
|
|
|
var poss = valuePossible[i];
|
|
|
|
|
if (poss == 0)
|
|
|
|
|
continue;
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
if (valueActual[i] != 0)
|
|
|
|
|
continue;
|
2022-06-18 18:04:24 +00:00
|
|
|
|
|
|
|
|
for (int j = 0; j < (int)Max; j++)
|
2021-04-08 22:58:09 +00:00
|
|
|
{
|
2022-06-18 18:04:24 +00:00
|
|
|
if ((poss & (1 << j)) == 0)
|
2021-04-08 22:58:09 +00:00
|
|
|
continue;
|
2022-06-18 18:04:24 +00:00
|
|
|
valueActual[i] = (EggSource5)j;
|
|
|
|
|
break;
|
2021-04-08 22:58:09 +00:00
|
|
|
}
|
|
|
|
|
}
|
2022-06-18 18:04:24 +00:00
|
|
|
}
|
2021-04-08 22:58:09 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
private static bool RecurseMovesForOrigin(in BreedInfo<EggSource5> info, int start, EggSource5 type = Max - 1)
|
|
|
|
|
{
|
|
|
|
|
int i = start;
|
|
|
|
|
do
|
2021-04-05 01:30:01 +00:00
|
|
|
{
|
2022-06-18 18:04:24 +00:00
|
|
|
var unpeel = type - 1;
|
|
|
|
|
if (unpeel != 0 && RecurseMovesForOrigin(info, i, unpeel))
|
|
|
|
|
return true;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
var permit = info.Possible[i];
|
|
|
|
|
if ((permit & (1 << (int)type)) == 0)
|
|
|
|
|
return false;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
info.Actual[i] = type;
|
|
|
|
|
} while (--i >= 0);
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
return VerifyBaseMoves(info);
|
|
|
|
|
}
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
|
|
|
private static bool VerifyBaseMoves(in BreedInfo<EggSource5> info)
|
|
|
|
|
{
|
|
|
|
|
var count = 0;
|
|
|
|
|
foreach (var x in info.Actual)
|
2021-04-05 01:30:01 +00:00
|
|
|
{
|
2022-06-18 18:04:24 +00:00
|
|
|
if (x == Base)
|
|
|
|
|
count++;
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
var moves = info.Moves;
|
|
|
|
|
if (count == -1)
|
|
|
|
|
return moves[^1] != 0;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
var baseMoves = info.Learnset.GetBaseEggMoves(info.Level);
|
|
|
|
|
if (baseMoves.Length < count)
|
|
|
|
|
return false;
|
|
|
|
|
if (moves[^1] == 0 && count != baseMoves.Length)
|
|
|
|
|
return false;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
for (int i = count - 1, b = baseMoves.Length - 1; i >= 0; i--, b--)
|
|
|
|
|
{
|
|
|
|
|
var move = moves[i];
|
|
|
|
|
var expect = baseMoves[b];
|
|
|
|
|
if (expect != move)
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
// A low-index base egg move may be nudged out, but can only reappear if sufficient non-base moves are before it.
|
|
|
|
|
if (baseMoves.Length == count)
|
|
|
|
|
return true;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
for (int i = count; i < info.Actual.Length; i++)
|
|
|
|
|
{
|
|
|
|
|
var isBase = (info.Possible[i] & (1 << (int)Base)) != 0;
|
|
|
|
|
if (!isBase)
|
|
|
|
|
continue;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
var baseIndex = baseMoves.IndexOf(moves[i]);
|
|
|
|
|
var min = moves.Length - baseMoves.Length + baseIndex;
|
|
|
|
|
if (i < min + count)
|
|
|
|
|
return false;
|
2021-04-05 01:30:01 +00:00
|
|
|
}
|
|
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
private static void MarkMovesForOrigin(in BreedInfo<EggSource5> value, ReadOnlySpan<int> eggMoves, int count, bool inheritLevelUp, PersonalInfo info)
|
2022-06-18 18:04:24 +00:00
|
|
|
{
|
|
|
|
|
var possible = value.Possible;
|
|
|
|
|
var learn = value.Learnset;
|
|
|
|
|
var baseEgg = value.Learnset.GetBaseEggMoves(value.Level);
|
|
|
|
|
var tm = info.TMHM;
|
Refactoring: Move Source (Legality) (#3560)
Rewrites a good amount of legality APIs pertaining to:
* Legal moves that can be learned
* Evolution chains & cross-generation paths
* Memory validation with forgotten moves
In generation 8, there are 3 separate contexts an entity can exist in: SW/SH, BD/SP, and LA. Not every entity can cross between them, and not every entity from generation 7 can exist in generation 8 (Gogoat, etc). By creating class models representing the restrictions to cross each boundary, we are able to better track and validate data.
The old implementation of validating moves was greedy: it would iterate for all generations and evolutions, and build a full list of every move that can be learned, storing it on the heap. Now, we check one game group at a time to see if the entity can learn a move that hasn't yet been validated. End result is an algorithm that requires 0 allocation, and a smaller/quicker search space.
The old implementation of storing move parses was inefficient; for each move that was parsed, a new object is created and adjusted depending on the parse. Now, move parse results are `struct` and store the move parse contiguously in memory. End result is faster parsing and 0 memory allocation.
* `PersonalTable` objects have been improved with new API methods to check if a species+form can exist in the game.
* `IEncounterTemplate` objects have been improved to indicate the `EntityContext` they originate in (similar to `Generation`).
* Some APIs have been extended to accept `Span<T>` instead of Array/IEnumerable
2022-08-03 23:15:27 +00:00
|
|
|
var tmlist = LearnSource5.TMHM_BW.AsSpan(0, 95); // actually 96, but TM96 is unavailable (Snarl - Lock Capsule)
|
2022-06-18 18:04:24 +00:00
|
|
|
|
|
|
|
|
var moves = value.Moves;
|
|
|
|
|
for (int i = 0; i < count; i++)
|
2021-04-05 01:30:01 +00:00
|
|
|
{
|
2022-06-18 18:04:24 +00:00
|
|
|
var move = moves[i];
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
if (baseEgg.IndexOf(move) != -1)
|
|
|
|
|
possible[i] |= 1 << (int)Base;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
if (inheritLevelUp && learn.GetLevelLearnMove(move) != -1)
|
|
|
|
|
possible[i] |= 1 << (int)ParentLevelUp;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
if (eggMoves.Contains(move))
|
|
|
|
|
possible[i] |= 1 << (int)FatherEgg;
|
2021-04-05 01:30:01 +00:00
|
|
|
|
2022-06-18 18:04:24 +00:00
|
|
|
var tmIndex = tmlist.IndexOf(move);
|
|
|
|
|
if (tmIndex != -1 && tm[tmIndex])
|
|
|
|
|
possible[i] |= 1 << (int)FatherTM;
|
2021-04-05 01:30:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|