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 ;
2022-05-31 04:43:52 +00:00
using static PKHeX . Core . EntityContext ;
namespace PKHeX.Core ;
/// <summary>
/// "Context" is an existence island; data format restricts the types of changes that can be made (such as evolving).
/// </summary>
/// <remarks>
/// Starting in the 8th generation games, entities can move between games with wildly different evolution rules.
/// Previous implementations of a "Format Generation" were unable to differentiate if a class object was present in one of these different-rule contexts.
/// The "Format Generation" is still a useful generalization to check if certain fields are present in the entity data, or if certain mutations are possible.
/// </remarks>
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
public enum EntityContext : byte
2022-05-31 04:43:52 +00:00
{
2022-06-08 06:32:57 +00:00
None = 0 ,
2022-05-31 04:43:52 +00:00
Gen1 = 1 ,
Gen2 = 2 ,
Gen3 = 3 ,
Gen4 = 4 ,
Gen5 = 5 ,
Gen6 = 6 ,
Gen7 = 7 ,
Gen8 = 8 ,
2022-11-25 01:42:17 +00:00
Gen9 = 9 ,
2022-05-31 04:43:52 +00:00
SplitInvalid ,
Gen7b ,
Gen8a ,
Gen8b ,
2022-06-08 06:32:57 +00:00
MaxInvalid ,
2022-05-31 04:43:52 +00:00
}
public static class EntityContextExtensions
{
public static int Generation ( this EntityContext value ) = > value < SplitInvalid ? ( int ) value : value switch
{
Gen7b = > 7 ,
Gen8a = > 8 ,
Gen8b = > 8 ,
_ = > throw new ArgumentOutOfRangeException ( nameof ( value ) , value , null ) ,
} ;
2022-06-08 06:32:57 +00:00
public static bool IsValid ( this EntityContext value ) = > value is not ( 0 or SplitInvalid ) and < MaxInvalid ;
2022-05-31 04:43:52 +00:00
public static GameVersion GetSingleGameVersion ( this EntityContext value ) = > value switch
{
Gen1 = > GameVersion . RD ,
Gen2 = > GameVersion . C ,
Gen3 = > GameVersion . E ,
Gen4 = > GameVersion . SS ,
Gen5 = > GameVersion . W2 ,
Gen6 = > GameVersion . AS ,
Gen7 = > GameVersion . UM ,
Gen8 = > GameVersion . SH ,
2022-11-27 19:22:53 +00:00
Gen9 = > GameVersion . VL ,
2022-05-31 04:43:52 +00:00
Gen7b = > GameVersion . GP ,
Gen8a = > GameVersion . PLA ,
Gen8b = > GameVersion . BD ,
_ = > throw new ArgumentOutOfRangeException ( nameof ( value ) , value , null ) ,
} ;
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
public static EntityContext GetContext ( this GameVersion version ) = > version switch
{
GameVersion . GP or GameVersion . GE = > Gen7b ,
GameVersion . PLA = > Gen8a ,
GameVersion . BD or GameVersion . SP = > Gen8b ,
_ = > ( EntityContext ) version . GetGeneration ( ) ,
} ;
2022-05-31 04:43:52 +00:00
}