Mirrors/PKHeX
2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-11-16 09:08:02 +00:00
Code Issues Projects Releases Packages Wiki Activity
PKHeX/PKHeX.Core/Legality/Encounters/EncounterGenerator.cs

1626 lines
66 KiB
C#
Raw Normal View History

Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using static PKHeX.Core.Legal;
namespace PKHeX.Core
{
misc tweaks no functional changes
2017-09-20 06:19:22 +00:00
/// <summary>
/// Generates matching <see cref="IEncounterable"/> data and relevant <see cref="LegalInfo"/> for a <see cref="PKM"/>.
/// Logic for generating possible in-game encounter data.
/// </summary>
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
public static class EncounterGenerator
{
misc tweaks no functional changes
2017-09-20 06:19:22 +00:00
/// <summary>
/// Generates possible <see cref="IEncounterable"/> data according to the input PKM data and legality info.
/// </summary>
/// <param name="pkm">PKM data</param>
/// <param name="info">Legality information</param>
/// <returns>Possible encounters</returns>
/// <remarks>
/// The iterator lazily finds possible encounters. If no encounters are possible, the enumerable will be empty.
/// </remarks>
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
public static IEnumerable<IEncounterable> GetEncounters(PKM pkm, LegalInfo info)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
switch (info.Generation)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
case 1:
case 2:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var enc in GetEncounters12(pkm, info))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return enc;
yield break;
case 3:
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
// info.PIDIV = MethodFinder.Analyze(pkm);
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var enc in GetEncounters3(pkm, info))
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
yield return enc;
yield break;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 4:
// info.PIDIV = MethodFinder.Analyze(pkm);
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var enc in GetEncounters4(pkm, info))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return enc;
yield break;
default:
foreach (var enc in GenerateRawEncounters(pkm))
yield return enc;
yield break;
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<IEncounterable> GetEncounters12(PKM pkm, LegalInfo info)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
int baseSpecies = GetBaseSpecies(pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
bool g1 = pkm.VC1 || pkm.Format == 1;
if (g1 && baseSpecies > MaxSpeciesID_1 || baseSpecies > MaxSpeciesID_2)
yield break;
foreach (var z in GenerateFilteredEncounters(pkm))
Misc fixes Track gen1/2 origin game as well as generation fix pk2 gender setting (incorrect bitmask & wasn't set from tabs) extend female gender check for gen2 to apply to GS encounters -- if met location is missing, was traded to gen1 which clears gender.
2017-05-28 23:56:51 +00:00
{
info.Generation = z.Generation;
info.Game = z.Game;
yield return z.Encounter;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<IEncounterable> GetEncounters3(PKM pkm, LegalInfo info)
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
info.PIDIV = MethodFinder.Analyze(pkm);
var deferred = new List<IEncounterable>();
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
foreach (var z in GenerateRawEncounters3(pkm, info))
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{
Misc cleanup Add PCD fixed PID check improve PID matching for CXD pkm hide no-pidiv match seed (00000000) fix matching fateful for wild pokespot pkm don't generate eggs for c/xd
2017-06-03 22:16:24 +00:00
if (z is EncounterSlot w && pkm.Version == 15)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
info.PIDIV = MethodFinder.GetPokeSpotSeeds(pkm, w.SlotNumber).FirstOrDefault() ?? info.PIDIV;
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
if (info.PIDIV.Type.IsCompatible3(z, pkm))
yield return z;
else
deferred.Add(z);
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
}
Add no-deferred early break for gen3 c627a86f said it added for both 3 & 4, but was only added for gen4.
2017-09-10 02:27:28 +00:00
if (deferred.Count == 0)
yield break;
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
info.PIDIVMatches = false;
foreach (var z in deferred)
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<IEncounterable> GetEncounters4(PKM pkm, LegalInfo info)
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
info.PIDIV = MethodFinder.Analyze(pkm);
Add RANDY Gen2 ingame trade closes #1538 rename pid deferral to pidiv deferral for clarity
2017-10-22 17:41:27 +00:00
var deferredPIDIV = new List<IEncounterable>();
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
var deferredEType = new List<IEncounterable>();
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
foreach (var z in GenerateRawEncounters4(pkm, info))
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
if (!info.PIDIV.Type.IsCompatible4(z, pkm))
Add RANDY Gen2 ingame trade closes #1538 rename pid deferral to pidiv deferral for clarity
2017-10-22 17:41:27 +00:00
deferredPIDIV.Add(z);
Fix gen4-6 gen4 origin encounter type defer check only check etype if appropriate (not gen7+)
2017-11-25 17:48:49 +00:00
else if (pkm.Format <= 6 && !IsEncounterTypeMatch(z, pkm.EncounterType))
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
deferredEType.Add(z);
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
else
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
}
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
foreach (var z in deferredEType)
yield return z;
Add RANDY Gen2 ingame trade closes #1538 rename pid deferral to pidiv deferral for clarity
2017-10-22 17:41:27 +00:00
if (deferredPIDIV.Count == 0)
Fix g4 move tutor lookup personalinfo setup wasn't populating info for form indexes remove erroneous pid-type mismatch message on gen3/4 non-matching if there are no deferred encounters
2017-08-27 18:04:31 +00:00
yield break;
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
info.PIDIVMatches = false;
Add RANDY Gen2 ingame trade closes #1538 rename pid deferral to pidiv deferral for clarity
2017-10-22 17:41:27 +00:00
foreach (var z in deferredPIDIV)
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
private static IEnumerable<GBEncounterData> GenerateRawEncounters12(PKM pkm, GameVersion game)
{
Fix gsc pre-evo species chain filtering simplify gsc check to do only once https://projectpokemon.org/home/forums/topic/43278-gen-2-hitmonlee-and-hitmonchan-flagged-as-illegal-if-location-is-mt-mortar-at-level-10/
2018-01-01 21:53:28 +00:00
bool gsc = GameVersion.GSC.Contains(game);
var gen = gsc ? 2 : 1;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
// Since encounter matching is super weak due to limited stored data in the structure
// Calculate all 3 at the same time and pick the best result (by species).
// Favor special event move gifts as Static Encounters when applicable
Fix gsc pre-evo species chain filtering simplify gsc check to do only once https://projectpokemon.org/home/forums/topic/43278-gen-2-hitmonlee-and-hitmonchan-flagged-as-illegal-if-location-is-mt-mortar-at-level-10/
2018-01-01 21:53:28 +00:00
var maxspeciesorigin = gsc ? MaxSpeciesID_2 : MaxSpeciesID_1;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
DexLevel[] vs = GetValidPreEvolutions(pkm, maxspeciesorigin: maxspeciesorigin).ToArray();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
HashSet<int> species = new HashSet<int>(vs.Select(p => p.Species).ToList());
var deferred = new List<IEncounterable>();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var t in GetValidEncounterTrades(pkm, game))
Change gen1/2 encounter preference Previous approach was 'most likely to find valid', this approach is a little greedier to try to find a more fitting match. Will result in a small increase in computation time, but trying out EncounterTrades and static encounters first is preferred. Fix Rhydon ingame trade gender. Bulbapedia is wrong, that's a Male Rhydon with those IVs.
2017-06-13 04:05:04 +00:00
{
Defer gen1/2 trades to end like prior commit, OT checks Closes #1391
2017-08-11 06:23:02 +00:00
if (pkm.Format >= 7)
{
deferred.Add(t);
continue;
}
Fix generation 1/2 encounters for pokemon with different initial moves in yellow/crystal than r/b/g/s The encounter generator was returning always RBY and GSC and that make the ParseMovesGenGB to check only for rb and gs learnset for initial moves, the game returned should be the game for the encounter to make ParseMovesGenGB use the correct learnset table for the initial moves Closes #1417
2017-08-25 14:25:59 +00:00
yield return new GBEncounterData(pkm, gen, t, t.Version);
Change gen1/2 encounter preference Previous approach was 'most likely to find valid', this approach is a little greedier to try to find a more fitting match. Will result in a small increase in computation time, but trying out EncounterTrades and static encounters first is preferred. Fix Rhydon ingame trade gender. Bulbapedia is wrong, that's a Male Rhydon with those IVs.
2017-06-13 04:05:04 +00:00
}
Defer gen2 fixed OT / special events Toss them to the end of the enumerable as OT checks aren't done in the generator/finder Closes #1392
2017-08-11 06:20:03 +00:00
foreach (var s in GetValidStaticEncounter(pkm, game).Where(z => species.Contains(z.Species)))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
// Valid stadium and non-stadium encounters, return only non-stadium encounters, they are less restrictive
Defer gen2 fixed OT / special events Toss them to the end of the enumerable as OT checks aren't done in the generator/finder Closes #1392
2017-08-11 06:20:03 +00:00
if (s.Version == GameVersion.Stadium || s.Version == GameVersion.Stadium2)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
deferred.Add(s);
continue;
}
Add gen2 japanese eggs Closes #1348
2017-08-06 03:25:20 +00:00
if (s.Version == GameVersion.EventsGBGen2 && s.Species != 251)
{
// no Gen2 events outside of Japan besides Celebi
Misc cleanup check gen2 stadium names, use pkm.Japanese when favorable
2017-10-25 01:27:40 +00:00
if (pkm.Japanese)
Defer gen2 fixed OT / special events Toss them to the end of the enumerable as OT checks aren't done in the generator/finder Closes #1392
2017-08-11 06:20:03 +00:00
deferred.Add(s);
continue;
Add gen2 japanese eggs Closes #1348
2017-08-06 03:25:20 +00:00
}
Fix gsc pre-evo species chain filtering simplify gsc check to do only once https://projectpokemon.org/home/forums/topic/43278-gen-2-hitmonlee-and-hitmonchan-flagged-as-illegal-if-location-is-mt-mortar-at-level-10/
2018-01-01 21:53:28 +00:00
if (gsc && !s.EggEncounter && s.Version == GameVersion.C && !pkm.HasOriginalMetLocation)
Filter crystal statics in matching, not table fetch Eggs from crystal traded to GS can hatch with no met location; skip crystal-only encounters unless they are non-eggs Closes #1245
2017-06-18 23:40:23 +00:00
continue;
Fix generation 1/2 encounters for pokemon with different initial moves in yellow/crystal than r/b/g/s The encounter generator was returning always RBY and GSC and that make the ParseMovesGenGB to check only for rb and gs learnset for initial moves, the game returned should be the game for the encounter to make ParseMovesGenGB use the correct learnset table for the initial moves Closes #1417
2017-08-25 14:25:59 +00:00
yield return new GBEncounterData(pkm, gen, s, s.Version);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Fix generation 1/2 encounters for pokemon with different initial moves in yellow/crystal than r/b/g/s The encounter generator was returning always RBY and GSC and that make the ParseMovesGenGB to check only for rb and gs learnset for initial moves, the game returned should be the game for the encounter to make ParseMovesGenGB use the correct learnset table for the initial moves Closes #1417
2017-08-25 14:25:59 +00:00
foreach (var e in GetValidWildEncounters(pkm, game).OfType<EncounterSlot1>())
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (!species.Contains(e.Species))
continue;
Fix generation 1/2 encounters for pokemon with different initial moves in yellow/crystal than r/b/g/s The encounter generator was returning always RBY and GSC and that make the ParseMovesGenGB to check only for rb and gs learnset for initial moves, the game returned should be the game for the encounter to make ParseMovesGenGB use the correct learnset table for the initial moves Closes #1417
2017-08-25 14:25:59 +00:00
yield return new GBEncounterData(pkm, gen, e, e.Version);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Fix gsc pre-evo species chain filtering simplify gsc check to do only once https://projectpokemon.org/home/forums/topic/43278-gen-2-hitmonlee-and-hitmonchan-flagged-as-illegal-if-location-is-mt-mortar-at-level-10/
2018-01-01 21:53:28 +00:00
if (gsc)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
bool WasEgg = !pkm.Gen1_NotTradeback && GetWasEgg23(pkm) && !NoHatchFromEgg.Contains(pkm.Species);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (WasEgg)
{
// Further Filtering
if (pkm.Format < 3)
{
WasEgg &= pkm.Met_Location == 0 || pkm.Met_Level == 1; // 2->1->2 clears met info
WasEgg &= pkm.CurrentLevel >= 5;
}
}
if (WasEgg)
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
int eggspec = GetBaseEggSpecies(pkm);
Korean language restrictions Restriction happens because Korean can not trade with non-Korean GB era games - There is no Korean release for gen 1 pokemon, included VC - With no gen1 pokemon means any Korean gen2 is Gen2_NotTradeback, that means no gen1 origin nor moves are Legal - Crystal was never released in Korean - Pokemon Stadium 2 was never released in Korean, that means no move reminder for gen 2 korean pokemon - Generation 4 can not trade between Korean and not Korean games, but Korean games can use the palpark with any language Chinese language restrictions There is no Chinese release for gen 1 and 2 pokemon games, VC Chinese games are in Japanese
2017-09-23 18:46:10 +00:00
if (AllowGen2Crystal(pkm))
Speculation++ As if I would have insider knowledge... ┬┴┬┴┤ ͡° ͜ʖ ͡°)├┬┴┬┴ Prepping core for eventual VC2 support where Crystal data is not retrievable.
2017-06-07 04:59:29 +00:00
yield return new GBEncounterData(eggspec, GameVersion.C); // gen2 egg
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return new GBEncounterData(eggspec, GameVersion.GS); // gen2 egg
}
}
foreach (var d in deferred)
Misc fixes Track gen1/2 origin game as well as generation fix pk2 gender setting (incorrect bitmask & wasn't set from tabs) extend female gender check for gen2 to apply to GS encounters -- if met location is missing, was traded to gen1 which clears gender.
2017-05-28 23:56:51 +00:00
yield return new GBEncounterData(pkm, gen, d, game);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Misc fixes Track gen1/2 origin game as well as generation fix pk2 gender setting (incorrect bitmask & wasn't set from tabs) extend female gender check for gen2 to apply to GS encounters -- if met location is missing, was traded to gen1 which clears gender.
2017-05-28 23:56:51 +00:00
private static IEnumerable<GBEncounterData> GenerateFilteredEncounters(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Clean up vc2 legality/transfer stuff
2017-11-24 18:13:42 +00:00
bool crystal = pkm.Format == 2 && pkm.Met_Location != 0 || pkm.Format >= 7 && pkm.OT_Gender == 1;
Change gen1/2 encounter preference Previous approach was 'most likely to find valid', this approach is a little greedier to try to find a more fitting match. Will result in a small increase in computation time, but trying out EncounterTrades and static encounters first is preferred. Fix Rhydon ingame trade gender. Bulbapedia is wrong, that's a Male Rhydon with those IVs.
2017-06-13 04:05:04 +00:00
var g1i = new PeekEnumerator<GBEncounterData>(get1().GetEnumerator());
var g2i = new PeekEnumerator<GBEncounterData>(get2().GetEnumerator());
var deferred = new List<GBEncounterData>();
while (g2i.PeekIsNext() || g1i.PeekIsNext())
{
Misc refactoring no functional change
2017-10-23 06:26:37 +00:00
var move = GetPreferredGBIterator(g1i, g2i);
Change gen1/2 encounter preference Previous approach was 'most likely to find valid', this approach is a little greedier to try to find a more fitting match. Will result in a small increase in computation time, but trying out EncounterTrades and static encounters first is preferred. Fix Rhydon ingame trade gender. Bulbapedia is wrong, that's a Male Rhydon with those IVs.
2017-06-13 04:05:04 +00:00
var obj = move.Peek();
Misc refactoring no functional change
2017-10-23 06:26:37 +00:00
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
if (obj.Generation == 1 && obj.Encounter is EncounterTrade && !IsEncounterTrade1Valid(pkm))
Change gen1/2 encounter preference Previous approach was 'most likely to find valid', this approach is a little greedier to try to find a more fitting match. Will result in a small increase in computation time, but trying out EncounterTrades and static encounters first is preferred. Fix Rhydon ingame trade gender. Bulbapedia is wrong, that's a Male Rhydon with those IVs.
2017-06-13 04:05:04 +00:00
deferred.Add(obj);
else
yield return obj;
move.MoveNext();
}
foreach (var z in deferred)
yield return z;
IEnumerable<GBEncounterData> get1()
{
if (!pkm.Gen2_NotTradeback && !crystal)
foreach (var z in GenerateRawEncounters12(pkm, GameVersion.RBY))
yield return z;
}
IEnumerable<GBEncounterData> get2()
{
Clean up vc2 legality/transfer stuff
2017-11-24 18:13:42 +00:00
if (!pkm.Gen1_NotTradeback)
Change gen1/2 encounter preference Previous approach was 'most likely to find valid', this approach is a little greedier to try to find a more fitting match. Will result in a small increase in computation time, but trying out EncounterTrades and static encounters first is preferred. Fix Rhydon ingame trade gender. Bulbapedia is wrong, that's a Male Rhydon with those IVs.
2017-06-13 04:05:04 +00:00
foreach (var z in GenerateRawEncounters12(pkm, crystal ? GameVersion.C : GameVersion.GSC))
yield return z;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Misc refactoring no functional change
2017-10-23 06:26:37 +00:00
/// <summary>
/// Gets the preferred iterator from a pair of <see cref="GBEncounterData"/> iterators based on the highest value <see cref="GBEncounterData.Type"/>.
/// </summary>
/// <param name="g1i">Generation 1 Iterator</param>
/// <param name="g2i">Generation 2 Iterator</param>
/// <returns>Preferred iterator </returns>
private static PeekEnumerator<GBEncounterData> GetPreferredGBIterator(PeekEnumerator<GBEncounterData> g1i, PeekEnumerator<GBEncounterData> g2i)
{
if (!g1i.PeekIsNext())
return g2i;
if (!g2i.PeekIsNext())
return g1i;
return g1i.Peek().Type > g2i.Peek().Type ? g1i : g2i;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
private static IEnumerable<IEncounterable> GenerateRawEncounters(PKM pkm)
{
int ctr = 0;
if (pkm.WasLink)
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidLinkGifts(pkm))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{ yield return z; ++ctr; }
if (ctr != 0) yield break;
}
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
if (pkm.WasEvent || pkm.WasEventEgg)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidGifts(pkm))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{ yield return z; ++ctr; }
if (ctr != 0) yield break;
}
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
if (pkm.WasEgg)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GenerateEggs(pkm))
Prevent eggs from generating nonstatic encounters Closes #1239 indirectly; anything gen5+ which was an egg can only be Daycare or EncounterStatic
2017-06-18 02:08:40 +00:00
{ yield return z; ++ctr; }
Don't generate encounter slots for eggs Closes #1749
2018-01-07 05:51:58 +00:00
if (ctr == 0) yield break;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidStaticEncounter(pkm))
Fix eevee static encounter collision scenario eevee gen7 egg has no moves; always generate eggs first for gen4+ Closes #1179 Closes #1176 (prior commit) there's probably a better way to optimize this (don't check wild encounters if 100% sure it's an egg); best left for future optimization since it's working fine atm.
2017-05-31 01:42:50 +00:00
{ yield return z; ++ctr; }
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
if (ctr != 0) yield break;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidFriendSafari(pkm))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{ yield return z; ++ctr; }
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
if (ctr != 0) yield break;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidWildEncounters(pkm))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{ yield return z; ++ctr; }
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
if (ctr != 0) yield break;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidEncounterTrades(pkm))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{ yield return z; ++ctr; }
// if (ctr != 0) yield break;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
}
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
private static IEnumerable<IEncounterable> GenerateRawEncounters4(PKM pkm, LegalInfo info)
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{
bool wasEvent = pkm.WasEvent || pkm.WasEventEgg; // egg events?
if (wasEvent)
{
Update gen3/4 encounter generators revisit for simplification now that EncounterTrade matching is more precise (PID required to match). #1249
2017-10-25 05:25:52 +00:00
int ctr = 0;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidGifts(pkm))
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{ yield return z; ++ctr; }
if (ctr != 0) yield break;
}
if (pkm.WasEgg)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GenerateEggs(pkm))
Update gen3/4 encounter generators revisit for simplification now that EncounterTrade matching is more precise (PID required to match). #1249
2017-10-25 05:25:52 +00:00
yield return z;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
foreach (var z in GetValidEncounterTrades(pkm))
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
var deferred = new LinkedList<IEncounterable>();
bool sport = pkm.Ball == 0x18; // never static encounters (conflict with non bcc / bcc)
bool safari = pkm.Ball == 0x05; // never static encounters
bool safariSport = safari || sport;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
if (!safariSport)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidStaticEncounter(pkm))
Misc fixes static-wild encounter g4 collision (abra gift), closes #1390 off by one pokepuff strings unshuffle bk4 ribbons pgt bad sanity events now auto-sanitized
2017-08-11 03:51:21 +00:00
{
if (z.Gift && pkm.Ball != 4)
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
deferred.AddLast(z);
Misc fixes static-wild encounter g4 collision (abra gift), closes #1390 off by one pokepuff strings unshuffle bk4 ribbons pgt bad sanity events now auto-sanitized
2017-08-11 03:51:21 +00:00
else
Update gen3/4 encounter generators revisit for simplification now that EncounterTrade matching is more precise (PID required to match). #1249
2017-10-25 05:25:52 +00:00
yield return z;
Misc fixes static-wild encounter g4 collision (abra gift), closes #1390 off by one pokepuff strings unshuffle bk4 ribbons pgt bad sanity events now auto-sanitized
2017-08-11 03:51:21 +00:00
}
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
var slots = FrameFinder.GetFrames(info.PIDIV, pkm).ToList();
Update gen3/4 encounter generators revisit for simplification now that EncounterTrade matching is more precise (PID required to match). #1249
2017-10-25 05:25:52 +00:00
foreach (var z in GetValidWildEncounters(pkm))
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
{
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
if (sport != z.Type.HasFlag(SlotType.BugContest))
{
deferred.AddLast(z);
continue;
}
Add slot level / IsEncounterable beginnings dynamic level -> calc level no sweet scent -> proc available (rock smash/fish) change frame checking in encountergenerator to save which frame it was found on (unused but possibly later can capture this for output)
2017-11-30 05:31:52 +00:00
var frame = slots.FirstOrDefault(s => s.IsSlotCompatibile(z, pkm));
Add bypass for gen4 unown meh
2017-12-03 03:54:50 +00:00
if (frame != null || pkm.Species == 201) // Unown -- don't really care to figure this out
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
yield return z;
Add Frame mismatch illegal message handling encounter will no longer be ignored as valid, will instead show the RNG frame mismatch message.
2017-11-29 05:30:53 +00:00
else
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
deferred.AddFirst(z);
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
}
Add Frame mismatch illegal message handling encounter will no longer be ignored as valid, will instead show the RNG frame mismatch message.
2017-11-29 05:30:53 +00:00
info.FrameMatches = false;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
foreach (var z in deferred)
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
// do static encounters if they were deferred to end, spit out any possible encounters for invalid pkm
if (safariSport)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidStaticEncounter(pkm))
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
yield return z;
}
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
private static IEnumerable<IEncounterable> GenerateRawEncounters3(PKM pkm, LegalInfo info)
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidGifts(pkm))
Add PIDIV checking for encounters Fixes HGSS egg moves, and improves encounter detail detection. example: togepi from FRLG transferred up, old detection couldn't differentiate the gift egg from a regular egg; however, PIDIVs can lend a hand -- eggs don't have a PIDIV! fixed shiny BACD spread detection (in regards to antishiny rerolls). Shiny WISHMKR now detected correctly.
2017-06-03 07:12:05 +00:00
yield return z;
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
foreach (var z in GetValidEncounterTrades(pkm))
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
var deferred = new Queue<IEncounterable>();
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
bool safari = pkm.Ball == 0x05; // never static encounters
if (!safari)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidStaticEncounter(pkm))
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
{
if (z.Gift && pkm.Ball != 4)
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
deferred.Enqueue(z);
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
else
yield return z;
}
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
var slots = FrameFinder.GetFrames(info.PIDIV, pkm).ToList();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidWildEncounters(pkm))
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
{
Add slot level / IsEncounterable beginnings dynamic level -> calc level no sweet scent -> proc available (rock smash/fish) change frame checking in encountergenerator to save which frame it was found on (unused but possibly later can capture this for output)
2017-11-30 05:31:52 +00:00
var frame = slots.FirstOrDefault(s => s.IsSlotCompatibile(z, pkm));
if (frame != null)
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
yield return z;
Add Frame mismatch illegal message handling encounter will no longer be ignored as valid, will instead show the RNG frame mismatch message.
2017-11-29 05:30:53 +00:00
else
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
deferred.Enqueue(z);
Add encounter slot checking emerald silly stuff like magnet pull not implemented so some stuff may be not matched.
2017-11-25 21:53:39 +00:00
}
Add Frame mismatch illegal message handling encounter will no longer be ignored as valid, will instead show the RNG frame mismatch message.
2017-11-29 05:30:53 +00:00
info.FrameMatches = false;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
Update gen3/4 encounter generators revisit for simplification now that EncounterTrade matching is more precise (PID required to match). #1249
2017-10-25 05:25:52 +00:00
if (pkm.Version != 15) // no eggs in C/XD
foreach (var z in GenerateEggs(pkm))
yield return z;
Misc fixes #1700 dp personal: add wormadam/deoxys manual forme count values generator: bcc handling for pkm present in & out of bcc, and static/wild duplicates util: fix incorrect variable reference
2017-12-14 00:17:02 +00:00
foreach (var z in deferred)
yield return z;
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
// do static encounters if they were deferred to end, spit out any possible encounters for invalid pkm
if (safari)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidStaticEncounter(pkm))
Split gen3/4 encounter generators from default Add exclusion for gen3/4 balls since met location requires a less precise match; static encounters will never be in safari/sport balls. Fix wurmple species ref, isn't smeargle
2017-06-02 23:56:38 +00:00
yield return z;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
// EncounterStatic
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
private static bool IsValidCatchRatePK1(EncounterStatic e, PK1 pk1)
{
var catch_rate = pk1.Catch_Rate;
// Pure gen 1, trades can be filter by catch rate
Fix yellow starter pikachu catch rate check Closes #1470
2017-09-20 05:55:05 +00:00
if (pk1.Species == 25 || pk1.Species == 26)
{
if (catch_rate == 190) // Red Blue Pikachu, is not a static encounter
return false;
if (catch_rate == 163 && e.Level == 5) // Light Ball (Yellow) starter
return true;
}
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
if (e.Version == GameVersion.Stadium)
{
switch (e.Species)
{
default:
return Stadium_CatchRate.Contains(catch_rate);
case 054: // Psyduck
// Amnesia Psyduck has different catch rates depending on language
return catch_rate == (pk1.Japanese ? 167 : 168);
}
}
// Encounters can have different Catch Rates (RBG vs Y)
var rate = e.Version == GameVersion.Y
? PersonalTable.Y[e.Species].CatchRate
: PersonalTable.RB[e.Species].CatchRate;
return catch_rate == rate;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterStatic> GetValidStaticEncounter(PKM pkm, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (gameSource == GameVersion.Any)
gameSource = (GameVersion)pkm.Version;
// Get possible encounters
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
IEnumerable<EncounterStatic> poss = GetStaticEncounters(pkm, gameSource: gameSource);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
int lvl = GetMinLevelEncounter(pkm);
Fix gen3 static encounter eggs add exclusions for egg data, fixes wynaut and togepi ingame gift eggs. Closes #1322
2017-07-12 16:02:54 +00:00
if (lvl < 0)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield break;
// Back Check against pkm
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
var enc = GetMatchingStaticEncounters(pkm, poss, lvl);
foreach (var z in enc)
yield return z;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterStatic> GetMatchingStaticEncounters(PKM pkm, IEnumerable<EncounterStatic> poss, int lvl)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Add static encounter deferrals Rarely ever used, the only case where an unfavorable match is returned first is Emerald Lati@s transferred to a future generation, as there are 2 encounters (one with and one without Fateful). Closes #1326 Thanks @sora10pls !
2017-07-14 06:12:30 +00:00
// check for petty rejection scenarios that will be flagged by other legality checks
var deferred = new List<EncounterStatic>();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
foreach (EncounterStatic e in poss)
{
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
if (!GetIsMatchStatic(pkm, e, lvl))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
continue;
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
if (pkm.FatefulEncounter != e.Fateful)
deferred.Add(e);
else
yield return e;
}
foreach (var e in deferred)
yield return e;
}
private static bool GetIsMatchStatic(PKM pkm, EncounterStatic e, int lvl)
{
if (e.Nature != Nature.Random && pkm.Nature != (int) e.Nature)
return false;
if (pkm.WasEgg != e.EggEncounter && pkm.Egg_Location == 0 && pkm.Format > 3 && pkm.GenNumber > 3 && !pkm.IsEgg)
return false;
add b2w2 n's pokemon PIDs add b2w2 fixed PID encounters (N's Pokemon), move nsparkle to this class redo static encounter cloning
2017-12-18 23:25:40 +00:00
if (e is EncounterStaticPID p && p.PID != pkm.PID)
return false;
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
if (pkm.Gen3 && e.EggLocation != 0) // Gen3 Egg
{
if (pkm.Format == 3 && pkm.IsEgg && e.EggLocation != pkm.Met_Location)
return false;
}
else if (pkm.VC || pkm.GenNumber <= 2 && e.EggLocation != 0) // Gen2 Egg
{
if (pkm.Format <= 2)
Misc gen2 fixes still a few problems left: surf encounters roamer met locations national park encounters lake of rage all-gyarados encounters (?) #1221
2017-06-13 05:16:20 +00:00
{
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
if (pkm.IsEgg)
Misc gen2 fixes still a few problems left: surf encounters roamer met locations national park encounters lake of rage all-gyarados encounters (?) #1221
2017-06-13 05:16:20 +00:00
{
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
if (pkm.Met_Location != 0 && pkm.Met_Level != 0)
return false;
}
else
{
switch (pkm.Met_Level)
Misc gen2 fixes still a few problems left: surf encounters roamer met locations national park encounters lake of rage all-gyarados encounters (?) #1221
2017-06-13 05:16:20 +00:00
{
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
case 0 when pkm.Met_Location != 0:
return false;
case 1 when pkm.Met_Location == 0:
return false;
default: if (pkm.Met_Location == 0)
return false;
break;
Misc gen2 fixes still a few problems left: surf encounters roamer met locations national park encounters lake of rage all-gyarados encounters (?) #1221
2017-06-13 05:16:20 +00:00
}
}
fix gen2 egg met level mod https://projectpokemon.org/home/forums/topic/43278-gen-2-hitmonlee-and-hitmonchan-flagged-as-illegal-if-location-is-mt-mortar-at-level-10/?tab=comments#comment-225577
2018-01-02 05:51:36 +00:00
if (pkm.Met_Level == 1)
lvl = 5; // met @ 1, hatch @ 5.
Misc gen2 fixes still a few problems left: surf encounters roamer met locations national park encounters lake of rage all-gyarados encounters (?) #1221
2017-06-13 05:16:20 +00:00
}
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
}
else if (e.EggLocation != pkm.Egg_Location)
{
add b2w2 n's pokemon PIDs add b2w2 fixed PID encounters (N's Pokemon), move nsparkle to this class redo static encounter cloning
2017-12-18 23:25:40 +00:00
if (pkm.IsEgg) // unhatched
{
if (e.EggLocation != pkm.Met_Location)
return false;
if (pkm.Egg_Location != 0)
return false;
}
Fix pt/hgss egg location handling 4->5 Closes #1766 pt/hgss egg location data is lost on transfer, retaining faraway place only. 2c8e2176e95e2002162193166efa10c6883d70ac fix was incorrect
2018-01-21 19:57:34 +00:00
else if (pkm.Gen4)
Add static encounter egg edge case handling Closes #1219 reject the eevee case if any relearn moves are present allow traded eggs to be matched
2017-06-12 01:39:19 +00:00
{
Fix pt/hgss egg location handling 4->5 Closes #1766 pt/hgss egg location data is lost on transfer, retaining faraway place only. 2c8e2176e95e2002162193166efa10c6883d70ac fix was incorrect
2018-01-21 19:57:34 +00:00
if (pkm.Egg_Location != 2002) // Link Trade
{
// check Pt/HGSS data
if (pkm.Format <= 4)
return false; // must match
if (e.EggLocation >= 3000 || e.EggLocation <= 2010) // non-Pt/HGSS egg gift
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
return false;
Fix pt/hgss egg location handling 4->5 Closes #1766 pt/hgss egg location data is lost on transfer, retaining faraway place only. 2c8e2176e95e2002162193166efa10c6883d70ac fix was incorrect
2018-01-21 19:57:34 +00:00
// transferring 4->5 clears pt/hgss location value and keeps Faraway Place
if (pkm.Egg_Location != 3002) // Faraway Place
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
return false;
Fix pt/hgss egg location handling 4->5 Closes #1766 pt/hgss egg location data is lost on transfer, retaining faraway place only. 2c8e2176e95e2002162193166efa10c6883d70ac fix was incorrect
2018-01-21 19:57:34 +00:00
}
}
else
{
if (pkm.Egg_Location != 30002) // Link Trade
return false;
}
}
else if (e.EggLocation != 0 && pkm.Gen4)
{
// Check the inverse scenario for 4->5 eggs
if (e.EggLocation < 3000 && e.EggLocation > 2010) // Pt/HGSS egg gift
{
if (pkm.Format > 4)
return false; // locations match when it shouldn't
Add static encounter egg edge case handling Closes #1219 reject the eevee case if any relearn moves are present allow traded eggs to be matched
2017-06-12 01:39:19 +00:00
}
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
}
if (pkm.HasOriginalMetLocation)
{
if (!e.EggEncounter && e.Location != 0 && e.Location != pkm.Met_Location)
return false;
if (e.Level != lvl)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
if (!(pkm.Format == 3 && e.EggEncounter && lvl == 0))
return false;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
}
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
else if (e.Level > lvl)
return false;
if (e.Gender != -1 && e.Gender != pkm.Gender)
return false;
FormChange check: use original form not current form Closes #1758 noticing the different usage for species (encounter species vs current), iterating over possible dexlevels (unnecessary?)
2018-01-13 20:10:17 +00:00
if (e.Form != pkm.AltForm && !e.SkipFormCheck && !IsFormChangeable(pkm, e.Species, e.Form))
Fix static encounter gift / egg edge case extract EncounterStatic match determination; in doing so fixes "lvl" by passing byval. Pichu encounters (2) come before the Gift level 25 pikachu, causing lvl to be dropped to 5. When pikachu comes around, it compares 5==25 -> bad; pulling out the method and passing byval allows it to be 25 at the start of every new encounterstatic checked.
2017-12-17 02:24:03 +00:00
return false;
if (e.EggLocation == 60002 && e.Relearn[0] == 0 && pkm.RelearnMoves.Any(z => z != 0)) // gen7 eevee edge case
return false;
// Defer to EC/PID check
// if (e.Shiny != null && e.Shiny != pkm.IsShiny)
// continue;
// Defer ball check to later
// if (e.Gift && pkm.Ball != 4) // PokéBall
// continue;
if (pkm is PK1 pk1 && pk1.Gen1_NotTradeback)
if (!IsValidCatchRatePK1(e, pk1))
return false;
if (!AllowGBCartEra && GameVersion.GBCartEraOnly.Contains(e.Version))
return false;
return true;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
private static IEnumerable<EncounterStatic> GetStaticEncounters(PKM pkm, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (gameSource == GameVersion.Any)
gameSource = (GameVersion)pkm.Version;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var table = GetEncounterStaticTable(pkm, gameSource);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
switch (pkm.GenNumber)
{
case 1:
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
return GetStatic(pkm, table, maxspeciesorigin: MaxSpeciesID_1);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 2:
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
return GetStatic(pkm, table, maxspeciesorigin: MaxSpeciesID_2);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
default:
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
return GetStatic(pkm, table);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
}
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
private static IEnumerable<EncounterStatic> GetStatic(PKM pkm, IEnumerable<EncounterStatic> table, int maxspeciesorigin = -1, int lvl = -1, bool skip = false)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
IEnumerable<DexLevel> dl = GetValidPreEvolutions(pkm, maxspeciesorigin: maxspeciesorigin, lvl: lvl, skipChecks: skip);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
return table.Where(e => dl.Any(d => d.Species == e.Species));
}
// EncounterSlot
Misc performance tweaks Switch encounter slot generator to yield style to not require the entire method to finish iterating Although the pressure slot may be best-matching, it isn't the typical match. Defer pressure slot clone to the end (defers the orderby calculation) There's probably a better way to do the pre-work (gen 5+ only operate off one encounterarea... usually. Past Gens end up repeating the same work for each area tested slot matching runs slightly faster now due to the deferred execution
2017-06-30 07:37:17 +00:00
private static IEnumerable<EncounterSlot> GetRawEncounterSlots(PKM pkm, int lvl, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
int maxspeciesorigin = -1;
if (gameSource == GameVersion.RBY) maxspeciesorigin = MaxSpeciesID_1;
else if (GameVersion.GSC.Contains(gameSource)) maxspeciesorigin = MaxSpeciesID_2;
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
var vs = GetValidPreEvolutions(pkm, maxspeciesorigin: maxspeciesorigin);
return GetEncounterAreas(pkm, gameSource).SelectMany(area => GetValidEncounterSlots(pkm, area, vs, DexNav: pkm.AO, lvl: lvl));
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterSlot> GetValidWildEncounters(PKM pkm, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (gameSource == GameVersion.Any)
gameSource = (GameVersion)pkm.Version;
Misc performance tweaks Switch encounter slot generator to yield style to not require the entire method to finish iterating Although the pressure slot may be best-matching, it isn't the typical match. Defer pressure slot clone to the end (defers the orderby calculation) There's probably a better way to do the pre-work (gen 5+ only operate off one encounterarea... usually. Past Gens end up repeating the same work for each area tested slot matching runs slightly faster now due to the deferred execution
2017-06-30 07:37:17 +00:00
int lvl = GetMinLevelEncounter(pkm);
if (lvl <= 0)
yield break;
var s = GetRawEncounterSlots(pkm, lvl, gameSource);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
bool IsSafariBall = pkm.Ball == 5;
bool IsSportsBall = pkm.Ball == 0x18;
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
bool IsHidden = pkm.AbilityNumber == 4; // hidden Ability
int species = pkm.Species;
var deferred = new List<EncounterSlot>();
foreach (EncounterSlot slot in s)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Misc tweaks for encounter generation reduce 'as' usages for pk1 (cast & check once) reorder some slot generation checks (early return prior to slot filtering; not crucial as the linq wasn't evaluated yet).
2017-06-30 06:50:24 +00:00
// check for petty rejection scenarios that will be flagged by other legality checks
// defer these edge case scenarios in the event that a later encounter ends up passing
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
if (slot.Species == 265 && species != 265 && !IsWurmpleEvoValid(pkm)) { } // bad wurmple evolution
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
else if (IsHidden ^ IsHiddenAbilitySlot(slot)) { } // ability mismatch
else if (IsSafariBall ^ IsSafariSlot(slot.Type)) { } // Safari Zone only ball
else if (IsSportsBall ^ slot.Type == SlotType.BugContest) { } // BCC only ball
else
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
yield return slot;
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
continue;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
deferred.Add(slot);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
foreach (var d in deferred)
yield return d;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterSlot> GetValidFriendSafari(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (!pkm.XY)
yield break;
if (pkm.Met_Location != 148) // Friend Safari
yield break;
if (pkm.Met_Level != 30)
yield break;
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
var vs = GetValidPreEvolutions(pkm).Where(d => d.Level >= 30);
foreach (var slot in vs.SelectMany(z => Encounters6.FriendSafari[z.Species]))
yield return slot;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
private static IEnumerable<EncounterSlot> GetValidEncounterSlots(PKM pkm, EncounterArea loc, IEnumerable<DexLevel> vs, bool DexNav = false, int lvl = -1, bool ignoreLevel = false)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Don't generate encounter slots for eggs Closes #1749
2018-01-07 05:51:58 +00:00
if (pkm.WasEgg)
return Enumerable.Empty<EncounterSlot>();
Misc performance tweaks Switch encounter slot generator to yield style to not require the entire method to finish iterating Although the pressure slot may be best-matching, it isn't the typical match. Defer pressure slot clone to the end (defers the orderby calculation) There's probably a better way to do the pre-work (gen 5+ only operate off one encounterarea... usually. Past Gens end up repeating the same work for each area tested slot matching runs slightly faster now due to the deferred execution
2017-06-30 07:37:17 +00:00
if (lvl < 0)
lvl = GetMinLevelEncounter(pkm);
if (lvl <= 0)
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
return Enumerable.Empty<EncounterSlot>();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
int gen = pkm.GenNumber;
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
if (gen < 3)
return GetValidEncounterSlots12(pkm, loc, vs, lvl, ignoreLevel);
const int fluteBoost = 4;
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
const int dexnavBoost = 30;
int df = DexNav ? fluteBoost : 0;
int dn = DexNav ? fluteBoost + dexnavBoost : 0;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
// Get Valid levels
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
var encounterSlots = GetValidEncounterSlotsByEvoLevel(pkm, loc.Slots, lvl, ignoreLevel, vs, df, dn);
Misc tweaks for encounter generation reduce 'as' usages for pk1 (cast & check once) reorder some slot generation checks (early return prior to slot filtering; not crucial as the linq wasn't evaluated yet).
2017-06-30 06:50:24 +00:00
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
// Return enumerable of slots pkm might have originated from
if (gen <= 5)
return GetFilteredSlotsByForm(pkm, encounterSlots);
if (DexNav && gen == 6)
return GetFilteredSlots6DexNav(pkm, lvl, encounterSlots, fluteBoost);
return GetFilteredSlots67(pkm, encounterSlots);
}
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
private static IEnumerable<EncounterSlot> GetValidEncounterSlots12(PKM pkm, EncounterArea loc, IEnumerable<DexLevel> vs, int lvl = -1, bool ignoreLevel = false)
{
if (lvl < 0)
lvl = GetMinLevelEncounter(pkm);
if (lvl <= 0)
return Enumerable.Empty<EncounterSlot>();
var Gen1Version = GameVersion.RBY;
bool RBDragonair = false;
if (!ignoreLevel && !FilterGBSlotsCatchRate(pkm, ref vs, ref Gen1Version, ref RBDragonair))
return Enumerable.Empty<EncounterSlot>();
var encounterSlots = GetValidEncounterSlotsByEvoLevel(pkm, loc.Slots, lvl, ignoreLevel, vs);
return GetFilteredSlots12(pkm, pkm.GenNumber, Gen1Version, encounterSlots, RBDragonair).OrderBy(slot => slot.LevelMin); // prefer lowest levels
}
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
private static IEnumerable<EncounterSlot> GetValidEncounterSlotsByEvoLevel(PKM pkm, IEnumerable<EncounterSlot> slots, int lvl, bool ignoreLevel, IEnumerable<DexLevel> vs, int df = 0, int dn = 0)
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
{
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
// Get slots where pokemon can exist with respect to the evolution chain
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (ignoreLevel)
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
return slots.Where(slot => vs.Any(evo => evo.Species == slot.Species)).ToList();
slots = slots.Where(slot => vs.Any(evo => evo.Species == slot.Species && evo.Level >= slot.LevelMin - df));
// Get slots where pokemon can exist with respect to level constraints
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
if (pkm.HasOriginalMetLocation)
return slots.Where(slot => slot.LevelMin - df <= lvl && lvl <= slot.LevelMax + (slot.Permissions.AllowDexNav ? dn : df)).ToList();
// check for any less than current level
return slots.Where(slot => slot.LevelMin <= lvl).ToList();
}
private static IEnumerable<EncounterSlot> GetFilteredSlotsByForm(PKM pkm, IEnumerable<EncounterSlot> encounterSlots)
{
return WildForms.Contains(pkm.Species)
? encounterSlots.Where(slot => slot.Form == pkm.AltForm)
: encounterSlots;
}
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
private static IEnumerable<EncounterSlot> GetFilteredSlots67(PKM pkm, IEnumerable<EncounterSlot> encounterSlots)
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
{
int species = pkm.Species;
int form = pkm.AltForm;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Block wild dusk rockruff closes #1627 adds test cases
2017-11-18 04:02:01 +00:00
// Edge Case Handling
switch (species)
{
case 744 when form == 1:
case 745 when form == 2:
yield break;
}
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
var slots = new List<EncounterSlot>();
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
if (AlolanVariantEvolutions12.Contains(species)) // match form if same species, else form 0.
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
{
foreach (var slot in encounterSlots)
{
if (species == slot.Species ? slot.Form == form : slot.Form == 0)
yield return slot;
slots.Add(slot);
}
}
Update wild/egg generators for totem cases so wonky edge cases
2017-11-14 16:43:04 +00:00
else if (ShouldMatchSlotForm()) // match slot form
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
{
foreach (var slot in encounterSlots)
{
if (slot.Form == form)
yield return slot;
slots.Add(slot);
}
}
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
else
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
{
foreach (var slot in encounterSlots)
{
yield return slot; // no form checking
slots.Add(slot);
}
}
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
// Filter for Form Specific
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
// Pressure Slot
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
EncounterSlot slotMax = slots.OrderByDescending(slot => slot.LevelMax).FirstOrDefault();
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
if (slotMax == null)
yield break; // yield break;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
if (AlolanVariantEvolutions12.Contains(species)) // match form if same species, else form 0.
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
if (species == slotMax.Species ? slotMax.Form == form : slotMax.Form == 0)
yield return GetPressureSlot(slotMax, pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Update wild/egg generators for totem cases so wonky edge cases
2017-11-14 16:43:04 +00:00
else if (ShouldMatchSlotForm()) // match slot form
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
if (slotMax.Form == form)
yield return GetPressureSlot(slotMax, pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
else
yield return GetPressureSlot(slotMax, pkm);
Update wild/egg generators for totem cases so wonky edge cases
2017-11-14 16:43:04 +00:00
bool ShouldMatchSlotForm() => WildForms.Contains(species) || AlolanOriginForms.Contains(species) || FormConverter.IsTotemForm(species, form);
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
}
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
private static IEnumerable<EncounterSlot> GetFilteredSlots6DexNav(PKM pkm, int lvl, IEnumerable<EncounterSlot> encounterSlots, int fluteBoost)
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
{
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
var slots = new List<EncounterSlot>();
foreach (EncounterSlot s in encounterSlots)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
if (WildForms.Contains(pkm.Species) && s.Form != pkm.AltForm)
{
slots.Add(s);
continue;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
bool nav = s.Permissions.AllowDexNav && (pkm.RelearnMove1 != 0 || pkm.AbilityNumber == 4);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
EncounterSlot slot = s.Clone();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
slot.Permissions.DexNav = nav;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (slot.LevelMin > lvl)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
slot.Permissions.WhiteFlute = true;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (slot.LevelMax + 1 <= lvl && lvl <= slot.LevelMax + fluteBoost)
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
slot.Permissions.BlackFlute = true;
if (slot.LevelMax != lvl && slot.Permissions.AllowDexNav)
slot.Permissions.DexNav = true;
Misc performance tweaks Switch encounter slot generator to yield style to not require the entire method to finish iterating Although the pressure slot may be best-matching, it isn't the typical match. Defer pressure slot clone to the end (defers the orderby calculation) There's probably a better way to do the pre-work (gen 5+ only operate off one encounterarea... usually. Past Gens end up repeating the same work for each area tested slot matching runs slightly faster now due to the deferred execution
2017-06-30 07:37:17 +00:00
yield return slot;
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
slots.Add(s);
Misc performance tweaks Switch encounter slot generator to yield style to not require the entire method to finish iterating Although the pressure slot may be best-matching, it isn't the typical match. Defer pressure slot clone to the end (defers the orderby calculation) There's probably a better way to do the pre-work (gen 5+ only operate off one encounterarea... usually. Past Gens end up repeating the same work for each area tested slot matching runs slightly faster now due to the deferred execution
2017-06-30 07:37:17 +00:00
}
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
// Pressure Slot
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
EncounterSlot slotMax = slots.OrderByDescending(slot => slot.LevelMax).FirstOrDefault();
Misc performance tweaks Switch encounter slot generator to yield style to not require the entire method to finish iterating Although the pressure slot may be best-matching, it isn't the typical match. Defer pressure slot clone to the end (defers the orderby calculation) There's probably a better way to do the pre-work (gen 5+ only operate off one encounterarea... usually. Past Gens end up repeating the same work for each area tested slot matching runs slightly faster now due to the deferred execution
2017-06-30 07:37:17 +00:00
if (slotMax != null)
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
yield return GetPressureSlot(slotMax, pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
private static EncounterSlot GetPressureSlot(EncounterSlot s, PKM pkm)
{
var max = s.Clone();
max.Permissions.Pressure = true;
max.Form = pkm.AltForm;
return max;
}
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
private static bool FilterGBSlotsCatchRate(PKM pkm, ref IEnumerable<DexLevel> vs, ref GameVersion Gen1Version, ref bool RBDragonair)
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
{
if (!(pkm is PK1 pk1) || !pkm.Gen1_NotTradeback)
return true;
// Pure gen 1, slots can be filter by catch rate
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
var rate = pk1.Catch_Rate;
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
switch (pkm.Species)
{
// Pikachu
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
case 25 when rate == 163:
case 26 when rate == 163:
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
return false; // Yellow Pikachu is not a wild encounter
// Kadabra (YW)
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
case 64 when rate == 96:
case 65 when rate == 96:
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
vs = vs.Where(s => s.Species == 64);
Gen1Version = GameVersion.YW;
return true;
// Kadabra (RB)
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
case 64 when rate == 100:
case 65 when rate == 100:
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
vs = vs.Where(s => s.Species == 64);
Gen1Version = GameVersion.RB;
return true;
// Dragonair (YW)
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
case 148 when rate == 27:
case 149 when rate == 27:
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
vs = vs.Where(s => s.Species == 148); // Yellow Dragonair, ignore Dratini encounters
Gen1Version = GameVersion.YW;
return true;
// Dragonair (RB)
case 148:
case 149:
// Red blue dragonair have the same catch rate as dratini, it could also be a dratini from any game
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
vs = vs.Where(s => rate == PersonalTable.RB[s.Species].CatchRate);
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
RBDragonair = true;
return true;
default:
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
vs = vs.Where(s => rate == PersonalTable.RB[s.Species].CatchRate);
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
return true;
}
}
Refactoring check alolan forms for forme matching, break up large method to something a little more understandable.
2017-11-11 17:35:07 +00:00
private static IEnumerable<EncounterSlot> GetFilteredSlots12(PKM pkm, int gen, GameVersion Gen1Version, IEnumerable<EncounterSlot> slots, bool RBDragonair)
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
{
switch (gen)
{
case 1:
if (Gen1Version != GameVersion.RBY)
slots = slots.Where(slot => Gen1Version.Contains(((EncounterSlot1)slot).Version));
// Red Blue dragonair or dratini from any gen 1 games
if (RBDragonair)
return slots.Where(slot => GameVersion.RB.Contains(((EncounterSlot1)slot).Version) || slot.Species == 147);
return slots;
case 2:
if (pkm is PK2 pk2 && pk2.Met_Day != 0)
Misc tweaks minor perf improvements (don't ToList for encounter slots, store all slots incrementally); has better performance for legal pkm checks
2017-12-23 19:49:20 +00:00
return slots.Where(slot => ((EncounterSlot1)slot).Time.Contains(pk2.Met_Day));
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
return slots;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Refactoring misc cleanup/breaking up large methods from recent PR
2017-07-07 00:01:29 +00:00
default:
return slots;
}
}
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
private static IEnumerable<EncounterArea> GetEncounterSlots(PKM pkm, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (gameSource == GameVersion.Any)
gameSource = (GameVersion)pkm.Version;
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
return GetEncounterTable(pkm, gameSource);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterArea> GetEncounterAreas(PKM pkm, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (gameSource == GameVersion.Any)
gameSource = (GameVersion)pkm.Version;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var slots = GetEncounterSlots(pkm, gameSource: gameSource);
Enforce met location matching for crystal data Only while format == 2 improve detection for gen1/2 ingame trades
2017-06-13 01:15:26 +00:00
bool noMet = !pkm.HasOriginalMetLocation || pkm.Format == 2 && gameSource != GameVersion.C;
return noMet ? slots : slots.Where(area => area.Location == pkm.Met_Location);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
// EncounterLink
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterLink> GetValidLinkGifts(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
switch (pkm.GenNumber)
{
case 6:
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
return Encounters6.LinkGifts6.Where(g => g.Species == pkm.Species && g.Level == pkm.Met_Level);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
default:
Use empty enumerable when appropriate no allocation == no pressure for garbage collector
2017-10-23 22:44:01 +00:00
return Enumerable.Empty<EncounterLink>();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
}
// EncounterTrade
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static EncounterTrade[] GetEncounterTradeTable(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
switch (pkm.GenNumber)
{
case 3:
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
return pkm.FRLG ? Encounters3.TradeGift_FRLG : Encounters3.TradeGift_RSE;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 4:
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
return pkm.HGSS ? Encounters4.TradeGift_HGSS : Encounters4.TradeGift_DPPt;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 5:
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
return pkm.B2W2 ? Encounters5.TradeGift_B2W2 : Encounters5.TradeGift_BW;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 6:
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
return pkm.XY ? Encounters6.TradeGift_XY : Encounters6.TradeGift_AO;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 7:
usum prep Copied binaries from sm, references set up for saving time later I assume not much will change in terms of structures, so it should just be a file replacement & filling in static encounter table => 'working' legality checks
2017-09-01 05:37:28 +00:00
return pkm.SM ? Encounters7.TradeGift_SM : Encounters7.TradeGift_USUM;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
return null;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterTrade> GetValidEncounterTradesVC(PKM pkm, GameVersion gameSource)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var p = GetValidPreEvolutions(pkm).ToArray();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
switch (gameSource)
{
case GameVersion.RBY:
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
var table = !AllowGen1Tradeback ? Encounters1.TradeGift_RBY_NoTradeback : Encounters1.TradeGift_RBY_Tradeback;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetValidEncounterTradesVC1(pkm, p, table);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case GameVersion.GSC:
Enforce met location matching for crystal data Only while format == 2 improve detection for gen1/2 ingame trades
2017-06-13 01:15:26 +00:00
case GameVersion.C:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetValidEncounterTradesVC2(pkm, p);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
default:
return null;
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterTrade> GetValidEncounterTradesVC2(PKM pkm, DexLevel[] p)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
// Check GSC trades. Reuse generic table fetch-match
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
var possible = GetValidEncounterTradesVC1(pkm, p, Encounters2.TradeGift_GSC);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
foreach (var z in possible)
{
// Filter Criteria
if (z.TID != pkm.TID)
continue;
Add gsc goldenrod / fix mania shuckie
2017-06-18 05:44:05 +00:00
if (z.Gender >= 0 && z.Gender != pkm.Gender && pkm.Format <= 2)
Enforce met location matching for crystal data Only while format == 2 improve detection for gen1/2 ingame trades
2017-06-13 01:15:26 +00:00
continue;
Add gsc goldenrod / fix mania shuckie
2017-06-18 05:44:05 +00:00
if (z.IVs[0] >= 0 && !z.IVs.SequenceEqual(pkm.IVs) && pkm.Format <= 2)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
continue;
Add "Can't Tell" recognition for gen2 ingame trades Fix xatu's IVs, dodrio's gender why bulba, yes serebii
2017-06-17 06:14:22 +00:00
if (pkm.Met_Location != 0 && pkm.Format == 2 && pkm.Met_Location != 126)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
continue;
Relocate encounter data loading to separate files shifts encounter data from Legal's split tables to individual files for easier maintenance and initialization. Legal Core's init is so much simpler now. fix resource name typo
2017-07-25 07:28:43 +00:00
int index = Array.IndexOf(Encounters2.TradeGift_GSC, z);
if (Encounters2.TradeGift_GSC_OTs[index].All(ot => ot != pkm.OT_Name))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
continue;
yield return z;
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterTrade> GetValidEncounterTradesVC1(PKM pkm, DexLevel[] p, IEnumerable<EncounterTrade> table)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
var possible = table.Where(f => p.Any(r => r.Species == f.Species));
foreach (var z in possible)
{
if (z == null)
continue;
if (z.Level > pkm.CurrentLevel) // minimum required level
continue;
if (pkm.Format != 1 || !pkm.Gen1_NotTradeback)
yield return z;
// Even if the in game trade uses the tables with source pokemon allowing generation 2 games, the traded pokemon could be a non-tradeback pokemon
var rate = (pkm as PK1)?.Catch_Rate;
misc tweaks no functional changes
2017-09-20 06:19:22 +00:00
if (z is EncounterTradeCatchRate r)
Generation 1/2 Legal improvements (#1310) * Added location to encounter slot to make verification againts the location of the encounter when the pokemon has lost met location, like generation 2 heabutt tree, jhoto surfing in route 45 and in the future generation 4 munchlax tree Added version to generation 1 and 2 encounter locations to filter by catch rate based of the version of the encounter and check initial moves of the encounter only for the game that match the encounter Filter generation 2 pokemon for crystal who have met location based of the time of day when it was captured Completed version to static and traded encounters for gen 1 pokemon, to avoid check a red encounter with yellow initial moves, if an encounter is possible in both games with diferent moves it is duplicated (like eevee), if it is possible in both games with the same moves is left as RBY, the encounter will only use red/blue moveset Verify some invalid gen 2 encounters. Crystall heabutt encounters based on the TID, using the tree selection algorithm of the game to determine if the encounter is possible for the TID (implemented base on https://bulbapedia.bulbagarden.net/wiki/Headbutt_tree#Mechanics). Coordinates of Crystal trees obtained with the programa G2Map Added checks for fishing encounters for unreacheable water tiles in gen 2, route 14, national park and the beta safari zone. * Fix gen 1 static encounters and trade encounters filter by version * Missing strings
2017-07-06 23:03:41 +00:00
{
if (rate != r.Catch_Rate)
continue;
}
else
{
if (z.Version == GameVersion.YW && rate != PersonalTable.Y[z.Species].CatchRate)
continue;
if (z.Version != GameVersion.YW && rate != PersonalTable.RB[z.Species].CatchRate)
continue;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterTrade> GetValidEncounterTrades(PKM pkm, GameVersion gameSource = GameVersion.Any)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (gameSource == GameVersion.Any)
gameSource = (GameVersion)pkm.Version;
if (pkm.VC || pkm.Format <= 2)
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
foreach (var z in GetValidEncounterTradesVC(pkm, gameSource))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
yield break;
}
int lang = pkm.Language;
Add LanguageID enum no functional change, just less-magic-numbers for easier to understand src
2017-10-23 04:01:08 +00:00
if (lang == (int)LanguageID.UNUSED_6) // invalid language
Misc languageID legality checking update Checks for max language ID on transferred pkm (gen5 pkm on gen7 can't have CHS/CHT etc) handles edge case for JPN B/W ingame trades update pk5->pk6 transfer logic to bump langID 0 to 1. Thanks HaxAras & Britty for providing samples!
2017-09-16 00:43:31 +00:00
yield break;
Add LanguageID enum no functional change, just less-magic-numbers for easier to understand src
2017-10-23 04:01:08 +00:00
if (lang == (int)LanguageID.Hacked && (pkm.Format != 5 || !pkm.BW)) // Japanese trades in BW have no language ID
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield break;
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
int lvl = GetMinLevelEncounter(pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (lvl <= 0)
yield break;
// Get valid pre-evolutions
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
IEnumerable<DexLevel> p = GetValidPreEvolutions(pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
EncounterTrade[] table = GetEncounterTradeTable(pkm);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (table == null)
yield break;
var poss = table.Where(f => p.Any(r => r.Species == f.Species) && f.Version.Contains((GameVersion)pkm.Version));
foreach (var z in poss)
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
if (IsEncounterTradeValid(pkm, z, lvl))
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static bool IsEncounterTradeValid(PKM pkm, EncounterTrade z, int lvl)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
for (int i = 0; i < 6; i++)
if (z.IVs[i] != -1 && z.IVs[i] != pkm.IVs[i])
return false;
Add ranch ingame trades debut of the long awaited EncounterTradePID class gist to generate trades from folder (using LINQPad): https://gist.github.com/kwsch/d778f1f63e4c393e5440dfb0e14cfcc3 Closes #1458 , although Mew/Phione's PIDIV method is unknown.
2017-09-21 04:28:29 +00:00
if (z is EncounterTradePID p)
{
if (p.PID != pkm.EncryptionConstant)
return false;
Add form/nature checks for gen5 trades altform wasn't checked for EncounterTrade nature wasn't checked for gen5 origin (decoupled from PID, but forced) #1702
2017-12-16 22:09:03 +00:00
if (z.Nature != Nature.Random && (int)z.Nature != pkm.Nature) // gen5 BW only
return false;
Add ranch ingame trades debut of the long awaited EncounterTradePID class gist to generate trades from folder (using LINQPad): https://gist.github.com/kwsch/d778f1f63e4c393e5440dfb0e14cfcc3 Closes #1458 , although Mew/Phione's PIDIV method is unknown.
2017-09-21 04:28:29 +00:00
}
else
{
if (z.Shiny ^ pkm.IsShiny)
return false;
if (z.Nature != Nature.Random && (int)z.Nature != pkm.Nature)
return false;
if (z.Gender != -1 && z.Gender != pkm.Gender)
return false;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (z.TID != pkm.TID)
return false;
if (z.SID != pkm.SID)
return false;
if (pkm.HasOriginalMetLocation)
{
Add "Can't Tell" recognition for gen2 ingame trades Fix xatu's IVs, dodrio's gender why bulba, yes serebii
2017-06-17 06:14:22 +00:00
var loc = z.Location > 0 ? z.Location : EncounterTrade.DefaultMetLocation[pkm.GenNumber - 1];
if (loc != pkm.Met_Location)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
return false;
if (pkm.Format < 5)
{
if (z.Level > lvl)
return false;
}
else if (z.Level != lvl)
return false;
}
else if (z.Level > lvl)
return false;
Add ranch ingame trades debut of the long awaited EncounterTradePID class gist to generate trades from folder (using LINQPad): https://gist.github.com/kwsch/d778f1f63e4c393e5440dfb0e14cfcc3 Closes #1458 , although Mew/Phione's PIDIV method is unknown.
2017-09-21 04:28:29 +00:00
if (z.CurrentLevel != -1 && z.CurrentLevel > pkm.CurrentLevel)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
return false;
Add ranch ingame trades debut of the long awaited EncounterTradePID class gist to generate trades from folder (using LINQPad): https://gist.github.com/kwsch/d778f1f63e4c393e5440dfb0e14cfcc3 Closes #1458 , although Mew/Phione's PIDIV method is unknown.
2017-09-21 04:28:29 +00:00
FormChange check: use original form not current form Closes #1758 noticing the different usage for species (encounter species vs current), iterating over possible dexlevels (unnecessary?)
2018-01-13 20:10:17 +00:00
if (z.Form != pkm.AltForm && !IsFormChangeable(pkm, pkm.Species, z.Form))
Add form/nature checks for gen5 trades altform wasn't checked for EncounterTrade nature wasn't checked for gen5 origin (decoupled from PID, but forced) #1702
2017-12-16 22:09:03 +00:00
return false;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (z.OTGender != -1 && z.OTGender != pkm.OT_Gender)
return false;
add location interface for verbose analysis output indicates met location for transferred mons most gen1/2 encounters won't show values due to the location not being stored respective to the string tables (anyone wanna do a location remap after initial load?)
2018-01-02 20:00:41 +00:00
if (z.EggLocation != pkm.Egg_Location)
Add ranch ingame trades debut of the long awaited EncounterTradePID class gist to generate trades from folder (using LINQPad): https://gist.github.com/kwsch/d778f1f63e4c393e5440dfb0e14cfcc3 Closes #1458 , although Mew/Phione's PIDIV method is unknown.
2017-09-21 04:28:29 +00:00
return false;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
// if (z.Ability == 4 ^ pkm.AbilityNumber == 4) // defer to Ability
// countinue;
return true;
}
// MysteryGift
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<MysteryGift> GetValidGifts(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
switch (pkm.GenNumber)
{
Add initial gen3 event detection egg events supported, only some gen3 event distros supported will eventually flag for PIDIV type mismatching @kamronbatman
2017-05-29 07:48:25 +00:00
case 3:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetMatchingWC3(pkm, MGDB_G3);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 4:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetMatchingPCD(pkm, MGDB_G4);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 5:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetMatchingPGF(pkm, MGDB_G5);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 6:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetMatchingWC6(pkm, MGDB_G6);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
case 7:
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return GetMatchingWC7(pkm, MGDB_G7);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
default:
Use empty enumerable when appropriate no allocation == no pressure for garbage collector
2017-10-23 22:44:01 +00:00
return Enumerable.Empty<MysteryGift>();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<MysteryGift> GetMatchingWC3(PKM pkm, IEnumerable<MysteryGift> DB)
Add initial gen3 event detection egg events supported, only some gen3 event distros supported will eventually flag for PIDIV type mismatching @kamronbatman
2017-05-29 07:48:25 +00:00
{
if (DB == null)
yield break;
var validWC3 = new List<MysteryGift>();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var vs = GetValidPreEvolutions(pkm, MaxSpeciesID_3).ToArray();
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
var enumerable = DB.OfType<WC3>().Where(wc => vs.Any(dl => dl.Species == wc.Species));
foreach (WC3 wc in enumerable)
Add initial gen3 event detection egg events supported, only some gen3 event distros supported will eventually flag for PIDIV type mismatching @kamronbatman
2017-05-29 07:48:25 +00:00
{
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (!GetIsMatchWC3(pkm, wc))
Add initial gen3 event detection egg events supported, only some gen3 event distros supported will eventually flag for PIDIV type mismatching @kamronbatman
2017-05-29 07:48:25 +00:00
continue;
if (wc.Species == pkm.Species) // best match
yield return wc;
else
validWC3.Add(wc);
}
foreach (var z in validWC3)
yield return z;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<MysteryGift> GetMatchingPCD(PKM pkm, IEnumerable<MysteryGift> DB)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Misc tweaks fix pcd detection (yield brewk needed to be inside brackets remove brackets from single line lambda expressions
2017-07-06 06:05:49 +00:00
if (DB == null || pkm.IsEgg && pkm.Format != 4) // transferred
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield break;
Manaphy Egg fixes
2017-07-05 19:31:41 +00:00
if (IsRangerManaphy(pkm))
Misc tweaks fix pcd detection (yield brewk needed to be inside brackets remove brackets from single line lambda expressions
2017-07-06 06:05:49 +00:00
{
Add LanguageID enum no functional change, just less-magic-numbers for easier to understand src
2017-10-23 04:01:08 +00:00
if (pkm.Language != (int)LanguageID.Korean) // never korean
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
yield return new PGT { Data = { [0] = 7, [8] = 1 } };
Misc tweaks fix pcd detection (yield brewk needed to be inside brackets remove brackets from single line lambda expressions
2017-07-06 06:05:49 +00:00
yield break;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
var deferred = new List<MysteryGift>();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var vs = GetValidPreEvolutions(pkm).ToArray();
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
var enumerable = DB.OfType<PCD>().Where(wc => vs.Any(dl => dl.Species == wc.Species));
foreach (PCD mg in enumerable)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
var wc = mg.Gift.PK;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (!GetIsMatchPCD(pkm, wc, vs))
continue;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Add mysterygift version receivability check for PCD Closes #1242
2017-06-18 06:09:00 +00:00
bool receivable = mg.CanBeReceivedBy(pkm.Version);
if (wc.Species == pkm.Species && receivable) // best match
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return mg;
else
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
deferred.Add(mg);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
foreach (var z in deferred)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<MysteryGift> GetMatchingPGF(PKM pkm, IEnumerable<MysteryGift> DB)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (DB == null)
yield break;
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
var deferred = new List<MysteryGift>();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var vs = GetValidPreEvolutions(pkm).ToArray();
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
var enumerable = DB.OfType<PGF>().Where(wc => vs.Any(dl => dl.Species == wc.Species));
foreach (PGF wc in enumerable)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (!GetIsMatchPGF(pkm, wc, vs))
continue;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (wc.Species == pkm.Species) // best match
yield return wc;
else
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
deferred.Add(wc);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
foreach (var z in deferred)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<MysteryGift> GetMatchingWC6(PKM pkm, IEnumerable<MysteryGift> DB)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (DB == null)
yield break;
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
var deferred = new List<MysteryGift>();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var vs = GetValidPreEvolutions(pkm).ToArray();
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
var enumerable = DB.OfType<WC6>().Where(wc => vs.Any(dl => dl.Species == wc.Species));
foreach (WC6 wc in enumerable)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (!GetIsMatchWC6(pkm, wc, vs))
continue;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Add deferral case for gen6 magmar classic ribbon use "when" for easy src code Thanks Nessus!
2017-10-19 01:28:17 +00:00
switch (wc.CardID)
{
case 0525 when wc.IV_HP == 0xFE: // Diancie was distributed with no IV enforcement & 3IVs
case 0504 when wc.RibbonClassic != ((IRibbonSetEvent4)pkm).RibbonClassic: // magmar with/without classic
deferred.Add(wc);
continue;
}
if (wc.Species == pkm.Species) // best match
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return wc;
else
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
deferred.Add(wc);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
foreach (var z in deferred)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<MysteryGift> GetMatchingWC7(PKM pkm, IEnumerable<MysteryGift> DB)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (DB == null)
yield break;
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
var deferred = new List<MysteryGift>();
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
var vs = GetValidPreEvolutions(pkm).ToArray();
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
var enumerable = DB.OfType<WC7>().Where(wc => vs.Any(dl => dl.Species == wc.Species));
foreach (WC7 wc in enumerable)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (!GetIsMatchWC7(pkm, wc, vs))
continue;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if ((pkm.SID << 16 | pkm.TID) == 0x79F57B49) // Greninja WC has variant PID and can arrive @ 36 or 37
{
if (!pkm.IsShiny)
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
deferred.Add(wc);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
continue;
}
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
if (wc.PIDType == 0 && pkm.PID != wc.PID)
continue;
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
if (wc.Species == pkm.Species) // best match
yield return wc;
else
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
deferred.Add(wc);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
foreach (var z in deferred)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
yield return z;
}
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
private static bool GetIsMatchWC3(PKM pkm, WC3 wc)
{
// Gen3 Version MUST match.
if (wc.Version != 0 && !((GameVersion)wc.Version).Contains((GameVersion)pkm.Version))
return false;
bool hatchedEgg = wc.IsEgg && !pkm.IsEgg;
if (!hatchedEgg)
{
if (wc.SID != -1 && wc.SID != pkm.SID) return false;
if (wc.TID != -1 && wc.TID != pkm.TID) return false;
if (wc.OT_Name != null && wc.OT_Name != pkm.OT_Name) return false;
if (wc.OT_Gender < 3 && wc.OT_Gender != pkm.OT_Gender) return false;
}
if (wc.Language != -1 && wc.Language != pkm.Language) return false;
if (wc.Ball != pkm.Ball) return false;
if (wc.Fateful != pkm.FatefulEncounter)
{
// XD Gifts only at level 20 get flagged after transfer
bool valid = wc.Level == 20 && pkm is XK3;
if (!valid)
return false;
}
if (pkm.IsNative)
{
if (wc.Met_Level != pkm.Met_Level)
return false;
add location interface for verbose analysis output indicates met location for transferred mons most gen1/2 encounters won't show values due to the location not being stored respective to the string tables (anyone wanna do a location remap after initial load?)
2018-01-02 20:00:41 +00:00
if (wc.Location != pkm.Met_Location && (!wc.IsEgg || pkm.IsEgg))
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
return false;
}
else
{
if (pkm.IsEgg)
return false;
if (wc.Level > pkm.Met_Level)
return false;
}
return true;
}
private static bool GetIsMatchPCD(PKM pkm, PKM wc, IEnumerable<DexLevel> vs)
{
if (!wc.IsEgg)
{
if (wc.TID != pkm.TID) return false;
if (wc.SID != pkm.SID) return false;
if (wc.OT_Name != pkm.OT_Name) return false;
if (wc.OT_Gender != pkm.OT_Gender) return false;
if (wc.Language != 0 && wc.Language != pkm.Language) return false;
if (pkm.Format != 4) // transferred
{
// met location: deferred to general transfer check
if (wc.CurrentLevel > pkm.Met_Level) return false;
}
else
{
if (wc.Egg_Location + 3000 != pkm.Met_Location) return false;
if (wc.CurrentLevel != pkm.Met_Level) return false;
}
}
else // Egg
{
if (wc.Egg_Location + 3000 != pkm.Egg_Location && pkm.Egg_Location != 2002) // traded
return false;
if (wc.CurrentLevel != pkm.Met_Level)
return false;
if (pkm.IsEgg && !pkm.IsNative)
return false;
}
FormChange check: use original form not current form Closes #1758 noticing the different usage for species (encounter species vs current), iterating over possible dexlevels (unnecessary?)
2018-01-13 20:10:17 +00:00
if (wc.AltForm != pkm.AltForm && vs.All(dl => !IsFormChangeable(pkm, dl.Species, wc.AltForm)))
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
return false;
if (wc.Ball != pkm.Ball) return false;
if (wc.OT_Gender < 3 && wc.OT_Gender != pkm.OT_Gender) return false;
if (wc.PID == 1 && pkm.IsShiny) return false;
if (wc.Gender != 3 && wc.Gender != pkm.Gender) return false;
if (wc.CNT_Cool > pkm.CNT_Cool) return false;
if (wc.CNT_Beauty > pkm.CNT_Beauty) return false;
if (wc.CNT_Cute > pkm.CNT_Cute) return false;
if (wc.CNT_Smart > pkm.CNT_Smart) return false;
if (wc.CNT_Tough > pkm.CNT_Tough) return false;
if (wc.CNT_Sheen > pkm.CNT_Sheen) return false;
Invert PCD return value on match Result of refactoring and manually flipping all the returns Closes #1421
2017-08-26 00:29:14 +00:00
return true;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
}
private static bool GetIsMatchPGF(PKM pkm, PGF wc, IEnumerable<DexLevel> vs)
{
if (!wc.IsEgg)
{
if (wc.SID != pkm.SID) return false;
if (wc.TID != pkm.TID) return false;
Rework mysterygift pkm sprite generation don't bother converting to pkm then generating the sprite off that; use the overload with int/bool removes sav/pkm dependency for generating gift descriptions, and standardizes the names a little. maybe a PKMBase interface would be useful...
2017-11-18 19:34:23 +00:00
if (wc.OT_Name != pkm.OT_Name) return false;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (wc.OTGender < 3 && wc.OTGender != pkm.OT_Gender) return false;
if (wc.PID != 0 && pkm.PID != wc.PID) return false;
if (wc.PIDType == 0 && pkm.IsShiny) return false;
if (wc.PIDType == 2 && !pkm.IsShiny) return false;
if (wc.OriginGame != 0 && wc.OriginGame != pkm.Version) return false;
if (wc.Language != 0 && wc.Language != pkm.Language) return false;
if (wc.EggLocation != pkm.Egg_Location) return false;
if (wc.MetLocation != pkm.Met_Location) return false;
}
else
{
if (wc.EggLocation != pkm.Egg_Location && pkm.Egg_Location != 30003) // traded
return false;
if (pkm.IsEgg && !pkm.IsNative)
return false;
}
FormChange check: use original form not current form Closes #1758 noticing the different usage for species (encounter species vs current), iterating over possible dexlevels (unnecessary?)
2018-01-13 20:10:17 +00:00
if (wc.Form != pkm.AltForm && vs.All(dl => !IsFormChangeable(pkm, dl.Species, wc.Form))) return false;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (wc.Level != pkm.Met_Level) return false;
if (wc.Ball != pkm.Ball) return false;
if (wc.Nature != 0xFF && wc.Nature != pkm.Nature) return false;
if (wc.Gender != 2 && wc.Gender != pkm.Gender) return false;
if (wc.CNT_Cool > pkm.CNT_Cool) return false;
if (wc.CNT_Beauty > pkm.CNT_Beauty) return false;
if (wc.CNT_Cute > pkm.CNT_Cute) return false;
if (wc.CNT_Smart > pkm.CNT_Smart) return false;
if (wc.CNT_Tough > pkm.CNT_Tough) return false;
if (wc.CNT_Sheen > pkm.CNT_Sheen) return false;
return true;
}
private static bool GetIsMatchWC6(PKM pkm, WC6 wc, IEnumerable<DexLevel> vs)
{
if (pkm.Egg_Location == 0) // Not Egg
{
if (wc.CardID != pkm.SID) return false;
if (wc.TID != pkm.TID) return false;
Rework mysterygift pkm sprite generation don't bother converting to pkm then generating the sprite off that; use the overload with int/bool removes sav/pkm dependency for generating gift descriptions, and standardizes the names a little. maybe a PKMBase interface would be useful...
2017-11-18 19:34:23 +00:00
if (wc.OT_Name != pkm.OT_Name) return false;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (wc.OTGender != pkm.OT_Gender) return false;
if (wc.PIDType == 0 && pkm.PID != wc.PID) return false;
if (wc.PIDType == 2 && !pkm.IsShiny) return false;
if (wc.PIDType == 3 && pkm.IsShiny) return false;
if (wc.OriginGame != 0 && wc.OriginGame != pkm.Version) return false;
if (wc.EncryptionConstant != 0 && wc.EncryptionConstant != pkm.EncryptionConstant) return false;
if (wc.Language != 0 && wc.Language != pkm.Language) return false;
}
FormChange check: use original form not current form Closes #1758 noticing the different usage for species (encounter species vs current), iterating over possible dexlevels (unnecessary?)
2018-01-13 20:10:17 +00:00
if (wc.Form != pkm.AltForm && vs.All(dl => !IsFormChangeable(pkm, dl.Species, wc.Form))) return false;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (wc.IsEgg)
{
if (wc.EggLocation != pkm.Egg_Location && pkm.Egg_Location != 30002) // traded
return false;
if (pkm.IsEgg && !pkm.IsNative)
return false;
}
else
{
if (wc.EggLocation != pkm.Egg_Location) return false;
if (wc.MetLocation != pkm.Met_Location) return false;
}
if (wc.Level != pkm.Met_Level) return false;
if (wc.Ball != pkm.Ball) return false;
if (wc.OTGender < 3 && wc.OTGender != pkm.OT_Gender) return false;
if (wc.Nature != 0xFF && wc.Nature != pkm.Nature) return false;
if (wc.Gender != 3 && wc.Gender != pkm.Gender) return false;
if (wc.CNT_Cool > pkm.CNT_Cool) return false;
if (wc.CNT_Beauty > pkm.CNT_Beauty) return false;
if (wc.CNT_Cute > pkm.CNT_Cute) return false;
if (wc.CNT_Smart > pkm.CNT_Smart) return false;
if (wc.CNT_Tough > pkm.CNT_Tough) return false;
if (wc.CNT_Sheen > pkm.CNT_Sheen) return false;
return true;
}
private static bool GetIsMatchWC7(PKM pkm, WC7 wc, IEnumerable<DexLevel> vs)
{
if (pkm.Egg_Location == 0) // Not Egg
{
if (wc.OTGender != 3)
{
if (wc.SID != pkm.SID) return false;
if (wc.TID != pkm.TID) return false;
if (wc.OTGender != pkm.OT_Gender) return false;
}
Rework mysterygift pkm sprite generation don't bother converting to pkm then generating the sprite off that; use the overload with int/bool removes sav/pkm dependency for generating gift descriptions, and standardizes the names a little. maybe a PKMBase interface would be useful...
2017-11-18 19:34:23 +00:00
if (!string.IsNullOrEmpty(wc.OT_Name) && wc.OT_Name != pkm.OT_Name) return false;
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (wc.OriginGame != 0 && wc.OriginGame != pkm.Version) return false;
if (wc.EncryptionConstant != 0 && wc.EncryptionConstant != pkm.EncryptionConstant) return false;
if (wc.Language != 0 && wc.Language != pkm.Language) return false;
}
FormChange check: use original form not current form Closes #1758 noticing the different usage for species (encounter species vs current), iterating over possible dexlevels (unnecessary?)
2018-01-13 20:10:17 +00:00
if (wc.Form != pkm.AltForm && vs.All(dl => !IsFormChangeable(pkm, dl.Species, wc.Form)))
Add rockruff event evo edge case different altform IDs
2017-11-17 04:59:16 +00:00
{
if (wc.Species == 744 && wc.Form == 1 && pkm.Species == 745 && pkm.AltForm == 2)
{
// Rockruff gift edge case; has altform 1 then evolves to altform 2
}
else
return false;
}
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (wc.IsEgg)
{
if (wc.EggLocation != pkm.Egg_Location && pkm.Egg_Location != 30002) // traded
return false;
if (pkm.IsEgg && !pkm.IsNative)
return false;
}
else
{
if (wc.EggLocation != pkm.Egg_Location) return false;
if (wc.MetLocation != pkm.Met_Location) return false;
}
if (wc.MetLevel != pkm.Met_Level) return false;
if (wc.Ball != pkm.Ball) return false;
if (wc.OTGender < 3 && wc.OTGender != pkm.OT_Gender) return false;
if (wc.Nature != 0xFF && wc.Nature != pkm.Nature) return false;
if (wc.Gender != 3 && wc.Gender != pkm.Gender) return false;
if (wc.CNT_Cool > pkm.CNT_Cool) return false;
if (wc.CNT_Beauty > pkm.CNT_Beauty) return false;
if (wc.CNT_Cute > pkm.CNT_Cute) return false;
if (wc.CNT_Smart > pkm.CNT_Smart) return false;
if (wc.CNT_Tough > pkm.CNT_Tough) return false;
if (wc.CNT_Sheen > pkm.CNT_Sheen) return false;
if (wc.PIDType == 2 && !pkm.IsShiny) return false;
if (wc.PIDType == 3 && pkm.IsShiny) return false;
Invert PCD return value on match Result of refactoring and manually flipping all the returns Closes #1421
2017-08-26 00:29:14 +00:00
block ash greninja from USUM game origin should really be part of a 'receivable by game' check; not doing any more of these edge cases. need card hash -> permit bits for future cases.
2017-11-22 16:24:54 +00:00
switch (wc.CardID)
more rockruff 1 handling y u do dis gf Closes #1630
2017-11-19 04:08:11 +00:00
{
block ash greninja from USUM game origin should really be part of a 'receivable by game' check; not doing any more of these edge cases. need card hash -> permit bits for future cases.
2017-11-22 16:24:54 +00:00
case 1624: // Rockruff
if (pkm.Species == 745 && pkm.AltForm != 2)
return false;
if (pkm.Version == (int)GameVersion.US)
return wc.Move3 == 424; // Fire Fang
if (pkm.Version == (int)GameVersion.UM)
return wc.Move3 == 422; // Thunder Fang
more rockruff 1 handling y u do dis gf Closes #1630
2017-11-19 04:08:11 +00:00
return false;
block ash greninja from USUM game origin should really be part of a 'receivable by game' check; not doing any more of these edge cases. need card hash -> permit bits for future cases.
2017-11-22 16:24:54 +00:00
case 2046: // Ash Greninja
return pkm.SM; // not USUM
more rockruff 1 handling y u do dis gf Closes #1630
2017-11-19 04:08:11 +00:00
}
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
return true;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
// EncounterEgg
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static IEnumerable<EncounterEgg> GenerateEggs(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (NoHatchFromEgg.Contains(pkm.Species))
yield break;
Update wild/egg generators for totem cases so wonky edge cases
2017-11-14 16:43:04 +00:00
if (FormConverter.IsTotemForm(pkm.Species, pkm.AltForm, pkm.GenNumber))
yield break; // no totem eggs
Add gen6+ link trade egg edge case slakoth with play rough with x/y version why u modify game origin when hatched???
2017-09-29 00:11:30 +00:00
int gen = pkm.GenNumber;
// version is a true indicator for all generation 3-5 origins
var ver = (GameVersion) pkm.Version;
int max = GetMaxSpeciesOrigin(gen);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Don't generate egg encounters if species cant exist Closes #1286
2017-06-30 03:12:40 +00:00
var baseSpecies = GetBaseSpecies(pkm, 0);
Add gen6+ link trade egg edge case slakoth with play rough with x/y version why u modify game origin when hatched???
2017-09-29 00:11:30 +00:00
int lvl = gen < 4 ? 5 : 1;
Don't generate egg encounters if species cant exist Closes #1286
2017-06-30 03:12:40 +00:00
if (baseSpecies <= max)
Add gen6+ link trade egg edge case slakoth with play rough with x/y version why u modify game origin when hatched???
2017-09-29 00:11:30 +00:00
{
Don't generate egg encounters if species cant exist Closes #1286
2017-06-30 03:12:40 +00:00
yield return new EncounterEgg { Game = ver, Level = lvl, Species = baseSpecies };
Add gen6+ link trade egg edge case slakoth with play rough with x/y version why u modify game origin when hatched???
2017-09-29 00:11:30 +00:00
if (gen > 5 && pkm.WasTradedEgg)
yield return new EncounterEgg { Game = tradePair(), Level = lvl, Species = baseSpecies };
}
Don't generate egg encounters if species cant exist Closes #1286
2017-06-30 03:12:40 +00:00
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
if (!GetSplitBreedGeneration(pkm).Contains(pkm.Species))
Refactoring Flag Korean Ranger Manaphy (never distributed) extract pk1 catch rate verification
2017-08-31 04:30:07 +00:00
yield break; // no other possible species
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
baseSpecies = GetBaseSpecies(pkm, 1);
if (baseSpecies <= max)
Add gen6+ link trade egg edge case slakoth with play rough with x/y version why u modify game origin when hatched???
2017-09-29 00:11:30 +00:00
{
Don't generate egg encounters if species cant exist Closes #1286
2017-06-30 03:12:40 +00:00
yield return new EncounterEgg { Game = ver, Level = lvl, Species = baseSpecies, SplitBreed = true };
Add gen6+ link trade egg edge case slakoth with play rough with x/y version why u modify game origin when hatched???
2017-09-29 00:11:30 +00:00
if (gen > 5 && pkm.WasTradedEgg)
yield return new EncounterEgg { Game = tradePair(), Level = lvl, Species = baseSpecies, SplitBreed = true };
}
// Gen6+ update the origin game when hatched. Quick manip for X.Y<->A.O | S.M<->US.UM, ie X->A
Fix tradepair calculation (link trade eggs) returned invalid pair values for gen7 due to 2 unused game IDs between the gen6&gen7 pairs
2017-11-29 17:21:17 +00:00
GameVersion tradePair()
{
if (ver <= GameVersion.OR) // gen6
return (GameVersion)((int)ver ^ 2);
if (ver <= GameVersion.MN) // gen7
return ver + 2;
return ver - 2;
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
// Utility
Add manaphy egg PIDIV check slightly different from hatched in that it can't be shiny as an egg as the ID/SID doesn't change until hatched. move Ranger check to utility
2017-07-06 00:47:48 +00:00
private static bool IsRangerManaphy(PKM pkm)
{
var egg = pkm.Egg_Location;
const int ranger = 3001;
const int linkegg = 2002;
if (!pkm.IsEgg) // Link Trade Egg or Ranger
return egg == linkegg || egg == ranger;
if (egg != ranger)
return false;
var met = pkm.Met_Location;
return met == linkegg || met == 0;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static bool IsHiddenAbilitySlot(EncounterSlot slot)
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
{
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
return slot.Permissions.DexNav || slot.Type == SlotType.FriendSafari || slot.Type == SlotType.Horde || slot.Type == SlotType.SOS;
Rework encounter slot generating Closes #1171 Calculate rejection scenarios, store rejected slots to spit out at the end rather than returning them early.
2017-05-28 18:10:01 +00:00
}
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
internal static bool IsSafariSlot(SlotType t)
{
Switch slottype to flags simplifies some logic, adds some documentation, speeds up loading very slightly
2017-11-04 00:14:18 +00:00
return t.HasFlag(SlotType.Safari);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
internal static bool IsDexNavValid(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
if (!pkm.AO || !pkm.InhabitedGeneration(6))
return false;
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
var vs = GetValidPreEvolutions(pkm);
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
IEnumerable<EncounterArea> locs = GetDexNavAreas(pkm);
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
var d_areas = locs.Select(loc => GetValidEncounterSlots(pkm, loc, vs, DexNav: true));
Refactoring Extract mystery gift matching criteria into separate method
2017-08-24 17:09:34 +00:00
return d_areas.Any(slots => slots.Any(slot => slot.Permissions.AllowDexNav && slot.Permissions.DexNav));
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
Move encountertype deferral to main generator gen4->gen5/6 electrode will match static & wild slots, but deferral only defers within the same IEncounterable group.
2017-10-22 16:42:15 +00:00
private static bool IsEncounterTypeMatch(IEncounterable e, int type)
{
switch (e)
{
case EncounterStaticTyped t:
return t.TypeEncounter.Contains(type);
case EncounterSlot w:
return w.TypeEncounter.Contains(type);
default:
return type == 0;
}
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
internal static EncounterArea GetCaptureLocation(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
var vs = GetValidPreEvolutions(pkm);
Remove double encounter slot species filtering GetValid already filters by species move some common non-location code out of the method; can be done for the dexlevel fetching too -- future improvement.
2017-11-19 20:41:23 +00:00
return (from area in GetEncounterSlots(pkm)
move evochain fetch outside of location iterator also relocate gen12 code so it only runs for gen12
2017-11-19 23:26:41 +00:00
let slots = GetValidEncounterSlots(pkm, area, vs, DexNav: pkm.AO, ignoreLevel: true).ToArray()
Refactoring de-linq some areas where direct accessing is possible (list/array)
2017-12-05 04:16:54 +00:00
where slots.Length != 0
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
select new EncounterArea
{
Location = area.Location,
Slots = slots,
}).OrderBy(area => area.Slots.Min(x => x.LevelMin)).FirstOrDefault();
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
internal static EncounterStatic GetStaticLocation(PKM pkm, int species = -1)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
switch (pkm.GenNumber)
{
case 1:
Simplify vc transfer checks supply met level so the static encounter has a level to work with instead of 0 Closes #1316 in other areas: level 48 charizard VC1 transfer changed to mewtwo causes minlvl > maxlevel, handle instead of throwing exception.
2017-07-09 15:47:17 +00:00
return GetRBYStaticTransfer(species, pkm.Met_Level);
case 2:
return GetGSStaticTransfer(species, pkm.Met_Level);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
default:
Refactor level-evolution checks slightly Allows evolution met level check to be skipped Adds minimum level constraint for evolution chain generating Closes #1430 also adds deferral to the gen3 encounter generator as encounterstatic gifts can collide with wild encounters when transferred
2017-08-29 01:12:57 +00:00
var table = GetEncounterStaticTable(pkm, (GameVersion)pkm.Version);
return GetStatic(pkm, table, lvl: 100, skip: true).FirstOrDefault();
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
}
}
Add VC transfer checks checks were previously only performed when finding the encounter, once found, the GB encounter was validated. the transfer encounter is derived after all encounter checks, thus remaining unchecked (really, only for Locations). Move generating logic to the generator, and double check the locations are valid. #1535 Thanks @DJPanda065 !
2017-10-21 04:07:15 +00:00
internal static bool IsVCStaticTransferEncounterValid(PKM pkm, EncounterStatic e)
{
return pkm.Met_Location == e.Location && pkm.Egg_Location == e.EggLocation;
}
internal static IEncounterable GetVCStaticTransferEncounter(PKM pkm)
{
if (pkm.VC1)
return GetRBYStaticTransfer(pkm.Species, pkm.Met_Level);
Add flagging for crystal transfers users should know better but best to know allow gen2 female when from crystal
2017-11-25 02:19:16 +00:00
if (pkm.VC2 && (pkm.Version != (int)GameVersion.C || AllowGen2VCCrystal))
Add VC transfer checks checks were previously only performed when finding the encounter, once found, the GB encounter was validated. the transfer encounter is derived after all encounter checks, thus remaining unchecked (really, only for Locations). Move generating logic to the generator, and double check the locations are valid. #1535 Thanks @DJPanda065 !
2017-10-21 04:07:15 +00:00
return GetGSStaticTransfer(pkm.Species, pkm.Met_Level);
return new EncounterInvalid(pkm);
}
private static EncounterStatic GetRBYStaticTransfer(int species, int pkmMetLevel)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
return new EncounterStatic
{
Species = species,
Gift = true, // Forces Poké Ball
Ability = TransferSpeciesDefaultAbility_1.Contains(species) ? 1 : 4, // Hidden by default, else first
Shiny = species == 151 ? (bool?)false : null,
Fateful = species == 151,
misc tweaks pull out transfer locations to const references add vc2 & crown beast/celebi met location suggesting add vc2 crystal sensitive detection add 2 more usum trainer stats (thanks holla!)
2017-11-23 05:45:30 +00:00
Location = Transfer1,
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
EggLocation = 0,
IV3 = true,
Simplify vc transfer checks supply met level so the static encounter has a level to work with instead of 0 Closes #1316 in other areas: level 48 charizard VC1 transfer changed to mewtwo causes minlvl > maxlevel, handle instead of throwing exception.
2017-07-09 15:47:17 +00:00
Level = pkmMetLevel,
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
Version = GameVersion.RBY
};
}
Add VC transfer checks checks were previously only performed when finding the encounter, once found, the GB encounter was validated. the transfer encounter is derived after all encounter checks, thus remaining unchecked (really, only for Locations). Move generating logic to the generator, and double check the locations are valid. #1535 Thanks @DJPanda065 !
2017-10-21 04:07:15 +00:00
private static EncounterStatic GetGSStaticTransfer(int species, int pkmMetLevel)
Add more gen2 hypothetical handling won't be active until VC2 release
2017-06-10 22:48:12 +00:00
{
return new EncounterStatic
{
Species = species,
Gift = true, // Forces Poké Ball
Ability = TransferSpeciesDefaultAbility_2.Contains(species) ? 1 : 4, // Hidden by default, else first
Shiny = species == 151 || species == 251 ? (bool?)false : null,
Fateful = species == 151 || species == 251,
misc tweaks pull out transfer locations to const references add vc2 & crown beast/celebi met location suggesting add vc2 crystal sensitive detection add 2 more usum trainer stats (thanks holla!)
2017-11-23 05:45:30 +00:00
Location = Transfer2,
Add more gen2 hypothetical handling won't be active until VC2 release
2017-06-10 22:48:12 +00:00
EggLocation = 0,
IV3 = true,
Simplify vc transfer checks supply met level so the static encounter has a level to work with instead of 0 Closes #1316 in other areas: level 48 charizard VC1 transfer changed to mewtwo causes minlvl > maxlevel, handle instead of throwing exception.
2017-07-09 15:47:17 +00:00
Level = pkmMetLevel,
Add more gen2 hypothetical handling won't be active until VC2 release
2017-06-10 22:48:12 +00:00
Version = GameVersion.GS
};
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
internal static bool IsEncounterTrade1Valid(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
string ot = pkm.OT_Name;
string tr = pkm.Format <= 2 ? "TRAINER" : "Trainer"; // decaps on transfer
return ot == "トレーナー" || ot == tr;
}
Refactoring mostly renaming things, includes a little bit of added sugar and splitting methods to simplify the codebase. all methods are now PascalCase
2017-06-18 01:37:19 +00:00
private static bool IsWurmpleEvoValid(PKM pkm)
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
{
Fix wurmple evo gen3/4 yeah it was never the lowest 16 bits as every-internet-source claims. 1D9C9130 silcoon => 3716[8] = cascoon (nope) #1330 was correct!
2017-07-17 22:58:09 +00:00
uint evoVal = PKX.GetWurmpleEvoVal(pkm.EncryptionConstant);
Refactor encounter matching exercise in deferred execution/state machine, only calculate possible matches until a sufficiently valid match is obtained. Previous setup would try to calculate the 'best match' and had band-aid workarounds in cases where a subsequent check may determine it to be a false match. There's still more ways to improve speed: - precalculate relationships for Encounter Slots rather than iterating over every area - yielding individual slots instead of an entire area - group non-egg wondercards by ID in a dict/hashtable for faster retrieval reworked some internals: - EncounterMatch is always an IEncounterable instead of an object, for easy pattern matching. - Splitbreed checking is done per encounter and is stored in the EncounterEgg result - Encounter validation uses Encounter/Move/RelearnMove/Evolution to whittle to the final encounter. As a part of the encounter matching, a lazy peek is used to check if an invalid encounter should be retained instead of discarded; if another encounter has not been checked, it'll stop the invalid checks and move on. If it is the last encounter, no other valid encounters exist so it will keep the parse for the invalid encounter. If no encounters are yielded, then there is no encountermatch. An EncounterInvalid is created to store basic details, and the parse is carried out. Breaks some legality checking features for flagging invalid moves in more detail, but those can be re-added in a separate check (if splitbreed & any move invalid -> check for other split moves). Should now be easier to follow the flow & maintain :smile:
2017-05-28 04:17:53 +00:00
int wIndex = Array.IndexOf(WurmpleEvolutions, pkm.Species) / 2;
return evoVal == wIndex;
}
}
}
Reference in a new issue Copy permalink