478 lines
21 KiB
C#
478 lines
21 KiB
C#
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using UnityEngine;
|
||
|
||
namespace TKS
|
||
{
|
||
/// <summary>적 유닛 1기의 행동 후보 1건(가상 실행 결과 점수 포함).</summary>
|
||
public class AiPlan
|
||
{
|
||
public Unit Unit;
|
||
public Vector2 Target;
|
||
public bool UseSkill;
|
||
public float Score;
|
||
/// <summary>0 = 서포터(창병 밀기 · 책사 덤불 제거 · 이득 있는 버프) · 1 = 돌격(보·기·창) · 2 = 사격(궁·책).</summary>
|
||
public int Group;
|
||
public string Why = "";
|
||
public int Candidates;
|
||
public float Ms;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 적 AI 예측 시뮬레이션(PD 2026-11-06 #1098 · 전술규칙_적AI_기획서 §2): 후보 행동을 실제 규칙(ActionResolver · 기믹 · 스킬 · 견제)으로 가상 실행(Sim)해
|
||
/// ai_weights.csv 점수가 가장 높은 것을 고른다. 후보 = 방위(유닛 ≤ many_units = dirs · 넘으면 dirs_many) × 파워 3단 × 액티브 사용 여부 ·
|
||
/// 궁·책 = 사거리 안 표적 + (책사) 덤불 중심 + 방위 이동 · 유닛 1기 예산 budget_ms · 난이도 = aiAccuracy(보스 +boss_accuracy · 투기장 mode_accuracy)로
|
||
/// 최고 선택 · 아니면 상위 top_n 무작위 + 파워 ±noise_power · 턴 운영 = 서포터 → 돌격 → 사격 순, 1기 실행마다 재평가(BattleManager).
|
||
/// </summary>
|
||
public static class TacticalAI
|
||
{
|
||
static readonly List<float> lastEvalMs = new List<float>();
|
||
|
||
/// <summary>최근 평가 시간(ms · 성능 테스트용).</summary>
|
||
public static IReadOnlyList<float> LastEvalMs
|
||
{
|
||
get { return lastEvalMs; }
|
||
}
|
||
|
||
public static bool Available
|
||
{
|
||
get { return AiWeights.Load() != null; }
|
||
}
|
||
|
||
/// <summary>이 적 보스가 액티브를 쓰는가(1부 보스만 · 다음 행동형만 · ai_weights boss_active · active_max_chapter).</summary>
|
||
public static bool BossUsesActive(BalanceConfig.StageDef stage, BalanceConfig.EnemySpawn e)
|
||
{
|
||
var w = AiWeights.Load();
|
||
if (w == null || stage == null || e == null || !e.isBoss) return false;
|
||
return w["boss_active"] >= 0.5f && stage.chapter >= 1 && stage.chapter <= Mathf.RoundToInt(w["active_max_chapter"]);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 다음에 움직일 적 1기와 그 행동: 남은 유닛 전원 평가 → 그룹(서포터 → 돌격 → 사격) 순 · 같은 그룹은 점수 높은 순 → 그 유닛의 후보에서 난이도대로 고른다.
|
||
/// 교전 범위 밖(가장 가까운 아군이 aggro 보다 멂)은 대기 → null 이면 이번 턴 끝.
|
||
/// </summary>
|
||
public static AiPlan Next(BattleManager bm, List<Unit> pending, float accuracy, float aggro, System.Random rng)
|
||
{
|
||
lastEvalMs.Clear();
|
||
var w = AiWeights.Load();
|
||
if (w == null) return null;
|
||
var players = bm.AliveUnits(Faction.Player);
|
||
if (players.Count == 0) return null;
|
||
AiPlan best = null;
|
||
List<AiPlan> bestList = null;
|
||
int enemyCount = bm.AliveCount(Faction.Enemy);
|
||
foreach (var u in pending)
|
||
{
|
||
if (u == null || !u.IsAlive) continue;
|
||
if (NearestDist(u, players) > aggro) continue;
|
||
List<AiPlan> list;
|
||
var top = Evaluate(bm, u, enemyCount, out list);
|
||
if (top == null) continue;
|
||
if (best == null || top.Group < best.Group || (top.Group == best.Group && top.Score > best.Score))
|
||
{
|
||
best = top;
|
||
bestList = list;
|
||
}
|
||
}
|
||
if (best == null) return null;
|
||
return Choose(bm, best.Unit, bestList, accuracy, rng, w);
|
||
}
|
||
|
||
static float NearestDist(Unit u, List<Unit> players)
|
||
{
|
||
float best = float.MaxValue;
|
||
foreach (var p in players)
|
||
{
|
||
if (p.IsAlive) best = Mathf.Min(best, Vector2.Distance(u.Position, p.Position));
|
||
}
|
||
return best;
|
||
}
|
||
|
||
/// <summary>난이도: 최고 점수를 accuracy(+보스 · 투기장 = mode) 확률로 · 아니면 상위 top_n 중 무작위 + 파워 ±noise.</summary>
|
||
static AiPlan Choose(BattleManager bm, Unit u, List<AiPlan> list, float accuracy, System.Random rng, AiWeights w)
|
||
{
|
||
float acc = accuracy + (u.IsBoss ? w["boss_accuracy"] : 0f);
|
||
if (bm.Mode != null && bm.Mode.kind == OutGame.ArenaRules.Arena) acc = w["mode_accuracy"];
|
||
if (list.Count == 1 || rng.NextDouble() < acc) return list[0];
|
||
int n = Mathf.Clamp(Mathf.RoundToInt(w["top_n"]), 1, list.Count);
|
||
var pick = list[rng.Next(n)];
|
||
float noise = w["noise_power"];
|
||
Vector2 v = pick.Target - u.Position;
|
||
float k = 1f + ((float)rng.NextDouble() * 2f - 1f) * noise;
|
||
var copy = new AiPlan { Unit = pick.Unit, UseSkill = pick.UseSkill, Score = pick.Score, Group = pick.Group, Why = pick.Why + " · 오차", Candidates = pick.Candidates, Ms = pick.Ms };
|
||
float max = SkillMods.SlingMax(u);
|
||
v *= k;
|
||
if (v.magnitude > max) v = v.normalized * max;
|
||
copy.Target = bm.Board.ClampInside(u.Position + v, u.Radius);
|
||
return copy;
|
||
}
|
||
|
||
/// <summary>유닛 1기 평가: 후보마다 가상 실행 → 점수 내림차순 목록(list[0] = 최고).</summary>
|
||
public static AiPlan Evaluate(BattleManager bm, Unit u, int enemyCount, out List<AiPlan> list)
|
||
{
|
||
list = new List<AiPlan>();
|
||
var w = AiWeights.Load();
|
||
if (w == null || u == null || !u.IsAlive) return null;
|
||
var sw = Stopwatch.StartNew();
|
||
float budget = Mathf.Max(5f, w["budget_ms"]);
|
||
var cands = Candidates(bm, u, enemyCount, w);
|
||
var skills = bm.Skills != null ? bm.Skills.Of(u) : null;
|
||
bool canSkill = skills != null && skills.HasActive && skills.Active.Trigger == SkillTrigger.NextAction && skills.CooldownLeft(bm.TurnNumber) <= 0;
|
||
var resolver = new ActionResolver(bm.Config, bm, new System.Random(12345));
|
||
var snap = Sim.Take(bm);
|
||
int done = 0;
|
||
foreach (var t in cands)
|
||
{
|
||
for (int s = 0; s < (canSkill ? 2 : 1); s++)
|
||
{
|
||
if (sw.Elapsed.TotalMilliseconds > budget && list.Count > 0) break;
|
||
var plan = Simulate(bm, resolver, u, t, s == 1, snap, w);
|
||
done++;
|
||
if (plan != null) list.Add(plan);
|
||
}
|
||
}
|
||
list.Sort((a, b) => b.Score.CompareTo(a.Score));
|
||
float ms = (float)sw.Elapsed.TotalMilliseconds;
|
||
lastEvalMs.Add(ms);
|
||
if (list.Count == 0) return null;
|
||
list[0].Candidates = done;
|
||
list[0].Ms = ms;
|
||
return list[0];
|
||
}
|
||
|
||
/// <summary>후보 목표점: 방위 × 파워 3단 · 궁·책은 사거리(+접근) 안 표적 · 책사는 덤불 중심까지.</summary>
|
||
static List<Vector2> Candidates(BattleManager bm, Unit u, int enemyCount, AiWeights w)
|
||
{
|
||
var res = new List<Vector2>();
|
||
float sling = SkillMods.SlingMax(u);
|
||
int dirs = Mathf.Max(4, Mathf.RoundToInt(enemyCount > w["many_units"] ? w["dirs_many"] : w["dirs"]));
|
||
float[] powers = { w["power_1"], w["power_2"], w["power_3"] };
|
||
if (UnitTypeInfo.IsRanged(u.Type))
|
||
{
|
||
float reach = SkillMods.Range(u) + u.ArcherMoveAllow;
|
||
foreach (var p in bm.AliveUnits(Faction.Player))
|
||
{
|
||
float gap = Vector2.Distance(u.Position, p.Position) - u.Radius * Combat.CastRadiusScale - p.Radius;
|
||
if (gap <= reach + 0.5f) res.Add(p.Position); // 표적 = 그 유닛 중심(목표점 명중 크리)
|
||
}
|
||
var layer = GimmickLayer.Current;
|
||
if (u.Type == UnitType.Strategist && layer != null)
|
||
{
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (!g.BlocksMove || !g.Def.strategistClear) continue;
|
||
if (Vector2.Distance(u.Position, g.Shape.Center) - g.Shape.BoundingRadius <= reach) res.Add(g.Shape.Center);
|
||
}
|
||
}
|
||
dirs = Mathf.Max(4, dirs / 2); // 이동 후보(엄폐·고지 자리 잡기)
|
||
}
|
||
for (int i = 0; i < dirs; i++)
|
||
{
|
||
float a = i * Mathf.PI * 2f / dirs;
|
||
Vector2 d = new Vector2(Mathf.Cos(a), Mathf.Sin(a));
|
||
foreach (var k in powers) res.Add(bm.Board.ClampInside(u.Position + d * sling * k, u.Radius));
|
||
}
|
||
return res;
|
||
}
|
||
|
||
static AiPlan Simulate(BattleManager bm, ActionResolver resolver, Unit u, Vector2 target, bool useSkill, Sim.Snapshot snap, AiWeights w)
|
||
{
|
||
var o = new ActionOutcome();
|
||
float score;
|
||
string why;
|
||
Sim.Active = true;
|
||
try
|
||
{
|
||
if (useSkill) bm.Skills.Of(u).Reserved = true;
|
||
var before = Before(bm, snap);
|
||
Sim.Run(resolver.Resolve(u, target, false, o));
|
||
Sim.Run(bm.ApplyOverwatch(u, o));
|
||
score = Score(bm, u, o, useSkill, before, snap, w, out why);
|
||
}
|
||
finally
|
||
{
|
||
Sim.Active = false;
|
||
Sim.Restore(bm, snap);
|
||
}
|
||
int group = UnitTypeInfo.IsRanged(u.Type) ? 2 : 1;
|
||
if (why.Contains("서포트") || why.Contains("덤불")) group = 0;
|
||
return new AiPlan { Unit = u, Target = target, UseSkill = useSkill, Score = score, Group = group, Why = why };
|
||
}
|
||
|
||
class Pre
|
||
{
|
||
public readonly Dictionary<Unit, Sim.UnitSnap> Units = new Dictionary<Unit, Sim.UnitSnap>();
|
||
public readonly HashSet<GimmickInstance> Removed = new HashSet<GimmickInstance>();
|
||
}
|
||
|
||
static Pre Before(BattleManager bm, Sim.Snapshot snap)
|
||
{
|
||
var p = new Pre();
|
||
foreach (var x in snap.Units) p.Units[x.U] = x;
|
||
var layer = GimmickLayer.Current;
|
||
if (layer != null)
|
||
{
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (g.Removed || g.Broken) p.Removed.Add(g);
|
||
}
|
||
}
|
||
return p;
|
||
}
|
||
|
||
/// <summary>점수(기획서 §2-3) — 가상 실행 직후 상태 vs 실행 전.</summary>
|
||
static float Score(BattleManager bm, Unit u, ActionOutcome o, bool useSkill, Pre pre, Sim.Snapshot snap, AiWeights w, out string why)
|
||
{
|
||
var parts = new List<string>();
|
||
float s = 0f;
|
||
float playerDmg = 0f;
|
||
int kills = 0;
|
||
foreach (var kv in pre.Units)
|
||
{
|
||
var x = kv.Value;
|
||
var v = x.U;
|
||
if (v == null || x.Hp <= 0) continue;
|
||
int dmg = Mathf.Max(0, x.Hp - v.Hp);
|
||
if (v.Faction == Faction.Player)
|
||
{
|
||
playerDmg += dmg;
|
||
s += w["dmg_player"] * dmg;
|
||
if (v.Hp <= 0)
|
||
{
|
||
kills++;
|
||
s += w["kill_base"] + w["kill_hp_ratio"] * (x.MaxHp > 0 ? (float)x.Hp / x.MaxHp : 0f);
|
||
}
|
||
}
|
||
else s += w["dmg_own"] * dmg;
|
||
}
|
||
if (playerDmg > 0f) parts.Add("피해 " + playerDmg);
|
||
if (kills > 0) parts.Add("처치 " + kills);
|
||
|
||
var layer = GimmickLayer.Current;
|
||
if (layer != null)
|
||
{
|
||
foreach (var a in layer.Affected)
|
||
{
|
||
if (a.Unit == null) continue;
|
||
float val = w["gimmick_dest_bonus"] + a.Value;
|
||
s += a.Unit.Faction == Faction.Player ? val : -val;
|
||
if (a.Unit.Faction == Faction.Player) parts.Add("기믹 " + a.Kind);
|
||
}
|
||
// 플레이어 유닛을 폭약 수레 반경으로 밀어 넣음
|
||
foreach (var d in o.Displaced)
|
||
{
|
||
if (d.Unit == null || d.Unit.Faction != Faction.Player || !d.Unit.IsAlive) continue;
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (!g.BlocksMove || g.Def.projectile != GimmickProjectile.Destroy) continue;
|
||
float r = g.P(1, 0f);
|
||
if (Vector2.Distance(d.Unit.Position, g.Shape.Center) <= r && Vector2.Distance(d.From, g.Shape.Center) > r)
|
||
{
|
||
s += w["gimmick_dest_bonus"];
|
||
parts.Add("수레 반경");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (o.Chains > 0)
|
||
{
|
||
s += w["chain"] * o.Chains;
|
||
parts.Add("연쇄 " + o.Chains);
|
||
}
|
||
|
||
if (u.Type == UnitType.Spear)
|
||
{
|
||
var seen = new HashSet<Unit>();
|
||
int reach = 0;
|
||
foreach (var d in o.Displaced)
|
||
{
|
||
var a = d.Unit;
|
||
if (a == null || a == u || a.Faction != u.Faction || !a.IsAlive || !seen.Add(a)) continue;
|
||
if (Vector2.Distance(d.From, d.To) < 0.1f) continue;
|
||
foreach (var p in bm.AliveUnits(Faction.Player))
|
||
{
|
||
float before = Vector2.Distance(d.From, p.Position) - a.Radius - p.Radius;
|
||
float after = Vector2.Distance(a.Position, p.Position) - a.Radius - p.Radius;
|
||
if (after <= SkillMods.SlingMax(a) && after < before) reach++;
|
||
}
|
||
}
|
||
if (reach > 0)
|
||
{
|
||
s += w["support_reach"] * reach;
|
||
parts.Add("서포트 " + reach);
|
||
}
|
||
}
|
||
|
||
if (u.Type == UnitType.Cavalry)
|
||
{
|
||
var hit = new HashSet<Unit>();
|
||
foreach (var a in o.Attacked)
|
||
{
|
||
if (a != null && a.Faction == Faction.Player) hit.Add(a);
|
||
}
|
||
if (hit.Count > 0)
|
||
{
|
||
s += w["pierce_hit"] * hit.Count; // 복귀 성공·실패 점수 = 기병 복귀 제거로 삭제(PD 2026-11-10)
|
||
parts.Add("관통 " + hit.Count);
|
||
}
|
||
}
|
||
|
||
if (u.IsAlive && UnitTypeInfo.IsRanged(u.Type))
|
||
{
|
||
if (layer != null && Covered(u, bm, layer))
|
||
{
|
||
s += w["archer_cover"];
|
||
parts.Add("목책 엄폐");
|
||
}
|
||
if (layer != null && layer.ZoneAt(u.Position, GimmickZone.High) != null)
|
||
{
|
||
s += w["high_ground"];
|
||
parts.Add("고지");
|
||
}
|
||
if (OnCavalryLine(u, bm, layer))
|
||
{
|
||
s += w["cav_line"];
|
||
parts.Add("기병 관통선");
|
||
}
|
||
}
|
||
|
||
if (u.Type == UnitType.Strategist)
|
||
{
|
||
var hit = new HashSet<Unit>();
|
||
foreach (var a in o.Attacked)
|
||
{
|
||
if (a != null && a.Faction == Faction.Player) hit.Add(a);
|
||
}
|
||
if (hit.Count > 0)
|
||
{
|
||
s += w["splash_hit"] * hit.Count;
|
||
parts.Add("광역 " + hit.Count);
|
||
}
|
||
if (layer != null)
|
||
{
|
||
int routes = OpenedRoutes(bm, u, layer, pre);
|
||
if (routes > 0)
|
||
{
|
||
s += w["route_open"] * routes;
|
||
parts.Add("덤불 제거 " + routes);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (u.IsAlive && layer != null)
|
||
{
|
||
var burn = layer.ZoneAt(u.Position, GimmickZone.Burn);
|
||
if (burn != null) s += w["zone_end"] * burn.P(1, 0f) * u.MaxHp;
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (g.Zone != GimmickZone.Capture || !g.ZoneActive) continue;
|
||
float r = g.P(1, 0f);
|
||
if (Vector2.Distance(u.Position, g.Shape.Center) - u.Radius > r) continue;
|
||
bool foe = false;
|
||
foreach (var p in bm.AliveUnits(Faction.Player))
|
||
{
|
||
if (Vector2.Distance(p.Position, g.Shape.Center) - p.Radius <= r) foe = true;
|
||
}
|
||
if (!foe && g.Owner != (int)u.Faction)
|
||
{
|
||
s += w["banner"];
|
||
parts.Add("군기");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (useSkill && playerDmg <= 0f) s += w["skill_waste"];
|
||
if (useSkill) parts.Add("액티브");
|
||
|
||
if (playerDmg <= 0f && kills == 0 && u.IsAlive)
|
||
{
|
||
var start = pre.Units[u].Pos;
|
||
float before = float.MaxValue, after = float.MaxValue;
|
||
foreach (var p in bm.AliveUnits(Faction.Player))
|
||
{
|
||
before = Mathf.Min(before, Vector2.Distance(start, p.Position));
|
||
after = Mathf.Min(after, Vector2.Distance(u.Position, p.Position));
|
||
}
|
||
if (before < float.MaxValue)
|
||
{
|
||
float gain = before - after;
|
||
if (UnitTypeInfo.IsRanged(u.Type)) gain = Mathf.Min(gain, Mathf.Max(0f, before - SkillMods.Range(u))); // 원거리 = 사거리까지만 다가간다
|
||
s += w["approach"] * gain;
|
||
}
|
||
}
|
||
why = string.Join(" · ", parts.ToArray());
|
||
return s;
|
||
}
|
||
|
||
/// <summary>궁·책 종료 위치와 플레이어 근접 유닛 사이 직선에 목책(투사체 통과 · 이동 막힘)이 있는가.</summary>
|
||
static bool Covered(Unit u, BattleManager bm, GimmickLayer layer)
|
||
{
|
||
foreach (var p in bm.AliveUnits(Faction.Player))
|
||
{
|
||
if (!UnitTypeInfo.IsMelee(p.Type)) continue;
|
||
if (Vector2.Distance(p.Position, u.Position) > SkillMods.SlingMax(p) + 2f) continue;
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (!g.BlocksMove || g.Def.projectile != GimmickProjectile.Pass || g.Zone == GimmickZone.River) continue;
|
||
if (g.Shape.SegmentTouches(u.Position, p.Position)) return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>플레이어 기병의 관통 사정(슬링 + 반지름) 안이고 사이에 장애물이 없으면 관통선 위.</summary>
|
||
static bool OnCavalryLine(Unit u, BattleManager bm, GimmickLayer layer)
|
||
{
|
||
foreach (var c in bm.AliveUnits(Faction.Player))
|
||
{
|
||
if (c.Type != UnitType.Cavalry) continue;
|
||
if (Vector2.Distance(c.Position, u.Position) > SkillMods.SlingMax(c) + u.Radius) continue;
|
||
bool blocked = false;
|
||
if (layer != null)
|
||
{
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (g.BlocksMove && g.Shape.SegmentTouches(c.Position, u.Position)) blocked = true;
|
||
}
|
||
}
|
||
if (!blocked) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>이번 가상 실행으로 지워진 덤불 때문에 새로 열린 (적 측 유닛 → 플레이어 유닛) 직선 수(사거리·슬링 안 · 다른 장애물 없음).</summary>
|
||
static int OpenedRoutes(BattleManager bm, Unit shooter, GimmickLayer layer, Pre pre)
|
||
{
|
||
var cleared = new List<GimmickInstance>();
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (g.Removed && !pre.Removed.Contains(g) && g.Def.strategistClear) cleared.Add(g);
|
||
}
|
||
if (cleared.Count == 0) return 0;
|
||
int n = 0;
|
||
foreach (var a in bm.AliveUnits(shooter.Faction))
|
||
{
|
||
if (a == shooter) continue;
|
||
float reach = UnitTypeInfo.IsRanged(a.Type) ? SkillMods.Range(a) + a.ArcherMoveAllow : SkillMods.SlingMax(a);
|
||
foreach (var p in bm.AliveUnits(Faction.Player))
|
||
{
|
||
if (Vector2.Distance(a.Position, p.Position) - a.Radius - p.Radius > reach) continue;
|
||
bool wasBlocked = false;
|
||
foreach (var g in cleared)
|
||
{
|
||
if (g.Shape.SegmentTouches(a.Position, p.Position, a.Radius * 0.8f)) wasBlocked = true;
|
||
}
|
||
if (!wasBlocked) continue;
|
||
bool stillBlocked = false;
|
||
foreach (var g in layer.Items)
|
||
{
|
||
if (g.BlocksMove && g.Shape.SegmentTouches(a.Position, p.Position, a.Radius * 0.8f)) stillBlocked = true;
|
||
}
|
||
if (!stillBlocked) n++;
|
||
}
|
||
}
|
||
return n;
|
||
}
|
||
}
|
||
}
|