1031 lines
46 KiB
C#
1031 lines
46 KiB
C#
|
|
using System.Collections;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using UnityEngine;
|
|||
|
|
|
|||
|
|
namespace TKS
|
|||
|
|
{
|
|||
|
|
/// <summary>
|
|||
|
|
/// 연의 전기 전투(컨텐츠 모드 기획 10판 ② · 개발 요청서 C) — 표 = scenario_battles · scenario_layout(n_act 판) · scenario_rules(win · challenge1 · challenge2 · rule) ·
|
|||
|
|
/// scenario_conditions(사전) · scenario_tune(적 세기) · content_modes_config scenario.*.
|
|||
|
|
/// 고정 편성 · 고정 능력치(성장 없음 · 스킬 Lv = scenario.ally_skill_level) · 적 체력/공격 = 기준 유닛 타격 몇 회분(전투 시작 때 계산) · 열전 = power_mult_hard ÷ power_mult_normal.
|
|||
|
|
/// 승리 = win 조건 전부 · 도전 = challenge1 · 2(이겼을 때만) · 전용 규칙 = rule 줄.
|
|||
|
|
/// </summary>
|
|||
|
|
public class ScenarioRules : ModeBattleRules
|
|||
|
|
{
|
|||
|
|
public string BattleId;
|
|||
|
|
public bool Hard;
|
|||
|
|
public BalanceConfig Config;
|
|||
|
|
|
|||
|
|
ContentRow battle;
|
|||
|
|
readonly List<ContentRow> conds = new List<ContentRow>();
|
|||
|
|
readonly List<ContentLayoutRow> layout = new List<ContentLayoutRow>();
|
|||
|
|
int act = 1, acts = 1;
|
|||
|
|
float hardMult = 1f;
|
|||
|
|
// 태그 → 유닛 · 기믹 · 표시
|
|||
|
|
readonly Dictionary<Unit, ContentLayoutRow> unitRow = new Dictionary<Unit, ContentLayoutRow>();
|
|||
|
|
readonly List<GimmickInstance> gims = new List<GimmickInstance>();
|
|||
|
|
readonly Dictionary<GimmickInstance, ContentLayoutRow> gimRow = new Dictionary<GimmickInstance, ContentLayoutRow>();
|
|||
|
|
readonly List<GameObject> marks = new List<GameObject>();
|
|||
|
|
// 집계
|
|||
|
|
readonly Dictionary<string, int> count = new Dictionary<string, int>();
|
|||
|
|
readonly Dictionary<Unit, HashSet<Unit>> hitBy = new Dictionary<Unit, HashSet<Unit>>(); // 대상 → 맞힌 아군
|
|||
|
|
readonly HashSet<GimmickInstance> ignited = new HashSet<GimmickInstance>();
|
|||
|
|
readonly Dictionary<GimmickInstance, int> burnStart = new Dictionary<GimmickInstance, int>();
|
|||
|
|
bool allyLost, failed, noAttackBroken, zoneHurt, passed, flooded, buffed;
|
|||
|
|
int missShots, perTurn, bestPerTurn, holdTurns;
|
|||
|
|
string failWhy = "";
|
|||
|
|
Unit heroUnit;
|
|||
|
|
readonly HashSet<Unit> rescued = new HashSet<Unit>();
|
|||
|
|
readonly Dictionary<Unit, Unit> lastHitter = new Dictionary<Unit, Unit>();
|
|||
|
|
readonly Dictionary<Unit, HitKind> lastKind = new Dictionary<Unit, HitKind>();
|
|||
|
|
int chargeStunUntil = -1;
|
|||
|
|
Vector2 chargeDir;
|
|||
|
|
bool chargeArmed;
|
|||
|
|
|
|||
|
|
// ---------- 표 ----------
|
|||
|
|
|
|||
|
|
string V(ContentRow r)
|
|||
|
|
{
|
|||
|
|
return Hard && r.S("s_value_hard").Length > 0 ? r.S("s_value_hard") : r.S("s_value");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
float VF(ContentRow r)
|
|||
|
|
{
|
|||
|
|
float v;
|
|||
|
|
return ContentTables.TryNum(V(r), out v) ? v : 0f;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ContentRow Rule(string key)
|
|||
|
|
{
|
|||
|
|
foreach (var r in conds)
|
|||
|
|
if (r.S("e_slot") == "rule" && r.S("s_cond") == key) return r;
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
List<string> Targets(ContentRow r)
|
|||
|
|
{
|
|||
|
|
return r.L("s_target");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public List<ContentRow> Slot(string slot)
|
|||
|
|
{
|
|||
|
|
var res = new List<ContentRow>();
|
|||
|
|
foreach (var r in conds)
|
|||
|
|
if (r.S("e_slot") == slot) res.Add(r);
|
|||
|
|
return res;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 준비 ----------
|
|||
|
|
|
|||
|
|
public string Prepare(BalanceConfig.StageDef stage)
|
|||
|
|
{
|
|||
|
|
battle = ContentTables.Find("scenario_battles", "s_id", BattleId);
|
|||
|
|
if (battle == null) return "scenario_battles 에 " + BattleId + " 없음";
|
|||
|
|
foreach (var r in ContentTables.Rows("scenario_rules"))
|
|||
|
|
if (r.S("s_battle") == BattleId) conds.Add(r);
|
|||
|
|
acts = Mathf.Max(1, battle.I("n_acts"));
|
|||
|
|
float n = ContentTables.Num("scenario", "power_mult_normal"), h = ContentTables.Num("scenario", "power_mult_hard");
|
|||
|
|
hardMult = Hard && n > 0f ? h / n : 1f;
|
|||
|
|
stage.title = battle.S("s_title_ko") + (Hard ? " (열전)" : " (연의)");
|
|||
|
|
if (!LoadAct(1, stage)) return "scenario_layout 에 " + BattleId + " 배치 없음";
|
|||
|
|
int tl = 0;
|
|||
|
|
foreach (var r in Slot("win"))
|
|||
|
|
if (r.S("s_cond") == "turn_limit" || r.S("s_cond") == "survive_turns") tl = Mathf.RoundToInt(VF(r));
|
|||
|
|
TurnLimitValue = tl > 0 ? tl : ContentTables.Int(RaidData.Mode, "safety_max_turns");
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public int TurnLimitValue { get; private set; }
|
|||
|
|
|
|||
|
|
bool LoadAct(int a, BalanceConfig.StageDef stage)
|
|||
|
|
{
|
|||
|
|
layout.Clear();
|
|||
|
|
foreach (var r in ContentTables.Rows("scenario_layout"))
|
|||
|
|
if (r.S("s_battle") == BattleId && r.I("n_act", 1) == a) layout.Add(ContentLayoutRow.From(r));
|
|||
|
|
layout.Sort((x, y) => x.slot.CompareTo(y.slot));
|
|||
|
|
if (layout.Count == 0) return false;
|
|||
|
|
act = a;
|
|||
|
|
if (stage != null)
|
|||
|
|
{
|
|||
|
|
stage.enemies.Clear();
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
if (r.side == "enemy" && r.spawnTurn <= 0) stage.enemies.Add(EnemySpawn(r));
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 고정 편성(scenario.fixed_spec · ally_spec · ally_skill_level) ----------
|
|||
|
|
|
|||
|
|
public override List<LineupEntry> Lineup(List<LineupEntry> preset)
|
|||
|
|
{
|
|||
|
|
var res = new List<LineupEntry>();
|
|||
|
|
var db = OutGame.OutGameRoot.Instance != null ? OutGame.OutGameRoot.Instance.Session.Db : OutGame.OutGameData.Default;
|
|||
|
|
int lv = ContentTables.Int("scenario", "ally_skill_level");
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
{
|
|||
|
|
if (r.side != "ally" || r.unitId.Length == 0) continue;
|
|||
|
|
var h = db != null && db.Heroes != null ? db.Heroes.Get(r.unitId) : null;
|
|||
|
|
if (h == null) continue;
|
|||
|
|
var e = new LineupEntry
|
|||
|
|
{
|
|||
|
|
slot = res.Count, id = h.id, name = h.nameKo, type = r.HasType ? r.UnitType : h.type, art = h.art, // type_override = 배치 표의 병종 칸
|
|||
|
|
hpMult = h.hpMult, atkMult = h.atkMult, defMult = h.defMult, // 성장 없는 기본 능력치(병종 기본값 × 영웅 고유 배율)
|
|||
|
|
};
|
|||
|
|
if (!h.isSoldier)
|
|||
|
|
{
|
|||
|
|
e.general = true;
|
|||
|
|
e.skillActive = h.skillActive;
|
|||
|
|
e.skillPassive = h.skillPassive;
|
|||
|
|
e.activeLv = e.passiveLv = Mathf.Max(1, lv);
|
|||
|
|
}
|
|||
|
|
res.Add(e);
|
|||
|
|
}
|
|||
|
|
return res;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override Vector2 AllyPosition(int slot, Vector2 fallback)
|
|||
|
|
{
|
|||
|
|
int k = 0;
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
{
|
|||
|
|
if (r.side != "ally" || r.unitId.Length == 0) continue;
|
|||
|
|
if (k++ == slot) return r.pos;
|
|||
|
|
}
|
|||
|
|
return fallback;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override int MaxAllies
|
|||
|
|
{
|
|||
|
|
get { return 0; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 적 세기(scenario_tune · enemy_hp_calc · enemy_atk_calc) ----------
|
|||
|
|
|
|||
|
|
BalanceConfig.EnemySpawn EnemySpawn(ContentLayoutRow r)
|
|||
|
|
{
|
|||
|
|
var tune = ContentTables.Find("scenario_tune", "s_battle", BattleId);
|
|||
|
|
var db = OutGame.OutGameRoot.Instance != null ? OutGame.OutGameRoot.Instance.Session.Db : OutGame.OutGameData.Default;
|
|||
|
|
var refHero = tune != null && db != null ? db.Heroes.Get(tune.S("s_ref_hero")) : null;
|
|||
|
|
UnitType t = r.UnitType;
|
|||
|
|
var st = Config.GetStats(t);
|
|||
|
|
bool boss = r.boss;
|
|||
|
|
float hpMult = 1f, atkMult = 1f;
|
|||
|
|
int ch, sn;
|
|||
|
|
int chapter = OutGame.ArenaRules.ParseStageKey(battle.S("s_unlock_stage"), out ch, out sn) ? ch : 1;
|
|||
|
|
float baseHp, baseAtk;
|
|||
|
|
string art;
|
|||
|
|
ContentEnemyRef.Of(Config, chapter, t, boss, r.general, out baseHp, out baseAtk, out art);
|
|||
|
|
if (refHero != null && tune != null)
|
|||
|
|
{
|
|||
|
|
var rs = Config.GetStats(refHero.type);
|
|||
|
|
float refAtk = rs.atk * refHero.atkMult, refHp = rs.maxHp * refHero.hpMult, refDef = rs.def * refHero.defMult;
|
|||
|
|
// 기준 유닛의 일반 타격 피해(치명타 · 스킬 · 난수 없음 · 상성 포함) − 방어
|
|||
|
|
float hit = Mathf.Max(1f, refAtk * Config.Matchup(refHero.type, t) - st.def * Config.defenseFactor);
|
|||
|
|
int hits = r.HasHits ? r.hits : boss ? tune.I("n_boss_hits") : (r.general ? tune.I("n_general_hits") : tune.I("n_soldier_hits"));
|
|||
|
|
float hp = hit * Mathf.Max(0.1f, hits - ContentTables.Num("scenario", "enemy_hp_margin")) * hardMult * r.hpMult;
|
|||
|
|
hpMult = hp / Mathf.Max(1f, st.maxHp * (boss ? Config.bossHpMult : 1f));
|
|||
|
|
var inf = Config.GetStats(UnitType.Infantry);
|
|||
|
|
float side = inf.atk > 0 ? (refHp * tune.F("n_enemy_hit_pct") / 100f + refDef * Config.defenseFactor) / inf.atk : 1f;
|
|||
|
|
atkMult = baseAtk * side * hardMult * r.atkMult;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
hpMult = baseHp * hardMult * r.hpMult;
|
|||
|
|
atkMult = baseAtk * hardMult * r.atkMult;
|
|||
|
|
}
|
|||
|
|
return new BalanceConfig.EnemySpawn
|
|||
|
|
{
|
|||
|
|
name = r.nameKo.Length > 0 ? r.nameKo : UnitTypeInfo.Korean(t), type = t, position = r.pos, hpMult = hpMult, atkMult = atkMult,
|
|||
|
|
isBoss = boss, isGeneral = r.general || boss, art = r.unitId.Length > 0 ? ArtOf(r.unitId, art) : art,
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static string ArtOf(string unitId, string fallback)
|
|||
|
|
{
|
|||
|
|
var db = OutGame.OutGameRoot.Instance != null ? OutGame.OutGameRoot.Instance.Session.Db : OutGame.OutGameData.Default;
|
|||
|
|
var h = db != null ? db.Heroes.Get(unitId) : null;
|
|||
|
|
return h != null && h.art.Length > 0 ? h.art : unitId;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 시작 ----------
|
|||
|
|
|
|||
|
|
public override bool EliminationVictory
|
|||
|
|
{
|
|||
|
|
get { return false; }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override void OnBegin()
|
|||
|
|
{
|
|||
|
|
BindAct();
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
if (r.side == "npc") SpawnNpc(r);
|
|||
|
|
var inv = Rule("invincible");
|
|||
|
|
if (inv != null && Targets(inv).Count > 0) // 빈 대상 보호(Fable QA 13)
|
|||
|
|
foreach (var u in TagUnits(Targets(inv)[0])) u.MinHp = 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>판의 유닛 · 기믹 · 표시를 표 줄에 잇는다(전투 시작 · 연전 다음 판).</summary>
|
|||
|
|
void BindAct()
|
|||
|
|
{
|
|||
|
|
var enemyRows = layout.FindAll(r => r.side == "enemy" && r.spawnTurn <= 0);
|
|||
|
|
int k = 0;
|
|||
|
|
foreach (var u in Battle.Units)
|
|||
|
|
{
|
|||
|
|
if (u == null || !u.IsAlive) continue;
|
|||
|
|
if (u.Faction == Faction.Enemy && !unitRow.ContainsKey(u) && k < enemyRows.Count) unitRow[u] = enemyRows[k++];
|
|||
|
|
if (u.Faction == Faction.Player && !u.Npc)
|
|||
|
|
{
|
|||
|
|
var ar = layout.Find(r => r.side == "ally" && r.unitId == u.HeroId);
|
|||
|
|
if (ar != null) unitRow[u] = ar;
|
|||
|
|
if (heroUnit == null && ar != null && (ar.tag == "hero" || ar.tag == "trio")) heroUnit = u;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
{
|
|||
|
|
if (r.side == "gimmick")
|
|||
|
|
{
|
|||
|
|
if (r.gimmickId == "halberd") { SpawnHalberd(r); continue; } // 화극 과녁 = 맞힌 횟수를 세는 움직이지 않는 표적(유닛)
|
|||
|
|
var g = ContentLayout.SpawnGimmick(Battle.Gimmicks, r);
|
|||
|
|
if (g == null) continue;
|
|||
|
|
gims.Add(g);
|
|||
|
|
gimRow[g] = r;
|
|||
|
|
}
|
|||
|
|
else if (r.side == "mark") DrawMark(r);
|
|||
|
|
}
|
|||
|
|
if (Battle.Gimmicks != null) Battle.Gimmicks.ResolveOverlaps();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SpawnHalberd(ContentLayoutRow r)
|
|||
|
|
{
|
|||
|
|
var u = Battle.SpawnUnit(UnitType.Infantry, Faction.Enemy, r.pos, r.nameKo.Length > 0 ? r.nameKo : "화극", 1f, 0f);
|
|||
|
|
u.Radius = r.wOrR > 0f ? r.wOrR : u.Radius;
|
|||
|
|
if (u.Collider != null) u.Collider.radius = u.Radius;
|
|||
|
|
u.Npc = true;
|
|||
|
|
u.MinHp = u.MaxHp; // 부서지지 않는다
|
|||
|
|
u.PushTaken = 0f;
|
|||
|
|
unitRow[u] = r;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void SpawnNpc(ContentLayoutRow r)
|
|||
|
|
{
|
|||
|
|
var db = OutGame.OutGameRoot.Instance != null ? OutGame.OutGameRoot.Instance.Session.Db : OutGame.OutGameData.Default;
|
|||
|
|
var h = db != null ? db.Heroes.Get(r.unitId) : null;
|
|||
|
|
UnitType t = r.HasType ? r.UnitType : h != null ? h.type : UnitType.Infantry;
|
|||
|
|
var u = Battle.SpawnUnit(t, Faction.Player, r.pos, r.nameKo.Length > 0 ? r.nameKo : h != null ? h.nameKo : r.unitId, h != null ? h.hpMult : 1f, 0f, false, h != null ? h.art : ArtOf(r.unitId, ""));
|
|||
|
|
u.Npc = true;
|
|||
|
|
u.ActedThisTurn = true;
|
|||
|
|
u.HeroId = r.unitId;
|
|||
|
|
unitRow[u] = r;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void DrawMark(ContentLayoutRow r)
|
|||
|
|
{
|
|||
|
|
var go = new GameObject("ScnMark_" + r.tag);
|
|||
|
|
go.transform.position = new Vector3(r.pos.x, r.pos.y, 0f);
|
|||
|
|
Color c = r.gimmickId == "exit" ? new Color(0.3f, 1f, 0.4f, 0.35f) : r.gimmickId == "home" ? new Color(0.3f, 0.6f, 1f, 0.35f) : new Color(1f, 0.25f, 0.2f, 0.45f);
|
|||
|
|
bool circle = r.shape != "rect";
|
|||
|
|
var sr = ProceduralSprites.NewSprite(go.transform, "Fill", circle ? ProceduralSprites.Ring : ProceduralSprites.Square, c, 1f, 4);
|
|||
|
|
Vector2 size = circle ? new Vector2(r.wOrR * 2f, r.wOrR * 2f) : new Vector2(r.wOrR, Mathf.Max(0.15f, r.h));
|
|||
|
|
Vector2 native = sr.sprite.bounds.size;
|
|||
|
|
sr.transform.localScale = new Vector3(size.x / Mathf.Max(0.001f, native.x), size.y / Mathf.Max(0.001f, native.y), 1f);
|
|||
|
|
marks.Add(go);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ClearMarks()
|
|||
|
|
{
|
|||
|
|
foreach (var m in marks)
|
|||
|
|
if (m != null) Object.Destroy(m);
|
|||
|
|
marks.Clear();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 태그 ----------
|
|||
|
|
|
|||
|
|
List<Unit> TagUnits(string tag)
|
|||
|
|
{
|
|||
|
|
var res = new List<Unit>();
|
|||
|
|
foreach (var kv in unitRow)
|
|||
|
|
if (kv.Key != null && (kv.Value.tag == tag || (tag == "hero" && kv.Key == heroUnit))) res.Add(kv.Key);
|
|||
|
|
return res;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
List<GimmickInstance> TagGims(string tag)
|
|||
|
|
{
|
|||
|
|
var res = new List<GimmickInstance>();
|
|||
|
|
foreach (var kv in gimRow)
|
|||
|
|
if (kv.Value.tag == tag) res.Add(kv.Key);
|
|||
|
|
return res;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ContentLayoutRow TagRow(string tag)
|
|||
|
|
{
|
|||
|
|
return layout.Find(r => r.tag == tag);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool IsTag(Unit u, string tag)
|
|||
|
|
{
|
|||
|
|
ContentLayoutRow r;
|
|||
|
|
return u != null && ((unitRow.TryGetValue(u, out r) && r.tag == tag) || (tag == "hero" && u == heroUnit));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void Add(string key, int n = 1)
|
|||
|
|
{
|
|||
|
|
int v;
|
|||
|
|
count.TryGetValue(key, out v);
|
|||
|
|
count[key] = v + n;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int Count(string key)
|
|||
|
|
{
|
|||
|
|
int v;
|
|||
|
|
return count.TryGetValue(key, out v) ? v : 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 수치 ----------
|
|||
|
|
|
|||
|
|
public override float DealtMult(Unit a, Unit d)
|
|||
|
|
{
|
|||
|
|
if (a != null && buffed && a == heroUnit)
|
|||
|
|
{
|
|||
|
|
var b = Rule("buff_on_kill");
|
|||
|
|
if (b != null) return 1f + VF(b) / 100f;
|
|||
|
|
}
|
|||
|
|
return 1f;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override Vector2 AdjustTarget(Unit u, Vector2 target)
|
|||
|
|
{
|
|||
|
|
var w = Rule("wind_shift");
|
|||
|
|
if (w != null && WindTurn() && u != null && UnitTypeInfo.IsRanged(u.Type)) return target + Vector2.right * VF(w); // 바람 턴 = 화살이 오른쪽으로 휜다
|
|||
|
|
return target;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool WindTurn()
|
|||
|
|
{
|
|||
|
|
var w = Rule("wind_turn");
|
|||
|
|
if (w == null) return false;
|
|||
|
|
foreach (var t in ContentTables.SplitList(V(w)))
|
|||
|
|
{
|
|||
|
|
float v;
|
|||
|
|
if (ContentTables.TryNum(t, out v) && Mathf.RoundToInt(v) == Battle.TurnNumber) return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool EnemyActs(Unit e)
|
|||
|
|
{
|
|||
|
|
if (e != null && e.Npc) return false; // 화극 과녁
|
|||
|
|
var idle = Rule("idle_until");
|
|||
|
|
if (idle != null && IsTag(e, Targets(idle).Count > 0 ? Targets(idle)[0] : "") && Battle.TurnNumber <= VF(idle)) return false;
|
|||
|
|
if (chargeStunUntil >= Battle.TurnNumber && IsTag(e, "target")) return false;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool CountsForVictory(Unit u)
|
|||
|
|
{
|
|||
|
|
return u == null || !u.Npc;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 집계 ----------
|
|||
|
|
|
|||
|
|
public override void OnDamaged(Unit d, int dealt, Unit by, HitKind kind, int before)
|
|||
|
|
{
|
|||
|
|
if (d == null) return;
|
|||
|
|
lastKind[d] = kind;
|
|||
|
|
if (by != null) lastHitter[d] = by;
|
|||
|
|
if (d.Faction == Faction.Player && kind == HitKind.Gimmick) zoneHurt = true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override void OnAction(Unit actor, ActionOutcome o)
|
|||
|
|
{
|
|||
|
|
if (actor == null || o == null) return;
|
|||
|
|
if (actor.Faction == Faction.Player && !actor.Npc)
|
|||
|
|
{
|
|||
|
|
foreach (var a in o.Attacked)
|
|||
|
|
{
|
|||
|
|
if (a == null) continue;
|
|||
|
|
HashSet<Unit> s;
|
|||
|
|
if (!hitBy.TryGetValue(a, out s)) hitBy[a] = s = new HashSet<Unit>();
|
|||
|
|
s.Add(actor);
|
|||
|
|
ContentLayoutRow r;
|
|||
|
|
if (unitRow.TryGetValue(a, out r)) Add("hit:" + r.tag);
|
|||
|
|
if (IsTag(a, "noshoot") || NoAttackTarget(a)) noAttackBroken = true;
|
|||
|
|
}
|
|||
|
|
foreach (var f in o.FriendlyHit)
|
|||
|
|
if (IsTag(f, "noshoot")) noAttackBroken = true;
|
|||
|
|
foreach (var p in o.Pushed)
|
|||
|
|
if (NoAttackTarget(p)) noAttackBroken = true; // 밀치기로 닿아도 실패
|
|||
|
|
if (o.Fired && o.ShotHit == null) missShots++;
|
|||
|
|
if (o.Fired && o.ShotHit != null && !IsTag(o.ShotHit, "halberd") && TagUnits("halberd").Count > 0) missShots++;
|
|||
|
|
// 불 붙이기(타격 · 책사 광역이 닿은 기믹)
|
|||
|
|
if (o.Fired && actor.Type == UnitType.Strategist)
|
|||
|
|
{
|
|||
|
|
Vector2 c = o.ShotHit != null ? o.ShotHit.Position : (o.Path.Count > 0 ? o.Path[o.Path.Count - 1] : actor.Position);
|
|||
|
|
foreach (var g in gims)
|
|||
|
|
if (Flammable(g) && g.Shape.SignedDistance(c) <= Config.strategistSplashRadius) Ignite(g, actor);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// 구출 · 탈출 · 복귀 · 저지선
|
|||
|
|
foreach (var u in Battle.AliveUnits(Faction.Player))
|
|||
|
|
{
|
|||
|
|
if (!u.Npc || rescued.Contains(u)) continue;
|
|||
|
|
if (IsTag(u, "adou") && heroUnit != null && Vector2.Distance(u.Position, heroUnit.Position) <= u.Radius + heroUnit.Radius + 0.3f)
|
|||
|
|
{
|
|||
|
|
rescued.Add(u);
|
|||
|
|
u.MinHp = u.MaxHp; // 품에 안은 뒤에는 다치지 않는다(광역 · 사격이 닿아도 · Fable QA 4)
|
|||
|
|
u.gameObject.SetActive(false); // 품에 안음
|
|||
|
|
Fx.Popup(heroUnit.Position, "구출!", new Color(0.4f, 1f, 0.5f));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool NoAttackTarget(Unit u)
|
|||
|
|
{
|
|||
|
|
foreach (var r in Slot("challenge1"))
|
|||
|
|
if (r.S("s_cond") == "no_attack" && Targets(r).Count > 0 && Targets(r)[0] != "noshoot" && IsTag(u, Targets(r)[0])) return true;
|
|||
|
|
foreach (var r in Slot("challenge2"))
|
|||
|
|
if (r.S("s_cond") == "no_attack" && Targets(r).Count > 0 && Targets(r)[0] != "noshoot" && IsTag(u, Targets(r)[0])) return true;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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;
|
|||
|
|
if (IsTag(d, "huanggai")) Add("dead:huanggai");
|
|||
|
|
if (d == heroUnit) Add("dead:hero");
|
|||
|
|
if (IsTag(d, "adou")) Add("dead:adou");
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
ContentLayoutRow r;
|
|||
|
|
string tag = unitRow.TryGetValue(d, out r) ? r.tag : "";
|
|||
|
|
Add("kill:" + tag);
|
|||
|
|
Add("kill:*");
|
|||
|
|
Unit killer = by ?? (lastHitter.ContainsKey(d) ? lastHitter[d] : null);
|
|||
|
|
if (killer != null && killer == heroUnit) Add("fin:" + tag);
|
|||
|
|
HitKind k = lastKind.ContainsKey(d) ? lastKind[d] : HitKind.Attack;
|
|||
|
|
if (k == HitKind.Gimmick || k == HitKind.Dot || by == null)
|
|||
|
|
{
|
|||
|
|
if (InZoneTag(d.Position, "flood")) Add("gk:flood");
|
|||
|
|
if (InFire(d.Position)) Add("gk:fire");
|
|||
|
|
if (InRiver(d.Position)) Add("gk:river"); // 강물에 빠져 쓰러짐만(Fable QA 6)
|
|||
|
|
}
|
|||
|
|
if (Battle.Phase != BattlePhase.EnemyTurn)
|
|||
|
|
{
|
|||
|
|
perTurn++;
|
|||
|
|
bestPerTurn = Mathf.Max(bestPerTurn, perTurn);
|
|||
|
|
}
|
|||
|
|
var b = Rule("buff_on_kill");
|
|||
|
|
if (b != null && Targets(b).Count > 0 && tag == Targets(b)[0] && !buffed)
|
|||
|
|
{
|
|||
|
|
buffed = true;
|
|||
|
|
if (heroUnit != null) Fx.Popup(heroUnit.Position, "공격력 +" + VF(b) + "%", new Color(1f, 0.9f, 0.3f));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override void OnGimmickBroken(GimmickInstance g, Unit by)
|
|||
|
|
{
|
|||
|
|
ContentLayoutRow r;
|
|||
|
|
if (!gimRow.TryGetValue(g, out r)) return;
|
|||
|
|
Add("broken:" + r.tag);
|
|||
|
|
if (Flammable(g)) Ignite(g, by);
|
|||
|
|
if (r.tag == "sluice" && TagGims("sluice").TrueForAll(x => x.Broken) && !flooded) Flood();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 불 · 물 ----------
|
|||
|
|
|
|||
|
|
bool Flammable(GimmickInstance g)
|
|||
|
|
{
|
|||
|
|
ContentLayoutRow r;
|
|||
|
|
return g != null && gimRow.TryGetValue(g, out r) && (r.gimmickId == "warship" || r.gimmickId == "camp" || r.gimmickId == "granary" || r.gimmickId == "dry_grass");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void Ignite(GimmickInstance g, Unit by)
|
|||
|
|
{
|
|||
|
|
if (g == null || ignited.Contains(g)) return;
|
|||
|
|
ignited.Add(g);
|
|||
|
|
burnStart[g] = Battle.TurnNumber;
|
|||
|
|
ContentLayoutRow r = gimRow[g];
|
|||
|
|
Add("ignite:" + r.tag);
|
|||
|
|
Add("ignite_turn:" + r.tag + ":" + Battle.TurnNumber);
|
|||
|
|
if (Battle.Phase != BattlePhase.EnemyTurn) perTurnIgnite++;
|
|||
|
|
bestPerTurnIgnite = Mathf.Max(bestPerTurnIgnite, perTurnIgnite);
|
|||
|
|
var layer = Battle.Gimmicks;
|
|||
|
|
if (layer != null)
|
|||
|
|
{
|
|||
|
|
float rad = g.Shape.BoundingRadius;
|
|||
|
|
var burn = layer.SpawnBurning(g.Shape.Center, rad, g.Def.p2 > 0f ? g.Def.p2 : 2f); // 불탄 자리 = 불타는 잔해(정의 p2 턴 · 없으면 2)
|
|||
|
|
if (burn != null) gims.Add(burn);
|
|||
|
|
if (r.gimmickId != "dry_grass") layer.Remove(g); // 배 · 막사 · 군량고 = 불타 없어짐
|
|||
|
|
}
|
|||
|
|
if (!Sim.Active) Fx.Popup(g.Shape.Center, "불!", new Color(1f, 0.5f, 0.15f));
|
|||
|
|
var sp = Rule("ignite_spread");
|
|||
|
|
if (sp != null && by != null && Targets(sp).Count > 0 && IsTag(by, Targets(sp)[0])) // 황개 = 양옆 n척까지
|
|||
|
|
{
|
|||
|
|
int n = Mathf.RoundToInt(VF(sp));
|
|||
|
|
var row = TagGims(r.tag);
|
|||
|
|
row.Sort((a, b) => gimRow[a].slot.CompareTo(gimRow[b].slot));
|
|||
|
|
int i = row.IndexOf(g);
|
|||
|
|
for (int k = 1; k <= n; k++)
|
|||
|
|
{
|
|||
|
|
if (i - k >= 0) Ignite(row[i - k], null);
|
|||
|
|
if (i + k < row.Count) Ignite(row[i + k], null);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int perTurnIgnite, bestPerTurnIgnite;
|
|||
|
|
|
|||
|
|
/// <summary>번짐 — 적 턴마다 불붙은 것 옆으로(정의 p1 = 거리 · 바람 턴 = 이어진 것 전부).</summary>
|
|||
|
|
void Spread()
|
|||
|
|
{
|
|||
|
|
var burning = new List<GimmickInstance>(ignited);
|
|||
|
|
bool wind = WindTurn();
|
|||
|
|
foreach (var g in burning)
|
|||
|
|
{
|
|||
|
|
ContentLayoutRow r;
|
|||
|
|
if (!gimRow.TryGetValue(g, out r)) continue;
|
|||
|
|
float reach = g.Def.p1 > 0f ? g.Def.p1 : 1f;
|
|||
|
|
foreach (var o in TagGims(r.tag))
|
|||
|
|
{
|
|||
|
|
if (ignited.Contains(o) || o.Removed) continue;
|
|||
|
|
float d = Vector2.Distance(o.Shape.Center, g.Shape.Center) - o.Shape.BoundingRadius - g.Shape.BoundingRadius;
|
|||
|
|
if (d <= reach || wind) Ignite(o, null);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool InFire(Vector2 p)
|
|||
|
|
{
|
|||
|
|
if (Battle.Gimmicks == null) return false;
|
|||
|
|
foreach (var g in Battle.Gimmicks.Items)
|
|||
|
|
if (!g.Removed && g.Zone == GimmickZone.Burn && g.Shape.Contains(p)) return true;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool InRiver(Vector2 p)
|
|||
|
|
{
|
|||
|
|
if (Battle.Gimmicks == null) return false;
|
|||
|
|
foreach (var g in Battle.Gimmicks.Items)
|
|||
|
|
if (!g.Removed && g.Def.id == "river" && g.Shape.SignedDistance(p) <= 0.5f) return true;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool InZoneTag(Vector2 p, string tag)
|
|||
|
|
{
|
|||
|
|
foreach (var g in TagGims(tag))
|
|||
|
|
if (!g.Removed && g.Shape.Contains(p)) return true;
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>수문이 모두 부서지면 저지대(lowland · tag flood)가 물에 잠긴다 → 늪(이동 비용) + 적 턴마다 최대 체력 p1 비율 피해.</summary>
|
|||
|
|
void Flood()
|
|||
|
|
{
|
|||
|
|
flooded = true;
|
|||
|
|
foreach (var g in TagGims("flood"))
|
|||
|
|
{
|
|||
|
|
var p = gimRow[g].Placement();
|
|||
|
|
p.gimmickId = "swamp";
|
|||
|
|
var def = GimmickTables.Db != null ? GimmickTables.Db.Get("swamp") : null;
|
|||
|
|
if (def != null && Battle.Gimmicks != null) Battle.Gimmicks.Spawn(def, p, true);
|
|||
|
|
}
|
|||
|
|
if (!Sim.Active) Fx.Popup(Vector2.zero, "성이 물에 잠긴다!", new Color(0.4f, 0.7f, 1f));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 턴 ----------
|
|||
|
|
|
|||
|
|
public override IEnumerator OnTurnStart(Faction f)
|
|||
|
|
{
|
|||
|
|
if (f == Faction.Enemy)
|
|||
|
|
{
|
|||
|
|
Spread();
|
|||
|
|
if (flooded) // 물에 잠긴 저지대의 적 = 최대 체력 p1 비율 피해
|
|||
|
|
foreach (var g in TagGims("flood"))
|
|||
|
|
foreach (var e in Battle.AliveUnits(Faction.Enemy))
|
|||
|
|
if (!e.Npc && g.Shape.Contains(e.Position) && Battle.Gimmicks != null) Battle.Gimmicks.PctDamage(e, g.Def.p1 > 0f ? g.Def.p1 : 0f, "물");
|
|||
|
|
var hz = HoldRule();
|
|||
|
|
if (hz != null && Targets(hz).Count > 0)
|
|||
|
|
foreach (var u in TagUnits(Targets(hz)[0]))
|
|||
|
|
if (u.IsAlive && InFire(u.Position)) holdTurns++;
|
|||
|
|
var zg = Rule("zone_grow");
|
|||
|
|
if (zg != null && Targets(zg).Count > 0) // 오관 4판 = 불이 위로 넓어진다
|
|||
|
|
foreach (var g in TagGims(Targets(zg)[0]).ToArray())
|
|||
|
|
{
|
|||
|
|
var p = gimRow[g].Placement();
|
|||
|
|
float grow = VF(zg);
|
|||
|
|
p.cy = g.Shape.Center.y + (g.Shape.Type == GimmickShapeType.Rect ? g.Shape.Size.y * 0.5f : g.Shape.R) + grow * 0.5f;
|
|||
|
|
p.h = grow;
|
|||
|
|
p.shape = GimmickShapeType.Rect;
|
|||
|
|
p.wOrR = g.Shape.Type == GimmickShapeType.Rect ? g.Shape.Size.x : g.Shape.R * 2f;
|
|||
|
|
var def = g.Def;
|
|||
|
|
var n = Battle.Gimmicks.Spawn(def, p, true);
|
|||
|
|
gims.Add(n);
|
|||
|
|
gimRow[n] = gimRow[g];
|
|||
|
|
}
|
|||
|
|
if (ChargeTurn()) yield return BossCharge();
|
|||
|
|
yield break;
|
|||
|
|
}
|
|||
|
|
perTurn = 0;
|
|||
|
|
perTurnIgnite = 0;
|
|||
|
|
if (pendingAct) // 적 턴에 관문 장수가 쓰러졌다 → 이 아군 턴부터 다음 판(Fable QA 2)
|
|||
|
|
{
|
|||
|
|
pendingAct = false;
|
|||
|
|
NextAct(false);
|
|||
|
|
}
|
|||
|
|
// 원군(reinforce) = 규칙 값(연의 s_value · 열전 s_value_hard)의 i 번째 턴 → 배치 표의 i 번째 원군 무리(n_spawn_turn 순 · 모자라면 마지막 무리 · Fable QA 5)
|
|||
|
|
var rf = Rule("reinforce");
|
|||
|
|
int wave = -1;
|
|||
|
|
if (rf != null)
|
|||
|
|
{
|
|||
|
|
var turns = ContentTables.SplitList(V(rf));
|
|||
|
|
for (int i = 0; i < turns.Count; i++)
|
|||
|
|
{
|
|||
|
|
float tv;
|
|||
|
|
if (ContentTables.TryNum(turns[i], out tv) && Mathf.RoundToInt(tv) == Battle.TurnNumber) wave = i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
var waves = new List<int>();
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
if (r.side == "enemy" && r.spawnTurn > 0 && !waves.Contains(r.spawnTurn)) waves.Add(r.spawnTurn);
|
|||
|
|
waves.Sort();
|
|||
|
|
int waveTurn = wave >= 0 && waves.Count > 0 ? waves[Mathf.Min(wave, waves.Count - 1)] : -1;
|
|||
|
|
if (waveTurn > 0)
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
{
|
|||
|
|
if (r.side != "enemy" || r.spawnTurn != waveTurn) continue;
|
|||
|
|
var e = EnemySpawn(r);
|
|||
|
|
var u = Battle.SpawnUnit(e.type, Faction.Enemy, e.position, e.name, e.hpMult, e.atkMult, e.isBoss, e.art);
|
|||
|
|
Battle.Skills.AttachEnemy(u, e, false);
|
|||
|
|
unitRow[u] = r;
|
|||
|
|
if (!Sim.Active) Fx.Popup(u.Position, "원군!", new Color(1f, 0.4f, 0.3f));
|
|||
|
|
}
|
|||
|
|
if (WindTurn() && !Sim.Active) Fx.Popup(Vector2.up * 6f, "바람이 분다 →", new Color(0.8f, 0.9f, 1f));
|
|||
|
|
if (ChargeTurn()) ArmCharge();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ContentRow HoldRule()
|
|||
|
|
{
|
|||
|
|
foreach (var r in conds)
|
|||
|
|
if (r.S("s_cond") == "hold_in_zone") return r;
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 돌진(boss_charge · 맹장 토벌전 여포 줄과 같은 폭 · 피해 · 밀어냄) ----------
|
|||
|
|
|
|||
|
|
bool ChargeTurn()
|
|||
|
|
{
|
|||
|
|
var c = Rule("boss_charge");
|
|||
|
|
if (c == null) return false;
|
|||
|
|
var parts = V(c).Split(':'); // 「돌진 주기(턴) : 바위에 막히면 멈추는 턴」
|
|||
|
|
float every;
|
|||
|
|
return parts.Length > 0 && ContentTables.TryNum(parts[0], out every) && every > 0f && Battle.TurnNumber % Mathf.RoundToInt(every) == 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void ArmCharge()
|
|||
|
|
{
|
|||
|
|
var t = TagUnits("target").Find(u => u.IsAlive);
|
|||
|
|
var players = Battle.AliveUnits(Faction.Player);
|
|||
|
|
players.RemoveAll(p => p.Npc);
|
|||
|
|
if (t == null || players.Count == 0) return;
|
|||
|
|
Unit far = players[0];
|
|||
|
|
foreach (var p in players)
|
|||
|
|
if (Vector2.Distance(p.Position, t.Position) > Vector2.Distance(far.Position, t.Position)) far = p;
|
|||
|
|
chargeDir = (far.Position - t.Position).normalized;
|
|||
|
|
chargeArmed = true;
|
|||
|
|
var lv = ContentTables.Find(RaidData.Stats, "s_boss_id", "lvbu");
|
|||
|
|
float w = lv != null ? lv.F("f_pattern_size") : 1f, len = Battle.Config.boardSize.magnitude;
|
|||
|
|
var go = new GameObject("ScnWarn");
|
|||
|
|
go.transform.position = (Vector3)(t.Position + chargeDir * len * 0.5f);
|
|||
|
|
var sr = ProceduralSprites.NewSprite(go.transform, "Fill", ProceduralSprites.Square, new Color(1f, 0.15f, 0.1f, 0.32f), 1f, 5);
|
|||
|
|
Vector2 native = sr.sprite.bounds.size;
|
|||
|
|
sr.transform.localScale = new Vector3(w / native.x, len / native.y, 1f);
|
|||
|
|
sr.transform.localRotation = Quaternion.Euler(0f, 0f, Mathf.Atan2(chargeDir.y, chargeDir.x) * Mathf.Rad2Deg - 90f);
|
|||
|
|
warn = go;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
GameObject warn;
|
|||
|
|
|
|||
|
|
IEnumerator BossCharge()
|
|||
|
|
{
|
|||
|
|
if (!chargeArmed) yield break;
|
|||
|
|
chargeArmed = false;
|
|||
|
|
if (warn != null) Object.Destroy(warn);
|
|||
|
|
var t = TagUnits("target").Find(u => u.IsAlive);
|
|||
|
|
var lv = ContentTables.Find(RaidData.Stats, "s_boss_id", "lvbu");
|
|||
|
|
if (t == null || lv == null) yield break;
|
|||
|
|
float width = lv.F("f_pattern_size"), mult = lv.F("n_pattern_dmg_pct") / 100f, push = lv.F("f_pattern_push");
|
|||
|
|
Vector2 from = t.Position, to = from;
|
|||
|
|
bool blocked = false;
|
|||
|
|
for (float d = 0.2f; d <= Battle.Config.boardSize.magnitude; d += 0.2f)
|
|||
|
|
{
|
|||
|
|
Vector2 p = from + chargeDir * d;
|
|||
|
|
if (Battle.Board.ClampInside(p, t.Radius) != p) break;
|
|||
|
|
bool hit = false;
|
|||
|
|
if (Battle.Gimmicks != null)
|
|||
|
|
foreach (var g in Battle.Gimmicks.Items)
|
|||
|
|
if (g.BlocksMove && !g.Broken && !g.Removed && g.Shape.SignedDistance(p) < t.Radius) hit = true;
|
|||
|
|
if (hit)
|
|||
|
|
{
|
|||
|
|
blocked = true;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
to = p;
|
|||
|
|
}
|
|||
|
|
var victims = new List<Unit>();
|
|||
|
|
foreach (var u in Battle.AliveUnits(Faction.Player))
|
|||
|
|
{
|
|||
|
|
float along = Vector2.Dot(u.Position - from, chargeDir);
|
|||
|
|
float off = Mathf.Abs(Vector2.Dot(u.Position - from, new Vector2(-chargeDir.y, chargeDir.x)));
|
|||
|
|
if (along >= 0f && along <= Vector2.Distance(from, to) + t.Radius && off <= width * 0.5f + u.Radius) victims.Add(u);
|
|||
|
|
}
|
|||
|
|
if (!Sim.Active) yield return Fx.MoveAlong(t.transform, from, to, Battle.Config.moveSpeed, null);
|
|||
|
|
t.Position = to;
|
|||
|
|
foreach (var v in victims)
|
|||
|
|
{
|
|||
|
|
int dmg = Mathf.RoundToInt(Combat.Damage(Config, t, v, false, Battle.Rng, true) * mult);
|
|||
|
|
SkillSystem.Deal(v, dmg, t, HitKind.Skill);
|
|||
|
|
if (v.IsAlive && push > 0f) v.Position = Battle.Board.ClampInside(v.Position + chargeDir * push * v.PushTaken, v.Radius);
|
|||
|
|
}
|
|||
|
|
if (Battle.Gimmicks != null) Battle.Gimmicks.ResolveOverlaps();
|
|||
|
|
Physics2D.SyncTransforms();
|
|||
|
|
if (blocked)
|
|||
|
|
{
|
|||
|
|
var c = Rule("boss_charge");
|
|||
|
|
var parts = V(c).Split(':');
|
|||
|
|
float stun;
|
|||
|
|
chargeStunUntil = Battle.TurnNumber + (parts.Length > 1 && ContentTables.TryNum(parts[1], out stun) ? Mathf.RoundToInt(stun) : 0);
|
|||
|
|
if (!Sim.Active) Fx.Popup(t.Position, "돌진이 막혔다!", new Color(1f, 0.9f, 0.3f));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 조건 판정 ----------
|
|||
|
|
|
|||
|
|
/// <summary>조건 1줄을 지금 채웠는가(end = 전투 끝 판정 · false = 진행 중 승리 검사).</summary>
|
|||
|
|
bool Met(ContentRow r, bool end)
|
|||
|
|
{
|
|||
|
|
string c = r.S("s_cond");
|
|||
|
|
var tg = Targets(r);
|
|||
|
|
string t0 = tg.Count > 0 ? tg[0] : "", t1 = tg.Count > 1 ? tg[1] : "";
|
|||
|
|
float v = VF(r);
|
|||
|
|
switch (c)
|
|||
|
|
{
|
|||
|
|
case "kill_target":
|
|||
|
|
{
|
|||
|
|
var us = TagUnits(t0);
|
|||
|
|
int dead = us.FindAll(u => !u.IsAlive).Count;
|
|||
|
|
return us.Count > 0 && dead >= Mathf.Min(us.Count, Mathf.Max(1, Mathf.RoundToInt(v)));
|
|||
|
|
}
|
|||
|
|
case "turn_limit": return Battle.TurnNumber <= v;
|
|||
|
|
case "survive_turns": return end && Battle.TurnNumber >= v && TagUnits(t0).Exists(u => u.IsAlive);
|
|||
|
|
case "rescue": return TagUnits(t0).Exists(u => rescued.Contains(u));
|
|||
|
|
case "escape":
|
|||
|
|
case "return_home":
|
|||
|
|
{
|
|||
|
|
var mark = TagRow(t1);
|
|||
|
|
if (mark == null) return false;
|
|||
|
|
if (c == "escape" && TagUnits("adou").Count > 0 && !TagUnits("adou").Exists(u => rescued.Contains(u))) return false;
|
|||
|
|
if (c == "return_home" && Count("hit:" + TargetOf("hit_target")) <= 0) return false;
|
|||
|
|
return TagUnits(t0).Exists(u => u.IsAlive && Vector2.Distance(u.Position, mark.pos) <= mark.wOrR + u.Radius * 0.5f);
|
|||
|
|
}
|
|||
|
|
case "destroy_objects": return Count("broken:" + t0) >= v;
|
|||
|
|
case "ignite_count": return Count("ignite:" + t0) >= v;
|
|||
|
|
case "hit_by_all":
|
|||
|
|
{
|
|||
|
|
var trio = TagUnits("trio");
|
|||
|
|
if (trio.Count == 0) trio = TagUnits("hero");
|
|||
|
|
foreach (var target in TagUnits(t0))
|
|||
|
|
{
|
|||
|
|
HashSet<Unit> s;
|
|||
|
|
if (!hitBy.TryGetValue(target, out s)) return false;
|
|||
|
|
foreach (var h in trio)
|
|||
|
|
if (!s.Contains(h)) return false;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
case "hit_target": return Count("hit:" + t0) >= v;
|
|||
|
|
case "gimmick_kill": return Count("gk:" + t0) >= v;
|
|||
|
|
case "no_attack": return !noAttackBroken;
|
|||
|
|
case "no_death": return t0.Length == 0 ? !allyLost : Count("dead:" + t0) == 0;
|
|||
|
|
case "hp_keep":
|
|||
|
|
{
|
|||
|
|
var u = TagUnits(t0).Find(x => x.Faction == Faction.Player);
|
|||
|
|
return u != null && u.IsAlive && u.Hp * 100f >= v * u.MaxHp;
|
|||
|
|
}
|
|||
|
|
case "finisher": return Count("fin:" + t1) >= v;
|
|||
|
|
case "miss_limit": return missShots <= v;
|
|||
|
|
case "hold_in_zone": return holdTurns >= v;
|
|||
|
|
case "no_zone_damage": return !zoneHurt;
|
|||
|
|
case "no_pass": return !passed;
|
|||
|
|
case "per_turn_count": return Mathf.Max(bestPerTurnIgnite, bestPerTurn) >= v;
|
|||
|
|
case "by_turn":
|
|||
|
|
{
|
|||
|
|
var p = V(r).Split(':');
|
|||
|
|
float tt, nn;
|
|||
|
|
if (p.Length < 2 || !ContentTables.TryNum(p[0], out tt) || !ContentTables.TryNum(p[1], out nn)) return false;
|
|||
|
|
int sum = 0;
|
|||
|
|
for (int k = 1; k <= tt; k++) sum += Count("ignite_turn:" + t0 + ":" + k);
|
|||
|
|
return sum >= nn;
|
|||
|
|
}
|
|||
|
|
case "chain_battle": return act >= acts && TagUnits(t0).TrueForAll(u => !u.IsAlive);
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
string TargetOf(string cond)
|
|||
|
|
{
|
|||
|
|
foreach (var r in conds)
|
|||
|
|
if (r.S("s_cond") == cond && Targets(r).Count > 0) return Targets(r)[0];
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>승리 조건 가운데 시간 조건(턴 제한 · 버티기)을 뺀 것이 모두 채워졌는가.</summary>
|
|||
|
|
bool WinNow()
|
|||
|
|
{
|
|||
|
|
bool any = false;
|
|||
|
|
foreach (var r in Slot("win"))
|
|||
|
|
{
|
|||
|
|
string c = r.S("s_cond");
|
|||
|
|
if (c == "turn_limit") continue;
|
|||
|
|
if (c == "survive_turns") return false;
|
|||
|
|
any = true;
|
|||
|
|
if (!Met(r, false)) return false;
|
|||
|
|
}
|
|||
|
|
return any;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool CheckEnd(out BattlePhase phase, out string message)
|
|||
|
|
{
|
|||
|
|
phase = BattlePhase.PlayerTurn;
|
|||
|
|
message = null;
|
|||
|
|
// 저지선(no_pass) = 적이 선을 넘음
|
|||
|
|
var line = layout.Find(r => r.side == "mark" && r.gimmickId == "line");
|
|||
|
|
if (line != null)
|
|||
|
|
foreach (var e in Battle.AliveUnits(Faction.Enemy))
|
|||
|
|
if (!e.Npc && e.Position.y < line.pos.y) passed = true;
|
|||
|
|
// 실패: 주역 · 구출 대상이 쓰러짐
|
|||
|
|
if (heroUnit != null && !heroUnit.IsAlive)
|
|||
|
|
{
|
|||
|
|
phase = BattlePhase.Defeat;
|
|||
|
|
message = "주역이 쓰러졌다";
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
foreach (var a in TagUnits("adou"))
|
|||
|
|
if (!a.IsAlive)
|
|||
|
|
{
|
|||
|
|
phase = BattlePhase.Defeat;
|
|||
|
|
message = "구출 대상이 쓰러졌다";
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
// 연전 — 이 판의 장수(general)를 모두 쓰러뜨리면 다음 판
|
|||
|
|
var chain = Rule("chain_battle") ?? Slot("win").Find(r => r.S("s_cond") == "chain_battle");
|
|||
|
|
if (chain != null && act < acts)
|
|||
|
|
{
|
|||
|
|
string tag = Targets(chain).Count > 0 ? Targets(chain)[0] : "general";
|
|||
|
|
var gens = new List<Unit>();
|
|||
|
|
foreach (var kv in unitRow)
|
|||
|
|
if (kv.Key != null && kv.Value.tag == tag && kv.Key.Faction == Faction.Enemy) gens.Add(kv.Key);
|
|||
|
|
if (gens.Count > 0 && gens.TrueForAll(u => !u.IsAlive) && !pendingAct)
|
|||
|
|
{
|
|||
|
|
if (Battle.Phase == BattlePhase.EnemyTurn) pendingAct = true; // 적 턴 도중 = 다음 아군 턴 시작에 넘어간다
|
|||
|
|
else NextAct(true);
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (WinNow())
|
|||
|
|
{
|
|||
|
|
phase = BattlePhase.StageClear;
|
|||
|
|
message = "승리 — " + battle.S("s_win_cond_ko");
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override BattlePhase OnTurnLimit(out string message)
|
|||
|
|
{
|
|||
|
|
foreach (var r in Slot("win"))
|
|||
|
|
if (r.S("s_cond") == "survive_turns" && Met(r, true))
|
|||
|
|
{
|
|||
|
|
message = "버텨 냈다 — 승리";
|
|||
|
|
return BattlePhase.StageClear;
|
|||
|
|
}
|
|||
|
|
message = Battle.TurnLimit + "턴 종료 — 실패";
|
|||
|
|
return BattlePhase.Defeat;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool pendingAct;
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// 오관참육장 다음 판 — 남은 적 · 기믹 · 표시를 치우고 다음 판 배치를 놓는다(아군 체력 · 스킬 대기 · 턴 수는 이어짐 · 출발 자리는 판마다 같다).
|
|||
|
|
/// newTurn = 아군 행동 중에 넘어감(새 아군 턴을 연다) · false = 이미 새 아군 턴이 시작됨(적 턴에 넘어간 경우).
|
|||
|
|
/// </summary>
|
|||
|
|
void NextAct(bool newTurn)
|
|||
|
|
{
|
|||
|
|
foreach (var u in new List<Unit>(Battle.Units))
|
|||
|
|
if (u != null && u.Faction == Faction.Enemy) Battle.RemoveUnit(u);
|
|||
|
|
if (Battle.Gimmicks != null)
|
|||
|
|
foreach (var g in gims) Battle.Gimmicks.Remove(g);
|
|||
|
|
gims.Clear();
|
|||
|
|
gimRow.Clear();
|
|||
|
|
ignited.Clear();
|
|||
|
|
ClearMarks();
|
|||
|
|
var keep = new Dictionary<Unit, ContentLayoutRow>();
|
|||
|
|
foreach (var kv in unitRow)
|
|||
|
|
if (kv.Key != null && kv.Key.Faction == Faction.Player) keep[kv.Key] = kv.Value;
|
|||
|
|
unitRow.Clear();
|
|||
|
|
foreach (var kv in keep) unitRow[kv.Key] = kv.Value;
|
|||
|
|
LoadAct(act + 1, null);
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
{
|
|||
|
|
if (r.side == "enemy" && r.spawnTurn <= 0)
|
|||
|
|
{
|
|||
|
|
var e = EnemySpawn(r);
|
|||
|
|
var u = Battle.SpawnUnit(e.type, Faction.Enemy, e.position, e.name, e.hpMult, e.atkMult, e.isBoss, e.art);
|
|||
|
|
Battle.Skills.AttachEnemy(u, e, false);
|
|||
|
|
unitRow[u] = r;
|
|||
|
|
}
|
|||
|
|
if (r.side == "ally")
|
|||
|
|
foreach (var kv in keep)
|
|||
|
|
if (kv.Key.HeroId == r.unitId && kv.Key.IsAlive) kv.Key.Position = r.pos;
|
|||
|
|
}
|
|||
|
|
foreach (var r in layout)
|
|||
|
|
{
|
|||
|
|
if (r.side == "gimmick")
|
|||
|
|
{
|
|||
|
|
var g = ContentLayout.SpawnGimmick(Battle.Gimmicks, r);
|
|||
|
|
if (g == null) continue;
|
|||
|
|
gims.Add(g);
|
|||
|
|
gimRow[g] = r;
|
|||
|
|
}
|
|||
|
|
else if (r.side == "mark") DrawMark(r);
|
|||
|
|
}
|
|||
|
|
if (Battle.Gimmicks != null) Battle.Gimmicks.ResolveOverlaps();
|
|||
|
|
Physics2D.SyncTransforms();
|
|||
|
|
if (!Sim.Active) Fx.Popup(Vector2.zero, act + "번째 관문", new Color(1f, 0.9f, 0.5f));
|
|||
|
|
if (newTurn) Battle.NextActTurn();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------- 결과 ----------
|
|||
|
|
|
|||
|
|
public bool[] Challenges(bool win)
|
|||
|
|
{
|
|||
|
|
var res = new bool[2];
|
|||
|
|
var c1 = Slot("challenge1");
|
|||
|
|
var c2 = Slot("challenge2");
|
|||
|
|
res[0] = win && c1.Count > 0 && c1.TrueForAll(r => Met(r, true));
|
|||
|
|
res[1] = win && c2.Count > 0 && c2.TrueForAll(r => Met(r, true));
|
|||
|
|
return res;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override bool[] Tasks
|
|||
|
|
{
|
|||
|
|
get { return Challenges(Battle != null && Battle.Phase == BattlePhase.StageClear); }
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override string ProgressLine
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
var parts = new List<string>();
|
|||
|
|
foreach (var r in Slot("win"))
|
|||
|
|
if (r.S("s_cond") != "turn_limit") parts.Add((Met(r, false) ? "●" : "○") + Label(r) + Progress(r));
|
|||
|
|
if (acts > 1) parts.Add(act + "/" + acts + "판");
|
|||
|
|
return string.Join(" ", parts.ToArray());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>집계형 조건의 진행 수(「 3/10」).</summary>
|
|||
|
|
string Progress(ContentRow r)
|
|||
|
|
{
|
|||
|
|
var tg = Targets(r);
|
|||
|
|
string t0 = tg.Count > 0 ? tg[0] : "";
|
|||
|
|
int v = Mathf.RoundToInt(VF(r)), n = -1;
|
|||
|
|
switch (r.S("s_cond"))
|
|||
|
|
{
|
|||
|
|
case "ignite_count": n = Count("ignite:" + t0); break;
|
|||
|
|
case "destroy_objects": n = Count("broken:" + t0); break;
|
|||
|
|
case "hit_target": n = Count("hit:" + t0); break;
|
|||
|
|
case "gimmick_kill": n = Count("gk:" + t0); break;
|
|||
|
|
case "kill_target": n = TagUnits(t0).FindAll(u => !u.IsAlive).Count; break;
|
|||
|
|
case "survive_turns": n = Battle != null ? Battle.TurnNumber : 0; break;
|
|||
|
|
}
|
|||
|
|
return n >= 0 ? " " + n + "/" + v : "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
string Label(ContentRow r)
|
|||
|
|
{
|
|||
|
|
var d = ContentTables.Find("scenario_conditions", "s_key", r.S("s_cond"));
|
|||
|
|
return d != null ? d.S("s_name_ko") : r.S("s_cond");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public override void Summarize(List<string> lines)
|
|||
|
|
{
|
|||
|
|
if (battle == null) return;
|
|||
|
|
var ch = Challenges(Battle != null && Battle.Phase == BattlePhase.StageClear);
|
|||
|
|
lines.Add("도전 1 「" + battle.S("s_challenge1_ko") + "」 " + (ch[0] ? "달성" : "미달성"));
|
|||
|
|
lines.Add("도전 2 「" + battle.S("s_challenge2_ko") + "」 " + (ch[1] ? "달성" : "미달성"));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|