346 lines
15 KiB
C#
346 lines
15 KiB
C#
using PkmnLib.Dynamic.BattleFlow;
|
|
using PkmnLib.Dynamic.Libraries;
|
|
using PkmnLib.Dynamic.Models;
|
|
using PkmnLib.Dynamic.Models.Choices;
|
|
using PkmnLib.Dynamic.ScriptHandling;
|
|
using PkmnLib.Static.Moves;
|
|
using PkmnLib.Static.Utils;
|
|
|
|
namespace PkmnLib.Dynamic.AI.Explicit;
|
|
|
|
/// <summary>
|
|
/// An explicit AI that has explicitly written logic for each Pokémon and move.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This is heavily based on the AI used in <a href="https://github.com/Maruno17/pokemon-essentials">Pokémon Essentials</a>
|
|
/// </remarks>
|
|
public class ExplicitAI : PokemonAI
|
|
{
|
|
public const int MoveFailScore = 20;
|
|
public const int MoveUselessScore = 60;
|
|
public const int MoveBaseScore = 100;
|
|
|
|
private const float TrainerSkill = 100; // TODO: This should be configurable
|
|
private bool CanPredictMoveFailure => true; // TODO: This should be configurable
|
|
private bool ScoreMoves => true; // TODO: This should be configurable
|
|
|
|
private float MoveScoreThreshold => (float)(0.6f + 0.35f * Math.Sqrt(Math.Min(TrainerSkill, 100) / 100f));
|
|
|
|
private readonly IReadOnlyExplicitAIHandlers _handlers;
|
|
|
|
private readonly IRandom _random = new RandomImpl();
|
|
|
|
/// <inheritdoc />
|
|
public ExplicitAI(IDynamicLibrary library) : base("explicit")
|
|
{
|
|
_handlers = library.ExplicitAIHandlers;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public override ITurnChoice GetChoice(IBattle battle, IPokemon pokemon)
|
|
{
|
|
if (battle.HasForcedTurn(pokemon, out var choice))
|
|
return choice;
|
|
var moveChoices = GetMoveScores(pokemon, battle);
|
|
if (moveChoices.Count == 0)
|
|
{
|
|
var opponentSide = (byte)(pokemon.BattleData!.SideIndex == 0 ? 1 : 0);
|
|
return battle.Library.MiscLibrary.ReplacementChoice(pokemon, opponentSide, pokemon.BattleData.Position);
|
|
}
|
|
var maxScore = moveChoices.Max(x => x.score);
|
|
// TODO: Consider switching to a different pokémon if the score is too low
|
|
|
|
var threshold = (float)Math.Floor(maxScore * MoveScoreThreshold);
|
|
var considerChoices = moveChoices.Select(x => (x, Math.Max(x.score - threshold, 0))).ToArray();
|
|
var totalScore = considerChoices.Sum(x => x.Item2);
|
|
if (totalScore == 0)
|
|
{
|
|
var opponentSide = (byte)(pokemon.BattleData!.SideIndex == 0 ? 1 : 0);
|
|
return battle.Library.MiscLibrary.ReplacementChoice(pokemon, opponentSide, pokemon.BattleData.Position);
|
|
}
|
|
var initialRandomValue = _random.GetFloat(0, totalScore);
|
|
var randomValue = initialRandomValue;
|
|
for (var i = 0; i < considerChoices.Length; i++)
|
|
{
|
|
randomValue -= considerChoices[i].Item2;
|
|
if (randomValue >= 0)
|
|
continue;
|
|
|
|
var (index, _, targetIndex) = considerChoices[i].x;
|
|
var learnedMove = pokemon.Moves[index];
|
|
var opponentSide = (byte)(pokemon.BattleData!.SideIndex == 0 ? 1 : 0);
|
|
if (targetIndex == -1)
|
|
targetIndex = pokemon.BattleData.Position;
|
|
return new MoveChoice(pokemon, learnedMove!, opponentSide, (byte)targetIndex);
|
|
}
|
|
throw new InvalidOperationException("No valid move choice found. This should not happen.");
|
|
}
|
|
|
|
private List<(int index, int score, int targetIndex)> GetMoveScores(IPokemon user, IBattle battle)
|
|
{
|
|
var choices = new List<(int index, int score, int targetIndex)>();
|
|
foreach (var (learnedMove, index) in user.Moves.Select((x, i) => (x, i)).Where(x => x.x != null))
|
|
{
|
|
var moveChoice = new MoveChoice(user, learnedMove!, 0, 0);
|
|
if (!battle.CanUse(moveChoice))
|
|
{
|
|
if (learnedMove!.CurrentPp == 0 && learnedMove.MaxPp > 0)
|
|
{
|
|
AILogging.LogInformation($"{user} cannot use {learnedMove} because it has no PP left.");
|
|
}
|
|
else
|
|
{
|
|
AILogging.LogInformation($"{user} cannot use {learnedMove} because it is not a valid choice.");
|
|
}
|
|
continue;
|
|
}
|
|
var moveData = learnedMove!.MoveData;
|
|
var moveName = moveData.Name;
|
|
moveChoice.RunScriptHook<IScriptChangeMove>(x => x.ChangeMove(moveChoice, ref moveName));
|
|
if (moveName != learnedMove.MoveData.Name)
|
|
{
|
|
AILogging.LogInformation($"{user} changed {learnedMove} to {moveName}.");
|
|
if (!battle.Library.StaticLibrary.Moves.TryGet(moveName, out moveData))
|
|
throw new InvalidOperationException($"Move {moveName} not found in the move library.");
|
|
var secondaryEffect = moveData.SecondaryEffect;
|
|
if (secondaryEffect != null)
|
|
{
|
|
if (moveChoice.User.Library.ScriptResolver.TryResolve(ScriptCategory.Move, secondaryEffect.Name,
|
|
secondaryEffect.Parameters, out var script))
|
|
{
|
|
moveChoice.Script.Set(script);
|
|
script.OnAddedToParent(moveChoice);
|
|
}
|
|
else
|
|
{
|
|
moveChoice.Script.Clear();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
moveChoice.Script.Clear();
|
|
}
|
|
}
|
|
var aiMove = new AIMoveState(user, moveData);
|
|
if (CanPredictMoveFailure && PredictMoveFailure(user, battle, aiMove))
|
|
{
|
|
AILogging.LogInformation($"{user} is considering {aiMove.Move.Name} but it will fail.");
|
|
AddMoveToChoices(index, MoveFailScore);
|
|
}
|
|
|
|
var target = moveData.Target;
|
|
if (target is MoveTarget.All or MoveTarget.AllAlly or MoveTarget.AllOpponent or MoveTarget.SelfUse)
|
|
{
|
|
var score = GetMoveScore(user, aiMove, battle);
|
|
AddMoveToChoices(index, score);
|
|
}
|
|
else if (target is MoveTarget.AdjacentOpponent or MoveTarget.Any or MoveTarget.Adjacent
|
|
or MoveTarget.AdjacentAllySelf)
|
|
{
|
|
// TODO: get redirected target
|
|
foreach (var pokemon in battle.Sides.SelectMany(x => x.Pokemon).WhereNotNull())
|
|
{
|
|
var battleData = pokemon.BattleData;
|
|
if (battleData == null)
|
|
continue;
|
|
if (!TargetResolver.IsValidTarget(battleData.SideIndex, battleData.Position, target, user))
|
|
continue;
|
|
if (target.TargetsFoe() && battleData.SideIndex == user.BattleData?.SideIndex)
|
|
{
|
|
continue;
|
|
}
|
|
var score = GetMoveScoreAgainstTarget(user, aiMove, pokemon, battle);
|
|
AddMoveToChoices(index, score, battleData.Position);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var targets = new List<IPokemon>();
|
|
foreach (var pokemon in battle.Sides.SelectMany(x => x.Pokemon).WhereNotNull())
|
|
{
|
|
var battleData = pokemon.BattleData;
|
|
if (battleData == null)
|
|
continue;
|
|
if (!TargetResolver.IsValidTarget(battleData.SideIndex, battleData.Position, target, user))
|
|
continue;
|
|
if (target.TargetsFoe() && battleData.SideIndex == user.BattleData?.SideIndex)
|
|
{
|
|
continue;
|
|
}
|
|
targets.Add(pokemon);
|
|
}
|
|
var score = GetMoveScore(user, aiMove, battle, targets);
|
|
AddMoveToChoices(index, score);
|
|
}
|
|
}
|
|
return choices;
|
|
|
|
void AddMoveToChoices(int index, int score, int targetIndex = -1)
|
|
{
|
|
choices.Add((index, score, targetIndex));
|
|
// If the user is a wild Pokémon, doubly prefer a random move.
|
|
if (battle.IsWildBattle && user.PersonalityValue % user.Moves.Count == index)
|
|
{
|
|
choices.Add((index, score, targetIndex));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool PredictMoveFailure(IPokemon user, IBattle battle, AIMoveState aiMove)
|
|
{
|
|
if (user.HasStatus("sleep"))
|
|
{
|
|
// User is asleep, and will not wake up, and the move is not usable while asleep.
|
|
if (user.GetStatusTurnsLeft != 0 && !aiMove.Move.HasFlag("usable_while_asleep"))
|
|
{
|
|
AILogging.LogInformation($"{user} is asleep and cannot use {aiMove.Move.Name}.");
|
|
return true;
|
|
}
|
|
}
|
|
// The move is only usable while asleep, but the user is not asleep
|
|
else if (aiMove.Move.HasFlag("usable_while_asleep"))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Primal weather
|
|
if (battle.WeatherName == "primordial_sea" && aiMove.Move.MoveType.Name == "fire")
|
|
return true;
|
|
if (battle.WeatherName == "desolate_lands" && aiMove.Move.MoveType.Name == "water")
|
|
return true;
|
|
|
|
// Check if the move will fail based on the handlers
|
|
return aiMove.Move.SecondaryEffect != null &&
|
|
_handlers.MoveWillFail(aiMove.Move.SecondaryEffect.Name, new MoveOption(aiMove, battle, null));
|
|
}
|
|
|
|
private static readonly StringKey PsychicTerrainName = new("psychic_terrain");
|
|
private static readonly StringKey DazzlingName = new("dazzling");
|
|
private static readonly StringKey QueenlyMajestyName = new("queenly_majesty");
|
|
private static readonly StringKey PranksterName = new("prankster");
|
|
private static readonly StringKey DarkName = new("dark");
|
|
private static readonly StringKey GroundName = new("ground");
|
|
private static readonly StringKey PowderName = new("powder");
|
|
private static readonly StringKey SubstituteName = new("substitute");
|
|
private static readonly StringKey InfiltratorName = new("infiltrator");
|
|
|
|
private bool PredictMoveFailureAgainstTarget(IPokemon user, AIMoveState aiMove, IPokemon target, IBattle battle)
|
|
{
|
|
if (aiMove.Move.SecondaryEffect != null && _handlers.MoveWillFailAgainstTarget(aiMove.Move.SecondaryEffect.Name,
|
|
new MoveOption(aiMove, battle, target)))
|
|
return true;
|
|
if (aiMove.Move.Priority > 0)
|
|
{
|
|
if (target.BattleData?.SideIndex != user.BattleData?.SideIndex)
|
|
{
|
|
// Psychic Terrain makes all priority moves fail if the target is affected
|
|
if (battle.TerrainName == PsychicTerrainName && !target.IsFloating)
|
|
{
|
|
return true;
|
|
}
|
|
// Dazzling and Queenly Majesty prevent priority moves from being used against the Pokémon with those abilities
|
|
if (target.BattleData?.BattleSide.Pokemon.WhereNotNull().Any(x =>
|
|
x.ActiveAbility?.Name == DazzlingName || x.ActiveAbility?.Name == QueenlyMajestyName) == true)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
// TODO: Check immunity because of ability
|
|
|
|
var moveType = aiMove.Move.MoveType;
|
|
var typeEffectiveness = battle.Library.StaticLibrary.Types.GetEffectiveness(moveType, target.Types);
|
|
if (aiMove.Move.Category != MoveCategory.Status && typeEffectiveness == 0)
|
|
return true;
|
|
if (user.ActiveAbility?.Name == PranksterName && aiMove.Move.Category == MoveCategory.Status &&
|
|
target.Types.Any(x => x.Name == DarkName) && target.BattleData?.SideIndex != user.BattleData?.SideIndex)
|
|
return true;
|
|
if (aiMove.Move.Category != MoveCategory.Status && moveType.Name == GroundName && target.IsFloating)
|
|
return true;
|
|
if (aiMove.Move.HasFlag(PowderName) && !AffectedByPowder(target))
|
|
return true;
|
|
if (target.Volatile.Contains(SubstituteName) && aiMove.Move.Category == MoveCategory.Status &&
|
|
user.ActiveAbility?.Name != InfiltratorName)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private int GetMoveScore(IPokemon user, AIMoveState aiMove, IBattle battle, IReadOnlyList<IPokemon>? targets = null)
|
|
{
|
|
var score = MoveBaseScore;
|
|
if (targets != null)
|
|
{
|
|
score = 0;
|
|
var affectedTargets = 0;
|
|
foreach (var target in targets)
|
|
{
|
|
var targetScore = GetMoveScoreAgainstTarget(user, aiMove, target, battle);
|
|
if (targetScore < 0)
|
|
continue;
|
|
score += targetScore;
|
|
affectedTargets++;
|
|
}
|
|
if (affectedTargets == 0 && CanPredictMoveFailure)
|
|
{
|
|
return MoveFailScore;
|
|
}
|
|
if (affectedTargets > 0)
|
|
score = (int)(score / (float)affectedTargets);
|
|
}
|
|
if (ScoreMoves)
|
|
{
|
|
if (aiMove.Move.SecondaryEffect != null)
|
|
{
|
|
_handlers.ApplyMoveEffectScore(aiMove.Move.SecondaryEffect.Name, new MoveOption(aiMove, battle, null),
|
|
ref score);
|
|
_handlers.ApplyGenerateMoveScoreModifiers(new MoveOption(aiMove, battle, null), ref score);
|
|
}
|
|
}
|
|
if (score < 0)
|
|
score = 0;
|
|
return score;
|
|
}
|
|
|
|
private int GetMoveScoreAgainstTarget(IPokemon user, AIMoveState aiMove, IPokemon target, IBattle battle)
|
|
{
|
|
if (CanPredictMoveFailure && PredictMoveFailureAgainstTarget(user, aiMove, target, battle))
|
|
{
|
|
AILogging.LogInformation($"{user} is considering {aiMove.Move.Name} against {target} but it will fail.");
|
|
return -1;
|
|
}
|
|
var score = MoveBaseScore;
|
|
if (ScoreMoves && aiMove.Move.SecondaryEffect != null)
|
|
{
|
|
var estimatedDamage = AIHelpers.CalculateDamageEstimation(aiMove.Move, user, target, battle.Library);
|
|
var moveOption = new MoveOption(aiMove, battle, target, estimatedDamage);
|
|
_handlers.ApplyMoveEffectAgainstTargetScore(aiMove.Move.SecondaryEffect.Name, moveOption, ref score);
|
|
_handlers.ApplyGenerateMoveAgainstTargetScoreModifiers(moveOption, ref score);
|
|
}
|
|
|
|
if (aiMove.Move.Target.TargetsFoe() && target.BattleData?.SideIndex == user.BattleData?.SideIndex &&
|
|
target.BattleData?.Position != user.BattleData?.Position)
|
|
{
|
|
if (score == MoveUselessScore)
|
|
return -1;
|
|
score = (int)(1.85f * MoveBaseScore - score);
|
|
}
|
|
|
|
return score;
|
|
}
|
|
|
|
private static readonly StringKey GrassName = new("grass");
|
|
private static readonly StringKey OvercoatName = new("overcoat");
|
|
private static readonly StringKey SafetyGogglesName = new("safety_goggles");
|
|
|
|
private static bool AffectedByPowder(IPokemon pokemon)
|
|
{
|
|
if (pokemon.Types.Any(x => x.Name == GrassName))
|
|
return false;
|
|
if (pokemon.ActiveAbility?.Name == OvercoatName)
|
|
return false;
|
|
if (pokemon.HasHeldItem(SafetyGogglesName))
|
|
return false;
|
|
return true;
|
|
}
|
|
} |