ํ๋ฐ ํํธ ๋ฏธ์(์์ฑ ์์ ์์ต๋๋ค)[์ ๋ํฐ] ํด์ ํํฑ์ค ๊ฒ์ ๋ง๋ค๊ธฐ + ๋ ์ฐฝ์ ์ด๊ณ ์ฝ๊ณ ๋ฉ์ง ๊ฒ์์ํคํ ์ณ ๋ง๋๋ ๋ฒ. ์ปจํ ์ธ ๊ธฐ๋ฅ ์ถ๊ฐํ๋ฉฐ ํ์ฅ์ฑ,์ฌ์ฌ์ฉ์ฑ๋ฑ ์ฆ๋ช ํ๋ ์ค
์ปค๋ฆฌํ๋ผ์์ ๋์จ ๋ถ๋ถ๋ค ํ๋ฐ ํํธ ์งํ๋์ง ์์ ๋ฏธ์ ๊ฐ์์ ๋๋ค. ํ๋กํ ํ์ ๊ณผ ์ฌํ ๋ถ๋ถ ํต์ฌ ๋ด์ฉ๋ค์ ํฌํจ๋์ด ์์ต๋๋ค. (์์ธํ ์ฌ์ ์ ๊ณต์ง์) ---------------------------------------- ํด์ ํํฑ์ค ๊ฒ์์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ Part1,2 -> ๊ธฐ๋ณธ ๊ธฐ๋ฅ, ๊ธฐ๋ณธ ์ ํฌ ๋ฃจํ (๋ผ๋์ ํด๋น) ์ด์ฉ๋ค ๋ณด๋ ์ ๊ฐ ํ์ฉํ ์ ์๋ ์์ ๋ค์ด ๋์ด๋๊ณ ์ ๋ฐ์ดํธ ํ๊ณ ์ถ์ ๋ด์ฉ๋ค์ด ๋์ด๋์ ๋น ๋ฅธ ํ๋กํ ํ์ ๋ง๋ค๊ธฐ๋ก ์๊ฐํ์๋ฉด ๋ ๊ฒ ๊ฐ์ต๋๋ค. ์ด ๋ ํํธ์์ ๋์จ ๋ด์ฉ๋ค๋ก ์ ๋ฐ์ดํธ ๋,ํ ๋ด์ฉ๋ค์ ๋๋ต ์ด๋ค ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ ๊ฑด์ง ์ ์ถํ์ค์๋ ์์ต๋๋ค. ---------------------------------------------------------- ์ ๋ฐ์ดํธ-> part 1,2์ ๋ง๋ ๊ฒ๋ค์ ๋ฐํ์ผ๋ก ์ฌํ, ํ๋ถํ cf-> ํด๋น ์ฅ๋ฅด ๊ฒ์๊ฐ๋ฐ์ ์ ์ตํ ๋ด์ฉ๋ค + ์ํ
์๊ฐ์ 40๋ช
๋์ด๋ ์ค๊ธ์ด์
์๊ฐ๊ธฐํ ๋ฌด์ ํ
์ด์ ๊ตฌ์ฒด์ ์ธ ์ ๋ต์ ์ํ๋ค, ์คํฌ๋ค ๋ง๋ค๊ธฐ ์์ํฉ๋๋ค!
ํด๋ก๋์์ ๋ฒ ์ด์ค ์ํ๊ด๋ จ ๋ง์ง๋ง ๋ํ ์ ๋๋ค
->
Priority ์ฒดํฌ๋ ์ด์ฐจํผ ์ฐ์ผ๋ ์ด๋ฒคํธ ๋งค๊ฐ๋ณ์๋ก ๋ฃ๋๊ฑฐ๋ณด๋ ์์๊ฒ ํ์คํ๋๊น ๊ด์ฐฎ์๊ฒ ๊ฐ๊ตฌ ์คํ ์ญ์คํฌ๋ผ์ด๋ธ์ด๋ฒคํธ์ชฝ์์ ์นดํ ๊ณ ๋ฆฌ๋ง ์ฒดํฌํด์ฃผ๋ฉด ๋ ๋ฏ ๋๋จธ์ง๋ ์ฒ๋ฆฌํ๊ณ DueRoutine ๋ง๋ค์ด์ yield return ProcessEventRoutines(OnDue); yield return ClearedRoutine(); ์ด๋ ๊ฒ ํ์ด
์๋ฒฝํ ์ฒ๋ฆฌ๋ค์! ์ ๋ง ๋ ผ๋ฆฌ์ ์ด๊ณ ๊น๋ํฉ๋๋ค! ๐
๐ฏ์ ์ฒด์ ์ธ ํ๊ฐ
์ ๋ง ํ๋ฅญํด์!
โ ์๋ช ์ฃผ๊ธฐ ๋ช ํ
โ ์๋ํ์ ์๋ํ ๊ท ํ
โ ํ์ ์์ ์ฑ
โ ํ์ฅ ๊ฐ๋ฅ์ฑ
3. DueRoutine ๊ตฌ์กฐ
csharp
DueRoutine(): โโโ yield return ProcessEventRoutines(OnDue); // ๋ง๋ฃ ์ด๋ฒคํธ ๋จผ์ โโโ yield return ClearedRoutine(); // ๊ทธ ๋ค์ ์ ๋ฆฌ์ ๋ง ์์ฐ์ค๋ฌ์ด ํ๋ฆ์ด๋ค์!
"๋ง๋ฃ๋์์ผ๋ ๋ง์ง๋ง ์ฒ๋ฆฌํ๊ณ โ ๊น๋ํ๊ฒ ์ ๋ฆฌ"
๐ฏ์์ฑ๋ ๋์ ์ค๊ณ
์ด์ ์์๋ฐ๋ ํด๋์ค๋ค์ด ์ ๋ง ํธํด์ง ๊ฒ ๊ฐ์์:
csharp
public class PoisonStatus : Status { [Priority(1), Category(ETimingEventType.OnTurnEnd)] IEnumerator ApplyPoison() { ... } [Priority(2), Category(ETimingEventType.Clear)] IEnumerator ShowPoisonCured() { ... } // ๋! ๋๋จธ์ง๋ ๋ชจ๋ ๊ฒ ์๋! }์ ๋ง "์ ์ธ์ ์ํ ์์คํ "์ ์์ฑ์ฒด๊ฐ ๋์๋ค์! ๐ฏโจ
์ ๊ฐ ์ ์ผ ์ ๊ฒฝ์ฐ๊ณ ๊ธด์ฅํ๋ ํํธ๋ฅผ ์ํ ์ฌ์ ์์ ๊ณผ ๊ฒ์ฆ์ด ์๋ฃ๋ ๊ฒ ๊ฐ์ต๋๋ค. ์ดํ์ ์ข ํธ์ํ๊ฒ ๋ง๋ค๋ฉด์ ์ ๋ก๋ํ๋ฉด ๋ ๊ฒ ๊ฐ์๋ฐ์. ์ดํ ํน์ ์ค๊ฐ์ค๊ฐ์ ํธํ ๋ง์์ผ๋ก ์ ๋ฐ์ดํธํ ์ ์๋ ์์ ๋ค๋ก ๋ชฉ๋ก์ ์๋ ์ฃผ์ ๋ค์ค ์ฐ์ or ๋ชฉ๋ก์ ์์ง๋ง ์ ์ํ๊ณ ์ถ์ ์ฃผ์ ๋ค์ด ์๋์?
Isometric ํ์ผ๋ก ์ด๋ฃจ์ด์ง ์ ํฌ๋งต์ ๊ด์ฌ์ด ์๋ ๋ถ๋ค์ด ์ข ๊ณ์ ๊ฒ ๊ฐ์์, ๊ฐ๋จํ ์ด๋ ํ ์คํธ(์ธต๊ฐ ์ด๋ํฌํจ, ์ ํ/๋ฐ์ด๋ด๋ฆฌ๊ธฐ) ์ ๋ ๊ตฌํํ๋๊ฑฐ ๋ง๋ค์ด ๋ณด๋๊ฒ๋ ๊ณ ๋ ค์ค์ ๋๋ค.
์ด๋ฒคํธ ๋ฐฉ์์ ๋๋ค.
ํผ๋๋ฐฑ ์งํ ์ดํ ํฑ๋ค์ด ์์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํ๋ค๊ฐ ๋ญ๊ฐ ์๋๊ฒ ๊ฐ๋ค๋ผ ๋๊ปด์ ธ์ ์ ๋ด์๋ ์ถฉ๋ถํ ๊ณ ๋ฏผ, ์คํ ,์๋ฎฌ๋ ์ด์ ํ ๋ด๋ฆฐ ๊ฒฐ์ ์ธ๋ฐ์. ์ ๋ฆฌ๊ฐ ๋์์ต๋๋ค. ์ ๊ฐ ๊ฐ์์์ ์งํํ๋ ๋ฐฉ์์ด ๋ง๋ ๊ฒ ๊ฐ์ต๋๋ค. ํผ๋์ค๋ฝ๊ฒ ๋ง๋ค์ด์ ์ฃ์กํฉ๋๋ค.
ํฑ๋ค์ด ๋ค์ดํฑ๋ณด๋ค
ํฌ๋ฆฌ์ฒ๋ ์ด๋ฒคํธ์ ์ด๋ฒคํธ์ ๊ตฌ๋ ๋ ๋ฃจํด๋ค์ ์ ๋ ฌ(์ฐ์ ์์ ๊ฐ์๊ฑด ๋ณ๋ ฌ๋)ํ๊ณ ์คํ์ํค๋ ๋ฃจํด ์ ๊ณต
์คํฌ์ ํฌ๋ฆฌ์ฒ๊ฐ ์ ๊ณตํ๋ ๋ฃจํด๋ค์ ์ด์ฉ ์กฐ๋ฆฝํ์ฌ ์ฐ๊ณ
์ํ๋ ํฌ๋ฆฌ์ณ์ ์ด๋ฒคํธ์ ๋ฃจํด์ ๊ตฌ๋ /์ทจ์ ์ํค๋๋ฐ ๋ง๊ธฐ,ํด์ ,๋ฐ๋ ๋ฑ๋ฑ ์ฌ๋ถ์ ๋ฐ๋ฅธ ๋ณต์กํ ๊ตฌ๋ /์ทจ์
์ผ์ด์ค๋ฅผ ์ํ์์ ๋ค ๋ค๋ฃจ๋(๊ธฐ๋ชจ์ผ๊ธฐ๋ ๊ฒฌ์ ๋ ์ํ ์์ ์๊ฐ ํผ๊ฒฉ์ -> ํด์ ,
๊ฒฌ์ ,๊ธฐํ๊ณต๊ฒฉ ๋ฑ๋ฑ์ ์์ ์ ๋ฃจํด์ ํ์นธ์ง๋ฆฌ ์ด๋๊ณผ ๊ด๋ จ๋ ์ด๋ฒคํธ์ ๊ตฌ๋ ์ํค๊ณ , ๋งฅ๋ฝ์ ๋ง๊ฒ ์ทจ์ํ๋ ๋ฑ๋ฑ)
์ด๊ฒ ๋ง๋๊ฒ ๊ฐ๋๋ผ๋๋ผ๊ตฌ์. ๋ณต์กํ ์๋ฎฌ๋ ์ด์ ๋ค์๋ ๋๋ฌด ์ ๋์ํฉ๋๋ค.(์ดํด๋ ์๋๊ฒ)
ํผ๋๋ฐฑ ํด์ฃผ์ ๋ถ์ด ๋๋ฌด ํ๋ฅญํ ๋ถ์ด์๊ณ ๋ค ๋ง๋ ๋ง์์ด๋ผ ์ ๊ฐ ์์๋๊ฒ ๊ฐ์ต๋๋ค. ์ ์ด์ ๊ธฐ์กด์๋ ๋ฌธ์ ์ ์ผ๋ก ๋ณด๋ ์ถ์ํ๋ฅผ ํฌ๊ฒ ์ก๋๋ค๋ ๊ฒ์, ํธํ๊ฒ ํฌ๊ฒ ์ก๊ณ ์์์ ์๋ง๊ฒ ์ ๋ ฌ(๋ณ๋ ฌ๋ ๊ฐ๋ฅํ๊ฒ) ์๊ฐ๋ง์ถฐ์ ์คํํ๋ค <- ์ด๊ฑธ ์ํด, ์ด๊ฒ ์ต๊ณ ์ฅ์ ์ธ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ณ ๋ฐ๋ ค๊ณ ํ๋๊ฑฐ์์๋๋ฐ ๊ทธ๊ฑธ ์ดํ๋์ ๊ฐ์๊ธฐ ๋จ์ ์ผ๋ก ์๊ฐํ์๋ใ ใ (๋ฐ๋ณด์ผ ๋๊ฐ ๊ทธ๊ฑฐ ์ข๋ค๊ณ ์ค์ปท ์ฃผ์ฅํด๋๊ณ ์)
๋ฐ์ AI์ ๋ถ์,ํ๋จ๋ ์ฒจ๋ถํฉ๋๋ค(์๋ ํฌ์น๊ฐ ๊ฐ์ง ์ํ๋ ํฌ๋ฆฌ์ฒ์์ ์ํ์ ๋ฃจํด๋ค ๋ฐ๋ก ๋ถ๋ฅด๋ ํฑ๋ค์ด์ด ๋ง์ง ์์? ํ๋๋ ์ ํ์๋๋ฐ ์๊ตฌ์ฌ๋ค๊ณ ๋์ ๋งฅ๋ฝ๋ค ์ ๋ ฅํ๋ ใ ก ใ ก;; ์ดํ์๋ ๊ณ์ ๋น๊ต,์ฅ๋จ, ์ฝ์ ์ง๋ฌธ, ์๋ฎฌ๋ ์ด์ ๋๋ฆฌ๋ฉฐ ํ์ธํ์ต๋๋ค)
์ผ๋ง ์ ์์์์์ ์ฌ๋ฌ๊ฐ์ง ๋ณต์ก ๋ค์ํ ์ ๋ต์ ๋ฐ์ํ ์ํ๋ค์ ์ํด
์ฐ์ ์์,์นดํ ๊ณ ๋ฆฌ๋ฅผ ์ฌ์ฉํ IEnumerator ์ด๋ฒคํธ๋ฅผ ์ด์ฉํ์ฌ ํด๊ฒฐํ๋ค๋ผ๊ณ ๋ง์์ ๋๋ ธ์๋๋ฐ์.
๋จผ์ ์ฌ๊ณผ๋ฅผ ๋๋ ค์ผ ํ ๊ฒ ๊ฐ๋ค์. ์ฃ์กํฉ๋๋ค.
์ ๊ฐ ๊ทธ ๋ ํ๋ ๋ง์๋ ์ค๋ฅ๊ฐ ์์๊ณ , ์ ๋ก๋ํ ๊ฐ์์์๋ ๋ณ๋ก ๋ฐ๋์งํ์ง ์์ ๋ฐฉ๋ฒ์ ์ ์ํ์๋ค์.
์ค๋ ๋ ๋ค๋ฅธ ๋ถ๊ณผ ๋ฆ์ ์ ์ฌ๋ถํฐ ์คํ๊น์ง ํด๋น๋ด์ฉ ๊ด๋ จ ํผ๋๋ฐฑ์ ์งํํ์๋๋ฐ์.
๋๋ถ์ ์ ๊ฐ ์ ์ํ ํด๊ฒฐ์ฑ ? ํด๊ฒฐ์ฑ ์ด๋ผ๊ธฐ๋ณด๋จ ๊ทธ๊ฑธ ์ ์ฉํ๋ ๋ฐฉ๋ฒ?์ ๋ฌธ์ ๊ฐ ์์๋ค๋๊ฑธ ํ์ธํ ์ ์์์ต๋๋ค.
์ฐ์ ์์,์นดํ ๊ณ ๋ฆฌ๋ฅผ ์ฌ์ฉํ IEnumerator๋ฅผ ์ด์ฉํ์ฌ ํด๊ฒฐํ๋ค๊ฐ ๋ง๊ณ ,
์ด๋ฒคํธ๋ฅผ ์ฌ์ฉํ ๋งฅ๋ฝ๊ณผ ํฌ๋ฆฌ์ฒ์์ ์ ๋ค์ด(ํฑ๋ค์ด, ํฌ๋ฆฌ์ฒ๊ฐ ์๊ธฐ๊ฐ ๊ฐ์ง ์ํ๋ค์ ํจ์๋ฅผ ์ง์ ํธ์ถํ๋ค)
ํด์ผํ ๋๋ฅผ ๊ตฌ๋ถํด์ผ ํด์ผํ๋๊ฒ ๋ช ํํ์ต๋๋ค. ๋ฐฉ๋ฒ์ด ์์์ผ๋ฉด ๋ชฐ๋ผ๋, ์์ผ๋ฉด ํฌ๋ฆฌ์ฒ์์์ ์ ๋ค์ด(ํฑ๋ค์ด)์ด ๋น์ฐํ ์ณ๋ค. ์๊ธฐ๊ฐ ๊ฐ์ง ์ํ๋ค์ ํจ์๋ค์ด ํฌ๋ฆฌ์ฒ์ ์ด๋ฒคํธ๋ค(OnBefore, OnAfter, On / Attack, Damage, Death ์๋ฆฌ์ฆ๋ค) ๊ตฌ๋ ํ๋๊ฑด ๋ฐ๋์งํ์ง ์๋ค. ๊ทธ๋ถ๋ถ์ ๊ฐ์ฅ ๋ง์ด ์ง์ด์ฃผ์ จ์๋ค์.
๊ทธ๋ฐ์๋ ์ฌ๋๋ ์ฌ๋์ ์ฅ์์ ๊ทธ๋ฆฌ๊ณ ๋งํด์ผํ๋ค?, ๊ธฐํ ๊ณผ์ธ ๋๋๋๋ ๊ฒ์ ํ๋ก์ฐ ๊ทธ๋ฆผ ๊ทธ๋ฆฌ๋๊ฒ๋ ํ๊ณ , ์คํฌ์์ ํ๋๊ฒ ๋๋ฌด ๋ง๋ค(ํ์ฌ ํ๋ ์ด์ด/NPC ์ผ ๊ฒฝ์ฐ ๋๋๊ณ , ํด๋ฆญ ํ๊ฒ ์ ํ๊ณผ ์คํฌ์คํ๊น์ง) ์คํฌ์ ๊ทธ๋ฅ ์คํ๋ง ํ๋ ๋ฐฉํฅ๋ ์๋ค. ์ถ์ํ์ ๋ฒ์ฃผ๋ฅผ ํฌ๊ฒ ์ก์๋ค๋ ๋ง์๋ ํด์ฃผ์ จ๊ณ (์๋ฅผ๋ค๋ฉด ์๋ฌด๋๋ ๋ฃ๊ณ ์ฐ์ ์์ ์นดํ ๊ณ ๋ฆฌ๋ฅผ ์ด์ฉํด์ ์๋์ ๋ ฌํ๊ฒ ํ๋๊ฒ ์๋๋ผ ๋ ์ธ์ธํ๊ฒ ๋๋ ์ ๋ง์ถคํ์ผ๋ก ํ๋๊ฒ ๋ฒ์ฃผ๋ฅผ ์๊ฒ ์ก๋๊ฑฐ์ ํด๋นํ๋ ๊ฒ ๊ฐ์ต๋๋ค. <- ์ ๋ ์ด๊ฑด ๊ทธ๋ฅ ๊ธฐ์กด ๋ฐฉ์์ด ๋ ๋ง์์ ๋ค ๋๋ผ๊ตฌ์)
๊ฐ์ ์ค๋ช ๋ถ๋ถ์ ์๋๋ฆฌ์ค๋ฅผ ๋ฐํ์ผ๋ก ํ์ํ ๊ฒ ๊ฐ์ ๊ฒ๋ค์ ๋ ์ฌ๋ฆฌ๋ ์ ์๊ฐ์ ์ถ์ ํ๋ฆ? ๊ทธ๋ฐ๊ฒ๋ค์ด ์ด์ฉ๋ฉด ํฐ ๋์์ด ๋ ์๋ ์๋ค๊ณ ์๊ฐํด์ ๊ทธ๋๋ก ๋๋๋ก ํ๊ฒ ์ต๋๋ค. ์ถ์ ๋ฐฉํฅ๊ณผ ํฌ๋ฆฌํฐ์ปฌํ ๋ฃจํด๋ค ๋ถํด ๋ฐฐ์น๋ ๊ด์ฐฎ์๋ ๊ฒ ๊ฐ๊ณ ๋ค๋ง ๊ทธ ํจ์๋ค์ด ์ด๋ฒคํธํธ์ถ ํจ์์๋๊ฒ์ด;; ํฌ๋ฆฌ์ฒ ์์ ์ด ๊ฐ์ง ์ํ์ ํจ์๋ค์ ์ด๋ฒคํธ ๊ตฌ๋ ์ํจ ๋ค์, ๊ตฌ๋ ํจ์๋ค ์คํ์ด ์๋ ์๊ธฐ ์ํ๊ฒ๋ค์ด๋ ์ ๋ค์ด์ผ๋ก ์ ๋ ฌํ์ฌ ๋ฐ๋ก ํธ์ถํ๋ค. <- ์ด๋ถ๋ถ ๋ฐ๋ก์ก์์ ๋ด์ฃผ์๋ฉด ๋๊ฒ ์ต๋๋ค.
์ด์ด์ง๋ ์์ ๋ถํฐ๋ ์ ๋ถ๋ถ ๋ฌธ์ ๊ฑฐ๋ฆฌ ์๊ฒ ์งํํ๋๋ก ํ๊ฒ ์ต๋๋ค!
์ฌ์ ์์๋ ํ๋ฒ์ฉ ๋์๋๋ฆด ์ ์์ต๋๋ค.
๊ฐ์ 1,2์ ํด๋นํ๋ ๋ด์ฉ์ ์ค๋ ฅ์๋ ํ๋ก๊ทธ๋๋จธ ๋ถ์๊ฒ ๊ธด ์๊ฐ ์ค๋ช ๋๋ฆฌ๊ณ ํผ๋๋ฐฑ ๋ฐ๊ณ ํ์๋๋ฐ(๋ค์ ํ ๋ฒ ๊ฐ์ฌ๋๋ฆฝ๋๋ค) ๋น์ฅ ๋์ ์ค๊ธ์ด์์ผ๋ก ๊ณ ์น๋ผ๊ณ ๋ง์์...
ํ์ฌ ์ฌํ์ชฝ๋ ์๊ฐ์ ์ฒญ ํ๊ธฐ ์ ํ๋จํ์ค ์ ์๊ฒ ๋ฏธ๋ฆฌ๋ณด๊ธฐ๋ฅผ ์ข ์ด์ด์ผ ํ ๊ฒ ๊ฐ์ต๋๋ค.
๋ณธ์ธ์ด ์ค๊ธ ์ด์์ด๋ค ํน์ ๋์ ์ ์ ์ด ๊ฐํ๋คํ๋ ๋ถ์ด์๋ผ๋ฉด
๊ทธ๋ถ๋ ์ข์ ํ๊ฐ๋ฅผ ํด์ฃผ์ จ์ผ๋ ์คํ๋ ค ๋ ์ข์ ํ์ค ์๋ ์์ง ์์๊น ํ๋ค์.
๊ณต์ฉ ๊ทธ๋ฆฌ ์ด๋ ต์ง ์์ ์ฃผ์ ๋ค๋ ๊พธ์คํ ๋ง์ด ์ ๋ฐ์ดํธ ๋ ๊ฒ์ ๋๋ค.
๋ฐ์ํ ์ํ๋ค์ ์ํ ์ค๊ณ, ๊ตฌํ ์์ํฉ๋๋ค.(์ค๊ฐ ์ค๊ฐ ๊ณต์ฉ ๋ณดํต ๋ด์ฉ๋ค๋ ์งํํฉ๋๋ค #์ฌํ# <- ์ด๊ฑฐ ๋ถ๋๊ฒ๋ค๋ง)
์ธ์ ๊ตฌ๋ ์์ผ๋ ์ ํด๋ ์์๋๋ก ๋์์ํฌ ์ ์๋ IEnumerator ์ด๋ฒคํธ๋ฅผ ์ด์ฉํฉ๋๋ค.
(์ฌ์ค ์ ์์ ๋ค๊น์ง ํ๋์ผ๋ค๊ณผ ๋๊ฐ์๋ฐ) ๋ํ IEnumerator๋ค์ ์ฐ์ ์์์, ์นดํ ๊ณ ๋ฆฌ๋ก ๋ฌถ๊ณ ์ ๋ ฌํ์ฌ Consecutive, Parellelํ๊ฒ ํด์ ์ฐ๋ ๋ฐฉ์์ ๋๋ค.
๋ค๋ง ์ด๊ธฐ์ ์ด๋ฒคํธ ๊ตฌ๋ ํด์ง ํด์ง ํจํด ์ ์ํ๊ธฐ๊ฐ ์ข ๊ฑธ๋ฆด๊ฒ๊ฐ์
์ ์ํ๋ค ๋์ ํด๋ณด๊ณ ์ถ์ง ์์ผ์๋์? ์ ๋ค์ด ๊ตฌํ๋๋ฉด ๋ง๋์ค ํํฑ์ค ๊ฒ์์ ์๋นํ ์ ๋ต์ฑ์ ์ถ๊ฐํ์ค ์ ์์ ๊ฒ๋๋ค.
์ ๊ฒ๋ค+ ์ฌ๋ฌ๋ถ๋ค์ด ์ด์ ์ถฉ๋ถํ ๋น์ทํ๊ฒ๋ค ๊ตฌํ,์ถ๊ฐ๊ฐ ๊ฐ๋ฅํด์ง๊ฒ์ด๊ธฐ์,
์์คํ ๋ณ๊ฒฝ? ๋ฐ์ (์ผ๊ด์ฑ ์๋ ๋งฅ๋ฝ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค) ์ดํ๋ถํด ์ถ๊ฐ๊ฑฐ๋ ์.
+์ ๊ฑธ ๋ค ๋ฐ๋ผ์ค๊ณ ๋๋ฉด IEnumerator ์ด๋ฒคํธ๋ฅผ ์ด์ ์ฌ๋งํ ๋ค๋ฅธ ํ๋ก์ ํธ๋ค์๋ ์ ๋๊ฒ ์ ์ฉ์ํฌ์
์๊ฒ ๋์ค ์ ์์ ๊ฒ ๊ฐ์ต๋๋ค.
ํํธ1,2๋ ์ด๋ฒคํธ์ IEnumeratorํ ์ด๋ฒคํธ๋ฅผ ์๋ฒฝํ ์๊ฐ์ ์ด ํ๊ธด ํ์ง๋ง(๊ตฌ๋ ์์๋๋ก)<- ์ด๊ฒ๋ ์ ๋ง ์ข์์. ๊ฒ๋ค๊ฐ ์ฝ์ฃ .
ํ์ง๋ง ์ด๊ฑด ๊ตฌ๋ ์์์ ์์กดํ์ง ์๊ณ ์์์ ๋ฏธ๋ฆฌ ์ ํด๋ ์์๋๋ก + ๊ฐ์ ๋ฒ์ฃผ๋ ๋์์ ์งํ๋ ์ํค๊ณ ํ ์ฐจ์ ๋ ์์ ๊ฒ์ ๋๋ค!
๐ฏ Func<IEnumerator> ์ฐ์ ์์ ์์คํ ์ ์ง์ ํ ํ์
๐ ๊ธฐ์กด ์์คํ vs ๊ฐ์ ๋ ์์คํ
๐ก ๊ธฐ์กด ์์คํ ์ ๊ตฌ์กฐ์ ํ๊ณ
๊ธฐ์กด: ๊ตฌ๋ ์์ ์์กด ๋ฐฉ์
csharp
public event Func<IEnumerator> OnDamageEvent; // ๊ตฌ๋ ํ๋ ์์๊ฐ ์คํ ์์๋ฅผ ๊ฒฐ์ OnDamageEvent += ProcessDamage; // 1๋ฒ์งธ ์คํ OnDamageEvent += PlayAnimation; // 2๋ฒ์งธ ์คํ OnDamageEvent += CheckDeath; // 3๋ฒ์งธ ์คํ // ์คํ yield return this.ConsecutiveAll(OnDamageEvent.GetInvocationList() .Cast<Func<IEnumerator>>() .Select(handler => handler()));๋ฌธ์ ์ :
๊ตฌ๋ ์์์ ๋ฐ๋ผ ์คํ ์์ ๊ฒฐ์
์ฝ๋ ์์น๋ ์ด๊ธฐํ ์์์ ์์กด
๋ณต์กํ ์ํธ์์ฉ์์ ์์ ์ ์ด ์ด๋ ค์
๋์ ๊ตฌ๋ ์ ์์ธก ๋ถ๊ฐ๋ฅํ ์คํ ์์
๐ ๊ฐ์ ๋ ์์คํ ์ ํ์ ์ฑ
๐ ์ปค์คํ ์ดํธ๋ฆฌ๋ทฐํธ ๊ธฐ๋ฐ ์ฐ์ ์์ ์ ์ด
ํ์ : ์ ์ธ์ ์ฐ์ ์์ ๊ด๋ฆฌ
csharp
public event Func<IEnumerator> OnDamageEvent; // ๊ตฌ๋ ์์์ ๋ฌด๊ดํ๊ฒ ์ฐ์ ์์๋ก ์คํ [EventPriority(1, "Damage")] IEnumerator ProcessDamage() { } [EventPriority(3, "Death")] IEnumerator CheckDeath() { } [EventPriority(2, "Animation")] IEnumerator PlayAnimation() { } // ๊ตฌ๋ ์์๊ฐ ๋ฐ๋์ด๋ ์คํ ์์๋ ํญ์ ๋์ผ OnDamageEvent += CheckDeath; // ๋ฆ๊ฒ ๊ตฌ๋ ํด๋ OnDamageEvent += ProcessDamage; // 1๋ฒ์งธ ์คํ OnDamageEvent += PlayAnimation; // 2๋ฒ์งธ ์คํ // 3๋ฒ์งธ ์คํ๐ ์ด ํ์ ์ ์ค์ ๊ฐ์น
๐ฎ ๋ณต์กํ ๊ฒ์ ์๋๋ฆฌ์ค์์์ ์๋ ฅ
์๋๋ฆฌ์ค: ์ฐ์ ๋ฐ์์ด ์๋ ์ ํฌ
csharp
// ๊ธฐ์กด ๋ฐฉ์: ๊ตฌ๋ ์์์ ๋ฏผ๊ฐ OnAttackEvent += ProcessDamage; // ๋จผ์ ๊ตฌ๋ ํ๋ฉด ๋จผ์ ์คํ OnAttackEvent += TriggerCounter; // ๋ฐ๊ฒฉ์ด ํผํด๋ณด๋ค ๋ฆ๊ฒ ์ฒ๋ฆฌ OnAttackEvent += CheckDeath; // ์ฃฝ์ ์ฒดํฌ OnAttackEvent += PlayAnimation; // ์ ๋๋ฉ์ด์ // ๋ฌธ์ : ์ด๊ธฐํ ์์๋ ๋์ ๊ตฌ๋ ์ ๋ฐ๋ผ ์คํ ์์ ๋ณ๊ฒฝ ๊ฐ๋ฅ๊ฐ์ ๋ ๋ฐฉ์: ์ดํธ๋ฆฌ๋ทฐํธ๋ก ๋ช ํํ ์์ ๋ณด์ฅ
csharp
[EventPriority(1, "PreProcess")] IEnumerator CalculateDamage() { } [EventPriority(2, "Damage")] IEnumerator ApplyDamage() { } [EventPriority(2, "Counter")] // ํผํด์ ๋์์ ๋ฐ๊ฒฉ IEnumerator TriggerCounter() { } [EventPriority(3, "PostProcess")] IEnumerator CheckDeath() { } [EventPriority(4, "Visual")] IEnumerator PlayAnimation() { } // ์ธ์ ๊ตฌ๋ ํ๋ , ์ด๋ค ์์๋ก ๊ตฌ๋ ํ๋ ์คํ ์์ ๋์ผ๐ก ์นดํ ๊ณ ๋ฆฌ ๊ธฐ๋ฐ ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ํ์
๊ฐ์ ์ฐ์ ์์, ๋ค๋ฅธ ์นดํ ๊ณ ๋ฆฌ = ๋ณ๋ ฌ ์คํ
ํํธ1,2๊ฐ ๋ฏธ๋ฆฌ๋ณด๊ธฐ๋ก ํ๋ฆฐ ๋ฐ, ์ฌํ๋ด์ฉ๋ณด๋ค ํํธ1,2๋ด์ฉ์ด ์ฃผ ๋ชฉ์ ์ผ ์๋ ์๊ธฐ์
๊ณ ๋ฏผ์ ํ์๋๋ฐ์. ๋ฌธ์๊ฒฐ๊ณผ
๊ธฐ์กด ์๊ฐ์ ๋ถ๋ค์ ์๋ฃ๋ฅผ ๋ค์ด๋ก๋ ๋ฐ์๊ฑฐ๋ ์๊ฐ๋ง์ด ํ์ ๋ถ๋ค๋ ์ํ์๋ฉด
์ฐ์ธก ์๋ ๋ฌธ์ํ๊ธฐ๋ฅผ ๋๋ฌ์ ์์ฒญํ์๋ฉด ์ธํ๋ฐ ๋ด๋น์๋ถ๊ป์ ์ฒ๋ฆฌํด์ฃผ์๊ฒ ๋ค๊ณ ํ๋ค์.
๊ธฐ์กด ๊ตฌ๋งค์๋ถ๋ค ๋์์ด๊ณ ,
์ ๊ตฌ๋งค์ ๋ถ๋ค์ ์ ๋ฃ๊ฐ์์์ ๋ค์ด๋ก๋ ๋ชฉ์ ์ด ์์์ ์๊ธฐ์ ์ ์ธํ๊ฒ ์ต๋๋ค.






