public static void CanLearnEggMoveBDSP(Species species, Move move)
{
MoveEgg.GetEggMoves(8, (int)species, 0, GameVersion.BD).Contains((int)move).Should().BeFalse();
var pb8 = new PB8 {
Species = (int)species
};
var encs = EncounterMovesetGenerator.GenerateEncounters(pb8, new[] { (int)move }, GameVersion.BD);
encs.Any().Should().BeFalse("Unavailable until HOME update supports BD/SP.");
}
public void SimulatorParseEncounter(string text)
{
var set = new ShowdownSet(text);
var pk7 = new PK7 {
Species = set.Species, AltForm = set.FormIndex, Moves = set.Moves, CurrentLevel = set.Level
};
var encs = EncounterMovesetGenerator.GenerateEncounters(pk7, set.Moves);
var tr3 = encs.First(z => z is EncounterTrade t && t.Generation == 3);
var pk3 = tr3.ConvertToPKM(new SAV3());
var la = new LegalityAnalysis(pk3);
la.Valid.Should().BeTrue();
}
public void SimulatorGetSmeargle()
{
var set = new ShowdownSet(SetSmeargle);
var pk7 = new PK7 {
Species = set.Species, Form = set.Form, Moves = set.Moves
};
var encs = EncounterMovesetGenerator.GenerateEncounters(pk7, set.Moves, GameVersion.MN);
Assert.True(encs.Any());
encs = EncounterMovesetGenerator.GenerateEncounters(pk7, set.Moves, GameVersion.MN);
var first = encs.FirstOrDefault();
Assert.NotNull(first);
var enc = first !;
var info = new SimpleTrainerInfo(GameVersion.SN);
var pk = enc.ConvertToPKM(info);
var la = new LegalityAnalysis(pk);
Assert.True(la.Valid);
}
private static bool InnerBruteForce(PKM pk, GameVersion game, bool shiny, int abilitynum, ShowdownSet set)
{
pk.ClearRelearnMoves();
switch (game)
{
case GameVersion.RD:
case GameVersion.BU:
case GameVersion.YW:
case GameVersion.GN:
pk.Met_Location = 30013;
pk.Met_Level = 100;
break;
case GameVersion.GD:
case GameVersion.SV:
case GameVersion.C:
pk.Met_Location = 30017;
pk.Met_Level = 100;
break;
case GameVersion.CXD:
pk.Met_Location = 30001;
pk.Met_Level = 100;
break;
default:
pk.SetSuggestedMetLocation();
break;
}
pk.SetSuggestedRelearnMoves();
pk.CurrentHandler = 1;
pk.HT_Name = "Archit";
pk.PID = PKX.GetRandomPID(pk.Species, pk.Gender, pk.Version, pk.Nature, pk.Format,
(uint)(pk.AbilityNumber * 0x10001));
if (shiny)
{
pk.SetShiny();
}
if (pk.PID == 0)
{
pk.PID = PKX.GetRandomPID(pk.Species, pk.Gender, pk.Version, pk.Nature, pk.Format,
(uint)(pk.AbilityNumber * 0x10001));
if (shiny)
{
pk.SetShiny();
}
}
pk.RefreshAbility(abilitynum);
pk.SetSuggestedMemories();
if (pk.GenNumber < 6)
{
pk.EncryptionConstant = pk.PID;
}
if (CommonErrorHandling2(pk))
{
pk.HyperTrain();
if (shiny)
{
pk.SetShiny();
}
return(true);
}
pk.HyperTrain();
bool legalized = new LegalityAnalysis(pk).Valid;
AlternateAbilityRefresh(pk);
if (pk.GenNumber < 6 && !legalized)
{
pk.EncryptionConstant = pk.PID;
}
if (new LegalityAnalysis(pk).Valid&& pk.Format >= pk.GenNumber)
{
pk.SetHappiness();
if (shiny && pk.IsShiny)
{
return(true);
}
if (!set.Shiny || pk.IsShiny)
{
return(true);
}
pk.SetShinySID();
if (new LegalityAnalysis(pk).Valid)
{
return(true);
}
pk.SetShiny();
if (new LegalityAnalysis(pk).Valid)
{
return(true);
}
}
else
{
var edge = EncounterMovesetGenerator.GenerateEncounters(pk).OfType <EncounterStatic>();
foreach (EncounterStatic el in edge)
{
ApplyEncounterAttributes(pk, set, el);
var la = new LegalityAnalysis(pk);
if (la.Valid)
{
return(true);
}
Debug.WriteLine(la.Report());
}
}
return(false);
}
/// <summary>
/// Main function that auto legalizes based on the legality
/// </summary>
/// <remarks>Leverages <see cref="Core"/>'s <see cref="EncounterMovesetGenerator"/> to create a <see cref="PKM"/> from a <see cref="IBattleTemplate"/>.</remarks>
/// <param name="dest">Destination for the generated pkm</param>
/// <param name="template">rough pkm that has all the <see cref="set"/> values entered</param>
/// <param name="set">Showdown set object</param>
/// <param name="satisfied">If the final result is legal or not</param>
public static PKM GetLegalFromTemplate(this ITrainerInfo dest, PKM template, IBattleTemplate set, out LegalizationResult satisfied)
{
RegenSet regen;
if (set is RegenTemplate t)
{
t.FixGender(template.PersonalInfo);
regen = t.Regen;
}
else
{
regen = RegenSet.Default;
}
template.ApplySetDetails(set);
template.SetRecordFlags(); // Validate TR moves for the encounter
var isHidden = template.AbilityNumber == 4;
if (template.PersonalInfo.Abilities.Count > 2) // Hidden ability exists for the template
{
isHidden = isHidden || template.PersonalInfo.Abilities[2] == template.Ability;
}
var destType = template.GetType();
var destVer = (GameVersion)dest.Game;
if (destVer <= 0 && dest is SaveFile s)
{
destVer = s.Version;
}
var timer = Stopwatch.StartNew();
var gamelist = FilteredGameList(template, destVer);
var encounters = EncounterMovesetGenerator.GenerateEncounters(pk: template, moves: set.Moves, gamelist);
var criteria = EncounterCriteria.GetCriteria(set);
foreach (var enc in encounters)
{
// Return out if set times out
if (timer.Elapsed.TotalSeconds >= Timeout)
{
timer.Stop();
satisfied = LegalizationResult.Timeout;
return(template);
}
// Look before we leap -- don't waste time generating invalid / incompatible junk.
if (!IsEncounterValid(set, enc, isHidden, destVer))
{
continue;
}
// Create the PKM from the template.
var tr = GetTrainer(regen, enc.Version, enc.Generation);
var raw = enc.ConvertToPKM(tr, criteria);
raw = raw.SanityCheckLocation(enc);
if (raw.IsEgg) // PGF events are sometimes eggs. Force hatch them before proceeding
{
raw.HandleEggEncounters(enc, tr);
}
raw.PreSetPIDIV(enc, set);
// Transfer any VC1 via VC2, as there may be GSC exclusive moves requested.
if (dest.Generation >= 7 && raw is PK1 basepk1)
{
raw = basepk1.ConvertToPK2();
}
// Bring to the target generation, then apply final details.
var pk = PKMConverter.ConvertToType(raw, destType, out _);
if (pk == null)
{
continue;
}
ApplySetDetails(pk, set, raw, dest, enc, regen);
// Apply final tweaks to the data.
if (pk is IGigantamax gmax && gmax.CanGigantamax != set.CanGigantamax)
{
if (!gmax.CanToggleGigantamax(pk.Species, pk.Form, enc.Species, enc.Form))
{
continue;
}
gmax.CanGigantamax = set.CanGigantamax; // soup hax
}
// Try applying batch editor values.
if (AllowBatchCommands && regen.HasBatchSettings)
{
pk.RefreshChecksum();
var b = regen.Batch;
if (!BatchEditing.TryModify(pk, b.Filters, b.Instructions))
{
continue;
}
}
if (pk is PK1 pk1 && ParseSettings.AllowGen1Tradeback)
{
pk1.Catch_Rate = pk1.Gen2Item; // Simulate a gen 2 trade/tradeback to allow tradeback moves
}
// Verify the Legality of what we generated, and exit if it is valid.
var la = new LegalityAnalysis(pk);
if (la.Valid)
{
satisfied = LegalizationResult.Regenerated;
return(pk);
}
Debug.WriteLine($"{la.Report()}\n");
}
satisfied = LegalizationResult.Failed;
return(template);
}
public static string SetAnalysis(this RegenTemplate set, SaveFile sav)
{
var species_name = SpeciesName.GetSpeciesNameGeneration(set.Species, (int)LanguageID.English, sav.Generation);
var analysis = set.Form == 0 ? string.Format(SPECIES_UNAVAILABLE, species_name)
: string.Format(SPECIES_UNAVAILABLE_FORM, species_name, set.FormName);
// Species checks
var gv = (GameVersion)sav.Game;
if (!gv.ExistsInGame(set.Species, set.Form))
{
return(analysis); // Species does not exist in the game
}
// Species exists -- check if it has atleast one move. If it has no moves and it didn't generate, that makes the mon still illegal in game (moves are set to legal ones)
var moves = set.Moves.Where(z => z != 0);
var count = moves.Count();
// Reusable data
var blank = sav.BlankPKM;
var batchedit = APILegality.AllowBatchCommands && set.Regen.HasBatchSettings;
var destVer = (GameVersion)sav.Game;
if (destVer <= 0)
{
destVer = sav.Version;
}
var gamelist = APILegality.FilteredGameList(blank, destVer, batchedit ? set.Regen.Batch.Filters : null);
// Move checks
List <IEnumerable <int> > move_combinations = new();
for (int i = count; i >= 1; i--)
{
move_combinations.AddRange(GetKCombs(moves, i));
}
int[] original_moves = new int[4];
set.Moves.CopyTo(original_moves, 0);
int[] successful_combination = GetValidMoves(set, sav, move_combinations, blank, gamelist);
if (!new HashSet <int>(original_moves.Where(z => z != 0)).SetEquals(successful_combination))
{
var invalid_moves = string.Join(", ", original_moves.Where(z => !successful_combination.Contains(z) && z != 0).Select(z => $"{(Move)z}"));
return(successful_combination.Length > 0 ? string.Format(INVALID_MOVES, species_name, invalid_moves) : ALL_MOVES_INVALID);
}
set.Moves = original_moves;
// All moves possible, get encounters
blank.ApplySetDetails(set);
blank.SetRecordFlags();
var encounters = EncounterMovesetGenerator.GenerateEncounters(pk: blank, moves: original_moves, gamelist);
if (set.Regen.EncounterFilters != null)
{
encounters = encounters.Where(enc => BatchEditing.IsFilterMatch(set.Regen.EncounterFilters, enc));
}
// Level checks, check if level is impossible to achieve
if (encounters.All(z => !APILegality.IsRequestedLevelValid(set, z)))
{
return(string.Format(LEVEL_INVALID, species_name, encounters.Min(z => z.LevelMin)));
}
encounters = encounters.Where(enc => APILegality.IsRequestedLevelValid(set, enc));
// Ability checks
var abilityreq = APILegality.GetRequestedAbility(blank, set);
if (abilityreq == AbilityRequest.NotHidden && encounters.All(z => z is EncounterStatic {
Ability: 4
}))