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(); } } }