#include <iostream>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <string>
#include <map>
#include <thread>
#include <mutex>
#include <ctime>

#pragma comment(lib, "ws2_32.lib")

const int ARENA_W = 160;
const int ARENA_H = 40;

struct RemotePlayer {
    int id;
    char symbol;
    float x, y;
};

std::map<int, RemotePlayer> g_world; // 입력받은 플레이어들의 상태
std::mutex g_worldLock; // 플레이어들의 상태를 갱신할때 걸리는 락
SOCKET g_sock; // 서버와의 통신 소켓
int g_myId = -1; // 서버에게 인식되는 클라이언트 자신의 id
bool g_running = true; // 프로그램 동작 여부
bool g_headless = false; // 더미 클라이언트 플래그, true일시 콘솔창 출력없이 프로세스가 진행됨

// 네트워크로부터 수신한 패킷을 해석해 플레이어 객체들의 상태에 반영하는 수신 스레드함수 
void NetworkReceiver() {
    char buffer[4096];
    std::string streamBuffer;
    while (g_running) {
        int bytesReceived = recv(g_sock, buffer, sizeof(buffer) - 1, 0);
        if (bytesReceived <= 0) { g_running = false; break; }
        buffer[bytesReceived] = '\0';
        streamBuffer += buffer;
        size_t pos;
        // 패킷이 줄바꿈 기준으로 있는 경우를 충분히 반영한다. 
        while ((pos = streamBuffer.find('\n')) != std::string::npos) {
            std::string line = streamBuffer.substr(0, pos);
            streamBuffer.erase(0, pos + 1);
            // 자신을 포함한 유저들의 위치 정보 처리
            if (line[0] == 'U') {
                int id; char sym; float x, y;
                if (sscanf_s(line.c_str(), "U %d %c %f %f", &id, &sym, 1, &x, &y) == 4) {
                    std::lock_guard<std::mutex> lock(g_worldLock);
                    RemotePlayer& p = g_world[id];
                    p.id = id; p.symbol = sym; p.x = x; p.y = y;
                }
            }
            // 클라이언트 유저의 자기 자신의 id정보 수신 처리, 이 정보는 자신의 id에 해당하는 문자를 붉게 칠하는 데에 쓰인다.
            if (line[0] == 'W') {
                int id; char sym; float x, y;
                if (sscanf_s(line.c_str(), "W %d %c %f %f", &id, &sym, 1, &x, &y) == 4) {
                    if (g_myId == -1) g_myId = id;
                }
            }
            // 통신을 끊은 클라이언트를 삭제하는 처리
            else if (line[0] == 'D') {
                int idToRemove;
                if (sscanf_s(line.c_str(), "D %d", &idToRemove) == 1) {
                    std::lock_guard<std::mutex> lock(g_worldLock);
                    g_world.erase(idToRemove);
                }
            }
        }
    }
}

int main(int argc, char* argv[]) {
    // 더미 클라이언트를 같은 시간에 실행하면 시드값이 같게 되어 문제가 생기기에 프로세스 id로 소금을 뿌린다.
    srand((unsigned int)time(NULL) ^ _getpid());

    // 프로그램 매개변수로 headless가 있으면 봇모드로 구동
    for (int i = 0; i < argc; i++) {
        if (std::string(argv[i]) == "-headless") {
            g_headless = true;
        }
    }

    HWND consoleWindow = GetConsoleWindow();
    // 프로그램 매개변수로 headless가 있으면 윈도우를 숨김
    if (g_headless) {
        ShowWindow(consoleWindow, SW_HIDE); 
    }

    // Windows Sockets Asynchronous Startup. Ws2_32.dll 라이브러리를 초기화함 2,2는 소켓 버전
    // WSAStartup은 호출횟수가 레퍼런스 카운팅되며, 호출된만큼 WSACleanup도 불려야 함.
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);
    g_sock = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);
    serverAddr.sin_port = htons(9000);

    if (connect(g_sock, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) return 0;

    // 수신 스레드 따로
    std::thread netThread(NetworkReceiver);
    netThread.detach();

    // 콘솔창 초기화
    HANDLE hConsole = NULL;
    wchar_t* screen = nullptr;
    WORD* colors = nullptr;

    if (!g_headless) {
        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        SMALL_RECT windowSize = { 0, 0, (short)(ARENA_W - 1), (short)(ARENA_H - 1) };
        COORD bufferSize = { (short)ARENA_W, (short)ARENA_H };
        SetConsoleScreenBufferSize(hOut, bufferSize);
        SetConsoleWindowInfo(hOut, TRUE, &windowSize);

        screen = new wchar_t[ARENA_W * ARENA_H];
        colors = new WORD[ARENA_W * ARENA_H];
        hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
        SetConsoleActiveScreenBuffer(hConsole);
    }

    DWORD dwBytesWritten = 0;

    // 유저 인풋 처리, 패킷 송신, 화면 출력 루프
    while (g_running) {
        // --- INPUT ---
        // headless 모드로 실행되거나 창에서 포커스가 빠지면 무작위로 이동
        bool useBotLogic = g_headless || (GetForegroundWindow() != consoleWindow);

        if (!useBotLogic) {
            if (GetAsyncKeyState('W') & 0x8000) send(g_sock, "W", 1, 0);
            if (GetAsyncKeyState('S') & 0x8000) send(g_sock, "S", 1, 0);
            if (GetAsyncKeyState('A') & 0x8000) send(g_sock, "A", 1, 0);
            if (GetAsyncKeyState('D') & 0x8000) send(g_sock, "D", 1, 0);
            if (GetAsyncKeyState(VK_ESCAPE)) g_running = false;
        }
        else {
            static int moveTimer = 0;
            static int currentBotDir = 0;
            if (moveTimer <= 0) {
                currentBotDir = rand() % 4;
                moveTimer = (10 + (rand() % 20)) * 0.5f;
            }
            const char* cmds = "WSAD";
            send(g_sock, &cmds[currentBotDir], 1, 0);
            moveTimer--;
        }

        // 창 렌더링
        if (!g_headless && hConsole) {
            for (int i = 0; i < ARENA_W * ARENA_H; i++) {
                screen[i] = L' ';
                colors[i] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
            }

            for (int x = 0; x < ARENA_W; x++) {
                int top = x;
                int bot = (ARENA_H - 1) * ARENA_W + x;
                screen[top] = screen[bot] = L'#';
                colors[top] = colors[bot] = FOREGROUND_INTENSITY;
            }
            for (int y = 0; y < ARENA_H; y++) {
                int left = y * ARENA_W;
                int right = y * ARENA_W + (ARENA_W - 1);
                screen[left] = screen[right] = L'#';
                colors[left] = colors[right] = FOREGROUND_INTENSITY;
            }

            {
                std::lock_guard<std::mutex> lock(g_worldLock);
                for (auto const& [id, p] : g_world) {
                    if (id == g_myId) continue;
                    int idx = (int)p.y * ARENA_W + (int)p.x;
                    if (idx >= 0 && idx < ARENA_W * ARENA_H) {
                        screen[idx] = (wchar_t)p.symbol;
                        colors[idx] = FOREGROUND_GREEN | FOREGROUND_BLUE;
                    }
                }
                if (g_world.count(g_myId)) {
                    RemotePlayer& me = g_world[g_myId];
                    int idx = (int)me.y * ARENA_W + (int)me.x;
                    if (idx >= 0 && idx < ARENA_W * ARENA_H) {
                        screen[idx] = (wchar_t)me.symbol;
                        colors[idx] = FOREGROUND_RED | FOREGROUND_INTENSITY;
                    }
                }
            }

            WriteConsoleOutputCharacterW(hConsole, screen, ARENA_W * ARENA_H, { 0,0 }, &dwBytesWritten);
            WriteConsoleOutputAttribute(hConsole, colors, ARENA_W * ARENA_H, { 0,0 }, &dwBytesWritten);
        }

        Sleep(50);
    }

    return 0;
}

#pragma once
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <iostream>
#include <thread>
#include <vector>

#pragma comment(lib, "ws2_32.lib")

#define MAX_PLAYERS 2001

// 세션별로 송/수신 overlapped를 따로 관리
struct Session {
    WSAOVERLAPPED recvOverlapped;
    WSAOVERLAPPED sendOverlapped; // Dedicated overlapped for bundling
    SOCKET socket;
    char buffer[1024];
    WSABUF wsaBuf;
    int playerId;
    bool isSending; // The "Gate" for this player
};

class IOCPServer {
public:
    virtual ~IOCPServer() { Stop(); }

    // 포트에 리스너 소켓을 만들고 클라이언트로부터 수신을 받는 워커스레드, 게임 로직을 실행하는 업데이트 스레드 생성
    bool Start(int port) {
        WSADATA wsaData;
        WSAStartup(MAKEWORD(2, 2), &wsaData);

        hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
        listenSock = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
        sockaddr_in addr = { AF_INET, htons(port), INADDR_ANY };
        bind(listenSock, (sockaddr*)&addr, sizeof(addr));
        listen(listenSock, SOMAXCONN);

        isRunning = true;
        int threads = std::thread::hardware_concurrency();
        for (int i = 0; i < threads; i++) std::thread(&IOCPServer::WorkerRoutine, this).detach();
        std::thread(&IOCPServer::UpdateRoutine, this).detach();

        return true;
    }

    // 무한루프를 돌며 Accept받는 구간
    void Run() {
        while (isRunning) {
            sockaddr_in cAddr;
            int len = sizeof(cAddr);
            SOCKET cSock = WSAAccept(listenSock, (sockaddr*)&cAddr, &len, nullptr, NULL);
            if (cSock != INVALID_SOCKET) OnAccept(cSock);
        }
    }

    void Stop() { isRunning = false; closesocket(listenSock); WSACleanup(); }

protected:
    // 업데이트 스레드를 위해 존재하는 가상 함수
    virtual void OnUpdate() = 0;
    // 패킷이 도착했을 때 워커 스레드에서 처리되는 가상함수
    virtual void OnRawReceive(int playerId, char* data, int len) = 0;
    virtual void OnRawConnect(Session* s) = 0;
    virtual void OnRawDisconnect(int playerId) = 0;
    HANDLE hIocp;

private:
    SOCKET listenSock;
    bool isRunning = false;

    void UpdateRoutine() {
        while (isRunning) {
            OnUpdate();
            Sleep(16);
        }
    }

    // CPU 개수 * 2 숫자로 돌아가는 워커 스레드들이 돌리는 함수
    void WorkerRoutine() {
        DWORD bytes;
        ULONG_PTR key;
        LPOVERLAPPED lpOverlapped;
        while (GetQueuedCompletionStatus(hIocp, &bytes, &key, &lpOverlapped, INFINITE)) {
            if (!lpOverlapped) continue;
            Session* s = (Session*)key;

            // send가 끝난거면 다시 소켓 게이트를 열어준다.
            if (lpOverlapped == &s->sendOverlapped) {
                s->isSending = false;
                continue;
            }

            // RECV Completion
            if (bytes == 0) {
                OnRawDisconnect(s->playerId);
                closesocket(s->socket);
                delete s;
                continue;
            }
            OnRawReceive(s->playerId, s->buffer, bytes);

            DWORD flags = 0;
            ZeroMemory(&s->recvOverlapped, sizeof(WSAOVERLAPPED));
            s->wsaBuf.buf = s->buffer;
            s->wsaBuf.len = sizeof(s->buffer);
            WSARecv(s->socket, &s->wsaBuf, 1, NULL, &flags, &s->recvOverlapped, NULL);
        }
    }

    // accept할 경우 세션을 만들어주고 WSA 통신을 위한 세팅 작업을 진행한다.
    void OnAccept(SOCKET cSock) {
        BOOL bNoDelay = TRUE;
        setsockopt(cSock, IPPROTO_TCP, TCP_NODELAY, (const char*)&bNoDelay, sizeof(bNoDelay));

        Session* s = new Session();
        s->socket = cSock;
        s->isSending = false;
        ZeroMemory(&s->recvOverlapped, sizeof(WSAOVERLAPPED));
        ZeroMemory(&s->sendOverlapped, sizeof(WSAOVERLAPPED));
        
        OnRawConnect(s);
        CreateIoCompletionPort((HANDLE)cSock, hIocp, (ULONG_PTR)s, 0);

        DWORD flags = 0;
        s->wsaBuf.buf = s->buffer;
        s->wsaBuf.len = sizeof(s->buffer);
        WSARecv(cSock, &s->wsaBuf, 1, NULL, &flags, &s->recvOverlapped, NULL);
    }
};

#pragma once
#include "IOCPServer.h"
#include <map>
#include <vector>
#include <mutex>
#include <set>
#include <algorithm>

#define ARENA_W 160
#define ARENA_H 40

// IOCP 서버의 한 갈래로 클라이언트들을 2차원 평면에서 마구 돌아다니게(Roam) 하는 서버
class RoamServer : public IOCPServer {
private:
    struct GameCommand { int pId; char input; bool isDisconnect; };
    struct Player { int id; char sym; float x, y; Session* session; };

    std::map<int, Player*> players;
    std::vector<GameCommand> cmdQueue;
    std::mutex qMtx;
    int idCounter = 1;

    // Static buffers for bundled data (N size, not N^2)
    char g_bundleBuffers[MAX_PLAYERS][16384]; 

protected:
    void OnRawConnect(Session* s) override {
        s->playerId = idCounter++;
        const char* syms = "@#$&%?!*VWXYZKMLNHPabcdefghijklmnopqrstuvwxyz0123456789+={}<>";
        players[s->playerId] = new Player{ s->playerId, syms[s->playerId % 61], 20.0f, 7.0f, s };
        
        char wMsg[64];
        int len = sprintf_s(wMsg, "W %d %c %.1f %.1f\n", s->playerId, syms[s->playerId % 61], 20.0f, 7.0f);
        send(s->socket, wMsg, len, 0);
    }

    void OnRawReceive(int pId, char* data, int len) override {
        std::lock_guard<std::mutex> lock(qMtx);
        cmdQueue.push_back({ pId, data[0], false });
    }

    void OnRawDisconnect(int pId) override {
        std::lock_guard<std::mutex> lock(qMtx);
        cmdQueue.push_back({ pId, 0, true });
    }

    // 게임 상태를 업데이트하는 루틴
    void OnUpdate() override {
        std::vector<GameCommand> frameCmds;
        {
            std::lock_guard<std::mutex> lock(qMtx);
            if (cmdQueue.empty()) return;
            frameCmds.swap(cmdQueue);
        }

        std::reverse(frameCmds.begin(), frameCmds.end());
        std::set<int> movedThisFrame;
        
        // Master frame buffer to hold all U updates for the current tick
        static char masterFrameBuffer[16384]; 
        int masterLen = 0;

        for (auto& cmd : frameCmds) {
            if (cmd.isDisconnect) {
                if (players.count(cmd.pId)) {
                    char dMsg[32];
                    int dLen = sprintf_s(dMsg, "D %d\n", cmd.pId);
                    delete players[cmd.pId];
                    players.erase(cmd.pId);
                    for (auto const& [id, p] : players) send(p->session->socket, dMsg, dLen, 0);
                }
                continue;
            }

            if (movedThisFrame.count(cmd.pId) || !players.count(cmd.pId)) continue;
            movedThisFrame.insert(cmd.pId);

            Player* p = players[cmd.pId];
            if (cmd.input == 'W') p->y -= 1.0f;
            else if (cmd.input == 'S') p->y += 1.0f;
            else if (cmd.input == 'A') p->x -= 1.0f;
            else if (cmd.input == 'D') p->x += 1.0f;

            p->x = (std::max)(1.0f, (std::min)((float)ARENA_W - 2, p->x));
            p->y = (std::max)(1.0f, (std::min)((float)ARENA_H - 2, p->y));

            // Append this movement to the bundled string
            masterLen += sprintf_s(masterFrameBuffer + masterLen, 16384 - masterLen, 
                                   "U %d %c %.1f %.1f\n", p->id, p->sym, p->x, p->y);
        }

        if (masterLen <= 0) return;

        // Broadcast the bundle to everyone
        for (auto const& [targetId, targetPlayer] : players) {
            Session* s = targetPlayer->session;
            
            // Only send if the previous bundle has been fully transmitted
            if (!s->isSending) {
                memcpy(g_bundleBuffers[targetId], masterFrameBuffer, masterLen);

                WSABUF wsaBuf;
                wsaBuf.buf = g_bundleBuffers[targetId];
                wsaBuf.len = (ULONG)masterLen;

                ZeroMemory(&s->sendOverlapped, sizeof(WSAOVERLAPPED));
                s->isSending = true;

                if (WSASend(s->socket, &wsaBuf, 1, NULL, 0, &s->sendOverlapped, NULL) == SOCKET_ERROR) {
                    if (WSAGetLastError() != WSA_IO_PENDING) s->isSending = false;
                }
            }
        }
        Sleep(20);
    }
};

 박씨는 모든 용병들 중 가장 무난한 삶을 살아 본 인물입니다. 그는 살아온 인생 35년 중 27년을 밭을 갈고 씨를 뿌리고 추수를 하는데에 보냈습니다. 27년간 박 씨는 커다란 자극 없이 무난하고 행복한 삶을 살았고, 그 27년간의 행복한 세월은 그의 수동적인 인생관을 단단하게 굳혔습니다.
그 27년간 같은 일을 반복하며 안정적인 생활을 통해 쌓은 무감각함의 관성 때문인지, 그는 자신이 일하는 논과 자신이 사는 마을 밖에서 일어나는 일들이 얼마나 심각한 지도 눈치채지 못했습니다.
박 씨가 살던 나라의 새로운 독재자 김택은은 특유의 정치 감각으로 쿠데타를 저지른 후 그것을 미화시켜 농민들의 지지를 얻었습니다. 하지만 이후 그의 기형적인 권력유지체계가 수많은 숙청과 학살을 야기했고 부패와 광기, 공포로 사회는 병들어갔습니다. 결국 박씨는 자신의 딸과 아내가 부패관리에게 한꺼번에 겁탈당한 후 살해당하자 졸지에 가족을 모두 잃은 처참한 피해자로 전락하는데, 그는 이런 급격한 심적인 충격을 다스리지 못하고 낫과 호미로 고을원님의 목을 따러 갑니다.
당연히 이런 무모한 돌격에는 아무런 성과가 없었고, 되레 자신의 목이 따이려는 찰나 순진하고 만만하고 흥분한 고기방패를 찾던 개선자에게 김택은을 처치할 기회를 얻는 조건으로 용병으로 고용되었습니다.

- 사용 기술

- 배경 이야기

에밀리는 자국 외교대사의 직속 호위대장으로 일하고 있었는데, 그녀의 일솜씨는 굉장히 뛰어났지만 한편으론 난폭하고 강한 기질과 한없이 성급한 성격을 가져 에밀리는 괴팍한 악녀로 악명이 높았습니다. 물론 남성중심적 풍조의 자국 사회분위기에서 여성이 요직을 꿰찬 탓에 이야기가 과장된 것인지, 아니면 그런 남성들의 눈초리에 성미가 독해질 수밖에 없었던 것인지는 알 수 없습니다.
어느 날 인근 강대국에 조공을 바치는 행사에 호위를 맡게 된 그녀는 강대국 사절단의 호위대장 하환백과 업무상의 대화를 나누게 되었는데, 에밀리는 안 좋은 소문이 도는 약소국의 여성무관인 자신에게 한없이 친절하고 예를 지키던 하환백의 태도에 감화되었고 그 후로 오래도록 그와 정분을 나누게 됩니다. 하환백은 그녀의 거친 성격의 이면에 상처가 숨겨져 있음을 처음으로 이해해 줬으며 결국 그 둘은 혼인합니다.
하지만 극과 극의 성미를 가진 사람들의 사랑이야기로 사람들의 입에서 자주 오르내리던 그들의 관계는 오래가지 못했습니다. 그들은 양국 간의 평화를 의미하는 비공식적인 상징이 되었으나 양국의 마찰로 이익을 얻을 수 있다 판단한 부패고위관료들의 음모로 둘은 불시의 기습을 받았고 하환백은 그녀를 지키다 사망합니다. 하환백은 에밀리의 행복을 위해 그녀에게 자신이 죽으면 재혼하라는 유언을 남기지만 에밀리는 정신을 반 날려먹은 듯한 충격과 상실감을 견디지 못하고 산속에 남편을 묻은 후 옆에 오두막을 짓고 살았습니다.
나날이 늘어가는 죄책감과 남편에 대한 그리움 끝에 극단적인 선택을 하려는 찰나 개선자가 나타나 용병으로 일해준다면 에밀리의 활에 남편의 영혼을 담아 남편과 다시 함께할 기회를 주겠다는 제안을 했고, 그녀는 그 제안을 단번에 받아들였습니다.

- 사용 기술

- 배경 이야기

라이 양은 자신이 속한 부족제사장의 장남이자 후계자입니다. 그는 동생 샤오 양과 함께 부족의 전통을 지키며 살았으며, 올곧은 행실과 성품으로 주변 사람들 사이에서 그 명망이 높았습니다.
그러던 어느 해 바다 건너 다른 미지의 대륙에서 온 푸른빛 피부의 이질적인 이민자들이 그의 고향에 정착합니다. 그 후로 얼마 지나지 않아 동생 샤오 양의 심기가 이상해지더니, 점점 그녀는 부족의 제사에 불참하고 외지인들과 놀러 다니며 이민자들의 학문에 관심을 갖는 등, 사파의 길로 새게 됩니다.
라이 양은 오빠로서 동생을 바른 길로 이끌어주기 위해 노력했지만 동생은 결코 말을 듣지 않았고 어느 날 둘이 심하게 다툰 이후로 샤오 양이 실종되자 그제야 뭔가 잘못되어 있었다는 걸 느낀 라이 양은 서둘러 샤오 양을 찾아 나서지만 샤오 양의 시신만 찾게 됩니다. 제사장의 피를 이어받은 사람들 중 강인한 정신력을 가진 사람은 죽은 사람을 부활시킬 수 있는 권능을 가지고 있었(다고 믿어졌)으나 이는 자신의 부족의 숭고한 원칙인 대순환을 역행하는 일이기에 라이 양은 동생의 시신을 수습한 후 그 앞에서 동생의 목숨과 규율 중 뭘 우선시해야 하는 것인지 고민합니다.
그때 만만하고 순진한 의무병을 찾던 개선자가 갑자기 그 앞에 등장하고, 라이 양에게 용병업을 통해 샤오 양을 살릴지 말지 고민할 시간을 주겠다고 제안합니다. 라이 양은 동생을 부활시킬지 말지 동생의 시신이 부패하기 전에 서둘러 결정을 내려야 했지만 개선자의 힘을 빌린다면 용병일을 끝내고 다시 이 시점으로 돌아올 때까지의 시간을 통해 진지하게 고민을 해 볼 수 있었기에 개선자의 제안을 받아들였습니다.

- 사용 기술

- 배경 이야기

 탄초는 정신건강이 양호한 사람들과 마찬가지로 선천적으로는 정상적인 아기로 태어났습니다. 하지만 일에 바빠 가정을 돌볼 틈이 없었던 아버지와 화를 잘 내는 신경질적인 기질의 어머니 때문에 탄초는 유년기를 불안하고 불행하게 보냈고, 불행하고 불안했던 유년기의 영향으로 탄초는 죽 정서불안에 시달려 사회에서 둔재, 고문관, 또라이 취급을 받으며 살았습니다.
탄초가 30대가 되던 해에, 인근 국가에서 종교개혁이 일어나 그 영향이 사방으로 번지기 시작했는데, 그 종교개혁의 주 내용은 온전히 사회를 지키기 위해서는 마녀, 흑염소, 악마의 숙주를 있는 대로 색출해 화형, 혹은 정화해야 한다는 것이었고, 말과 행동이 어눌했던 탄초는 그중 '악마의 숙주' 혐의를 받아 입에 끓는 납물을 붓는 신성치료를 선고받고 감옥에 갇히게 되었습니다.
축축한 감옥에 갇힌 채 단념한 채로 최대한 안 아프게 자살하는 방법을 고민하던 탄초 앞에 갑자기 개선자가 나타났고, 개선자는 많은 세계를 쏘다니며 얻은 지식을 바탕으로 그를 신경증환자로 진단하며, 그에게 협조의 대가로 정신질환을 진지하게 받아들이는 문명으로의 이민을 약속하며 용병업을 제안합니다.
그저 자신의 성격과 행동양식을 운명적인 저주로 인식하고 자책하던 탄초에게 있어서, 자신을 도움이 필요한 병자로 정의하는 '정신병'이란 단어는 자신의 인생에 개선의 여지가 있으리란 희망을 줬습니다. 개선자의 제안은 탄초에게 완벽히 이상적인 두 번째 기회로 다가왔고 그는 흔쾌히 제안을 수락했습니다.

- 사용 기술

- 배경 설명

가롯은 자신의 세계에서 망치 할아범으로 불리는 괴짜 외톨이였습니다. 하지만 젊었을 적의 그는 전쟁영웅이었고 온 국민의 존경을 한 몸에 받는 나라의 아이콘이었습니다.
중년이 된 가롯은 군인의 신분에서 내려와 그동안 모아둔 돈으로 프랜차이즈 맥주사업을 하지만, 갑작스레 나라를 휩쓴 혁명이 가롯이 치른 전쟁을 비롯한 역사를 재조명했고, 순식간에 가롯은 전쟁영웅에서 영아살해자의 오명을 뒤집어쓰게 됩니다.
이런 불명예를 잠시도 견디지 못했던 가롯은 이전 이름을 버리고 현재의 가롯 보울이란 이름으로 개명한 후 외딴 벽지로 내려가 살지만, 모든 부와 명예를 잃어버린 가롯은 영웅으로 추앙받던 과거의 잔영에 집착하게 되고, 온갖 기행을 일삼는 괴짜 할아범으로 추하게 늙습니다.
남은 건 과거에 대한 그리움뿐인 가롯을 지켜본 개선자는 그에게 남은 재능과 갱생의 가능성을 함께 본 후, 가롯에게 용병으로 일 해준다면 젊음을 돌려줄 것이라 제안했고, 가롯은 왕년의 영광을 되찾을 수 있을지도 모른다는 생각이 들자 자세한 이야기를 끝까지 듣지도 않은 채 개선자의 제안을 승낙했습니다.

- 사용 기술

- 배경 이야기

논시팟사의 가문은 대대로 유명한 화가, 조각가, 행위예술가들을 배출해 온 예술가가문입니다. 논시팟사는 그중 가장 독특한 화가인데, 도화지에 굵은 선을 몇 개 그리고 색칠한 후 그 그림을 그대로 보존하는, 이 채 5분도 걸리지 않는 작업 끝에 나온 결과물을 예술작품이라 주장했기 때문입니다.
수세식 소변기에 샘이란 이름표를 단 것이 예술작품의 반열에 들어가는 오묘 신비한 현대예술을 당신은 아마 한 번쯤 접해봤기에 논시팟사를 '독특하다, 창의적이다'라고 생각해 볼 수도 있겠죠. 하지만 논시팟사가 사는 세계는 그렇게 열린 세계가 아니었습니다. 도화지에 장난질을 해 놓은 것을 가지고 예술이라 억지를 부린다며 논시팟사의 가문에서는 그를 가문의 수치로 여겼고, 평론가들은 '그는 작품을 만드는 사람이 아닌 배설하는 사람이다.'라며 시도 때도 없이 조롱합니다.
소통하지 못하는 예술가 논시팟사는 자신만의 세계에서 산 셈이죠. 그렇게 집에서 은둔생활을 하던 논시팟사의 눈앞에 만만한 보조용병을 찾던 개선자가 나타나 논시팟사의 예술을 사람들이 이해할 수 있는 것으로 만들어주겠다며 용병업을 제안합니다.
그 제안을 어떻게 거절할 수 있었겠습니까? 문밖에는 자신을 이해 못 하고 싫어하는 사람들밖에 없었는데요.

- 사용 기술

- 배경 이야기

히르만은 개선자의 마력 없이도 강한 전투력을 가지는 몇 안 되는 용병 중 하나입니다. 그는 젊은 나이에도 불구하고 상당히 복잡 다난하고 기구한 인생을 살아 10대 양아치와 같은 건들거리는 외모 안에 환갑노인의 관록과 같은 지혜를 숨기고 있습니다.
그는 빈민가 출신으로 어릴 적부터 특유의 날렵한 몸짓과 잔머리로 동네꼬마 패거리들을 평정하며 골목대장에서 건달두목으로 성장했습니다. 하지만 그는 사람을 때리고 겁먹이고 윽박지르는 일상과 지조 없고 기회주의에 찌든 근시안적인 부하들에게 오래전부터 환멸을 느끼고 있었습니다. 결국 히르만의 이름을 내세우며 패악질을 일삼던 부하들이 빈민가의 꼬마를 죽인 일을 계기로 히르만은 자기 손으로 자신의 패거리들을 모두 불구자로 만든 후 자신이 진정 원하는 삶, 진정으로 따를 가치가 있는 숭고한 가치를 찾으려 애씁니다.
아쉽게도, 그가 사는 세계는 영웅을 낳을 여건조차 되지 않던 소말리아 뺨치는 피폐한 세계였습니다. 히르만이 찾은 뭔가 숭고한 가치를 추구하던 사람들은 그저 사기꾼으로만 드러났습니다. 뭔가 숭고한 가치를 찾고자 하던 히르만의 순수함은 날이 갈수록 수없이 많은 배신과 기만과 망신을 당하며 빛이 바래갔고, 오히려 살벌한 사회에서 살아남기 위해 히르만이 직접 배신과 기만을 일삼게 되는 지경에까지 이릅니다. 그 후로 죄책감과 자기부정, 허무주의가 차례로 그의 머릿속을 차지하자, 그는 오직 안정된 삶만을 꿈꾸게 되었고 개선자가 그를 찾기 전까지 히르만은 호떡장사를 하며 살았습니다.
어느 날 남창을 모집하던 포주가 우연히 이 번들번들한 호떡장사꾼을 눈여겨보게 되고, 무력으로 히르만을 포획할 계획을 세웁니다. 진작 이상한 낌새를 눈치챈 히르만은 야반도주를 하다 포주의 강력한 졸개들에 의해 궁지에 몰리게 됐는데, 이때 개선자가 히르만의 의식 속에 나타나 강력한 힘을 주겠다며 히르만을 설득합니다. 히르만은 개선자를 그다지 믿지 않았지만, 일단 제안을 받아들이면 당장의 곤경에서는 벗어날 수 있을 것이라 생각했기에 밑져도 본전이란 식으로 용병이 됐습니다.

- 사용 기술

- 배경 이야기

 샤오 양은 한때는 부족의 전통과 신념에 강한 믿음을 가지고 있었습니다. 또 부족의 의녀로서, 또한 무녀로서, 그녀는 오래전부터 고향에 만연해있던 돌림병을 전통적인 방법대로 병자의 영혼정화와 영물의 축복을 담은 문신을 통해 치료하려 했습니다.
그러던 어느 해 바다 건너 다른 미지의 대륙에서 온 푸른빛 피부의 이질적인 이민자들이 샤오 양의 고향에 정착합니다. 그 후로 얼마 지나지 않아 샤오 양은 인생에 다시없을 충격적인 상황을 보게 되는데, 자신의 부족이 수십 년간 극복하지 못했던 지독하고 악랄했던 돌림병을 신대륙을 밟은 지 수개월도 되지 않았던 이민자들이 백신주사를 자체개발해 면역력을 갖춰 정복해 버린 것입니다. 그 후로 샤오 양은 부족이 가진 전통과 사상의 가치를 의심하기 시작하고 이민자들과 잦은 교류를 가지며 점점 새로운 세계에 눈을 뜨게 됩니다.
물론, 제사장의 딸이자 부족대표무녀, 의녀가 스스로 부족의 근간을 의심하고 외지인과 어울리는 모습을 고깝게 본 사람들의 수는 결코 적지 않았습니다. 오빠인 라이 양은 끊임없이 동생에게 자중하라 충고했지만, 동생은 결코 고집을 꺾지 않았고, 하루는 둘이 심하게 다툰 어느 날 이후로 샤오 양은 부족을 떠나 연락도 끊고 라이 양을 피합니다. 그제야 뭔가 잘못되어 있는 것을 느낀 라이 양은 다시 동생을 챙기기 위해 그 뒤를 쫓지만 어느새 샤오 양은 데소나 독도마뱀에게 물려 싸늘한 시체가 되어 있었고, 라이 양은 있을 수 없는 일이라며 절규하며 샤오 양의 시신을 수습했습니다.
하지만 어찌 된 일인지, 시간이 얼마 흐르자 샤오 양은 자리를 툭툭 털며 어떤 음침한 동굴에서 깨어났습니다. 그리고 그 앞에 나타난 개선자가 샤오 양의 내적인 가치갈등과 오빠와의 외적인 갈등을 동시에 해결해 주겠다는 조건을 걸고 샤오 양에게 용병업을 제안합니다. 샤오 양은 개선자가 자신의 목숨을 구해줬다고 생각했으며, 또 그의 분위기가 자신이 친하게 지내던 이민자들의 가볍고 자유로운 느낌과 흡사하다 느꼈습니다. 개선자에게 좋은 인상을 받은 샤오 양은 그 제안을 수락했습니다.

- 사용 기술

- 배경 이야기

메스가탄의 고향세계에서는 악마와 인간사이의 전쟁이 치열하게 벌어지고 있었습니다. 미운 정이라는 말이 이때 쓰는 말일까요? 전쟁이 장기전으로 흘러가자 악마의 힘인 마력을 인간들도 쓸 수 있게 됐는데, 메스가탄은 특히 악마의 힘이 체질에 맞았던 모양입니다. 그는 마력을 적극적으로 활용해 유황지옥불을 유출시켜 악마들을 혼내줬고 차원문주술을 익혀 수많은 악마들을 낙사, 익사시키며 음란마귀의 페로몬분비샘을 활용해 대악마 함정을 만드는 등 악마들을 조롱능욕하는 데에 일가견을 보입니다. 이런 인재를 놓칠 수 없었던 개선자는 어느 날 메스가탄의 눈앞에 나타나 그의 도움을 요청합니다. 메스가탄은 당연히 고향방위를 이유로 거절하려 했지만, 개선자가 더 강력한 힘을 미끼로 꾀어내 결국 용병이 되었습니다.

- 사용 기술

- 배경 이야기

 옐라르라는 이름은 개선자가 직접 옐라르에게 지어준 이름인데, 그 이름에 별 뜻은 없습니다. 그전까지 옐라르에게는 이름이 없었기에 뭐라고 부를 이름이 필요했고, 개선자가 ㅖ와 ㄹ의 발음이 부드럽다고 생각해 옐라르라는 혀에 착착 감기는 이름을 만들어준 것뿐입니다. 실제로 그의 이름을 발음하면 혀가 입천장을 가볍게 간지럽히는 느낌과 함께 옥구슬이 은쟁반 위를 구르는 소리가 납니다.
옐라르는 다른 용병들이 합류하기 이전부터 비서처럼 개선자의 일을 도와줬습니다. 그 비서가 이번엔 용병일을 하는 거죠.
그의 체질은 보통 사람들과 굉장히 다른데, 그는 체온부터가 영하인 괴물이며 대부분의 물질대사를 자신만의 고유한 방식으로 처리합니다. 이런 걸 봐서는 애초에 그는 고향의 다른 주민들과 같은 종에 속하지도 않을 가능성도 있습니다.
개선자에게 고용되기 전, 고향에서 옐라르는 냉기를 끊임없이 강하게 내뿜는 탓에 푸른 도깨비라는 가명으로 불리며 주민들이 모두 두려워했습니다. 본명이 없을법한 이유죠. 아무도 가까이 갈 생각을 못했으니까요. 그런 옐라르에게 처음으로 말을 건 이가 개선자인데, 개선자는 옐라르의 성품을 살펴본 후 옐라르에게 자신의 체질을 조절할 수 있는 힘을 주겠다는 조건으로 그에게 비서직을 제안합니다. 사실 그 당시 옐라르는 그 제안의 내용에 크게 귀를 기울이지는 않았고, 그저 처음으로 누가 자신에게 말을 건 기념으로 제안을 받아들입니다. 도중에 일을 때려치우지 않고 계속하는 걸 보면 하는 일에 큰 불만은 없는 것 같습니다.
그의 피부가 지금은 붉은 이유는 자신의 냉기가 동료들을 해치지는 않을까 걱정한 옐라르가 자신의 냉기를 적당히 완화시키기 위한 노력의 일환으로 파란 파장의 강한 빛 에너지는 주로 흡수하려 하고 있기 때문입니다.

- Collider 클래스 헤더

#pragma once
#include <Windows.h>
#include <vector>
#include <unordered_set>
#include "Graphic.h"
#include "Vector2.h"
#include "Vector3.h"
#include "Rect.h"

#ifdef YUNUTY_EXPORTS
#define YUNUTY_API __declspec(dllexport)
#else
#define YUNUTY_API __declspec(dllimport)
#endif

using namespace std;
namespace yunutyEngine
{
    namespace physics
    {
        class RigidBody;
        class YUNUTY_API Collider : virtual public Component
        {
        public:
            class Impl;
            Collider(Impl* impl);
            virtual ~Collider();
            //bool IsTrigger();
            //void SetAsTrigger(bool isTrigger);
            bool IsUsingCCD();
            // Continuous Collision Detection 기능을 활성화하면 한 프레임에서 다음 프레임까지의 충돌을 연속적으로 체크합니다.
            // CCD 기능이 활성화되면 Bullet through paper 현상이 발생하지 않습니다.
            void EnableCCD(bool enable);
            // 콜라이더의 크기가 0이면 터짐, 콜라이더 크기가 매우 작을때 적용되는 최소한의 스케일
        protected:
            virtual void Start()override;
            virtual void Update()override;
            virtual void OnTransformUpdate() override;
            // 피직스 객체의 월드스케일이 달라졌을 때 이를 어떻게 반영할지 결정합니다.
            virtual void ApplyScale(const Vector3d& worldScale) = 0;
            virtual void OnEnable()override;
            virtual void OnDisable()override;
            RigidBody* rigidBody;

            Impl* impl;
        private:
            bool WasPxActorInitialized();
            Vector3d cachedScale;
            friend RigidBody;
#ifdef _DEBUG
            Vector3d firstLocation;
            Quaternion firstRotation;
#endif
        };
    }
}

-Rigidbody 클래스 헤더

#pragma once
#include <Windows.h>
#include <vector>
#include <unordered_set>
#include "Graphic.h"
#include "Vector2.h"
#include "Vector3.h"
#include "Rect.h"
#include "YunutyForceType.h"
#include "YunutyPhysicsMaterialInfo.h"

#ifdef YUNUTY_EXPORTS
#define YUNUTY_API __declspec(dllexport)
#else
#define YUNUTY_API __declspec(dllimport)
#endif

// RigidBody는 콜라이더에 강체 속성을 부여하고 싶을때 사용됩니다. 콜라이더 없이는 RigidBody의 코드가 제대로 동작할 수 없습니다.
using namespace std;
namespace yunutyEngine
{
    namespace physics
    {
        class Collider;
        class YUNUTY_API RigidBody : public Component
        {
        public:
            RigidBody();
            virtual ~RigidBody();
            bool GetIsStatic();
            void SetAsStatic(bool isStatic);
            void SetAsKinematic(bool isKinematic);
            bool GetIsKinematic();

            //void SetMaterialInfo();

            void LockTranslation(bool x, bool y, bool z);
            void LockRotation(bool x, bool y, bool z);
            void SetMass(float mass);
            void AddForce(const Vector3f& forceVector, ForceType forceType);
            void AddTorque(const Vector3f& forceVector, ForceType torqueType);
        protected:
            virtual void Start() override;
            virtual void OnEnable()override;
            virtual void OnDisable()override;
        private:
            std::vector<std::function<void()>> onStartCallbacks;
            Collider* attachedCollider;
            bool isStatic{ false };
            friend Collider;
        };
    }
}

- YunutyCoroutine.h

#pragma once

#ifdef YUNUTY_EXPORTS
#define YUNUTY_API __declspec(dllexport)
#else
#define YUNUTY_API __declspec(dllimport)
#endif

#include <vector>
#include <functional>

namespace yunutyEngine
{
    class Component;
    class YunutyCycle;
    namespace coroutine
    {
        class YieldInstruction;
        struct YUNUTY_API Coroutine
        {
            struct Coroutine_Handler;
            struct promise_type {
                YieldInstruction* yield = nullptr;
                std::vector<std::function<void()>> destroyCallBack;
                Coroutine get_return_object()
                {
                    return Coroutine(std::make_shared<Coroutine_Handler>(std::coroutine_handle<promise_type>::from_promise(*this)));
                }
                std::suspend_always initial_suspend() { return std::suspend_always{}; }
                std::suspend_always final_suspend() noexcept { return std::suspend_always{}; }
                void return_void() {}
                /*void return_value(YieldInstruction& yield) { this->yield = &yield; }
                void return_value(YieldInstruction&& yield) { this->yield = &yield; }*/
                std::suspend_always yield_value(std::suspend_always) { return {}; }
                std::suspend_always yield_value(YieldInstruction& yield) { this->yield = &yield; return {}; }
                std::suspend_always yield_value(YieldInstruction&& yield) { this->yield = &yield; return {}; }
                void unhandled_exception() 
                {
                    std::rethrow_exception(std::current_exception());
                }
            };
            explicit Coroutine(const std::shared_ptr<Coroutine_Handler>& h) : handle(h) {}
            ~Coroutine()
            {
                if (handle)
                {
                    for (auto each : handle->promise().destroyCallBack)
                    {
                        each();
                    }
                }
            }
            Coroutine(Coroutine const&) = delete;
            Coroutine(Coroutine&& other) noexcept
            {
                deathWish = other.deathWish;
                handle = other.handle;
                other.handle.reset();
            };
            void PushDestroyCallBack(const std::function<void()>& callBack)
            {
                handle->promise().destroyCallBack.push_back(callBack);
            }
            Coroutine& operator=(Coroutine const&) = delete;
            void resume() { handle->resume(); }
            YieldInstruction* GetLastYield() { return handle->promise().yield; };
            bool Done() { return handle->done(); }

            class Coroutine_Handler
            {
                friend struct Coroutine;
            public:
                Coroutine_Handler(const std::coroutine_handle<promise_type>& handle)
                    : primitive_handle(handle)
                {

                }

                ~Coroutine_Handler()
                {
                    if (primitive_handle)
                    {
                        primitive_handle.destroy();
                    }
                }

                auto& promise()
                {
                    return primitive_handle.promise();
                }
                
                void resume()
                {
                    primitive_handle.resume();
                }

                bool done()
                {
                    return primitive_handle.done();
                }

            private:
                std::coroutine_handle<promise_type> primitive_handle;
            };

            std::shared_ptr<Coroutine_Handler> handle;
        private:
            bool deathWish = false;
            friend yunutyEngine::Component;
            friend yunutyEngine::YunutyCycle;
        };
    }
}

( 코루틴 클래스의 정의 )

- YunutyYieldInstruction.h

#pragma once

namespace yunutyEngine
{
    namespace coroutine
    {
        class YieldInstruction
        {
        public:
            virtual bool ShouldResume() const = 0;
            virtual void Update() = 0;
        };
    }
}

( 코루틴 함수에서 반환할수 있는 객체 YieldInstruction의 정의 )

- YunutyWaitForSeconds.h

#pragma once
#include "YunutyYieldInstruction.h"

#ifdef YUNUTY_EXPORTS
#define YUNUTY_API __declspec(dllexport)
#else
#define YUNUTY_API __declspec(dllimport)
#endif

namespace yunutyEngine
{
    namespace coroutine
    {
        class YUNUTY_API WaitForSeconds :public YieldInstruction
        {
        private:
            float elapsed{ 0 };
            float seconds{ 0 };
            bool isRealTime{ false };
        public:
            WaitForSeconds(float seconds, bool isRealTime = false);
            virtual void Update() override;
            virtual bool ShouldResume() const override;
            float GetExceededTime() const;
        };
    }
}

( 코루틴이 n초동안 쉬었다가 다시 동작을 재개하게 만드는 YieldInstruction의 한 형태인 WaitForSeconds )

- YunutyCycle.cpp

...
...
for (unsigned int i = 0; i < updateTargetComponentsSize; i++)
{
    if (!updateTargetComponents[i]->GetActive() || !updateTargetComponents[i]->GetGameObject()->GetActive())
        continue;
    UpdateComponent(updateTargetComponents[i]);
    for (auto coroutine : updateTargetComponents[i]->coroutines)
    {
        if (coroutine->Done() || coroutine->deathWish)
        {
            continue;
        }
        if (auto yield = coroutine->GetLastYield(); yield)
        {
            yield->Update();
            if (yield->ShouldResume())
            {
                coroutine->handle->promise().yield = nullptr;
                coroutine->resume();
            }
        }
        else
        {
            coroutine->resume();
        }
    }
    if (!updateTargetComponents[i]->coroutines.empty())
    {
        std::erase_if(updateTargetComponents[i]->coroutines, [](std::shared_ptr<yunutyEngine::coroutine::Coroutine> coroutine) {return coroutine->Done() || coroutine->deathWish; });

        if (!updateTargetComponents[i]->coroutines.empty())
        {
            updateTargetComponents[i]->GetGameObject()->HandleComponentUpdateState(updateTargetComponents[i]);
        }
    }
}
...
...

( 컴포넌트 객체를 Update할 때 Coroutine도 같이 업데이트하는 부분 )

BehaviourTree.h

#include <vector>
#include <functional>
#include <unordered_set>
#include <unordered_map>

class BehaviourTree
{
public:
    struct Node
    {
    private:
        int nodeKey;
        std::unordered_map<int, Node> children;
        std::vector<Node*> childrenInOrder;
    public:
        // 재심청구 플래그, 이 플래그가 true이면 노드의 onExit 주기를 실행한 후 다시 조건을 확인한다.
        int GetNodeKey() const { return nodeKey; };
        std::function<void()> onEnter = []() {};
        std::function<void()> onExit = []() {};
        std::function<void()> onUpdate = []() {};
        std::function<bool()> enteringCondtion = []() {return false; };
        Node& operator[](int key);
        friend BehaviourTree;
    };
    const std::vector<const Node*>& GetActiveNodes()const { return activeOnCurrentUpdate; };
    void Update(int reassessCount = 0);
    static constexpr int maxReassessCount = 3;
    Node& operator[](int key);
    bool reAssessFlag = false;
private:
    std::vector<const Node*> activeOnLastUpdate;
    std::vector<const Node*> activeOnCurrentUpdate;
    std::unordered_map<int, Node> rootChildren;
    std::vector<Node*> rootChildrenInOrder;
};
BehaviourTree::Node& BehaviourTree::Node::operator[](int key)
{
    if (!children.contains(key))
    {
        children[key] = Node{};
        children[key].nodeKey = key;
        childrenInOrder.push_back(&children[key]);
    }
    return children[key];
}
void BehaviourTree::Update(int reassessCount)
{
    if (reassessCount > maxReassessCount)
        return;
    reAssessFlag = false;
    activeOnCurrentUpdate.clear();
    const auto* nodeChildren = &rootChildrenInOrder;
    while (nodeChildren && !nodeChildren->empty())
    {
        auto nodeChildrenBefore = nodeChildren;
        for (const auto& node : *nodeChildren)
        {
            if (node->enteringCondtion())
            {
                activeOnCurrentUpdate.push_back(node);
                nodeChildren = &node->childrenInOrder;
                break;
            }
        }
        assert(nodeChildrenBefore != nodeChildren, "behaviour node can't reach the leaf node.");
    }
    // 먼저 Exit를 순차적으로 부르고 다음 Enter들을 부른다.
    for (int i = activeOnLastUpdate.size() - 1; i >= 0 && reassessCount == 0; i--)
    {
        if (activeOnCurrentUpdate.size() - 1 < i || activeOnLastUpdate[i] != activeOnCurrentUpdate[i])
        {
            activeOnLastUpdate[i]->onExit();
        }
    }
    // Exit를 부른 상태에서 재심청구가 들어왔다면, 다시 Update문을 실행한다.
    if (reAssessFlag)
    {
        Update(reassessCount + 1);
        return;
    }
    for (int i = 0; i < activeOnCurrentUpdate.size(); i++)
    {
        if (((int)activeOnLastUpdate.size() - 1 < i) || (activeOnLastUpdate[i] != activeOnCurrentUpdate[i]))
        {
            activeOnCurrentUpdate[i]->onEnter();
        }
        activeOnCurrentUpdate[i]->onUpdate();
    }
    activeOnLastUpdate = activeOnCurrentUpdate;
}
BehaviourTree::Node& BehaviourTree::operator[](int key)
{
    if (!rootChildren.contains(key))
    {
        rootChildren[key] = Node{};
        rootChildren[key].nodeKey = key;
        rootChildrenInOrder.push_back(&rootChildren[key]);
    }
    return rootChildren[key];
}

Unit.cpp

...
...
unitBehaviourTree[UnitBehaviourTree::Hold][UnitBehaviourTree::Stop].enteringCondtion = [this]()
    {
        return true;
    };
unitBehaviourTree[UnitBehaviourTree::Hold][UnitBehaviourTree::Stop].onEnter = [this]()
    {
        OnStateEngage<UnitBehaviourTree::Stop>();
    };
unitBehaviourTree[UnitBehaviourTree::Hold][UnitBehaviourTree::Stop].onExit = [this]()
    {
        OnStateExit<UnitBehaviourTree::Stop>();
    };
unitBehaviourTree[UnitBehaviourTree::Move].enteringCondtion = [this]()
    {
        return CanProcessOrder<UnitOrderType::Move>();
    };
unitBehaviourTree[UnitBehaviourTree::Move].onEnter = [this]()
    {
        currentOrderType = pendingOrderType;
        pendingOrderType = UnitOrderType::None;
        OnStateEngage<UnitBehaviourTree::Move>();
    };
unitBehaviourTree[UnitBehaviourTree::Move].onExit = [this]()
    {
        OnStateExit<UnitBehaviourTree::Move>();
        if (pendingOrderType == UnitOrderType::None)
        {
            OrderHold();
            unitBehaviourTree.reAssessFlag = true;
        }
    };
unitBehaviourTree[UnitBehaviourTree::Move].onUpdate = [this]()
    {
        OnStateUpdate<UnitBehaviourTree::Move>();
    };
 ...
 ...

( 유닛의 초기화 코드 중 유닛이 가진 행동 트리의 각 노드의 진입조건, 진입시 실행할 함수, 해당 노드가 활성화되어있는 동안 실행할 업데이트 동작 등 노드의 속성을 지정하는 코드 )

UnitAcquistionCollider.h

#pragma once
#include "YunutyEngine.h"
#include "UnitAcquisitionCollider.h"

class Unit;
class UnitAcquisitionCollider : virtual public Component
{
public:
    // nullable
    std::weak_ptr<Unit> owner;
    int teamIndex{ 0 };
    // 콜라이더에 닿은 모든 유닛과 owner 기준 적, 아군 유닛들의 목록
    const std::unordered_set<Unit*>& GetUnits() { return units; }
    const std::unordered_set<Unit*>& GetEnemies() { return enemies; }
    const std::unordered_set<Unit*>& GetFriends() { return friends; }
    bool includeDeadUnits = false;
    bool includeInvulnerableUnits = false;
protected:
    virtual void Update() override;
    int GetTeamIndex();

    // 유닛이면 일단 집어넣는 리스트
    std::unordered_set<Unit*> unitsWhatSoEver;

    std::unordered_set<Unit*> units;
    std::unordered_set<Unit*> enemies;
    std::unordered_set<Unit*> friends;

    GameObject* debugMesh = nullptr;
private:
    bool ShouldContain(Unit* unit);
    virtual void OnTriggerEnter(physics::Collider* other) override;
    virtual void OnTriggerExit(physics::Collider* other) override;
};

UnitAcquistionCollider.cpp

#include "UnitAcquisitionCollider.h"
#include "InWanderLand.h"

bool UnitAcquisitionCollider::ShouldContain(Unit* unit)
{
    return (includeDeadUnits || unit->IsAlive()) && (includeInvulnerableUnits || !unit->IsInvulenerable());
}

void UnitAcquisitionCollider::OnTriggerEnter(physics::Collider* other)
{
    if (auto collider = other->GetGameObject()->GetComponent<UnitCollider>(); collider)
    {
        auto unit = collider->owner.lock().get();
        unitsWhatSoEver.insert(unit);
        bool includeDeadUnits = false;
        bool includeInvulnerableUnits = false;
        if (ShouldContain(unit))
        {
            units.insert(unit);
            int teamIndex = GetTeamIndex();
            int otherTeamIndex = unit->GetTeamIndex();
            if (teamIndex != otherTeamIndex)
            {
                enemies.insert(unit);
            }
            else
            {
                friends.insert(unit);
            }
        }
    }
}

void UnitAcquisitionCollider::OnTriggerExit(physics::Collider* other)
{
    if (!other) return;
    if (auto collider = other->GetGameObject()->GetComponent<UnitCollider>(); collider)
    {
        auto unit = collider->owner.lock().get();
        unitsWhatSoEver.erase(unit);
        units.erase(unit);
        enemies.erase(unit);
        friends.erase(unit);
    }
}

void UnitAcquisitionCollider::Update()
{
    units.clear();
    friends.clear();
    enemies.clear();
    std::copy_if(unitsWhatSoEver.begin(), unitsWhatSoEver.end(), std::inserter(units, units.end()), [this](Unit* const unit) { return ShouldContain(unit); });
    std::copy_if(units.begin(), units.end(), std::inserter(friends, friends.end()), [this](Unit* const unit) {return unit->GetTeamIndex() == GetTeamIndex(); });
    std::copy_if(units.begin(), units.end(), std::inserter(enemies, enemies.end()), [this](Unit* const unit) {return unit->GetTeamIndex() != GetTeamIndex(); });
}

int UnitAcquisitionCollider::GetTeamIndex()
{
    if (owner.expired())
        return teamIndex;
    else
        return owner.lock()->GetTeamIndex();
}

Unit 클래스의 멤버 변수로 쓰이며 각각 유닛의 공격범위, 유닛의 적 탐색 범위 역할을 수행하는 UnitAcquisitionCollider

...
...
    // 공격범위와 적 포착범위
    std::weak_ptr<UnitAcquisitionSphereCollider> attackRange;
    std::weak_ptr<UnitAcquisitionSphereCollider> acquisitionRange;
    std::weak_ptr<yunutyEngine::graphics::Animator> animatorComponent;
 ...
 ...

지면에서 문어발을 소환해 유닛을 중심으로 끌어모으는 스킬의 코드

UrsulaParalysisSkill.cpp

coroutine::Coroutine UrsulaParalysisSkill::operator()()
{
    colliderEffectRatio = 3.0f * 0.5f;
    auto blockFollowingNavigation = owner.lock()->referenceBlockFollowingNavAgent.Acquire();
    auto blockAnimLoop = owner.lock()->referenceBlockAnimLoop.Acquire();
    auto disableNavAgent = owner.lock()->referenceDisableNavAgent.Acquire();
    animator = owner.lock()->GetAnimator();
    paralysisAnim = wanderResources::GetAnimation(owner.lock()->GetFBXName(), UnitAnimType::Skill2);

    owner.lock()->SetDefaultAnimation(UnitAnimType::None);
    owner.lock()->PlayAnimation(UnitAnimType::Skill2);

    effectColliderCoroutine = owner.lock()->StartCoroutine(SpawningFieldEffect(dynamic_pointer_cast<UrsulaParalysisSkill>(selfWeakPtr.lock())));
    effectColliderCoroutine.lock()->PushDestroyCallBack([this]()
        {
            tentacleAnimator->GetGI().SetPlaySpeed(1);
            waveAnimator->GetGI().SetPlaySpeed(1);
            waveVFXAnimator.lock()->SetSpeed(1);

            FBXPool::Instance().Return(tentacleObject);
            FBXPool::Instance().Return(waveObject);
            UnitAcquisitionSphereColliderPool::Instance().Return(damageCollider);
            UnitAcquisitionSphereColliderPool::Instance().Return(knockBackCollider);
        });

    while (!animator.lock()->IsDone())
    {
        co_await std::suspend_always{};
    }

    disableNavAgent.reset();
    blockFollowingNavigation.reset();
    owner.lock()->Relocate(owner.lock()->GetTransform()->GetWorldPosition());
    if (owner.lock()->GetPendingOrderType() == UnitOrderType::None)
        owner.lock()->OrderAttackMove();
    co_return;
}

 Unit 클래스에서 스킬 코루틴 객체를 실행하고 coroutineSkill 변수에 집어넣는 코드

Unit.cpp

template<>
void Unit::OnStateEngage<UnitBehaviourTree::SkillCasting>()
{
    assert(pendingSkill.get() != nullptr);
    SetDesiredRotation(pendingSkill.get()->targetPos - GetTransform()->GetWorldPosition());
    onGoingSkill = std::move(pendingSkill);
    coroutineSkill = StartCoroutine(onGoingSkill.get()->operator()());
    onSkillActivation(onGoingSkill);
}

 스킬 코루틴이 현재 진행중이라면 유닛 행동 트리의 SkillOnGoing 노드가 활성화된다.

Unit.cpp

...
...
  unitBehaviourTree[UnitBehaviourTree::Skill][UnitBehaviourTree::SkillOnGoing].enteringCondtion = [this]()
        {
            return !coroutineSkill.expired();
        };
...
...

GameObjectPool.h

#pragma once
#include "Component.h"
#include "GameObject.h"
#include "Scene.h"
#include "SingletonClass.h"
#include <functional>
#include <unordered_set>
#include <deque>
#include <vector>

#ifdef YUNUTY_EXPORTS
#define YUNUTY_API __declspec(dllexport)
#else
#define YUNUTY_API __declspec(dllimport)
#endif

using namespace std;
using namespace yunutyEngine;
namespace yunutyEngine
{
    // 오브젝트가 필요하면 생성하고, 생성된 오브젝트의 용도가 다 끝나면 폐기하는 대신 비활성화만 시켜놨다가,
    // 다시 오브젝트에 대한 요청이 들어오면 재활성화 시키는 오브젝트 풀 객체입니다. 
    template<typename RepresenstativeComponent>
    class GameObjectPool
    {
        static_assert(std::is_base_of<Component, RepresenstativeComponent>::value, "only derived classes from component are allowed");
    public:
        virtual GameObject* GameObjectInitializer() { return Scene::getCurrentScene()->AddGameObject(); };
        // 빌려줄 오브젝트가 단 하나도 없을 경우, 활성화된 씬에서 게임 오브젝트를 생성한 뒤 RepresentativeComponent를 붙여줍니다.
        // 이 작업 이후 추가적으로 실행할 초기화 함수를 정의합니다.
        virtual void ObjectInitializer(std::weak_ptr<RepresenstativeComponent> comp) = 0;
        // 오브젝트를 하나 빌렸을 때 실행될 함수를 정의합니다. 굳이 정의 안해도 됩니다.
        virtual void OnBorrow(std::weak_ptr<RepresenstativeComponent> comp) {};
        // 게임 오브젝트 풀에 저장된 게임 오브젝트를 활성화합니다.
        std::weak_ptr<RepresenstativeComponent> Borrow();
        // 게임 오브젝트 풀에서 관리하는 게임 오브젝트를 되돌려 줍니다.
        void Return(std::weak_ptr<RepresenstativeComponent>);
        int poolObjectsSize() { return poolObjects.size(); };
        int expendableObjectsSize() { return expendableObjects.size(); };
        void Clear();

    protected:
        const deque<std::weak_ptr<RepresenstativeComponent>>& GetPoolObjects() {
            return poolObjects;
        }
    protected:
        std::deque<std::weak_ptr<RepresenstativeComponent>> poolObjects;
        std::deque<std::weak_ptr<RepresenstativeComponent>> expendableObjects;
        std::unordered_set<RepresenstativeComponent*> expendableObjectSet;
    };

    template<typename RepresenstativeComponent>
    std::weak_ptr<RepresenstativeComponent> GameObjectPool<RepresenstativeComponent>::Borrow()
    {
        if (expendableObjects.empty())
        {
            auto gameObject = GameObjectInitializer();
            auto component = gameObject->AddComponentAsWeakPtr<RepresenstativeComponent>();
            ObjectInitializer(component);
            poolObjects.push_back(component);
            expendableObjects.push_back(component);
        }
        auto target = expendableObjects.front();
        expendableObjects.pop_front();
        expendableObjectSet.erase(target.lock().get());
        OnBorrow(target);
        target.lock()->GetGameObject()->SetSelfActive(true);
        return target;
    }

    template<typename RepresenstativeComponent>
    void GameObjectPool<RepresenstativeComponent>::Return(std::weak_ptr<RepresenstativeComponent> obj)
    {
        if (expendableObjectSet.contains(obj.lock().get()))
        {
            return;
        }
        expendableObjects.push_back(obj);
        expendableObjectSet.insert(obj.lock().get());
        obj.lock()->GetGameObject()->SetSelfActive(false);
    }
    template<typename RepresenstativeComponent>
    inline void GameObjectPool<RepresenstativeComponent>::Clear()
    {
        for (auto each : poolObjects)
        {
            Scene::getCurrentScene()->DestroyGameObject(each.lock()->GetGameObject());
        }
        poolObjects.clear();
        expendableObjects.clear();
        expendableObjectSet.clear();
    }
}

UnitPool.h

#pragma once
#include "YunutyEngine.h"

namespace application
{
    namespace editor
    {
        class Unit_TemplateData;
        class UnitData;
    }
}
class Unit;

class UnitPool : public SingletonClass<UnitPool>
{
public:
    /// Editor 에서 Map 이 바뀔 때, 초기화하는 함수입니다.
    void Reset();
    std::weak_ptr<Unit> Borrow(application::editor::UnitData* data);
    std::weak_ptr<Unit> Borrow(application::editor::Unit_TemplateData* td, const Vector3d& position, float rotation);
    std::weak_ptr<Unit> Borrow(application::editor::Unit_TemplateData* td, const Vector3d& position, const Quaternion& rotation);
    void Return(std::weak_ptr<Unit>);
private:
    std::weak_ptr<Unit> Borrow(application::editor::Unit_TemplateData* td);
    class PoolByTemplate : public GameObjectPool<Unit>
    {
    public:
        application::editor::Unit_TemplateData* templateData{ nullptr };
        virtual void ObjectInitializer(std::weak_ptr<Unit> unit) override;
        virtual void OnBorrow(std::weak_ptr<Unit> unit) override;
    };
    std::unordered_map<const application::editor::Unit_TemplateData*, std::shared_ptr<PoolByTemplate>> poolsByTemplate;
};

ProjectilePool.h

#pragma once
#include "YunutyEngine.h"
#include "Projectile.h"
#include "ProjectileType.h"
#include "InWanderLand.h"
#include <DirectXMath.h>

class Projectile;
struct ProjectileType;
struct ProjectileHoming;
// ProjectilePool은 fbx 이름별로 여러가지 풀들을 갖고 있다.
// ProjectilePool은 풀 집합체와 같다고 할 수 있다.
//template <typename T>
class ProjectilePool : public SingletonClass<ProjectilePool>
{
public:
    std::weak_ptr<Projectile> Borrow(std::weak_ptr<Unit> owner, std::weak_ptr<Unit> opponent);
    void Return(std::weak_ptr<Projectile>);
private:
    class PoolByMesh : public GameObjectPool<Projectile>
    {
    public:
        string fbxname;
        virtual void ObjectInitializer(std::weak_ptr<Projectile> projectile) override;
    };
    std::unordered_map<string, std::shared_ptr<PoolByMesh>> poolsByFBX;
    std::unordered_map<Projectile*, std::weak_ptr<PoolByMesh>> poolsByProjectile;
};

JsonUIData.h

#pragma once
#include "Storable.h"
#include "JsonUIFloatType.h"

struct JsonUIData
{
    // string imageName;
    std::string uiName;
    std::array<float, JsonUIFloatType::NUM> floats;
    int uiIndex;
    // 부모가 없다면 부모를 1920 * 1080 크기의 스크린 스페이스로 가정하게 된다.
    int parentUIIndex = -1;
    std::string imagePath;
    std::string koreanImagePath;
    std::string englishImagePath;
    std::string japaneseImagePath;
    int imagePriority;
    // 만약 플래그에 openingButton이 있다면 버튼을 눌렀을 때 활성화시킬 UI 창을 의미한다.
    std::vector<int> openTargets;
    // 만약 플래그에 diablingButton이 있다면 버튼을 눌렀을 때 비활성화시킬 UI 창을 의미한다.
    std::vector<int> closeTargets;
    std::vector<int> disablePropagationTargets;
    std::vector<int> enablePropagationTargets;
    std::vector<int> hoverEnableTargets;
    std::vector<float> color;
    std::vector<float> pivot;
    std::vector<float> anchor;
    std::vector<float> anchoredPosition;
    std::vector<float> enableOffset;
    std::vector<float> disableOffset;
    bool popUpX, popUpY, popUpZ;
    bool popDownX, popDownY, popDownZ;
    // 숫자를 표현할 때, 각 자릿수별로 숫자 폰트 이미지를 갈아치울 UI 객체들을 의미합니다.
    std::vector<int> numberDigits;
    // 숫자를 표현할 때 사용할 숫자 폰트 이미지 세트를 의미합니다.
    int numberFontSet;
    // 0~9까지의 숫자 폰트 이미지를 매핑합니다.
    std::vector<int> numberFontSetImages;
    // 숫자를 표현할 때, 올림처리하면 true, 내림처리하면 false입니다.
    bool numberCeil;
    // 0을 표시할지 여부입니다.
    bool numberShowZero;
    std::string soundOnClick;
    std::string soundOnHover;
    std::string soundOnEnable;
    std::string soundOnDisable;
    int enableCurveType;
    int disableCurveType;
    // 업그레이드 버튼의 경우, 활성화하기 위해 필요한 다른 버튼의 인덱스를 의미합니다.
    int dependentUpgrade{ -1 };
    vector<float> linearClipOnEnableStart;
    vector<float> linearClipOnEnableDir;
    int linearClipOnEnableCurveType;
    vector<float> linearClipOnDisableStart;
    vector<float> linearClipOnDisableDir;
    int linearClipOnDisableCurveType;
    vector<float> colorTintOnEnableStart;
    vector<float> colorTintOnEnableEnd;
    int colorTintOnEnableCurveType;
    vector<float> colorTintOnDisableStart;
    vector<float> colorTintOnDisableEnd;
    int colorTintOnDisableCurveType;
    // 전체 셀의 갯수
    int barCells_CellNumber;
    // 임의로 사용하게 될 사용자 플래그
    bool disableOnStartEdtior;
    bool disableOnStartExe;
    string musicPlayOnEnable_musicClip;
    string musicPlayOnDisable_musicClip;
    std::vector<int> exclusiveEnableGroup;
    string animatedSpriteFolderPath;
    bool animatedSpriteIsRepeat;
    bool duplicate_poolable;
    string videoPath1;
    string videoPath2;
    bool videoUnscaledDeltaTime;
    // 숫자를 가운데 정렬할지의 여부입니다.
    bool centerAlign;
    bool reAlignOnDisable;

    int customFlags;
    int customFlags2;
    // UI의 고유한 EnumID
    int enumID;
    // 사운드 매핑을 위한 ID
    int soundEnumID;
    FROM_JSON(JsonUIData);
};

(Json 형식으로 저장되는 UI 객체 하나의 정보)

UIExportFlag.h

enum class UIExportFlag
{
    None = 0,
    // 마우스가 올라갔을 때, 마우스가 클릭했을 때 등의 상호작용을 받습니다.
    IsButton = 1 << 0,
    // 특정 UI들을 닫는 용도로 쓰입니다.
    CloseButton = 1 << 1,
    // 특정 UI들을 여는 용도로 쓰입니다.
    OpeningButton = 1 << 2,
    // 비활성화시 그레이 스케일 적용된 이미지를 출력합니다.
    GrayScaleDisable = 1 << 4,
    // 활성화될때 팝업 효과를 줍니다.
    IsPoppingUp = 1 << 5,
    // 비활성화될때 사이즈를 줄입니다.
    IsPoppingDown = 1 << 6,
    // 버튼 위에 마우스 포인터가 올라왔을 때 자식 오브젝트들을 보여줍니다.
    IsIncludingTooltips = 1 << 7,
    // 게임을 시작할때 비활성화된 채로 시작합니다.
    DisableOnStart = 1 << 8,
    // 버튼이 토글 동작을 할때 사용됩니다.
    IsToggle = 1 << 9,
    // UI 이미지가 활성화될때 트랜슬레이션 오프셋 애니메이션을 재생합니다.
    IsTranslatingOnEnable = 1 << 10,
    // UI 이미지가 비활성화될때 트랜슬레이션 오프셋 애니메이션을 재생합니다.
    IsTranslatingOnDisable = 1 << 11,
    // 체력, 마나와 같은 값을 70 / 100과 같은 형태로 표시하는 텍스트입니다.
    // Adjuster에 들어가는 실수 값을 분자로 사용하며, 최대값이 갱신되면 분모도 갱신됩니다.
    //IsGuageText = 1 << 12,
    // 0~1 사이의 값으로 UI 이미지의 세로 크기를 조절할 수 있습니다.
    CanAdjustHeight = 1 << 13,
    // 0~1 사이의 값으로 UI 이미지의 가로 크기를 조절할 수 있습니다.
    CanAdjustWidth = 1 << 14,
    // 0~1 사이의 값으로 UI 이미지의 Radial Fill 각을 조절할 수 있습니다.
    CanAdjustRadialFill = 1 << 15,
    // 원본 이미지가 그저 사각형 흰색 이미지인지 나타냅니다.
    IsBlankImage = 1 << 16,
    // 이 이미지 아래에 깔린 버튼은 클릭이 가능합니다.
    NoOverlaying = 1 << 17,
    // 이미지가 커졌다가 작아지는 애니메이션을 반복적으로 재생합니다.
    IsPulsing = 1 << 18,
    ///////////////////////////
    // 여러 자리의 숫자를 표현합니다. 기본적으로 내림으로 연산이 되나, 0~1 사이의 값을 올림처리할지, 내림처리할지는 속성값에 따라 결정됩니다.
    IsNumber = 1 << 19,
    // 클릭할 때 효과음을 재생합니다.
    PlaySoundOnClick = 1 << 20,
    // 마우스가 올라갔을 때 효과음을 재생합니다.
    PlaySoundOnHover = 1 << 21,
    // UI 객체가 활성화될때 효과음을 재생합니다.
    PlaySoundOnEnable = 1 << 22,
    // UI 객체가 비활성화될때 효과음을 재생합니다.
    PlaySoundOnDisable = 1 << 23,
    // 자식 게임 객체들의 위치를 인덱스별로 저장해뒀다가, 활성화된 자식 객체들을 인덱스별로 저장된 위치에 자식 인덱스 순서대로 배치합니다.
    PriorityLayout = 1 << 24,
    // 0~9까지의 숫자 폰트를 의미하는 폰트 이미지 세트를 자식으로 가집니다. 이 이미지 세트는 IsNumber 속성을 가진 UI객체가 폰트 이미지를 바꾸는 데에 사용됩니다.
    IsDigitFont = 1 << 25,
    // 스킬 업그레이드에 쓰이는 버튼입니다. 선행 업그레이드를 가질 수 있습니다.
    IsSkillUpgrade = 1 << 26,
    // UI의 크기가 화면의 해상도에 따라 달라집니다.
    // 1920, 1080 해상도에서 만들어진 UI 이미지를 1280, 720 해상도에서 사용할 때, 이미지의 크기를 0.6667배로 조정합니다.
    ScaledByResolution = 1 << 27,
    // UI가 활성화될때 시간을 멈춥니다.
    TimeStopOnEnable = 1 << 28,
    // UI가 비활성화될때 시간정지를 해제합니다.
    TimeContinueOnDisable = 1 << 29,
    // UI가 활성화될때 투명도 애니메이션을 재생합니다.
    ColorTintOnEnable = 1 << 30,
    // UI가 비활성화될때 투명도 애니메이션을 재생합니다.
    ColorTintOnDisable = 1 << 31,

};
enum class UIExportFlag2
{
    None = 0,
    LinearClipOnEnable = 1 << 0,
    LinearClipOnDisable = 1 << 1,
    Duplicatable = 1 << 2,
    // 체력바, 마나 바 등 연속적인 데이터의 수치를 추정하기 위해 게이지의 일정단위마다 셀을 끊어 표시하고 싶을때 사용됩니다.
    IsBarCells = 1 << 3,
    // 0일때 하나도 클립 안함, 1일때 완전히 클립함
    AdjustLinearClip = 1 << 4,
    PlayMusicOnEnable = 1 << 5,
    PlayMusicOnDisable = 1 << 6,
    PauseMusicOnEnable = 1 << 7,
    UnPauseMusicOnDisable = 1 << 8,
    MultiplyMusicVolumeOnEnableDisable = 1 << 9,
    ExclusiveEnable = 1 << 10,
    DisableAfterEnable = 1 << 11,
    Dialogue_Manual = 1 << 12,
    Dialogue_Timed = 1 << 13,
    RedundantEnable = 1 << 14,
    AnimatedSprite = 1 << 15,
    ScriptUI = 1 << 16,
    EnumSound = 1 << 17,
    Rotating = 1 << 18,
    StartGameButton = 1 << 19,
    ReturnToTitleButton = 1 << 20,
    Video = 1 << 21,
    PropagateEnable = 1 << 22,
    PropagateDisable = 1 << 23,
    CapsuleClip = 1 << 24,
    DisableOnlyOnImport = 1 << 25,
    MultiLanguage = 1 << 26,
};

( UI 객체의 속성을 나타내는 플래그 )

UIEnumID

#pragma once
#include "PodStructs.h"

enum class UIEnumID
{
    // 아무것도 아님.
    None = 0,
    // 로빈, 우르술라, 헨젤의 초상화, 초상화 위의 이름 태그, 초상화를 가리는 적색 부상 오버레이, 체력바, 체력을 표시하는 텍스트 UI
    CharInfo_Robin,
    CharInfo_Ursula,
    CharInfo_Hansel,
    CharInfo_Robin_Left,
    CharInfo_Ursula_Left,
    CharInfo_Hansel_Left,
    CharInfo_Portrait,
    CharInfo_PortraitBloodOverlay,
    CharInfo_NameTag,
    CharInfo_HP_Fill,
    CharInfo_HP_Number_Current,
    CharInfo_HP_Number_Max,
    CharInfo_Buff_Bleeding,
    CharInfo_Buff_Blinding,
    CharInfo_Buff_Paralysis,
    CharInfo_Buff_KnockBack,
    CharInfo_Buff_Taunted,
    CharInfo_Buff_UrsulaSelf,
    CharInfo_Buff_HanselBuff,
    CharInfo_Buff_HanselDebuff,
    CharInfo_Skill_Use_Q,
    CharInfo_Skill_Use_Q_Overlay,
    CharInfo_Skill_Use_Q_Cooltime_Number,
    CharInfo_Skill_Use_W,
    CharInfo_Skill_Use_W_Overlay,
    CharInfo_Skill_Use_W_Cooltime_Number,
    // 전술모드 토글버튼
    Toggle_TacticMode,
    // 전술모드 토글버튼 흑백 오버레이
    Toggle_TacticMode_Overlay,
    Toggle_TacticMode_Cooltime_Number,
    // 화면 하단 마나 게이지
    ManaBar1,
    // 전술 모드 마나 게이지
    ManaBar2,
    // 화면 하단 마나 게이지 중 사용 대상이 되는 마나 오버레이
    ManaBarSpendOverlay1,
    // 전술 모드 마나 게이지 중 사용 대상이 되는 마나 오버레이
    ManaBarSpendOverlay2,
    // 현재 마나량을 나타내는 텍스트
    Mana_Text_CurrentMP,
    Mana_Text_CurrentMP_Tactic,
    // 최대 마나량을 나타내는 텍스트
    Mana_Text_MaxMP,
    Mana_Text_MaxMP_Tactic,
    // 사운드가 켜진 상태에서 표시할 UI버튼
    Sound_On,
    // 사운드가 꺼진 상태에서 표시할 UI버튼
    Sound_Off,
    // 음악이 켜진 상태에서 표시할 UI버튼
    Music_On,
    // 음악이 꺼진 상태에서 표시할 UI버튼
    Music_Off,
    // 인게임에서 사용되는 캐릭터 상태창, 전술모드 진입 버튼을 포함하는 하단 레이아웃
    Ingame_Bottom_Layout,
    // 인게임에서 사용되는 메뉴버튼
    Ingame_MenuButton,
    // 콤보 횟수를 표시함
    Ingame_Combo_Number,
    // "Combo"라는 문자를 표시함
    Ingame_Combo_Text,
    Ingame_Combo_DescriptionTitleImg,
    // 어떤 콤보를 달성해야 하는지 설명하는 텍스트, 몇 콤보를 달성해야 하는지에 대한 표시, 콤보 달성을 표시하는 체크박스의 V자 문양
    Ingame_Combo_Description1,
    Ingame_Combo_DescriptionImageUnfinished1,
    Ingame_Combo_DescriptionImageFinished1,
    Ingame_Combo_TargetNumUnfinished1,
    Ingame_Combo_TargetNumFinished1,
    Ingame_Combo_Check1,
    Ingame_Combo_Description2,
    Ingame_Combo_DescriptionImageUnFinished2,
    Ingame_Combo_DescriptionImageFinished2,
    Ingame_Combo_TargetNumUnfinished2,
    Ingame_Combo_TargetNumFinished2,
    Ingame_Combo_Check2,
    Ingame_Combo_Description3,
    Ingame_Combo_DescriptionImageUnFinished3,
    Ingame_Combo_DescriptionImageFinished3,
    Ingame_Combo_TargetNumUnfinished3,
    Ingame_Combo_TargetNumFinished3,
    Ingame_Combo_Check3,
    Ingame_Vinetting,
    BlackMask_Alpha,
    BlackMask_RightToLeft,
    BlackMask_TopToBottom,
    BlackMask_LeftToRight,
    BlackMask_BottomToTop,
    // 게임을 시작할 때, 메인화면으로 돌아갈 때에 사용되는 블랙마스크, 단순 연출용이 아니라 실제 게임로드, 종료를 위한 기능이 있다.
    BlackMask_GameLoad,
    BlackMask_GameEnd,
    LetterBox_Top,
    LetterBox_Bottom,
    // 인게임 하단에서 클릭할 시 스킬트리 메뉴를 여는 메뉴버튼
    InGame_SkiltreeMenu_Active,
    InGame_SkiltreeMenu_InActive,
    SkillPoint_Number,
    SkillUpgradeButtonRobin00,
    SkillUpgradeButtonRobin11,
    SkillUpgradeButtonRobin12,
    SkillUpgradeButtonRobin21,
    SkillUpgradeButtonRobin22,
    SkillUpgradeButtonUrsula00,
    SkillUpgradeButtonUrsula11,
    SkillUpgradeButtonUrsula12,
    SkillUpgradeButtonUrsula21,
    SkillUpgradeButtonUrsula22,
    SkillUpgradeButtonHansel00,
    SkillUpgradeButtonHansel11,
    SkillUpgradeButtonHansel12,
    SkillUpgradeButtonHansel21,
    SkillUpgradeButtonHansel22,
    SkillUpgradeButton_UpgradedImage,
    SkillUpgradeButton_Upgradable,
    SkillUpgradeButton_InUpgradableImage,
    PopUpMessage_NotEnoughSP,
    PopUpMessage_RequirementNotMet,
    PopUpMessage_PermissionForUpgrade,
    PopUpMessage_PermissionForUpgradeProceedButton,
    PopUpMessage_WarningForRestart,
    PopUpMessage_WarningForRestart_ProceedButton,
    StatusBar_Elite,
    StatusBar_MeleeEnemy,
    StatusBar_Hero_Robin,
    StatusBar_Hero_Ursula,
    StatusBar_Hero_Hansel,
    StatusBar_Boss,
    StatusBar_LeftDoor,
    StatusBar_RightDoor,
    StatusBar_Boss_Tactic,
    StatusBar_LeftDoor_Tactic,
    StatusBar_RightDoor_Tactic,
    StatusBar_HP_Number_Current,
    StatusBar_HP_Number_Max,
    StatusBar_HP_Cells,
    StatusBar_HP_Fill,
    StatusBar_SelectionName,
    TitleRoot,
    Quit_Proceed,
    MouseCursor,
    MouseCursor_Free,
    MouseCursor_Skill,
    MouseCursor_AttackMove,
    MouseCursor_OnButton,
    MouseCursor_OnEnemy,
    MouseCursor_OnAlly,
    MoveTargetFeedbackAnimSprites,
    AttackMoveTargetFeedbackAnimSprites,
    ErrorPopup_NoMana,
    ErrorPopup_Cooltime,
    ErrorPopup_CantLand,
    ErrorPopup_TacticQueueFull,
    VictoryPage,
    DefeatPage,
    TacticModeIngameUI,
    TacticModeRevertButton_Active,
    TacticModeRevertButton_InActive,
    TacticModeCommandIcon1,
    TacticModeCommandIcon2,
    TacticModeCommandIcon3,
    TacticModeCommandIcon4,
    TacticModeCommandIcon5,
    TacticModeCommandIcon6,
    TacticModeCommandIcon7,
    TacticModeCommandIcon8,
    TacticModeCommandIcon9,
    TacticModeCommandIcon10,
    TacticModeCommandIcon11,
    TacticModeCommandIcon12,
    BeaconOutside_Robin,
    BeaconOutside_Ursula,
    BeaconOutside_Hansel,
    BeaconOutside_Arrow,
    // 일반 잡졸들에 적용되는 데미지 표시기
    DamageIndicator_Default,
    DamageIndicator_Critical,
    DamageIndicator_Default_RedFont,
    DamageIndicator_Critical_RedFont,
    DamageIndicator_Default_BlueFont,
    DamageIndicator_Critical_BlueFont,
    DamageIndicator_Default_Cyan,
    DamageIndicator_Critical_Cyan,
    DamageIndicator_Default_BlackWhiteFont,
    DamageIndicator_Critical_BlackWhiteFont,
    DamageIndicator_Missed,
    DamageIndicator_Number,
    // 보스전때에만 출력되는 UI들
    BossUI_Default,
    BossUI_Tactic,
    CheckPointReached,
    LoadCheckPointButton1,
    LoadCheckPointButton2,
    InGameMenu,
    Localization,
};

( 특정 UI들의 고유한 ID를 나타내는 Enum )

UIYutility.cs, 유니티에서 UI 데이터를 내보내는데 쓰이는 클래스

using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEditor;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Collections.Generic;
using System.IO;
using UnityEngine.Windows.Speech;
using Newtonsoft.Json.Serialization;
using UnityEngine.UI;
using UnityEngine.Assertions;
using JetBrains.Annotations;
using System;
using System.Linq;

public class UIYutility : MonoBehaviour
{
    [Serializable]
    public class UIDataList : List<UIExportJsonData>
    {
        public List<UIExportJsonData> dataList = new List<UIExportJsonData>();
    }
    [MenuItem("Yutility/Export ui data")]
    private static void ExportUIData()
    {
        string path = EditorUtility.SaveFilePanel("Save file as...", "", "new iwui data", "iwui");
        if (path == "")
        {
            return;
        }
        Dictionary<GameObject, int> uiIDDictanary = new Dictionary<GameObject, int>();
        HashSet<string> foundManualDialogues = new HashSet<string>();
        HashSet<string> foundTimedDialogues = new HashSet<string>();
        HashSet<string> foundScriptUI = new HashSet<string>();
        HashSet<SoundEnumComp.SoundEnumID> foundSounds = new HashSet<SoundEnumComp.SoundEnumID>();
        HashSet<UIEnumIDComp.UIEnumID> foundUIIds = new HashSet<UIEnumIDComp.UIEnumID>();
        UIDataList uilist = new UIDataList();
        //List<UIExportJsonData> uIExportJsonDatas = new List<UIExportJsonData>();
        bool failedAlready = false;
        string jsonString = "";
        List<GameObject> roots = new List<GameObject>();
        List<GameObject> taggedObjects = new List<GameObject>();
        UnityEngine.SceneManagement.Scene currentScene = SceneManager.GetActiveScene();
        currentScene.GetRootGameObjects(roots);
        foreach (var each in roots)
        {
            DFS(each, "UIExportTarget", taggedObjects, uiIDDictanary);
        }
        foreach (var each in taggedObjects)
        {
            try
            {
                each.transform.localScale = Vector3.one;
                UIExportJsonData data = new UIExportJsonData();
                data.floats = new float[(int)JsonUIFloatType.NUM];
                data.uiName = each.name;
                data.uiIndex = uiIDDictanary[each];
                if (each.transform.parent && each.transform.parent.tag == "UIExportTarget")
                {
                    data.parentUIIndex = uiIDDictanary[each.transform.parent.gameObject];
                }
                var imageComp = each.GetComponent<UnityEngine.UI.Image>();
                if (imageComp)
                {
                    data.imagePath = AssetDatabase.GetAssetPath(imageComp.sprite);
                    data.imagePath = data.imagePath.Replace("Assets/Resources/", "");
                    if (data.imagePath == "")
                    {
                        data.customFlags |= (int)UIExportFlag.IsBlankImage;
                    }
                    data.color = new float[] { imageComp.color.r, imageComp.color.g, imageComp.color.b, imageComp.color.a };
                }
                var rectTransform = each.GetComponent<RectTransform>();
                Assert.IsTrue(rectTransform.anchorMin == rectTransform.anchorMax);
                data.pivot = new float[] { rectTransform.pivot.x, rectTransform.pivot.y };
                data.anchor = new float[] { rectTransform.anchorMax.x, rectTransform.anchorMax.y };
                data.anchoredPosition = new float[] { rectTransform.anchoredPosition.x, rectTransform.anchoredPosition.y };
                data.floats[(int)JsonUIFloatType.rotation] = rectTransform.localRotation.eulerAngles.z;
                data.floats[(int)JsonUIFloatType.width] = rectTransform.sizeDelta.x;
                data.floats[(int)JsonUIFloatType.height] = rectTransform.sizeDelta.y;
                // 임의로 사용하게 될 사용자 플래그


                if (each.GetComponent<AnchoredPosMustBeZero>())
                {
                    data.anchoredPosition[0] = 0;
                    data.anchoredPosition[1] = 0;
                }
                if (each.GetComponent<UIDoesPopup>())
                {
                    var comp = each.GetComponent<UIDoesPopup>();
                    data.customFlags |= (int)UIExportFlag.IsPoppingUp;
                    data.floats[(int)JsonUIFloatType.popUpDuration] = comp.popUpDuration;
                    data.floats[(int)JsonUIFloatType.popUpFrom] = comp.popUpFrom;
                    data.floats[(int)JsonUIFloatType.popUpTo] = comp.popUpTo;
                    data.popUpX = comp.popUpX;
                    data.popUpY = comp.popUpY;
                    data.popUpZ = comp.popUpZ;
                }
                if (each.GetComponent<UIDoesPopDown>())
                {
                    var comp = each.GetComponent<UIDoesPopDown>();
                    data.customFlags |= (int)UIExportFlag.IsPoppingDown;
                    data.floats[(int)JsonUIFloatType.popDownDuration] = comp.popDownDuration;
                    data.floats[(int)JsonUIFloatType.popDownFrom] = comp.popDownFrom;
                    data.floats[(int)JsonUIFloatType.popDownTo] = comp.popDownTo;
                    data.popDownX = comp.popDownX;
                    data.popDownY = comp.popDownY;
                    data.popDownZ = comp.popDownZ;
                }
                if (each.GetComponent<UIIncludingTooltips>())
                {
                    var comp = each.GetComponent<UIIncludingTooltips>();
                    data.customFlags |= (int)UIExportFlag.IsButton;
                    data.customFlags |= (int)UIExportFlag.IsIncludingTooltips;
                    data.hoverEnableTargets = comp.tooltips.Select(each => uiIDDictanary[each]).ToArray();
                }
                if (each.GetComponent<UIIsOpeningButton>())
                {
                    var comp = each.GetComponent<UIIsOpeningButton>();
                    data.customFlags |= (int)UIExportFlag.IsButton;
                    data.customFlags |= (int)UIExportFlag.OpeningButton;
                    if (each.GetComponent<UIIsOpeningButton>().canToggle)
                    {
                        data.customFlags |= (int)UIExportFlag.IsToggle;
                    }
                    if (comp.targets != null)
                    {
                        foreach (var eachOpenTarget in comp.targets)
                        {
                            if (eachOpenTarget == null)
                            {
                                Debug.LogError("null target at " + comp.gameObject.name, comp.gameObject);
                            }
                        }
                        data.openTargets = comp.targets.Where(each => each != null).Select(each => uiIDDictanary[each]).ToArray();
                    }
                }
                if (each.GetComponent<UICloseButton>())
                {
                    var comp = each.GetComponent<UICloseButton>();
                    data.customFlags |= (int)UIExportFlag.IsButton;
                    data.customFlags |= (int)UIExportFlag.CloseButton;
                    if (comp.targets != null)
                    {
                        foreach (var eachCloseTarget in comp.targets)
                        {
                            if (eachCloseTarget == null)
                            {
                                Debug.LogError("null target at " + comp.gameObject.name, comp.gameObject);
                            }
                        }
                        data.closeTargets = comp.targets.Select(each => uiIDDictanary[each]).ToArray();
                    }
                }
                if (each.GetComponent<PropagateDisable>())
                {
                    var comp = each.GetComponent<PropagateDisable>();
                    data.customFlags2 |= (int)UIExportFlag2.PropagateDisable;
                    if (comp.targets != null)
                    {
                        data.disablePropagationTargets = comp.targets.Select(each => uiIDDictanary[each]).ToArray();
                    }
                }
                if (each.GetComponent<PropagateEnable>())
                {
                    var comp = each.GetComponent<PropagateEnable>();
                    data.customFlags2 |= (int)UIExportFlag2.PropagateEnable;
                    if (comp.targets != null)
                    {
                        data.enablePropagationTargets = comp.targets.Select(each => uiIDDictanary[each]).ToArray();
                    }
                }
                if (each.GetComponent<UITranslatingOnEnable>())
                {
                    var comp = each.GetComponent<UITranslatingOnEnable>();
                    data.customFlags |= (int)UIExportFlag.IsTranslatingOnEnable;
                    data.floats[(int)JsonUIFloatType.enableDelay] = comp.delayTime;
                    data.floats[(int)JsonUIFloatType.enableDuration] = comp.transitioningDuration;
                    data.enableOffset = new float[] { comp.offset.x, comp.offset.y };
                    data.enableCurveType = (int)comp.curveType;
                }
                if (each.GetComponent<UITranslatingOnDisable>())
                {
                    var comp = each.GetComponent<UITranslatingOnDisable>();
                    data.customFlags |= (int)UIExportFlag.IsTranslatingOnDisable;
                    data.floats[(int)JsonUIFloatType.disableDelay] = comp.delayTime;
                    data.floats[(int)JsonUIFloatType.disableDuration] = comp.transitioningDuration;
                    data.disableOffset = new float[] { comp.offset.x, comp.offset.y };
                    data.disableCurveType = (int)comp.curveType;
                }
                if (each.GetComponent<CanAdjustHeight>())
                {
                    data.customFlags |= (int)UIExportFlag.CanAdjustHeight;
                    data.floats[(int)JsonUIFloatType.adjustingRate] = each.GetComponent<CanAdjustHeight>().adjustingRate;
                }
                if (each.GetComponent<CanAdjustWidth>())
                {
                    data.customFlags |= (int)UIExportFlag.CanAdjustWidth;
                    data.floats[(int)JsonUIFloatType.adjustingRate] = each.GetComponent<CanAdjustWidth>().adjustingRate;
                }
                if (each.GetComponent<CanAdjustRadialFill>())
                {
                    data.customFlags |= (int)UIExportFlag.CanAdjustRadialFill;
                    data.floats[(int)JsonUIFloatType.adjustingRate] = each.GetComponent<CanAdjustRadialFill>().adjustingRate;
                }
                if (each.GetComponent<DisableOnStart>())
                {
                    data.customFlags |= (int)UIExportFlag.DisableOnStart;
                    data.disableOnStartEdtior = each.GetComponent<DisableOnStart>().disableOnStartEditor;
                    data.disableOnStartExe = each.GetComponent<DisableOnStart>().disableOnStartExe;
                    if (each.GetComponent<DisableOnStart>().disableOnlyOnImport)
                    {
                        data.customFlags2 |= (int)UIExportFlag2.DisableOnlyOnImport;
                    }
                }
                if (each.GetComponent<UINoOverlaying>())
                {
                    data.customFlags |= (int)UIExportFlag.NoOverlaying;
                }
                if (each.GetComponent<CapsuleClip>())
                {
                    data.customFlags2 |= (int)UIExportFlag2.CapsuleClip;
                }
                if (each.GetComponent<IsPulsing>())
                {
                    var comp = each.GetComponent<IsPulsing>();
                    data.customFlags |= (int)UIExportFlag.IsPulsing;
                    data.floats[(int)JsonUIFloatType.pulsingMax] = comp.pulsingSizeMax;
                    data.floats[(int)JsonUIFloatType.pulsingMin] = comp.pulsingSizeMin;
                    data.floats[(int)JsonUIFloatType.pulsingPeriod] = comp.pulsingPeriod;
                }
                if (each.GetComponent<PlaySoundOnClick>())
                {
                    data.customFlags |= (int)UIExportFlag.PlaySoundOnClick;
                    data.soundOnClick = AssetDatabase.GetAssetPath(each.GetComponent<PlaySoundOnClick>().sound);
                    data.soundOnClick = data.soundOnClick.Replace("Assets/Resources/", "");
                }
                if (each.GetComponent<PlaySoundOnHover>())
                {
                    data.customFlags |= (int)UIExportFlag.PlaySoundOnHover;
                    data.soundOnHover = AssetDatabase.GetAssetPath(each.GetComponent<PlaySoundOnHover>().sound);
                    data.soundOnHover = data.soundOnHover.Replace("Assets/Resources/", "");
                }
                if (each.GetComponent<PlaySoundOnEnable>())
                {
                    data.customFlags |= (int)UIExportFlag.PlaySoundOnEnable;
                    data.soundOnEnable = AssetDatabase.GetAssetPath(each.GetComponent<PlaySoundOnEnable>().sound);
                    data.soundOnEnable = data.soundOnEnable.Replace("Assets/Resources/", "");
                }
                if (each.GetComponent<PlaySoundOnDisable>())
                {
                    data.customFlags |= (int)UIExportFlag.PlaySoundOnDisable;
                    data.soundOnDisable = AssetDatabase.GetAssetPath(each.GetComponent<PlaySoundOnDisable>().sound);
                    data.soundOnDisable = data.soundOnDisable.Replace("Assets/Resources/", "");
                }
                if (each.GetComponent<IsNumber>())
                {
                    var comp = each.GetComponent<IsNumber>();
                    data.customFlags |= (int)UIExportFlag.IsNumber;
                    data.numberCeil = comp.ceil;
                    data.numberShowZero = comp.showZero;
                    try
                    {
                        data.numberDigits = comp.digits.Select(each => uiIDDictanary[each.gameObject]).ToArray();
                    }
                    catch (Exception e)
                    {
                        Debug.LogError(e.Message, each.gameObject);
                        throw e;
                    }
                    data.numberFontSet = uiIDDictanary[comp.font.gameObject];
                }
                if (each.GetComponent<PriorityLayout>())
                {
                    var comp = each.GetComponent<PriorityLayout>();
                    data.customFlags |= (int)UIExportFlag.PriorityLayout;
                    data.floats[(int)JsonUIFloatType.layoutNormalizingTime] = comp.normalizingTime;
                    data.centerAlign = comp.centerAlign;
                    data.reAlignOnDisable = comp.reAlignOnDisable;
                }
                if (each.GetComponent<SkillUpgradeButton>())
                {
                    var comp = each.GetComponent<SkillUpgradeButton>();
                    data.customFlags |= (int)UIExportFlag.IsSkillUpgrade;
                    if (comp.dependentButton)
                    {
                        data.dependentUpgrade = uiIDDictanary[comp.dependentButton.gameObject];
                    }
                    else
                    {
                        data.dependentUpgrade = -1;
                    }
                }
                if (each.GetComponent<DigitFont>())
                {
                    data.customFlags |= (int)UIExportFlag.IsDigitFont;
                    data.numberFontSetImages = each.GetComponentsInChildren<Image>().Select(each => uiIDDictanary[each.gameObject]).ToArray();
                }
                if (each.GetComponent<ImagePriority>())
                {
                    var comp = each.GetComponent<ImagePriority>();
                    data.imagePriority = comp.priority;
                }
                if (each.GetComponent<TimeStopOnEnable>())
                {
                    var comp = each.GetComponent<TimeStopOnEnable>();
                    data.customFlags |= (int)UIExportFlag.TimeStopOnEnable;
                    data.floats[(int)JsonUIFloatType.timeStoppingDuration] = comp.timeStoppingDuration;
                }
                if (each.GetComponent<TimeContinueOnDisable>())
                {
                    data.customFlags |= (int)UIExportFlag.TimeContinueOnDisable;
                }
                if (each.GetComponent<ColorTintOnEnable>())
                {
                    var comp = each.GetComponent<ColorTintOnEnable>();
                    data.customFlags |= (int)UIExportFlag.ColorTintOnEnable;
                    data.colorTintOnEnableStart = new float[] { comp.startColor.r, comp.startColor.g, comp.startColor.b, comp.startColor.a };
                    data.colorTintOnEnableEnd = new float[] { comp.endColor.r, comp.endColor.g, comp.endColor.b, comp.endColor.a };
                    data.colorTintOnEnableCurveType = (int)comp.curveType;
                    data.floats[(int)JsonUIFloatType.colorTintOnEnableDuration] = comp.duration;
                }
                if (each.GetComponent<ColorTintOnDisable>())
                {
                    var comp = each.GetComponent<ColorTintOnDisable>();
                    data.customFlags |= (int)UIExportFlag.ColorTintOnDisable;
                    data.colorTintOnDisableStart = new float[] { comp.startColor.r, comp.startColor.g, comp.startColor.b, comp.startColor.a };
                    data.colorTintOnDisableEnd = new float[] { comp.endColor.r, comp.endColor.g, comp.endColor.b, comp.endColor.a };
                    data.colorTintOnDisableCurveType = (int)comp.curveType;
                    data.floats[(int)JsonUIFloatType.colorTintOnDisableDuration] = comp.duration;
                }
                if (each.GetComponent<LinearClipOnEnable>())
                {
                    var comp = each.GetComponent<LinearClipOnEnable>();
                    data.customFlags2 |= (int)UIExportFlag2.LinearClipOnEnable;
                    data.linearClipOnEnableStart = new float[] { comp.startPos.x, comp.startPos.y };
                    data.linearClipOnEnableDir = new float[] { comp.clipDirection.x, comp.clipDirection.y };
                    data.floats[(int)JsonUIFloatType.linearClipOnEnableDuration] = comp.clipDuration;
                    data.linearClipOnEnableCurveType = (int)comp.curveType;
                }
                if (each.GetComponent<LinearClipOnDisable>())
                {
                    var comp = each.GetComponent<LinearClipOnDisable>();
                    data.customFlags2 |= (int)UIExportFlag2.LinearClipOnDisable;
                    data.linearClipOnDisableStart = new float[] { comp.startPos.x, comp.startPos.y };
                    data.linearClipOnDisableDir = new float[] { comp.clipDirection.x, comp.clipDirection.y };
                    data.floats[(int)JsonUIFloatType.linearClipOnDisableDuration] = comp.clipDuration;
                    data.linearClipOnDisableCurveType = (int)comp.curveType;
                }
                if (each.GetComponent<IsDuplicatable>())
                {
                    var comp = each.GetComponent<IsDuplicatable>();
                    data.customFlags2 |= (int)UIExportFlag2.Duplicatable;
                    data.duplicate_poolable = comp.poolable;
                }
                if (each.GetComponent<BarCells>())
                {
                    var comp = each.GetComponent<BarCells>();
                    data.customFlags2 |= (int)UIExportFlag2.IsBarCells;
                    data.floats[(int)JsonUIFloatType.barCells_BarWidth] = comp.gaugeFill.rectTransform.sizeDelta.x;
                    data.floats[(int)JsonUIFloatType.barCells_BarHeight] = comp.gaugeFill.rectTransform.sizeDelta.y;
                    data.barCells_CellNumber = comp.cellCount;
                    data.floats[(int)JsonUIFloatType.barCells_GaugePerCell] = comp.gaugePerCell;
                }
                if (each.GetComponent<AdjustLinearClip>())
                {
                    var comp = each.GetComponent<AdjustLinearClip>();
                    data.customFlags2 |= (int)UIExportFlag2.AdjustLinearClip;
                    data.floats[(int)JsonUIFloatType.adjustLinearClipDirectionX] = comp.clipDirection.x;
                    data.floats[(int)JsonUIFloatType.adjustLinearClipDirectionY] = comp.clipDirection.y;
                    data.floats[(int)JsonUIFloatType.adjustLinearClipStartX] = comp.clipStart.x;
                    data.floats[(int)JsonUIFloatType.adjustLinearClipStartY] = comp.clipStart.y;
                    data.floats[(int)JsonUIFloatType.adjustLinearClipAdjustingRate] = comp.adjustingRate;
                }
                if (each.GetComponent<UIPlayMusicOnEnable>())
                {
                    var comp = each.GetComponent<UIPlayMusicOnEnable>();
                    data.customFlags2 |= (int)UIExportFlag2.MusicPlayOnEnable;
                    data.floats[(int)JsonUIFloatType.musicPlayOnEnable_fadeIn] = comp.fadeInTime;
                    data.floats[(int)JsonUIFloatType.musicPlayOnEnable_fadeOut] = comp.fadeOutTime;
                    if (comp.clip != null)
                    {
                        data.musicPlayOnEnable_musicClip = AssetDatabase.GetAssetPath(comp.clip);
                        data.musicPlayOnEnable_musicClip = data.musicPlayOnEnable_musicClip.Replace("Assets/Resources/", "");
                    }
                }
                if (each.GetComponent<UIPlayMusicOnDisable>())
                {
                    var comp = each.GetComponent<UIPlayMusicOnDisable>();
                    data.customFlags2 |= (int)UIExportFlag2.MusicPlayOnDisable;
                    data.floats[(int)JsonUIFloatType.musicPlayOnDisable_fadeIn] = comp.fadeInTime;
                    data.floats[(int)JsonUIFloatType.musicPlayOnDisable_fadeOut] = comp.fadeOutTime;
                    if (comp.clip != null)
                    {
                        data.musicPlayOnDisable_musicClip = AssetDatabase.GetAssetPath(comp.clip);
                        data.musicPlayOnDisable_musicClip = data.musicPlayOnDisable_musicClip.Replace("Assets/Resources/", "");
                    }
                }
                if (each.GetComponent<MusicUnpauseOnDisable>())
                {
                    data.customFlags2 |= (int)UIExportFlag2.MusicUnpauseOnDisable;
                }
                if (each.GetComponent<MusicPauseOnEnable>())
                {
                    data.customFlags2 |= (int)UIExportFlag2.MusicPauseOnEnable;
                }
                if (each.GetComponent<MusicMultiplyVolumeOnEnableDisable>())
                {
                    var comp = each.GetComponent<MusicMultiplyVolumeOnEnableDisable>();
                    data.customFlags2 |= (int)UIExportFlag2.MusicMultiplyVolumeOnEnableDisable;
                    data.floats[(int)JsonUIFloatType.musicMultiplyVolumeOnEnableDisable_enableFactor] = comp.enableFactor;
                    data.floats[(int)JsonUIFloatType.musicMultiplyVolumeOnEnableDisable_fadeDuration] = comp.fadeDuration;
                }
                //        ExclusiveEnable = 1 << 10,
                //DisableAfterEnable = 1 << 11,
                //Dialogue_Manual = 1 << 12,
                //Dialogue_Timed = 1 << 13,
                //RedundantEnable = 1 << 14,
                if (each.GetComponent<ExclusiveEnable>())
                {
                    var comp = each.GetComponent<ExclusiveEnable>();
                    data.customFlags2 |= (int)UIExportFlag2.ExclusiveEnable;
                    data.exclusiveEnableGroup = comp.exclusiveGroup.Select(each => uiIDDictanary[each]).ToArray();
                }
                if (each.GetComponent<DisableAfterEnable>())
                {
                    var comp = each.GetComponent<DisableAfterEnable>();
                    data.customFlags2 |= (int)UIExportFlag2.DisableAfterEnable;
                    data.floats[(int)JsonUIFloatType.disableAfterEnable_delayUntilDisable] = comp.delayUntilDisable;
                }
                if (each.GetComponent<Dialogue_Manual>())
                {
                    var comp = each.GetComponent<Dialogue_Manual>();
                    if (foundManualDialogues.Contains(comp.gameObject.name))
                    {
                        Debug.LogError("Dialogue_Manual이 중복됩니다! : ", each);
                        failedAlready = true;
                        break;
                    }
                    foundManualDialogues.Add(comp.gameObject.name);
                    data.customFlags2 |= (int)UIExportFlag2.Dialogue_Manual;
                }
                if (each.GetComponent<Dialogue_Timed>())
                {
                    var comp = each.GetComponent<Dialogue_Timed>();
                    if (foundTimedDialogues.Contains(comp.gameObject.name))
                    {
                        Debug.LogError("Dialogue_Timed이 중복됩니다! : ", each);
                        failedAlready = true;
                        break;
                    }
                    foundTimedDialogues.Add(comp.gameObject.name);
                    data.customFlags2 |= (int)UIExportFlag2.Dialogue_Timed;
                }
                if (each.GetComponent<ScriptUI>())
                {
                    var comp = each.GetComponent<ScriptUI>();
                    if (foundScriptUI.Contains(comp.gameObject.name))
                    {
                        Debug.LogError("ScriptUI의 이름이 중복됩니다! : ", each);
                        failedAlready = true;
                        break;
                    }
                    foundScriptUI.Add(comp.gameObject.name);
                    data.customFlags2 |= (int)UIExportFlag2.ScriptUI;
                }
                if (each.GetComponent<SoundEnumComp>() && each.GetComponent<SoundEnumComp>().soundEnumID != SoundEnumComp.SoundEnumID.None)
                {
                    var comp = each.GetComponent<SoundEnumComp>();
                    if (foundSounds.Contains(comp.soundEnumID))
                    {
                        Debug.LogError("sound id가 중복됩니다! : ", each);
                        failedAlready = true;
                        break;
                    }
                    foundSounds.Add(comp.soundEnumID);
                    data.soundEnumID = (int)comp.soundEnumID;
                    data.customFlags2 |= (int)UIExportFlag2.EnumSound;
                }
                if (each.GetComponent<RedundantEnable>())
                {
                    var comp = each.GetComponent<RedundantEnable>();
                    data.customFlags2 |= (int)UIExportFlag2.RedundantEnable;
                }
                if (each.GetComponent<RotatingUI>())
                {
                    var comp = each.GetComponent<RotatingUI>();
                    data.customFlags2 |= (int)UIExportFlag2.Rotating;
                    data.floats[(int)JsonUIFloatType.rotatingSpeed] = comp.rotateSpeed;
                    data.floats[(int)JsonUIFloatType.rotatingInitialRotation] = comp.transform.localRotation.eulerAngles.z;
                }
                if (each.GetComponent<StartGameButton>())
                {
                    var comp = each.GetComponent<StartGameButton>();
                    data.customFlags2 |= (int)UIExportFlag2.StartGameButton;
                }
                if (each.GetComponent<ReturnToTitleButton>())
                {
                    var comp = each.GetComponent<ReturnToTitleButton>();
                    data.customFlags2 |= (int)UIExportFlag2.ReturnToTitleButton;
                }
                if (each.GetComponent<Video>())
                {
                    var comp = each.GetComponent<Video>();
                    data.customFlags2 |= (int)UIExportFlag2.Video;
                    data.floats[(int)JsonUIFloatType.videoDuration1] = comp.videoDuration1;
                    data.videoUnscaledDeltaTime = comp.isDeltatimeUnscaled;
                    if (comp.video1 != null)
                    {
                        data.videoPath1 = AssetDatabase.GetAssetPath(comp.video1);
                        data.videoPath1 = data.videoPath1.Replace("Assets/Resources/", "");
                    }
                    if (comp.video2 != null)
                    {
                        data.videoPath2 = AssetDatabase.GetAssetPath(comp.video2);
                        data.videoPath2 = data.videoPath2.Replace("Assets/Resources/", "");
                    }
                }
                if (each.GetComponent<AnimatedSprite>())
                {
                    var comp = each.GetComponent<AnimatedSprite>();
                    data.customFlags2 |= (int)UIExportFlag2.AnimatedSprite;
                    data.animatedSpriteFolderPath = AssetDatabase.GetAssetPath(comp.Sprite);
                    data.animatedSpriteFolderPath = Path.GetDirectoryName(data.animatedSpriteFolderPath);
                    data.animatedSpriteFolderPath = data.animatedSpriteFolderPath.Replace("\\", "/");
                    data.animatedSpriteFolderPath = data.animatedSpriteFolderPath.Replace("Assets/Resources/", "");
                    data.animatedSpriteIsRepeat = comp.repeat;
                    Debug.Log(data.animatedSpriteFolderPath);
                }
                if (each.GetComponent<MultiLanguageImage>())
                {
                    var comp = each.GetComponent<MultiLanguageImage>();
                    data.customFlags2 |= (int)UIExportFlag2.MultiLanguage;
                    data.koreanImagePath = AssetDatabase.GetAssetPath(comp.koreanImg);
                    data.koreanImagePath = data.koreanImagePath.Replace("Assets/Resources/", "");
                    data.englishImagePath = AssetDatabase.GetAssetPath(comp.englishImg);
                    data.englishImagePath = data.englishImagePath.Replace("Assets/Resources/", "");
                    data.japaneseImagePath = AssetDatabase.GetAssetPath(comp.japaneseImg);
                    data.japaneseImagePath = data.japaneseImagePath.Replace("Assets/Resources/", "");
                }
                if (each.GetComponent<UIEnumIDComp>())
                {
                    var id = each.GetComponent<UIEnumIDComp>().uiEnumID;
                    data.enumID = (int)id;

                    if (id != UIEnumIDComp.UIEnumID.None && foundUIIds.Contains(id))
                    {
                        Debug.LogError("UI Enum ID가 다음 객체에서 중복됩니다! : ", each);
                    }
                    var parentUI = each.transform.parent;
                    bool skip = false;
                    while (parentUI)
                    {
                        if (parentUI.GetComponent<IsDuplicatable>())
                        {
                            skip = true;
                            break;
                        }
                        parentUI = parentUI.transform.parent;
                    }
                    if (!skip)
                    {
                        foundUIIds.Add(id);
                    }
                }
                uilist.dataList.Add(data);
            }
            catch (Exception e)
            {
                Debug.LogError(e.Message, each);
                failedAlready = true;
                break;
            }
        }
        if (!failedAlready)
        {
            jsonString = JsonUtility.ToJson(uilist, true);
            System.IO.File.WriteAllText(path, jsonString);
        }
    }
    private static void DFS(GameObject gameObject, string tagName, List<GameObject> list, Dictionary<GameObject, int> uiIDDict)
    {
        if (gameObject.tag == tagName)
        {
            list.Add(gameObject);
            uiIDDict.Add(gameObject, uiIDDict.Count);
        }
        foreach (Transform each in gameObject.transform)
        {
            DFS(each.gameObject, tagName, list, uiIDDict);
        }
    }
}