private static bool GetIsValidTradeVC1(PKM pkm, EncounterTrade z)
{
if (z.Level > pkm.CurrentLevel) // minimum required level
{
return(false);
}
if (pkm.Format != 1 || !pkm.Gen1_NotTradeback)
{
return(true);
}
// 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;
if (z is EncounterTradeCatchRate r)
{
if (rate != r.Catch_Rate)
{
return(false);
}
}
else
{
if (z.Version == GameVersion.YW && rate != PersonalTable.Y[z.Species].CatchRate)
{
return(false);
}
if (z.Version != GameVersion.YW && rate != PersonalTable.RB[z.Species].CatchRate)
{
return(false);
}
}
return(true);
}
private void VerifyTrade5(LegalityAnalysis data, EncounterTrade t)
{
var pkm = data.pkm;
int lang = pkm.Language;
// Trades for JPN games have language ID of 0, not 1.
if (pkm.BW)
{
if (pkm.Format == 5 && lang == (int)LanguageID.Japanese)
{
data.AddLine(GetInvalid(string.Format(LOTLanguage, 0, LanguageID.Japanese), CheckIdentifier.Language));
}
lang = Math.Max(lang, 1);
VerifyTrade(data, t, lang);
}
else // B2W2
{
if (t.TID == Encounters5.YancyTID || t.TID == Encounters5.CurtisTID)
{
VerifyTradeOTOnly(data, t);
}
else
{
VerifyTrade(data, t, lang);
}
}
}
private static void VerifyTrade(LegalityAnalysis data, EncounterTrade t, int language)
{
var ot = t.GetOT(language);
var nick = t.GetNickname(language);
VerifyTradeOTNick(data, t, nick, ot);
}
private static bool GetIsValidTradeVC2(PKM pkm, EncounterTrade z)
{
if (z.Level > pkm.CurrentLevel) // minimum required level
{
return(false);
}
if (z.TID != pkm.TID)
{
return(false);
}
if (z.Gender >= 0 && z.Gender != pkm.Gender && pkm.Format <= 2)
{
return(false);
}
if (z.IVs?.SequenceEqual(pkm.IVs) == false && pkm.Format <= 2)
{
return(false);
}
if (pkm.Met_Location != 0 && pkm.Format == 2 && pkm.Met_Location != 126)
{
return(false);
}
return(IsValidTradeOT12(z, pkm));
}
private void VerifyTrade3(LegalityAnalysis data, EncounterTrade t)
{
var pkm = data.pkm;
int lang = pkm.Language;
if (t.Species == 124) // FRLG Jynx
{
lang = DetectTradeLanguageG3DANTAEJynx(pkm, lang);
}
VerifyTrade(data, t, lang);
}
private void VerifyTrade12(LegalityAnalysis data, EncounterTrade t)
{
if (t.TID != 0) // Gen2 Trade
{
return; // already checked all relevant properties when fetching with getValidEncounterTradeVC2
}
if (!EncounterGenerator.IsEncounterTrade1Valid(data.pkm, t))
{
data.AddLine(GetInvalid(LEncTradeChangedOT, CheckIdentifier.Trainer));
}
}
private static CheckResult VerifyEncounter(PKM pkm, LegalInfo info)
{
return(info.EncounterMatch switch
{
EncounterEgg _ => VerifyEncounterEgg(pkm),
EncounterTrade t => VerifyEncounterTrade(pkm, t),
EncounterSlot w => VerifyEncounterWild(pkm, w),
EncounterStatic s => VerifyEncounterStatic(pkm, s),
MysteryGift g => VerifyEncounterEvent(pkm, g),
_ => new CheckResult(Severity.Invalid, LEncInvalid, CheckIdentifier.Encounter)
});
private static CheckResult VerifyEncounterTrade(PKM pkm, EncounterTrade trade)
{
if (trade.EvolveOnTrade && trade.Species == pkm.Species)
{
// Pokemon that evolve on trade can not be in the phase evolution after the trade
// If the trade holds an everstone EvolveOnTrade will be false for the encounter
var species = LegalityAnalysis.SpeciesStrings;
var unevolved = species[pkm.Species];
var evolved = species[pkm.Species + 1];
return(new CheckResult(Severity.Invalid, string.Format(LEvoTradeReq, unevolved, evolved), CheckIdentifier.Encounter));
}
return(new CheckResult(Severity.Valid, LEncTradeMatch, CheckIdentifier.Encounter));
}
private static void VerifyTrade12(LegalityAnalysis data, EncounterTrade t)
{
var t1 = (EncounterTrade1)t;
if (!t1.IsNicknameValid(data.pkm))
{
data.AddLine(GetInvalid(LEncTradeChangedNickname, CheckIdentifier.Nickname));
}
if (!t1.IsTrainerNameValid(data.pkm))
{
data.AddLine(GetInvalid(LEncTradeChangedOT, CheckIdentifier.Trainer));
}
}
private static void VerifyTrade(LegalityAnalysis data, EncounterTrade t, int language)
{
var ot = t.GetOT(language);
var nick = t.GetNickname(language);
if (string.IsNullOrEmpty(nick))
{
VerifyTradeOTOnly(data, t);
}
else
{
VerifyTradeOTNick(data, t, nick, ot);
}
}
private static int DetectTradeLanguage(string OT, EncounterTrade t, int currentLanguageID)
{
var names = t.TrainerNames;
for (int lang = 1; lang < names.Length; lang++)
{
if (names[lang] != OT)
{
continue;
}
return(lang);
}
return(currentLanguageID);
}
public static bool GetCanOTHandle(IEncounterable enc, PKM pkm, int gen)
{
if (gen < 6)
{
return(true);
}
return(enc switch
{
EncounterTrade _ => false,
WC6 wc6 when wc6.OT_Name.Length > 0 => false,
WC7 wc7 when wc7.OT_Name.Length > 0 && wc7.TID != 18075 => false, // Ash Pikachu QR Gift doesn't set Current Handler
WC8 wc8 when wc8.GetHasOT(pkm.Language) => false,
_ => true
});
private static void VerifyTradeOTNick(LegalityAnalysis data, EncounterTrade t, string nick, string OT)
{
var pkm = data.pkm;
// trades that are not nicknamed (but are present in a table with others being named)
var result = IsNicknameMatch(nick, pkm, t)
? GetValid(LEncTradeUnchanged, CheckIdentifier.Nickname)
: Get(LEncTradeChangedNickname, ParseSettings.NicknamedTrade, CheckIdentifier.Nickname);
data.AddLine(result);
if (OT != pkm.OT_Name)
{
data.AddLine(GetInvalid(LEncTradeChangedOT, CheckIdentifier.Trainer));
}
}
private static int DetectTradeLanguageG4MeisterMagikarp(PKM pkm, EncounterTrade t, int currentLanguageID)
{
if (currentLanguageID == (int)LanguageID.English)
{
return((int)LanguageID.German);
}
// All have German, regardless of origin version.
var lang = DetectTradeLanguage(pkm.OT_Name, t, currentLanguageID);
if (lang == (int)LanguageID.English) // possible collision with FR/ES/DE. Check nickname
{
return(pkm.Nickname == t.Nicknames[(int)LanguageID.French] ? (int)LanguageID.French : (int)LanguageID.Spanish); // Spanish is same as English
}
return(lang);
}
private static bool GetCanOTHandle(LegalityAnalysis data)
{
var Info = data.Info;
if (Info.Generation < 6)
{
return(true);
}
return(Info.EncounterMatch switch
{
EncounterTrade _ => false,
WC6 wc6 when wc6.OT_Name.Length > 0 => false,
WC7 wc7 when wc7.OT_Name.Length > 0 && wc7.TID != 18075 => false, // Ash Pikachu QR Gift doesn't set Current Handler
WC8 wc8 when wc8.GetHasOT(data.pkm.Language) => false,
_ => true
});
private void VerifyNicknameTrade(LegalityAnalysis data, EncounterTrade t)
{
switch (data.Info.Generation)
{
case 1:
case 2: VerifyTrade12(data, t); return;
case 3: VerifyTrade3(data, t); return;
case 4: VerifyTrade4(data, t); return;
case 5: VerifyTrade5(data, t); return;
case 6:
case 7: VerifyTrade(data, t, data.pkm.Language); return;
}
}
private static bool GetIsValidTradeVC2(PKM pkm, EncounterTrade z)
{
if (z.Level > pkm.CurrentLevel) // minimum required level
{
return(false);
}
if (z.TID != pkm.TID)
{
return(false);
}
if (z.Gender >= 0 && z.Gender != pkm.Gender && pkm.Format <= 2)
{
return(false);
}
if (z.IVs != null && !z.IVs.SequenceEqual(pkm.IVs) && pkm.Format <= 2)
{
return(false);
}
if (pkm.Met_Location != 0 && pkm.Format == 2 && pkm.Met_Location != 126)
{
return(false);
}
int index = Array.IndexOf(Encounters2.TradeGift_GSC, z);
int otIndex = Encounters2.TradeGift_GSC.Length + index;
bool valid;
if (pkm.Japanese)
{
valid = Encounters2.TradeGift_GSC_OTs[(int)LanguageID.Japanese][otIndex] == pkm.OT_Name;
}
else if (pkm.Korean)
{
valid = Encounters2.TradeGift_GSC_OTs[(int)LanguageID.Korean][otIndex] == pkm.OT_Name;
}
else
{
valid = Array.FindIndex(Encounters2.TradeGift_GSC_OTs, 2, 6, arr => arr.Length > index && arr[otIndex] == pkm.OT_Name) >= 0;
}
if (!valid)
{
return(false);
}
return(true);
}
private static int DetectTradeLanguageG4SurgePikachu(PKM pkm, EncounterTrade t, int currentLanguageID)
{
if (currentLanguageID == (int)LanguageID.French)
{
return((int)LanguageID.English);
}
// All have English, regardless of origin version.
var lang = DetectTradeLanguage(pkm.OT_Name, t, currentLanguageID);
if (lang == 2) // possible collision with ES/IT. Check nickname
{
return(pkm.Nickname == t.Nicknames[(int)LanguageID.Italian] ? (int)LanguageID.Italian : (int)LanguageID.Spanish);
}
return(lang);
}
private static bool IsValidTradeOT12(EncounterTrade z, PKM pkm)
{
var OT = pkm.OT_Name;
if (pkm.Japanese)
{
return(z.TrainerNames[(int)LanguageID.Japanese] == OT);
}
if (pkm.Korean)
{
return(z.TrainerNames[(int)LanguageID.Korean] == OT);
}
const int start = (int)LanguageID.English;
const int end = (int)LanguageID.Italian;
var index = Array.FindIndex(z.TrainerNames, start, end - start, w => w == OT);
return(index >= 0);
}
private void VerifyNicknameTrade(LegalityAnalysis data, EncounterTrade t)
{
switch (data.Info.Generation)
{
case 1: VerifyTrade12(data, t); return;
case 2: return; // already checked all relevant properties when fetching with getValidEncounterTradeVC2
case 3: VerifyTrade3(data, t); return;
case 4: VerifyTrade4(data, t); return;
case 5: VerifyTrade5(data, t); return;
case 6:
case 7:
case 8:
VerifyTrade(data, t, data.pkm.Language); return;
}
}
private void VerifyTrade4(LegalityAnalysis data, EncounterTrade t)
{
var pkm = data.pkm;
if (pkm.TID == 1000)
{
VerifyTradeOTOnly(data, t);
return;
}
int lang = pkm.Language;
switch (t.Species)
{
case (int)Species.Pikachu: // HGSS Pikachu
lang = DetectTradeLanguageG4SurgePikachu(pkm, t, lang);
// flag korean on gen4 saves since the pkm.Language is German
FlagKoreanIncompatibleSameGenTrade(data, pkm, lang);
break;
case (int)Species.Magikarp: // DPPt Magikarp
lang = DetectTradeLanguageG4MeisterMagikarp(pkm, t, lang);
// flag korean on gen4 saves since the pkm.Language is German
FlagKoreanIncompatibleSameGenTrade(data, pkm, lang);
break;
default:
if (lang == 1 && (pkm.Version == (int)GameVersion.D || pkm.Version == (int)GameVersion.P))
{
// DP English origin are Japanese lang
if (pkm.OT_Name != t.TrainerNames[1]) // not japanese
{
lang = 2; // English
}
}
break;
}
VerifyTrade(data, t, lang);
}
private static bool IsEncounterTradeValid(PKM pkm, EncounterTrade z, int lvl)
{
if (z.IVs != null)
{
for (int i = 0; i < 6; i++)
{
if (z.IVs[i] != -1 && z.IVs[i] != pkm.IVs[i])
{
return(false);
}
}
}
if (z is EncounterTradePID p)
{
if (p.PID != pkm.EncryptionConstant)
{
return(false);
}
if (z.Nature != Nature.Random && (int)z.Nature != pkm.Nature) // gen5 BW only
{
return(false);
}
}
else
{
if (!z.Shiny.IsValid(pkm))
{
return(false);
}
if (z.Nature != Nature.Random && (int)z.Nature != pkm.Nature)
{
return(false);
}
if (z.Gender != -1 && z.Gender != pkm.Gender)
{
return(false);
}
}
if (z.TID != pkm.TID)
{
return(false);
}
if (z.SID != pkm.SID)
{
return(false);
}
if (pkm.HasOriginalMetLocation)
{
var loc = z.Location > 0 ? z.Location : EncounterTrade.DefaultMetLocation[z.Generation - 1];
if (loc != pkm.Met_Location)
{
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);
}
if (z.CurrentLevel != -1 && z.CurrentLevel > pkm.CurrentLevel)
{
return(false);
}
if (z.Form != pkm.AltForm && !IsFormChangeable(pkm, pkm.Species))
{
return(false);
}
if (z.OTGender != -1 && z.OTGender != pkm.OT_Gender)
{
return(false);
}
if (z.EggLocation != pkm.Egg_Location)
{
return(false);
}
// if (z.Ability == 4 ^ pkm.AbilityNumber == 4) // defer to Ability
// countinue;
if (!z.Version.Contains((GameVersion)pkm.Version))
{
return(false);
}
if (pkm is IContestStats s && s.IsContestBelow(z))
{
return(false);
}
return(true);
}
private static void VerifyTradeOTOnly(LegalityAnalysis data, EncounterTrade t)
{
var result = CheckTradeOTOnly(data, t.TrainerNames);
data.AddLine(result);
}
internal static EncounterTrade getValidIngameTrade(PKM pkm)
{
if (!pkm.WasIngameTrade)
{
return(null);
}
int lang = pkm.Language;
if (lang == 0 || lang == 6)
{
return(null);
}
// Get valid pre-evolutions
IEnumerable <DexLevel> p = getValidPreEvolutions(pkm);
EncounterTrade[] table = null;
if (pkm.XY)
{
table = TradeGift_XY;
}
if (pkm.AO)
{
table = TradeGift_AO;
}
if (pkm.SM)
{
table = TradeGift_SM;
}
EncounterTrade z = table?.FirstOrDefault(f => p.Any(r => r.Species == f.Species));
if (z == null)
{
return(null);
}
for (int i = 0; i < 6; i++)
{
if (z.IVs[i] != -1 && z.IVs[i] != pkm.IVs[i])
{
return(null);
}
}
if (z.Shiny ^ pkm.IsShiny) // Are PIDs static?
{
return(null);
}
if (z.TID != pkm.TID)
{
return(null);
}
if (z.SID != pkm.SID)
{
return(null);
}
if (z.Location != pkm.Met_Location)
{
return(null);
}
if (z.Level != pkm.Met_Level)
{
return(null);
}
if (z.Nature != Nature.Random && (int)z.Nature != pkm.Nature)
{
return(null);
}
if (z.Gender != pkm.Gender)
{
return(null);
}
if (z.OTGender != -1 && z.OTGender != pkm.OT_Gender)
{
return(null);
}
// if (z.Ability == 4 ^ pkm.AbilityNumber == 4) // defer to Ability
// return null;
return(z);
}
