ThreeKingdomsSlingshot/Assets/Scripts/Runtime/Skills/SkillVfx.cs

1850 lines
117 KiB
C#
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using UnityEngine;
namespace TKS
{
/// <summary>
/// 스킬 이펙트(VFX) 재생 — WL 방식(2026-11-09 PD 「WL 에서 스킬을 구현하던 방식과 동일하게 유닛별 스킬 구현」):
/// 값 = 표 <c>Resources/Skills/skill_vfx.csv</c>(코드 상수 없음 · C45) · 이펙트 = 팩 프리팹의 사본 <c>Resources/Fx/TKS_Fx_*.prefab</c>
/// (원본 팩 <c>Assets/VFX/**</c> 는 고치지 않는다 · WL 의 <c>WL_Fx_*</c> 사본과 같은 규칙).
/// 키 = 스킬 id(skills.csv · 액티브) 또는 basic_&lt;병종&gt;(일반 슬링샷 공격 · 이동만인 추가 이동 제외).
/// 이벤트 = cast(액티브 발동 · 예약 스킬은 슬링샷 출발 순간 · 즉시형은 버튼) · travel(슬링샷 돌진 동안 · 따라가거나 f_every 마다 다시 띄움 · 끝나면 방출 멈춤) ·
/// hit(행동 중인 유닛이 상대에게 피해를 준 순간 · 대상마다 1번).
/// 표 다시 읽기 = 전투 시작마다(스킬 테스트 씬 「다시 배치」) · <see cref="Reload"/>.
/// 가상 실행(Sim.Active · 적 AI 예측) 중에는 아무것도 띄우지 않는다.
/// </summary>
public static class SkillVfx
{
public const string TablePath = "Skills/skill_vfx";
public const string FxFolder = "Fx/";
public const string EventCast = "cast";
public const string EventTravel = "travel";
public const string EventHit = "hit";
/// <summary>
/// 돌진이 적에게 닿기 직전(대상마다 · 앵커 기본 target · 방향 = 시전자 → 대상) — 이 행의 f_delay = 닿는 순간보다 몇 초 앞에 띄울지(빈칸 = 닿는 순간 ·
/// 접근이 그보다 짧으면 바로). 보병 돌진 첫 충돌 · 튕김 연쇄 충돌(ActionResolver.PreHit · PD 2026-11-12 주창 「적과 닿기 직전 적에게 베기」).
/// </summary>
public const string EventPreHit = "prehit";
// 2026-11-10 연출 2차(새 기획 #1112 스킬 72 · PD 「재정리부터 시작」): 투사체 · 폭발 · 지대 · 지속 기운 · 상태 이상 · 회복
/// <summary>특수·일반 사격의 투사체(시전자 → 도착점 · 비행 시간 = Fx.ArrowDuration · 피해 시점 그대로) — 행이 없으면 기존 선 화살.</summary>
public const string EventShot = "shot";
/// <summary>광역 중심(즉시 광역 · 폭발 사격 · 목책 칸) — 크기 단위 = 그 광역 반경(f_scale 1 = 반경).</summary>
public const string EventBlast = "blast";
/// <summary>투사체가 끝난 자리(명중 대상 또는 최대 사정거리 도달 위치) 1번 · 행 = Blast 와 같은 방식(크기 = 광역 반경 × f_scale) · PD 2026-11-13 손건 「하트는 피격 대상이나 최대 사정거리 도달 위치에」.</summary>
public const string EventLand = "land";
/// <summary>즉시형 스킬의 범위 시한 효과(버프)를 받은 대상마다 시전 순간 1번(미축 행진가 · PD 2026-11-13 「효과 범위 내 모든 아군에게 발생」).</summary>
public const string EventBuff = "buff";
/// <summary>스킬 지대(불꽃 · 불 장벽 · 독지대)가 남아 있는 동안 반복 — 크기 단위 = 지대 반경 · 선분 지대는 f_every(반경 배수 · 빈칸 1.6) 간격으로 여러 개.</summary>
public const string EventZone = "zone";
/// <summary>그 스킬 효과가 유닛에 남아 있는 동안 반복(예약 대기 · 시한 효과 대상 · SkillVfxLoops).</summary>
public const string EventAura = "aura";
/// <summary>상태 이상이 걸려 있는 동안 반복(키 status_stun · status_confuse · status_bleed · status_poison · status_burn · SkillVfxLoops).</summary>
public const string EventStatus = "status";
/// <summary>회복 받은 순간(키 common · 모든 회복 공통).</summary>
public const string EventHeal = "heal";
/// <summary>그 스킬로 재행동 기회가 생긴 순간 1번(유비 이도류 검법 등 · SkillSystem.EndAction · PD 2026-11-10).</summary>
public const string EventReact = "react";
/// <summary>
/// 실제 이동을 시작한 자리 1번(depart) · 이동이 끝난 자리 1번(arrive) — 돌진하지 않는 궁병의 이동(ActionResolver.ArcherRoutine ·
/// PD 2026-11-11 「황충 이동 시 최초 이동 때와 도착할 때 먼지 연출」) · 제자리 사격에는 나오지 않는다.
/// </summary>
/// <summary>
/// 효과 대상마다 그 자리에 내려오는 연출(drop) — 즉시형 회복이 대상에게 닿기 전(PD 2026-11-11 제갈량 「스킬 범위 내 유닛에게 빛 덩어리가 내려와 퍼지는 연출과 함께 … 회복」):
/// 행의 f_delay 뒤에 시작 · f_wait(초) = 효과(회복)를 적용할 시점 — <see cref="Drop"/> 가 가장 긴 f_wait 를 돌려주고 스킬 쪽이 그만큼 기다린 뒤 회복한다.
/// </summary>
public const string EventDrop = "drop";
/// <summary>
/// 레이저(beam · shot_laser · 2026-11-12 PD 태사자): 쏜 유닛 자리에서 조준 방향으로 눕혀 띄움(프리팹 위 +Y = 진행 방향 · 원점 = 쏜 자리) ·
/// 크기 = 역순 줄(b_rev · 빛 기둥) f_scale × 레이저 길이 · 나머지 줄(쏜 자리 섬광·연기) f_scale × 유닛 키 · f_wait = 띄운 뒤 피해를 주는 시점(가장 긴 값) — <see cref="Beam"/>.
/// </summary>
public const string EventBeam = "beam";
public const string EventDepart = "depart";
public const string EventArrive = "arrive";
/// <summary>장수 전용 일반 행동 키(hero_&lt;장수 id&gt;) — 스킬을 장착하지 않은 슬링샷에서 basic_병종 행에 더해짐(기본 공격 화살 · 이동 먼지).</summary>
public static string HeroKey(string heroId)
{
return string.IsNullOrEmpty(heroId) ? null : "hero_" + heroId.ToLowerInvariant();
}
public const string CommonKey = "common";
/// <summary>
/// 시험 키(스킬 테스트 씬 「기운 시험」 스위치 · PD 2026-11-10 「몸을 뒤덮는 연출을 스킬용으로 시험」): 비어 있지 않으면 슬링샷 공격 돌진(travel) 때
/// 이 키의 행(표 test_aura 등)을 함께 띄운다 · 실제 전투는 늘 빈칸.
/// </summary>
public static string TestTravelKey = "";
/// <summary>정렬 순서 기준(화살 8 · 광역 7 · 스킬 이름 글자 21 · 유닛 0 위) — 행 n_order 를 더한다.</summary>
public const int SortingBase = 12;
public class Row
{
/// <summary>키 원문(s_skill · ; 로 여러 개 = 그중 하나와 같으면 해당).</summary>
public string skill = "";
public string[] keys = new string[0];
/// <summary>진영(s_camp · shu · wei · wu · other) — 빈칸 = 모든 진영 · 유닛 진영이 빈칸(적 병사 등)이면 other 로 본다.</summary>
public string camp = "";
public bool HasKey(string key)
{
for (int i = 0; i < keys.Length; i++)
if (keys[i] == key) return true;
return false;
}
public string evt = "";
public string fx = "";
/// <summary>feet(발) · body(몸 가운데) · head(머리 끝) · target(피격 대상 몸 가운데 · hit 기본).</summary>
public string anchor = "";
/// <summary>유닛 머리 끝 높이(ArtHeight) 대비 크기 — 1 = 팩 원본 1 단위를 유닛 키로.</summary>
public float scale = 1f;
public float delay;
/// <summary>0 = 입자가 다 사라질 때까지(최대 MaxAutoLife).</summary>
public float life;
/// <summary>기울기(°) · 0 = 옆에서 본 모습 · −90 = 위에서 내려다본 모습(바닥 원·충격파) · face 행은 진행 축을 중심으로 카메라 쪽으로 기울임(<see cref="FxRotation"/>).</summary>
public float tilt;
/// <summary>true = 이펙트 정면(+Z)을 진행 방향(cast·travel = 슬링샷 방향 · hit = 때린 쪽 → 대상)으로 화면 안에서 돌림(투사체·베기·돌진).</summary>
public bool face;
/// <summary>travel 전용 · WL sustain = 시간당 방출 층(버스트 없는 층)을 반복으로 바꿔 돌진 내내 유지(버스트 층은 처음 1번).</summary>
public bool sustain;
/// <summary>travel 전용 · WL ClearEnd = 돌진이 끝나는 순간 남은 입자까지 지움(0 = 방출만 멈추고 남은 입자는 수명대로).</summary>
public bool clear;
/// <summary>입자 자체 이동 배율(시작 속도 · 속도 모듈) — 1 = 팩 원본 · 0.1 = 거의 제자리(스스로 앞으로 날아가는 데모용 돌진 이펙트를 유닛에 붙여 감싸게 · MasterStylizedFX Dash).</summary>
public float drift = 1f;
/// <summary>진행 방향 기준 위치 보정(유닛 키 배수 · + 앞 · − 뒤) — 예: 돌진 잔상(Dash)을 캐릭터 뒤쪽에(f_fwd).</summary>
public float fwd;
/// <summary>travel 전용 · 슬링샷 이동이 끝날 때 그 자리에서 이 초 동안 흐려지며 사라짐(f_fade · 0 = b_clear/방출만 멈춤 규칙 · b_clear 보다 우선).</summary>
public float fade;
/// <summary>유닛 위에 그릴 자식 층 이름(s_over · ; 로 여러 개) — 나머지 층은 n_order 그대로(이중 레이어 · 예: 혜성 머리 실드만 캐릭터 앞 · PD 2026-11-10).</summary>
public string[] over = new string[0];
/// <summary>
/// 끌 자식 층 이름(s_off · ; 로 여러 개 · 끝에 * = 그 글자로 시작하는 층 전부 · @root = 뿌리 층) — 그 층만 방출·그리기를 끔(다른 층은 그대로 · 사본·팩 원본 무수정).
/// PD 2026-11-11 「스킬 공격에 피격 시 먼지 발생되는 이펙트는 제거」 = hit·blast 행의 먼지·연기 층(dust* · smoke* · clouds).
/// </summary>
public string[] off = new string[0];
/// <summary>
/// 몸 감싸기 층(s_wrap · ; 로 여러 개 · 반복 기운 전용 · PD 2026-11-11 「캐릭터 주위를 확실히 휘감는 느낌 · 금줄이 화려하게 유닛을 감싸는 형태」):
/// 팩의 고리·줄기 메시 층을 같은 씨앗의 두 벌로 나눠 카메라에 가까운 반 = 유닛 위 층 · 먼 반 = 유닛 아래 층(n_order) — 줄기가 몸 앞을 지나 뒤로 돌아감
/// (자르는 경계선 없음 · 셰이더 TKS/FxPackHalf 의 면 고르기). f_wrap(사각 마스크로 위아래를 나누던 옛 방식)과 다름.
/// </summary>
public string[] wrapLayers = new string[0];
/// <summary>감싸기 층의 방출 배수(s_wrap 에 「층 이름*배수」 · 빈칸 1) — 금줄을 더 촘촘히(두 벌에 똑같이 적용).</summary>
public float[] wrapRate = new float[0];
/// <summary>층별 방출 배수(s_rate · 「층 이름*배수」 · @root = 뿌리 층 · 반복 이펙트 전용 · 감싸기와 무관).</summary>
public string[] rateLayers = new string[0];
public float[] rateMult = new float[0];
/// <summary>
/// 3단 색 입히기(s_ramp = #테;#몸;#심;불투명도 배수;감싸기 밖 층의 심 시작(0~1 · 빈칸 0.5 · 클수록 몸 색이 넓음);모양 가장자리 테 굵기(픽셀 · 빈칸 0 = 없음);모양 시트 방식의 심 깊이(픽셀);
/// 1 = 메시 아닌 띠·판 층도;팩의 새까만 층에 칠할 색(#RRGGBB · 빈칸 = 먹색 — PD 2026-11-11 「검은색 이펙트가 너무 튀기 때문에 다른 이펙트와 어울리는 색으로」) · PD 2026-11-11 「이전 이펙트를 지금과 같은 색감(금색)으로」): 팩 메시 층(고리·줄기 · HCFX apb 재질)의 색을
/// 그림의 가장자리 → 가운데 순으로 테 → 몸 → 심 색으로 칠함(원본의 밝기 3배·둘째 색 대신 = 희게 날아가지 않는 금색) · 불투명도 배수 = 팩 메시 층 전부
/// (PD 2026-11-11 「금줄에 맞게 캐릭터 주위 이펙트를 바꾸라고」 = 옅은 줄기·바닥 고리도 금줄과 같은 테·색·또렷함).
/// 열다섯째 값 = 밝기 방식(Eric 팩) 모양 문턱(0~1 · 빈칸 = 기본 0.12~0.34) — 고리 안쪽 번짐은 버리고 선만 또렷하게(2026-11-12 관평 진).
/// </summary>
public string[] ramp;
/// <summary>
/// 2D 평면 이펙트(b_flat · PD 2026-11-10 「돌진 이펙트가 너무 3D 느낌 → 2D 처럼」): 진행 방향으로 화면 안에서만 돌림(Z 축) · f_tilt 와 팩 루트 회전 무시 ·
/// 프리팹은 화면 평면에 그린 셀 그림(정면 = +X · Assets/VFX/TKS2D).
/// </summary>
public bool flat;
/// <summary>반복(aura·status·zone) 때 모든 층을 반복(b_loopall 1) — 빈칸 = 원래 반복인 층만 남기고 한 번 터지는 층은 끔(큰 섬광 방지).</summary>
public bool loopAll;
/// <summary>
/// 몸 감싸기(f_wrap · 반복 기운 전용 · PD 2026-11-11 「상반신은 이펙트보다 위 · 하반신은 아래 · 몸 주위를 둘러싼 느낌」): 0 보다 크면 같은 씨앗의 두 벌을 띄워
/// 발 ~ 발 + 키 × f_wrap(하반신) 안은 캐릭터 앞 · 그 위(상반신)는 캐릭터 뒤 — 사각 SpriteMask 로 나눔 · 0 = 한 벌(n_order 그대로).
/// </summary>
/// s_wrap(팩 층 면 나누기)과 함께 쓰면 뜻이 바뀜: 그림 발에서 키 × f_wrap 높이까지만 줄기가 몸 앞으로 지나가고 그 위(얼굴)는 머리 뒤로 지나감(마스크 없음 · 부드럽게 넘어감).
public float wrap;
/// <summary>
/// 화풍 층(b_cel 1 · PD 2026-11-11 「게임 화풍을 고려해 색감·질감·라이팅 조정」): 이 행의 이펙트를 <see cref="FxStyleLayer"/> 로 그린다
/// (면 2~4단 · 무광 색 · 먹선 외곽선 · 값 = fx_style.csv) · 빈칸 = 팩 원본 그대로.
/// </summary>
public bool cel;
/// <summary>투사체 비행 속도 배수(f_fly · shot 행 · 빈칸 1 · 여러 행이면 가장 큰 값) — 비행 시간 = 기본 시간 ÷ 배수(피해 시점도 그만큼 빨라짐).</summary>
public float fly = 1f;
/// <summary>효과 적용까지 기다리는 시간(f_wait · 초 · drop 행 · 빈칸 0).</summary>
public float wait;
/// <summary>레이저(beam) 역순(b_rev · 2026-11-12 PD 태사자 「내려치는 형태가 아니라 역순 = 태사자에게서 발사」): 원점을 먼 끝에 두고 뒤집어 놓음 — 먼 끝에서 쏜 자리로 내려치는 빛 기둥이 쏜 자리에서 먼 끝으로 뻗어 나감.</summary>
public bool rev;
/// <summary>
/// 바닥 충돌 판(b_ground · 2026-11-13 PD 주유 「명중 시 넓은 범위에 운석이 여러 개 떨어지며」): 팩 이펙트 중 「떨어진 입자가 바닥(3D 콜라이더)에 닿으면 터지는」 것은
/// 이 게임(2D · 바닥 콜라이더 없음)에서 입자가 그대로 지나가 충돌 이펙트가 안 나옴 → 이펙트 원점의 바닥면(이펙트의 XZ 면)을 충돌 판으로 넣는다(Hyper Casual Vol.2 HCFX_Meteor_*).
/// </summary>
public bool ground;
/// <summary>유닛 제자리 한 바퀴(f_turn · 초 · 2026-11-13 PD 21차 손상향 「이펙트와 함께 유닛을 한바퀴 회전」): 이 행이 나오는 순간 그 유닛 그림이 이 시간 동안 한 바퀴 돈다(UnitView.SpinOnce · 0 = 없음).</summary>
public float turn;
/// <summary>레이저(beam) 빛 기둥 굵기 배수(f_wide · 늘인 판 층의 가로 크기 · 길이는 그대로 · 2026-11-12 PD 태사자 「너무 직선 형태의 선 같아」).</summary>
public float wide = 1f;
/// <summary>까딱임(s_wobble 「각도*주기」 · 반복 이펙트의 입자를 좌우로 각도만큼 기울였다 돌아옴 · 빈칸 = 없음 · PD 2026-11-13 혼란 물음표).</summary>
public float wobbleDeg, wobbleSec = 1f;
/// <summary>화풍 층 변형 이름(s_style · b_cel 1 인 유닛 아래 이펙트 전용 · fx_style.csv 의 「키@변형」 값을 씀 · 빈칸 = 기본 값).</summary>
public string style = "";
/// <summary>
/// 쓴 유닛 올리기(b_lift 1 · PD 2026-11-11 「공격 이펙트는 몬스터보다 상단에 배치」): 이 이펙트를 다른 유닛 위(n_order −2 이하)에 그리고
/// 이펙트가 살아 있는 동안 쓴 유닛의 그림만 그 위로 올린다(<see cref="FxOwnerLift"/>) — 적은 덮되 쓴 캐릭터는 가리지 않게.
/// </summary>
public bool lift;
/// <summary>
/// 원본 세기 배수(f_alpha · 입자 시작 색 불투명도 · 빈칸 1) — 낮추면 옅어짐 · 화풍 층에서는 몸(단색 면) 대신 옅은 테로 그려짐
/// (유닛을 가리는 빛 기둥·막을 반투명하게).
/// </summary>
public float alpha = 1f;
/// <summary>
/// 색 바꾸기(s_hue · #RRGGBB 로 물들임: 색상 = 그 색 · 채도·밝기 = 원본 × 그 색의 채도·밝기 → 원본이 순색이면 딱 그 색 ·
/// 무채색(흰 심·연기 · 채도 0.12 미만)은 그대로) — 진영색·스킬 컨셉 색 · 띄운 것에만 적용(사본·팩 원본 무수정).
/// </summary>
public string hue = "";
/// <summary>바꾼 색의 채도 배수(f_sat · 빈칸 1 · s_hue 가 있을 때만).</summary>
public float sat = 1f;
/// <summary>1 = 유닛을 따라다님 · 0 = 생긴 자리에 남음 · −1(빈칸) = 기본(travel 따라감 · 그 밖 남음).</summary>
public int follow = -1;
public float speed = 1f;
/// <summary>세로 높이 배율(f_height · 빈칸 1 · PD 2026-11-11 「재행동 이펙트가 캐릭터 키보다 너무 높게 재생 → 키 높이에 맞게」): 위로 오르는 시작 속도 × k ·
/// 세워 놓은 메시 층(3D 크기)의 길이(Z) × k · 세로로 긴 빛(3D 크기 빌보드)의 세로(Y) × k — 고리가 오르는 높이와 빛기둥·뒷빛 키만 줄이고 가로 크기는 그대로.</summary>
public float height = 1f;
/// <summary>높이 자르기 배율(f_top · 빈칸 1 · PD 2026-11-11 「재행동 이펙트 높이가 낮아지면서 나선형 간격이 너무 좁아짐 → 간격을 높이 조절 전처럼」):
/// 위로 오르는 입자의 수명 × k = 원래 속도·간격 그대로 오르다 그 높이에서 사라짐(f_height 는 속도를 줄여 간격까지 같이 좁아짐) ·
/// 세운 메시 층 길이(Z)·세로로 긴 빛(Y) × k 는 f_height 와 같음.</summary>
public float top = 1f;
/// <summary>떨어지는 움직임 끔(b_nofall · PD 2026-11-11 「출혈 — 기존 프레임을 삭제하라는 지시가 아니라 낙하하는 이펙트만 제거」): 층은 그대로 두고
/// 중력 0 · 아래로 가는 속도(수명 속도·힘의 Y 음수)만 0 — 튀어 오른 그림이 떨어지지 않고 제자리에서 녹아 사라짐.</summary>
public bool noFall;
/// <summary>방사 범위(s_radial = 「시작;끝」 · 광역(blast) 행 전용 · 스킬 반경 배수 · PD 2026-11-11 「방사형 이펙트는 캐릭터를 중심으로 스킬 범위까지만 · 가장자리로 갈수록 점차 투명」):
/// 중심에서 반경 × 시작부터 옅어져 반경 × 끝에서 완전히 투명 — 재질을 TKS/FxPackHalf 로 바꿔 그림(지원 재질만).</summary>
public Vector2 radial;
public bool hasRadial;
/// <summary>끝날 때까지 남길 층(s_hold · ; 여러 개 · 반복 이펙트 전용 · PD 2026-11-11 「기절 = 머리 위 별이 효과 지속시간 동안 계속 표시」): 한 번 내는 입자(큰 별 3개)를
/// 수명이 다해도 사라지지 않게 유지 — 반복 규칙이 「한 번 터지는 층」으로 보고 끄던 층을 살린다(끝 = f_fade 로 흐려짐).</summary>
public string[] hold = new string[0];
public float dx;
public float dy;
public int order;
/// <summary>travel 전용: 0 보다 크면 돌진하는 동안 이 간격(초)마다 다시 띄움(WL 창 돌진 감싸기 0.3 · 흙먼지 0.15).</summary>
public float every;
}
/// <summary>travel 이펙트 묶음(행동 끝에 Stop) — 따라다니는 것만 담는다(남는 것은 제 수명대로).</summary>
public class Handle
{
public readonly List<GameObject> Objects = new List<GameObject>();
/// <summary>Stop 때 남은 입자까지 지울 것(b_clear).</summary>
public readonly HashSet<GameObject> ClearOnStop = new HashSet<GameObject>();
/// <summary>Stop 때 그 자리에서 흐려지며 사라질 것(f_fade 초).</summary>
public readonly Dictionary<GameObject, float> FadeOnStop = new Dictionary<GameObject, float>();
public bool Stopped;
}
/// <summary>life 0 일 때 입자 길이 상한(초) — 루프 입자가 끝없이 남지 않게.</summary>
public const float MaxAutoLife = 6f;
static List<Row> rows;
static readonly Dictionary<string, GameObject> prefabCache = new Dictionary<string, GameObject>();
public static void Reload()
{
rows = null;
prefabCache.Clear();
FxStyleLayer.Reload();
SkillVfxLoops.Ensure();
}
public static IReadOnlyList<Row> Rows
{
get
{
Ensure();
return rows;
}
}
static void Ensure()
{
if (rows != null) return;
rows = new List<Row>();
var ta = Resources.Load<TextAsset>(TablePath);
if (ta == null) return;
var lines = ta.text.Replace("\r", "").Split('\n');
string[] head = null;
foreach (var raw in lines)
{
var line = raw.TrimStart('');
if (line.Trim().Length == 0 || line.TrimStart().StartsWith("#")) continue;
var cells = SplitCsv(line);
if (head == null)
{
head = cells;
continue;
}
var r = new Row();
for (int i = 0; i < head.Length && i < cells.Length; i++)
{
string k = head[i].Trim(), v = cells[i].Trim();
if (v.Length == 0) continue;
switch (k)
{
case "s_skill":
r.skill = v;
r.keys = v.Split(';');
for (int j = 0; j < r.keys.Length; j++) r.keys[j] = r.keys[j].Trim();
break;
case "s_camp": r.camp = v.ToLowerInvariant(); break;
case "e_event": r.evt = v.ToLowerInvariant(); break;
case "s_fx": r.fx = v; break;
case "e_anchor": r.anchor = v.ToLowerInvariant(); break;
case "f_scale": r.scale = F(v, 1f); break;
case "f_delay": r.delay = F(v, 0f); break;
case "f_life": r.life = F(v, 0f); break;
case "f_tilt": r.tilt = F(v, 0f); break;
case "b_face": r.face = v == "1" || v.ToLowerInvariant() == "true"; break;
case "b_follow": r.follow = v == "1" || v.ToLowerInvariant() == "true" ? 1 : 0; break;
case "f_speed": r.speed = F(v, 1f); break;
case "f_dx": r.dx = F(v, 0f); break;
case "f_dy": r.dy = F(v, 0f); break;
case "n_order": int.TryParse(v, out r.order); break;
case "f_every": r.every = F(v, 0f); break;
case "b_sustain": r.sustain = v == "1" || v.ToLowerInvariant() == "true"; break;
case "b_clear": r.clear = v == "1" || v.ToLowerInvariant() == "true"; break;
case "f_drift": r.drift = F(v, 1f); break;
case "f_height": r.height = F(v, 1f); break;
case "f_top": r.top = F(v, 1f); break;
case "b_nofall": r.noFall = v == "1" || v.ToLowerInvariant() == "true"; break;
case "s_radial":
{
var rr = v.Split(';');
if (rr.Length >= 2) r.radial = new Vector2(F(rr[0], 0f), F(rr[1], 1f));
r.hasRadial = rr.Length >= 2;
break;
}
case "s_hold":
r.hold = v.Split(';');
for (int j = 0; j < r.hold.Length; j++) r.hold[j] = r.hold[j].Trim();
break;
case "f_fwd": r.fwd = F(v, 0f); break;
case "f_fade": r.fade = F(v, 0f); break;
case "s_over":
r.over = v.Split(';');
for (int j = 0; j < r.over.Length; j++) r.over[j] = r.over[j].Trim();
break;
case "s_off":
r.off = v.Split(';');
for (int j = 0; j < r.off.Length; j++) r.off[j] = r.off[j].Trim();
break;
case "s_wrap":
r.wrapLayers = v.Split(';');
r.wrapRate = new float[r.wrapLayers.Length];
for (int j = 0; j < r.wrapLayers.Length; j++)
{
var nm = r.wrapLayers[j].Split('*');
r.wrapLayers[j] = nm[0].Trim();
r.wrapRate[j] = nm.Length > 1 ? F(nm[1], 1f) : 1f;
}
break;
case "s_rate":
r.rateLayers = v.Split(';');
r.rateMult = new float[r.rateLayers.Length];
for (int j = 0; j < r.rateLayers.Length; j++)
{
var nm = r.rateLayers[j].Split('*');
r.rateLayers[j] = nm[0].Trim();
r.rateMult[j] = nm.Length > 1 ? F(nm[1], 1f) : 1f;
}
break;
case "s_ramp":
r.ramp = v.Split(';');
for (int j = 0; j < r.ramp.Length; j++) r.ramp[j] = r.ramp[j].Trim();
if (r.ramp.Length < 3) r.ramp = null;
break;
case "b_flat": r.flat = v == "1" || v.ToLowerInvariant() == "true"; break;
case "b_loopall": r.loopAll = v == "1" || v.ToLowerInvariant() == "true"; break;
case "f_wrap": r.wrap = F(v, 0f); break;
case "b_cel": r.cel = v == "1" || v.ToLowerInvariant() == "true"; break;
case "f_fly": r.fly = F(v, 1f); break;
case "f_wait": r.wait = F(v, 0f); break;
case "b_rev": r.rev = v == "1" || v.ToLowerInvariant() == "true"; break;
case "b_ground": r.ground = v == "1" || v.ToLowerInvariant() == "true"; break;
case "f_turn": r.turn = F(v, 0f); break;
case "f_wide": r.wide = F(v, 1f); break;
case "s_wobble":
{
var wp = v.Split('*');
r.wobbleDeg = F(wp[0], 0f);
if (wp.Length > 1) r.wobbleSec = F(wp[1], 1f);
break;
}
case "s_style": r.style = v; break;
case "b_lift": r.lift = v == "1" || v.ToLowerInvariant() == "true"; break;
case "f_alpha": r.alpha = F(v, 1f); break;
case "s_hue": r.hue = v; break;
case "f_sat": r.sat = F(v, 1f); break;
}
}
if (r.skill.Length > 0 && r.evt.Length > 0 && r.fx.Length > 0) rows.Add(r);
}
}
static float F(string v, float def)
{
float f;
return float.TryParse(v, NumberStyles.Float, CultureInfo.InvariantCulture, out f) ? f : def;
}
/// <summary>따옴표를 아는 CSV 한 줄 나누기(스킬 테스트 씬 표도 사용).</summary>
public static string[] SplitCsv(string line)
{
var res = new List<string>();
var sb = new System.Text.StringBuilder();
bool q = false;
for (int i = 0; i < line.Length; i++)
{
char c = line[i];
if (q)
{
if (c == '"' && i + 1 < line.Length && line[i + 1] == '"')
{
sb.Append('"');
i++;
}
else if (c == '"') q = false;
else sb.Append(c);
}
else if (c == '"') q = true;
else if (c == ',')
{
res.Add(sb.ToString());
sb.Length = 0;
}
else sb.Append(c);
}
res.Add(sb.ToString());
return res.ToArray();
}
public static bool Has(string skillId, string evt)
{
if (string.IsNullOrEmpty(skillId)) return false;
Ensure();
foreach (var r in rows)
if (r.evt == evt && r.HasKey(skillId)) return true;
return false;
}
public static GameObject LoadFx(string name)
{
GameObject p;
if (prefabCache.TryGetValue(name, out p) && p != null) return p;
p = Resources.Load<GameObject>(FxFolder + name);
if (p == null) Debug.LogWarning("[TKS] 스킬 이펙트 사본 없음: Resources/" + FxFolder + name + " (skill_vfx.csv s_fx)");
prefabCache[name] = p;
return p;
}
/// <summary>
/// 표의 (키, 이벤트) 행을 모두 띄운다. 키 = 스킬 id(skills.csv) 또는 basic_&lt;병종&gt;(일반 슬링샷 공격 · infantry · spear · cavalry · archer · strategist).
/// dir = 진행 방향(face) · target = hit 대상. 반환 = travel 정지용 묶음(지연·반복 행은 나중에 생김).
/// </summary>
public static Handle Play(Unit u, string key, string evt, Vector2 dir, Unit target = null)
{
var h = new Handle();
if (Sim.Active || u == null || string.IsNullOrEmpty(key)) return h;
Ensure();
string camp = string.IsNullOrEmpty(u.Camp) ? "other" : u.Camp.ToLowerInvariant();
foreach (var r in rows)
{
if (r.evt != evt || !r.HasKey(key)) continue;
if (r.camp.Length > 0 && r.camp != camp) continue; // 진영별 행(s_camp)
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
if (r.delay > 0f || (evt == EventTravel && r.every > 0f)) Fx.Run(Timed(r, prefab, u, dir, target, evt, h));
else Spawn(r, prefab, u, dir, target, evt, h);
}
return h;
}
/// <summary>닿기 직전 행(prehit)을 띄운다 — eta = 지금부터 target 에 닿기까지 남은 초 · 행마다 (eta − f_delay) 초 뒤(음수면 바로).</summary>
public static void PlayAhead(Unit u, string key, Vector2 dir, Unit target, float eta)
{
if (Sim.Active || u == null || target == null || string.IsNullOrEmpty(key)) return;
Ensure();
string camp = CampOf(u);
foreach (var r in rows)
{
if (!Match(r, key, EventPreHit, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
float wait = eta - r.delay;
if (wait > 0f) Fx.Run(Ahead(r, prefab, u, dir, target, wait));
else Spawn(r, prefab, u, dir, target, EventPreHit, new Handle());
}
}
static IEnumerator Ahead(Row r, GameObject prefab, Unit u, Vector2 dir, Unit target, float wait)
{
yield return Fx.Wait(wait);
if (u == null || target == null) yield break;
Spawn(r, prefab, u, dir, target, EventPreHit, new Handle());
}
static string CampOf(Unit u)
{
return string.IsNullOrEmpty(u.Camp) ? "other" : u.Camp.ToLowerInvariant();
}
static bool Match(Row r, string key, string evt, string camp)
{
return r.evt == evt && r.HasKey(key) && (r.camp.Length == 0 || r.camp == camp);
}
static float UnitH(Unit u)
{
return u.ArtHeight > 0f ? u.ArtHeight : u.Radius * 2f;
}
/// <summary>지금 행동 중인 유닛의 표 키(예약·시전 스킬 id · basic_병종) — 행동 중이 아니면 null.</summary>
static List<string> KeysOf(Unit u)
{
var sys = SkillSystem.Current;
return sys != null ? sys.VfxKeysOf(u) : null;
}
/// <summary>점 위치에 행 1개(투사체·폭발·지대 공용 · 이중 레이어 s_over 반영).</summary>
static GameObject SpawnPoint(Row r, GameObject prefab, Vector2 pos, float worldScale, Vector2? face, Transform parent)
{
var go = SpawnPrefab(prefab, pos, worldScale, r.tilt, r.face ? face : null, SortingBase + r.order, r.speed, parent, r.flat);
if (r.over.Length > 0)
foreach (var rd in go.GetComponentsInChildren<Renderer>(true))
if (System.Array.IndexOf(r.over, rd.gameObject.name) >= 0) rd.sortingOrder = SortingBase;
if (Mathf.Abs(r.drift - 1f) > 1e-3f) ScaleSelfMotion(go, r.drift);
if (Mathf.Abs(r.height - 1f) > 1e-3f) ScaleHeight(go, r.height, false);
if (Mathf.Abs(r.top - 1f) > 1e-3f) ScaleHeight(go, r.top, true);
if (r.noFall) NoFall(go);
if (r.ground) GroundPlane(go);
TurnOff(go, r.off);
Recolor(go, r);
if ((r.ramp != null || r.hasRadial) && r.wrapLayers.Length == 0) WrapAndRamp(go, r, float.MaxValue, 0f); // 감싸기 없는 행(시전·광역 등 한 번 재생 포함) = 색·테두리·방사 범위만
if (r.cel) FxStyleLayer.Register(go);
return go;
}
/// <summary>표 s_off 에 적힌 자식 층을 끈다(방출·그리기만 · 그 아래 층은 그대로) — 이름이 같거나, 끝이 * 이면 그 글자로 시작하는 층.</summary>
static void TurnOff(GameObject go, string[] off)
{
if (off == null || off.Length == 0) return;
foreach (var t in go.GetComponentsInChildren<Transform>(true))
{
bool hit = false;
foreach (var o in off)
{
if (o.Length == 0) continue;
if (o == "@root") hit |= t == go.transform;
else if (o[o.Length - 1] == '*' ? t.name.StartsWith(o.Substring(0, o.Length - 1), System.StringComparison.OrdinalIgnoreCase)
: string.Equals(t.name, o, System.StringComparison.OrdinalIgnoreCase)) hit = true;
}
if (!hit) continue;
var ps = t.GetComponent<ParticleSystem>();
if (ps != null)
{
var em = ps.emission;
em.enabled = false;
ps.Clear(false);
}
var rd = t.GetComponent<Renderer>();
if (rd != null) rd.enabled = false;
}
}
/// <summary>
/// 남아 있는 동안 반복(지대 · 기운 · 상태 이상): 원래 반복인 층이 있으면 그 층만 남기고 한 번만 터지는 층(시작 섬광 · 큰 빛기둥)은 끈다
/// (2026-11-10 실측: 가속 오라의 섬광 층 glow·area 를 반복시키면 화면을 덮는 빛기둥 · 시작 섬광은 cast 행이 맡음) ·
/// 반복 층이 하나도 없는 프리팹(핏방울 · 독 거품)은 전체를 반복.
/// </summary>
static void ForceLoop(GameObject go, bool loopAll = false, string[] hold = null)
{
var all = go.GetComponentsInChildren<ParticleSystem>(true);
if (loopAll)
{
// b_loopall(PD 2026-11-11 「재생 후 다시 반복되는 과정이 어색 → 시작하면 반복 구간을 자연스럽게 · 공격이 시작될 때 자연스럽게 종료」):
// 층마다 한 주기의 터짐(burst) 수를 연속 방출(초당 = 수 / 주기)로 바꾸고 첫 터짐만 시작 순간 1번 내보냄 → 주기마다 한꺼번에 다시 터지는 끊김 없음 ·
// 끝 = SkillVfx.Stop 이 방출만 멈춰 남은 입자가 제 수명대로 사라짐
// 2026-11-11 PD 「여전히 재생이 완전히 끝났다가 처음부터 다시 재생되는 느낌」 실측: 팩 층의 방출이 「주기 앞 절반에만 내고 뒤 절반은 0」인 곡선이라
// (HCFX_Energy_03 = 1초 주기 중 0.5초) 반복시켜도 0.4초 재생 → 0.4초 빈 화면이 되풀이됨 → 곡선도 한 주기의 평균으로 고르게 펴고,
// 수명이 주기보다 짧은 층(= 빈 틈이 생기는 층)은 입자 2개가 늘 겹치도록 최소 방출(2 / 수명)을 둔다(빛 층 = 한 개가 흐려질 때 다음 것이 밝아져 일정한 밝기).
// 터짐도 곡선도 없는 층(고른 방출)은 손대지 않음 · 수명 ≥ 주기인 터짐 층(도는 구슬·그림자)은 예전과 같은 값(터짐 수 / 주기)
foreach (var ps in all)
{
// 끝날 때까지 남길 층(s_hold · @root = 뿌리 층): 한 번 낸 입자를 그대로 유지 — 마법진 고리처럼 주기마다 다시 나타나면 깜박이는 층(2026-11-11 황충)
if (hold != null && (System.Array.IndexOf(hold, ps.name) >= 0 || (ps.transform == go.transform && System.Array.IndexOf(hold, "@root") >= 0)))
{
var hm = ps.main;
if (hm.loop) // 반복하는 층을 유지하면 주기마다 새 입자가 쌓이며 떠오름(2026-11-13 PD 혼란 물음표 「효과가 끝날 때까지 계속」) → 한 번만 내고 그 자리에 둠(마법진 유지 층은 원래 반복 아님 = 영향 없음)
{
hm.loop = false;
hm.startSpeed = 0f;
var hv = ps.velocityOverLifetime;
hv.enabled = false;
}
Hold(ps);
if (!ps.isPlaying) ps.Play(false);
continue;
}
var m = ps.main;
m.loop = true;
var em = ps.emission;
int intro = 0;
var rateMode = em.rateOverTime.mode;
bool curved = rateMode == ParticleSystemCurveMode.Curve || rateMode == ParticleSystemCurveMode.TwoCurves;
if (em.enabled && (em.burstCount > 0 || curved))
{
float dur = Mathf.Max(0.05f, m.duration);
float perCycle = CurveAverage(em.rateOverTime) * dur;
if (em.burstCount > 0)
{
var bursts = new ParticleSystem.Burst[em.burstCount];
em.GetBursts(bursts);
float total = 0f;
foreach (var b in bursts) total += b.count.constantMax;
intro = Mathf.RoundToInt(total);
perCycle += total;
em.SetBursts(new ParticleSystem.Burst[0]);
}
float life = Mathf.Max(0.05f, m.startLifetime.constantMax);
if (perCycle > 0f) em.rateOverTime = new ParticleSystem.MinMaxCurve(Mathf.Max(perCycle / dur, life < dur - 1e-3f ? 2f / life : 0f));
}
if (!ps.isPlaying) ps.Play(false);
if (intro > 0) ps.Emit(intro);
}
return;
}
bool anyLoop = false;
if (!loopAll) // b_loopall 1 = 모든 층 반복(유비 예약 기운 · 한 번 터지는 진홍·분홍 층까지 · PD 2026-11-10 「원색처럼 보임」)
foreach (var ps in all)
if (ps.main.loop) anyLoop = true;
foreach (var ps in all)
{
var m = ps.main;
if (!anyLoop) m.loop = true;
else if (!m.loop)
{
if (hold != null && System.Array.IndexOf(hold, ps.name) >= 0) // 끝날 때까지 남길 층(s_hold): 한 번 낸 입자를 유지
{
Hold(ps);
if (!ps.isPlaying) ps.Play(false);
continue;
}
ps.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
var em = ps.emission;
em.enabled = false;
continue;
}
if (!ps.isPlaying) ps.Play(false);
}
}
/// <summary>유지 층의 수명(초) — 상태 이상·기운이 가장 오래 남는 시간보다 충분히 길게.</summary>
const float HoldLife = 600f;
/// <summary>
/// 층의 입자를 끝날 때까지 유지(s_hold): 수명을 HoldLife 로 늘리고, 수명 비율로 적힌 값(수명 크기 곡선 · 수명 색 · 꼬리 길이)은 원래 초 단위가 되게 앞쪽으로 당긴다
/// (그대로 두면 처음 0.5초에 커지던 별이 1분에 걸쳐 커지고 꼬리가 끝없이 길어짐). 끝부분의 사라지는 구간은 버림 — 끝은 f_fade 가 맡음.
/// </summary>
static void Hold(ParticleSystem ps)
{
var m = ps.main;
float life0 = m.startLifetime.constantMax;
if (life0 <= 0f || life0 >= HoldLife) return;
float k = life0 / HoldLife;
m.startLifetime = new ParticleSystem.MinMaxCurve(HoldLife);
var sz = ps.sizeOverLifetime;
if (sz.enabled && (sz.size.mode == ParticleSystemCurveMode.Curve || sz.size.mode == ParticleSystemCurveMode.TwoCurves))
sz.size = new ParticleSystem.MinMaxCurve(sz.size.curveMultiplier, Squeeze(sz.size.curveMax ?? sz.size.curve, k));
var col = ps.colorOverLifetime;
if (col.enabled && col.color.gradientMax != null)
{
var g = col.color.gradientMax;
var ck = g.colorKeys;
var ak = g.alphaKeys;
var nck = new List<GradientColorKey>();
var nak = new List<GradientAlphaKey>();
foreach (var c in ck) if (c.time <= 0.5f) nck.Add(new GradientColorKey(c.color, c.time * k));
foreach (var a in ak) if (a.time <= 0.5f) nak.Add(new GradientAlphaKey(a.alpha, a.time * k));
if (nck.Count == 0) nck.Add(new GradientColorKey(ck.Length > 0 ? ck[0].color : Color.white, 0f));
if (nak.Count == 0) nak.Add(new GradientAlphaKey(1f, 0f));
var ng = new Gradient();
ng.SetKeys(nck.ToArray(), nak.ToArray());
col.color = new ParticleSystem.MinMaxGradient(ng);
}
// 셰이더로 넘기는 수명 곡선(나타나는 녹임 등 · Custom Data)도 원래 초 단위로 — 그대로 두면 「나타나는 동작」이 10분에 걸쳐 진행돼 안 보임(2026-11-11 황충 마법진 고리 실측)
var cd = ps.customData;
if (cd.enabled)
foreach (var stream in new[] { ParticleSystemCustomData.Custom1, ParticleSystemCustomData.Custom2 })
{
if (cd.GetMode(stream) != ParticleSystemCustomDataMode.Vector) continue;
int n = cd.GetVectorComponentCount(stream);
for (int i = 0; i < n; i++)
{
var c = cd.GetVector(stream, i);
if (c.mode == ParticleSystemCurveMode.Curve || c.mode == ParticleSystemCurveMode.TwoCurves)
cd.SetVector(stream, i, new ParticleSystem.MinMaxCurve(c.curveMultiplier, Squeeze(c.curveMax ?? c.curve, k)));
}
}
var tr = ps.trails;
if (tr.enabled && tr.mode == ParticleSystemTrailMode.PerParticle)
tr.lifetime = new ParticleSystem.MinMaxCurve(tr.lifetime.constantMax * k); // 꼬리 길이 = 입자 수명 대비 비율
}
/// <summary>수명 곡선의 앞 절반(나타나는 구간)만 시간축을 k 배로 당기고, 그 뒤는 마지막 값으로 유지.</summary>
static AnimationCurve Squeeze(AnimationCurve src, float k)
{
if (src == null) return AnimationCurve.Constant(0f, 1f, 1f);
var keys = new List<Keyframe>();
float last = 1f;
foreach (var key in src.keys)
{
if (key.time > 0.5f) continue;
keys.Add(new Keyframe(key.time * k, key.value, key.inTangent / k, key.outTangent / k));
last = key.value;
}
if (keys.Count == 0) return AnimationCurve.Constant(0f, 1f, src.Evaluate(0.5f));
keys.Add(new Keyframe(1f, last, 0f, 0f));
return new AnimationCurve(keys.ToArray());
}
/// <summary>방출 곡선의 한 주기 평균(초당 · 상수 = 그 값 · 곡선 = 16칸 평균 × 배수).</summary>
static float CurveAverage(ParticleSystem.MinMaxCurve c)
{
if (c.mode == ParticleSystemCurveMode.Constant) return c.constant;
if (c.mode == ParticleSystemCurveMode.TwoConstants) return (c.constantMin + c.constantMax) * 0.5f;
if (c.curveMax == null) return c.constantMax;
float sum = 0f;
const int n = 16;
for (int i = 0; i < n; i++) sum += Mathf.Max(0f, c.curveMax.Evaluate((i + 0.5f) / n));
return sum / n * c.curveMultiplier;
}
/// <summary>팩 HCFX apb 재질의 그림 속성 이름(셰이더 그래프 참조 이름) — 이 속성이 있는 재질만 감싸기·금색 입히기 대상.</summary>
const string PackMainTex = "Texture2D_F593E37E";
/// <summary>Namu 「Simple Stylized Slash」 셰이더 그래프(SH_Master_improved)의 그림 속성 이름 — 흰 모양 플립북 시트(셰이더 _Mode 1 = 모양 시트 방식).</summary>
const string ShapeMainTex = "Texture2D_3df04dddeab4420c8fa2aaeef72bcb87";
/// <summary>Element Splash 계열 셰이더 그래프(Fx_dissolve_particle_apb)의 그림 속성 이름(셰이더 _Mode 2).</summary>
const string DissolveMainTex = "Main_tex";
const string EricMainTex = "_MainTex";
/// <summary>금색 3단·테두리(TKS/FxPackHalf)로 바꿀 수 있는 재질이면 그 그림 속성 이름 · 아니면 null.</summary>
/// <summary>더하기(빛) 재질도 3단 색으로 바꿀지(s_ramp 열셋째 값 1 · 빈칸 = 안 바꿈) — 황토색 바닥에서 하얗게 날아가는 불덩이를 또렷하게(2026-11-11 제갈량 기본 공격 FX_Shoot_05).</summary>
static bool RampAdd(Row r)
{
return r != null && r.ramp != null && r.ramp.Length > 12 && r.ramp[12] == "1";
}
static string PackTexProp(Material m, bool add = false)
{
if (m == null) return null;
if (!add && m.shader != null && m.shader.name.EndsWith("_add")) return null; // 더하기(빛) 재질은 바꾸지 않음(행이 요청하면 바꿈 · RampAdd)
// Eric VFX(이식 셰이더 Eric/URP_AdditiveFlow · AlphaBlendFlow) = 그림 밝기로 모양을 잡는 방식(_MODE_LUM · 2026-11-11 조운 창 이펙트)
// · 같은 팩의 Eric/URP Particles/Additive(발밑 진 FX_Blue Rune 의 Rune_L·Rune_L2 · 2026-11-12 PD 「관평 이펙트 아웃라인을 이펙트 색에 가까운 녹색 계열로」)도 같은 방식
if (m.shader != null && (m.shader.name.StartsWith("Eric/URP_") || m.shader.name.StartsWith("Eric/URP Particles/")) && m.HasProperty(EricMainTex)) return EricMainTex;
// Casual RPG VFX(Lana Studio · Mobile/Particles/Additive · Alpha Blended) = 같은 밝기 방식(빛 번짐 그림을 또렷한 3단 색 + 테두리로 · 2026-11-11 황충 화살의 금빛 기운)
if (m.shader != null && m.shader.name.StartsWith("Mobile/Particles/") && m.HasProperty(EricMainTex)) return EricMainTex;
// Hovl Studio 셰이더 그래프(HS_Blend_CG 등 · 마법진·불꽃 = 검은 바탕의 흰 그림) = 같은 밝기 방식(2026-11-13 PD 주유 「시전 마법진 이펙트 등을 우리 게임의 화풍에 맞게」)
if (m.shader != null && m.shader.name.StartsWith("Shader Graphs/HS_") && m.HasProperty(EricMainTex)) return EricMainTex;
return m.HasProperty(PackMainTex) ? PackMainTex : m.HasProperty(ShapeMainTex) ? ShapeMainTex : m.HasProperty(DissolveMainTex) ? DissolveMainTex : null;
}
const string PackHalfShader = "Shaders/TKS_FxPackHalf";
static Shader packHalfShader;
static readonly Dictionary<string, Material> packHalfCache = new Dictionary<string, Material>();
/// <summary>팩 재질 → 면 고르기·금색 3단 재질(TKS/FxPackHalf) · cull 0 = 전부 · 1 = 먼 반 · 2 = 가까운 반 · 같은 조합은 1개만 만들어 공유.</summary>
/// <summary>
/// 색 단 경계 폭(s_ramp 열째 값 · 빈칸 0.12) — 크게 주면 테 색 → 몸 색 → 심 색이 띠로 끊기지 않고 부드럽게 이어짐
/// (2026-11-11 PD 「색감이 너무 쨍한 원색 계열 · 라이팅을 조금 부여해서 부드러운 색감」 = 조운 바닥 빛).
/// </summary>
static float RampSoft(Row r)
{
return r.ramp != null && r.ramp.Length > 9 ? F(r.ramp[9], 0.12f) : 0.12f;
}
static Material PackHalfMat(Material src, int cull, Row r, bool gain, int half = 0, float face = float.MaxValue, float band = 0f, bool around = false,
int tilesX = 1, int tilesY = 1)
{
string texProp = PackTexProp(src, RampAdd(r));
if (texProp == null) return null;
bool sheet = texProp == ShapeMainTex;
if (packHalfShader == null) packHalfShader = Resources.Load<Shader>(PackHalfShader);
if (packHalfShader == null) return null;
if (face > 1e6f) half = 0;
// 화풍 층(b_cel)에 들어가는 층은 테 색 없이 몸 색으로 — 테두리는 화풍 층의 먹선이 맡음(테 색이 넓게 번져 얼룩져 보이던 것 · 2026-11-11 실측)
bool noRim = r.cel;
string key = src.GetInstanceID() + "|" + cull + "|" + (r.ramp != null ? string.Join(";", r.ramp) : "") + "|" + gain + "|" + half + "|" + noRim + "|" + around + "|" + tilesX + "x" + tilesY + "|" + r.hasRadial;
Material m;
if (packHalfCache.TryGetValue(key, out m) && m != null) return m;
m = new Material(packHalfShader) { name = src.name + " (half " + cull + ")", hideFlags = HideFlags.DontSave };
m.mainTexture = src.GetTexture(texProp);
if (texProp == DissolveMainTex) m.EnableKeyword("_MODE_DISSOLVE"); // 방식 = 재질 키워드(셰이더가 컴파일 때 갈림)
if (texProp == EricMainTex)
{
// 밝기 방식: 그림 밝기 × 알파 × (재질 밝기 × 색 세기)로 모양을 또렷하게 끊음 · 흐르는 그림(리본·고깔)은 흐름·반복 값을 그대로 · 플립북이 아니면 칸 자르기 끔
m.EnableKeyword("_MODE_LUM");
m.mainTextureScale = src.GetTextureScale(texProp);
m.mainTextureOffset = src.GetTextureOffset(texProp);
if (src.HasProperty("_FlowSpeed")) m.SetVector("_Flow", src.GetVector("_FlowSpeed"));
var tint = src.HasProperty("_TintColor") ? src.GetColor("_TintColor") : Color.white;
float bright = src.HasProperty("_Brightness") ? src.GetFloat("_Brightness") : 1f;
m.SetColor("_LumTint", new Color(tint.r * bright, tint.g * bright, tint.b * bright, 1f)); // 원본 그림 색을 그대로 쓰는 행(색 칸 빈칸)의 색 배수
// 모양 문턱 배수 = 재질 밝기 × 색 세기 × s_ramp 열한째 값(빈칸 1 · 크게 주면 옅은 빛까지 모양으로 잡음 = 부드러운 빛 덩어리가 가는 줄만 남지 않게 · 2026-11-11 제갈량)
float lumMul = r.ramp != null && r.ramp.Length > 10 ? F(r.ramp[10], 1f) : 1f;
m.SetFloat("_LumGain", Mathf.Clamp(bright * Mathf.Max(tint.r, Mathf.Max(tint.g, tint.b)) * lumMul, 0.6f, 6f));
// 모양 경계의 부드러움(s_ramp 열두째 값 · 빈칸 0 = 또렷하게 끊음 · 1 = 원본 그림의 번짐을 그대로) — 안쪽으로 옅어지는 빛 고리·구름은 끊으면 속이 찬 원판이 됨(2026-11-11 제갈량 시전 고리 실측)
float shapeSoft = r.ramp != null && r.ramp.Length > 11 ? Mathf.Clamp01(F(r.ramp[11], 0f)) : 0f;
// 모양 문턱(s_ramp 열다섯째 값 · 빈칸 = 위 기본): 이 밝기보다 옅은 번짐은 버림(2026-11-12 PD 「관평 이펙트 아웃라인을 이펙트 색에 가까운 녹색 계열로」 —
// 기본 문턱이면 진 그림 안쪽의 넓은 번짐까지 속이 찬 원판이 됨 · 실측)
float cut = r.ramp != null && r.ramp.Length > 14 ? Mathf.Clamp01(F(r.ramp[14], 0f)) : 0f;
m.SetFloat("_ShapeLo", cut > 0f ? cut : Mathf.Lerp(0.12f, 0f, shapeSoft));
m.SetFloat("_ShapeHi", cut > 0f ? Mathf.Min(1f, cut + 0.12f) : Mathf.Lerp(0.34f, 1f, shapeSoft));
// 3색 그러데이션(s_ramp 열넷째 값 = 테 색이 끝나는 밝기 · 빈칸 = 끔): 어두운 곳을 테 색으로 칠해 테 → 몸 → 심으로 이어지게(테두리 선 대신 색 변화 · 불꽃)
float lumRim = r.ramp != null && r.ramp.Length > 13 ? F(r.ramp[13], 0f) : 0f;
m.SetFloat("_LumRimOn", lumRim > 0f ? 1f : 0f);
m.SetFloat("_LumRimLo", 0f);
m.SetFloat("_LumRimHi", Mathf.Max(0.05f, lumRim));
m.SetVector("_Tiles", new Vector4(Mathf.Max(1, tilesX), Mathf.Max(1, tilesY), 0f, 0f));
m.SetFloat("_CellOpen", tilesX <= 1 && tilesY <= 1 ? 1f : 0f);
if (r.ramp != null && r.ramp.Length > 4)
{
float core = F(r.ramp[4], 0.7f); // 밝은 심이 시작되는 밝기(s_ramp 다섯째 값 · 빈칸 0.7)
m.SetFloat("_CoreLo", core);
m.SetFloat("_CoreHi", core + RampSoft(r));
}
}
if (r.hasRadial) m.SetFloat("_FadeOn", 1f);
if (sheet)
{
m.EnableKeyword("_MODE_SHEET");
m.SetVector("_Tiles", new Vector4(Mathf.Max(1, tilesX), Mathf.Max(1, tilesY), 0f, 0f));
if (r.ramp != null && r.ramp.Length > 6) m.SetFloat("_CorePx", F(r.ramp[6], 0f)); // 모양 안쪽 심이 시작되는 깊이(픽셀)
}
m.renderQueue = src.renderQueue;
m.SetFloat("_Cull", cull);
m.SetFloat("_Half", half); // 얼굴 높이 값(_FaceY0 · _FaceY1)은 유닛마다·움직일 때마다 달라 재질이 아니라 렌더러마다 넣음(SkillVfxFaceLine)
if (r.ramp != null)
{
Color c;
// s_ramp 의 색 칸 셋이 모두 빈칸 = 색을 입히지 않고 원본 그림 색 그대로(모양·불투명도만 조절) — 그림에 그러데이션이 그려진 불꽃(2026-11-11 PD 「원본과 같이 그라데이션 색상도 · 꼬리쪽으로 갈수록 짙은 색」)
m.SetFloat("_Ramp", r.ramp.Length < 3 || r.ramp[0].Length + r.ramp[1].Length + r.ramp[2].Length > 0 ? 1f : 0f);
if (ColorUtility.TryParseHtmlString(r.ramp[noRim ? 1 : 0], out c)) m.SetColor("_Rim", c);
if (ColorUtility.TryParseHtmlString(r.ramp[1], out c)) m.SetColor("_Body", c);
if (ColorUtility.TryParseHtmlString(r.ramp[2], out c)) m.SetColor("_Light", c);
m.SetFloat("_AlphaGain", gain && r.ramp.Length > 3 ? F(r.ramp[3], 1f) : 1f);
if (r.ramp.Length > 8 && ColorUtility.TryParseHtmlString(r.ramp[8], out c)) m.SetColor("_Ink", c); // 팩의 새까만 층에 칠할 색(빈칸 = 먹색)
if (r.ramp.Length > 5) m.SetFloat("_OutlinePx", F(r.ramp[5], 0f)); // 모양 가장자리 테 굵기(픽셀 · 금줄·주위 층 공통 = 같은 갈색 테두리)
if (around && r.ramp.Length > 4 && texProp != EricMainTex)
{
// 감싸기 밖의 넓은 층(옅은 줄기·바닥 고리)은 심 색이 시작되는 자리를 따로(s_ramp 다섯째 값) — 넓은 그림은 가운데가 넓어 기본값이면 거의 전부 심 색(미색)이 됨
float core = F(r.ramp[4], 0.5f);
m.SetFloat("_CoreLo", core);
m.SetFloat("_CoreHi", core + RampSoft(r));
// 색 단 경계 폭을 준 행은 테 색 → 몸 색도 같은 폭으로 부드럽게(띠로 끊기지 않고 이어짐)
if (r.ramp.Length > 9 && r.ramp[9].Length > 0) m.SetFloat("_RimHi", m.GetFloat("_RimLo") + RampSoft(r));
}
}
packHalfCache[key] = m;
return m;
}
/// <summary>
/// 몸 감싸기(s_wrap) + 금색 입히기(s_ramp): 감싸기 층은 같은 씨앗의 복제 층을 하나 더 만들어 원래 층 = 먼 반(유닛 아래 · n_order) · 복제 층 = 가까운 반(유닛 위) ·
/// 좌우 뒤집기(flip)는 끔(뒤집힌 입자는 면 방향이 반대라 가까운 반·먼 반이 바뀜) · 그 밖의 팩 메시 층은 색만 입힘. ForceLoop 앞에 부른다(두 층이 같은 방출·같은 입자).
/// face = 얼굴 높이(기준점에서 위로 · 월드 단위 · float.MaxValue = 없음) — 그 위로는 가까운 반도 유닛 아래 벌이 그림(머리 뒤로 지나감 · band = 넘어가는 띠 반폭).
/// </summary>
static void WrapAndRamp(GameObject go, Row r, float face, float band)
{
uint seed = (uint)Random.Range(1, int.MaxValue / 2);
var faceRds = new List<Renderer>();
foreach (var rd in go.GetComponentsInChildren<ParticleSystemRenderer>(true))
{
// 기본 = 메시 층(고리·줄기)만 · s_ramp 여덟째 값 1 또는 s_radial = 띠·판(메시 아닌) 층도
bool allModes = r.hasRadial || (r.ramp != null && r.ramp.Length > 7 && r.ramp[7] == "1");
if ((rd.renderMode != ParticleSystemRenderMode.Mesh && !allModes) || PackTexProp(rd.sharedMaterial, RampAdd(r)) == null) continue;
var tsa = rd.GetComponent<ParticleSystem>().textureSheetAnimation;
// 칸 수는 격자 방식일 때만 — 스프라이트 방식(Casual RPG VFX = 층마다 스프라이트 1장)은 numTiles 가 남은 값일 뿐이라 그대로 쓰면
// 칸 경계마다 테두리가 그려져 격자무늬 네모가 됨(2026-11-11 제갈량 Loot_drop 실측)
bool grid = tsa.enabled && tsa.mode == ParticleSystemAnimationMode.Grid;
int tx = grid ? tsa.numTilesX : 1, ty = grid ? tsa.numTilesY : 1;
bool wrap = band > 0f && System.Array.IndexOf(r.wrapLayers, rd.gameObject.name) >= 0 && rd.transform != go.transform; // band 0 = 색만(한 번 재생 경로)
if (!wrap)
{
if (r.ramp == null) continue;
var all = PackHalfMat(rd.sharedMaterial, 0, r, true, 0, float.MaxValue, 0f, true, tx, ty); // 금줄과 같은 색·테·불투명도(PD 2026-11-11 「금줄에 맞게 캐릭터 주위 이펙트를 바꾸라고」)
if (all != null) rd.sharedMaterial = all;
continue;
}
// 얼굴 높이가 있으면 아래 벌 = 양면(먼 반 + 얼굴 높이 위의 가까운 반) · 위 벌 = 가까운 반(얼굴 높이 위로는 사라짐) · 없으면 먼 반 / 가까운 반
bool faceOn = face < 1e6f;
var far = PackHalfMat(rd.sharedMaterial, faceOn ? 0 : 1, r, true, 2, face, band);
var near = PackHalfMat(rd.sharedMaterial, 2, r, true, 1, face, band);
if (far == null || near == null) continue;
var dup = Object.Instantiate(rd.gameObject, rd.transform.parent);
dup.name = rd.gameObject.name + "_near";
for (int i = dup.transform.childCount - 1; i >= 0; i--) Object.Destroy(dup.transform.GetChild(i).gameObject);
var drd = dup.GetComponent<ParticleSystemRenderer>();
rd.flip = Vector3.zero;
drd.flip = Vector3.zero;
rd.sharedMaterial = far;
drd.sharedMaterial = near;
drd.sortingOrder = SortingBase; // 유닛 위
if (faceOn)
{
faceRds.Add(rd);
faceRds.Add(drd);
}
// 화풍 층(b_cel) 행이면 유닛 위 벌도 화풍 층의 위 판으로(앞뒤 두 벌이 같은 먹선·단색 면 · 한 벌만 넣으면 외곽선이 달라 보임 · 2026-11-11 실측) —
// 유비 예약 기운은 PD 2026-11-11 「금줄에 맞게 캐릭터 주위 이펙트를 바꾸라고」 결정으로 화풍 층을 쓰지 않음(b_cel 빈칸 · 금색 3단 s_ramp 로 통일)
dup.layer = r.cel ? FxStyleLayer.LayerOver : 0;
seed++;
foreach (var ps in new[] { rd.GetComponent<ParticleSystem>(), dup.GetComponent<ParticleSystem>() })
{
ps.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
ps.useAutoRandomSeed = false;
ps.randomSeed = seed;
}
}
if (faceRds.Count > 0) go.AddComponent<SkillVfxFaceLine>().Set(faceRds.ToArray(), face - band, face + band);
}
/// <summary>
/// 투사체(shot): 행동 중 유닛의 키에 shot 행이 있으면 시전자 → 도착점으로 날린다(비행 시간 = <see cref="Fx.ArrowDuration"/> · 피해 시점 그대로) ·
/// 행이 없으면 기존 선 화살(fallback 색). 기준점 = body(기본 · 몸 높이로 날아감) | feet.
/// </summary>
public static IEnumerator Shot(Unit u, Vector2 from, Vector2 to, Color fallback, float duration = 0f)
{
var list = new List<GameObject>();
var starts = new List<Vector2>();
var leads = new List<Vector2>(); // f_fwd 행 = 출발할 때만 진행 방향 앞에서 시작(거대 화살의 꼬리가 쏜 유닛 뒤로 튀어나오지 않게) · 날아가며 0 으로 줄어 도착점은 그대로
float fly = 1f; // 비행 속도 배수(f_fly · 가장 큰 값)
var lives = new List<float>(); // f_life 행 = 도착한 뒤 이 초만 남기고 통째로 지움(꼬리·줄기·반짝이까지 · 아주 작은 값 = 명중 뒤 아무것도 남기지 않음 · 2026-11-11 PD 제갈량 「피격 후 이펙트도 제거」)
var clears = new List<GameObject>(); // b_clear 행 = 도착하면 한 번 낸 입자(수명이 긴 머리·빛 층)를 바로 지움(꼬리·반짝이는 제 수명대로)
Vector2 d = to - from;
if (!Sim.Active && u != null)
{
var keys = KeysOf(u);
if (keys != null)
{
Ensure();
string camp = CampOf(u);
float h = UnitH(u);
Vector2 face = d.sqrMagnitude > 1e-6f ? d.normalized : Vector2.right;
foreach (var k in keys)
foreach (var r in rows)
{
if (!Match(r, k, EventShot, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
Vector2 p = from + (r.anchor == "feet" ? Vector2.zero : new Vector2(0f, h * 0.45f)) + new Vector2(r.dx, r.dy) * h;
if (r.fly > fly) fly = r.fly;
Vector2 lead = face * (r.fwd * h);
list.Add(SpawnPoint(r, prefab, p + lead, r.scale * h, face, null));
starts.Add(p);
leads.Add(lead);
lives.Add(r.life);
if (r.clear) clears.Add(list[list.Count - 1]);
}
}
}
if (list.Count == 0)
{
yield return Fx.Arrow(from, to, fallback);
yield break;
}
float dur = duration > 0f ? duration : Fx.ArrowDuration(d.magnitude) / Mathf.Max(0.1f, fly); // duration = 레이저 앞머리(빛 기둥이 뻗는 시간)
for (float t = 0f; t < dur; t += Time.deltaTime)
{
float k = t / dur;
for (int i = 0; i < list.Count; i++)
if (list[i] != null) list[i].transform.position = (Vector3)(starts[i] + d * k + leads[i] * (1f - k));
yield return null;
}
for (int i = 0; i < list.Count; i++)
if (list[i] != null) list[i].transform.position = (Vector3)(starts[i] + d);
foreach (var go in clears)
{
if (go == null) continue;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
if (ps.main.loop) continue;
ps.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
var prd = ps.GetComponent<Renderer>();
if (prd != null) prd.enabled = false; // 지운 뒤에도 한 장면 남는 것을 막음(늘인 입자 · 2026-11-11 제갈량 기본 공격 실측)
}
}
for (int i = 0; i < list.Count; i++)
{
if (list[i] == null || lives[i] <= 0f) continue;
Object.Destroy(list[i], lives[i]);
list[i] = null;
}
Stop(list);
}
/// <summary>
/// 레이저(beam): 행동 중 유닛 키의 beam 행을 쏜 자리(body = 몸 높이 · feet)에서 to 쪽으로 눕혀 띄우고 행의 f_wait 만큼 기다린다(그 뒤 호출 쪽이 경로 위 전원에 동시 피해) ·
/// 판 회전(b_flat)에 진행 방향의 오른쪽 수직을 넘겨 프리팹 위(+Y)가 진행 방향을 향하게 · 행이 없으면 기존 선 화살(fallback 색).
/// </summary>
public static IEnumerator Beam(Unit u, Vector2 from, Vector2 to, Color fallback)
{
Vector2 d = to - from;
float len = d.magnitude;
float wait = 0f;
float tip = 0f; // 빛 기둥 앞머리가 끝에 닿는 시간(역순 줄 · 세로 크기 곡선이 다 자라는 시각 ÷ 재생 속도)
bool any = false;
var along = new List<Row>(); // f_every 줄 = 레이저를 따라 띄움(앞머리 시간을 안 뒤에)
var alongFx = new List<GameObject>();
float h = 1f;
Vector2 dir = Vector2.up, side = Vector2.right;
if (!Sim.Active && u != null && len > 1e-3f)
{
var keys = KeysOf(u);
if (keys != null)
{
Ensure();
string camp = CampOf(u);
h = UnitH(u);
dir = d / len;
side = new Vector2(dir.y, -dir.x);
foreach (var k in keys)
foreach (var r in rows)
{
if (!Match(r, k, EventBeam, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
if (r.every > 0f && !r.rev)
{
along.Add(r);
alongFx.Add(prefab);
any = true;
continue;
}
Vector2 p = from + (r.anchor == "feet" ? Vector2.zero : new Vector2(0f, h * 0.45f)) + new Vector2(r.dx, r.dy) * h + dir * (r.fwd * h);
if (r.rev) p += dir * len; // 역순 = 원점 먼 끝 · 아래 판 방향을 뒤집음(위 = 쏜 쪽)
// 크기: 역순 줄(빛 기둥) = f_scale × 레이저 길이 · 나머지 줄(쏜 자리의 섬광·연기·조각) = f_scale × 유닛 키(조준 방향·화면 끝 거리와 상관없이 같은 크기)
var go = SpawnPoint(r, prefab, p, r.scale * (r.rev ? len : h), r.rev ? -side : side, null);
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var pr = ps.GetComponent<ParticleSystemRenderer>();
if (pr == null || pr.renderMode != ParticleSystemRenderMode.Stretch) continue;
// 길게 늘인 빛 기둥(늘인 판)은 화면 대비 최대 입자 크기(기본 5)에 걸리면 통째로 사라짐(세로 화면 · 전장 끝까지 = 화면 폭의 5배 넘음 · 2026-11-12 실측) → 제한을 풂
pr.maxParticleSize = BeamMaxParticleSize;
if (Mathf.Abs(r.wide - 1f) > 1e-3f) { var m = ps.main; m.startSizeXMultiplier *= r.wide; } // 굵기(f_wide)
if (r.rev) tip = Mathf.Max(tip, GrowTime(ps));
}
if (r.life > 0f && r.fade > 0f) SkillVfxFade.Begin(go, r.fade, Mathf.Max(0f, r.life - r.fade)); // 끝 f_fade 초 흐려지며 사라짐
else Object.Destroy(go, r.life > 0f ? r.life : AutoLife(go));
if (r.lift && u.View != null && u.View.Anim != null) FxOwnerLift.Attach(go, u.View.Anim.Renderer); // 레이저는 적 위 · 쏜 유닛은 그 위(2026-11-12 PD 태사자)
if (r.wait > wait) wait = r.wait;
any = true;
}
}
}
if (!any)
{
yield return Fx.Arrow(from, to, fallback);
yield break;
}
if (tip > 0f)
{
// 앞머리(화살 · 감싼 빛) = 이 유닛의 shot 줄을 빛 기둥이 뻗는 시간과 같은 시간에 날림(거리와 상관없이 앞머리에 붙음) · 피해 = 앞머리가 끝에 닿을 때(2026-11-12 PD 태사자 「화살이 레이저 앞머리에」)
Fx.Run(Shot(u, from, to, fallback, tip));
wait = Mathf.Max(wait, tip);
}
for (int i = 0; i < along.Count; i++) Fx.Run(AlongBeam(along[i], alongFx[i], from, dir, side, len, h, tip));
if (wait > 0f) yield return Fx.Wait(wait);
}
/// <summary>
/// 레이저를 따라 띄우는 줄(beam · f_every = 간격(유닛 키 배수) · 2026-11-12 PD 태사자 「주변이 일렁이는 푸른 불꽃 · 전기 효과」):
/// 쏜 자리에서 간격마다 · 앞머리가 그 자리를 지나는 순간(앞머리 시간 × 거리 비율 + f_delay) · 크기 = f_scale × 유닛 키 · 진행 방향을 바라봄.
/// </summary>
static IEnumerator AlongBeam(Row r, GameObject prefab, Vector2 from, Vector2 dir, Vector2 side, float len, float h, float tip)
{
Vector2 basePos = from + (r.anchor == "feet" ? Vector2.zero : new Vector2(0f, h * 0.45f)) + new Vector2(r.dx, r.dy) * h;
float step = Mathf.Max(0.1f, r.every * h);
float t0 = Time.time;
for (float dist = step * 0.5f; dist < len; dist += step)
{
float at = r.delay + (tip > 0f ? tip * dist / len : 0f);
while (Time.time - t0 < at) yield return null;
var go = SpawnPoint(r, prefab, basePos + dir * dist, r.scale * h, r.flat ? side : dir, null);
if (r.life > 0f && r.fade > 0f) SkillVfxFade.Begin(go, r.fade, Mathf.Max(0f, r.life - r.fade));
else Object.Destroy(go, r.life > 0f ? r.life : AutoLife(go));
}
}
/// <summary>늘인 판 층의 세로 크기 곡선(크기 · 수명 · y)이 처음 최대에 닿는 시각 × 수명 ÷ 재생 속도 = 빛 기둥이 다 뻗는 시간(곡선이 없으면 0).</summary>
static float GrowTime(ParticleSystem ps)
{
var so = ps.sizeOverLifetime;
if (!so.enabled || !so.separateAxes) return 0f;
var c = so.y.curveMax;
if (c == null || c.length < 2) return 0f;
float max = 0f;
foreach (var k in c.keys) max = Mathf.Max(max, k.value);
if (max <= 1e-4f) return 0f;
foreach (var k in c.keys)
if (k.value >= max * 0.99f)
return k.time * ps.main.startLifetime.constantMax / Mathf.Max(0.01f, ps.main.simulationSpeed);
return 0f;
}
/// <summary>레이저 빛 기둥의 최대 입자 크기(화면 비율 · 유니티 기본 5 → 전장 끝까지 늘인 기둥이 잘리지 않을 만큼).</summary>
const float BeamMaxParticleSize = 100f;
/// <summary>폭발(blast): 행동 중 유닛 키의 blast 행을 광역 중심에 · 크기 = 반경 × f_scale · 반환 = 띄운 것이 있음(있으면 호출 쪽이 납작한 원 Fx.Burst 를 생략).</summary>
public static bool Blast(Unit u, Vector2 center, float radius, string evt = EventBlast)
{
if (Sim.Active || u == null) return false;
var keys = KeysOf(u);
if (keys == null) return false;
Ensure();
string camp = CampOf(u);
bool any = false;
foreach (var k in keys)
foreach (var r in rows)
{
if (!Match(r, k, evt, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
if (r.delay > 0f) Fx.Run(BlastLater(r, prefab, center, radius));
else BlastNow(r, prefab, center, radius);
any = true;
}
return any;
}
static IEnumerator BlastLater(Row r, GameObject prefab, Vector2 center, float radius)
{
yield return Fx.Wait(r.delay);
BlastNow(r, prefab, center, radius);
}
static void BlastNow(Row r, GameObject prefab, Vector2 center, float radius)
{
float rad = Mathf.Max(0.2f, radius);
var go = SpawnPoint(r, prefab, center + new Vector2(r.dx, r.dy) * rad, r.scale * rad, null, null);
if (r.hasRadial) // 중심 = 광역 중심(시전자) · 반경 배수 → 월드 거리(재질은 공유 · 값은 렌더러마다)
{
var block = new MaterialPropertyBlock();
foreach (var rd in go.GetComponentsInChildren<ParticleSystemRenderer>(true))
{
if (rd.sharedMaterial == null || !rd.sharedMaterial.HasProperty("_FadeOn")) continue;
rd.GetPropertyBlock(block);
block.SetVector("_FadeCenter", new Vector4(center.x, center.y, 0f, 0f));
block.SetFloat("_FadeR0", rad * r.radial.x);
block.SetFloat("_FadeR1", rad * Mathf.Max(r.radial.x + 0.01f, r.radial.y));
rd.SetPropertyBlock(block);
}
}
if (r.life > 0f && r.fade > 0f) SkillVfxFade.Begin(go, r.fade, Mathf.Max(0f, r.life - r.fade)); // f_life 끝 f_fade 초 동안 흐려지며 사라짐(2026-11-12 PD 서서 바닥 그을음 「0.5초~1초 내외만 재생」)
else Object.Destroy(go, r.life > 0f ? r.life : AutoLife(go));
}
/// <summary>지대(zone): 그 키의 zone 행을 선분 a→b 위에 간격(f_every × 반경 · 빈칸 1.6)으로 · 반복 · parent(지대 그림) 밑에 두어 지대가 사라지면 함께 사라짐.</summary>
public static void Zone(Unit owner, string key, Vector2 a, Vector2 b, float radius, Transform parent)
{
if (Sim.Active || owner == null || parent == null || string.IsNullOrEmpty(key)) return;
Ensure();
string camp = CampOf(owner);
float rad = Mathf.Max(0.2f, radius);
foreach (var r in rows)
{
if (!Match(r, key, EventZone, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
float len = Vector2.Distance(a, b);
float gap = rad * (r.every > 0f ? r.every : 1.6f);
int n = len < 0.05f ? 1 : Mathf.Max(2, Mathf.CeilToInt(len / gap) + 1);
Vector2 dir = len > 1e-4f ? (b - a) / len : Vector2.right;
for (int i = 0; i < n; i++)
{
Vector2 p = n == 1 ? a : Vector2.Lerp(a, b, i / (float)(n - 1));
var go = SpawnPoint(r, prefab, p + new Vector2(r.dx, r.dy) * rad, r.scale * rad, dir, parent);
ForceLoop(go, r.loopAll);
}
}
}
/// <summary>회복 등 대상 유닛 자체에 1번(키 · 이벤트 · 기준점 = 행 anchor · 기본 body).</summary>
/// <summary>
/// 대상마다 내려오는 연출(drop 행)을 띄우고, 효과를 적용할 시점(가장 긴 f_wait · 초)을 돌려준다(행이 없거나 시뮬레이션이면 0 = 바로 적용).
/// </summary>
public static float Drop(IEnumerable<Unit> targets, string key)
{
if (Sim.Active || targets == null || string.IsNullOrEmpty(key)) return 0f;
Ensure();
float wait = 0f;
foreach (var t in targets)
{
if (t == null) continue;
string camp = CampOf(t);
foreach (var r in rows)
{
if (!Match(r, key, EventDrop, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
if (r.wait > wait) wait = r.wait;
if (r.delay > 0f) Fx.Run(DropLater(r, prefab, t));
else DropNow(r, prefab, t);
}
}
return wait;
}
/// <summary>
/// 그 스킬 heal 행의 가장 긴 f_wait(초) = 시전 연출이 재생된 뒤 회복(숫자·이펙트)을 적용할 시점(행이 없거나 시뮬레이션이면 0 = 바로 · PD 2026-11-13 방통 「연출이 재생된 후 회복 효과」).
/// </summary>
public static float HealWait(string key)
{
if (Sim.Active || string.IsNullOrEmpty(key)) return 0f;
Ensure();
float wait = 0f;
foreach (var r in rows)
if (r.evt == EventHeal && r.HasKey(key) && r.wait > wait) wait = r.wait;
return wait;
}
static IEnumerator DropLater(Row r, GameObject prefab, Unit t)
{
yield return Fx.Wait(r.delay);
if (t != null && t.IsAlive) DropNow(r, prefab, t);
}
static void DropNow(Row r, GameObject prefab, Unit t)
{
var go = SpawnPoint(r, prefab, AnchorPos(r, t), r.scale * UnitH(t), null, r.follow == 1 ? t.transform : null);
Object.Destroy(go, r.life > 0f ? r.life : AutoLife(go));
}
public static void PlayOn(Unit target, string key, string evt)
{
if (Sim.Active || target == null) return;
Ensure();
string camp = CampOf(target);
foreach (var r in rows)
{
if (!Match(r, key, evt, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
var go = SpawnPoint(r, prefab, AnchorPos(r, target), r.scale * UnitH(target), null, r.follow == 1 ? target.transform : null);
Object.Destroy(go, r.life > 0f ? r.life : AutoLife(go));
}
}
static Vector2 AnchorPos(Row r, Unit u)
{
float h = UnitH(u);
Vector2 pos = u.Position;
string a = r.anchor.Length > 0 ? r.anchor : "body";
if (a == "headside")
{
// 머리 옆(PD 2026-11-11 「출혈 위치가 타겟이 된 몬스터와 다른 위치에 발생」): 기준 = 머리 가운데(그림 머리 끝에서 반지름 × 1.1 아래) · f_dx·f_dy = 유닛 반지름 배수 —
// 키 배수로 두면 키 큰 유닛(기병)일수록 머리에서 멀어짐(머리 크기는 병종과 상관없이 반지름쯤으로 같음)
float top = -u.Radius * 0.55f + h;
return new Vector2(pos.x + r.dx * u.Radius, pos.y + top - u.Radius * 1.1f + r.dy * u.Radius);
}
if (a == "body" || a == "target") pos.y += h * 0.45f;
else if (a == "head")
{
// 머리 위 표시: 올리는 거리(f_dy)는 키 배수라 키 큰 유닛(기병 1.95 · 보병 1.34)일수록 머리에서 멀어진다 → 걸어 다니는 유닛 키(HeadRef)까지만 쳐서 올림
// (PD 2026-11-13 「혼란 상태에 빠진 영웅 중 기병 형태는 이펙트 위치가 너무 상단에 출력 → 좀 더 하단에」)
pos.y += h;
return pos + new Vector2(r.dx, r.dy) * HeadRef(u);
}
return pos + new Vector2(r.dx, r.dy) * h;
}
/// <summary>머리 위 표시(e_anchor head)의 기준 키 = 유닛 키와 「기마 그림 머리 끝 한도」(걸어 다니는 유닛 키쯤) 중 작은 값 — 기병도 보병과 같은 크기·같은 간격으로 뜸.</summary>
static float HeadRef(Unit u)
{
float h = UnitH(u);
return u.MountedArtMaxTop > 0f ? Mathf.Min(h, u.MountedArtMaxTop) : h;
}
/// <summary>기운·상태 이상 반복(SkillVfxLoops): 유닛에 붙여 반복 재생 · 반환 = 띄운 것(없으면 빈 목록).</summary>
public static List<GameObject> SpawnLoops(Unit u, string key, string evt)
{
var list = new List<GameObject>();
if (Sim.Active || u == null) return list;
Ensure();
string camp = CampOf(u);
foreach (var r in rows)
{
if (!Match(r, key, evt, camp)) continue;
var prefab = LoadFx(r.fx);
if (prefab == null) continue;
if (r.wrap > 0f && r.wrapLayers.Length == 0)
{
list.AddRange(SpawnWrap(r, prefab, u));
continue;
}
var go = SpawnPoint(r, prefab, AnchorPos(r, u), r.scale * (r.anchor == "head" ? HeadRef(u) : UnitH(u)), null, u.transform); // 머리 위 표시 = 기병도 보병과 같은 크기
if (r.hold.Length > 0 && r.fade <= 0f) loopFade[go] = 0.2f; // 유지 층은 수명이 길어 끝날 때 바로 흐려 지움
if (r.wrapLayers.Length > 0)
{
// 얼굴 높이(f_wrap = 그림 발에서 키 × f_wrap · 0 = 없음): 기준점에서 위로 잰 월드 높이로 바꿔 넘김(부드러운 띠 = 키 × ±0.06)
float h = UnitH(u);
float face = r.wrap > 0f ? h * r.wrap - u.Radius * 0.55f - (AnchorPos(r, u).y - u.Position.y) : float.MaxValue;
WrapAndRamp(go, r, face, h * 0.06f);
}
if (r.face && u.View != null) go.AddComponent<SkillVfxFacing>().Init(u.View); // 반복 이펙트의 b_face = f_dx 를 유닛이 바라보는 쪽 기준으로
ForceLoop(go, r.loopAll, r.hold);
if (r.wobbleDeg > 0f) go.AddComponent<SkillVfxWobble>().Init(r.wobbleDeg, r.wobbleSec); // 좌우 까딱임(s_wobble)
for (int j = 0; j < r.wrapLayers.Length; j++) // 감싸기 층 방출 배수(원래 층 + 가까운 반 복제 층에 똑같이)
{
if (Mathf.Abs(r.wrapRate[j] - 1f) < 1e-3f) continue;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
if (ps.name != r.wrapLayers[j] && ps.name != r.wrapLayers[j] + "_near") continue;
var em = ps.emission;
em.rateOverTimeMultiplier *= r.wrapRate[j];
}
}
// 층별 방출 배수(s_rate): 반복으로 고르게 편 뒤의 방출량에 곱함(@root = 뿌리 층 · 감싸기 복제 층 _near 도 같이) —
// 한 번 재생하는 팩 이펙트를 반복시키면 방출이 「한 주기 평균」(가장 셀 때의 1/4 쯤)이 되어 솟는 선 같은 층이 성기게 보임(2026-11-11 조운 발동 예정)
for (int j = 0; j < r.rateLayers.Length; j++)
{
if (Mathf.Abs(r.rateMult[j] - 1f) < 1e-3f) continue;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
bool rootRate = r.rateLayers[j] == "@root" && ps.transform == go.transform;
if (!rootRate && ps.name != r.rateLayers[j] && ps.name != r.rateLayers[j] + "_near") continue;
var em = ps.emission;
em.rateOverTimeMultiplier *= r.rateMult[j];
}
}
if (r.fade > 0f) loopFade[go] = r.fade; // 끝날 때 흐려지며 사라짐(f_fade · 빈칸 = 방출만 멈추고 자연 소멸 = 유비 예약 기운)
list.Add(go);
}
return list;
}
/// <summary>
/// 몸 감싸기(f_wrap): 같은 씨앗(입자 모양·시점 동일)의 두 벌 — 뒤 벌 = 캐릭터 아래 층(n_order · 음수 아니면 −1) · 마스크 밖만 보임 /
/// 앞 벌 = 캐릭터 위 층(SortingBase) · 마스크 안만 보임 · 마스크 = 발 아래 2키 ~ 발 + 키 × f_wrap 사각(폭 4키 · 유닛을 따라감).
/// 결과 = 하반신 높이의 이펙트는 몸 앞 · 상반신 높이는 몸 뒤(감싸는 느낌) · 한 자리에 한 벌만 보여 겹쳐 진해지지 않음.
/// </summary>
static List<GameObject> SpawnWrap(Row r, GameObject prefab, Unit u)
{
var res = new List<GameObject>();
float h = UnitH(u);
Vector2 pos = AnchorPos(r, u);
int underOrder = SortingBase + Mathf.Min(r.order, -1);
int seed = Random.Range(1, int.MaxValue / 2);
var under = SpawnPoint(r, prefab, pos, r.scale * h, null, u.transform);
var over = SpawnPoint(r, prefab, pos, r.scale * h, null, u.transform);
foreach (var pair in new[] { new KeyValuePair<GameObject, int>(under, underOrder), new KeyValuePair<GameObject, int>(over, SortingBase) })
{
var mi = pair.Key == over ? SpriteMaskInteraction.VisibleInsideMask : SpriteMaskInteraction.VisibleOutsideMask;
foreach (var rd in pair.Key.GetComponentsInChildren<Renderer>(true))
{
rd.sortingOrder = pair.Value;
var pr = rd as ParticleSystemRenderer;
if (pr != null) pr.maskInteraction = mi;
var sr = rd as SpriteRenderer;
if (sr != null) sr.maskInteraction = mi;
}
Reseed(pair.Key, seed);
ForceLoop(pair.Key, r.loopAll);
}
var m = new GameObject("WrapMask");
m.transform.SetParent(u.transform, false);
var sm = m.AddComponent<SpriteMask>();
sm.sprite = ProceduralSprites.Square;
sm.isCustomRangeActive = true;
sm.backSortingOrder = underOrder - 1; // 이 두 벌 정렬 사이만 영향(다른 스프라이트는 마스크 상호작용 없음)
sm.frontSortingOrder = SortingBase;
float feet = -u.Radius * 0.55f; // UnitView 아트 발(유닛 위치 기준)
float top = feet + h * r.wrap, bottom = feet - h * 2f;
m.transform.localPosition = new Vector3(0f, (top + bottom) * 0.5f, 0f);
m.transform.localScale = new Vector3(h * 4f, top - bottom, 1f);
res.Add(under);
res.Add(over);
res.Add(m);
return res;
}
/// <summary>두 벌이 같은 입자를 내도록 같은 씨앗으로 다시 시작(층 순서마다 씨앗 + 순번).</summary>
static void Reseed(GameObject go, int seed)
{
int i = 0;
var all = go.GetComponentsInChildren<ParticleSystem>(true);
foreach (var ps in all) ps.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
foreach (var ps in all)
{
ps.useAutoRandomSeed = false;
ps.randomSeed = (uint)(seed + i++);
}
foreach (var ps in all) ps.Play(false);
}
/// <summary>
/// 행의 색 바꾸기(s_hue · f_sat)와 세기(f_alpha)를 띄운 이펙트에 적용 — 입자 시작 색 · 수명 색 · 사용자 데이터 색(Hyper Casual 2nd color) ·
/// 트레일·선·스프라이트 색. 색상만 바꾸고 채도·밝기는 유지(채도 0.12 미만 = 흰 심·연기는 그대로) · 세기는 시작 색 불투명도에만 곱함.
/// </summary>
static void Recolor(GameObject go, Row r)
{
Recolor(go, r.hue, r.sat, r.alpha);
}
/// <summary>색 바꾸기·세기(행 값 없이 직접 · 에디터 미리보기 도구 공용).</summary>
public static void Recolor(GameObject go, string hueHex, float sat, float alpha)
{
bool hueOn = !string.IsNullOrEmpty(hueHex);
bool alphaOn = Mathf.Abs(alpha - 1f) > 1e-3f;
if (!hueOn && !alphaOn) return;
float th = 0f, ts = 1f, tv = 1f;
if (hueOn)
{
Color tc;
if (!ColorUtility.TryParseHtmlString(hueHex, out tc)) hueOn = false;
else Color.RGBToHSV(tc, out th, out ts, out tv);
}
System.Func<Color, Color> hueOnly = c =>
{
if (!hueOn) return c;
float h, sv, v;
Color.RGBToHSV(c, out h, out sv, out v);
if (sv < 0.12f) return c;
var n = Color.HSVToRGB(th, Mathf.Clamp01(sv * ts * sat), Mathf.Clamp01(v * tv));
n.a = c.a;
return n;
};
System.Func<Color, Color> start = c =>
{
var n = hueOnly(c);
n.a *= alpha;
return n;
};
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var m = ps.main;
m.startColor = MapColors(m.startColor, start);
if (!hueOn) continue;
var col = ps.colorOverLifetime;
if (col.enabled) col.color = MapColors(col.color, hueOnly);
var cd = ps.customData;
if (cd.enabled)
foreach (var st in new[] { ParticleSystemCustomData.Custom1, ParticleSystemCustomData.Custom2 })
if (cd.GetMode(st) == ParticleSystemCustomDataMode.Color) cd.SetColor(st, MapColors(cd.GetColor(st), hueOnly));
var tr = ps.trails;
if (tr.enabled)
{
tr.colorOverLifetime = MapColors(tr.colorOverLifetime, hueOnly);
tr.colorOverTrail = MapColors(tr.colorOverTrail, hueOnly);
}
}
// 미리 채워 둔 입자(prewarm · 도는 구슬 고리 등)는 띄우는 순간 원래 색으로 이미 만들어져 있음(2026-11-11 실측: 보라로 바꾼 구슬이 파랑으로 보임)
// → 색을 바꾼 뒤 껐다 켜서 새 색으로 다시 채운다
bool prewarm = false;
if (hueOn)
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
if (ps.main.prewarm) prewarm = true;
if (prewarm && go.activeSelf)
{
go.SetActive(false);
go.SetActive(true);
}
foreach (var t in go.GetComponentsInChildren<TrailRenderer>(true)) t.colorGradient = MapGradient(t.colorGradient, start);
foreach (var l in go.GetComponentsInChildren<LineRenderer>(true)) l.colorGradient = MapGradient(l.colorGradient, start);
foreach (var sr in go.GetComponentsInChildren<SpriteRenderer>(true)) sr.color = start(sr.color);
}
static ParticleSystem.MinMaxGradient MapColors(ParticleSystem.MinMaxGradient g, System.Func<Color, Color> f)
{
switch (g.mode)
{
case ParticleSystemGradientMode.Color: return new ParticleSystem.MinMaxGradient(f(g.color));
case ParticleSystemGradientMode.TwoColors: return new ParticleSystem.MinMaxGradient(f(g.colorMin), f(g.colorMax));
case ParticleSystemGradientMode.Gradient: return new ParticleSystem.MinMaxGradient(MapGradient(g.gradient, f));
case ParticleSystemGradientMode.TwoGradients: return new ParticleSystem.MinMaxGradient(MapGradient(g.gradientMin, f), MapGradient(g.gradientMax, f));
default:
var res = new ParticleSystem.MinMaxGradient(MapGradient(g.gradient, f));
res.mode = g.mode;
return res;
}
}
static Gradient MapGradient(Gradient g, System.Func<Color, Color> f)
{
if (g == null) return g;
var ck = g.colorKeys;
var ak = g.alphaKeys;
float amul = f(Color.white).a; // 세기 배수(시작 색 전용 함수면 1 이 아님)
for (int i = 0; i < ck.Length; i++)
{
var c = f(new Color(ck[i].color.r, ck[i].color.g, ck[i].color.b, 1f));
ck[i].color = new Color(c.r, c.g, c.b, 1f);
}
if (Mathf.Abs(amul - 1f) > 1e-3f)
for (int i = 0; i < ak.Length; i++) ak[i].alpha *= amul;
var n = new Gradient { mode = g.mode };
n.SetKeys(ck, ak);
return n;
}
/// <summary>basic_&lt;병종&gt; 키(일반 슬링샷 공격 이펙트 · 2026-11-09 PD 시험 「보병 · 창 · 기병 슬링샷 공격에 WL 창 돌진 이펙트」).</summary>
public static string BasicKey(UnitType t)
{
return "basic_" + t.ToString().ToLowerInvariant();
}
static IEnumerator Timed(Row r, GameObject prefab, Unit u, Vector2 dir, Unit target, string evt, Handle h)
{
if (r.delay > 0f) yield return Fx.Wait(r.delay);
do
{
if (u == null || h.Stopped) yield break;
Spawn(r, prefab, u, dir, target, evt, h);
if (!(evt == EventTravel && r.every > 0f)) yield break;
yield return Fx.Wait(r.every);
} while (true);
}
static void Spawn(Row r, GameObject prefab, Unit u, Vector2 dir, Unit target, string evt, Handle into)
{
if (r.turn > 0f && u != null && u.View != null) u.View.SpinOnce(r.turn); // 이 행과 함께 유닛이 한 바퀴(f_turn)
bool onTarget = evt == EventHit || evt == EventPreHit;
string anchor = r.anchor.Length > 0 ? r.anchor : onTarget ? "target" : "feet";
Unit at = anchor == "target" && target != null ? target : u;
// 도착 이펙트는 이동이 끝나기 직전(논리 위치가 아직 출발점)에 나오므로 화면에 보이는 자리 기준
Vector2 pos = evt == EventArrive && at.transform != null ? (Vector2)at.transform.position : at.Position;
float h = at.ArtHeight > 0f ? at.ArtHeight : at.Radius * 2f;
if (anchor == "body" || anchor == "target") pos.y += h * 0.45f;
else if (anchor == "head") pos.y += h;
else if (anchor == "dash")
{
// 돌진(PD 2026-11-10 「복귀할 때 이펙트가 캐릭터보다 위쪽에 생겨 안 보임 → 유닛 바닥에 보이도록」): 위·옆으로 갈 때 = 몸 가운데 ·
// 아래로 갈수록 발 쪽으로(곧장 아래 = 발) — 뒤로 끌리는 빛이 머리 위가 아니라 몸·발 둘레에 오게
float down = dir.sqrMagnitude > 1e-6f ? Mathf.Max(0f, -dir.normalized.y) : 0f;
pos.y += h * 0.45f * (1f - down);
}
pos += new Vector2(r.dx, r.dy) * h;
Vector2 face = dir;
if (onTarget && target != null)
{
var d = target.Position - u.Position;
if (d.sqrMagnitude > 1e-4f) face = d.normalized;
}
if (Mathf.Abs(r.fwd) > 1e-4f && face.sqrMagnitude > 1e-6f) pos += face.normalized * (r.fwd * h); // 진행 방향 앞(+) · 뒤(−)
bool follow = r.follow == 1 || (r.follow < 0 && evt == EventTravel);
var go = SpawnPrefab(prefab, pos, r.scale * h, r.tilt, r.face ? (Vector2?)face : null, SortingBase + r.order, r.speed,
follow ? at.transform : null, r.flat);
if (r.over.Length > 0) // 이중 레이어: 지정한 층만 유닛 위(정렬 SortingBase · 유닛 0 · 이름 글자 21 사이)
foreach (var rd in go.GetComponentsInChildren<Renderer>(true))
if (System.Array.IndexOf(r.over, rd.gameObject.name) >= 0) rd.sortingOrder = SortingBase;
if (evt == EventTravel && r.sustain) Sustain(go);
if (Mathf.Abs(r.drift - 1f) > 1e-3f) ScaleSelfMotion(go, r.drift);
if (Mathf.Abs(r.height - 1f) > 1e-3f) ScaleHeight(go, r.height, false);
if (Mathf.Abs(r.top - 1f) > 1e-3f) ScaleHeight(go, r.top, true);
if (r.noFall) NoFall(go);
if (r.ground) GroundPlane(go);
TurnOff(go, r.off);
Recolor(go, r);
if (r.ramp != null) WrapAndRamp(go, r, float.MaxValue, 0f); // 금색 3단·테두리(감싸기는 반복 기운 전용)
if (r.cel) FxStyleLayer.Register(go, r.style);
if (r.lift && u.View != null && u.View.Anim != null) FxOwnerLift.Attach(go, u.View.Anim.Renderer);
float life = r.life > 0f ? r.life : (evt == EventTravel && follow) ? 0f : AutoLife(go);
if (r.life > 0f && r.fade > 0f && evt != EventTravel) SkillVfxFade.Begin(go, r.fade, Mathf.Max(0f, r.life - r.fade)); // f_life 끝 f_fade 초 동안 흐려지며 사라짐(2026-11-12 PD 서서 「피격 후 잔존하는 불타는 연출이 너무 길게」)
else if (life > 0f) Object.Destroy(go, life);
if (follow || (evt == EventTravel && (r.clear || r.fade > 0f))) into.Objects.Add(go); // 이동 끝(Stop)에 방출을 멈춤(따라가는 것은 떼어 놓음)
if (evt == EventTravel && r.fade > 0f) into.FadeOnStop[go] = r.fade;
else if (evt == EventTravel && r.clear) into.ClearOnStop.Add(go);
}
/// <summary>
/// 팩 3D 이펙트(위 = +Y · 정면 = +Z)를 2D 전장 화면에 놓는 회전(2026-11-09 PD 「돌진하는 동안 이펙트가 정상적으로 안 보임」 수정).
/// face 없음 = X 축 tilt°(0 = 옆모습 · −90 = 바로 위에서 본 모습).
/// face 있음 = 옆에서 본 모습으로 화면에 눕혀(정면 → 화면 진행 방향 · 위 → 화면 쪽 수직) 진행 방향으로 화면 안에서 돌린다 — 정면·위로 세운 판(찌르기 섬광 · 돌진 줄기)이
/// 어느 방향으로 가든 납작하게 보이지 않게(3D 그대로 두면 위쪽 돌진 때 판의 옆면만 보임 · 실측) · tilt = 진행 축을 중심으로 카메라 쪽으로 기울이는 각도(−90 = 위에서 본 모습 · 바닥 원이 보임) ·
/// 왼쪽으로 갈 때는 위아래가 뒤집히지 않게 반대로 돌림.
/// </summary>
/// <summary>
/// 프리팹 원본 루트 회전 r0 을 살린 화면 회전(2026-11-10 PD 「스크린샷 분석해서 다시 적용」 — MasterStylizedFX 투사체·Dash 는 루트에 (0, 90, 270) 같은 회전이 들어 있어
/// 덮어쓰면 혜성 판이 옆으로 서서 가늘게만 보임 · 실측): 팩 데모 세계에서 r0 로 놓인 이펙트의 진행 축(r0 · +Z 의 수평 성분)을 +Z 로 돌려 맞춘 뒤 FxRotation 을 건다.
/// 루트 회전이 0 인 사본(WL 창 돌진 등)은 FxRotation 과 같다.
/// </summary>
public static Quaternion FxRotation(float tilt, Vector2? face, Quaternion r0)
{
var fwd = r0 * Vector3.forward;
fwd.y = 0f;
var align = fwd.sqrMagnitude > 1e-6f ? Quaternion.Inverse(Quaternion.LookRotation(fwd.normalized, Vector3.up)) : Quaternion.identity;
return FxRotation(tilt, face) * align * r0;
}
public static Quaternion FxRotation(float tilt, Vector2? face)
{
if (!face.HasValue || face.Value.sqrMagnitude <= 1e-6f) return Quaternion.Euler(tilt, 0f, 0f);
var f = face.Value;
float ang = Mathf.Atan2(f.y, f.x) * Mathf.Rad2Deg;
float roll = Mathf.Abs(ang) > 90f ? 180f - tilt : tilt;
return Quaternion.Euler(0f, 0f, ang) * Quaternion.AngleAxis(roll, Vector3.right) * Quaternion.LookRotation(Vector3.right, Vector3.up);
}
/// <summary>2D 평면 이펙트 회전(b_flat): 정면 +X 를 진행 방향으로 화면 안에서만 돌림 · 방향 없음 = 그대로.</summary>
public static Quaternion FlatRotation(Vector2? face)
{
if (!face.HasValue || face.Value.sqrMagnitude <= 1e-6f) return Quaternion.identity;
return Quaternion.Euler(0f, 0f, Mathf.Atan2(face.Value.y, face.Value.x) * Mathf.Rad2Deg);
}
/// <summary>입자 자체 이동(시작 속도 · 속도 모듈)을 k 배로(f_drift).</summary>
static void ScaleSelfMotion(GameObject go, float k)
{
k = Mathf.Max(0f, k);
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var m = ps.main;
m.startSpeedMultiplier *= k;
var v = ps.velocityOverLifetime;
if (v.enabled) v.speedModifierMultiplier *= k;
}
}
/// <summary>
/// 바닥 충돌 판(b_ground): 장면 콜라이더와 충돌하도록 만든 층(World)을 이펙트 원점의 바닥면(이펙트 XZ 면 · 법선 = 이펙트 +Y)과 충돌하게 바꾼다 —
/// 기울기(f_tilt)를 주면 바닥면도 같이 기울어 비스듬히 내려다본 바닥이 됨 · 충돌 설정(수명 감소 · 하위 방출)은 팩 그대로.
/// </summary>
static void GroundPlane(GameObject go)
{
Transform plane = null;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var c = ps.collision;
if (!c.enabled || c.type != ParticleSystemCollisionType.World) continue;
if (plane == null)
{
plane = new GameObject("GroundPlane").transform;
plane.SetParent(go.transform, false);
}
c.type = ParticleSystemCollisionType.Planes;
c.SetPlane(0, plane);
}
}
/// <summary>떨어지는 움직임만 끔(b_nofall): 중력 0 · 수명 속도·힘의 아래 방향(Y 음수) 0 — 층·그림·수명은 그대로.</summary>
static void NoFall(GameObject go)
{
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var m = ps.main;
m.gravityModifier = new ParticleSystem.MinMaxCurve(0f);
var v = ps.velocityOverLifetime;
if (v.enabled) v.y = NoNegative(v.y);
var f = ps.forceOverLifetime;
if (f.enabled) f.y = NoNegative(f.y);
}
}
/// <summary>곡선·상수의 음수 부분을 0 으로(양수는 그대로).</summary>
static ParticleSystem.MinMaxCurve NoNegative(ParticleSystem.MinMaxCurve c)
{
switch (c.mode)
{
case ParticleSystemCurveMode.Constant:
return new ParticleSystem.MinMaxCurve(Mathf.Max(0f, c.constant));
case ParticleSystemCurveMode.TwoConstants:
return new ParticleSystem.MinMaxCurve(Mathf.Max(0f, c.constantMin), Mathf.Max(0f, c.constantMax));
case ParticleSystemCurveMode.Curve:
return new ParticleSystem.MinMaxCurve(c.curveMultiplier, ClampCurve(c.curve, c.curveMultiplier));
default:
return new ParticleSystem.MinMaxCurve(c.curveMultiplier, ClampCurve(c.curveMin, c.curveMultiplier), ClampCurve(c.curveMax, c.curveMultiplier));
}
}
static AnimationCurve ClampCurve(AnimationCurve src, float mult)
{
if (src == null) return AnimationCurve.Constant(0f, 1f, 0f);
var keys = src.keys;
for (int i = 0; i < keys.Length; i++)
{
if (keys[i].value * mult < 0f) keys[i].value = 0f;
keys[i].inTangent = 0f;
keys[i].outTangent = 0f;
}
return new AnimationCurve(keys);
}
/// <summary>세로 높이만 k 배: cut 거짓(f_height) = 시작 속도 × k(천천히 올라 간격도 좁아짐) · cut 참(f_top) = 오르는 입자의 수명 × k(속도·간격 그대로 · 그 높이에서 사라짐) ·
/// 공통 = 세운 메시 층의 길이(3D 크기 Z) · 세로로 긴 빛의 키(Y).</summary>
static void ScaleHeight(GameObject go, float k, bool cut)
{
k = Mathf.Max(0f, k);
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var m = ps.main;
if (!cut) m.startSpeedMultiplier *= k;
else if (m.startSpeed.constantMax > 1e-3f || m.startSpeed.mode == ParticleSystemCurveMode.Curve || m.startSpeed.mode == ParticleSystemCurveMode.TwoCurves)
m.startLifetimeMultiplier *= k;
var rd = ps.GetComponent<ParticleSystemRenderer>();
if (rd == null || !m.startSize3D) continue;
if (rd.renderMode == ParticleSystemRenderMode.Mesh) m.startSizeZMultiplier *= k; // 세운 메시(빛기둥)의 길이
else m.startSizeYMultiplier *= k; // 세로로 긴 빛(3D 크기 빌보드)의 키
}
}
/// <summary>WL WLStaffEarth.Sustain 과 같음 — 시간당 방출(초당 5 이상) · 버스트 없는 층만 반복으로(돌진 내내 이어짐 · 버스트 층은 처음 1번만).</summary>
static void Sustain(GameObject go)
{
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var em = ps.emission;
if (!em.enabled || em.rateOverTime.constantMax < 5f) continue;
bool burst = false;
for (int i = 0; i < em.burstCount; i++)
if (em.GetBurst(i).count.constantMax > 0f) burst = true;
if (burst) continue;
var m = ps.main;
m.loop = true;
}
}
/// <summary>
/// 프리팹 1개 띄우기(표 행 · 스킬 테스트 씬 이펙트 보기 공용). worldScale = 루트 배율 · 입자 크기 모드를 전부 Hierarchy 로(Local 이면 루트 배율이 안 먹음 · K-WL-325) ·
/// 트레일·선 굵기도 배율 · 렌더러 정렬 = order · 회전은 <see cref="FxRotation"/>.
/// </summary>
public static GameObject SpawnPrefab(GameObject prefab, Vector2 pos, float worldScale, float tilt, Vector2? face, int order, float speed, Transform follow,
bool flat = false)
{
Quaternion rot = flat ? FlatRotation(face) : FxRotation(tilt, face, prefab.transform.localRotation);
var go = Object.Instantiate(prefab, new Vector3(pos.x, pos.y, 0f), rot);
go.name = prefab.name;
float s = Mathf.Max(0.001f, worldScale);
go.transform.localScale = prefab.transform.localScale * s;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var m = ps.main;
m.scalingMode = ParticleSystemScalingMode.Hierarchy;
if (speed > 0f && Mathf.Abs(speed - 1f) > 1e-3f) m.simulationSpeed *= speed;
}
foreach (var tr in go.GetComponentsInChildren<TrailRenderer>(true)) tr.widthMultiplier *= s;
foreach (var lr in go.GetComponentsInChildren<LineRenderer>(true)) lr.widthMultiplier *= s;
foreach (var rd in go.GetComponentsInChildren<Renderer>(true)) rd.sortingOrder = order;
DisableSoftParticles(go);
if (follow != null) go.transform.SetParent(follow, true);
return go;
}
/// <summary>VFX_Klaus 셰이더 그래프(Hyper Casual · Shoot&amp;Hit) 「Use SoftParticleFactor?」 속성 참조 이름.</summary>
const string SoftParticleToggle = "Boolean_BB495B7B";
/// <summary>
/// 같은 「Use SoftParticleFactor?」 스위치의 셰이더별 참조 이름(2026-11-11 실측 · 이펙트 목록 렌더에서 258개가 안 보인 원인):
/// BB495B7B = HCFX_Particle_apb · 2ndColor · Shoot&amp;Hit_apb / 2FAC1FE4 = HCFX_Particle_add · Shoot&amp;Hit_add · Kyeoms 폭발 /
/// 52F3CBA5 = Fx_ParticleDissolve_add·apb(Earth Skills · Element Splash) / 9C0948F4 = Fx_dissolve_particle_apb.
/// </summary>
static readonly string[] SoftParticleToggles = { SoftParticleToggle, "Boolean_2FAC1FE4", "Boolean_52F3CBA5", "Boolean_9C0948F4" };
static readonly Dictionary<Material, Material> noSoftCache = new Dictionary<Material, Material>();
/// <summary>
/// 소프트 파티클 끄기(2026-11-10 실측): VFX_Klaus 셰이더 그래프의 「Use SoftParticleFactor?」 = 1 이면 장면 깊이(Scene Depth)로 투명도를 줄이는데
/// 이 게임은 직교 2D 카메라 + 깊이를 쓰지 않는 스프라이트라 입자가 생성·그려져도 화면에 색이 0(Hyper Casual 팩 전부 안 보임 · Lana 팩은 정상) →
/// 띄울 때 그 속성만 0 인 재질 복제본으로 바꿔 끼운다(원본 팩 재질 무수정 · 재질마다 1번 복제해 공유).
/// </summary>
static void DisableSoftParticles(GameObject go)
{
foreach (var r in go.GetComponentsInChildren<Renderer>(true)) // 입자 · 트레일 · 메시 전부(같은 재질을 메시 층도 씀)
{
var mats = r.sharedMaterials;
bool changed = false;
for (int i = 0; i < mats.Length; i++)
{
var m = mats[i];
if (m == null) continue;
Material v;
if (!noSoftCache.TryGetValue(m, out v) || v == null)
{
v = null;
foreach (var key in SoftParticleToggles)
{
if (!m.HasProperty(key) || m.GetFloat(key) < 0.5f) continue;
if (v == null) v = new Material(m) { name = m.name + " (no soft)" };
v.SetFloat(key, 0f);
}
if (v == null) continue;
noSoftCache[m] = v;
}
mats[i] = v;
changed = true;
}
if (changed) r.sharedMaterials = mats;
}
}
/// <summary>입자 길이(시작 지연 + 길이 + 최대 수명) 중 가장 긴 것 · 루프는 MaxAutoLife.</summary>
public static float AutoLife(GameObject go)
{
float best = 0.5f;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
var m = ps.main;
float sp = Mathf.Max(0.01f, m.simulationSpeed);
float t = m.loop ? MaxAutoLife : (m.startDelay.constantMax + m.duration + m.startLifetime.constantMax) / sp;
if (t > best) best = t;
}
return Mathf.Min(best, MaxAutoLife);
}
/// <summary>붙어 있던 이펙트(travel) 끝: 방출을 멈추고 떼어 놓은 뒤 남은 입자가 사라지면 지운다.</summary>
public static void Stop(Handle h)
{
if (h == null) return;
h.Stopped = true; // 반복(f_every) 멈춤
foreach (var kv in h.FadeOnStop)
{
var go = kv.Key;
if (go == null) continue;
go.transform.SetParent(null, true); // 이동이 끝난 자리에 남아 흐려짐
SkillVfxFade.Begin(go, kv.Value);
h.Objects.Remove(go);
}
h.FadeOnStop.Clear();
foreach (var go in h.ClearOnStop)
{
if (go == null) continue;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true)) ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
h.Objects.Remove(go);
Object.Destroy(go); // WL ClearEnd — 돌진 끝 = 이펙트 끝
}
h.ClearOnStop.Clear();
Stop(h.Objects);
}
/// <summary>반복 기운·상태 이상(aura · status)이 끝날 때 흐려지는 시간(행 f_fade) — 유닛에 붙은 채 이 초 동안 흐려진 뒤 지움.</summary>
static readonly Dictionary<GameObject, float> loopFade = new Dictionary<GameObject, float>();
public static void Stop(List<GameObject> list)
{
if (list == null) return;
foreach (var go in list)
{
if (go == null) continue;
float fadeSec;
if (loopFade.TryGetValue(go, out fadeSec))
{
// 2026-11-11 실측: 모든 층 반복(b_loopall)인 구슬 고리는 입자 수명이 길어 공격이 발동된 뒤에도 몇 초 남음 → 붙은 채 짧게 흐려져 사라짐
loopFade.Remove(go);
SkillVfxFade.Begin(go, fadeSec);
continue;
}
go.transform.SetParent(null, true);
float rest = 0.2f;
foreach (var ps in go.GetComponentsInChildren<ParticleSystem>(true))
{
ps.Stop(true, ParticleSystemStopBehavior.StopEmitting);
rest = Mathf.Max(rest, ps.main.startLifetime.constantMax / Mathf.Max(0.01f, ps.main.simulationSpeed));
}
foreach (var tr in go.GetComponentsInChildren<TrailRenderer>(true))
{
tr.emitting = false;
rest = Mathf.Max(rest, tr.time); // 꼬리가 제 길이만큼 줄어 사라질 때까지(IB 속도 꼬리 0.6초 · 2026-11-10)
}
Object.Destroy(go, Mathf.Min(rest, MaxAutoLife));
}
list.Clear();
}
}
}