768 lines
31 KiB
C#
768 lines
31 KiB
C#
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
|
||
namespace TKS
|
||
{
|
||
/// <summary>
|
||
/// 보급전 전투(컨텐츠 모드 기획 10판 ① · 개발 요청서 B) — 던전 4곳의 전투 규칙과 판정 값.
|
||
/// 입장 · 보상 · 소탕 · 서버 연결은 OutGame/Supply/SupplyRules · 화면은 SupplyScreen.
|
||
/// </summary>
|
||
public static class SupplyBattle
|
||
{
|
||
/// <summary>던전 · 단계의 전투 준비 — 적 편성(StageDef) · 규칙 · 제한 턴. 표가 모자라면 why 에 까닭.</summary>
|
||
public static SupplyRulesBase Create(BalanceConfig cfg, string dungeonId, int tier, out BalanceConfig.StageDef stage, out string why)
|
||
{
|
||
stage = null;
|
||
why = null;
|
||
ContentTables.Reload();
|
||
var d = SupplyData.GetDungeon(dungeonId);
|
||
var t = SupplyData.GetTier(tier);
|
||
if (d == null || t == null)
|
||
{
|
||
why = "표에 없는 던전 · 단계";
|
||
return null;
|
||
}
|
||
SupplyRulesBase r;
|
||
switch (dungeonId)
|
||
{
|
||
case SupplyData.Tactics: r = new TacticsRules(); break;
|
||
case SupplyData.Granary: r = new GranaryRules(); break;
|
||
case SupplyData.Drill: r = new DrillRules(); break;
|
||
case SupplyData.BanditId: r = new BanditRules(); break;
|
||
default:
|
||
why = "규칙이 없는 던전 " + dungeonId;
|
||
return null;
|
||
}
|
||
r.Dungeon = d;
|
||
r.Tier = t;
|
||
r.Config = cfg;
|
||
stage = new BalanceConfig.StageDef { title = d.nameKo + " " + tier + "단계", subtitle = "보급전", chapter = 0, stage = 0, kind = StageKind.Normal, aiAccuracy = 1f, aiAggroRange = 999f };
|
||
var refSt = ContentEnemyRef.RefStage(cfg, t.Chapter);
|
||
if (refSt != null)
|
||
{
|
||
stage.aiAccuracy = refSt.aiAccuracy;
|
||
stage.aiAggroRange = refSt.aiAggroRange;
|
||
stage.faction = refSt.faction;
|
||
stage.bgTheme = refSt.bgTheme;
|
||
}
|
||
why = r.Prepare(stage);
|
||
return why == null ? r : null;
|
||
}
|
||
}
|
||
|
||
/// <summary>보급전 4곳 공통 — 던전 · 단계 · 제한 턴 · 판정 값.</summary>
|
||
public abstract class SupplyRulesBase : ModeBattleRules
|
||
{
|
||
public SupplyData.Dungeon Dungeon;
|
||
public SupplyData.Tier Tier;
|
||
public BalanceConfig Config;
|
||
protected readonly List<ContentLayoutRow> layout = new List<ContentLayoutRow>();
|
||
protected readonly List<Vector2> allySlots = new List<Vector2>();
|
||
|
||
public int TurnLimit
|
||
{
|
||
get { return Dungeon != null ? Dungeon.turnLimit : 0; }
|
||
}
|
||
|
||
/// <summary>적 편성 · 자리 표 읽기(null = 준비 끝 · 글 = 입장할 수 없는 까닭).</summary>
|
||
public abstract string Prepare(BalanceConfig.StageDef stage);
|
||
|
||
public override Vector2 AllyPosition(int slot, Vector2 fallback)
|
||
{
|
||
return slot >= 0 && slot < allySlots.Count ? allySlots[slot] : fallback;
|
||
}
|
||
|
||
/// <summary>자리 표(supply_layout · 키 = s_dungeon + n_tier · n_tier 0 = 모든 단계 공용)에서 이 던전 · 단계의 줄.</summary>
|
||
protected string LoadSpots()
|
||
{
|
||
layout.Clear();
|
||
var rows = ContentTables.Rows(SupplyData.SpotLayout);
|
||
if (rows.Count == 0) return "배치 표 대기(" + SupplyData.SpotLayout + ".csv · 기획 세션 요청 중)";
|
||
bool exact = false;
|
||
foreach (var r in rows)
|
||
if (r.S("s_dungeon") == Dungeon.id && r.I("n_tier") == Tier.tier) exact = true;
|
||
foreach (var r in rows)
|
||
if (r.S("s_dungeon") == Dungeon.id && r.I("n_tier") == (exact ? Tier.tier : 0)) layout.Add(ContentLayoutRow.From(r));
|
||
layout.Sort((a, b) => a.slot.CompareTo(b.slot));
|
||
if (layout.Count == 0) return "배치 표에 " + Dungeon.id + " 자리가 없음";
|
||
ReadAllySlots();
|
||
return null;
|
||
}
|
||
|
||
protected void ReadAllySlots()
|
||
{
|
||
allySlots.Clear();
|
||
foreach (var r in layout)
|
||
if (r.side == "ally_slot") allySlots.Add(r.pos);
|
||
}
|
||
|
||
protected void SpawnLayoutGimmicks()
|
||
{
|
||
var layer = Battle != null ? Battle.Gimmicks : null;
|
||
foreach (var r in layout)
|
||
if (r.side == "gimmick") ContentLayout.SpawnGimmick(layer, r);
|
||
}
|
||
|
||
public override BattlePhase OnTurnLimit(out string message)
|
||
{
|
||
float? v = JudgeValue;
|
||
string g;
|
||
float pct;
|
||
SupplyData.Judge(Dungeon, true, v ?? 0f, Tasks, out g, out pct);
|
||
if (Dungeon.gradeBy == "more" && g.Length > 0)
|
||
{
|
||
message = TurnLimit + "턴 종료 — 판정 " + g;
|
||
return BattlePhase.StageClear;
|
||
}
|
||
message = TurnLimit + "턴 종료";
|
||
return BattlePhase.Defeat;
|
||
}
|
||
|
||
/// <summary>이번 판의 판정(결과 화면 · 서버 판정과 같은 규칙).</summary>
|
||
public void Verdict(bool win, out string grade, out float pct)
|
||
{
|
||
float? v = JudgeValue;
|
||
SupplyData.Judge(Dungeon, win, v ?? 0f, Tasks, out grade, out pct);
|
||
}
|
||
}
|
||
|
||
// ---------- 병법 훈련 ----------
|
||
|
||
/// <summary>
|
||
/// 병법 훈련(supply_tactics_stages · 좌표 supply_tactics_layout · 부품 supply_tactics_parts) — 단계마다 정해진 전장 · 적 · 훈련 조건 1 · 과제 2.
|
||
/// 승리 = ★ win · 과제마다 ★ task(최대 max). 훈련 조건: 가호 · 금기(병종 피해 배율) · 정예(출전 수) · 절제(스킬 횟수) · 역풍(발사 거리) · 선제(적 먼저) · 맹세(아군 1기 쓰러지면 패배).
|
||
/// </summary>
|
||
public class TacticsRules : SupplyRulesBase
|
||
{
|
||
SupplyData.TacticsStage st;
|
||
int maxAllies;
|
||
UnitType ruleType;
|
||
bool hasRuleType;
|
||
List<float> ruleNums = new List<float>();
|
||
|
||
// 과제 집계
|
||
int kills, killsThisTurn, bestTurnKills, vanguardKills, counterHits, doubleShots, matchupKills, terrainKills, slams;
|
||
bool allyLost, kingFirstOk = true, kingDown;
|
||
int skillUses;
|
||
|
||
public override string Prepare(BalanceConfig.StageDef stage)
|
||
{
|
||
st = SupplyData.GetTactics(Tier.tier);
|
||
if (st == null) return "병법 훈련 " + Tier.tier + "단계 표 없음";
|
||
layout.Clear();
|
||
layout.AddRange(ContentLayout.Rows(SupplyData.TacticsLayout, "n_tier", Tier.tier.ToString()));
|
||
if (layout.Count == 0) return "병법 훈련 " + Tier.tier + "단계 배치 없음";
|
||
ReadAllySlots();
|
||
maxAllies = allySlots.Count;
|
||
ruleNums = SupplyData.PartNumbers("rule", st.rule);
|
||
hasRuleType = SupplyData.TypeFromKorean(st.ruleArgKo, out ruleType);
|
||
if (st.rule == "elite" && ruleNums.Count > 0) maxAllies = Mathf.Min(maxAllies, Mathf.RoundToInt(ruleNums[0]));
|
||
stage.title = "병법 훈련 " + Tier.tier + "단계 — " + st.themeKo;
|
||
int ch = Tier.Chapter;
|
||
foreach (var r in layout)
|
||
if (r.side == "enemy") stage.enemies.Add(ContentLayout.Enemy(Config, ch, r));
|
||
return null;
|
||
}
|
||
|
||
public override int MaxAllies
|
||
{
|
||
get { return maxAllies; }
|
||
}
|
||
|
||
public override bool EnemyFirst
|
||
{
|
||
get { return st != null && st.rule == "ambush"; }
|
||
}
|
||
|
||
public override void OnBegin()
|
||
{
|
||
SpawnLayoutGimmicks();
|
||
}
|
||
|
||
public override float DealtMult(Unit a, Unit d)
|
||
{
|
||
if (st == null || a == null || a.Faction != Faction.Player) return 1f;
|
||
if (st.rule == "favor" && hasRuleType && ruleNums.Count >= 2) return 1f + (a.Type == ruleType ? ruleNums[0] : ruleNums[1]) / 100f;
|
||
if (st.rule == "taboo" && hasRuleType && ruleNums.Count >= 1 && a.Type == ruleType) return 1f + ruleNums[0] / 100f;
|
||
return 1f;
|
||
}
|
||
|
||
public override float SlingMult(Unit u)
|
||
{
|
||
if (st != null && st.rule == "headwind" && u != null && u.Faction == Faction.Player && ruleNums.Count >= 1) return 1f + ruleNums[0] / 100f;
|
||
return 1f;
|
||
}
|
||
|
||
public override string SkillBlocked(Unit u)
|
||
{
|
||
if (st == null || st.rule != "temper" || ruleNums.Count == 0 || u == null || u.Faction != Faction.Player) return null;
|
||
int max = Mathf.RoundToInt(ruleNums[0]);
|
||
return skillUses >= max ? "절제 — 이 판의 스킬 " + max + "회를 모두 썼습니다" : null;
|
||
}
|
||
|
||
public override void OnActiveUsed(Unit u)
|
||
{
|
||
if (u != null && u.Faction == Faction.Player) skillUses++;
|
||
}
|
||
|
||
public override IEnumerator OnTurnStart(Faction f)
|
||
{
|
||
if (f == Faction.Player) killsThisTurn = 0;
|
||
yield break;
|
||
}
|
||
|
||
public override void OnAction(Unit actor, ActionOutcome o)
|
||
{
|
||
if (actor == null || actor.Faction != Faction.Player || o == null) return;
|
||
var hit = new HashSet<Unit>();
|
||
foreach (var a in o.Attacked)
|
||
if (a != null && a.Faction == Faction.Enemy) hit.Add(a);
|
||
if (hit.Count >= 2) doubleShots++;
|
||
}
|
||
|
||
public override void OnDamaged(Unit d, int dealt, Unit by, HitKind kind, int before)
|
||
{
|
||
if (d != null) lastHitKind[d] = kind; // 지형 처치 판정(마지막 피해가 기믹)
|
||
if (d != null && d.Faction == Faction.Player && kind == HitKind.Counter) counterHits++;
|
||
}
|
||
|
||
public override void OnSlam(Unit target, Unit pusher)
|
||
{
|
||
if (target != null && target.Faction == Faction.Enemy) slams++;
|
||
}
|
||
|
||
public override void OnDeath(Unit d, Unit by)
|
||
{
|
||
if (d == null) return;
|
||
if (d.Faction == Faction.Player)
|
||
{
|
||
if (!d.Npc && !SkillSystem.IsSummon(d)) allyLost = true;
|
||
return;
|
||
}
|
||
kills++;
|
||
if (Battle != null && Battle.Phase != BattlePhase.EnemyTurn)
|
||
{
|
||
killsThisTurn++;
|
||
bestTurnKills = Mathf.Max(bestTurnKills, killsThisTurn);
|
||
}
|
||
if (Battle != null && Battle.TurnNumber <= 2) vanguardKills++;
|
||
var lastKind = lastHitKind.ContainsKey(d) ? lastHitKind[d] : HitKind.Attack;
|
||
if (lastKind == HitKind.Gimmick || by == null) terrainKills++;
|
||
else if (by.Faction == Faction.Player && Config.Matchup(by.Type, d.Type) > 1f) matchupKills++;
|
||
if (d.IsBoss)
|
||
{
|
||
kingDown = true;
|
||
}
|
||
else if (!kingDown && HasCaptain) kingFirstOk = false; // 대장보다 호위가 먼저 쓰러졌다
|
||
}
|
||
|
||
readonly Dictionary<Unit, HitKind> lastHitKind = new Dictionary<Unit, HitKind>();
|
||
|
||
bool HasCaptain
|
||
{
|
||
get
|
||
{
|
||
foreach (var r in layout)
|
||
if (r.side == "enemy" && r.boss) return true;
|
||
return false;
|
||
}
|
||
}
|
||
|
||
public override bool CheckEnd(out BattlePhase phase, out string message)
|
||
{
|
||
phase = BattlePhase.PlayerTurn;
|
||
message = null;
|
||
if (st != null && st.rule == "oath" && allyLost)
|
||
{
|
||
phase = BattlePhase.Defeat;
|
||
message = "맹세 — 아군이 쓰러져 패배";
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool TaskDone(string id, int n)
|
||
{
|
||
if (Battle == null) return false;
|
||
switch (id)
|
||
{
|
||
case "fast": return Battle.Phase == BattlePhase.StageClear && Battle.TurnNumber <= n;
|
||
case "sweep": return bestTurnKills >= n;
|
||
case "vanguard": return vanguardKills >= n;
|
||
case "nodeath": return !allyLost;
|
||
case "ironwall": return HpPct() >= n;
|
||
case "nocounter": return counterHits <= n;
|
||
case "double": return doubleShots >= n;
|
||
case "matchup": return matchupKills >= n;
|
||
case "terrain": return terrainKills >= n;
|
||
case "slam": return slams >= n;
|
||
case "kingfirst": return kingDown && kingFirstOk;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
float HpPct()
|
||
{
|
||
float hp = 0f, max = 0f;
|
||
foreach (var u in Battle.Units)
|
||
{
|
||
if (u == null || u.Faction != Faction.Player || u.Npc || SkillSystem.IsSummon(u)) continue;
|
||
hp += Mathf.Max(0, u.Hp);
|
||
max += u.MaxHp;
|
||
}
|
||
return max > 0f ? hp / max * 100f : 0f;
|
||
}
|
||
|
||
public override bool[] Tasks
|
||
{
|
||
get { return st == null ? null : new[] { TaskDone(st.task1, st.n1), TaskDone(st.task2, st.n2) }; }
|
||
}
|
||
|
||
public override string ProgressLine
|
||
{
|
||
get
|
||
{
|
||
if (st == null) return "";
|
||
var t = Tasks;
|
||
return "과제 " + (t[0] ? "●" : "○") + (t[1] ? "●" : "○") + (st.rule != "none" ? " · " + st.ruleKo : "");
|
||
}
|
||
}
|
||
|
||
public override void Summarize(List<string> lines)
|
||
{
|
||
if (st == null) return;
|
||
var t = Tasks;
|
||
lines.Add("과제 1 「" + SupplyData.TaskText(st.task1, st.n1) + "」 " + (t[0] ? "달성" : "미달성"));
|
||
lines.Add("과제 2 「" + SupplyData.TaskText(st.task2, st.n2) + "」 " + (t[1] ? "달성" : "미달성"));
|
||
}
|
||
|
||
}
|
||
|
||
// ---------- 군량고 습격 ----------
|
||
|
||
/// <summary>군량고 습격 — 후보 자리(supply_layout granary_spot) 가운데 supply.granary_count 채를 무작위로 · 제한 턴 안에 부순 수 = 판정 값(more).</summary>
|
||
public class GranaryRules : SupplyRulesBase
|
||
{
|
||
readonly List<GimmickInstance> granaries = new List<GimmickInstance>();
|
||
int broken;
|
||
|
||
public override string Prepare(BalanceConfig.StageDef stage)
|
||
{
|
||
var why = LoadSpots();
|
||
if (why != null) return why;
|
||
if (GimmickTables.Db == null || GimmickTables.Db.Get(SupplyData.Granary) == null) return "기믹 정의 대기(gimmicks.csv granary · TKS/Import Gimmicks)";
|
||
foreach (var r in layout)
|
||
if (r.side == "granary_spot" && r.wOrR <= 0f) return "군량고 자리 크기 없음(supply_layout granary_spot f_w_or_r · 기획 세션 요청 중)";
|
||
int ch = Tier.Chapter;
|
||
foreach (var r in layout)
|
||
if (r.side == "enemy") stage.enemies.Add(ContentLayout.Enemy(Config, ch, r));
|
||
return null;
|
||
}
|
||
|
||
public override bool EliminationVictory
|
||
{
|
||
get { return false; }
|
||
}
|
||
|
||
public override void OnBegin()
|
||
{
|
||
SpawnLayoutGimmicks();
|
||
var spots = new List<ContentLayoutRow>();
|
||
foreach (var r in layout)
|
||
if (r.side == "granary_spot") spots.Add(r);
|
||
int n = Mathf.Min(spots.Count, ContentTables.Int(SupplyData.Mode, "granary_count"));
|
||
var rng = Battle.Rng;
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
int k = rng.Next(spots.Count);
|
||
var r = spots[k];
|
||
spots.RemoveAt(k);
|
||
var g = ContentLayout.SpawnGimmick(Battle.Gimmicks, new ContentLayoutRow { gimmickId = SupplyData.Granary, shape = r.shape.Length > 0 ? r.shape : "circle", pos = r.pos, wOrR = r.wOrR, h = r.h, line = r.line });
|
||
if (g != null) granaries.Add(g);
|
||
}
|
||
}
|
||
|
||
public override void OnGimmickBroken(GimmickInstance g, Unit by)
|
||
{
|
||
if (granaries.Contains(g) && (by == null || by.Faction == Faction.Player)) broken++; // 적이 부순 것은 세지 않는다(기획 세션에 알림)
|
||
}
|
||
|
||
public override bool CheckEnd(out BattlePhase phase, out string message)
|
||
{
|
||
phase = BattlePhase.PlayerTurn;
|
||
message = null;
|
||
bool all = granaries.Count > 0;
|
||
foreach (var g in granaries)
|
||
if (!g.Broken) all = false;
|
||
if (all) // 남은 군량고가 없다 = 끝(판정 = 아군이 부순 수)
|
||
{
|
||
string g;
|
||
float pct;
|
||
SupplyData.Judge(Dungeon, true, broken, null, out g, out pct);
|
||
phase = g.Length > 0 ? BattlePhase.StageClear : BattlePhase.Defeat;
|
||
message = "군량고가 모두 불탔습니다";
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public override float? JudgeValue
|
||
{
|
||
get { return broken; }
|
||
}
|
||
|
||
public override string ProgressLine
|
||
{
|
||
get { return "부순 군량고 " + broken + " / " + granaries.Count; }
|
||
}
|
||
|
||
public override void Summarize(List<string> lines)
|
||
{
|
||
lines.Add("부순 군량고 " + broken + " / " + granaries.Count);
|
||
}
|
||
}
|
||
|
||
// ---------- 연병장 훈련 ----------
|
||
|
||
/// <summary>
|
||
/// 연병장 훈련 — 허수아비(적 진영 · 움직이지 않음 · 반격 0 · 밀리지 않음 · 승패 인원 제외)가 늘 supply.drill_active_by_tier 개 ·
|
||
/// 부수면 drill_respawn_sec 뒤 다른 자리(drill_spawn_exclude · drill_hard_max · drill_zone_streak_max)에서 솟는다 · 준 피해 합(남은 체력을 넘는 피해 제외 ·
|
||
/// 황금 = × f_score_mult) ÷ 목표 피해(짚 체력 × 동시 수 × drill_s_target_per_active) = 판정 값(%).
|
||
/// </summary>
|
||
public class DrillRules : SupplyRulesBase
|
||
{
|
||
class Dummy
|
||
{
|
||
public Unit unit;
|
||
public ContentRow kind;
|
||
public ContentLayoutRow spot;
|
||
public int bornTurn;
|
||
}
|
||
|
||
readonly List<ContentLayoutRow> spots = new List<ContentLayoutRow>();
|
||
readonly List<Dummy> dummies = new List<Dummy>();
|
||
readonly HashSet<string> hardZones = new HashSet<string>();
|
||
int active, strawHp, hardMax, streakMax;
|
||
string lastZone = "";
|
||
int streak;
|
||
float score, target;
|
||
|
||
public override string Prepare(BalanceConfig.StageDef stage)
|
||
{
|
||
var why = LoadSpots();
|
||
if (why != null) return why;
|
||
foreach (var r in layout)
|
||
if (r.side == "drill_spot") spots.Add(r);
|
||
if (spots.Count == 0) return "연병장 자리 없음";
|
||
foreach (var z in ContentTables.Rows(SupplyData.DrillZones))
|
||
if (z.B("b_hard")) hardZones.Add(z.S("s_zone"));
|
||
active = Mathf.RoundToInt(ContentTables.Step(SupplyData.Mode, "drill_active_by_tier", Tier.tier, ContentTables.Num(SupplyData.Mode, "drill_active")));
|
||
hardMax = ContentTables.Int(SupplyData.Mode, "drill_hard_max");
|
||
streakMax = ContentTables.Int(SupplyData.Mode, "drill_zone_streak_max");
|
||
// 짚 허수아비 체력 = 그 단계 장 마지막 스테이지의 적 보병 체력(common.enemy_ref = 게임 스테이지 적) × supply.drill_dummy_hp_mult
|
||
strawHp = Mathf.Max(1, Mathf.RoundToInt(ContentEnemyRef.Hp(Config, ContentEnemyRef.LastStage(Config, Tier.Chapter), UnitType.Infantry, false) * ContentTables.Num(SupplyData.Mode, "drill_dummy_hp_mult")));
|
||
target = strawHp * active * ContentTables.Num(SupplyData.Mode, "drill_s_target_per_active");
|
||
return null;
|
||
}
|
||
|
||
public override bool EliminationVictory
|
||
{
|
||
get { return false; }
|
||
}
|
||
|
||
public override bool EnemyActs(Unit e)
|
||
{
|
||
return Find(e) == null;
|
||
}
|
||
|
||
public override bool CountsForVictory(Unit u)
|
||
{
|
||
return Find(u) == null;
|
||
}
|
||
|
||
public override bool NoMatchup(Unit d)
|
||
{
|
||
return Find(d) != null;
|
||
}
|
||
|
||
public override bool StatusImmune(Unit d)
|
||
{
|
||
return Find(d) != null;
|
||
}
|
||
|
||
Dummy Find(Unit u)
|
||
{
|
||
foreach (var d in dummies)
|
||
if (d.unit == u) return d;
|
||
return null;
|
||
}
|
||
|
||
public override void OnBegin()
|
||
{
|
||
SpawnLayoutGimmicks();
|
||
// 시작 = drill_start(「plain:3;hard:2」 — 쉬운 자리 · 어려운 자리 수)
|
||
var start = ContentTables.Map(SupplyData.Mode, "drill_start");
|
||
float v;
|
||
int plain = start.TryGetValue("plain", out v) ? Mathf.RoundToInt(v) : active;
|
||
int hard = start.TryGetValue("hard", out v) ? Mathf.RoundToInt(v) : 0;
|
||
for (int i = 0; i < plain; i++) Spawn(false, false);
|
||
for (int i = 0; i < hard; i++) Spawn(true, false);
|
||
while (Alive() < active && Spawn(null, false)) { }
|
||
}
|
||
|
||
int Alive()
|
||
{
|
||
int n = 0;
|
||
foreach (var d in dummies)
|
||
if (d.unit != null && d.unit.IsAlive) n++;
|
||
return n;
|
||
}
|
||
|
||
int AliveHard()
|
||
{
|
||
int n = 0;
|
||
foreach (var d in dummies)
|
||
if (d.unit != null && d.unit.IsAlive && hardZones.Contains(d.spot.tag)) n++;
|
||
return n;
|
||
}
|
||
|
||
/// <summary>허수아비 1개를 솟게 한다(hard = true 어려운 자리만 · false 쉬운 자리만 · null 어디든) · 자리가 없으면 false.</summary>
|
||
bool Spawn(bool? hard, bool fromBreak, ContentLayoutRow brokenSpot = null)
|
||
{
|
||
var cand = new List<ContentLayoutRow>();
|
||
float gap = ContentTables.Num(SupplyData.Mode, "drill_spawn_gap"); // 「다른 허수아비 n칸 안」 제외(1칸 = 전장 1 단위 · PD 2026-11-10 「1 m = 전장 1 칸」)
|
||
foreach (var s in spots)
|
||
{
|
||
if (s == brokenSpot) continue;
|
||
bool isHard = hardZones.Contains(s.tag);
|
||
if (hard.HasValue && isHard != hard.Value) continue;
|
||
if (isHard && AliveHard() >= hardMax) continue;
|
||
if (streakMax > 0 && s.tag == lastZone && streak >= streakMax) continue;
|
||
bool blocked = false;
|
||
foreach (var u in Battle.Units)
|
||
{
|
||
if (u == null || !u.IsAlive) continue;
|
||
float need = Find(u) != null ? gap : u.Radius + 0.4f; // 다른 허수아비 2칸 안 · 아군이 선 칸
|
||
if (Vector2.Distance(u.Position, s.pos) < need) blocked = true;
|
||
}
|
||
if (!blocked) cand.Add(s);
|
||
}
|
||
if (cand.Count == 0) return false;
|
||
var spot = cand[Battle.Rng.Next(cand.Count)];
|
||
var kind = PickKind();
|
||
float hpMult = kind != null ? kind.F("f_hp_mult", 1f) : 1f;
|
||
var baseHp = Config.GetStats(UnitType.Infantry).maxHp;
|
||
var u2 = Battle.SpawnUnit(UnitType.Infantry, Faction.Enemy, spot.pos, kind != null ? kind.S("s_name_ko") : "허수아비", strawHp * hpMult / Mathf.Max(1f, baseHp), 0f);
|
||
u2.Npc = true; // 반격 없음 · 승패 인원 제외
|
||
u2.PushTaken = 0f; // 밀리지 않는다
|
||
u2.ActedThisTurn = true;
|
||
if (u2.View != null) u2.View.Refresh();
|
||
dummies.Add(new Dummy { unit = u2, kind = kind, spot = spot, bornTurn = Battle.TurnNumber });
|
||
if (spot.tag == lastZone) streak++;
|
||
else
|
||
{
|
||
lastZone = spot.tag;
|
||
streak = 1;
|
||
}
|
||
if (fromBreak && !Sim.Active) Fx.Popup(spot.pos, "새 허수아비", new Color(1f, 0.9f, 0.5f));
|
||
return true;
|
||
}
|
||
|
||
ContentRow PickKind()
|
||
{
|
||
var rows = ContentTables.Rows(SupplyData.DrillDummies);
|
||
int sum = 0;
|
||
foreach (var r in rows) sum += Mathf.Max(0, r.I("n_weight"));
|
||
if (sum <= 0) return rows.Count > 0 ? rows[0] : null;
|
||
int pick = Battle.Rng.Next(sum);
|
||
foreach (var r in rows)
|
||
{
|
||
pick -= Mathf.Max(0, r.I("n_weight"));
|
||
if (pick < 0) return r;
|
||
}
|
||
return rows[rows.Count - 1];
|
||
}
|
||
|
||
public override void OnDamaged(Unit d, int dealt, Unit by, HitKind kind, int before)
|
||
{
|
||
var dm = Find(d);
|
||
if (dm == null) return;
|
||
float mult = dm.kind != null ? dm.kind.F("f_score_mult", 1f) : 1f;
|
||
score += Mathf.Min(dealt, before) * mult; // 남은 체력을 넘는 피해는 세지 않는다(drill_overkill no)
|
||
}
|
||
|
||
public override void OnDeath(Unit d, Unit by)
|
||
{
|
||
var dm = Find(d);
|
||
if (dm == null) return;
|
||
Battle.StartCoroutine(Respawn(dm.spot));
|
||
}
|
||
|
||
IEnumerator Respawn(ContentLayoutRow broken)
|
||
{
|
||
yield return Fx.Wait(ContentTables.Num(SupplyData.Mode, "drill_respawn_sec"));
|
||
if (Battle == null || Battle.Phase == BattlePhase.StageClear || Battle.Phase == BattlePhase.Defeat) yield break;
|
||
if (Alive() < active) Spawn(null, true, broken);
|
||
Battle.NotifyChanged();
|
||
}
|
||
|
||
public override IEnumerator OnTurnStart(Faction f)
|
||
{
|
||
if (f != Faction.Player) yield break;
|
||
foreach (var d in dummies.ToArray()) // 황금 허수아비 = n_life_turns 턴 뒤 가라앉는다
|
||
{
|
||
int life = d.kind != null ? d.kind.I("n_life_turns") : 0;
|
||
if (life <= 0 || d.unit == null || !d.unit.IsAlive || Battle.TurnNumber - d.bornTurn < life) continue;
|
||
var spot = d.spot;
|
||
dummies.Remove(d);
|
||
Battle.RemoveUnit(d.unit);
|
||
if (Alive() < active) Spawn(null, true, spot);
|
||
}
|
||
}
|
||
|
||
public override float? JudgeValue
|
||
{
|
||
get { return target > 0f ? score / target * 100f : 0f; }
|
||
}
|
||
|
||
public override string ProgressLine
|
||
{
|
||
get { return "피해 " + Mathf.RoundToInt(score).ToString("N0") + " / " + Mathf.RoundToInt(target).ToString("N0") + " (" + Mathf.FloorToInt(JudgeValue ?? 0f) + "%)"; }
|
||
}
|
||
|
||
public override void Summarize(List<string> lines)
|
||
{
|
||
lines.Add(ProgressLine);
|
||
}
|
||
}
|
||
|
||
// ---------- 황건적 소탕 ----------
|
||
|
||
/// <summary>
|
||
/// 황건적 소탕 — 삼형제(supply_bandit · 그 장 마지막 스테이지 보스의 체력 · 공격력 × n_hp_pct · n_atk_pct %) · 한 명이 쓰러질 때마다 남은 형제 공격력 +
|
||
/// bandit_rage_atk_pct(쓰러진 수 → %) · 즉시 · 한 발사로 함께 쓰러지면 한꺼번에 셈 · 분노한 형제는 다음 행동에 형을 쓰러뜨린 아군을 노림(bandit_revenge) ·
|
||
/// 형제별 표적(맏형 = 가장 먼 아군 · 둘째 = 가장 가까운 · 막내 = 체력 가장 낮은) · 판정 값 = 걸린 턴(less).
|
||
/// </summary>
|
||
public class BanditRules : SupplyRulesBase
|
||
{
|
||
readonly Dictionary<Unit, string> brothers = new Dictionary<Unit, string>();
|
||
readonly Dictionary<Unit, Unit> revenge = new Dictionary<Unit, Unit>();
|
||
int dead;
|
||
|
||
public override string Prepare(BalanceConfig.StageDef stage)
|
||
{
|
||
var why = LoadSpots();
|
||
if (why != null) return why;
|
||
var last = ContentEnemyRef.LastStage(Config, Tier.Chapter);
|
||
BalanceConfig.EnemySpawn boss = null;
|
||
if (last != null)
|
||
foreach (var e in last.enemies)
|
||
if (e.isBoss)
|
||
{
|
||
boss = e;
|
||
break;
|
||
}
|
||
float bh = boss != null ? boss.hpMult : Config.bossGeneralHpMult, ba = boss != null ? boss.atkMult : Config.bossGeneralAtkMult;
|
||
int ch = Tier.Chapter;
|
||
foreach (var r in layout)
|
||
{
|
||
if (r.side != "enemy") continue;
|
||
var b = ContentTables.Find(SupplyData.Bandit, "s_id", r.tag);
|
||
if (b == null)
|
||
{
|
||
stage.enemies.Add(ContentLayout.Enemy(Config, ch, r));
|
||
continue;
|
||
}
|
||
UnitType t;
|
||
UnitTypeInfo.TryParseKey(b.S("s_class"), out t);
|
||
stage.enemies.Add(new BalanceConfig.EnemySpawn
|
||
{
|
||
name = b.S("s_name_ko"), type = t, position = r.pos, isBoss = true, isGeneral = true, art = b.S("s_art"),
|
||
hpMult = bh * b.I("n_hp_pct") / 100f, atkMult = ba * b.I("n_atk_pct") / 100f,
|
||
});
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public override void OnBegin()
|
||
{
|
||
SpawnLayoutGimmicks();
|
||
foreach (var u in Battle.Units)
|
||
{
|
||
if (u == null || u.Faction != Faction.Enemy) continue;
|
||
foreach (var b in ContentTables.Rows(SupplyData.Bandit))
|
||
if (b.S("s_name_ko") == u.DisplayName) brothers[u] = b.S("s_id");
|
||
}
|
||
}
|
||
|
||
public override float DealtMult(Unit a, Unit d)
|
||
{
|
||
if (a == null || !brothers.ContainsKey(a) || dead <= 0) return 1f;
|
||
float pct;
|
||
return ContentTables.Map(SupplyData.Mode, "bandit_rage_atk_pct").TryGetValue(dead.ToString(), out pct) ? 1f + pct / 100f : 1f;
|
||
}
|
||
|
||
public override void OnDeath(Unit d, Unit by)
|
||
{
|
||
if (d == null || !brothers.ContainsKey(d)) return;
|
||
dead++;
|
||
if (by != null && by.Faction == Faction.Player && ContentTables.Int(SupplyData.Mode, "bandit_revenge") > 0)
|
||
foreach (var b in brothers.Keys)
|
||
if (b != null && b.IsAlive) revenge[b] = by;
|
||
if (!Sim.Active)
|
||
foreach (var b in brothers.Keys)
|
||
if (b != null && b.IsAlive) Fx.Popup(b.Position, "분노!", new Color(1f, 0.3f, 0.2f));
|
||
}
|
||
|
||
public override Unit EnemyTarget(Unit e)
|
||
{
|
||
string id;
|
||
if (e == null || !brothers.TryGetValue(e, out id)) return null;
|
||
Unit r;
|
||
if (revenge.TryGetValue(e, out r))
|
||
{
|
||
revenge.Remove(e); // 다음 행동 1회
|
||
if (r != null && r.IsAlive) return r;
|
||
}
|
||
var players = Battle.AliveUnits(Faction.Player);
|
||
players.RemoveAll(p => p.Npc);
|
||
if (players.Count == 0) return null;
|
||
Unit best = null;
|
||
float bv = 0f;
|
||
foreach (var p in players)
|
||
{
|
||
float v;
|
||
switch (id)
|
||
{
|
||
case "eldest": v = Vector2.Distance(e.Position, p.Position); break; // 가장 멀리 있는 아군
|
||
case "second": v = -Vector2.Distance(e.Position, p.Position); break; // 가장 가까운 아군
|
||
case "youngest": v = -p.Hp; break; // 체력이 가장 낮은 아군
|
||
default: return null;
|
||
}
|
||
if (best == null || v > bv)
|
||
{
|
||
best = p;
|
||
bv = v;
|
||
}
|
||
}
|
||
return best;
|
||
}
|
||
|
||
public override float? JudgeValue
|
||
{
|
||
get { return Battle != null ? Battle.TurnNumber : 0; }
|
||
}
|
||
|
||
public override string ProgressLine
|
||
{
|
||
get { return "쓰러뜨린 형제 " + dead + " / " + brothers.Count; }
|
||
}
|
||
|
||
public override void Summarize(List<string> lines)
|
||
{
|
||
lines.Add("걸린 턴 " + (Battle != null ? Battle.TurnNumber : 0));
|
||
}
|
||
}
|
||
}
|