using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using UnityEngine;
namespace TKS
{
///
/// 스킬 이펙트(VFX) 재생 — WL 방식(2026-11-09 PD 「WL 에서 스킬을 구현하던 방식과 동일하게 유닛별 스킬 구현」):
/// 값 = 표 Resources/Skills/skill_vfx.csv(코드 상수 없음 · C45) · 이펙트 = 팩 프리팹의 사본 Resources/Fx/TKS_Fx_*.prefab
/// (원본 팩 Assets/VFX/** 는 고치지 않는다 · WL 의 WL_Fx_* 사본과 같은 규칙).
/// 키 = 스킬 id(skills.csv · 액티브) 또는 basic_<병종>(일반 슬링샷 공격 · 이동만인 추가 이동 제외).
/// 이벤트 = cast(액티브 발동 · 예약 스킬은 슬링샷 출발 순간 · 즉시형은 버튼) · travel(슬링샷 돌진 동안 · 따라가거나 f_every 마다 다시 띄움 · 끝나면 방출 멈춤) ·
/// hit(행동 중인 유닛이 상대에게 피해를 준 순간 · 대상마다 1번).
/// 표 다시 읽기 = 전투 시작마다(스킬 테스트 씬 「다시 배치」) · .
/// 가상 실행(Sim.Active · 적 AI 예측) 중에는 아무것도 띄우지 않는다.
///
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";
///
/// 돌진이 적에게 닿기 직전(대상마다 · 앵커 기본 target · 방향 = 시전자 → 대상) — 이 행의 f_delay = 닿는 순간보다 몇 초 앞에 띄울지(빈칸 = 닿는 순간 ·
/// 접근이 그보다 짧으면 바로). 보병 돌진 첫 충돌 · 튕김 연쇄 충돌(ActionResolver.PreHit · PD 2026-11-12 주창 「적과 닿기 직전 적에게 베기」).
///
public const string EventPreHit = "prehit";
// 2026-11-10 연출 2차(새 기획 #1112 스킬 72 · PD 「재정리부터 시작」): 투사체 · 폭발 · 지대 · 지속 기운 · 상태 이상 · 회복
/// 특수·일반 사격의 투사체(시전자 → 도착점 · 비행 시간 = Fx.ArrowDuration · 피해 시점 그대로) — 행이 없으면 기존 선 화살.
public const string EventShot = "shot";
/// 광역 중심(즉시 광역 · 폭발 사격 · 목책 칸) — 크기 단위 = 그 광역 반경(f_scale 1 = 반경).
public const string EventBlast = "blast";
/// 투사체가 끝난 자리(명중 대상 또는 최대 사정거리 도달 위치) 1번 · 행 = Blast 와 같은 방식(크기 = 광역 반경 × f_scale) · PD 2026-11-13 손건 「하트는 피격 대상이나 최대 사정거리 도달 위치에」.
public const string EventLand = "land";
/// 즉시형 스킬의 범위 시한 효과(버프)를 받은 대상마다 시전 순간 1번(미축 행진가 · PD 2026-11-13 「효과 범위 내 모든 아군에게 발생」).
public const string EventBuff = "buff";
/// 스킬 지대(불꽃 · 불 장벽 · 독지대)가 남아 있는 동안 반복 — 크기 단위 = 지대 반경 · 선분 지대는 f_every(반경 배수 · 빈칸 1.6) 간격으로 여러 개.
public const string EventZone = "zone";
/// 그 스킬 효과가 유닛에 남아 있는 동안 반복(예약 대기 · 시한 효과 대상 · SkillVfxLoops).
public const string EventAura = "aura";
/// 상태 이상이 걸려 있는 동안 반복(키 status_stun · status_confuse · status_bleed · status_poison · status_burn · SkillVfxLoops).
public const string EventStatus = "status";
/// 회복 받은 순간(키 common · 모든 회복 공통).
public const string EventHeal = "heal";
/// 그 스킬로 재행동 기회가 생긴 순간 1번(유비 이도류 검법 등 · SkillSystem.EndAction · PD 2026-11-10).
public const string EventReact = "react";
///
/// 실제 이동을 시작한 자리 1번(depart) · 이동이 끝난 자리 1번(arrive) — 돌진하지 않는 궁병의 이동(ActionResolver.ArcherRoutine ·
/// PD 2026-11-11 「황충 이동 시 최초 이동 때와 도착할 때 먼지 연출」) · 제자리 사격에는 나오지 않는다.
///
///
/// 효과 대상마다 그 자리에 내려오는 연출(drop) — 즉시형 회복이 대상에게 닿기 전(PD 2026-11-11 제갈량 「스킬 범위 내 유닛에게 빛 덩어리가 내려와 퍼지는 연출과 함께 … 회복」):
/// 행의 f_delay 뒤에 시작 · f_wait(초) = 효과(회복)를 적용할 시점 — 가 가장 긴 f_wait 를 돌려주고 스킬 쪽이 그만큼 기다린 뒤 회복한다.
///
public const string EventDrop = "drop";
///
/// 레이저(beam · shot_laser · 2026-11-12 PD 태사자): 쏜 유닛 자리에서 조준 방향으로 눕혀 띄움(프리팹 위 +Y = 진행 방향 · 원점 = 쏜 자리) ·
/// 크기 = 역순 줄(b_rev · 빛 기둥) f_scale × 레이저 길이 · 나머지 줄(쏜 자리 섬광·연기) f_scale × 유닛 키 · f_wait = 띄운 뒤 피해를 주는 시점(가장 긴 값) — .
///
public const string EventBeam = "beam";
public const string EventDepart = "depart";
public const string EventArrive = "arrive";
/// 장수 전용 일반 행동 키(hero_<장수 id>) — 스킬을 장착하지 않은 슬링샷에서 basic_병종 행에 더해짐(기본 공격 화살 · 이동 먼지).
public static string HeroKey(string heroId)
{
return string.IsNullOrEmpty(heroId) ? null : "hero_" + heroId.ToLowerInvariant();
}
public const string CommonKey = "common";
///
/// 시험 키(스킬 테스트 씬 「기운 시험」 스위치 · PD 2026-11-10 「몸을 뒤덮는 연출을 스킬용으로 시험」): 비어 있지 않으면 슬링샷 공격 돌진(travel) 때
/// 이 키의 행(표 test_aura 등)을 함께 띄운다 · 실제 전투는 늘 빈칸.
///
public static string TestTravelKey = "";
/// 정렬 순서 기준(화살 8 · 광역 7 · 스킬 이름 글자 21 · 유닛 0 위) — 행 n_order 를 더한다.
public const int SortingBase = 12;
public class Row
{
/// 키 원문(s_skill · ; 로 여러 개 = 그중 하나와 같으면 해당).
public string skill = "";
public string[] keys = new string[0];
/// 진영(s_camp · shu · wei · wu · other) — 빈칸 = 모든 진영 · 유닛 진영이 빈칸(적 병사 등)이면 other 로 본다.
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 = "";
/// feet(발) · body(몸 가운데) · head(머리 끝) · target(피격 대상 몸 가운데 · hit 기본).
public string anchor = "";
/// 유닛 머리 끝 높이(ArtHeight) 대비 크기 — 1 = 팩 원본 1 단위를 유닛 키로.
public float scale = 1f;
public float delay;
/// 0 = 입자가 다 사라질 때까지(최대 MaxAutoLife).
public float life;
/// 기울기(°) · 0 = 옆에서 본 모습 · −90 = 위에서 내려다본 모습(바닥 원·충격파) · face 행은 진행 축을 중심으로 카메라 쪽으로 기울임().
public float tilt;
/// true = 이펙트 정면(+Z)을 진행 방향(cast·travel = 슬링샷 방향 · hit = 때린 쪽 → 대상)으로 화면 안에서 돌림(투사체·베기·돌진).
public bool face;
/// travel 전용 · WL sustain = 시간당 방출 층(버스트 없는 층)을 반복으로 바꿔 돌진 내내 유지(버스트 층은 처음 1번).
public bool sustain;
/// travel 전용 · WL ClearEnd = 돌진이 끝나는 순간 남은 입자까지 지움(0 = 방출만 멈추고 남은 입자는 수명대로).
public bool clear;
/// 입자 자체 이동 배율(시작 속도 · 속도 모듈) — 1 = 팩 원본 · 0.1 = 거의 제자리(스스로 앞으로 날아가는 데모용 돌진 이펙트를 유닛에 붙여 감싸게 · MasterStylizedFX Dash).
public float drift = 1f;
/// 진행 방향 기준 위치 보정(유닛 키 배수 · + 앞 · − 뒤) — 예: 돌진 잔상(Dash)을 캐릭터 뒤쪽에(f_fwd).
public float fwd;
/// travel 전용 · 슬링샷 이동이 끝날 때 그 자리에서 이 초 동안 흐려지며 사라짐(f_fade · 0 = b_clear/방출만 멈춤 규칙 · b_clear 보다 우선).
public float fade;
/// 유닛 위에 그릴 자식 층 이름(s_over · ; 로 여러 개) — 나머지 층은 n_order 그대로(이중 레이어 · 예: 혜성 머리 실드만 캐릭터 앞 · PD 2026-11-10).
public string[] over = new string[0];
///
/// 끌 자식 층 이름(s_off · ; 로 여러 개 · 끝에 * = 그 글자로 시작하는 층 전부 · @root = 뿌리 층) — 그 층만 방출·그리기를 끔(다른 층은 그대로 · 사본·팩 원본 무수정).
/// PD 2026-11-11 「스킬 공격에 피격 시 먼지 발생되는 이펙트는 제거」 = hit·blast 행의 먼지·연기 층(dust* · smoke* · clouds).
///
public string[] off = new string[0];
///
/// 몸 감싸기 층(s_wrap · ; 로 여러 개 · 반복 기운 전용 · PD 2026-11-11 「캐릭터 주위를 확실히 휘감는 느낌 · 금줄이 화려하게 유닛을 감싸는 형태」):
/// 팩의 고리·줄기 메시 층을 같은 씨앗의 두 벌로 나눠 카메라에 가까운 반 = 유닛 위 층 · 먼 반 = 유닛 아래 층(n_order) — 줄기가 몸 앞을 지나 뒤로 돌아감
/// (자르는 경계선 없음 · 셰이더 TKS/FxPackHalf 의 면 고르기). f_wrap(사각 마스크로 위아래를 나누던 옛 방식)과 다름.
///
public string[] wrapLayers = new string[0];
/// 감싸기 층의 방출 배수(s_wrap 에 「층 이름*배수」 · 빈칸 1) — 금줄을 더 촘촘히(두 벌에 똑같이 적용).
public float[] wrapRate = new float[0];
/// 층별 방출 배수(s_rate · 「층 이름*배수」 · @root = 뿌리 층 · 반복 이펙트 전용 · 감싸기와 무관).
public string[] rateLayers = new string[0];
public float[] rateMult = new float[0];
///
/// 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 관평 진).
///
public string[] ramp;
///
/// 2D 평면 이펙트(b_flat · PD 2026-11-10 「돌진 이펙트가 너무 3D 느낌 → 2D 처럼」): 진행 방향으로 화면 안에서만 돌림(Z 축) · f_tilt 와 팩 루트 회전 무시 ·
/// 프리팹은 화면 평면에 그린 셀 그림(정면 = +X · Assets/VFX/TKS2D).
///
public bool flat;
/// 반복(aura·status·zone) 때 모든 층을 반복(b_loopall 1) — 빈칸 = 원래 반복인 층만 남기고 한 번 터지는 층은 끔(큰 섬광 방지).
public bool loopAll;
///
/// 몸 감싸기(f_wrap · 반복 기운 전용 · PD 2026-11-11 「상반신은 이펙트보다 위 · 하반신은 아래 · 몸 주위를 둘러싼 느낌」): 0 보다 크면 같은 씨앗의 두 벌을 띄워
/// 발 ~ 발 + 키 × f_wrap(하반신) 안은 캐릭터 앞 · 그 위(상반신)는 캐릭터 뒤 — 사각 SpriteMask 로 나눔 · 0 = 한 벌(n_order 그대로).
///
/// s_wrap(팩 층 면 나누기)과 함께 쓰면 뜻이 바뀜: 그림 발에서 키 × f_wrap 높이까지만 줄기가 몸 앞으로 지나가고 그 위(얼굴)는 머리 뒤로 지나감(마스크 없음 · 부드럽게 넘어감).
public float wrap;
///
/// 화풍 층(b_cel 1 · PD 2026-11-11 「게임 화풍을 고려해 색감·질감·라이팅 조정」): 이 행의 이펙트를 로 그린다
/// (면 2~4단 · 무광 색 · 먹선 외곽선 · 값 = fx_style.csv) · 빈칸 = 팩 원본 그대로.
///
public bool cel;
/// 투사체 비행 속도 배수(f_fly · shot 행 · 빈칸 1 · 여러 행이면 가장 큰 값) — 비행 시간 = 기본 시간 ÷ 배수(피해 시점도 그만큼 빨라짐).
public float fly = 1f;
/// 효과 적용까지 기다리는 시간(f_wait · 초 · drop 행 · 빈칸 0).
public float wait;
/// 레이저(beam) 역순(b_rev · 2026-11-12 PD 태사자 「내려치는 형태가 아니라 역순 = 태사자에게서 발사」): 원점을 먼 끝에 두고 뒤집어 놓음 — 먼 끝에서 쏜 자리로 내려치는 빛 기둥이 쏜 자리에서 먼 끝으로 뻗어 나감.
public bool rev;
///
/// 바닥 충돌 판(b_ground · 2026-11-13 PD 주유 「명중 시 넓은 범위에 운석이 여러 개 떨어지며」): 팩 이펙트 중 「떨어진 입자가 바닥(3D 콜라이더)에 닿으면 터지는」 것은
/// 이 게임(2D · 바닥 콜라이더 없음)에서 입자가 그대로 지나가 충돌 이펙트가 안 나옴 → 이펙트 원점의 바닥면(이펙트의 XZ 면)을 충돌 판으로 넣는다(Hyper Casual Vol.2 HCFX_Meteor_*).
///
public bool ground;
/// 유닛 제자리 한 바퀴(f_turn · 초 · 2026-11-13 PD 21차 손상향 「이펙트와 함께 유닛을 한바퀴 회전」): 이 행이 나오는 순간 그 유닛 그림이 이 시간 동안 한 바퀴 돈다(UnitView.SpinOnce · 0 = 없음).
public float turn;
/// 레이저(beam) 빛 기둥 굵기 배수(f_wide · 늘인 판 층의 가로 크기 · 길이는 그대로 · 2026-11-12 PD 태사자 「너무 직선 형태의 선 같아」).
public float wide = 1f;
/// 까딱임(s_wobble 「각도*주기」 · 반복 이펙트의 입자를 좌우로 각도만큼 기울였다 돌아옴 · 빈칸 = 없음 · PD 2026-11-13 혼란 물음표).
public float wobbleDeg, wobbleSec = 1f;
/// 화풍 층 변형 이름(s_style · b_cel 1 인 유닛 아래 이펙트 전용 · fx_style.csv 의 「키@변형」 값을 씀 · 빈칸 = 기본 값).
public string style = "";
///
/// 쓴 유닛 올리기(b_lift 1 · PD 2026-11-11 「공격 이펙트는 몬스터보다 상단에 배치」): 이 이펙트를 다른 유닛 위(n_order −2 이하)에 그리고
/// 이펙트가 살아 있는 동안 쓴 유닛의 그림만 그 위로 올린다() — 적은 덮되 쓴 캐릭터는 가리지 않게.
///
public bool lift;
///
/// 원본 세기 배수(f_alpha · 입자 시작 색 불투명도 · 빈칸 1) — 낮추면 옅어짐 · 화풍 층에서는 몸(단색 면) 대신 옅은 테로 그려짐
/// (유닛을 가리는 빛 기둥·막을 반투명하게).
///
public float alpha = 1f;
///
/// 색 바꾸기(s_hue · #RRGGBB 로 물들임: 색상 = 그 색 · 채도·밝기 = 원본 × 그 색의 채도·밝기 → 원본이 순색이면 딱 그 색 ·
/// 무채색(흰 심·연기 · 채도 0.12 미만)은 그대로) — 진영색·스킬 컨셉 색 · 띄운 것에만 적용(사본·팩 원본 무수정).
///
public string hue = "";
/// 바꾼 색의 채도 배수(f_sat · 빈칸 1 · s_hue 가 있을 때만).
public float sat = 1f;
/// 1 = 유닛을 따라다님 · 0 = 생긴 자리에 남음 · −1(빈칸) = 기본(travel 따라감 · 그 밖 남음).
public int follow = -1;
public float speed = 1f;
/// 세로 높이 배율(f_height · 빈칸 1 · PD 2026-11-11 「재행동 이펙트가 캐릭터 키보다 너무 높게 재생 → 키 높이에 맞게」): 위로 오르는 시작 속도 × k ·
/// 세워 놓은 메시 층(3D 크기)의 길이(Z) × k · 세로로 긴 빛(3D 크기 빌보드)의 세로(Y) × k — 고리가 오르는 높이와 빛기둥·뒷빛 키만 줄이고 가로 크기는 그대로.
public float height = 1f;
/// 높이 자르기 배율(f_top · 빈칸 1 · PD 2026-11-11 「재행동 이펙트 높이가 낮아지면서 나선형 간격이 너무 좁아짐 → 간격을 높이 조절 전처럼」):
/// 위로 오르는 입자의 수명 × k = 원래 속도·간격 그대로 오르다 그 높이에서 사라짐(f_height 는 속도를 줄여 간격까지 같이 좁아짐) ·
/// 세운 메시 층 길이(Z)·세로로 긴 빛(Y) × k 는 f_height 와 같음.
public float top = 1f;
/// 떨어지는 움직임 끔(b_nofall · PD 2026-11-11 「출혈 — 기존 프레임을 삭제하라는 지시가 아니라 낙하하는 이펙트만 제거」): 층은 그대로 두고
/// 중력 0 · 아래로 가는 속도(수명 속도·힘의 Y 음수)만 0 — 튀어 오른 그림이 떨어지지 않고 제자리에서 녹아 사라짐.
public bool noFall;
/// 방사 범위(s_radial = 「시작;끝」 · 광역(blast) 행 전용 · 스킬 반경 배수 · PD 2026-11-11 「방사형 이펙트는 캐릭터를 중심으로 스킬 범위까지만 · 가장자리로 갈수록 점차 투명」):
/// 중심에서 반경 × 시작부터 옅어져 반경 × 끝에서 완전히 투명 — 재질을 TKS/FxPackHalf 로 바꿔 그림(지원 재질만).
public Vector2 radial;
public bool hasRadial;
/// 끝날 때까지 남길 층(s_hold · ; 여러 개 · 반복 이펙트 전용 · PD 2026-11-11 「기절 = 머리 위 별이 효과 지속시간 동안 계속 표시」): 한 번 내는 입자(큰 별 3개)를
/// 수명이 다해도 사라지지 않게 유지 — 반복 규칙이 「한 번 터지는 층」으로 보고 끄던 층을 살린다(끝 = f_fade 로 흐려짐).
public string[] hold = new string[0];
public float dx;
public float dy;
public int order;
/// travel 전용: 0 보다 크면 돌진하는 동안 이 간격(초)마다 다시 띄움(WL 창 돌진 감싸기 0.3 · 흙먼지 0.15).
public float every;
}
/// travel 이펙트 묶음(행동 끝에 Stop) — 따라다니는 것만 담는다(남는 것은 제 수명대로).
public class Handle
{
public readonly List Objects = new List();
/// Stop 때 남은 입자까지 지울 것(b_clear).
public readonly HashSet ClearOnStop = new HashSet();
/// Stop 때 그 자리에서 흐려지며 사라질 것(f_fade 초).
public readonly Dictionary FadeOnStop = new Dictionary();
public bool Stopped;
}
/// life 0 일 때 입자 길이 상한(초) — 루프 입자가 끝없이 남지 않게.
public const float MaxAutoLife = 6f;
static List rows;
static readonly Dictionary prefabCache = new Dictionary();
public static void Reload()
{
rows = null;
prefabCache.Clear();
FxStyleLayer.Reload();
SkillVfxLoops.Ensure();
}
public static IReadOnlyList Rows
{
get
{
Ensure();
return rows;
}
}
static void Ensure()
{
if (rows != null) return;
rows = new List();
var ta = Resources.Load(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;
}
/// 따옴표를 아는 CSV 한 줄 나누기(스킬 테스트 씬 표도 사용).
public static string[] SplitCsv(string line)
{
var res = new List();
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(FxFolder + name);
if (p == null) Debug.LogWarning("[TKS] 스킬 이펙트 사본 없음: Resources/" + FxFolder + name + " (skill_vfx.csv s_fx)");
prefabCache[name] = p;
return p;
}
///
/// 표의 (키, 이벤트) 행을 모두 띄운다. 키 = 스킬 id(skills.csv) 또는 basic_<병종>(일반 슬링샷 공격 · infantry · spear · cavalry · archer · strategist).
/// dir = 진행 방향(face) · target = hit 대상. 반환 = travel 정지용 묶음(지연·반복 행은 나중에 생김).
///
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;
}
/// 닿기 직전 행(prehit)을 띄운다 — eta = 지금부터 target 에 닿기까지 남은 초 · 행마다 (eta − f_delay) 초 뒤(음수면 바로).
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;
}
/// 지금 행동 중인 유닛의 표 키(예약·시전 스킬 id · basic_병종) — 행동 중이 아니면 null.
static List KeysOf(Unit u)
{
var sys = SkillSystem.Current;
return sys != null ? sys.VfxKeysOf(u) : null;
}
/// 점 위치에 행 1개(투사체·폭발·지대 공용 · 이중 레이어 s_over 반영).
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(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;
}
/// 표 s_off 에 적힌 자식 층을 끈다(방출·그리기만 · 그 아래 층은 그대로) — 이름이 같거나, 끝이 * 이면 그 글자로 시작하는 층.
static void TurnOff(GameObject go, string[] off)
{
if (off == null || off.Length == 0) return;
foreach (var t in go.GetComponentsInChildren(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();
if (ps != null)
{
var em = ps.emission;
em.enabled = false;
ps.Clear(false);
}
var rd = t.GetComponent();
if (rd != null) rd.enabled = false;
}
}
///
/// 남아 있는 동안 반복(지대 · 기운 · 상태 이상): 원래 반복인 층이 있으면 그 층만 남기고 한 번만 터지는 층(시작 섬광 · 큰 빛기둥)은 끈다
/// (2026-11-10 실측: 가속 오라의 섬광 층 glow·area 를 반복시키면 화면을 덮는 빛기둥 · 시작 섬광은 cast 행이 맡음) ·
/// 반복 층이 하나도 없는 프리팹(핏방울 · 독 거품)은 전체를 반복.
///
static void ForceLoop(GameObject go, bool loopAll = false, string[] hold = null)
{
var all = go.GetComponentsInChildren(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);
}
}
/// 유지 층의 수명(초) — 상태 이상·기운이 가장 오래 남는 시간보다 충분히 길게.
const float HoldLife = 600f;
///
/// 층의 입자를 끝날 때까지 유지(s_hold): 수명을 HoldLife 로 늘리고, 수명 비율로 적힌 값(수명 크기 곡선 · 수명 색 · 꼬리 길이)은 원래 초 단위가 되게 앞쪽으로 당긴다
/// (그대로 두면 처음 0.5초에 커지던 별이 1분에 걸쳐 커지고 꼬리가 끝없이 길어짐). 끝부분의 사라지는 구간은 버림 — 끝은 f_fade 가 맡음.
///
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();
var nak = new List();
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); // 꼬리 길이 = 입자 수명 대비 비율
}
/// 수명 곡선의 앞 절반(나타나는 구간)만 시간축을 k 배로 당기고, 그 뒤는 마지막 값으로 유지.
static AnimationCurve Squeeze(AnimationCurve src, float k)
{
if (src == null) return AnimationCurve.Constant(0f, 1f, 1f);
var keys = new List();
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());
}
/// 방출 곡선의 한 주기 평균(초당 · 상수 = 그 값 · 곡선 = 16칸 평균 × 배수).
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;
}
/// 팩 HCFX apb 재질의 그림 속성 이름(셰이더 그래프 참조 이름) — 이 속성이 있는 재질만 감싸기·금색 입히기 대상.
const string PackMainTex = "Texture2D_F593E37E";
/// Namu 「Simple Stylized Slash」 셰이더 그래프(SH_Master_improved)의 그림 속성 이름 — 흰 모양 플립북 시트(셰이더 _Mode 1 = 모양 시트 방식).
const string ShapeMainTex = "Texture2D_3df04dddeab4420c8fa2aaeef72bcb87";
/// Element Splash 계열 셰이더 그래프(Fx_dissolve_particle_apb)의 그림 속성 이름(셰이더 _Mode 2).
const string DissolveMainTex = "Main_tex";
const string EricMainTex = "_MainTex";
/// 금색 3단·테두리(TKS/FxPackHalf)로 바꿀 수 있는 재질이면 그 그림 속성 이름 · 아니면 null.
/// 더하기(빛) 재질도 3단 색으로 바꿀지(s_ramp 열셋째 값 1 · 빈칸 = 안 바꿈) — 황토색 바닥에서 하얗게 날아가는 불덩이를 또렷하게(2026-11-11 제갈량 기본 공격 FX_Shoot_05).
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 packHalfCache = new Dictionary();
/// 팩 재질 → 면 고르기·금색 3단 재질(TKS/FxPackHalf) · cull 0 = 전부 · 1 = 먼 반 · 2 = 가까운 반 · 같은 조합은 1개만 만들어 공유.
///
/// 색 단 경계 폭(s_ramp 열째 값 · 빈칸 0.12) — 크게 주면 테 색 → 몸 색 → 심 색이 띠로 끊기지 않고 부드럽게 이어짐
/// (2026-11-11 PD 「색감이 너무 쨍한 원색 계열 · 라이팅을 조금 부여해서 부드러운 색감」 = 조운 바닥 빛).
///
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(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;
}
///
/// 몸 감싸기(s_wrap) + 금색 입히기(s_ramp): 감싸기 층은 같은 씨앗의 복제 층을 하나 더 만들어 원래 층 = 먼 반(유닛 아래 · n_order) · 복제 층 = 가까운 반(유닛 위) ·
/// 좌우 뒤집기(flip)는 끔(뒤집힌 입자는 면 방향이 반대라 가까운 반·먼 반이 바뀜) · 그 밖의 팩 메시 층은 색만 입힘. ForceLoop 앞에 부른다(두 층이 같은 방출·같은 입자).
/// face = 얼굴 높이(기준점에서 위로 · 월드 단위 · float.MaxValue = 없음) — 그 위로는 가까운 반도 유닛 아래 벌이 그림(머리 뒤로 지나감 · band = 넘어가는 띠 반폭).
///
static void WrapAndRamp(GameObject go, Row r, float face, float band)
{
uint seed = (uint)Random.Range(1, int.MaxValue / 2);
var faceRds = new List();
foreach (var rd in go.GetComponentsInChildren(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().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();
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(), dup.GetComponent() })
{
ps.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
ps.useAutoRandomSeed = false;
ps.randomSeed = seed;
}
}
if (faceRds.Count > 0) go.AddComponent().Set(faceRds.ToArray(), face - band, face + band);
}
///
/// 투사체(shot): 행동 중 유닛의 키에 shot 행이 있으면 시전자 → 도착점으로 날린다(비행 시간 = · 피해 시점 그대로) ·
/// 행이 없으면 기존 선 화살(fallback 색). 기준점 = body(기본 · 몸 높이로 날아감) | feet.
///
public static IEnumerator Shot(Unit u, Vector2 from, Vector2 to, Color fallback, float duration = 0f)
{
var list = new List();
var starts = new List();
var leads = new List(); // f_fwd 행 = 출발할 때만 진행 방향 앞에서 시작(거대 화살의 꼬리가 쏜 유닛 뒤로 튀어나오지 않게) · 날아가며 0 으로 줄어 도착점은 그대로
float fly = 1f; // 비행 속도 배수(f_fly · 가장 큰 값)
var lives = new List(); // f_life 행 = 도착한 뒤 이 초만 남기고 통째로 지움(꼬리·줄기·반짝이까지 · 아주 작은 값 = 명중 뒤 아무것도 남기지 않음 · 2026-11-11 PD 제갈량 「피격 후 이펙트도 제거」)
var clears = new List(); // 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(true))
{
if (ps.main.loop) continue;
ps.Stop(false, ParticleSystemStopBehavior.StopEmittingAndClear);
var prd = ps.GetComponent();
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);
}
///
/// 레이저(beam): 행동 중 유닛 키의 beam 행을 쏜 자리(body = 몸 높이 · feet)에서 to 쪽으로 눕혀 띄우고 행의 f_wait 만큼 기다린다(그 뒤 호출 쪽이 경로 위 전원에 동시 피해) ·
/// 판 회전(b_flat)에 진행 방향의 오른쪽 수직을 넘겨 프리팹 위(+Y)가 진행 방향을 향하게 · 행이 없으면 기존 선 화살(fallback 색).
///
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(); // f_every 줄 = 레이저를 따라 띄움(앞머리 시간을 안 뒤에)
var alongFx = new List();
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(true))
{
var pr = ps.GetComponent();
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);
}
///
/// 레이저를 따라 띄우는 줄(beam · f_every = 간격(유닛 키 배수) · 2026-11-12 PD 태사자 「주변이 일렁이는 푸른 불꽃 · 전기 효과」):
/// 쏜 자리에서 간격마다 · 앞머리가 그 자리를 지나는 순간(앞머리 시간 × 거리 비율 + f_delay) · 크기 = f_scale × 유닛 키 · 진행 방향을 바라봄.
///
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));
}
}
/// 늘인 판 층의 세로 크기 곡선(크기 · 수명 · y)이 처음 최대에 닿는 시각 × 수명 ÷ 재생 속도 = 빛 기둥이 다 뻗는 시간(곡선이 없으면 0).
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;
}
/// 레이저 빛 기둥의 최대 입자 크기(화면 비율 · 유니티 기본 5 → 전장 끝까지 늘인 기둥이 잘리지 않을 만큼).
const float BeamMaxParticleSize = 100f;
/// 폭발(blast): 행동 중 유닛 키의 blast 행을 광역 중심에 · 크기 = 반경 × f_scale · 반환 = 띄운 것이 있음(있으면 호출 쪽이 납작한 원 Fx.Burst 를 생략).
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(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));
}
/// 지대(zone): 그 키의 zone 행을 선분 a→b 위에 간격(f_every × 반경 · 빈칸 1.6)으로 · 반복 · parent(지대 그림) 밑에 두어 지대가 사라지면 함께 사라짐.
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);
}
}
}
/// 회복 등 대상 유닛 자체에 1번(키 · 이벤트 · 기준점 = 행 anchor · 기본 body).
///
/// 대상마다 내려오는 연출(drop 행)을 띄우고, 효과를 적용할 시점(가장 긴 f_wait · 초)을 돌려준다(행이 없거나 시뮬레이션이면 0 = 바로 적용).
///
public static float Drop(IEnumerable 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;
}
///
/// 그 스킬 heal 행의 가장 긴 f_wait(초) = 시전 연출이 재생된 뒤 회복(숫자·이펙트)을 적용할 시점(행이 없거나 시뮬레이션이면 0 = 바로 · PD 2026-11-13 방통 「연출이 재생된 후 회복 효과」).
///
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;
}
/// 머리 위 표시(e_anchor head)의 기준 키 = 유닛 키와 「기마 그림 머리 끝 한도」(걸어 다니는 유닛 키쯤) 중 작은 값 — 기병도 보병과 같은 크기·같은 간격으로 뜸.
static float HeadRef(Unit u)
{
float h = UnitH(u);
return u.MountedArtMaxTop > 0f ? Mathf.Min(h, u.MountedArtMaxTop) : h;
}
/// 기운·상태 이상 반복(SkillVfxLoops): 유닛에 붙여 반복 재생 · 반환 = 띄운 것(없으면 빈 목록).
public static List SpawnLoops(Unit u, string key, string evt)
{
var list = new List();
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().Init(u.View); // 반복 이펙트의 b_face = f_dx 를 유닛이 바라보는 쪽 기준으로
ForceLoop(go, r.loopAll, r.hold);
if (r.wobbleDeg > 0f) go.AddComponent().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(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(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;
}
///
/// 몸 감싸기(f_wrap): 같은 씨앗(입자 모양·시점 동일)의 두 벌 — 뒤 벌 = 캐릭터 아래 층(n_order · 음수 아니면 −1) · 마스크 밖만 보임 /
/// 앞 벌 = 캐릭터 위 층(SortingBase) · 마스크 안만 보임 · 마스크 = 발 아래 2키 ~ 발 + 키 × f_wrap 사각(폭 4키 · 유닛을 따라감).
/// 결과 = 하반신 높이의 이펙트는 몸 앞 · 상반신 높이는 몸 뒤(감싸는 느낌) · 한 자리에 한 벌만 보여 겹쳐 진해지지 않음.
///
static List SpawnWrap(Row r, GameObject prefab, Unit u)
{
var res = new List();
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(under, underOrder), new KeyValuePair(over, SortingBase) })
{
var mi = pair.Key == over ? SpriteMaskInteraction.VisibleInsideMask : SpriteMaskInteraction.VisibleOutsideMask;
foreach (var rd in pair.Key.GetComponentsInChildren(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();
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;
}
/// 두 벌이 같은 입자를 내도록 같은 씨앗으로 다시 시작(층 순서마다 씨앗 + 순번).
static void Reseed(GameObject go, int seed)
{
int i = 0;
var all = go.GetComponentsInChildren(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);
}
///
/// 행의 색 바꾸기(s_hue · f_sat)와 세기(f_alpha)를 띄운 이펙트에 적용 — 입자 시작 색 · 수명 색 · 사용자 데이터 색(Hyper Casual 2nd color) ·
/// 트레일·선·스프라이트 색. 색상만 바꾸고 채도·밝기는 유지(채도 0.12 미만 = 흰 심·연기는 그대로) · 세기는 시작 색 불투명도에만 곱함.
///
static void Recolor(GameObject go, Row r)
{
Recolor(go, r.hue, r.sat, r.alpha);
}
/// 색 바꾸기·세기(행 값 없이 직접 · 에디터 미리보기 도구 공용).
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 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 start = c =>
{
var n = hueOnly(c);
n.a *= alpha;
return n;
};
foreach (var ps in go.GetComponentsInChildren(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(true))
if (ps.main.prewarm) prewarm = true;
if (prewarm && go.activeSelf)
{
go.SetActive(false);
go.SetActive(true);
}
foreach (var t in go.GetComponentsInChildren(true)) t.colorGradient = MapGradient(t.colorGradient, start);
foreach (var l in go.GetComponentsInChildren(true)) l.colorGradient = MapGradient(l.colorGradient, start);
foreach (var sr in go.GetComponentsInChildren(true)) sr.color = start(sr.color);
}
static ParticleSystem.MinMaxGradient MapColors(ParticleSystem.MinMaxGradient g, System.Func 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 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;
}
/// basic_<병종> 키(일반 슬링샷 공격 이펙트 · 2026-11-09 PD 시험 「보병 · 창 · 기병 슬링샷 공격에 WL 창 돌진 이펙트」).
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(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);
}
///
/// 팩 3D 이펙트(위 = +Y · 정면 = +Z)를 2D 전장 화면에 놓는 회전(2026-11-09 PD 「돌진하는 동안 이펙트가 정상적으로 안 보임」 수정).
/// face 없음 = X 축 tilt°(0 = 옆모습 · −90 = 바로 위에서 본 모습).
/// face 있음 = 옆에서 본 모습으로 화면에 눕혀(정면 → 화면 진행 방향 · 위 → 화면 쪽 수직) 진행 방향으로 화면 안에서 돌린다 — 정면·위로 세운 판(찌르기 섬광 · 돌진 줄기)이
/// 어느 방향으로 가든 납작하게 보이지 않게(3D 그대로 두면 위쪽 돌진 때 판의 옆면만 보임 · 실측) · tilt = 진행 축을 중심으로 카메라 쪽으로 기울이는 각도(−90 = 위에서 본 모습 · 바닥 원이 보임) ·
/// 왼쪽으로 갈 때는 위아래가 뒤집히지 않게 반대로 돌림.
///
///
/// 프리팹 원본 루트 회전 r0 을 살린 화면 회전(2026-11-10 PD 「스크린샷 분석해서 다시 적용」 — MasterStylizedFX 투사체·Dash 는 루트에 (0, 90, 270) 같은 회전이 들어 있어
/// 덮어쓰면 혜성 판이 옆으로 서서 가늘게만 보임 · 실측): 팩 데모 세계에서 r0 로 놓인 이펙트의 진행 축(r0 · +Z 의 수평 성분)을 +Z 로 돌려 맞춘 뒤 FxRotation 을 건다.
/// 루트 회전이 0 인 사본(WL 창 돌진 등)은 FxRotation 과 같다.
///
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);
}
/// 2D 평면 이펙트 회전(b_flat): 정면 +X 를 진행 방향으로 화면 안에서만 돌림 · 방향 없음 = 그대로.
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);
}
/// 입자 자체 이동(시작 속도 · 속도 모듈)을 k 배로(f_drift).
static void ScaleSelfMotion(GameObject go, float k)
{
k = Mathf.Max(0f, k);
foreach (var ps in go.GetComponentsInChildren(true))
{
var m = ps.main;
m.startSpeedMultiplier *= k;
var v = ps.velocityOverLifetime;
if (v.enabled) v.speedModifierMultiplier *= k;
}
}
///
/// 바닥 충돌 판(b_ground): 장면 콜라이더와 충돌하도록 만든 층(World)을 이펙트 원점의 바닥면(이펙트 XZ 면 · 법선 = 이펙트 +Y)과 충돌하게 바꾼다 —
/// 기울기(f_tilt)를 주면 바닥면도 같이 기울어 비스듬히 내려다본 바닥이 됨 · 충돌 설정(수명 감소 · 하위 방출)은 팩 그대로.
///
static void GroundPlane(GameObject go)
{
Transform plane = null;
foreach (var ps in go.GetComponentsInChildren(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);
}
}
/// 떨어지는 움직임만 끔(b_nofall): 중력 0 · 수명 속도·힘의 아래 방향(Y 음수) 0 — 층·그림·수명은 그대로.
static void NoFall(GameObject go)
{
foreach (var ps in go.GetComponentsInChildren(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);
}
}
/// 곡선·상수의 음수 부분을 0 으로(양수는 그대로).
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);
}
/// 세로 높이만 k 배: cut 거짓(f_height) = 시작 속도 × k(천천히 올라 간격도 좁아짐) · cut 참(f_top) = 오르는 입자의 수명 × k(속도·간격 그대로 · 그 높이에서 사라짐) ·
/// 공통 = 세운 메시 층의 길이(3D 크기 Z) · 세로로 긴 빛의 키(Y).
static void ScaleHeight(GameObject go, float k, bool cut)
{
k = Mathf.Max(0f, k);
foreach (var ps in go.GetComponentsInChildren(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();
if (rd == null || !m.startSize3D) continue;
if (rd.renderMode == ParticleSystemRenderMode.Mesh) m.startSizeZMultiplier *= k; // 세운 메시(빛기둥)의 길이
else m.startSizeYMultiplier *= k; // 세로로 긴 빛(3D 크기 빌보드)의 키
}
}
/// WL WLStaffEarth.Sustain 과 같음 — 시간당 방출(초당 5 이상) · 버스트 없는 층만 반복으로(돌진 내내 이어짐 · 버스트 층은 처음 1번만).
static void Sustain(GameObject go)
{
foreach (var ps in go.GetComponentsInChildren(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;
}
}
///
/// 프리팹 1개 띄우기(표 행 · 스킬 테스트 씬 이펙트 보기 공용). worldScale = 루트 배율 · 입자 크기 모드를 전부 Hierarchy 로(Local 이면 루트 배율이 안 먹음 · K-WL-325) ·
/// 트레일·선 굵기도 배율 · 렌더러 정렬 = order · 회전은 .
///
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(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(true)) tr.widthMultiplier *= s;
foreach (var lr in go.GetComponentsInChildren(true)) lr.widthMultiplier *= s;
foreach (var rd in go.GetComponentsInChildren(true)) rd.sortingOrder = order;
DisableSoftParticles(go);
if (follow != null) go.transform.SetParent(follow, true);
return go;
}
/// VFX_Klaus 셰이더 그래프(Hyper Casual · Shoot&Hit) 「Use SoftParticleFactor?」 속성 참조 이름.
const string SoftParticleToggle = "Boolean_BB495B7B";
///
/// 같은 「Use SoftParticleFactor?」 스위치의 셰이더별 참조 이름(2026-11-11 실측 · 이펙트 목록 렌더에서 258개가 안 보인 원인):
/// BB495B7B = HCFX_Particle_apb · 2ndColor · Shoot&Hit_apb / 2FAC1FE4 = HCFX_Particle_add · Shoot&Hit_add · Kyeoms 폭발 /
/// 52F3CBA5 = Fx_ParticleDissolve_add·apb(Earth Skills · Element Splash) / 9C0948F4 = Fx_dissolve_particle_apb.
///
static readonly string[] SoftParticleToggles = { SoftParticleToggle, "Boolean_2FAC1FE4", "Boolean_52F3CBA5", "Boolean_9C0948F4" };
static readonly Dictionary noSoftCache = new Dictionary();
///
/// 소프트 파티클 끄기(2026-11-10 실측): VFX_Klaus 셰이더 그래프의 「Use SoftParticleFactor?」 = 1 이면 장면 깊이(Scene Depth)로 투명도를 줄이는데
/// 이 게임은 직교 2D 카메라 + 깊이를 쓰지 않는 스프라이트라 입자가 생성·그려져도 화면에 색이 0(Hyper Casual 팩 전부 안 보임 · Lana 팩은 정상) →
/// 띄울 때 그 속성만 0 인 재질 복제본으로 바꿔 끼운다(원본 팩 재질 무수정 · 재질마다 1번 복제해 공유).
///
static void DisableSoftParticles(GameObject go)
{
foreach (var r in go.GetComponentsInChildren(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;
}
}
/// 입자 길이(시작 지연 + 길이 + 최대 수명) 중 가장 긴 것 · 루프는 MaxAutoLife.
public static float AutoLife(GameObject go)
{
float best = 0.5f;
foreach (var ps in go.GetComponentsInChildren(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);
}
/// 붙어 있던 이펙트(travel) 끝: 방출을 멈추고 떼어 놓은 뒤 남은 입자가 사라지면 지운다.
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(true)) ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
h.Objects.Remove(go);
Object.Destroy(go); // WL ClearEnd — 돌진 끝 = 이펙트 끝
}
h.ClearOnStop.Clear();
Stop(h.Objects);
}
/// 반복 기운·상태 이상(aura · status)이 끝날 때 흐려지는 시간(행 f_fade) — 유닛에 붙은 채 이 초 동안 흐려진 뒤 지움.
static readonly Dictionary loopFade = new Dictionary();
public static void Stop(List 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(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(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();
}
}
}