838 lines
34 KiB
C#
838 lines
34 KiB
C#
using System.Collections.Generic;
|
||
using UnityEngine;
|
||
using UnityEngine.UI;
|
||
|
||
namespace TKS.OutGame
|
||
{
|
||
/// <summary>
|
||
/// 연무장 허브 연출(PD 2026-11-18 「기존 내정 메뉴를 참고해 연무장 화면에 애니메이션 연출 · 맵 내 환경 연출」) — 값 = 표 Resources/UI/Yeonmu/yeonmu_scene.csv
|
||
/// (내정·로비와 같은 LobbyScene 형식 + s_spot · f_tx · f_ty · C45 · 허브 표 키 scene).
|
||
/// 환경 = 내정·로비와 같은 코드 LobbyAmbient: flag 깃발 · sway 풀꽃 · light 등불(유닛 아래 AmbBack) · bird 새 떼 · petal 꽃잎(유닛 위 AmbFront).
|
||
/// 이 코드 = patch(깃발 자리 바탕 · 배경 Static 층) · cloud(흘러가는 구름 + 땅 그림자) · 유닛 연출 duel(비무대 대련) · shoot(훈련장 궁병 활쏘기 → 과녁에 꽂힘) ·
|
||
/// zzz(서서 조는 병사 z) · spark(수리 병사 망치 불똥) · drop(말 입에서 떨어지는 건초) — 유닛 그림은 원화 클립 그대로 이어 붙임(새로 그리는 애니 없음 · 내정 UiDrillAnim 과 같은 원칙).
|
||
/// 층(P41): Content → Art(Static · 배경 + patch) → AmbBack(Frame) → Scene(Frame · 유닛) → Fx(Frame · 구름 그림자 · 화살 · 불똥 · z) → AmbFront(Frame) → Clouds(Frame) → Tags(Event).
|
||
/// 좌표 = 배경 캔버스 px(왼쪽 위 0,0 · 아래로 +) · 유닛 연출의 「그림 px」 = 그 유닛 프레임(meta frame) px(왼쪽 위 0,0).
|
||
/// </summary>
|
||
public class ArenaHubFx : MonoBehaviour
|
||
{
|
||
const string Idle = "front_idle";
|
||
const string Ready = "front_ready";
|
||
const string Action = "front_action";
|
||
const string DrillReady = "drill_ready";
|
||
const string DrillAction = "drill_action";
|
||
const int PoolMax = 64;
|
||
|
||
/// <summary>유닛 연결(허브 장식 유닛 1명) — 그림 px → 캔버스 px 환산.</summary>
|
||
class ActorRef
|
||
{
|
||
public RectTransform rt;
|
||
public Image img;
|
||
public UnitArtData data;
|
||
public Vector2 basePos;
|
||
public float dir = 1f;
|
||
public float fw;
|
||
public float fh;
|
||
public float k;
|
||
public Vector2 pivot;
|
||
|
||
/// <summary>그림 px 점(fx, fy) → 캔버스 px(아래로 +) · pos = 유닛 anchoredPosition(발).</summary>
|
||
public Vector2 At(float fx, float fy, Vector2 pos)
|
||
{
|
||
float lx = (fx - pivot.x * fw) * k * dir;
|
||
float ly = (fh - fy - pivot.y * fh) * k;
|
||
return new Vector2(pos.x + lx, -pos.y - ly);
|
||
}
|
||
|
||
public Vector2 At(float fx, float fy)
|
||
{
|
||
return At(fx, fy, basePos);
|
||
}
|
||
}
|
||
|
||
class Particle
|
||
{
|
||
public RectTransform rt;
|
||
public Image img;
|
||
public bool on;
|
||
public Vector2 p;
|
||
public Vector2 v;
|
||
public float g;
|
||
public float t;
|
||
public float life;
|
||
public float s0;
|
||
public float s1;
|
||
public float rot;
|
||
public float vrot;
|
||
public float fin;
|
||
public float fout;
|
||
public float sway;
|
||
public float ph;
|
||
public Color c;
|
||
}
|
||
|
||
class Fighter
|
||
{
|
||
public ActorRef a;
|
||
public LobbyScene.Row row;
|
||
public Sprite[] idle;
|
||
public Sprite ready;
|
||
public Sprite action;
|
||
public Vector2 idlePos;
|
||
public Vector2 readyPos;
|
||
public Vector2 actionPos;
|
||
public float idleOffset;
|
||
public float nextBlink;
|
||
public float blinkEnd = -1f;
|
||
public float knockAt = -99f;
|
||
public float knockAmp;
|
||
|
||
public float Turn
|
||
{
|
||
get { return Mathf.Max(0.1f, row.rest + row.stand + row.ready + row.hit + row.hold); }
|
||
}
|
||
}
|
||
|
||
class Duel
|
||
{
|
||
public readonly Fighter[] f = new Fighter[2];
|
||
public int lastTurn = -1;
|
||
public float t0;
|
||
}
|
||
|
||
class Shooter
|
||
{
|
||
public ActorRef a;
|
||
public LobbyScene.Row row;
|
||
public Sprite[] idle;
|
||
public Sprite aim;
|
||
public Sprite loose;
|
||
public float idleOffset;
|
||
public float nextBlink;
|
||
public float blinkEnd = -1f;
|
||
public int lastCycle = int.MinValue;
|
||
public float shotAt = -99f;
|
||
public bool landed;
|
||
public Image arrow;
|
||
public Image stuck;
|
||
public Vector2 from;
|
||
public Vector2 to;
|
||
public float stuckRot;
|
||
}
|
||
|
||
class Sleeper
|
||
{
|
||
public ActorRef a;
|
||
public LobbyScene.Row row;
|
||
public Sprite[] sp;
|
||
public int i;
|
||
public float next;
|
||
}
|
||
|
||
class Trigger
|
||
{
|
||
public ActorRef a;
|
||
public LobbyScene.Row row;
|
||
public Sprite[] frames;
|
||
public Sprite[] sp;
|
||
public int last = -1;
|
||
}
|
||
|
||
class Cloud
|
||
{
|
||
public LobbyScene.Row row;
|
||
public RectTransform wisp;
|
||
public RectTransform shadow;
|
||
public float x;
|
||
public float w;
|
||
}
|
||
|
||
ArenaHub hub;
|
||
Vector2 canvas;
|
||
RectTransform clouds;
|
||
readonly List<Particle> pool = new List<Particle>();
|
||
readonly List<Duel> duels = new List<Duel>();
|
||
readonly List<Shooter> shooters = new List<Shooter>();
|
||
readonly List<Sleeper> sleepers = new List<Sleeper>();
|
||
readonly List<Trigger> triggers = new List<Trigger>();
|
||
readonly List<Cloud> cloudList = new List<Cloud>();
|
||
List<LobbyScene.Row> rows;
|
||
|
||
/// <summary>층(테스트): 유닛 아래 환경 · 연출 · 유닛 위 환경 · 구름.</summary>
|
||
public RectTransform AmbBack { get; private set; }
|
||
public RectTransform Layer { get; private set; }
|
||
public RectTransform AmbFront { get; private set; }
|
||
public RectTransform Clouds
|
||
{
|
||
get { return clouds; }
|
||
}
|
||
|
||
/// <summary>묶은 유닛 연출 수(테스트 · 캡처 로그): 대련 쌍 · 궁병 · 조는 병사 · 프레임 맞춤(불똥 · 건초) · 구름.</summary>
|
||
public int DuelCount
|
||
{
|
||
get { return duels.Count; }
|
||
}
|
||
|
||
public int ShooterCount
|
||
{
|
||
get { return shooters.Count; }
|
||
}
|
||
|
||
public int SleeperCount
|
||
{
|
||
get { return sleepers.Count; }
|
||
}
|
||
|
||
public int TriggerCount
|
||
{
|
||
get { return triggers.Count; }
|
||
}
|
||
|
||
public int CloudCount
|
||
{
|
||
get { return cloudList.Count; }
|
||
}
|
||
|
||
/// <summary>프레임 맞춤 연출(불똥 · 건초)이 원화 프레임을 잡은 횟수 · 지금 켜진 입자 수(테스트 · 캡처 로그).</summary>
|
||
public int Fired { get; private set; }
|
||
|
||
public int ParticlesOn
|
||
{
|
||
get
|
||
{
|
||
int n = 0;
|
||
foreach (var p in pool)
|
||
if (p.on)
|
||
n++;
|
||
return n;
|
||
}
|
||
}
|
||
|
||
/// <summary>프레임 맞춤 연출이 보는 유닛의 지금 원화 프레임 번호(-1 = 클립 밖 그림 · 캡처 로그 점검).</summary>
|
||
public string TriggerFrames()
|
||
{
|
||
var sb = new System.Text.StringBuilder();
|
||
foreach (var t in triggers) sb.Append(t.row.kind).Append('=').Append(System.Array.IndexOf(t.frames, t.a.img.sprite)).Append('/').Append(t.frames.Length).Append(' ');
|
||
return sb.ToString();
|
||
}
|
||
|
||
/// <summary>지금 날고 있는 화살 수 · 꽂혀 있는 화살 수(테스트).</summary>
|
||
public int ArrowsFlying
|
||
{
|
||
get
|
||
{
|
||
int n = 0;
|
||
foreach (var s in shooters)
|
||
if (s.arrow != null && s.arrow.enabled)
|
||
n++;
|
||
return n;
|
||
}
|
||
}
|
||
|
||
public int ArrowsStuck
|
||
{
|
||
get
|
||
{
|
||
int n = 0;
|
||
foreach (var s in shooters)
|
||
if (s.stuck != null && s.stuck.enabled)
|
||
n++;
|
||
return n;
|
||
}
|
||
}
|
||
|
||
// ---------- 만들기 ----------
|
||
|
||
/// <summary>
|
||
/// 허브(배경 · 유닛 · 이름표 층이 다 만들어진 뒤)에 연출을 얹는다 — 표가 없으면 null(연출 없이 예전 그대로).
|
||
/// </summary>
|
||
public static ArenaHubFx Build(ArenaHub hub, string table, Vector2 cs)
|
||
{
|
||
var rows = string.IsNullOrEmpty(table) ? null : LobbyScene.Load(table);
|
||
if (rows == null || rows.Count == 0) return null;
|
||
// ① 깃발 자리 바탕(배경과 같은 Static 층 · 흔들릴 때 원래 깃발이 비치지 않게)
|
||
foreach (var r in rows)
|
||
if (r.kind == "patch")
|
||
Patch(hub.Art, r);
|
||
// ② 유닛 아래 환경(깃발 · 풀꽃 · 등불) = LobbyAmbient(내정·로비와 같은 코드)
|
||
var back = Kinds(rows, "flag", "sway", "light");
|
||
RectTransform ambBack = null;
|
||
if (back.Count > 0)
|
||
{
|
||
ambBack = (RectTransform)LobbyAmbient.Build(hub.Content, cs.x, cs.y, back).transform;
|
||
ambBack.name = "AmbBack";
|
||
ambBack.SetSiblingIndex(hub.Scene.GetSiblingIndex());
|
||
}
|
||
// ③ 연출 층(유닛 위 · 이름표 아래)
|
||
var layer = UiLayer.Group("Fx", hub.Content, UiRate.Frame);
|
||
layer.SetSiblingIndex(hub.Tags.GetSiblingIndex());
|
||
var fx = layer.gameObject.AddComponent<ArenaHubFx>();
|
||
fx.hub = hub;
|
||
fx.canvas = cs;
|
||
fx.rows = rows;
|
||
fx.Layer = layer;
|
||
fx.AmbBack = ambBack;
|
||
// ④ 유닛 위 환경(새 떼 · 꽃잎)
|
||
var front = Kinds(rows, "bird", "petal");
|
||
if (front.Count > 0)
|
||
{
|
||
fx.AmbFront = (RectTransform)LobbyAmbient.Build(hub.Content, cs.x, cs.y, front).transform;
|
||
fx.AmbFront.name = "AmbFront";
|
||
fx.AmbFront.SetSiblingIndex(hub.Tags.GetSiblingIndex());
|
||
}
|
||
// ⑤ 구름(맨 위 · 이름표 아래)
|
||
fx.clouds = UiLayer.Group("Clouds", hub.Content, UiRate.Frame);
|
||
fx.clouds.SetSiblingIndex(hub.Tags.GetSiblingIndex());
|
||
fx.Setup();
|
||
return fx;
|
||
}
|
||
|
||
static List<LobbyScene.Row> Kinds(List<LobbyScene.Row> src, params string[] kinds)
|
||
{
|
||
var list = new List<LobbyScene.Row>();
|
||
foreach (var r in src)
|
||
if (System.Array.IndexOf(kinds, r.kind) >= 0)
|
||
list.Add(r);
|
||
return list;
|
||
}
|
||
|
||
static Sprite Sp(string id)
|
||
{
|
||
if (string.IsNullOrEmpty(id)) return null;
|
||
var sp = UISkin.Icon(id);
|
||
if (sp == null && id.IndexOf('/') >= 0) sp = Resources.Load<Sprite>(id);
|
||
return sp;
|
||
}
|
||
|
||
static Sprite[] Sps(LobbyScene.Row r)
|
||
{
|
||
var list = new List<Sprite>();
|
||
foreach (var id in r.Sprites)
|
||
{
|
||
var s = Sp(id);
|
||
if (s != null) list.Add(s);
|
||
}
|
||
return list.ToArray();
|
||
}
|
||
|
||
static void Patch(RectTransform art, LobbyScene.Row r)
|
||
{
|
||
var sp = Sp(r.sprite);
|
||
if (sp == null) return;
|
||
var rt = UiKit.Rect("Patch_" + sp.name, art, new Vector2(0f, 1f), new Vector2(0f, 1f), new Vector2(r.x, -r.y), new Vector2(r.w, r.h));
|
||
var img = rt.gameObject.AddComponent<Image>();
|
||
img.sprite = sp;
|
||
img.raycastTarget = false;
|
||
}
|
||
|
||
void Setup()
|
||
{
|
||
// 구름 그림자는 연출 층 맨 앞(화살·불똥 아래)
|
||
foreach (var r in rows)
|
||
if (r.kind == "cloud")
|
||
AddCloud(r);
|
||
var pairs = new Dictionary<int, Duel>();
|
||
foreach (var r in rows)
|
||
{
|
||
switch (r.kind)
|
||
{
|
||
case "duel":
|
||
var f = NewFighter(r);
|
||
if (f == null) break;
|
||
Duel d;
|
||
if (!pairs.TryGetValue(r.n, out d))
|
||
{
|
||
pairs[r.n] = d = new Duel { t0 = Time.unscaledTime + r.first };
|
||
d.f[0] = f;
|
||
}
|
||
else if (d.f[1] == null)
|
||
{
|
||
d.f[1] = f;
|
||
duels.Add(d);
|
||
}
|
||
break;
|
||
case "shoot":
|
||
AddShooter(r);
|
||
break;
|
||
case "zzz":
|
||
AddSleeper(r);
|
||
break;
|
||
case "spark":
|
||
case "drop":
|
||
AddTrigger(r);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
ActorRef Bind(LobbyScene.Row r)
|
||
{
|
||
if (hub == null || string.IsNullOrEmpty(r.spot)) return null;
|
||
var rt = hub.ActorRt(r.spot, r.slot);
|
||
var def = hub.ActorOf(r.spot, r.slot);
|
||
if (rt == null || def == null) return null;
|
||
var data = UnitArt.Load(def.art);
|
||
var img = rt.GetComponent<Image>();
|
||
if (data == null || img == null) return null;
|
||
float fw = data.Meta.frame != null && data.Meta.frame.Length > 1 ? data.Meta.frame[0] : rt.sizeDelta.x;
|
||
float fh = data.Meta.frame != null && data.Meta.frame.Length > 1 ? data.Meta.frame[1] : rt.sizeDelta.y;
|
||
return new ActorRef
|
||
{
|
||
rt = rt,
|
||
img = img,
|
||
data = data,
|
||
basePos = rt.anchoredPosition,
|
||
dir = rt.localScale.x < 0f ? -1f : 1f,
|
||
fw = fw,
|
||
fh = fh,
|
||
k = rt.sizeDelta.x / Mathf.Max(1f, fw),
|
||
pivot = rt.pivot,
|
||
};
|
||
}
|
||
|
||
/// <summary>대기 숨 프레임 재생을 이 연출이 맡는다(UiFrameAnim 은 뗀다 · 둘이 같은 그림을 바꾸면 깜빡임).</summary>
|
||
static void TakeOver(ActorRef a)
|
||
{
|
||
var fa = a.img.GetComponent<UiFrameAnim>();
|
||
if (fa != null) Object.Destroy(fa);
|
||
}
|
||
|
||
static Sprite First(UnitArtData d, string clip, Sprite def)
|
||
{
|
||
Sprite[] f;
|
||
return d.Clips.TryGetValue(clip, out f) && f.Length > 0 ? f[0] : def;
|
||
}
|
||
|
||
Fighter NewFighter(LobbyScene.Row r)
|
||
{
|
||
var a = Bind(r);
|
||
Sprite[] idle;
|
||
if (a == null || !a.data.Clips.TryGetValue(Idle, out idle) || idle.Length == 0) return null;
|
||
TakeOver(a);
|
||
var f = new Fighter { a = a, row = r, idle = idle };
|
||
f.ready = First(a.data, Ready, idle[0]);
|
||
f.action = First(a.data, Action, f.ready);
|
||
// 허브 표 발 자리 = 타격 그림(front_action) 자리 → 대기 = 타격의 뒷발 맞춤만큼 뒤로(내정 train_feet 와 같은 값 · f_x 자세 · f_w 타격 · 그림 px)
|
||
// f_y = 세 자세 모두 바라보는 쪽으로 옮기는 px(두 사람 간격 · 긴 창이 몸을 찌르지 않게 · 오른쪽 사람이 화면 밖으로 나가지 않게)
|
||
var fwd = new Vector2(a.dir * r.y, 0f);
|
||
f.actionPos = a.basePos + fwd;
|
||
f.idlePos = f.actionPos - new Vector2(a.dir * r.w * a.k, 0f);
|
||
f.readyPos = f.idlePos + new Vector2(a.dir * r.x * a.k, 0f);
|
||
f.idleOffset = Random.value * a.data.CycleSeconds(Idle, idle.Length);
|
||
return f;
|
||
}
|
||
|
||
void AddShooter(LobbyScene.Row r)
|
||
{
|
||
var a = Bind(r);
|
||
Sprite[] idle;
|
||
if (a == null || !a.data.Clips.TryGetValue(Idle, out idle) || idle.Length == 0) return;
|
||
TakeOver(a);
|
||
var s = new Shooter { a = a, row = r, idle = idle };
|
||
s.aim = First(a.data, DrillReady, First(a.data, Ready, idle[0]));
|
||
s.loose = First(a.data, DrillAction, First(a.data, Action, s.aim));
|
||
s.idleOffset = Random.value * a.data.CycleSeconds(Idle, idle.Length);
|
||
var sp = Sps(r);
|
||
if (sp.Length > 0)
|
||
{
|
||
// 화살 = 그림에 메긴 화살 길이 × f_h(0 = 1 · 작은 화면에서 보이게 · QA r1) · 촉 끝(오른쪽)이 피벗
|
||
float len = r.w * a.k * (r.h > 0.01f ? r.h : 1f);
|
||
float thick = len * sp[0].rect.height / Mathf.Max(1f, sp[0].rect.width) * (r.scale > 0.01f ? r.scale : 1f);
|
||
s.arrow = NewImage("Arrow_" + r.spot + r.slot, sp[0], new Vector2(1f, 0.5f), new Vector2(len, thick));
|
||
s.stuck = NewImage("Stuck_" + r.spot + r.slot, sp[0], new Vector2(1f, 0.5f), new Vector2(len, thick));
|
||
s.stuck.type = Image.Type.Filled;
|
||
s.stuck.fillMethod = Image.FillMethod.Horizontal;
|
||
s.stuck.fillOrigin = (int)Image.OriginHorizontal.Left;
|
||
s.stuck.fillAmount = Mathf.Clamp01(r.min);
|
||
// 시작 = 그림 화살 촉(가운데 + 반 길이 · f_speed 각도) · 끝 = 과녁 가운데(f_tx, f_ty)
|
||
float ang = r.speed * Mathf.Deg2Rad;
|
||
s.from = a.At(r.x + Mathf.Cos(ang) * r.w * 0.5f, r.y - Mathf.Sin(ang) * r.w * 0.5f);
|
||
s.to = new Vector2(r.tx, r.ty);
|
||
}
|
||
shooters.Add(s);
|
||
}
|
||
|
||
void AddSleeper(LobbyScene.Row r)
|
||
{
|
||
var a = Bind(r);
|
||
var sp = Sps(r);
|
||
if (a == null || sp.Length == 0) return;
|
||
sleepers.Add(new Sleeper { a = a, row = r, sp = sp, next = Time.unscaledTime + r.first });
|
||
}
|
||
|
||
void AddTrigger(LobbyScene.Row r)
|
||
{
|
||
var a = Bind(r);
|
||
Sprite[] fr;
|
||
var sp = Sps(r);
|
||
if (a == null || sp.Length == 0 || !a.data.Clips.TryGetValue(Idle, out fr) || fr.Length == 0) return;
|
||
triggers.Add(new Trigger { a = a, row = r, frames = fr, sp = sp });
|
||
}
|
||
|
||
void AddCloud(LobbyScene.Row r)
|
||
{
|
||
var sp = Sps(r);
|
||
if (sp.Length == 0 || r.w <= 0f) return;
|
||
var c = new Cloud { row = r, w = r.w };
|
||
float h = r.w * sp[0].rect.height / Mathf.Max(1f, sp[0].rect.width);
|
||
if (sp.Length > 1 && r.shade > 0f)
|
||
{
|
||
var s = NewImage("CloudShadow", sp[1], new Vector2(0.5f, 0.5f), new Vector2(r.w, r.w * sp[1].rect.height / Mathf.Max(1f, sp[1].rect.width)));
|
||
s.color = new Color(0f, 0f, 0f, r.shade);
|
||
s.enabled = true;
|
||
c.shadow = s.rectTransform;
|
||
}
|
||
if (r.color.a > 0.001f)
|
||
{
|
||
var w = UiKit.Rect("Cloud", clouds, new Vector2(0f, 1f), new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(r.w, h));
|
||
var img = w.gameObject.AddComponent<Image>();
|
||
img.sprite = sp[0];
|
||
img.raycastTarget = false;
|
||
img.color = r.color;
|
||
c.wisp = w;
|
||
}
|
||
// 처음 자리 = f_phase(0 = 왼쪽 밖 · 1 = 오른쪽 밖) · 화면을 열자마자 보이게
|
||
c.x = Mathf.Lerp(-c.w * 0.5f, canvas.x + c.w * 0.5f, Mathf.Repeat(r.phase, 1f));
|
||
cloudList.Add(c);
|
||
}
|
||
|
||
Image NewImage(string name, Sprite sp, Vector2 pivot, Vector2 size)
|
||
{
|
||
var rt = UiKit.Rect(name, Layer, new Vector2(0f, 1f), pivot, Vector2.zero, size);
|
||
var img = rt.gameObject.AddComponent<Image>();
|
||
img.sprite = sp;
|
||
img.raycastTarget = false;
|
||
img.enabled = false;
|
||
return img;
|
||
}
|
||
|
||
// ---------- 입자 ----------
|
||
|
||
Particle Emit(Sprite sp, Vector2 pos, Vector2 vel, float grav, float life, float s0, float s1, Color c, float fin, float fout)
|
||
{
|
||
if (sp == null || life <= 0f) return null;
|
||
Particle p = null;
|
||
foreach (var q in pool)
|
||
if (!q.on)
|
||
{
|
||
p = q;
|
||
break;
|
||
}
|
||
if (p == null)
|
||
{
|
||
if (pool.Count >= PoolMax) return null;
|
||
var rt = UiKit.Rect("P" + pool.Count, Layer, new Vector2(0f, 1f), new Vector2(0.5f, 0.5f), Vector2.zero, Vector2.zero);
|
||
var img = rt.gameObject.AddComponent<Image>();
|
||
img.raycastTarget = false;
|
||
p = new Particle { rt = rt, img = img };
|
||
pool.Add(p);
|
||
}
|
||
p.on = true;
|
||
p.img.sprite = sp;
|
||
p.p = pos;
|
||
p.v = vel;
|
||
p.g = grav;
|
||
p.t = 0f;
|
||
p.life = life;
|
||
p.s0 = s0;
|
||
p.s1 = s1;
|
||
p.rot = 0f;
|
||
p.vrot = 0f;
|
||
p.fin = Mathf.Max(0.01f, fin);
|
||
p.fout = Mathf.Max(0.01f, fout);
|
||
p.sway = 0f;
|
||
p.ph = Random.value;
|
||
p.c = c;
|
||
p.rt.gameObject.SetActive(true);
|
||
Draw(p);
|
||
return p;
|
||
}
|
||
|
||
static void Draw(Particle p)
|
||
{
|
||
float u = Mathf.Clamp01(p.t / p.life);
|
||
float s = Mathf.Lerp(p.s0, p.s1, 1f - (1f - u) * (1f - u));
|
||
var sz = p.img.sprite.rect.size;
|
||
float k = s / Mathf.Max(1f, Mathf.Max(sz.x, sz.y));
|
||
p.rt.sizeDelta = sz * k;
|
||
float sx = p.sway * Mathf.Sin((p.t / 1.6f + p.ph) * Mathf.PI * 2f);
|
||
p.rt.anchoredPosition = new Vector2(p.p.x + sx, -p.p.y);
|
||
p.rt.localEulerAngles = new Vector3(0f, 0f, p.rot);
|
||
var c = p.c;
|
||
c.a *= Mathf.Clamp01(Mathf.Min(p.t / p.fin, (p.life - p.t) / p.fout));
|
||
p.img.color = c;
|
||
}
|
||
|
||
void UpdateParticles(float dt)
|
||
{
|
||
foreach (var p in pool)
|
||
{
|
||
if (!p.on) continue;
|
||
p.t += dt;
|
||
if (p.t >= p.life)
|
||
{
|
||
p.on = false;
|
||
p.rt.gameObject.SetActive(false);
|
||
continue;
|
||
}
|
||
p.v.y += p.g * dt;
|
||
p.p += p.v * dt;
|
||
p.rot += p.vrot * dt;
|
||
Draw(p);
|
||
}
|
||
}
|
||
|
||
/// <summary>불똥 · 반짝이 한 번(타격 점) — 표 줄 하나(s_sprite 첫 그림 = 불똥 · 두 번째 = 반짝 별).</summary>
|
||
void Burst(LobbyScene.Row r, Sprite[] sp, Vector2 at)
|
||
{
|
||
for (int i = 0; i < r.count; i++)
|
||
{
|
||
float ang = (-90f + Random.Range(-1f, 1f) * Mathf.Max(0f, r.waves)) * Mathf.Deg2Rad; // 위로 ± f_waves 도
|
||
float spd = r.speed * Random.Range(0.6f, 1.15f);
|
||
float sz = r.scale * Random.Range(0.75f, 1.2f);
|
||
Emit(sp[0], at, new Vector2(Mathf.Cos(ang), Mathf.Sin(ang)) * spd, r.amp, r.period * Random.Range(0.8f, 1.2f), sz, sz * 0.35f, r.color, 0.02f, r.period * 0.5f);
|
||
}
|
||
if (sp.Length > 1 && r.h > 0f)
|
||
{
|
||
var p = Emit(sp[1], at, Vector2.zero, 0f, Mathf.Max(0.05f, r.hit), r.h * 0.4f, r.h, r.color, 0.02f, Mathf.Max(0.05f, r.hit) * 0.6f);
|
||
if (p != null) p.rot = Random.Range(0f, 45f);
|
||
}
|
||
}
|
||
|
||
// ---------- 매 프레임 ----------
|
||
|
||
void Update()
|
||
{
|
||
if (hub == null) return; // Play 중 재컴파일 = 직렬화 안 된 값이 비면 멈춤
|
||
float now = Time.unscaledTime;
|
||
float dt = Mathf.Min(0.1f, Time.unscaledDeltaTime);
|
||
foreach (var d in duels) UpdateDuel(d, now);
|
||
foreach (var s in shooters) UpdateShooter(s, now);
|
||
foreach (var s in sleepers) UpdateSleeper(s, now);
|
||
foreach (var t in triggers) UpdateTrigger(t);
|
||
UpdateClouds(dt);
|
||
UpdateParticles(dt);
|
||
}
|
||
|
||
static void Set(ActorRef a, Sprite sp, Vector2 pos)
|
||
{
|
||
if (a.img.sprite != sp) a.img.sprite = sp;
|
||
pos = new Vector2(Mathf.Round(pos.x), Mathf.Round(pos.y)); // 정수 px(비정수 계단 방지 · R21 함정)
|
||
if (a.rt.anchoredPosition != pos) a.rt.anchoredPosition = pos;
|
||
}
|
||
|
||
static Sprite IdleFrame(UnitArtData data, Sprite[] idle, float t, ref float nextBlink, ref float blinkEnd)
|
||
{
|
||
int f = data.ApplyBlink(Idle, idle.Length, data.FrameAt(Idle, idle.Length, t), t, ref nextBlink, ref blinkEnd);
|
||
return idle[Mathf.Clamp(f, 0, idle.Length - 1)];
|
||
}
|
||
|
||
static float Smooth(float x)
|
||
{
|
||
x = Mathf.Clamp01(x);
|
||
return x * x * (3f - 2f * x);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 비무대 대련 = 두 사람이 번갈아 공격(표 순서) — 공격 차례: 쉼(둘 다 대기 숨) → 서기(공격 = 자세 · 받는 쪽 = 대기 숨 그대로) → 모으기(뒤로 f_min px) →
|
||
/// 타격(타격 그림 + 상대 쪽으로 f_max px 더 내디딤 · 무기 끝 f_tx,f_ty 에 반짝 + 불똥 · 받는 쪽 발밑 흙먼지 + f_amp px 밀려남) → 유지 → 다음 사람 차례.
|
||
/// </summary>
|
||
void UpdateDuel(Duel d, float now)
|
||
{
|
||
float c0 = d.f[0].Turn, c1 = d.f[1].Turn;
|
||
float local = Mathf.Max(0f, now - d.t0);
|
||
int cyc = Mathf.FloorToInt(local / (c0 + c1));
|
||
float t = local - cyc * (c0 + c1);
|
||
int ai = t < c0 ? 0 : 1;
|
||
if (ai == 1) t -= c0;
|
||
var at = d.f[ai];
|
||
var df = d.f[1 - ai];
|
||
var r = at.row;
|
||
float t1 = r.rest, t2 = t1 + r.stand, t3 = t2 + r.ready, t4 = t3 + r.hit;
|
||
int turn = cyc * 2 + ai;
|
||
// 받는 쪽 = 대기 숨 그대로(막는 자세 그림 = 창을 겨눈 그림이라 「동시 공격」으로 읽힘 · QA r1) + 맞으면 밀림
|
||
Set(df.a, IdleFrame(df.a.data, df.idle, now + df.idleOffset, ref df.nextBlink, ref df.blinkEnd), df.idlePos + Knock(df, now));
|
||
if (t < t1)
|
||
{
|
||
Set(at.a, IdleFrame(at.a.data, at.idle, now + at.idleOffset, ref at.nextBlink, ref at.blinkEnd), at.idlePos);
|
||
return;
|
||
}
|
||
if (t < t3)
|
||
{
|
||
float back = t < t2 ? 0f : r.min * Smooth((t - t2) / Mathf.Max(0.01f, r.ready));
|
||
Set(at.a, at.ready, at.readyPos - new Vector2(at.a.dir * back, 0f));
|
||
return;
|
||
}
|
||
// 타격 = 상대 쪽으로 f_max px 더 내디딤(무기가 상대에 닿게 · QA r1 「칼이 닿지 않은 타격」)
|
||
Set(at.a, at.action, Lunged(at));
|
||
if (turn != d.lastTurn)
|
||
{
|
||
d.lastTurn = turn;
|
||
Clash(at, df, now);
|
||
}
|
||
}
|
||
|
||
static Vector2 Lunged(Fighter f)
|
||
{
|
||
return f.actionPos + new Vector2(f.a.dir * Mathf.Max(0f, f.row.max), 0f);
|
||
}
|
||
|
||
static Vector2 Knock(Fighter f, float now)
|
||
{
|
||
float u = now - f.knockAt;
|
||
if (u < 0f || u > 0.4f || f.knockAmp <= 0f) return Vector2.zero;
|
||
// 0.05 초에 밀려났다가 0.35 초에 걸쳐 제자리(뒤 = 바라보는 반대쪽)
|
||
float e = u < 0.05f ? Smooth(u / 0.05f) : 1f - Smooth((u - 0.05f) / 0.35f);
|
||
return new Vector2(-f.a.dir * f.knockAmp * e, 0f);
|
||
}
|
||
|
||
void Clash(Fighter at, Fighter df, float now)
|
||
{
|
||
df.knockAt = now;
|
||
df.knockAmp = at.row.amp;
|
||
var tip = at.a.At(at.row.tx, at.row.ty, Lunged(at));
|
||
foreach (var r in rows)
|
||
{
|
||
if (r.kind == "clash")
|
||
{
|
||
var sp = Sps(r);
|
||
if (sp.Length > 0) Burst(r, sp, tip);
|
||
}
|
||
else if (r.kind == "clash_dust")
|
||
{
|
||
var sp = Sps(r);
|
||
if (sp.Length == 0) continue;
|
||
var foot = new Vector2(df.idlePos.x - df.a.dir * r.x, -df.idlePos.y + r.y);
|
||
Emit(sp[0], foot, new Vector2(-df.a.dir * r.speed, 0f), 0f, r.period, r.w, r.w * Mathf.Max(1f, r.max), r.color, 0.03f, r.period * 0.7f);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 훈련장 궁병 = 쉼(대기 숨 f_rest) → 겨눔(drill_ready f_stand) → 쏨(drill_action f_hold · 그 순간 화살이 그림 화살 자리에서 과녁으로) — 화살은 f_amp px 포물선 ·
|
||
/// f_period 초에 과녁(f_tx,f_ty) → 촉 쪽 (1 − f_min) 이 박힌 채 f_max 초 꽂혀 흔들리다 사라짐 · 꽂힐 때 표 줄 hit 반짝.
|
||
/// </summary>
|
||
void UpdateShooter(Shooter s, float now)
|
||
{
|
||
var r = s.row;
|
||
float cyc = Mathf.Max(0.2f, r.rest + r.stand + r.hold);
|
||
float local = now - r.phase;
|
||
int n = Mathf.FloorToInt(local / cyc);
|
||
float t = local - n * cyc;
|
||
if (t < r.rest) Set(s.a, IdleFrame(s.a.data, s.idle, now + s.idleOffset, ref s.nextBlink, ref s.blinkEnd), s.a.basePos);
|
||
else if (t < r.rest + r.stand) Set(s.a, s.aim, s.a.basePos);
|
||
else
|
||
{
|
||
Set(s.a, s.loose, s.a.basePos);
|
||
if (n != s.lastCycle)
|
||
{
|
||
s.lastCycle = n;
|
||
s.shotAt = now - (t - r.rest - r.stand);
|
||
s.landed = false;
|
||
}
|
||
}
|
||
if (s.arrow == null) return;
|
||
float fly = Mathf.Max(0.05f, r.period);
|
||
float u = (now - s.shotAt) / fly;
|
||
bool flying = u >= 0f && u < 1f;
|
||
if (s.arrow.enabled != flying) s.arrow.enabled = flying;
|
||
if (flying)
|
||
{
|
||
var d = s.to - s.from;
|
||
var pos = s.from + d * u + new Vector2(0f, -r.amp * 4f * u * (1f - u));
|
||
var tan = d + new Vector2(0f, -r.amp * 4f * (1f - 2f * u));
|
||
var art = s.arrow.rectTransform;
|
||
art.anchoredPosition = new Vector2(pos.x, -pos.y);
|
||
art.localEulerAngles = new Vector3(0f, 0f, Mathf.Atan2(-tan.y, tan.x) * Mathf.Rad2Deg);
|
||
}
|
||
else if (u >= 1f && !s.landed)
|
||
{
|
||
s.landed = true;
|
||
var d = s.to - s.from;
|
||
var tan = d + new Vector2(0f, r.amp * 4f);
|
||
s.stuckRot = Mathf.Atan2(-tan.y, tan.x) * Mathf.Rad2Deg;
|
||
s.stuck.rectTransform.anchoredPosition = new Vector2(s.to.x, -s.to.y);
|
||
foreach (var h in rows)
|
||
{
|
||
if (h.kind != "shoot_hit") continue;
|
||
var sp = Sps(h);
|
||
if (sp.Length > 0) Burst(h, sp, s.to);
|
||
}
|
||
}
|
||
// 꽂힌 화살(흔들림 0.35 초 · f_max 초 뒤 0.3 초에 사라짐)
|
||
float st = now - s.shotAt - fly;
|
||
bool stuck = s.landed && st >= 0f && st < r.max + 0.3f;
|
||
if (s.stuck.enabled != stuck) s.stuck.enabled = stuck;
|
||
if (!stuck) return;
|
||
float wob = st < 0.35f ? 6f * Mathf.Sin(st * 40f) * (1f - st / 0.35f) : 0f;
|
||
s.stuck.rectTransform.localEulerAngles = new Vector3(0f, 0f, s.stuckRot + wob);
|
||
var c = s.stuck.color;
|
||
c.a = st < r.max ? 1f : 1f - (st - r.max) / 0.3f;
|
||
s.stuck.color = c;
|
||
}
|
||
|
||
/// <summary>서서 조는 병사 = 머리 위(그림 px f_x,f_y)에서 z 를 차례로(i_count 개 · 그림 순서 s_sprite · 갈수록 큼) f_gap_min 초 간격 → f_gap_max 쉼 · 위로 f_speed px/초 · 오른쪽 f_w px · 흔들림 f_amp.</summary>
|
||
void UpdateSleeper(Sleeper s, float now)
|
||
{
|
||
if (now < s.next) return;
|
||
var r = s.row;
|
||
int n = Mathf.Max(1, r.count);
|
||
var sp = s.sp[Mathf.Min(s.i, s.sp.Length - 1)];
|
||
float size = r.scale * (1f + 0.3f * s.i);
|
||
float life = Mathf.Max(0.3f, r.period);
|
||
var p = Emit(sp, s.a.At(r.x, r.y), new Vector2(r.w / life, -r.speed), 0f, life, size * 0.7f, size * Mathf.Max(1f, r.max), r.color, 0.2f, life * 0.4f); // 앞 60 % 는 또렷하게(QA r1)
|
||
if (p != null)
|
||
{
|
||
p.sway = r.amp;
|
||
p.rot = Random.Range(-8f, 8f);
|
||
}
|
||
s.i++;
|
||
if (s.i >= n)
|
||
{
|
||
s.i = 0;
|
||
s.next = now + r.gapMax;
|
||
}
|
||
else s.next = now + r.gapMin;
|
||
}
|
||
|
||
/// <summary>원화 프레임 i_n 이 막 보일 때 한 번 — spark = 망치 불똥(Burst) · drop = 건초 한 가닥(확률 f_min · 떨어짐 중력 f_amp).</summary>
|
||
void UpdateTrigger(Trigger t)
|
||
{
|
||
int idx = System.Array.IndexOf(t.frames, t.a.img.sprite);
|
||
if (idx == t.last) return;
|
||
t.last = idx;
|
||
if (idx != t.row.n) return;
|
||
Fired++;
|
||
var r = t.row;
|
||
var at = t.a.At(r.x, r.y);
|
||
if (r.kind == "spark")
|
||
{
|
||
Burst(r, t.sp, at);
|
||
return;
|
||
}
|
||
if (Random.value > r.min) return;
|
||
for (int i = 0; i < Mathf.Max(1, r.count); i++)
|
||
{
|
||
var sp = t.sp[Random.Range(0, t.sp.Length)];
|
||
var p = Emit(sp, at + new Vector2(Random.Range(-3f, 3f), 0f), new Vector2(Random.Range(-1f, 1f) * r.w, r.speed * Random.Range(0.7f, 1.2f)), r.amp, r.period * Random.Range(0.85f, 1.15f), r.scale, r.scale, Color.white, 0.04f, r.period * 0.4f);
|
||
if (p == null) continue;
|
||
p.rot = Random.Range(-40f, 40f);
|
||
p.vrot = Random.Range(-120f, 120f);
|
||
}
|
||
}
|
||
|
||
/// <summary>흘러가는 구름 = f_speed px/초로 오른쪽(음수 = 왼쪽) · 화면 밖으로 나가면 반대쪽에서 다시 · 그림자 = (f_tx, f_ty) 만큼 어긋난 땅 그림자(알파 f_shade).</summary>
|
||
void UpdateClouds(float dt)
|
||
{
|
||
foreach (var c in cloudList)
|
||
{
|
||
var r = c.row;
|
||
c.x += r.speed * dt;
|
||
if (r.speed >= 0f && c.x > canvas.x + c.w * 0.5f + Mathf.Abs(r.tx)) c.x = -c.w * 0.5f - Mathf.Abs(r.tx);
|
||
if (r.speed < 0f && c.x < -c.w * 0.5f - Mathf.Abs(r.tx)) c.x = canvas.x + c.w * 0.5f + Mathf.Abs(r.tx);
|
||
if (c.wisp != null) c.wisp.anchoredPosition = new Vector2(c.x, -r.y);
|
||
if (c.shadow != null) c.shadow.anchoredPosition = new Vector2(c.x + r.tx, -(r.y + r.ty));
|
||
}
|
||
}
|
||
}
|
||
}
|