diff --git a/Server/src/SOR.Ai/Engine/AiDifficultyProfiles.cs b/Server/src/SOR.Ai/Engine/AiDifficultyProfiles.cs
index 5ecd1eb..d4e4690 100644
--- a/Server/src/SOR.Ai/Engine/AiDifficultyProfiles.cs
+++ b/Server/src/SOR.Ai/Engine/AiDifficultyProfiles.cs
@@ -15,10 +15,10 @@ internal static class AiDifficultyProfiles
DisplayName = "Novice",
EngineType = "Random",
MistakeRate = 1.0f,
- MinThinkTimeMs = 600,
- MaxThinkTimeMs = 1400,
- MinActionDelayMs = 300,
- MaxActionDelayMs = 700,
+ MinThinkTimeMs = 300,
+ MaxThinkTimeMs = 700,
+ MinActionDelayMs = 150,
+ MaxActionDelayMs = 400,
},
// ── Tier 2: Apprentice (Heuristic, 60% mistakes) ─────────────────────
@@ -28,10 +28,10 @@ internal static class AiDifficultyProfiles
DisplayName = "Apprentice",
EngineType = "Heuristic",
MistakeRate = 0.60f,
- MinThinkTimeMs = 700,
- MaxThinkTimeMs = 1600,
- MinActionDelayMs = 400,
- MaxActionDelayMs = 900,
+ MinThinkTimeMs = 400,
+ MaxThinkTimeMs = 900,
+ MinActionDelayMs = 200,
+ MaxActionDelayMs = 500,
MaterialWeight = 1.0f,
AffinityControlWeight = 0.5f,
ThreatWeight = 0.5f,
@@ -46,10 +46,10 @@ internal static class AiDifficultyProfiles
DisplayName = "Journeyman",
EngineType = "Heuristic",
MistakeRate = 0.40f,
- MinThinkTimeMs = 800,
- MaxThinkTimeMs = 1800,
- MinActionDelayMs = 400,
- MaxActionDelayMs = 900,
+ MinThinkTimeMs = 400,
+ MaxThinkTimeMs = 1000,
+ MinActionDelayMs = 200,
+ MaxActionDelayMs = 500,
MaterialWeight = 1.0f,
AffinityControlWeight = 0.8f,
ThreatWeight = 0.8f,
@@ -64,10 +64,10 @@ internal static class AiDifficultyProfiles
DisplayName = "Adept",
EngineType = "Heuristic",
MistakeRate = 0.25f,
- MinThinkTimeMs = 900,
- MaxThinkTimeMs = 2000,
- MinActionDelayMs = 500,
- MaxActionDelayMs = 1100,
+ MinThinkTimeMs = 500,
+ MaxThinkTimeMs = 1100,
+ MinActionDelayMs = 250,
+ MaxActionDelayMs = 600,
MaterialWeight = 1.0f,
AffinityControlWeight = 1.0f,
ThreatWeight = 1.0f,
@@ -82,10 +82,10 @@ internal static class AiDifficultyProfiles
DisplayName = "Expert",
EngineType = "Heuristic",
MistakeRate = 0.10f,
- MinThinkTimeMs = 1000,
- MaxThinkTimeMs = 2200,
- MinActionDelayMs = 600,
- MaxActionDelayMs = 1200,
+ MinThinkTimeMs = 600,
+ MaxThinkTimeMs = 1300,
+ MinActionDelayMs = 300,
+ MaxActionDelayMs = 700,
MaterialWeight = 1.0f,
AffinityControlWeight = 1.2f,
ThreatWeight = 1.2f,
@@ -102,10 +102,10 @@ internal static class AiDifficultyProfiles
MistakeRate = 0.05f,
MctsTimeBudgetMs = 500,
MctsMaxDepth = 3,
- MinThinkTimeMs = 1200,
- MaxThinkTimeMs = 2500,
- MinActionDelayMs = 700,
- MaxActionDelayMs = 1400,
+ MinThinkTimeMs = 700,
+ MaxThinkTimeMs = 1500,
+ MinActionDelayMs = 400,
+ MaxActionDelayMs = 800,
MaterialWeight = 1.2f,
AffinityControlWeight = 1.4f,
ThreatWeight = 1.4f,
@@ -120,10 +120,10 @@ internal static class AiDifficultyProfiles
MistakeRate = 0.02f,
MctsTimeBudgetMs = 1500,
MctsMaxDepth = 5,
- MinThinkTimeMs = 1400,
- MaxThinkTimeMs = 3000,
- MinActionDelayMs = 800,
- MaxActionDelayMs = 1500,
+ MinThinkTimeMs = 800,
+ MaxThinkTimeMs = 1700,
+ MinActionDelayMs = 450,
+ MaxActionDelayMs = 900,
MaterialWeight = 1.3f,
AffinityControlWeight = 1.5f,
ThreatWeight = 1.5f,
@@ -138,10 +138,10 @@ internal static class AiDifficultyProfiles
MistakeRate = 0.0f,
MctsTimeBudgetMs = 4000,
MctsMaxDepth = 7,
- MinThinkTimeMs = 1500,
- MaxThinkTimeMs = 3200,
- MinActionDelayMs = 900,
- MaxActionDelayMs = 1600,
+ MinThinkTimeMs = 900,
+ MaxThinkTimeMs = 1800,
+ MinActionDelayMs = 500,
+ MaxActionDelayMs = 1000,
MaterialWeight = 1.4f,
AffinityControlWeight = 1.6f,
ThreatWeight = 1.6f,
@@ -157,10 +157,10 @@ internal static class AiDifficultyProfiles
MistakeRate = 0.0f,
MctsTimeBudgetMs = 6000,
MctsMaxDepth = 10,
- MinThinkTimeMs = 1500,
- MaxThinkTimeMs = 3000,
- MinActionDelayMs = 900,
- MaxActionDelayMs = 1600,
+ MinThinkTimeMs = 900,
+ MaxThinkTimeMs = 1800,
+ MinActionDelayMs = 500,
+ MaxActionDelayMs = 1000,
MaterialWeight = 1.5f,
AffinityControlWeight = 1.8f,
ThreatWeight = 1.8f,
@@ -175,10 +175,10 @@ internal static class AiDifficultyProfiles
MistakeRate = 0.0f,
MctsTimeBudgetMs = 10000,
MctsMaxDepth = 15,
- MinThinkTimeMs = 1500,
- MaxThinkTimeMs = 3000,
- MinActionDelayMs = 1000,
- MaxActionDelayMs = 1800,
+ MinThinkTimeMs = 1000,
+ MaxThinkTimeMs = 2000,
+ MinActionDelayMs = 600,
+ MaxActionDelayMs = 1100,
MaterialWeight = 1.6f,
AffinityControlWeight = 2.0f,
ThreatWeight = 2.0f,
diff --git a/Server/src/SOR.Ai/Heuristics/ScoringFunctions.cs b/Server/src/SOR.Ai/Heuristics/ScoringFunctions.cs
index 4445053..809d67e 100644
--- a/Server/src/SOR.Ai/Heuristics/ScoringFunctions.cs
+++ b/Server/src/SOR.Ai/Heuristics/ScoringFunctions.cs
@@ -9,45 +9,40 @@ using SOR.Game.Grid;
///
/// 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.
+/// Score = Σ (weight × feature). Higher = better for the AI.
+/// Weights come from AiDifficultyProfile so different difficulties/strategies
+/// produce different behaviour without code changes.
///
internal static class ScoringFunctions
{
- ///
- /// Evaluate the board state from the AI's perspective.
- /// Returns a dimensionless float — only the relative ordering of scores matters.
- ///
public static float Evaluate(
- GameState state,
- string aiAccountId,
+ 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);
+ 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);
+ float sacrificeOpportunity = SacrificeOpportunityScore(state, aiPlayer);
- return material * profile.MaterialWeight
- + affinityControl * profile.AffinityControlWeight
- + threat * profile.ThreatWeight
- + positional * profile.PositionalWeight
- + resource * profile.ResourceWeight;
+ return material * profile.MaterialWeight
+ + affinityControl * profile.AffinityControlWeight
+ + threat * profile.ThreatWeight
+ + positional * profile.PositionalWeight
+ + resource * profile.ResourceWeight
+ + sacrificeOpportunity * profile.ResourceWeight; // same weight as resource
}
- // ── Feature functions ──────────────────────────────────────────────────────
+ // ── Material ──────────────────────────────────────────────────────────────
///
- /// 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.
+ /// own unit power − opponent unit power + ArchSpirit HP ratio × 500.
+ /// ArchSpirit HP dominates: keeping yours alive and threatening theirs are top priorities.
///
private static float MaterialScore(GameState state, string aiAccountId)
{
@@ -57,38 +52,37 @@ internal static class ScoringFunctions
{
if (player.IsEliminated) continue;
- bool isOwn = playerId == aiAccountId;
- float sign = isOwn ? 1f : -1f;
+ bool isOwn = playerId == aiAccountId;
+ float sign = isOwn ? 1f : -1f;
- // Field units.
foreach (var fc in player.Field.OfType())
{
- if (fc.IsLeader) continue; // ArchSpirit counted separately.
- float value = (fc.Damage ?? 0) * 2f + (fc.MaxHealth ?? 0);
- score += sign * value;
+ if (fc.IsLeader) continue;
+ score += sign * ((fc.Damage ?? 0) * 2f + (fc.MaxHealth ?? 0));
}
- // 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
+ score += sign * (ratio * 500f);
}
}
return score;
}
+ // ── Affinity control + Terramorpha chaining ───────────────────────────────
+
///
- /// Affinity control = tiles with own ArchSpirit's affinity within channeling range × 3.
- /// Rewards building a "pool" of valid channeling tiles.
+ /// Coverage = number of affinity-matching tiles within ArchSpirit channeling range × 3.
+ /// Cluster bonus = +1.5 per tile that is adjacent to at least one other matching tile.
+ ///
+ /// The cluster bonus drives Terramorpha placements that extend an existing chain:
+ /// placing a Terramorpha adjacent to another already-converted tile scores higher
+ /// than an isolated placement, even when coverage gain is the same.
///
private static float AffinityControlScore(
GameState state, string aiAccountId, PlayerState aiPlayer)
@@ -97,14 +91,13 @@ internal static class ScoringFunctions
var archSpirit = aiPlayer.ArchSpirit;
if (board is null || archSpirit?.Position is null) return 0f;
-
- if (!Enum.TryParse(archSpirit.Affinity, out var aiAffinity))
- return 0f;
+ if (!Enum.TryParse(archSpirit.Affinity, out var aiAffinity)) return 0f;
var origin = archSpirit.Position.Value;
var maxRange = archSpirit.MaxChannelRange ?? 1;
- float count = 0f;
+ // Pass 1: collect all matching tiles within channeling range.
+ var matchingInRange = new HashSet();
foreach (var tile in board.Tiles.Values)
{
var dist = board.HexSides > 0
@@ -113,28 +106,72 @@ internal static class ScoringFunctions
if (dist > maxRange) continue;
if (AffinitySystem.IsAffinityValid(tile, aiAffinity))
- count++;
+ matchingInRange.Add(tile.Coord);
}
- return count * 3f;
+ float coverage = matchingInRange.Count * 3f;
+
+ // Pass 2: cluster bonus — each matching tile adjacent to another matching tile.
+ // Counted at most once per tile (break after first matching neighbour found)
+ // to avoid over-weighting large clusters.
+ float clusterBonus = 0f;
+ foreach (var coord in matchingInRange)
+ {
+ foreach (var neighbor in board.GetNeighbors(coord))
+ {
+ if (matchingInRange.Contains(neighbor))
+ {
+ clusterBonus += 1.5f;
+ break;
+ }
+ }
+ }
+
+ return coverage + clusterBonus;
}
+ // ── Threat ────────────────────────────────────────────────────────────────
+
///
- /// Threat = −30 per opponent unit that can reach the AI's ArchSpirit.
- /// A strong deterrent against leaving the ArchSpirit undefended.
+ /// Base penalty of −30 per enemy unit that can reach the AI's ArchSpirit.
+ /// Scaled up sharply when the ArchSpirit is damaged:
+ /// HP < 50% → additional −40 per threat
+ /// HP < 25% → additional −90 per threat (critical — flee or defend)
+ ///
+ /// This makes the AI increasingly aggressive about blocking/retreating as
+ /// its ArchSpirit loses health, rather than ignoring danger until it's too late.
///
private static float ThreatScore(
GameState state, string aiAccountId, PlayerState aiPlayer)
{
- var ctx = new AiTurnContext(state, aiAccountId);
- int threats = ThreatDetector.CountThreatsToArchSpirit(ctx);
- return -threats * 30f;
+ var ctx = new AiTurnContext(state, aiAccountId);
+ int threats = ThreatDetector.CountThreatsToArchSpirit(ctx);
+
+ if (threats == 0) return 0f;
+
+ float penalty = threats * 30f;
+
+ var arch = aiPlayer.ArchSpirit;
+ if (arch is not null)
+ {
+ float maxHp = arch.MaxHealth ?? 1f;
+ float curHp = arch.CurrentHealth ?? 0f;
+ float hpRatio = maxHp > 0 ? curHp / maxHp : 0f;
+
+ if (hpRatio < 0.25f)
+ penalty += threats * 90f; // critical HP — survival overrides everything
+ else if (hpRatio < 0.5f)
+ penalty += threats * 40f; // damaged — strongly prefer to defend
+ }
+
+ return -penalty;
}
+ // ── Positional ────────────────────────────────────────────────────────────
+
///
- /// 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.
+ /// +15 per own unit adjacent to any enemy ArchSpirit (pressure).
+ /// +2 per own unit in the board centre (control).
///
private static float PositionalScore(
GameState state, string aiAccountId, PlayerState aiPlayer)
@@ -143,13 +180,10 @@ internal static class ScoringFunctions
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();
foreach (var (id, p) in state.Players)
{
@@ -162,7 +196,6 @@ internal static class ScoringFunctions
{
if (unit.Position is null) continue;
- // Adjacent to enemy ArchSpirit.
foreach (var eap in enemyArchPositions)
{
bool adjacent = board.HexSides > 0
@@ -171,7 +204,6 @@ internal static class ScoringFunctions
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);
@@ -184,21 +216,71 @@ internal static class ScoringFunctions
return score;
}
+ // ── Resource ──────────────────────────────────────────────────────────────
+
///
- /// Resource = −10 if SP well above typical per-turn gain (penalise hoarding)
- /// + +5 per Sacrifice Token.
+ /// −10 for hoarding SP beyond 3× per-turn gain.
+ /// +8 per sacrifice token (raised: tokens are immediately fungible for strong plays).
///
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;
+ score += aiPlayer.CurrentSt * 8f;
+
+ return score;
+ }
+
+ // ── Sacrifice opportunity ─────────────────────────────────────────────────
+
+ ///
+ /// One-step lookahead: if there are sacrificeable units adjacent to the ArchSpirit,
+ /// check whether the ST gained from sacrificing them would unlock any card in hand
+ /// that is currently unaffordable. Add that card's estimated value to the score.
+ ///
+ /// Without this, the greedy engine sees sacrifice as a net negative (lose a unit)
+ /// and skips it — even though sacrifice + play on the same turn is strongly positive.
+ ///
+ private static float SacrificeOpportunityScore(GameState state, PlayerState aiPlayer)
+ {
+ if (!aiPlayer.CanSacrificeSpirit) return 0f;
+
+ var archSpirit = aiPlayer.ArchSpirit;
+ if (archSpirit?.Position is null) return 0f;
+
+ // Count units the AI could sacrifice right now.
+ int sacrificeableCount = 0;
+ foreach (var fc in aiPlayer.Field.OfType())
+ {
+ if (fc.IsLeader || !fc.CanBeSacrificed || fc.Position is null) continue;
+ if (fc.Position.Value.IsOrthogonallyAdjacentTo(archSpirit.Position.Value))
+ sacrificeableCount++;
+ }
+
+ if (sacrificeableCount == 0) return 0f;
+
+ float score = 0f;
+ int projectedSt = aiPlayer.CurrentSt + sacrificeableCount;
+
+ foreach (var card in aiPlayer.Hand)
+ {
+ // Only cards that are unaffordable now but reachable with sacrifice ST.
+ if (card.StCost <= aiPlayer.CurrentSt) continue;
+ if (card.StCost > projectedSt) continue;
+ if (card.SpCost > aiPlayer.CurrentSp) continue;
+
+ float value = card.CardType switch
+ {
+ "Spirit" => (card.Damage ?? 0) * 2f + (card.MaxHealth ?? 0) + 10f,
+ "Terramorpha" => 20f,
+ _ => 8f,
+ };
+ score += value;
+ }
return score;
}