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