Implement SOR.Ai Phase 2: decision engines, candidate generator, heuristic scoring
Phase 2.3 — Random & Heuristic engines: - IAiDecisionEngine interface + AiAction discriminated union (Draw, PlayCard, Move, Attack, Sacrifice, Ascend, EndTurn) - AiDifficultyProfile / AiDifficultyProfiles: in-code profiles for tiers 1–10 with timing, mistake rates, and scoring weights - RandomDecisionEngine: picks random legal action each step (Difficulty 1 — Novice) - HeuristicDecisionEngine: greedy loop with JSON-clone simulation + mistake injection (Difficulties 2–10) Phase 2.4 — ActionCandidateGenerator: - Enumerates all legal moves: Spirit/Terramorpha/Ruin/Repentance/Instinct channelings, movement (Walk/Flight/Jump/Teleport), attacks, sacrifices, ascends - Delegates range/path/affinity logic to SOR.Game.Grid (Pathfinding, AttackSystem, AffinitySystem) Phase 2.5 — Heuristic scoring: - ScoringFunctions.Evaluate: material, affinity control, threat, positional, resource weights - ThreatDetector: counts enemy units that can reach AI ArchSpirit (with move-into-range lookahead) AiPlayerSession wired to select engine by difficulty profile, submit full action plan with humanized think/action delays, and catch GameException gracefully per action. Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>
This commit is contained in:
@@ -3,9 +3,11 @@ namespace SOR.Ai.Core;
|
||||
using System.Text.Json;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using SOR.Ai.Engine;
|
||||
using SOR.Ai.Heuristics;
|
||||
using SOR.Ai.Transport;
|
||||
using SOR.Database.Enums; // GamePhase
|
||||
using SOR.Game; // GameState
|
||||
using SOR.Game; // GameState, GameEngine, game request records
|
||||
using SOR.Networking.Abstractions.Messaging;
|
||||
using SOR.Networking.Abstractions.Transport;
|
||||
|
||||
@@ -14,10 +16,11 @@ using SOR.Networking.Abstractions.Transport;
|
||||
///
|
||||
/// Responsibilities:
|
||||
/// - Submits game.ready at startup so the game can begin.
|
||||
/// - Executes the AI's turn when AiPlayerSessionManager signals it.
|
||||
/// - Executes the AI's full turn when AiPlayerSessionManager signals it.
|
||||
///
|
||||
/// Phase 1 stub: ExecuteTurnAsync immediately ends the turn (pass).
|
||||
/// Later phases add decision logic.
|
||||
/// Phase 1: placed ArchSpirit randomly; ended turn immediately.
|
||||
/// Phase 2: selects a decision engine based on Difficulty, computes a full
|
||||
/// action plan, and submits each action with human-like timing delays.
|
||||
/// </summary>
|
||||
internal sealed class AiPlayerSession : IAsyncDisposable
|
||||
{
|
||||
@@ -49,61 +52,94 @@ internal sealed class AiPlayerSession : IAsyncDisposable
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
// ── Public API ────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Sends game.ready on behalf of the AI after a short humanizing delay.
|
||||
/// Called once when the game session is detected by AiPlayerSessionManager.
|
||||
/// </summary>
|
||||
public async Task SendReadyAsync(CancellationToken appCt)
|
||||
{
|
||||
using var ct = CancellationTokenSource.CreateLinkedTokenSource(appCt, _sessionCts.Token);
|
||||
using var cts = CancellationTokenSource.CreateLinkedTokenSource(appCt, _sessionCts.Token);
|
||||
var ct = cts.Token;
|
||||
|
||||
// Short random delay before sending ready — feels more natural.
|
||||
await Task.Delay(Random.Shared.Next(300, 900), ct.Token);
|
||||
await Task.Delay(Random.Shared.Next(300, 900), ct);
|
||||
|
||||
_logger.LogDebug("AI {Account} sending game.ready for session {Session}.",
|
||||
AiAccountId, SessionId);
|
||||
|
||||
await InvokeHandlerAsync("game.ready",
|
||||
JsonSerializer.SerializeToUtf8Bytes(new { SessionId }),
|
||||
ct.Token);
|
||||
ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Executes the AI's full turn.
|
||||
/// Phase 1 stub: end turn immediately (AI passes).
|
||||
///
|
||||
/// Selects the decision engine based on the difficulty profile, computes
|
||||
/// an action plan, then submits each action with human-like delays.
|
||||
/// Placement phase is handled separately (random coord from starting zone).
|
||||
/// </summary>
|
||||
public async Task ExecuteTurnAsync(GameState state, CancellationToken appCt)
|
||||
{
|
||||
using var cts = CancellationTokenSource.CreateLinkedTokenSource(appCt, _sessionCts.Token);
|
||||
var ct = cts.Token;
|
||||
var ct = cts.Token;
|
||||
|
||||
_logger.LogDebug(
|
||||
"AI {Account} (seat {Seat}) taking turn {Turn} in session {Session}.",
|
||||
AiAccountId, SeatIndex, state.TurnNumber, SessionId);
|
||||
|
||||
// Handle Placement phase separately — must place ArchSpirit before main turn.
|
||||
// Placement phase: place ArchSpirit before everything else.
|
||||
if (state.Phase == GamePhase.Placement)
|
||||
{
|
||||
await ExecutePlacementAsync(state, ct);
|
||||
return;
|
||||
}
|
||||
|
||||
// Phase 1 stub: immediately end turn with a short simulated delay.
|
||||
await Task.Delay(Random.Shared.Next(800, 2000), ct);
|
||||
// Resolve difficulty profile + strategy overlay.
|
||||
var profile = AiDifficultyProfiles.Get(Difficulty).WithStrategy(Strategy);
|
||||
|
||||
_logger.LogDebug(
|
||||
"AI {Account} ending turn (stub — no decision logic yet).",
|
||||
AiAccountId);
|
||||
// Think delay (before first action).
|
||||
await Task.Delay(
|
||||
Random.Shared.Next(profile.MinThinkTimeMs, profile.MaxThinkTimeMs + 1), ct);
|
||||
|
||||
await InvokeHandlerAsync("game.end_turn",
|
||||
JsonSerializer.SerializeToUtf8Bytes(new { SessionId }),
|
||||
ct);
|
||||
// Compute action plan.
|
||||
var ctx = new AiTurnContext(state, AiAccountId);
|
||||
var engine = ResolveEngine(profile);
|
||||
IReadOnlyList<AiAction> plan;
|
||||
try
|
||||
{
|
||||
plan = engine.ComputeTurn(ctx);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex, "AI {Account}: decision engine threw — falling back to pass.", AiAccountId);
|
||||
plan = [new AiEndTurnAction()];
|
||||
}
|
||||
|
||||
_logger.LogDebug("AI {Account} turn plan: {Count} action(s).", AiAccountId, plan.Count);
|
||||
|
||||
// Submit each action with delays.
|
||||
foreach (var action in plan)
|
||||
{
|
||||
ct.ThrowIfCancellationRequested();
|
||||
|
||||
var (msgType, payload) = ActionToMessage(action);
|
||||
if (msgType is null) continue;
|
||||
|
||||
await InvokeHandlerAsync(msgType, payload, ct);
|
||||
|
||||
// Small delay between sequential actions (except after EndTurn).
|
||||
if (action is not AiEndTurnAction)
|
||||
{
|
||||
await Task.Delay(
|
||||
Random.Shared.Next(profile.MinActionDelayMs, profile.MaxActionDelayMs + 1), ct);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Places the AI's ArchSpirit on a random valid tile in its starting zone.
|
||||
/// Called during the Placement phase.
|
||||
/// </summary>
|
||||
// ── Placement ─────────────────────────────────────────────────────────────
|
||||
|
||||
private async Task ExecutePlacementAsync(GameState state, CancellationToken ct)
|
||||
{
|
||||
if (!state.Players.ContainsKey(AiAccountId))
|
||||
@@ -112,7 +148,6 @@ internal sealed class AiPlayerSession : IAsyncDisposable
|
||||
return;
|
||||
}
|
||||
|
||||
// Pick a random coord from the starting zone for this seat.
|
||||
if (state.Board is null ||
|
||||
!state.Board.StartingZones.TryGetValue(SeatIndex, out var zone) ||
|
||||
zone.Count == 0)
|
||||
@@ -137,18 +172,82 @@ internal sealed class AiPlayerSession : IAsyncDisposable
|
||||
ct);
|
||||
}
|
||||
|
||||
// ── Engine selection ──────────────────────────────────────────────────────
|
||||
|
||||
private static IAiDecisionEngine ResolveEngine(AiDifficultyProfile profile) =>
|
||||
profile.EngineType switch
|
||||
{
|
||||
"Heuristic" => new HeuristicDecisionEngine(profile),
|
||||
_ => new RandomDecisionEngine(), // "Random" + any future unknown
|
||||
};
|
||||
|
||||
// ── Action → message mapping ──────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Maps an AiAction to the game message type and JSON payload.
|
||||
/// Returns (null, null) for actions that don't produce a message (e.g., internal guards).
|
||||
/// </summary>
|
||||
private (string? msgType, ReadOnlyMemory<byte> payload) ActionToMessage(AiAction action)
|
||||
{
|
||||
return action switch
|
||||
{
|
||||
AiDrawAction =>
|
||||
Msg("game.draw", new GameDrawRequest(SessionId)),
|
||||
|
||||
AiPlayCardAction play => play.TargetTiles.Count switch
|
||||
{
|
||||
0 => Msg("game.play_card",
|
||||
new GamePlayCardRequest(SessionId, play.CardInstanceId)),
|
||||
1 => Msg("game.play_card",
|
||||
new GamePlayCardRequest(SessionId, play.CardInstanceId,
|
||||
TargetTile: new CoordDto(play.TargetTiles[0].X, play.TargetTiles[0].Y))),
|
||||
_ => Msg("game.play_card",
|
||||
new GamePlayCardRequest(SessionId, play.CardInstanceId,
|
||||
TargetTiles: play.TargetTiles
|
||||
.Select(c => new CoordDto(c.X, c.Y)).ToList())),
|
||||
},
|
||||
|
||||
AiMoveAction move =>
|
||||
Msg("game.move_unit",
|
||||
new GameMoveUnitRequest(SessionId, move.UnitInstanceId,
|
||||
new CoordDto(move.Target.X, move.Target.Y))),
|
||||
|
||||
AiAttackAction atk =>
|
||||
Msg("game.attack",
|
||||
new GameAttackRequest(SessionId, atk.AttackerInstanceId, atk.TargetInstanceId)),
|
||||
|
||||
AiSacrificeAction sac =>
|
||||
Msg("game.sacrifice",
|
||||
new GameSacrificeRequest(SessionId, sac.UnitInstanceId)),
|
||||
|
||||
AiAscendAction asc =>
|
||||
Msg("game.ascend",
|
||||
new GameAscendRequest(SessionId, asc.IncomingCardInstanceId)),
|
||||
|
||||
AiEndTurnAction =>
|
||||
Msg("game.end_turn", new GameEndTurnRequest(SessionId)),
|
||||
|
||||
_ => (null, ReadOnlyMemory<byte>.Empty),
|
||||
};
|
||||
}
|
||||
|
||||
private static (string msgType, ReadOnlyMemory<byte> payload) Msg<T>(string type, T body)
|
||||
=> (type, JsonSerializer.SerializeToUtf8Bytes(body));
|
||||
|
||||
// ── Handler invocation ────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Resolves and invokes a game message handler directly in-process,
|
||||
/// as if the AI were a connected client sending that message.
|
||||
/// </summary>
|
||||
private async Task InvokeHandlerAsync(
|
||||
string messageType,
|
||||
string messageType,
|
||||
ReadOnlyMemory<byte> payload,
|
||||
CancellationToken ct)
|
||||
CancellationToken ct)
|
||||
{
|
||||
using var scope = _scopeFactory.CreateScope();
|
||||
var handlers = scope.ServiceProvider.GetServices<IMessageHandler>();
|
||||
var handler = handlers.FirstOrDefault(h => h.MessageType == messageType);
|
||||
using var scope = _scopeFactory.CreateScope();
|
||||
var handlers = scope.ServiceProvider.GetServices<IMessageHandler>();
|
||||
var handler = handlers.FirstOrDefault(h => h.MessageType == messageType);
|
||||
|
||||
if (handler is null)
|
||||
{
|
||||
@@ -174,14 +273,22 @@ internal sealed class AiPlayerSession : IAsyncDisposable
|
||||
{
|
||||
// Session or app shutdown — ignore.
|
||||
}
|
||||
catch (GameException gex)
|
||||
{
|
||||
_logger.LogDebug(
|
||||
"AI {Account}: handler '{Type}' rejected action: {Code}.",
|
||||
AiAccountId, messageType, gex.Message);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogWarning(ex,
|
||||
"AI {Account}: handler '{Type}' threw an exception.",
|
||||
"AI {Account}: handler '{Type}' threw an unexpected exception.",
|
||||
AiAccountId, messageType);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Lifecycle ─────────────────────────────────────────────────────────────
|
||||
|
||||
public void Cancel() => _sessionCts.Cancel();
|
||||
|
||||
public ValueTask DisposeAsync()
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
namespace SOR.Ai.Engine;
|
||||
|
||||
/// <summary>
|
||||
/// Immutable configuration profile for one AI difficulty tier.
|
||||
/// Profiles are defined in AiDifficultyProfiles (in-code constants, no migrations needed).
|
||||
/// Strategy archetypes apply weight overlays on top via WithStrategy().
|
||||
/// </summary>
|
||||
internal sealed record AiDifficultyProfile
|
||||
{
|
||||
public int Difficulty { get; init; } // 1–10
|
||||
public string DisplayName { get; init; } = "";
|
||||
public string EngineType { get; init; } = ""; // "Random" | "Heuristic" | "MCTS" | "Neural"
|
||||
|
||||
// ── Mistake injection ─────────────────────────────────────────────────────
|
||||
/// <summary>Probability (0–1) of replacing the optimal action with a random one.</summary>
|
||||
public float MistakeRate { get; init; }
|
||||
/// <summary>Probability (0–1) of picking the 2nd-best action instead of the best.</summary>
|
||||
public float SuboptimalRate { get; init; }
|
||||
|
||||
// ── MCTS params (Phase 3) ────────────────────────────────────────────────
|
||||
public int MctsTimeBudgetMs { get; init; }
|
||||
public int MctsMaxDepth { get; init; }
|
||||
|
||||
// ── Humanization delays ───────────────────────────────────────────────────
|
||||
/// <summary>Think time before the first action of the turn (ms).</summary>
|
||||
public int MinThinkTimeMs { get; init; }
|
||||
public int MaxThinkTimeMs { get; init; }
|
||||
/// <summary>Delay between subsequent actions within one turn (ms).</summary>
|
||||
public int MinActionDelayMs { get; init; }
|
||||
public int MaxActionDelayMs { get; init; }
|
||||
|
||||
// ── Heuristic scoring weights ─────────────────────────────────────────────
|
||||
public float MaterialWeight { get; init; } = 1.0f;
|
||||
public float AffinityControlWeight { get; init; } = 1.0f;
|
||||
public float ThreatWeight { get; init; } = 1.0f;
|
||||
public float PositionalWeight { get; init; } = 1.0f;
|
||||
public float ResourceWeight { get; init; } = 1.0f;
|
||||
|
||||
// ── Strategy overlay ──────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Returns a new profile with scoring weights adjusted for the given strategy archetype.
|
||||
/// Strategies shift priorities without changing difficulty level.
|
||||
/// </summary>
|
||||
public AiDifficultyProfile WithStrategy(string strategy) => strategy switch
|
||||
{
|
||||
"Aggressive" => this with
|
||||
{
|
||||
MaterialWeight = MaterialWeight * 1.3f,
|
||||
ThreatWeight = ThreatWeight * 0.5f, // less defensive
|
||||
PositionalWeight = PositionalWeight * 1.5f, // push toward opponent
|
||||
},
|
||||
"Control" => this with
|
||||
{
|
||||
ThreatWeight = ThreatWeight * 1.6f, // protect ArchSpirit
|
||||
AffinityControlWeight = AffinityControlWeight * 1.8f, // Terramorpha priority
|
||||
MaterialWeight = MaterialWeight * 0.8f,
|
||||
},
|
||||
"Ramp" => this with
|
||||
{
|
||||
ResourceWeight = ResourceWeight * 2.0f, // value ST/SP accumulation
|
||||
MaterialWeight = MaterialWeight * 0.7f,
|
||||
},
|
||||
"Swarm" => this with
|
||||
{
|
||||
MaterialWeight = MaterialWeight * 1.2f, // value unit count
|
||||
PositionalWeight = PositionalWeight * 1.1f,
|
||||
},
|
||||
_ => this, // "Balanced" — no adjustment
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
namespace SOR.Ai.Engine;
|
||||
|
||||
/// <summary>
|
||||
/// Static lookup table for all 10 difficulty profiles.
|
||||
/// In-code constants — no DB storage needed, tuning is done via code changes.
|
||||
/// </summary>
|
||||
internal static class AiDifficultyProfiles
|
||||
{
|
||||
private static readonly AiDifficultyProfile[] _profiles =
|
||||
[
|
||||
// ── Tier 1: Novice (Random) ───────────────────────────────────────────
|
||||
new()
|
||||
{
|
||||
Difficulty = 1,
|
||||
DisplayName = "Novice",
|
||||
EngineType = "Random",
|
||||
MistakeRate = 1.0f,
|
||||
MinThinkTimeMs = 600,
|
||||
MaxThinkTimeMs = 1400,
|
||||
MinActionDelayMs = 300,
|
||||
MaxActionDelayMs = 700,
|
||||
},
|
||||
|
||||
// ── Tier 2: Apprentice (Heuristic, 60% mistakes) ─────────────────────
|
||||
new()
|
||||
{
|
||||
Difficulty = 2,
|
||||
DisplayName = "Apprentice",
|
||||
EngineType = "Heuristic",
|
||||
MistakeRate = 0.60f,
|
||||
MinThinkTimeMs = 700,
|
||||
MaxThinkTimeMs = 1600,
|
||||
MinActionDelayMs = 400,
|
||||
MaxActionDelayMs = 900,
|
||||
MaterialWeight = 1.0f,
|
||||
AffinityControlWeight = 0.5f,
|
||||
ThreatWeight = 0.5f,
|
||||
PositionalWeight = 0.5f,
|
||||
ResourceWeight = 0.5f,
|
||||
},
|
||||
|
||||
// ── Tier 3: Journeyman (Heuristic, 40% mistakes) ─────────────────────
|
||||
new()
|
||||
{
|
||||
Difficulty = 3,
|
||||
DisplayName = "Journeyman",
|
||||
EngineType = "Heuristic",
|
||||
MistakeRate = 0.40f,
|
||||
MinThinkTimeMs = 800,
|
||||
MaxThinkTimeMs = 1800,
|
||||
MinActionDelayMs = 400,
|
||||
MaxActionDelayMs = 900,
|
||||
MaterialWeight = 1.0f,
|
||||
AffinityControlWeight = 0.8f,
|
||||
ThreatWeight = 0.8f,
|
||||
PositionalWeight = 0.8f,
|
||||
ResourceWeight = 0.7f,
|
||||
},
|
||||
|
||||
// ── Tier 4: Adept (Heuristic, 25% mistakes) ──────────────────────────
|
||||
new()
|
||||
{
|
||||
Difficulty = 4,
|
||||
DisplayName = "Adept",
|
||||
EngineType = "Heuristic",
|
||||
MistakeRate = 0.25f,
|
||||
MinThinkTimeMs = 900,
|
||||
MaxThinkTimeMs = 2000,
|
||||
MinActionDelayMs = 500,
|
||||
MaxActionDelayMs = 1100,
|
||||
MaterialWeight = 1.0f,
|
||||
AffinityControlWeight = 1.0f,
|
||||
ThreatWeight = 1.0f,
|
||||
PositionalWeight = 1.0f,
|
||||
ResourceWeight = 0.8f,
|
||||
},
|
||||
|
||||
// ── Tier 5: Expert (Heuristic, 10% mistakes) ─────────────────────────
|
||||
new()
|
||||
{
|
||||
Difficulty = 5,
|
||||
DisplayName = "Expert",
|
||||
EngineType = "Heuristic",
|
||||
MistakeRate = 0.10f,
|
||||
MinThinkTimeMs = 1000,
|
||||
MaxThinkTimeMs = 2200,
|
||||
MinActionDelayMs = 600,
|
||||
MaxActionDelayMs = 1200,
|
||||
MaterialWeight = 1.0f,
|
||||
AffinityControlWeight = 1.2f,
|
||||
ThreatWeight = 1.2f,
|
||||
PositionalWeight = 1.1f,
|
||||
ResourceWeight = 1.0f,
|
||||
},
|
||||
|
||||
// ── Tiers 6–10: placeholder Heuristic until MCTS/Neural are built ─────
|
||||
// Phase 3 will replace EngineType with "MCTS" / "Neural".
|
||||
new()
|
||||
{
|
||||
Difficulty = 6,
|
||||
DisplayName = "Master",
|
||||
EngineType = "Heuristic", // TODO Phase 3: "MCTS"
|
||||
MistakeRate = 0.05f,
|
||||
MctsTimeBudgetMs = 500,
|
||||
MctsMaxDepth = 3,
|
||||
MinThinkTimeMs = 1200,
|
||||
MaxThinkTimeMs = 2500,
|
||||
MinActionDelayMs = 700,
|
||||
MaxActionDelayMs = 1400,
|
||||
MaterialWeight = 1.2f,
|
||||
AffinityControlWeight = 1.4f,
|
||||
ThreatWeight = 1.4f,
|
||||
PositionalWeight = 1.2f,
|
||||
ResourceWeight = 1.2f,
|
||||
},
|
||||
new()
|
||||
{
|
||||
Difficulty = 7,
|
||||
DisplayName = "Grandmaster",
|
||||
EngineType = "Heuristic", // TODO Phase 3: "MCTS"
|
||||
MistakeRate = 0.02f,
|
||||
MctsTimeBudgetMs = 1500,
|
||||
MctsMaxDepth = 5,
|
||||
MinThinkTimeMs = 1400,
|
||||
MaxThinkTimeMs = 3000,
|
||||
MinActionDelayMs = 800,
|
||||
MaxActionDelayMs = 1500,
|
||||
MaterialWeight = 1.3f,
|
||||
AffinityControlWeight = 1.5f,
|
||||
ThreatWeight = 1.5f,
|
||||
PositionalWeight = 1.3f,
|
||||
ResourceWeight = 1.3f,
|
||||
},
|
||||
new()
|
||||
{
|
||||
Difficulty = 8,
|
||||
DisplayName = "Champion",
|
||||
EngineType = "Heuristic", // TODO Phase 3: "MCTS"
|
||||
MistakeRate = 0.0f,
|
||||
MctsTimeBudgetMs = 4000,
|
||||
MctsMaxDepth = 7,
|
||||
MinThinkTimeMs = 1500,
|
||||
MaxThinkTimeMs = 3200,
|
||||
MinActionDelayMs = 900,
|
||||
MaxActionDelayMs = 1600,
|
||||
MaterialWeight = 1.4f,
|
||||
AffinityControlWeight = 1.6f,
|
||||
ThreatWeight = 1.6f,
|
||||
PositionalWeight = 1.4f,
|
||||
ResourceWeight = 1.4f,
|
||||
},
|
||||
new()
|
||||
{
|
||||
Difficulty = 9,
|
||||
DisplayName = "Legend",
|
||||
EngineType = "Heuristic", // TODO Phase 4: "Neural"
|
||||
MistakeRate = 0.0f,
|
||||
MinThinkTimeMs = 1500,
|
||||
MaxThinkTimeMs = 3000,
|
||||
MinActionDelayMs = 900,
|
||||
MaxActionDelayMs = 1600,
|
||||
MaterialWeight = 1.5f,
|
||||
AffinityControlWeight = 1.8f,
|
||||
ThreatWeight = 1.8f,
|
||||
PositionalWeight = 1.5f,
|
||||
ResourceWeight = 1.5f,
|
||||
},
|
||||
new()
|
||||
{
|
||||
Difficulty = 10,
|
||||
DisplayName = "Mythic",
|
||||
EngineType = "Heuristic", // TODO Phase 4: "Neural"
|
||||
MistakeRate = 0.0f,
|
||||
MinThinkTimeMs = 1500,
|
||||
MaxThinkTimeMs = 3000,
|
||||
MinActionDelayMs = 1000,
|
||||
MaxActionDelayMs = 1800,
|
||||
MaterialWeight = 1.6f,
|
||||
AffinityControlWeight = 2.0f,
|
||||
ThreatWeight = 2.0f,
|
||||
PositionalWeight = 1.6f,
|
||||
ResourceWeight = 1.6f,
|
||||
},
|
||||
];
|
||||
|
||||
/// <summary>Returns the difficulty profile for the given tier (1–10).</summary>
|
||||
public static AiDifficultyProfile Get(int difficulty)
|
||||
=> _profiles[Math.Clamp(difficulty, 1, 10) - 1];
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
namespace SOR.Ai.Engine;
|
||||
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Game.Grid;
|
||||
|
||||
/// <summary>
|
||||
/// Contract for all AI turn-planning engines.
|
||||
/// Takes a snapshot of the game state and returns an ordered action plan
|
||||
/// that the session manager will execute sequentially.
|
||||
///
|
||||
/// Implementations must be pure (no DB, no network). They may read GameState
|
||||
/// but must not mutate it — the caller owns the original state.
|
||||
/// </summary>
|
||||
internal interface IAiDecisionEngine
|
||||
{
|
||||
/// <summary>
|
||||
/// Compute the full action plan for the AI's turn.
|
||||
/// The plan MUST end with <see cref="AiEndTurnAction"/> as the final element.
|
||||
/// </summary>
|
||||
IReadOnlyList<AiAction> ComputeTurn(AiTurnContext ctx);
|
||||
}
|
||||
|
||||
// ── AiAction discriminated union ──────────────────────────────────────────────
|
||||
|
||||
/// <summary>Base type for all AI actions.</summary>
|
||||
internal abstract record AiAction;
|
||||
|
||||
/// <summary>Draw card(s) from deck (Draw phase).</summary>
|
||||
internal sealed record AiDrawAction : AiAction;
|
||||
|
||||
/// <summary>
|
||||
/// Channel (play) a card from hand.
|
||||
/// TargetTiles contains:
|
||||
/// - 0 entries → Ruin / Repentance / Instinct (no tile required)
|
||||
/// - 1 entry → Spirit or Terramorpha Mono
|
||||
/// - 2 entries → Terramorpha Di (tiles must be adjacent)
|
||||
/// - 3 entries → Terramorpha Tri (each adjacent to the previous)
|
||||
/// </summary>
|
||||
internal sealed record AiPlayCardAction(
|
||||
string CardInstanceId,
|
||||
IReadOnlyList<Coord> TargetTiles) : AiAction;
|
||||
|
||||
/// <summary>Move a unit to a new tile.</summary>
|
||||
internal sealed record AiMoveAction(
|
||||
string UnitInstanceId,
|
||||
Coord Target) : AiAction;
|
||||
|
||||
/// <summary>Attack an opponent's unit (or ArchSpirit) with one of the AI's field cards.</summary>
|
||||
internal sealed record AiAttackAction(
|
||||
string AttackerInstanceId,
|
||||
string TargetInstanceId) : AiAction;
|
||||
|
||||
/// <summary>Activate an active ability (no target required for Phase 2).</summary>
|
||||
internal sealed record AiActivateAbilityAction(
|
||||
string UnitInstanceId,
|
||||
int AbilityIndex) : AiAction;
|
||||
|
||||
/// <summary>Sacrifice a Spirit adjacent to the AI's ArchSpirit.</summary>
|
||||
internal sealed record AiSacrificeAction(string UnitInstanceId) : AiAction;
|
||||
|
||||
/// <summary>Ascend the AI's ArchSpirit to the next tier.</summary>
|
||||
internal sealed record AiAscendAction(string IncomingCardInstanceId) : AiAction;
|
||||
|
||||
/// <summary>End the AI's turn (always the final action in the plan).</summary>
|
||||
internal sealed record AiEndTurnAction : AiAction;
|
||||
@@ -0,0 +1,49 @@
|
||||
namespace SOR.Ai.Engine;
|
||||
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Ai.Heuristics;
|
||||
using SOR.Database.Enums;
|
||||
|
||||
/// <summary>
|
||||
/// Random decision engine (Difficulty 1 — Novice).
|
||||
/// Picks a random legal action each step until SP/MP is exhausted or no candidates remain.
|
||||
/// All chosen actions are valid (won't throw GameException when submitted).
|
||||
/// </summary>
|
||||
internal sealed class RandomDecisionEngine : IAiDecisionEngine
|
||||
{
|
||||
public IReadOnlyList<AiAction> ComputeTurn(AiTurnContext ctx)
|
||||
{
|
||||
var plan = new List<AiAction>();
|
||||
|
||||
// Draw phase → always draw.
|
||||
if (ctx.State.Phase == GamePhase.Draw)
|
||||
plan.Add(new AiDrawAction());
|
||||
|
||||
// Main phase: pick random legal actions until exhausted.
|
||||
// Limit iterations to prevent runaway loops in edge cases.
|
||||
const int maxActions = 50;
|
||||
int iterations = 0;
|
||||
|
||||
while (iterations++ < maxActions)
|
||||
{
|
||||
var candidates = ActionCandidateGenerator.All(ctx);
|
||||
|
||||
// Filter out draw action — handled above, or not applicable.
|
||||
var mainCandidates = candidates
|
||||
.Where(a => a is not AiDrawAction)
|
||||
.ToList();
|
||||
|
||||
if (mainCandidates.Count == 0)
|
||||
break;
|
||||
|
||||
var chosen = mainCandidates[Random.Shared.Next(mainCandidates.Count)];
|
||||
plan.Add(chosen);
|
||||
|
||||
// If it was an AttackAction the attacker is now exhausted — stop if no
|
||||
// other actions are available (will be detected on next iteration).
|
||||
}
|
||||
|
||||
plan.Add(new AiEndTurnAction());
|
||||
return plan;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,374 @@
|
||||
namespace SOR.Ai.Heuristics;
|
||||
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Ai.Engine;
|
||||
using SOR.Database.Enums;
|
||||
using SOR.Game;
|
||||
using SOR.Game.Combat;
|
||||
using SOR.Game.Grid;
|
||||
|
||||
/// <summary>
|
||||
/// Enumerates every legal action available to the AI on its current turn.
|
||||
/// Pure static methods — no side effects, no DB access.
|
||||
/// Delegates range/path/affinity logic to SOR.Game modules so no rules are duplicated.
|
||||
/// </summary>
|
||||
internal static class ActionCandidateGenerator
|
||||
{
|
||||
/// <summary>Returns all legal actions for the active player in the given turn context.</summary>
|
||||
public static IReadOnlyList<AiAction> All(AiTurnContext ctx)
|
||||
{
|
||||
var state = ctx.State;
|
||||
var result = new List<AiAction>();
|
||||
|
||||
if (state.Phase == GamePhase.Draw)
|
||||
{
|
||||
result.Add(new AiDrawAction());
|
||||
return result;
|
||||
}
|
||||
|
||||
if (state.Phase != GamePhase.Main)
|
||||
return result;
|
||||
|
||||
result.AddRange(Channelings(ctx));
|
||||
result.AddRange(AllMovements(ctx));
|
||||
result.AddRange(AllAttacks(ctx));
|
||||
result.AddRange(Sacrifices(ctx));
|
||||
result.AddRange(AscendCandidates(ctx));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ── Channeling ────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>All valid card-play actions (Spirits, Terramorpha, Ruin, Repentance/Instinct).</summary>
|
||||
public static IReadOnlyList<AiPlayCardAction> Channelings(AiTurnContext ctx)
|
||||
{
|
||||
var player = ctx.AiPlayer;
|
||||
var state = ctx.State;
|
||||
var board = state.Board;
|
||||
var result = new List<AiPlayCardAction>();
|
||||
|
||||
foreach (var card in player.Hand)
|
||||
{
|
||||
if (player.CurrentSp < card.SpCost) continue;
|
||||
if (player.CurrentSt < card.StCost) continue;
|
||||
|
||||
switch (card.CardType)
|
||||
{
|
||||
case "Spirit":
|
||||
if (!player.CanChannelSpirit) continue;
|
||||
result.AddRange(SpiritChannelings(ctx, card, board));
|
||||
break;
|
||||
|
||||
case "Terramorpha":
|
||||
result.AddRange(TerramorphaChannelings(ctx, card, board));
|
||||
break;
|
||||
|
||||
case "Ruin":
|
||||
if (!player.CanChannelRuin) continue;
|
||||
// Placement is random — just add one candidate per Ruin card.
|
||||
result.Add(new AiPlayCardAction(card.InstanceId, []));
|
||||
break;
|
||||
|
||||
case "Repentance":
|
||||
if (!player.CanChannelRepentance) continue;
|
||||
result.Add(new AiPlayCardAction(card.InstanceId, []));
|
||||
break;
|
||||
|
||||
case "Instinct":
|
||||
if (!player.CanChannelInstinct) continue;
|
||||
result.Add(new AiPlayCardAction(card.InstanceId, []));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private static IEnumerable<AiPlayCardAction> SpiritChannelings(
|
||||
AiTurnContext ctx, CardInstance card, Board? board)
|
||||
{
|
||||
if (board is null) yield break;
|
||||
|
||||
var archSpirit = ctx.AiPlayer.ArchSpirit;
|
||||
if (archSpirit?.Position is null) yield break;
|
||||
|
||||
var origin = archSpirit.Position.Value;
|
||||
var minRange = card.MinChannelRange ?? 1;
|
||||
var maxRange = card.MaxChannelRange ?? 1;
|
||||
|
||||
if (!Enum.TryParse<Affinity>(card.Affinity, out var affinity))
|
||||
yield break;
|
||||
|
||||
foreach (var tile in board.Tiles.Values)
|
||||
{
|
||||
if (!tile.IsEmpty) continue;
|
||||
|
||||
var dist = board.HexSides > 0
|
||||
? HexGrid.Distance(origin, tile.Coord, board.HexSides)
|
||||
: origin.ManhattanDistance(tile.Coord);
|
||||
|
||||
if (dist < minRange || dist > maxRange) continue;
|
||||
if (!AffinitySystem.IsAffinityValid(tile, affinity)) continue;
|
||||
|
||||
yield return new AiPlayCardAction(card.InstanceId, [tile.Coord]);
|
||||
}
|
||||
}
|
||||
|
||||
private static IEnumerable<AiPlayCardAction> TerramorphaChannelings(
|
||||
AiTurnContext ctx, CardInstance card, Board? board)
|
||||
{
|
||||
if (board is null) yield break;
|
||||
|
||||
bool allowed = card.TerramorphaMode switch
|
||||
{
|
||||
TerramorphaMode.Mono => ctx.AiPlayer.CanChannelTerramorphaMono,
|
||||
TerramorphaMode.Di => ctx.AiPlayer.CanChannelTerramorphaDi,
|
||||
TerramorphaMode.Tri => ctx.AiPlayer.CanChannelTerramorphaTri,
|
||||
_ => false,
|
||||
};
|
||||
if (!allowed) yield break;
|
||||
|
||||
var allCoords = board.Tiles.Keys
|
||||
.Select(k => board.Tiles[k].Coord)
|
||||
.ToList();
|
||||
|
||||
if (card.TerramorphaMode == TerramorphaMode.Mono)
|
||||
{
|
||||
foreach (var c in allCoords)
|
||||
yield return new AiPlayCardAction(card.InstanceId, [c]);
|
||||
}
|
||||
else if (card.TerramorphaMode == TerramorphaMode.Di)
|
||||
{
|
||||
foreach (var c1 in allCoords)
|
||||
foreach (var c2 in board.GetNeighbors(c1))
|
||||
yield return new AiPlayCardAction(card.InstanceId, [c1, c2]);
|
||||
}
|
||||
else // Tri
|
||||
{
|
||||
foreach (var c1 in allCoords)
|
||||
foreach (var c2 in board.GetNeighbors(c1))
|
||||
foreach (var c3 in board.GetNeighbors(c2))
|
||||
{
|
||||
if (c3 == c1) continue;
|
||||
yield return new AiPlayCardAction(card.InstanceId, [c1, c2, c3]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Movement ──────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>All movement candidates for all of the AI's movable units.</summary>
|
||||
public static IReadOnlyList<AiMoveAction> AllMovements(AiTurnContext ctx)
|
||||
{
|
||||
var result = new List<AiMoveAction>();
|
||||
foreach (var unit in AllFieldUnits(ctx.AiPlayer))
|
||||
result.AddRange(Movements(ctx, unit.InstanceId));
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Movement candidates for a specific unit.</summary>
|
||||
public static IReadOnlyList<AiMoveAction> Movements(AiTurnContext ctx, string unitInstanceId)
|
||||
{
|
||||
var state = ctx.State;
|
||||
var board = state.Board;
|
||||
if (board is null) return [];
|
||||
|
||||
var unit = FindUnit(ctx.AiPlayer, unitInstanceId);
|
||||
if (unit is null || !unit.CanMove || unit.CurrentMp <= 0 || unit.Position is null)
|
||||
return [];
|
||||
|
||||
var movType = unit.MovementType;
|
||||
var result = new List<AiMoveAction>();
|
||||
|
||||
if (movType is MovementType.Walk or MovementType.Flight)
|
||||
{
|
||||
var blocked = BuildBlockedSet(state, unitInstanceId, movType);
|
||||
var reachable = Pathfinding.GetReachableWithCost(board, unit.Position.Value, unit.CurrentMp, blocked);
|
||||
foreach (var (coord, _) in reachable)
|
||||
{
|
||||
var tile = board.GetTile(coord);
|
||||
if (tile is not null && tile.IsEmpty)
|
||||
result.Add(new AiMoveAction(unitInstanceId, coord));
|
||||
}
|
||||
}
|
||||
else if (movType is MovementType.Jump)
|
||||
{
|
||||
foreach (var coord in Pathfinding.GetJumpRange(board, unit.Position.Value, 1, unit.CurrentMp))
|
||||
{
|
||||
var tile = board.GetTile(coord);
|
||||
if (tile is not null && tile.IsEmpty)
|
||||
result.Add(new AiMoveAction(unitInstanceId, coord));
|
||||
}
|
||||
}
|
||||
else if (movType is MovementType.Teleport)
|
||||
{
|
||||
var occupancy = board.BuildOccupancyMap();
|
||||
occupancy.Remove(unit.Position.Value);
|
||||
foreach (var coord in Pathfinding.GetJumpRange(board, unit.Position.Value, 1, unit.CurrentMp))
|
||||
{
|
||||
var tile = board.GetTile(coord);
|
||||
if (tile is null || !tile.IsEmpty) continue;
|
||||
if (LineOfSight.HasLos(board, unit.Position.Value, coord, occupancy, board.HexSides))
|
||||
result.Add(new AiMoveAction(unitInstanceId, coord));
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ── Attacks ───────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>All attack candidates for all of the AI's units that can still attack.</summary>
|
||||
public static IReadOnlyList<AiAttackAction> AllAttacks(AiTurnContext ctx)
|
||||
{
|
||||
var result = new List<AiAttackAction>();
|
||||
foreach (var unit in AllFieldUnits(ctx.AiPlayer))
|
||||
result.AddRange(Attacks(ctx, unit.InstanceId));
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>Attack candidates for a specific unit.</summary>
|
||||
public static IReadOnlyList<AiAttackAction> Attacks(AiTurnContext ctx, string unitInstanceId)
|
||||
{
|
||||
var state = ctx.State;
|
||||
var board = state.Board;
|
||||
|
||||
var unit = FindUnit(ctx.AiPlayer, unitInstanceId);
|
||||
if (unit is null || unit.IsExhausted || !unit.CanAttack || unit.Position is null)
|
||||
return [];
|
||||
|
||||
if (unit.ExtraAttacksRemaining == 0 && unit.IsExhausted)
|
||||
return [];
|
||||
|
||||
var result = new List<AiAttackAction>();
|
||||
var minRange = unit.MinAttackRange ?? 1;
|
||||
var maxRange = unit.MaxAttackRange ?? 1;
|
||||
|
||||
if (board is not null)
|
||||
{
|
||||
var occupancy = board.BuildOccupancyMap();
|
||||
var attackableCoords = AttackSystem.GetAttackableCoords(
|
||||
board, unit.Position.Value, minRange, maxRange, unit.RequiresLos, occupancy)
|
||||
.ToHashSet();
|
||||
|
||||
foreach (var enemyId in ctx.OpponentIds)
|
||||
{
|
||||
var enemy = state.Players[enemyId];
|
||||
foreach (var target in AllFieldUnits(enemy))
|
||||
{
|
||||
if (!target.CanBeAttacked) continue;
|
||||
if (target.Position.HasValue && attackableCoords.Contains(target.Position.Value))
|
||||
result.Add(new AiAttackAction(unitInstanceId, target.InstanceId));
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// No board — any enemy unit is valid (fallback for legacy games).
|
||||
foreach (var enemyId in ctx.OpponentIds)
|
||||
foreach (var target in AllFieldUnits(state.Players[enemyId]))
|
||||
if (target.CanBeAttacked)
|
||||
result.Add(new AiAttackAction(unitInstanceId, target.InstanceId));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ── Sacrifice ─────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>Sacrifice candidates — non-ArchSpirit Spirits adjacent to the AI's ArchSpirit.</summary>
|
||||
public static IReadOnlyList<AiSacrificeAction> Sacrifices(AiTurnContext ctx)
|
||||
{
|
||||
if (!ctx.AiPlayer.CanSacrificeSpirit) return [];
|
||||
|
||||
var archSpirit = ctx.AiPlayer.ArchSpirit;
|
||||
if (archSpirit?.Position is null) return [];
|
||||
|
||||
var archPos = archSpirit.Position.Value;
|
||||
var result = new List<AiSacrificeAction>();
|
||||
|
||||
foreach (var unit in ctx.AiPlayer.Field.OfType<FieldCard>())
|
||||
{
|
||||
if (unit.IsLeader || !unit.CanBeSacrificed) continue;
|
||||
if (unit.Position is null) continue;
|
||||
if (unit.Position.Value.IsOrthogonallyAdjacentTo(archPos))
|
||||
result.Add(new AiSacrificeAction(unit.InstanceId));
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ── Ascend ────────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>Ascend candidates — next-tier ArchSpirit available in any zone, affordable.</summary>
|
||||
public static IReadOnlyList<AiAscendAction> AscendCandidates(AiTurnContext ctx)
|
||||
{
|
||||
var player = ctx.AiPlayer;
|
||||
var archSpirit = player.ArchSpirit;
|
||||
if (archSpirit?.Position is null) return [];
|
||||
if (!player.CanAscendArchSpirit) return [];
|
||||
|
||||
int nextTier = (archSpirit.Tier ?? 1) + 1;
|
||||
var currentDefId = archSpirit.CardDefinitionId;
|
||||
|
||||
var candidates = player.Hand
|
||||
.Concat(player.Deck)
|
||||
.Concat(player.Discard)
|
||||
.Where(c => c.CardType == "ArchSpirit"
|
||||
&& (c.Tier ?? 1) == nextTier
|
||||
&& c.PreviousTierId == currentDefId
|
||||
&& player.CurrentSp >= c.SpCost
|
||||
&& player.CurrentSt >= c.StCost)
|
||||
.Select(c => new AiAscendAction(c.InstanceId))
|
||||
.ToList();
|
||||
|
||||
return candidates;
|
||||
}
|
||||
|
||||
// ── Helpers ───────────────────────────────────────────────────────────────
|
||||
|
||||
private static IEnumerable<FieldCard> AllFieldUnits(PlayerState player)
|
||||
{
|
||||
foreach (var fc in player.Field.OfType<FieldCard>())
|
||||
yield return fc;
|
||||
|
||||
if (player.ArchSpirit is not null)
|
||||
yield return player.ArchSpirit;
|
||||
}
|
||||
|
||||
private static FieldCard? FindUnit(PlayerState player, string instanceId)
|
||||
{
|
||||
foreach (var fc in player.Field.OfType<FieldCard>())
|
||||
if (fc.InstanceId == instanceId) return fc;
|
||||
if (player.ArchSpirit?.InstanceId == instanceId)
|
||||
return player.ArchSpirit;
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Replicates GameEngine's internal blocked-tile set for movement pathfinding.
|
||||
/// Walk is blocked by all units; Flight is blocked only by other Flight units.
|
||||
/// </summary>
|
||||
private static HashSet<Coord> BuildBlockedSet(
|
||||
GameState state, string movingUnitId, MovementType? movType)
|
||||
{
|
||||
var blocked = new HashSet<Coord>();
|
||||
foreach (var player in state.Players.Values)
|
||||
{
|
||||
foreach (var card in player.Field.OfType<FieldCard>())
|
||||
{
|
||||
if (card.InstanceId == movingUnitId || !card.Position.HasValue) continue;
|
||||
if (movType == MovementType.Flight && card.MovementType != MovementType.Flight) continue;
|
||||
blocked.Add(card.Position.Value);
|
||||
}
|
||||
var arch = player.ArchSpirit;
|
||||
if (arch is not null && arch.InstanceId != movingUnitId && arch.Position.HasValue)
|
||||
{
|
||||
if (movType != MovementType.Flight || arch.MovementType == MovementType.Flight)
|
||||
blocked.Add(arch.Position.Value);
|
||||
}
|
||||
}
|
||||
return blocked;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
namespace SOR.Ai.Heuristics;
|
||||
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Ai.Engine;
|
||||
using SOR.Database.Enums;
|
||||
using SOR.Game;
|
||||
|
||||
/// <summary>
|
||||
/// Greedy heuristic decision engine (Difficulties 2–5 and 6–10 until MCTS/Neural phases).
|
||||
///
|
||||
/// Turn algorithm:
|
||||
/// 1. Draw (always, no decision needed).
|
||||
/// 2. Greedy loop: at each step pick the candidate action that maximises
|
||||
/// ScoringFunctions.Evaluate on the simulated post-action state.
|
||||
/// MistakeRate: randomly replace optimal with a random candidate.
|
||||
/// 3. Append AiEndTurnAction.
|
||||
///
|
||||
/// State simulation clones via JSON (GameEngine.Serialize/Deserialize) so the
|
||||
/// original state is never mutated, and ability side-effects are included in scores.
|
||||
/// </summary>
|
||||
internal sealed class HeuristicDecisionEngine : IAiDecisionEngine
|
||||
{
|
||||
private readonly AiDifficultyProfile _profile;
|
||||
|
||||
public HeuristicDecisionEngine(AiDifficultyProfile profile)
|
||||
{
|
||||
_profile = profile;
|
||||
}
|
||||
|
||||
public IReadOnlyList<AiAction> ComputeTurn(AiTurnContext ctx)
|
||||
{
|
||||
var plan = new List<AiAction>();
|
||||
|
||||
// ── 1. Draw phase ─────────────────────────────────────────────────────
|
||||
GameState workingState;
|
||||
if (ctx.State.Phase == GamePhase.Draw)
|
||||
{
|
||||
plan.Add(new AiDrawAction());
|
||||
|
||||
// Simulate the draw to get the Main-phase state for greedy evaluation.
|
||||
workingState = CloneState(ctx.State);
|
||||
try { GameEngine.Draw(workingState, ctx.AiAccountId); }
|
||||
catch { workingState = CloneState(ctx.State); /* if draw fails, proceed anyway */ }
|
||||
}
|
||||
else
|
||||
{
|
||||
workingState = CloneState(ctx.State);
|
||||
}
|
||||
|
||||
// ── 2. Greedy main phase loop ─────────────────────────────────────────
|
||||
float baseScore = ScoringFunctions.Evaluate(workingState, ctx.AiAccountId, _profile);
|
||||
const int maxActions = 50;
|
||||
int iterations = 0;
|
||||
|
||||
while (iterations++ < maxActions)
|
||||
{
|
||||
var workingCtx = new AiTurnContext(workingState, ctx.AiAccountId);
|
||||
var candidates = ActionCandidateGenerator.All(workingCtx)
|
||||
.Where(a => a is not AiDrawAction)
|
||||
.ToList();
|
||||
|
||||
if (candidates.Count == 0) break;
|
||||
|
||||
AiAction? bestAction = null;
|
||||
float bestScore = baseScore;
|
||||
|
||||
foreach (var candidate in candidates)
|
||||
{
|
||||
var simState = CloneState(workingState);
|
||||
float score;
|
||||
try
|
||||
{
|
||||
ApplyAction(simState, ctx.AiAccountId, candidate);
|
||||
score = ScoringFunctions.Evaluate(simState, ctx.AiAccountId, _profile);
|
||||
}
|
||||
catch
|
||||
{
|
||||
// Invalid in the current state — skip.
|
||||
continue;
|
||||
}
|
||||
|
||||
if (score > bestScore)
|
||||
{
|
||||
bestScore = score;
|
||||
bestAction = candidate;
|
||||
}
|
||||
}
|
||||
|
||||
if (bestAction is null)
|
||||
break; // no improvement available
|
||||
|
||||
// ── Mistake injection ──────────────────────────────────────────────
|
||||
if (_profile.MistakeRate > 0 && Random.Shared.NextSingle() < _profile.MistakeRate)
|
||||
bestAction = candidates[Random.Shared.Next(candidates.Count)];
|
||||
|
||||
plan.Add(bestAction);
|
||||
|
||||
// Apply the chosen action to the working state.
|
||||
try { ApplyAction(workingState, ctx.AiAccountId, bestAction); }
|
||||
catch { break; /* action became invalid — stop the loop */ }
|
||||
|
||||
baseScore = ScoringFunctions.Evaluate(workingState, ctx.AiAccountId, _profile);
|
||||
}
|
||||
|
||||
plan.Add(new AiEndTurnAction());
|
||||
return plan;
|
||||
}
|
||||
|
||||
// ── Helpers ───────────────────────────────────────────────────────────────
|
||||
|
||||
private static GameState CloneState(GameState state)
|
||||
=> GameEngine.Deserialize(GameEngine.Serialize(state));
|
||||
|
||||
/// <summary>
|
||||
/// Apply one AiAction directly to a GameState (for simulation purposes).
|
||||
/// Throws GameException if the action is invalid — callers must handle this.
|
||||
/// </summary>
|
||||
private static void ApplyAction(GameState state, string actorId, AiAction action)
|
||||
{
|
||||
switch (action)
|
||||
{
|
||||
case AiDrawAction:
|
||||
GameEngine.Draw(state, actorId);
|
||||
break;
|
||||
|
||||
case AiPlayCardAction play:
|
||||
GameEngine.ChannelCard(state, actorId, play.CardInstanceId, play.TargetTiles);
|
||||
break;
|
||||
|
||||
case AiMoveAction move:
|
||||
GameEngine.MoveUnit(state, actorId, move.UnitInstanceId, move.Target);
|
||||
break;
|
||||
|
||||
case AiAttackAction atk:
|
||||
GameEngine.Attack(state, actorId, atk.AttackerInstanceId, atk.TargetInstanceId);
|
||||
break;
|
||||
|
||||
case AiSacrificeAction sac:
|
||||
GameEngine.Sacrifice(state, actorId, sac.UnitInstanceId);
|
||||
break;
|
||||
|
||||
case AiAscendAction asc:
|
||||
GameEngine.Ascend(state, actorId, asc.IncomingCardInstanceId);
|
||||
break;
|
||||
|
||||
case AiEndTurnAction:
|
||||
// Don't simulate end-turn — the greedy loop handles the termination.
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,205 @@
|
||||
namespace SOR.Ai.Heuristics;
|
||||
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Ai.Engine;
|
||||
using SOR.Database.Enums;
|
||||
using SOR.Game;
|
||||
using SOR.Game.Grid;
|
||||
|
||||
/// <summary>
|
||||
/// Board evaluation function for the heuristic decision engine.
|
||||
///
|
||||
/// Score = Σ (weight × feature) using the formula from the architecture plan §5.2.
|
||||
/// Higher = better for the AI. Weights come from AiDifficultyProfile so that
|
||||
/// different difficulty/strategy combinations produce different behaviour without
|
||||
/// any code changes.
|
||||
/// </summary>
|
||||
internal static class ScoringFunctions
|
||||
{
|
||||
/// <summary>
|
||||
/// Evaluate the board state from the AI's perspective.
|
||||
/// Returns a dimensionless float — only the relative ordering of scores matters.
|
||||
/// </summary>
|
||||
public static float Evaluate(
|
||||
GameState state,
|
||||
string aiAccountId,
|
||||
AiDifficultyProfile profile)
|
||||
{
|
||||
if (!state.Players.TryGetValue(aiAccountId, out var aiPlayer))
|
||||
return 0f;
|
||||
|
||||
float material = MaterialScore(state, aiAccountId);
|
||||
float affinityControl = AffinityControlScore(state, aiAccountId, aiPlayer);
|
||||
float threat = ThreatScore(state, aiAccountId, aiPlayer);
|
||||
float positional = PositionalScore(state, aiAccountId, aiPlayer);
|
||||
float resource = ResourceScore(state, aiPlayer);
|
||||
|
||||
return material * profile.MaterialWeight
|
||||
+ affinityControl * profile.AffinityControlWeight
|
||||
+ threat * profile.ThreatWeight
|
||||
+ positional * profile.PositionalWeight
|
||||
+ resource * profile.ResourceWeight;
|
||||
}
|
||||
|
||||
// ── Feature functions ──────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Material = own unit value − opponent unit value + ArchSpirit HP ratio bonus.
|
||||
///
|
||||
/// Unit value = Damage × 2 + MaxHealth (roughly captures combat power).
|
||||
/// ArchSpirit HP ratio × 500 heavily rewards keeping your ArchSpirit healthy.
|
||||
/// </summary>
|
||||
private static float MaterialScore(GameState state, string aiAccountId)
|
||||
{
|
||||
float score = 0f;
|
||||
|
||||
foreach (var (playerId, player) in state.Players)
|
||||
{
|
||||
if (player.IsEliminated) continue;
|
||||
|
||||
bool isOwn = playerId == aiAccountId;
|
||||
float sign = isOwn ? 1f : -1f;
|
||||
|
||||
// Field units.
|
||||
foreach (var fc in player.Field.OfType<FieldCard>())
|
||||
{
|
||||
if (fc.IsLeader) continue; // ArchSpirit counted separately.
|
||||
float value = (fc.Damage ?? 0) * 2f + (fc.MaxHealth ?? 0);
|
||||
score += sign * value;
|
||||
}
|
||||
|
||||
// ArchSpirit HP ratio.
|
||||
var arch = player.ArchSpirit;
|
||||
if (arch is not null)
|
||||
{
|
||||
float maxHp = arch.MaxHealth ?? 1;
|
||||
float curHp = arch.CurrentHealth ?? 0;
|
||||
float ratio = maxHp > 0 ? curHp / maxHp : 0f;
|
||||
|
||||
if (isOwn)
|
||||
score += ratio * 500f;
|
||||
else
|
||||
score -= ratio * 500f; // destroying opponent ArchSpirit is very good
|
||||
}
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Affinity control = tiles with own ArchSpirit's affinity within channeling range × 3.
|
||||
/// Rewards building a "pool" of valid channeling tiles.
|
||||
/// </summary>
|
||||
private static float AffinityControlScore(
|
||||
GameState state, string aiAccountId, PlayerState aiPlayer)
|
||||
{
|
||||
var board = state.Board;
|
||||
var archSpirit = aiPlayer.ArchSpirit;
|
||||
|
||||
if (board is null || archSpirit?.Position is null) return 0f;
|
||||
|
||||
if (!Enum.TryParse<Affinity>(archSpirit.Affinity, out var aiAffinity))
|
||||
return 0f;
|
||||
|
||||
var origin = archSpirit.Position.Value;
|
||||
var maxRange = archSpirit.MaxChannelRange ?? 1;
|
||||
|
||||
float count = 0f;
|
||||
foreach (var tile in board.Tiles.Values)
|
||||
{
|
||||
var dist = board.HexSides > 0
|
||||
? HexGrid.Distance(origin, tile.Coord, board.HexSides)
|
||||
: origin.ManhattanDistance(tile.Coord);
|
||||
if (dist > maxRange) continue;
|
||||
|
||||
if (AffinitySystem.IsAffinityValid(tile, aiAffinity))
|
||||
count++;
|
||||
}
|
||||
|
||||
return count * 3f;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Threat = −30 per opponent unit that can reach the AI's ArchSpirit.
|
||||
/// A strong deterrent against leaving the ArchSpirit undefended.
|
||||
/// </summary>
|
||||
private static float ThreatScore(
|
||||
GameState state, string aiAccountId, PlayerState aiPlayer)
|
||||
{
|
||||
var ctx = new AiTurnContext(state, aiAccountId);
|
||||
int threats = ThreatDetector.CountThreatsToArchSpirit(ctx);
|
||||
return -threats * 30f;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Positional = +15 per own unit adjacent to any enemy ArchSpirit
|
||||
/// + +2 per own unit in the center 3×3 zone of the board.
|
||||
/// Rewards pressure and board control.
|
||||
/// </summary>
|
||||
private static float PositionalScore(
|
||||
GameState state, string aiAccountId, PlayerState aiPlayer)
|
||||
{
|
||||
var board = state.Board;
|
||||
if (board is null) return 0f;
|
||||
|
||||
float score = 0f;
|
||||
|
||||
// Center zone: tiles within ⌊board/3⌋ of center.
|
||||
int cx = board.Width / 2;
|
||||
int cy = board.Height / 2;
|
||||
int centerRadius = Math.Max(1, Math.Min(board.Width, board.Height) / 3);
|
||||
|
||||
// Collect enemy ArchSpirit positions.
|
||||
var enemyArchPositions = new List<Coord>();
|
||||
foreach (var (id, p) in state.Players)
|
||||
{
|
||||
if (id == aiAccountId || p.IsEliminated) continue;
|
||||
if (p.ArchSpirit?.Position.HasValue == true)
|
||||
enemyArchPositions.Add(p.ArchSpirit.Position.Value);
|
||||
}
|
||||
|
||||
foreach (var unit in aiPlayer.Field.OfType<FieldCard>())
|
||||
{
|
||||
if (unit.Position is null) continue;
|
||||
|
||||
// Adjacent to enemy ArchSpirit.
|
||||
foreach (var eap in enemyArchPositions)
|
||||
{
|
||||
bool adjacent = board.HexSides > 0
|
||||
? HexGrid.Distance(unit.Position.Value, eap, board.HexSides) == 1
|
||||
: unit.Position.Value.IsOrthogonallyAdjacentTo(eap);
|
||||
if (adjacent) { score += 15f; break; }
|
||||
}
|
||||
|
||||
// Center control (square grid only for simplicity).
|
||||
if (board.HexSides == 0)
|
||||
{
|
||||
int dx = Math.Abs(unit.Position.Value.X - cx);
|
||||
int dy = Math.Abs(unit.Position.Value.Y - cy);
|
||||
if (dx <= centerRadius && dy <= centerRadius)
|
||||
score += 2f;
|
||||
}
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resource = −10 if SP well above typical per-turn gain (penalise hoarding)
|
||||
/// + +5 per Sacrifice Token.
|
||||
/// </summary>
|
||||
private static float ResourceScore(GameState state, PlayerState aiPlayer)
|
||||
{
|
||||
float score = 0f;
|
||||
|
||||
// Penalise excessive unspent SP.
|
||||
int spPerTurn = state.Rules.SpAccumulationPerTurn;
|
||||
if (spPerTurn > 0 && aiPlayer.CurrentSp > spPerTurn * 3)
|
||||
score -= 10f;
|
||||
|
||||
// Sacrifice tokens are immediately valuable.
|
||||
score += aiPlayer.CurrentSt * 5f;
|
||||
|
||||
return score;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
namespace SOR.Ai.Heuristics;
|
||||
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Database.Enums;
|
||||
using SOR.Game;
|
||||
using SOR.Game.Combat;
|
||||
using SOR.Game.Grid;
|
||||
|
||||
/// <summary>
|
||||
/// Detects enemy units that can reach (attack) the AI's ArchSpirit on the next turn.
|
||||
/// Used by ScoringFunctions to penalise board states that leave the ArchSpirit exposed.
|
||||
/// </summary>
|
||||
internal static class ThreatDetector
|
||||
{
|
||||
/// <summary>
|
||||
/// Returns the number of opponent units that could attack the AI's ArchSpirit
|
||||
/// if the opponent were to act right now (ignoring exhaustion resets between turns).
|
||||
///
|
||||
/// Conservative over-estimate: assumes all opponent units are fresh (max MP restored).
|
||||
/// </summary>
|
||||
public static int CountThreatsToArchSpirit(AiTurnContext ctx)
|
||||
{
|
||||
var state = ctx.State;
|
||||
var board = state.Board;
|
||||
var archSpirit = ctx.AiPlayer.ArchSpirit;
|
||||
|
||||
if (archSpirit?.Position is null || board is null)
|
||||
return 0;
|
||||
|
||||
var archPos = archSpirit.Position.Value;
|
||||
var occupancy = board.BuildOccupancyMap();
|
||||
int threats = 0;
|
||||
|
||||
foreach (var enemyId in ctx.OpponentIds)
|
||||
{
|
||||
var enemy = state.Players[enemyId];
|
||||
|
||||
foreach (var unit in AllEnemyUnits(enemy))
|
||||
{
|
||||
if (unit.Position is null || !unit.CanAttack) continue;
|
||||
|
||||
var minRange = unit.MinAttackRange ?? 1;
|
||||
var maxRange = unit.MaxAttackRange ?? 1;
|
||||
|
||||
// Check direct attack range first (fast path).
|
||||
if (AttackSystem.CanAttack(
|
||||
unit.Position.Value, archPos,
|
||||
minRange, maxRange, unit.RequiresLos,
|
||||
board, occupancy))
|
||||
{
|
||||
threats++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Check if the unit can move into attack range.
|
||||
int mp = unit.MaxMp ?? 0; // restored at start of enemy turn
|
||||
if (mp <= 0) continue;
|
||||
|
||||
if (CanReachAttackRange(unit, archPos, mp, minRange, maxRange, state, board))
|
||||
threats++;
|
||||
}
|
||||
}
|
||||
|
||||
return threats;
|
||||
}
|
||||
|
||||
// ── Helpers ───────────────────────────────────────────────────────────────
|
||||
|
||||
private static bool CanReachAttackRange(
|
||||
FieldCard unit, Coord target, int mp,
|
||||
int minRange, int maxRange,
|
||||
GameState state, Board board)
|
||||
{
|
||||
// Build a hypothetical blocked set treating all current occupants as blockers.
|
||||
var blocked = new HashSet<Coord>();
|
||||
foreach (var p in state.Players.Values)
|
||||
{
|
||||
foreach (var fc in p.Field.OfType<FieldCard>())
|
||||
{
|
||||
if (fc.InstanceId == unit.InstanceId || !fc.Position.HasValue) continue;
|
||||
if (unit.MovementType == MovementType.Flight && fc.MovementType != MovementType.Flight) continue;
|
||||
blocked.Add(fc.Position.Value);
|
||||
}
|
||||
var arch = p.ArchSpirit;
|
||||
if (arch is not null && arch.InstanceId != unit.InstanceId && arch.Position.HasValue)
|
||||
{
|
||||
if (unit.MovementType != MovementType.Flight || arch.MovementType == MovementType.Flight)
|
||||
blocked.Add(arch.Position.Value);
|
||||
}
|
||||
}
|
||||
|
||||
var reachable = Pathfinding.GetReachableWithCost(
|
||||
board, unit.Position!.Value, mp, blocked);
|
||||
|
||||
var occupancy = board.BuildOccupancyMap();
|
||||
|
||||
foreach (var (reachableCoord, _) in reachable)
|
||||
{
|
||||
if (AttackSystem.CanAttack(
|
||||
reachableCoord, target,
|
||||
minRange, maxRange, unit.RequiresLos,
|
||||
board, occupancy))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private static IEnumerable<FieldCard> AllEnemyUnits(PlayerState enemy)
|
||||
{
|
||||
foreach (var fc in enemy.Field.OfType<FieldCard>())
|
||||
yield return fc;
|
||||
if (enemy.ArchSpirit is not null)
|
||||
yield return enemy.ArchSpirit;
|
||||
}
|
||||
}
|
||||
@@ -3,7 +3,9 @@ namespace SOR.Ai;
|
||||
using Microsoft.Extensions.Configuration;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using SOR.Ai.Core;
|
||||
using SOR.Ai.Engine;
|
||||
using SOR.Ai.Handlers;
|
||||
using SOR.Ai.Heuristics;
|
||||
using SOR.Ai.Lobby;
|
||||
using SOR.Ai.Seeding;
|
||||
using SOR.Networking.Abstractions.Messaging;
|
||||
@@ -41,6 +43,13 @@ public static class ServiceRegistration
|
||||
services.AddScoped<AiSlotAssigner>();
|
||||
services.AddScoped<AiLobbyService>();
|
||||
|
||||
// ── Decision engines (transient — each turn gets a fresh instance) ──────
|
||||
// Engines are resolved directly by AiPlayerSession via ResolveEngine(),
|
||||
// not injected via DI — they are pure stateless objects built from profiles.
|
||||
// Registering here for clarity and future testability.
|
||||
services.AddTransient<RandomDecisionEngine>();
|
||||
services.AddTransient<HeuristicDecisionEngine>();
|
||||
|
||||
// ── Lobby message handlers ────────────────────────────────────────────
|
||||
services.AddTransient<IMessageHandler, GameAddAiHandler>();
|
||||
services.AddTransient<IMessageHandler, GameRemoveAiHandler>();
|
||||
|
||||
Reference in New Issue
Block a user