337 lines
14 KiB
C#
337 lines
14 KiB
C#
using PkmnLib.Dynamic.AI.Explicit;
|
|
using PkmnLib.Plugin.Gen7.Libraries.Battling;
|
|
using PkmnLib.Plugin.Gen7.Scripts.Side;
|
|
using PkmnLib.Static.Moves;
|
|
|
|
namespace PkmnLib.Plugin.Gen7.AI;
|
|
|
|
public static class AIHelperFunctions
|
|
{
|
|
public static int GetScoreForTargetStatRaise(int score, AIMoveState move, IPokemon target,
|
|
StatisticSet<sbyte> statChanges, bool fixedChange = false, bool ignoreContrary = false)
|
|
{
|
|
var wholeEffect = move.Move.Category != MoveCategory.Status;
|
|
|
|
var desireMult = 1;
|
|
if (move.User.BattleData?.SideIndex != target.BattleData?.SideIndex)
|
|
desireMult = -1;
|
|
|
|
if (!ignoreContrary && !fixedChange && target.ActiveAbility?.Name == "contrary")
|
|
{
|
|
if (desireMult > 0 && wholeEffect)
|
|
{
|
|
return ExplicitAI.MoveUselessScore;
|
|
}
|
|
return GetScoreForTargetStatDrop(move, target, statChanges, fixedChange, true);
|
|
}
|
|
|
|
var addEffect = move.GetScoreChangeForAdditionalEffect(target);
|
|
if (addEffect == -999)
|
|
{
|
|
return score;
|
|
}
|
|
var expectedEndOfTurnDamage = 0;
|
|
target.RunScriptHook<IAIInfoScriptExpectedEndOfTurnDamage>(x =>
|
|
x.ExpectedEndOfTurnDamage(target, ref expectedEndOfTurnDamage));
|
|
// If the target is expected to faint from the end of turn damage, we don't want to
|
|
// apply the score for the stat raise, as it will not be able to use it.
|
|
if (expectedEndOfTurnDamage >= target.CurrentHealth)
|
|
return wholeEffect ? ExplicitAI.MoveUselessScore : score;
|
|
|
|
if (!move.User.HasMoveWithEffect("power_trip"))
|
|
{
|
|
var foeIsAware = target.BattleData?.BattleSide.Pokemon.Any(x => x?.ActiveAbility?.Name == "unaware") !=
|
|
true;
|
|
if (!foeIsAware)
|
|
{
|
|
return wholeEffect ? ExplicitAI.MoveUselessScore : score;
|
|
}
|
|
}
|
|
var realStatChanges = new StatBoostStatisticSet();
|
|
foreach (var (stat, i) in statChanges)
|
|
{
|
|
var increment = i;
|
|
if (!IsStatRaiseWorthwhile(target, stat, increment, fixedChange))
|
|
{
|
|
continue;
|
|
}
|
|
if (!fixedChange && target.ActiveAbility?.Name == "simple")
|
|
{
|
|
increment *= 2;
|
|
}
|
|
increment = (sbyte)Math.Max(increment,
|
|
StatBoostStatisticSet.MaxStatBoost - target.StatBoost.GetStatistic(stat));
|
|
realStatChanges.SetStatistic(stat, increment);
|
|
}
|
|
if (realStatChanges.IsEmpty)
|
|
{
|
|
return wholeEffect ? ExplicitAI.MoveUselessScore : score;
|
|
}
|
|
|
|
score += addEffect;
|
|
score = GetTargetStatRaiseScoreGeneric(score, target, realStatChanges, move, desireMult);
|
|
|
|
foreach (var realStatChange in realStatChanges.Where(x => x.value > 0))
|
|
{
|
|
GetTargetStatRaiseScoreOne(ref score, target, realStatChange.statistic, realStatChange.value, move,
|
|
desireMult);
|
|
}
|
|
return score;
|
|
}
|
|
|
|
public static int GetScoreForTargetStatDrop(AIMoveState move, IPokemon target, StatisticSet<sbyte> statChanges,
|
|
bool fixedChange = false, bool ignoreContrary = false) =>
|
|
throw new NotImplementedException("This method is not implemented");
|
|
|
|
/// <summary>
|
|
/// Checks if a stat raise is worthwhile for the given Pokémon and stat.
|
|
/// </summary>
|
|
private static bool IsStatRaiseWorthwhile(IPokemon pokemon, Statistic stat, sbyte amount, bool fixedChange = false)
|
|
{
|
|
if (!fixedChange && pokemon.StatBoost.GetStatistic(stat) == StatBoostStatisticSet.MaxStatBoost)
|
|
return false;
|
|
if (!pokemon.HasMoveWithEffect("power_trip", "baton_pass"))
|
|
return true;
|
|
|
|
switch (stat)
|
|
{
|
|
case Statistic.Attack:
|
|
{
|
|
if (!pokemon.Moves.WhereNotNull().Any(x => x.MoveData.Category == MoveCategory.Physical &&
|
|
x.MoveData.SecondaryEffect?.Name != "foul_play"))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.Defense:
|
|
{
|
|
var opponentSide = pokemon.BattleData!.Battle.Sides.First(x => x != pokemon.BattleData.BattleSide);
|
|
return opponentSide.Pokemon.WhereNotNull().Any(x => x.Moves.WhereNotNull().Any(y =>
|
|
y.MoveData.Category == MoveCategory.Physical || y.MoveData.SecondaryEffect?.Name == "psyshock"));
|
|
}
|
|
case Statistic.SpecialAttack:
|
|
{
|
|
if (pokemon.Moves.WhereNotNull().All(x => x.MoveData.Category != MoveCategory.Special))
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.SpecialDefense:
|
|
{
|
|
var opponentSide = pokemon.BattleData!.Battle.Sides.First(x => x != pokemon.BattleData.BattleSide);
|
|
return opponentSide.Pokemon.WhereNotNull().Any(x => x.Moves.WhereNotNull().Any(y =>
|
|
y.MoveData.Category == MoveCategory.Special && y.MoveData.SecondaryEffect?.Name != "psyshock"));
|
|
}
|
|
case Statistic.Speed:
|
|
{
|
|
if (!pokemon.HasMoveWithEffect("electro_ball", "power_trip"))
|
|
{
|
|
var targetSpeed = pokemon.BoostedStats.Speed;
|
|
var opponentSide = pokemon.BattleData!.Battle.Sides.First(x => x != pokemon.BattleData.BattleSide);
|
|
var meaningful = opponentSide.Pokemon.WhereNotNull().Select(opponent => opponent.BoostedStats.Speed)
|
|
.Any(foeSpeed => targetSpeed < foeSpeed && targetSpeed * 2.5 > foeSpeed);
|
|
if (!meaningful)
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.Accuracy:
|
|
{
|
|
var minAccuracy = pokemon.Moves.WhereNotNull().Min(x => x.MoveData.Accuracy);
|
|
if (minAccuracy >= 90 && pokemon.StatBoost.Accuracy >= 0)
|
|
{
|
|
var meaningful = false;
|
|
var opponentSide = pokemon.BattleData!.Battle.Sides.First(x => x != pokemon.BattleData.BattleSide);
|
|
if (opponentSide.Pokemon.WhereNotNull().Any(x => x.StatBoost.Evasion > 0))
|
|
{
|
|
meaningful = true;
|
|
}
|
|
if (!meaningful)
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static void GetTargetStatRaiseScoreOne(ref int score, IPokemon target, Statistic stat, sbyte increment,
|
|
AIMoveState move, float desireMult = 1)
|
|
{
|
|
var oldStage = target.StatBoost.GetStatistic(stat);
|
|
var newStage = (sbyte)(oldStage + increment);
|
|
var incMult = Gen7BattleStatCalculator.GetStatBoostModifier(Math.Min(newStage, (sbyte)6)) /
|
|
Gen7BattleStatCalculator.GetStatBoostModifier(oldStage);
|
|
var actualIncrement = incMult;
|
|
incMult -= 1;
|
|
incMult *= desireMult;
|
|
var opponentSide = target.BattleData!.Battle.Sides.First(x => x != target.BattleData.BattleSide);
|
|
|
|
switch (stat)
|
|
{
|
|
case Statistic.Attack:
|
|
{
|
|
if (oldStage >= 2 && increment == 1)
|
|
score -= (int)(10 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
else
|
|
{
|
|
var hasSpecialMoves = target.Moves.WhereNotNull()
|
|
.Any(x => x.MoveData.Category == MoveCategory.Special);
|
|
var inc = hasSpecialMoves ? 8 : 12;
|
|
score += (int)(inc * incMult);
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.Defense:
|
|
{
|
|
if (oldStage >= 2 && increment == 1)
|
|
score -= (int)(10 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
else
|
|
score += (int)(10 * incMult);
|
|
break;
|
|
}
|
|
case Statistic.SpecialAttack:
|
|
{
|
|
if (oldStage >= 2 && increment == 1)
|
|
score -= (int)(10 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
else
|
|
{
|
|
var hasPhysicalMoves = target.Moves.WhereNotNull().Any(x =>
|
|
x.MoveData.Category == MoveCategory.Physical &&
|
|
x.MoveData.SecondaryEffect?.Name != "foul_play");
|
|
var inc = hasPhysicalMoves ? 8 : 12;
|
|
score += (int)(inc * incMult);
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.SpecialDefense:
|
|
{
|
|
if (oldStage >= 2 && increment == 1)
|
|
score -= (int)(10 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
else
|
|
score += (int)(10 * incMult);
|
|
break;
|
|
}
|
|
case Statistic.Speed:
|
|
{
|
|
var targetSpeed = target.BoostedStats.Speed;
|
|
foreach (var opponent in opponentSide.Pokemon.WhereNotNull())
|
|
{
|
|
var foeSpeed = opponent.BoostedStats.Speed;
|
|
if (foeSpeed <= targetSpeed)
|
|
continue;
|
|
if (foeSpeed > targetSpeed * 2.5)
|
|
continue;
|
|
if (targetSpeed * actualIncrement > foeSpeed)
|
|
score += (int)(15 * incMult);
|
|
else
|
|
score += (int)(8 * incMult);
|
|
}
|
|
if (target.HasMoveWithEffect("electro_ball", "power_trip"))
|
|
{
|
|
score += (int)(5 * incMult);
|
|
}
|
|
if (opponentSide.Pokemon.WhereNotNull().Any(x => x.HasMoveWithEffect("gyro_ball")))
|
|
{
|
|
score -= (int)(5 * incMult);
|
|
}
|
|
if (target.ActiveAbility?.Name == "speed_boost")
|
|
{
|
|
score -= (int)(15 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.Accuracy:
|
|
{
|
|
if (oldStage >= 2 && increment == 1)
|
|
{
|
|
score -= (int)(10 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
}
|
|
else
|
|
{
|
|
var minAccuracy = target.Moves.WhereNotNull().Min(x => x.MoveData.Accuracy);
|
|
var previousMinAccuracy =
|
|
minAccuracy * Gen7BattleStatCalculator.GetAccuracyEvasionStatModifier(0, oldStage);
|
|
if (previousMinAccuracy < 90)
|
|
{
|
|
score += (int)(10 * incMult);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case Statistic.Evasion:
|
|
{
|
|
foreach (var opponent in opponentSide.Pokemon.WhereNotNull())
|
|
{
|
|
var endOfTurnDamage = 0;
|
|
opponent.RunScriptHook<IAIInfoScriptExpectedEndOfTurnDamage>(x =>
|
|
x.ExpectedEndOfTurnDamage(opponent, ref endOfTurnDamage));
|
|
if (endOfTurnDamage > 0)
|
|
score += (int)(5 * incMult);
|
|
}
|
|
if (oldStage >= 2 && increment == 1)
|
|
{
|
|
score -= (int)(10 * (target.Opposes(move.User) ? 1 : desireMult));
|
|
}
|
|
else
|
|
{
|
|
score += (int)(10 * incMult);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (target.HasMoveWithEffect("power_trip"))
|
|
{
|
|
score += (int)(5 * increment * desireMult);
|
|
}
|
|
if (opponentSide.Pokemon.WhereNotNull().Any(x => x.HasMoveWithEffect("punishment")))
|
|
{
|
|
score -= (int)(5 * increment * desireMult);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the score for the generic concept of raising a target's stats.
|
|
/// </summary>
|
|
private static int GetTargetStatRaiseScoreGeneric(int score, IPokemon target, StatisticSet<sbyte> statChanges,
|
|
AIMoveState move, float desireMult = 1)
|
|
{
|
|
var totalIncrement = statChanges.Sum(x => x.value);
|
|
var turns = target.BattleData!.Battle.CurrentTurnNumber - target.BattleData!.SwitchInTurn;
|
|
if (turns < 2 && move.Move.Category == MoveCategory.Status)
|
|
score += (int)(totalIncrement * desireMult * 5);
|
|
|
|
score +=
|
|
(int)(totalIncrement * desireMult * ((100 * (target.CurrentHealth / (float)target.MaxHealth) - 50) / 8));
|
|
return score;
|
|
}
|
|
|
|
private static int GetScoreChangeForAdditionalEffect(this AIMoveState move, IPokemon? target)
|
|
{
|
|
if (move.Move.SecondaryEffect is null)
|
|
return 0;
|
|
if (move.User.ActiveAbility?.Name == "sheer_force")
|
|
return -999;
|
|
if (target is not null && target.BattleData?.Position != move.User.BattleData?.Position &&
|
|
target.ActiveAbility?.Name == "shield_dust")
|
|
return -999;
|
|
|
|
if ((move.Move.SecondaryEffect.Chance < 100 && move.User.ActiveAbility?.Name == "serene_grace") ||
|
|
move.User.BattleData?.BattleSide.VolatileScripts.Contains<RainbowEffect>() == true)
|
|
{
|
|
return 5;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private static bool HasMoveWithEffect(this IPokemon pokemon, params StringKey[] effect)
|
|
{
|
|
return pokemon.Moves.WhereNotNull().Any(move => move.MoveData.SecondaryEffect?.Name is not null &&
|
|
effect.Contains(move.MoveData.SecondaryEffect.Name));
|
|
}
|
|
|
|
private static bool Opposes(this IPokemon pokemon, IPokemon target) =>
|
|
pokemon.BattleData?.BattleSide != target.BattleData?.BattleSide;
|
|
} |