fix : 서버 버그 수정 작업 머지

Merge branch 'fix/mmo-server-logic-bugs' of https://git.tolelom.xyz/A301/a301_mmo_game_server

# Conflicts:
#	MMOTestServer/MMOserver/Game/GameServer.cs

ANALYSIS.md

@@ -1,173 +0,0 @@
-# MMO Game Server 코드 분석 및 문제점 보고서
-
-## 1. 프로젝트 구조 개요
-
-```
-a301_mmo_game_server/
-├── MMOTestServer/
-│   ├── MMOserver/          # 메인 게임 서버 (.NET 9.0)
-│   │   ├── Game/           # GameServer (ServerBase 상속)
-│   │   ├── Packet/         # PacketCode 열거형 + ProtoBuf 패킷 정의
-│   │   └── RDB/            # DB 연결, Repository, Service, Handler
-│   └── ServerLib/          # 공유 라이브러리
-│       ├── Packet/         # PacketSerializer, PacketType
-│       ├── RDB/            # IDbConnectionFactory, ARepository, Response
-│       └── Service/        # ServerBase, Session, SessionManager
-└── ClientTester/
-    ├── EchoClientTester/   # 더미 클라이언트 부하 테스터
-    └── TempServer/         # 단순 에코 서버
-```
-
-### 기술 스택
-| 구성 요소 | 기술 |
-|-----------|------|
-| 네트워크 | LiteNetLib 2.0.2 (UDP) |
-| 직렬화 | protobuf-net 3.2.56 |
-| DB | MySQL + Dapper 2.1.66 |
-| 설정 | Microsoft.Extensions.Configuration |
-| 로깅 | Serilog |
-| 프레임워크 | .NET 9.0 |
-
-### 아키텍처 흐름
-```
-클라이언트 → LiteNetLib UDP → ServerBase (인증/에코) → GameServer (게임 로직)
-                                                          ↓
-                                                    Handler → Service → Repository → MySQL
-```
-
-### 인증 흐름
-1. 클라이언트 연결 → `pendingPeers`에 등록
-2. Auth 패킷(type=1, 8byte hashKey) 수신 → 인증 처리
-3. 기존 같은 hashKey 세션 있으면 교체 (WiFi→LTE 재연결)
-4. `sessions`에 등록 + `OnSessionConnected()` 호출
-
----
-
-## 2. 발견된 문제점
-
-### [CRITICAL] IDbConnection 리소스 누수 - `ARepository.cs`
-
-**모든 DB 메서드에서 `IDbConnection`을 `using` 없이 사용.**
-MySQL 커넥션이 풀로 반환되지 않아 풀 고갈 → 서버 장애 발생.
-
-```csharp
-// 문제: connection이 Dispose되지 않음
-public async Task<T?> GetByIdAsync(int id)
-{
-    IDbConnection conn = CreateConnection();  // 열림
-    return await conn.GetAsync<T>(id);        // 반환 후 conn 방치
-}
-```
-
-**영향받는 메서드:** GetByIdAsync, GetAllAsync, InsertAsync, UpdateAsync, DeleteAsync, QueryAsync, QueryFirstOrDefaultAsync, ExecuteAsync, WithTransactionAsync (총 9개)
-
-### [CRITICAL] GameServer 추상 메서드에 NotImplementedException
-
-실제 클라이언트가 인증 후 `OnSessionConnected()`가 호출되면 **서버가 크래시**됨.
-에코 테스트는 인증 없이 동작하므로 문제가 노출되지 않았을 뿐.
-
-```csharp
-protected override void OnSessionConnected(NetPeer peer, long hashKey)
-{
-    throw new NotImplementedException();  // 서버 크래시
-}
-```
-
-### [HIGH] Auth 패킷 페이로드 검증 주석 처리 - `ServerBase.cs:202-209`
-
-payload 길이 검증이 주석 처리되어, 8바이트 미만의 잘못된 패킷으로 `BitConverter.ToInt64`에서 **IndexOutOfRangeException** 발생 가능.
-
-```csharp
-// 주석 처리됨 - 악의적 패킷으로 크래시 가능
-// if (payload.Length < sizeof(long))
-// {
-//     peer.Disconnect();
-//     return;
-// }
-```
-
-### [HIGH] MemoryStream 미해제 - `PacketSerializer.cs`
-
-Serialize/DeserializePayload에서 MemoryStream을 `using` 없이 사용.
-
-```csharp
-public static byte[] Serialize<T>(ushort type, ushort size, T packet)
-{
-    MemoryStream ms = new MemoryStream();  // Dispose 안됨
-    // ...
-}
-```
-
-### [HIGH] NetDataWriter 매 전송마다 할당 - `ServerBase.cs:234-257`
-
-`SendTo`, `Broadcast`, `BroadcastExcept` 호출 시마다 `new NetDataWriter()` 생성.
-초당 수천 패킷 처리 시 GC 압력 급증.
-
-### [MEDIUM] Serilog 구조적 로깅 구문 오류 - `ServerBase.cs:89`
-
-`request.ConnectionKey`가 템플릿 변수가 아닌 리터럴 문자열로 들어감.
-
-```csharp
-// 잘못됨: {request.ConnectionKey}는 Serilog 템플릿 변수가 아님
-Log.Debug("해당 클라이언트의 ConnectionKey={request.ConnectionKey}가 동일하지 않습니다", request.Data.ToString());
-```
-
-### [MEDIUM] DummyClients.SendPing() BodyLength 불일치
-
-`BodyLength`를 `"seq:{seq}".Length`로 계산하지만, 실제 전송 문자열은 `"Echo seq:{seq}"`.
-
-```csharp
-packetHeader.BodyLength = $"seq:{seq}".Length;   // "seq:0" = 5
-writer.Put($"Echo seq:{seq}");                    // "Echo seq:0" = 10  ← 불일치
-```
-
-### [MEDIUM] SessionManager가 GetHashCode()를 키로 사용
-
-`session.GetHashCode()`는 객체 해시이므로 의미 있는 키가 아님. `session.HashKey`를 써야 함.
-또한 **SessionManager 자체가 어디서도 사용되지 않음**.
-
-### [MEDIUM] PacketSerializer.Serialize의 size 파라미터 무의미
-
-`size`를 인자로 받아 헤더에 쓰지만, 실제 직렬화된 payload 크기와 무관. 호출자가 잘못된 size를 넘기면 역직렬화 시 문제 발생.
-
-### [LOW] async void 이벤트 핸들러 - `EchoClientTester/Program.cs:32`
-
-```csharp
-service.OnAllDisconnected += async () =>  // async void 위험
-{
-    await cts.CancelAsync();
-};
-```
-
-`async void`는 예외가 전파되지 않아 프로세스가 비정상 종료될 수 있음.
-
-### [LOW] Thread Safety - `ServerBase.cs`
-
-`pendingPeers`와 `sessions`가 일반 `Dictionary`. LiteNetLib은 단일 스레드 폴링이므로 현재는 문제 없지만, 외부에서 `SendTo/Broadcast`를 호출하면 race condition 가능.
-
-### [LOW] PacketHeader 클래스가 ClientTester와 MMOserver에 중복 정의
-
-동일한 개념의 패킷 헤더가 각 프로젝트에 다른 형태로 존재.
-
----
-
-## 3. 수정 사항 요약
-
-| # | 심각도 | 파일 | 수정 내용 |
-|---|--------|------|-----------|
-| 1 | CRITICAL | ARepository.cs | 모든 DB 메서드에 `using` 추가 |
-| 2 | CRITICAL | GameServer.cs | NotImplementedException → 로그 출력으로 변경 |
-| 3 | HIGH | ServerBase.cs | Auth/Echo payload 길이 검증 주석 해제 |
-| 4 | HIGH | PacketSerializer.cs | MemoryStream에 `using` 추가 |
-| 5 | HIGH | ServerBase.cs | NetDataWriter 재사용 (ThreadLocal 풀) |
-| 6 | MEDIUM | ServerBase.cs | Serilog 템플릿 구문 수정 |
-| 7 | MEDIUM | DummyClients.cs | BodyLength 계산 수정 |
-| 8 | MEDIUM | PacketSerializer.cs | size 파라미터 제거, 자동 계산 |
-| 9 | LOW | EchoClientTester/Program.cs | async void 이벤트 안전하게 변경 |
-| 10 | HIGH | ServerBase.cs | `isListening`에 `volatile` 추가 (스레드 간 가시성) |
-| 11 | HIGH | ServerBase.cs | `Deserialize` 실패 시 null payload 체크 추가 |
-| 12 | HIGH | ClientTester/PacketSerializer.cs | ServerLib과 동일한 MemoryStream 누수 + size 파라미터 수정 |
-| 13 | MEDIUM | TestHandlers.cs | 모든 핸들러 메서드에 try-catch 추가 (예외 → Error 응답) |
-| 14 | HIGH | PacketSerializer.cs (양쪽) | `size` 필드 검증 구현 - 헤더 size > 실제 payload 시 null 반환 |
-| 15 | MEDIUM | TestRepository.cs | `DbConnectionFactory` → `IDbConnectionFactory` 인터페이스로 변경 |
-| 16 | LOW | DummyClients.cs | `pendingPings` 무한 증가 방지 - 오래된 항목 자동 정리 |

CLAUDE.md

@@ -0,0 +1,182 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+# 서버 빌드 및 실행
+cd MMOTestServer
+dotnet build -c Debug
+dotnet run --project MMOserver/MMOserver.csproj
+
+# 릴리즈 빌드
+dotnet build -c Release
+dotnet publish -c Release
+
+# Docker
+cd MMOTestServer
+docker-compose up --build    # 9050/udp, 9500/udp 노출
+
+# 클라이언트 테스터
+cd ClientTester/EchoClientTester
+dotnet run                                  # 대화형 메뉴
+dotnet run -- stress -c 100 -d 60           # 부하 테스트
+dotnet run -- stress -c 50 -d 0 -i 100 -r 1000 -b 10  # 상세 옵션
+```
+
+## Tech Stack
+
+- **C# / .NET 9.0** (C# 13)
+- **LiteNetLib** — UDP 네트워킹
+- **protobuf-net** — 바이너리 패킷 직렬화
+- **MySQL** + **Dapper** / **Dapper.Contrib** — 비동기 DB 접근
+- **Serilog** — 로깅 (콘솔 + 파일)
+
+## Project Purpose
+
+"One of the plans" 게임의 실시간 MMO 서버.
+로비, 채널 관리, 플레이어 동기화 (이동/전투/상태) 담당.
+
+## Project Structure
+
+```
+MMOTestServer/
+├── MMOserver/              # 게임 서버 실행 프로젝트
+│   ├── Game/               # GameServer, Player, Channel, ChannelManager
+│   ├── Packet/             # PacketHeader(코드 정의), PacketBody(Protobuf 메시지)
+│   ├── Api/                # RestApi (JWT 검증 외부 호출)
+│   ├── RDB/                # Handler → Service → Repository → MySQL
+│   ├── Utils/              # UuidGeneratorManager, Singleton
+│   ├── Program.cs          # 진입점
+│   ├── config.json         # DB 연결 설정
+│   └── Dockerfile          # 멀티스테이지 빌드
+├── ServerLib/              # 재사용 네트워킹 DLL
+│   ├── Service/            # ServerBase, Session, SessionManager
+│   ├── Packet/             # PacketSerializer
+│   └── RDB/                # ARepository<T>, DbConnectionFactory
+└── compose.yaml            # Docker Compose
+
+ClientTester/
+└── EchoClientTester/       # 테스트 클라이언트
+    ├── EchoDummyService/   # Echo RTT 측정
+    ├── DummyService/       # 더미 플레이어 이동 시뮬레이션 (10명)
+    └── StressTest/         # 부하 테스트 (P50/P95/P99, CSV 내보내기)
+```
+
+## 핵심 아키텍처
+
+### 네트워크 코어 (ServerLib)
+
+**ServerBase** — LiteNetLib `INetEventListener` 구현. 싱글 스레드 이벤트 폴링 (1ms 간격).
+
+연결 흐름:
+```
+UDP Connect → PendingPeer 등록 → 인증 패킷 수신 → Session 생성 → OnSessionConnected
+```
+
+- **PendingPeers**: `Dictionary<int, NetPeer>` (peer.Id 기반, 미인증)
+- **Sessions**: `Dictionary<long, Session>` (hashKey 기반, 인증 완료)
+- **TokenHash**: `Dictionary<string, long>` (JWT 토큰 → hashKey 매핑)
+- **재접속**: 같은 hashKey로 재접속 시 기존 peer 교체 (WiFi↔LTE 전환 대응)
+- **전송 헬퍼**: `SendTo()`, `Broadcast()`, `BroadcastExcept()` (캐시된 NetDataWriter 사용)
+
+**Session** — 연결별 상태: Token, HashKey, Peer 참조.
+- 속도 제한: 슬라이딩 윈도우 (1초), 기본 60 패킷/초
+- 3회 위반 시 강제 연결 해제
+
+### 패킷 프로토콜
+
+바이너리 헤더 + Protobuf 페이로드:
+```
+[2B: type (ushort LE)] [2B: size (ushort LE)] [NB: protobuf payload]
+```
+
+**패킷 코드 (PacketHeader.cs):**
+
+| 코드 | 이름 | 전송 방식 | 용도 |
+|------|------|-----------|------|
+| 1 | ACC_TOKEN | Reliable | JWT 인증 |
+| 1001 | DUMMY_ACC_TOKEN | Reliable | 테스트 인증 (hashKey≤1000) |
+| 1000 | ECHO | ReliableUnordered | RTT 측정 |
+| 2 | LOAD_GAME | Reliable | 게임 로드 |
+| 3 | LOAD_CHANNEL | Reliable | 채널 목록 |
+| 4 | INTO_CHANNEL | Reliable | 채널 입장 |
+| 5 | UPDATE_CHANNEL_USER | Reliable | 유저 입장/퇴장 브로드캐스트 |
+| 6 | EXIT_CHANNEL | Reliable | 채널 퇴장 |
+| 7 | TRANSFORM_PLAYER | **Unreliable** | 위치/회전 동기화 (HOL 방지) |
+| 8 | ACTION_PLAYER | ReliableOrdered | 공격/스킬/회피 액션 |
+| 9 | STATE_PLAYER | ReliableOrdered | HP/MP 상태 |
+| 10-12 | TRANSFORM/ACTION/STATE_NPC | 위와 동일 | NPC 동기화 |
+| 13 | DAMAGE | Reliable | 데미지 |
+| 14-15 | UPDATE_PARTY/USER_PARTY | Reliable | 파티 |
+
+**Protobuf 메시지 (PacketBody.cs):**
+- PlayerInfo: PlayerId, Nickname, Level, Hp, MaxHp, Mp, MaxMp, Position(Vector3), RotY
+- TransformPlayerPacket: PlayerId, Position, RotY
+- ActionPlayerPacket: PlayerId, PlayerActionType(IDLE/MOVE/ATTACK/SKILL/DODGE/DIE/REVIVE), SkillId, TargetId
+- StatePlayerPacket: PlayerId, Hp, MaxHp, Mp, MaxMp
+
+### GameServer (MMOserver/Game/)
+
+ServerBase 확장. 패킷 핸들러 딕셔너리로 라우팅:
+- `INTO_CHANNEL` — 채널 입장, 기존 유저 목록 응답 + 신규 유저 브로드캐스트
+- `EXIT_CHANNEL` — 채널 퇴장, 나머지 유저에게 알림
+- `TRANSFORM_PLAYER` — 위치 브로드캐스트 (Unreliable)
+- `ACTION_PLAYER` — 액션 브로드캐스트 (ReliableOrdered)
+- `STATE_PLAYER` — 상태 브로드캐스트 (ReliableOrdered)
+
+**인증 흐름:**
+- `HandleAuth()`: JWT를 `https://a301.api.tolelom.xyz/api/auth/verify`로 검증 (3회 재시도, 5초 타임아웃). 401이면 즉시 실패.
+- `HandleAuthDummy()`: 토큰 값을 hashKey로 직접 사용 (hashKey≤1000만 허용).
+
+### 채널 시스템
+
+- **Channel**: `Dictionary<long, Player>` (hashKey → Player). 기본 최대 100명.
+- **ChannelManager**: 싱글톤. 기본 1개 채널. `connectUsers` 딕셔너리로 userId→channelId 추적.
+
+### DB 레이어
+
+**Handler → Service → Repository → MySQL** 패턴.
+
+- **ARepository\<T\>**: Dapper.Contrib 기반 제네릭 CRUD. 트랜잭션 지원 (`WithTransactionAsync`).
+- **DbConnectionFactory**: `config.json` 또는 환경변수에서 연결 문자열 생성. 커넥션 풀: Min=5, Max=100.
+- **Response\<T\>**: 표준 응답 봉투 (`{ Success, Data, Error }`).
+
+새 테이블 추가 시: `Models/` → `Repositories/` (ARepository 상속) → `Services/` → `Handlers/`. ServerLib은 수정 불필요.
+
+## 스레딩 모델
+
+- 네트워크 루프: 싱글 스레드 폴링 (게임 상태에 락 불필요)
+- JWT 검증 / DB: async/await (네트워크 루프 블로킹 없음)
+- UUID 생성: ReaderWriterLockSlim
+
+## 설정
+
+```json
+// config.json
+{
+  "Database": {
+    "Host": "localhost",
+    "Port": "3306",
+    "Name": "game_db",
+    "User": "root",
+    "Password": "...",
+    "Pooling": {
+      "MinimumPoolSize": "5",
+      "MaximumPoolSize": "100",
+      "ConnectionTimeout": "30",
+      "ConnectionIdleTimeout": "180"
+    }
+  }
+}
+```
+
+서버 기본 포트: 9500 (UDP). Ping 간격: 3000ms. 연결 타임아웃: 60000ms.
+
+## 알려진 제한사항
+
+- 서버 측 위치 검증 미구현 (스피드핵/텔레포트 가능)
+- 플레이어 데이터 DB 영속화 미구현 (하드코딩된 기본값 사용)
+- NPC/파티 패킷 코드 정의됨 but 핸들러 미구현
+- 수평 확장 미지원 (단일 서버 인스턴스)

ClientTester/EchoClientTester/DummyService/DummyClientService.cs

@@ -1,7 +1,7 @@
 using LiteNetLib;
 using Serilog;
 
-namespace ClientTester.EchoDummyService;
+namespace ClientTester.DummyService;
 
 public class DummyClientService
 {
@@ -11,20 +11,25 @@ public class DummyClientService
     // 모든거 강종
     public event Action? OnAllDisconnected;
 
-    public DummyClientService(int count, string ip, int port, string key, int sendIntervalMs = 1000)
+    public DummyClientService(int count, string ip, int port, string key, int sendIntervalMs = 1000, MapBounds? mapBounds = null)
     {
         sendInterval = sendIntervalMs;
-        clients = Enumerable.Range(0, count).Select(i => new DummyClients(i, ip, port, key)).ToList();
+        clients = Enumerable.Range(1, count).Select(i =>
+        {
+            DummyClients client = new DummyClients(i, ip, port, key);
+            if (mapBounds != null)
+            {
+                client.Map = mapBounds;
+            }
+            return client;
+        }).ToList();
 
         Log.Information("[SERVICE] {Count}개 클라이언트 생성 → {Ip}:{Port}", count, ip, port);
     }
 
     public async Task RunAsync(CancellationToken ct)
     {
-        await Task.WhenAll(
-            PollLoopAsync(ct),
-            SendLoopAsync(ct)
-        );
+        await Task.WhenAll(PollLoopAsync(ct), SendLoopAsync(ct));
     }
 
     private async Task PollLoopAsync(CancellationToken ct)
@@ -33,30 +38,23 @@ public class DummyClientService
         {
             foreach (DummyClients c in clients)
             {
-                c.PollEvents();
+                try
+                {
+                    c.PollEvents();
+                }
+                catch (Exception ex)
+                {
+                    Log.Error("[Client {ClientId}] PollEvents 예외: {Ex}", c.clientId, ex.Message);
+                }
             }
 
-            try
-            {
-                await Task.Delay(10, ct);
-            }
-            catch (OperationCanceledException)
-            {
-                break;
-            }
+            await Task.Delay(10);
         }
     }
 
     private async Task SendLoopAsync(CancellationToken ct)
     {
-        try
-        {
-            await Task.Delay(500, ct);
-        }
-        catch (OperationCanceledException)
-        {
-            return;
-        }
+        await Task.Delay(500);
 
         int tick = 0;
 
@@ -67,7 +65,7 @@ public class DummyClientService
 
             foreach (DummyClients client in clients)
             {
-                client.SendPing();
+                client.SendTransform();
                 if (client.peer != null)
                 {
                     sent++;
@@ -88,14 +86,7 @@ public class DummyClientService
             Log.Debug("[TICK {Tick:000}] {Sent}/{Total} 전송", tick, sent, total);
             tick++;
 
-            try
-            {
-                await Task.Delay(sendInterval, ct);
-            }
-            catch (OperationCanceledException)
-            {
-                break;
-            }
+            await Task.Delay(sendInterval);
         }
     }
 
@@ -106,8 +97,6 @@ public class DummyClientService
 
         Log.Information("───────────── Performance Report ─────────────");
 
-        double totalAvgRtt = 0;
-
         foreach (DummyClients c in clients)
         {
             NetStatistics? stats = c.peer?.Statistics;
@@ -115,24 +104,22 @@ public class DummyClientService
             float lossPct = stats?.PacketLossPercent ?? 0f;
 
             Log.Information(
-                "[Client {ClientId:00}] Sent={Sent} Recv={Recv} | Loss={Loss}({LossPct:F1}%) AvgRTT={AvgRtt:F3}ms LastRTT={LastRtt:F3}ms",
-                c.clientId, c.SentCount, c.ReceivedCount, loss, lossPct, c.AvgRttMs, c.LastRttMs);
+                "[Client {ClientId:00}] Sent={Sent} Recv={Recv} | Loss={Loss}({LossPct:F1}%)",
+                c.clientId, c.SentCount, c.ReceivedCount, loss, lossPct);
 
             totalSent += c.SentCount;
             totalRecv += c.ReceivedCount;
-            totalAvgRtt += c.AvgRttMs;
+
             if (c.peer != null)
             {
                 connected++;
             }
         }
 
-        double avgRtt = connected > 0 ? totalAvgRtt / connected : 0;
-
         Log.Information("────────────────────────────────────────────");
         Log.Information(
-            "[TOTAL] Sent={Sent} Recv={Recv} Connected={Connected}/{Total} AvgRTT={AvgRtt:F3}ms",
-            totalSent, totalRecv, connected, clients.Count, avgRtt);
+            "[TOTAL] Sent={Sent} Recv={Recv} Connected={Connected}/{Total}",
+            totalSent, totalRecv, connected, clients.Count);
         Log.Information("────────────────────────────────────────────");
     }
 

ClientTester/EchoClientTester/DummyService/DummyClients.cs

@@ -0,0 +1,170 @@
+using System.Diagnostics;
+using ClientTester.Packet;
+using LiteNetLib;
+using LiteNetLib.Utils;
+using Serilog;
+
+namespace ClientTester.DummyService;
+
+public class DummyClients
+{
+    private NetManager manager;
+    private EventBasedNetListener listener;
+    private NetDataWriter? writer;
+    public NetPeer? peer;
+    public int clientId; // 일단 이게 hashKey가 됨 => 0 ~ 1000번까지는 더미용응로 뺴둠
+
+    // info
+    private Vector3 position = new Vector3();
+    private int rotY = 0;
+    private float moveSpeed = 3.5f;
+    private float distance = 0.0f;
+    private float preTime = 0.0f;
+
+    // 이동 계산용
+    private readonly Stopwatch moveClock = Stopwatch.StartNew();
+    private float posX = 0f;
+    private float posZ = 0f;
+    private float dirX = 0f;
+    private float dirZ = 0f;
+
+    // 맵 경계
+    public MapBounds Map { get; set; } = new MapBounds(-50f, 50f, -50f, 50f);
+
+    // 통계
+    public int SentCount
+    {
+        set;
+        get;
+    }
+
+    public int ReceivedCount
+    {
+        set;
+        get;
+    }
+
+    public int RttCount
+    {
+        set;
+        get;
+    }
+
+    public DummyClients(int clientId, string ip, int port, string key)
+    {
+        this.clientId = clientId;
+        listener = new EventBasedNetListener();
+        manager = new NetManager(listener);
+        writer = new NetDataWriter();
+
+        listener.PeerConnectedEvent += netPeer =>
+        {
+            peer = netPeer;
+            Log.Information("[Client {ClientId:00}] 연결됨", this.clientId);
+
+            // clientID가 토큰의 hashKey라고 가정함
+            DummyAccTokenPacket recvTokenPacket = new DummyAccTokenPacket();
+            recvTokenPacket.Token = clientId;
+
+            byte[] data = PacketSerializer.Serialize((ushort)PacketCode.DUMMY_ACC_TOKEN, recvTokenPacket);
+            writer.Put(data);
+            peer.Send(writer, DeliveryMethod.ReliableOrdered);
+            writer.Reset();
+        };
+
+        listener.NetworkReceiveEvent += (peer, reader, channel, deliveryMethod) =>
+        {
+            ReceivedCount++;
+            reader.Recycle();
+        };
+
+        listener.PeerDisconnectedEvent += (peer, info) =>
+        {
+            Log.Warning("[Client {ClientId:00}] 연결 끊김: {Reason}", this.clientId, info.Reason);
+            this.peer = null;
+        };
+
+        manager.Start();
+        manager.Connect(ip, port, key);
+    }
+
+    public void UpdateDummy()
+    {
+        // 델타 타임 계산 (초 단위)
+        float now = (float)moveClock.Elapsed.TotalSeconds;
+        float delta = preTime > 0f ? now - preTime : 0.1f;
+        preTime = now;
+
+        // 남은 거리가 없으면 새 방향·목표 거리 설정
+        if (distance <= 0f)
+        {
+            // 벽에 붙어있으면 반대 방향 강제, 아니면 ±30도 회전
+            int wallRotY = Map.GetRotYAwayFromWall(posX, posZ);
+            rotY = wallRotY >= 0
+                ? (wallRotY + Random.Shared.Next(-30, 31) + 360) % 360
+                : (rotY     + Random.Shared.Next(-30, 31) + 360) % 360;
+
+            float rad = rotY * MathF.PI / 180f;
+            dirX = MathF.Sin(rad);
+            dirZ = MathF.Cos(rad);
+
+            // 3초~12초에 도달할 수 있는 거리 = moveSpeed × 랜덤 초
+            float seconds = 3f + (float)Random.Shared.NextDouble() * 9f;
+            distance = moveSpeed * seconds;
+        }
+
+        // 이번 틱 이동량 (남은 거리 초과 방지)
+        float step = MathF.Min(moveSpeed * delta, distance);
+        float nextX = posX + dirX * step;
+        float nextZ = posZ + dirZ * step;
+
+        // 벽 충돌 시 clamp + 다음 틱에 방향 재설정
+        bool hitWall = Map.Clamp(ref nextX, ref nextZ);
+        posX = nextX;
+        posZ = nextZ;
+        distance = hitWall ? 0f : distance - step;
+
+        // 정수 Vector3 갱신
+        position.X = posX;
+        position.Z = posZ;
+    }
+
+    public void SendTransform()
+    {
+        if (peer == null || writer == null)
+        {
+            return;
+        }
+
+        UpdateDummy();
+        TransformPlayerPacket transformPlayerPacket = new TransformPlayerPacket
+        {
+            PlayerId = clientId,
+            RotY = rotY,
+            Position = new Packet.Position
+            {
+                X = position.X,
+                Y = -0.5f, // 높이는 버린다.
+                Z = position.Z
+            }
+        };
+
+        // Protobuf 직렬화 + 헤더 조립
+        byte[] data = PacketSerializer.Serialize((ushort)PacketCode.TRANSFORM_PLAYER, transformPlayerPacket);
+        writer.Put(data);
+        // 이동은 손실 감수함
+        peer.Send(writer, DeliveryMethod.Unreliable);
+        SentCount++;
+        writer.Reset();
+    }
+
+    public void PollEvents()
+    {
+        manager.PollEvents();
+    }
+
+    public void Stop()
+    {
+        manager.Stop();
+    }
+}

ClientTester/EchoClientTester/DummyService/MapBounds.cs

@@ -0,0 +1,116 @@
+namespace ClientTester.DummyService;
+
+public class MapBounds
+{
+    public float MinX
+    {
+        get;
+        set;
+    }
+
+    public float MaxX
+    {
+        get;
+        set;
+    }
+
+    public float MinZ
+    {
+        get;
+        set;
+    }
+
+    public float MaxZ
+    {
+        get;
+        set;
+    }
+
+    public MapBounds(float minX, float maxX, float minZ, float maxZ)
+    {
+        MinX = minX;
+        MaxX = maxX;
+        MinZ = minZ;
+        MaxZ = maxZ;
+    }
+
+    // 위치가 경계 안에 있는지 체크
+    public bool IsInside(float x, float z)
+    {
+        return x >= MinX && x <= MaxX && z >= MinZ && z <= MaxZ;
+    }
+
+    // 경계 초과 시 clamp, 벽에 부딪혔으면 true 반환
+    public bool Clamp(ref float x, ref float z)
+    {
+        bool hit = false;
+
+        if (x < MinX)
+        {
+            x = MinX;
+            hit = true;
+        }
+        else if (x > MaxX)
+        {
+            x = MaxX;
+            hit = true;
+        }
+
+        if (z < MinZ)
+        {
+            z = MinZ;
+            hit = true;
+        }
+        else if (z > MaxZ)
+        {
+            z = MaxZ;
+            hit = true;
+        }
+
+        return hit;
+    }
+
+    // 현재 위치 기준으로 벽 반대 방향 rotY 계산 (벽 없으면 -1)
+    public int GetRotYAwayFromWall(float x, float z, float margin = 0.5f)
+    {
+        bool atLeft = x <= MinX + margin;
+        bool atRight = x >= MaxX - margin;
+        bool atBottom = z <= MinZ + margin;
+        bool atTop = z >= MaxZ - margin;
+
+        if (!atLeft && !atRight && !atBottom && !atTop)
+        {
+            return -1; // 벽 근처 아님
+        }
+
+        // 벽 반대 방향 벡터 합산
+        float awayX = 0f, awayZ = 0f;
+        if (atLeft)
+        {
+            awayX += 1f;
+        }
+
+        if (atRight)
+        {
+            awayX -= 1f;
+        }
+
+        if (atBottom)
+        {
+            awayZ += 1f;
+        }
+
+        if (atTop)
+        {
+            awayZ -= 1f;
+        }
+
+        // 정규화
+        float len = MathF.Sqrt(awayX * awayX + awayZ * awayZ);
+        awayX /= len;
+        awayZ /= len;
+
+        // 방향 벡터 → rotY (degree)
+        return ((int)(MathF.Atan2(awayX, awayZ) * 180f / MathF.PI) + 360) % 360;
+    }
+}

ClientTester/EchoClientTester/EchoClientTester.csproj

@@ -8,6 +8,12 @@
         <RootNamespace>ClientTester</RootNamespace>
     </PropertyGroup>
 
+    <ItemGroup>
+      <None Update="appsettings.json">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+    </ItemGroup>
+
     <ItemGroup>
       <PackageReference Include="LiteNetLib" Version="2.0.2" />
       <PackageReference Include="protobuf-net" Version="3.2.56" />

ClientTester/EchoClientTester/EchoDummyService/EchoDummyClientService.cs

@@ -0,0 +1,156 @@
+using LiteNetLib;
+using Serilog;
+
+namespace ClientTester.EchoDummyService;
+
+public class EchoDummyClientService
+{
+    private readonly List<EchoDummyClients> clients;
+    private readonly int sendInterval;
+
+    // 유닛 테스트용 (n패킷 시간체크)
+    public bool IsTest
+    {
+        get;
+        set;
+    } = false;
+
+    public int TestCount
+    {
+        get;
+        set;
+    } = 100000;
+
+    // 모든거 강종
+    public event Action? OnAllDisconnected;
+
+    public EchoDummyClientService(int count, string ip, int port, string key, int sendIntervalMs = 1000)
+    {
+        sendInterval = sendIntervalMs;
+        clients = Enumerable.Range(0, count).Select(i => new EchoDummyClients(i, ip, port, key)).ToList();
+
+        Log.Information("[SERVICE] {Count}개 클라이언트 생성 → {Ip}:{Port}", count, ip, port);
+    }
+
+    public async Task RunAsync(CancellationToken ct)
+    {
+        if (IsTest)
+        {
+            foreach (EchoDummyClients c in clients)
+            {
+                c.TestCount = TestCount;
+            }
+
+            Log.Information("[TEST] 유닛 테스트 모드: 클라이언트당 {Count}개 수신 시 자동 종료", TestCount);
+        }
+
+        await Task.WhenAll(
+            PollLoopAsync(ct),
+            SendLoopAsync(ct)
+        );
+    }
+
+    private async Task PollLoopAsync(CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            foreach (EchoDummyClients c in clients)
+            {
+                c.PollEvents();
+            }
+
+            await Task.Delay(10);
+        }
+    }
+
+    private async Task SendLoopAsync(CancellationToken ct)
+    {
+        await Task.Delay(500);
+
+        int tick = 0;
+
+        while (!ct.IsCancellationRequested)
+        {
+            int sent = 0;
+            int total = clients.Count;
+
+            foreach (EchoDummyClients client in clients)
+            {
+                client.SendPing();
+                if (client.peer != null)
+                {
+                    sent++;
+                }
+                else
+                {
+                    total--;
+                }
+            }
+
+            if (total == 0)
+            {
+                Log.Information("All Disconnect Clients");
+                OnAllDisconnected?.Invoke();
+                break;
+            }
+
+            Log.Debug("[TICK {Tick:000}] {Sent}/{Total} 전송", tick, sent, total);
+            tick++;
+
+            await Task.Delay(sendInterval);
+        }
+    }
+
+    public void PrintStats()
+    {
+        int totalSent = 0, totalRecv = 0;
+        int connected = 0;
+        int rttClientCount = 0;
+
+        Log.Information("───────────── Performance Report ─────────────");
+
+        double totalAvgRtt = 0;
+
+        foreach (EchoDummyClients c in clients)
+        {
+            NetStatistics? stats = c.peer?.Statistics;
+            long loss = stats?.PacketLoss ?? 0;
+            float lossPct = stats?.PacketLossPercent ?? 0f;
+
+            Log.Information(
+                "[Client {ClientId:00}] Sent={Sent} Recv={Recv} | Loss={Loss}({LossPct:F1}%) AvgRTT={AvgRtt:F3}ms LastRTT={LastRtt:F3}ms",
+                c.clientId, c.SentCount, c.ReceivedCount, loss, lossPct, c.AvgRttMs, c.LastRttMs);
+
+            totalSent += c.SentCount;
+            totalRecv += c.ReceivedCount;
+            if (c.RttCount > 0)
+            {
+                totalAvgRtt += c.AvgRttMs;
+                rttClientCount++;
+            }
+
+            if (c.peer != null)
+            {
+                connected++;
+            }
+        }
+
+        double avgRtt = rttClientCount > 0 ? totalAvgRtt / rttClientCount : 0;
+
+        Log.Information("────────────────────────────────────────────");
+        Log.Information(
+            "[TOTAL] Sent={Sent} Recv={Recv} Connected={Connected}/{Total} AvgRTT={AvgRtt:F3}ms",
+            totalSent, totalRecv, connected, clients.Count, avgRtt);
+        Log.Information("────────────────────────────────────────────");
+    }
+
+    public void Stop()
+    {
+        foreach (EchoDummyClients c in clients)
+        {
+            c.Stop();
+        }
+
+        Log.Information("[SERVICE] 모든 클라이언트 종료됨.");
+    }
+}

ClientTester/EchoClientTester/EchoDummyService/EchoDummyClients.cs

@@ -1,13 +1,15 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Text;
 using ClientTester.Packet;
 using LiteNetLib;
 using LiteNetLib.Utils;
+using ProtoBuf;
 using Serilog;
 
 namespace ClientTester.EchoDummyService;
 
-public class DummyClients
+public class EchoDummyClients
 {
     private NetManager manager;
     private EventBasedNetListener listener;
@@ -18,7 +20,14 @@ public class DummyClients
     // seq → 송신 타임스탬프 (Stopwatch tick)
     private ConcurrentDictionary<int, long> pendingPings = new();
     private int seqNumber;
-    private const int MaxPendingPings = 1000;
+    private const int MAX_PENDING_PINGS = 1000;
+
+    // 유닛 테스트용 (0 = 제한 없음)
+    public int TestCount
+    {
+        get;
+        set;
+    } = 0;
 
     // 통계
     public int SentCount
@@ -51,7 +60,7 @@ public class DummyClients
         get;
     }
 
-    public DummyClients(int clientId, string ip, int port, string key)
+    public EchoDummyClients(int clientId, string ip, int port, string key)
     {
         this.clientId = clientId;
         listener = new EventBasedNetListener();
@@ -68,10 +77,14 @@ public class DummyClients
         {
             short code = reader.GetShort();
             short bodyLength = reader.GetShort();
-            string? msg = reader.GetString();
+
+            byte[] payloadBytes = new byte[bodyLength];
+            reader.GetBytes(payloadBytes, bodyLength);
+            EchoPacket echoPacket = PacketSerializer.DeserializePayload<EchoPacket>(payloadBytes);
+            string msg = echoPacket.Str;
             long sentTick;
 
-            if (msg != null && msg.StartsWith("Echo seq:") &&
+            if (msg.StartsWith("Echo seq:") &&
                 int.TryParse(msg.Substring("Echo seq:".Length), out int seq) &&
                 pendingPings.TryRemove(seq, out sentTick))
             {
@@ -82,6 +95,12 @@ public class DummyClients
             }
 
             ReceivedCount++;
+
+            if (TestCount > 0 && ReceivedCount >= TestCount)
+            {
+                peer.Disconnect();
+            }
+
             reader.Recycle();
         };
 
@@ -106,22 +125,24 @@ public class DummyClients
         pendingPings[seq] = Stopwatch.GetTimestamp();
 
         // 응답 없는 오래된 ping 정리 (패킷 유실 시 메모리 누수 방지)
-        if (pendingPings.Count > MaxPendingPings)
+        if (pendingPings.Count > MAX_PENDING_PINGS)
         {
-            int cutoff = seq - MaxPendingPings;
+            int cutoff = seq - MAX_PENDING_PINGS;
             foreach (int key in pendingPings.Keys)
             {
                 if (key < cutoff)
+                {
                     pendingPings.TryRemove(key, out _);
+                }
             }
         }
 
-        PacketHeader packetHeader = new PacketHeader();
-        packetHeader.Code = 0;
-        packetHeader.BodyLength = $"Echo seq:{seq}".Length;
-        writer.Put((short)packetHeader.Code);
-        writer.Put((short)packetHeader.BodyLength);
-        writer.Put($"Echo seq:{seq}");
+        // string → raw bytes (길이 prefix 방지)
+        EchoPacket echoPacket = new EchoPacket();
+        echoPacket.Str = $"Echo seq:{seq}";
+
+        byte[] data = PacketSerializer.Serialize<EchoPacket>((ushort)PacketCode.ECHO, echoPacket);
+        writer.Put(data);
         // 순서보장 안함 HOL Blocking 제거
         peer.Send(writer, DeliveryMethod.ReliableUnordered);
         SentCount++;

ClientTester/EchoClientTester/EchoDummyService/Map.cs

@@ -0,0 +1,6 @@
+namespace ClientTester.EchoDummyService;
+
+public class Map
+{
+    // TODO : 맵 정보 필요
+}

ClientTester/EchoClientTester/Packet/PacketBody.cs

@@ -4,12 +4,28 @@ using ProtoBuf;
 
 namespace ClientTester.Packet;
 
+// ============================================================
+// 에코용
+// ============================================================
+
+// ECHO
+[ProtoContract]
+public class EchoPacket
+{
+    [ProtoMember(1)]
+    public string Str
+    {
+        get;
+        set;
+    }
+}
+
 // ============================================================
 // 공통 타입
 // ============================================================
 
 [ProtoContract]
-public class Vector3
+public class Position
 {
     [ProtoMember(1)]
     public float X
@@ -86,7 +102,7 @@ public class PlayerInfo
     }
 
     [ProtoMember(8)]
-    public Vector3 Position
+    public Position Position
     {
         get;
         set;
@@ -100,31 +116,25 @@ public class PlayerInfo
     }
 }
 
+// ============================================================
+// 인증
+// ============================================================
+
+// DUMMY_ACC_TOKEN
 [ProtoContract]
-public class ItemInfo
+public class DummyAccTokenPacket
 {
     [ProtoMember(1)]
-    public int ItemId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public int Count
+    public int Token
     {
         get;
         set;
     }
 }
 
-// ============================================================
-// 인증
-// ============================================================
-
-// RECV_TOKEN
+// ACC_TOKEN
 [ProtoContract]
-public class RecvTokenPacket
+public class AccTokenPacket
 {
     [ProtoMember(1)]
     public string Token
@@ -134,7 +144,7 @@ public class RecvTokenPacket
     }
 }
 
-// LOAD_GAME
+// LOAD_GAME 내 정보
 [ProtoContract]
 public class LoadGamePacket
 {
@@ -151,155 +161,58 @@ public class LoadGamePacket
         get;
         set;
     }
+
+    [ProtoMember(3)]
+    public int MaplId
+    {
+        get;
+        set;
+    }
 }
 
 // ============================================================
 // 로비
 // ============================================================
 
-// INTO_LOBBY
 [ProtoContract]
-public class IntoLobbyPacket
+public class ChannelInfo
 {
     [ProtoMember(1)]
-    public List<PlayerInfo> Players
-    {
-        get;
-        set;
-    } = null!;
-}
-
-// EXIT_LOBBY
-[ProtoContract]
-public class ExitLobbyPacket
-{
-    [ProtoMember(1)]
-    public int PlayerId
-    {
-        get;
-        set;
-    }
-}
-
-// ============================================================
-// 인스턴스 던전
-// ============================================================
-
-public enum BossState
-{
-    START,
-    END,
-    PHASE_CHANGE
-}
-
-public enum BossResult
-{
-    SUCCESS,
-    FAIL
-}
-
-// INTO_INSTANCE
-[ProtoContract]
-public class IntoInstancePacket
-{
-    [ProtoMember(1)]
-    public int InstanceId
+    public int ChannelId
     {
         get;
         set;
     }
 
     [ProtoMember(2)]
-    public int BossId
+    public int ChannelUserCount
     {
         get;
         set;
     }
 
     [ProtoMember(3)]
-    public List<int> PlayerIds
+    public int ChannelUserMax
     {
         get;
         set;
     }
 }
 
-// UPDATE_BOSS
 [ProtoContract]
-public class UpdateBossPacket
+public class LoadChannelPacket
 {
     [ProtoMember(1)]
-    public BossState State
+    public List<ChannelInfo> Channels
     {
         get;
         set;
-    }
-
-    [ProtoMember(2)]
-    public int Phase
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
-    public BossResult Result
-    {
-        get;
-        set;
-    } // END일 때만 유효
+    } = new List<ChannelInfo>();
 }
 
-// REWARD_INSTANCE
+// 채널 내 파티 정보 (INTO_CHANNEL 응답에 포함)
 [ProtoContract]
-public class RewardInstancePacket
-{
-    [ProtoMember(1)]
-    public int Exp
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public List<ItemInfo> Items
-    {
-        get;
-        set;
-    }
-}
-
-// EXIT_INSTANCE
-[ProtoContract]
-public class ExitInstancePacket
-{
-    [ProtoMember(1)]
-    public int PlayerId
-    {
-        get;
-        set;
-    }
-}
-
-// ============================================================
-// 파티
-// ============================================================
-
-public enum PartyUpdateType
-{
-    CREATE,
-    DELETE
-}
-
-public enum UserPartyUpdateType
-{
-    JOIN,
-    LEAVE
-}
-
-// UPDATE_PARTY
-[ProtoContract]
-public class UpdatePartyPacket
+public class PartyInfoData
 {
     [ProtoMember(1)]
     public int PartyId
@@ -309,40 +222,114 @@ public class UpdatePartyPacket
     }
 
     [ProtoMember(2)]
-    public PartyUpdateType Type
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
     public int LeaderId
     {
         get;
         set;
     }
+
+    [ProtoMember(3)]
+    public List<int> MemberPlayerIds
+    {
+        get;
+        set;
+    } = new List<int>();
+
+    [ProtoMember(4)]
+    public string PartyName
+    {
+        get;
+        set;
+    }
 }
 
-// UPDATE_USER_PARTY
+// INTO_CHANNEL
+// 클라->서버: 입장할 채널 ID
+// 서버->클라: 채널 내 나 이외 플레이어 목록
 [ProtoContract]
-public class UpdateUserPartyPacket
+public class IntoChannelPacket
 {
     [ProtoMember(1)]
+    public int ChannelId
+    {
+        get;
+        set;
+    } // 클라->서버: 입장할 채널 ID
+
+    [ProtoMember(2)]
+    public List<PlayerInfo> Players
+    {
+        get;
+        set;
+    } = new List<PlayerInfo>(); // 서버->클라: 채널 내 플레이어 목록
+
+    [ProtoMember(3)]
+    public List<PartyInfoData> Parties
+    {
+        get;
+        set;
+    } = new List<PartyInfoData>(); // 서버->클라: 채널 내 파티 목록
+}
+
+// 파티원 모두 채널이동
+// 클라->서버: 입장할 채널 ID
+[ProtoContract]
+public class IntoChannelPartyPacket
+{
+    [ProtoMember(1)]
+    public int ChannelId
+    {
+        get;
+        set;
+    } // 클라->서버: 입장할 채널 ID
+
+    [ProtoMember(2)]
+    public List<PlayerInfo> Players
+    {
+        get;
+        set;
+    } = new List<PlayerInfo>(); // 서버->클라: 채널 내 플레이어 목록
+
+    [ProtoMember(3)]
+    public List<PartyInfoData> Parties
+    {
+        get;
+        set;
+    } = new List<PartyInfoData>(); // 서버->클라: 채널 내 파티 목록
+
+    [ProtoMember(4)]
     public int PartyId
     {
         get;
         set;
     }
+}
+
+// UPDATE_CHANNEL_USER 유저 접속/나감
+[ProtoContract]
+public class UpdateChannelUserPacket
+{
+    [ProtoMember(1)]
+    public PlayerInfo Players
+    {
+        get;
+        set;
+    }
 
     [ProtoMember(2)]
-    public int PlayerId
+    public bool IsAdd
     {
         get;
         set;
     }
+}
 
-    [ProtoMember(3)]
-    public UserPartyUpdateType Type
+// EXIT_CHANNEL 나가는 유저
+[ProtoContract]
+public class ExitChannelPacket
+{
+    [ProtoMember(1)]
+    public int PlayerId
     {
         get;
         set;
@@ -376,7 +363,7 @@ public class TransformPlayerPacket
     }
 
     [ProtoMember(2)]
-    public Vector3 Position
+    public Position Position
     {
         get;
         set;
@@ -488,7 +475,7 @@ public class TransformNpcPacket
     }
 
     [ProtoMember(2)]
-    public Vector3 Position
+    public Position Position
     {
         get;
         set;
@@ -604,3 +591,165 @@ public class DamagePacket
         set;
     }
 }
+
+// ============================================================
+// 에러
+// ============================================================
+
+public enum ErrorCode : int
+{
+    // 파티 (10021~)
+    PARTY_ALREADY_IN_PARTY = 10021,
+    PARTY_JOIN_FAILED = 10022,
+    PARTY_NOT_IN_PARTY = 10023,
+    PARTY_DELETE_FAILED = 10024,
+    PARTY_UPDATE_FAILED = 10025,
+}
+
+// ERROR (서버 -> 클라)
+[ProtoContract]
+public class ErrorPacket
+{
+    [ProtoMember(1)]
+    public ErrorCode Code
+    {
+        get;
+        set;
+    }
+}
+
+// ============================================================
+// 파티
+// ============================================================
+
+public enum PartyUpdateType
+{
+    CREATE,
+    DELETE,
+    JOIN,
+    LEAVE,
+    UPDATE
+}
+
+// REQUEST_PARTY (클라 -> 서버) - CREATE: PartyName 사용 / JOIN·LEAVE·DELETE: PartyId 사용
+[ProtoContract]
+public class RequestPartyPacket
+{
+    [ProtoMember(1)]
+    public PartyUpdateType Type
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int PartyId
+    {
+        get;
+        set;
+    } // JOIN, LEAVE, DELETE 시 사용
+
+    [ProtoMember(3)]
+    public string PartyName
+    {
+        get;
+        set;
+    } // CREATE 시 사용
+}
+
+// ============================================================
+// 채팅
+// ============================================================
+
+public enum ChatType
+{
+    GLOBAL, // 전체 채널
+    PARTY, // 파티원
+    WHISPER // 귓말
+}
+
+// CHAT (클라 -> 서버 & 서버 -> 클라)
+// 클라->서버: Type, TargetId(WHISPER 시), Message
+// 서버->클라: Type, SenderId, SenderNickname, TargetId(WHISPER 시), Message
+[ProtoContract]
+public class ChatPacket
+{
+    [ProtoMember(1)]
+    public ChatType Type
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int SenderId
+    {
+        get;
+        set;
+    } // 서버에서 채워줌
+
+    [ProtoMember(3)]
+    public string SenderNickname
+    {
+        get;
+        set;
+    } // 서버에서 채워줌
+
+    [ProtoMember(4)]
+    public int TargetId
+    {
+        get;
+        set;
+    } // WHISPER일 때 대상 PlayerId
+
+    [ProtoMember(5)]
+    public string Message
+    {
+        get;
+        set;
+    }
+}
+
+// ============================================================
+// 파티
+// ============================================================
+
+// UPDATE_PARTY (서버 -> 클라) - 파티 생성/삭제: LeaderId 사용 / 파티원 추가/제거: PlayerId 사용
+[ProtoContract]
+public class UpdatePartyPacket
+{
+    [ProtoMember(1)]
+    public int PartyId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public PartyUpdateType Type
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(3)]
+    public int LeaderId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(4)]
+    public int PlayerId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(5)]
+    public string PartyName
+    {
+        get;
+        set;
+    } // CREATE일 때 사용
+}

ClientTester/EchoClientTester/Packet/PacketHeader.cs

@@ -1,61 +1,71 @@
 namespace ClientTester.Packet;
 
-public enum PacketCode : short
+public enum PacketCode : ushort
 {
-    NONE,
+    // ECHO
+    ECHO = 1000,
+
+    // DUMMY 클라는 이걸로 jwt토큰 안받음
+    DUMMY_ACC_TOKEN = 1001,
+
     // 초기 클라이언트 시작시 jwt토큰 받아옴
-    RECV_TOKEN,
-    // jwt토큰 검증후 게임에 들어갈지 말지 (내 데이터도 전송)
+    ACC_TOKEN = 1,
+
+    // 내 정보 로드 (서버 -> 클라)
     LOAD_GAME,
 
-    // 마을(로비)진입시 모든 데이터 로드
-    INTO_LOBBY,
+    // 모든 채널 로드 - jwt토큰 검증후 게임에 들어갈지 말지 (내 데이터도 전송)
+    // (서버 -> 클라)
+    LOAD_CHANNEL,
 
-    // 로비 나가기
-    EXIT_LOBBY,
+    // 나 채널 접속 (클라 -> 서버)
+    INTO_CHANNEL,
 
-    // 인스턴스 던전 입장
-    INTO_INSTANCE,
+    // 파티 채널 접속 (클라 -> 서버)
+    INTO_CHANNEL_PARTY,
 
-    // 결과 보상
-    REWARD_INSTANCE,
+    // 새로운 유저 채널 접속 (서버 -> 클라) / 유저 채널 나감 (서버 -> 클라)
+    UPDATE_CHANNEL_USER,
 
-    // 보스전 (시작, 종료)
-    UPDATE_BOSS,
+    // 채널 나가기 (클라 -> 서버)
+    EXIT_CHANNEL,
 
-    // 인스턴스 던전 퇴장
-    EXIT_INSTANCE,
-
-    // 파티 (생성, 삭제)
-    UPDATE_PARTY,
-
-    // 파티 유저 업데이트(추가 삭제)
-    UPDATE_USER_PARTY,
-
-    // 플레이어 위치, 방향
+    // 플레이어 위치, 방향 (서버 -> 클라 \ 클라 -> 서버)
     TRANSFORM_PLAYER,
 
-    // 플레이어 행동 업데이트
+    // 플레이어 행동 업데이트 (서버 -> 클라 \ 클라 -> 서버)
     ACTION_PLAYER,
 
-    // 플레이어 스테이트 업데이트
+    // 플레이어 스테이트 업데이트 (서버 -> 클라 \ 클라 -> 서버)
     STATE_PLAYER,
 
-    // NPC 위치, 방향
+    // NPC 위치, 방향 (서버 -> 클라)
     TRANSFORM_NPC,
 
-    // NPC 행동 업데이트
+    // NPC 행동 업데이트 (서버 -> 클라)
     ACTION_NPC,
 
-    // NPC 스테이트 업데이트
+    // NPC 스테이트 업데이트 (서버 -> 클라)
     STATE_NPC,
 
-    // 데미지 UI 전달
-    DAMAGE
+    // 데미지 UI 전달 (서버 -> 클라)
+    DAMAGE,
+
+    // 파티 생성/삭제, 파티원 추가/제거 (서버 -> 클라)
+    UPDATE_PARTY,
+
+    // 파티 참가/탈퇴/생성/해산 요청 (클라 -> 서버)
+    REQUEST_PARTY,
+
+    // 채팅 (클라 -> 서버 & 서버 -> 클라) - GLOBAL / PARTY / WHISPER
+    CHAT,
+
+    // 요청 실패 응답 (서버 -> 클라)
+    ERROR = 9999
 }
 
 public class PacketHeader
 {
     public PacketCode Code;
-    public int BodyLength;
+    public ushort BodyLength;
 }

ClientTester/EchoClientTester/Packet/PacketSerializer.cs

@@ -11,15 +11,18 @@ namespace ClientTester.Packet
         public static byte[] Serialize<T>(ushort type, T packet)
         {
             using MemoryStream payloadMs = new MemoryStream();
-            Serializer.Serialize(payloadMs, packet);
+            Serializer.Serialize<T>(payloadMs, packet);
             byte[] payload = payloadMs.ToArray();
             ushort size = (ushort)payload.Length;
 
             byte[] result = new byte[4 + payload.Length];
+            // 2바이트 패킷 타입 헤더
             result[0] = (byte)(type & 0xFF);
             result[1] = (byte)(type >> 8);
+            // 2바이트 패킷 길이 헤더
             result[2] = (byte)(size & 0xFF);
             result[3] = (byte)(size >> 8);
+            // protobuf 페이로드
             Buffer.BlockCopy(payload, 0, result, 4, payload.Length);
             return result;
         }
@@ -36,10 +39,12 @@ namespace ClientTester.Packet
             ushort type = (ushort)(data[0] | (data[1] << 8));
             ushort size = (ushort)(data[2] | (data[3] << 8));
 
+            // 헤더에 명시된 size와 실제 데이터 길이 검증
             int actualPayloadLen = data.Length - 4;
             if (size > actualPayloadLen)
             {
-                Log.Warning("[PacketSerializer] 페이로드 크기 불일치 HeaderSize={Size} ActualSize={Actual}", size, actualPayloadLen);
+                Log.Warning("[PacketSerializer] 페이로드 크기 불일치 HeaderSize={Size} ActualSize={Actual}", size,
+                    actualPayloadLen);
                 return (0, 0, null)!;
             }
 

ClientTester/EchoClientTester/Program.cs

@@ -1,45 +1,275 @@
+using System.Text.Json;
+using ClientTester.DummyService;
 using ClientTester.EchoDummyService;
+using ClientTester.StressTest;
+using ClientTester.Utils;
 using Serilog;
 
 class EcoClientTester
 {
-    public static readonly string SERVER_IP = "tolelom.xyz";
-    public static readonly int SERVER_PORT = 9500;
-    public static readonly string CONNECTION_KEY = "test";
-    public static readonly int CLIENT_COUNT = 100;
+    public static string SERVER_IP = "localhost";
+    public static int SERVER_PORT = 9500;
+    public static string CONNECTION_KEY = "";
+    public static int CLIENT_COUNT = 50;
+
+    private static void LoadConfig()
+    {
+        string path = Path.Combine(AppContext.BaseDirectory, "appsettings.json");
+        if (!File.Exists(path)) return;
+
+        using JsonDocument doc = JsonDocument.Parse(File.ReadAllText(path));
+        JsonElement root = doc.RootElement;
+
+        if (root.TryGetProperty("ServerIp", out JsonElement ip)) SERVER_IP = ip.GetString() ?? SERVER_IP;
+        if (root.TryGetProperty("ServerPort", out JsonElement port)) SERVER_PORT = port.GetInt32();
+        if (root.TryGetProperty("ConnectionKey", out JsonElement key)) CONNECTION_KEY = key.GetString() ?? CONNECTION_KEY;
+        if (root.TryGetProperty("ClientCount", out JsonElement count)) CLIENT_COUNT = count.GetInt32();
+    }
+
+    private async Task StartEchoDummyTest()
+    {
+        try
+        {
+            CancellationTokenSource cts = new CancellationTokenSource();
+            Console.CancelKeyPress += (_, e) =>
+            {
+                e.Cancel = true;
+                Log.Warning("[SHUTDOWN] Ctrl+C 감지, 종료 중...");
+                cts.Cancel();
+            };
+
+            EchoDummyClientService service =
+                new EchoDummyClientService(CLIENT_COUNT, SERVER_IP, SERVER_PORT, CONNECTION_KEY, 100);
+            service.OnAllDisconnected += () =>
+            {
+                Log.Warning("[SHUTDOWN] 종료 이벤트 발생, 종료 중...");
+                cts.Cancel();
+            };
+
+            // service.IsTest = true;
+            // service.TestCount = 100;
+            await service.RunAsync(cts.Token);
+
+            service.PrintStats();
+            service.Stop();
+
+            await Log.CloseAndFlushAsync();
+        }
+        catch (Exception e)
+        {
+            Log.Error($"[SHUTDOWN] 예외 발생 : {e}");
+        }
+    }
+
+    private async Task StartDummyTest()
+    {
+        try
+        {
+            CancellationTokenSource cts = new CancellationTokenSource();
+            Console.CancelKeyPress += (_, e) =>
+            {
+                e.Cancel = true;
+                Log.Warning("[SHUTDOWN] Ctrl+C 감지, 종료 중...");
+                cts.Cancel();
+            };
+
+            DummyClientService service =
+                new DummyClientService(CLIENT_COUNT, SERVER_IP, SERVER_PORT, CONNECTION_KEY, 100);
+            service.OnAllDisconnected += () =>
+            {
+                Log.Warning("[SHUTDOWN] 종료 이벤트 발생, 종료 중...");
+                cts.Cancel();
+            };
+
+            await service.RunAsync(cts.Token);
+
+            service.PrintStats();
+            service.Stop();
+
+            await Log.CloseAndFlushAsync();
+        }
+        catch (Exception e)
+        {
+            Log.Error($"[SHUTDOWN] 예외 발생 : {e}");
+        }
+    }
+
+    private async Task StartStressTest(int duration, int sendInterval, int rampInterval, int clientsPerRamp)
+    {
+        try
+        {
+            CancellationTokenSource cts = new CancellationTokenSource();
+            Console.CancelKeyPress += (_, e) =>
+            {
+                e.Cancel = true;
+                Log.Warning("[SHUTDOWN] Ctrl+C 감지, 종료 중...");
+                cts.Cancel();
+            };
+
+            StressTestService service = new StressTestService(
+                CLIENT_COUNT, SERVER_IP, SERVER_PORT, CONNECTION_KEY,
+                durationSec: duration,
+                sendIntervalMs: sendInterval,
+                rampUpIntervalMs: rampInterval,
+                clientsPerRamp: clientsPerRamp);
+
+            service.OnTestCompleted += () =>
+            {
+                Log.Information("[STRESS] 테스트 시간 종료.");
+            };
+
+            try
+            {
+                await service.RunAsync(cts.Token);
+            }
+            catch (OperationCanceledException) { }
+
+            service.PrintFinalReport();
+
+            string timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
+            string csvPath = $"results/stress_{CLIENT_COUNT}clients_{timestamp}.csv";
+            Directory.CreateDirectory("results");
+            service.ExportCsv(csvPath);
+
+            service.Stop();
+            await Log.CloseAndFlushAsync();
+        }
+        catch (Exception e)
+        {
+            Log.Error($"[SHUTDOWN] 예외 발생 : {e}");
+        }
+    }
+
+    private static void PrintUsage()
+    {
+        Console.WriteLine();
+        Console.WriteLine("사용법:");
+        Console.WriteLine("  EchoClientTester                          대화형 모드");
+        Console.WriteLine("  EchoClientTester stress [옵션]             스트레스 테스트");
+        Console.WriteLine();
+        Console.WriteLine("스트레스 테스트 옵션:");
+        Console.WriteLine("  -c, --clients <수>        클라이언트 수 (기본: 50)");
+        Console.WriteLine("  -d, --duration <초>       테스트 시간 (기본: 60, 0=무제한)");
+        Console.WriteLine("  -i, --interval <ms>       전송 주기 (기본: 100)");
+        Console.WriteLine("  -r, --ramp <ms>           Ramp-up 간격 (기본: 1000)");
+        Console.WriteLine("  -b, --batch <수>           Ramp-up 당 클라이언트 수 (기본: 10)");
+        Console.WriteLine("  --ip <주소>               서버 IP (기본: localhost)");
+        Console.WriteLine("  --port <포트>              서버 포트 (기본: 9500)");
+        Console.WriteLine();
+        Console.WriteLine("예시:");
+        Console.WriteLine("  EchoClientTester stress -c 100 -d 120");
+        Console.WriteLine("  EchoClientTester stress -c 200 -d 60 -r 500 -b 20 --ip 192.168.0.10");
+    }
 
     private static async Task Main(string[] args)
     {
-        // .MinimumLevel.Warning() // Warning 이상만 출력 배포시
+        // 유니코드 문자(═, ║ 등) 콘솔 깨짐 방지
+        Console.OutputEncoding = System.Text.Encoding.UTF8;
 
+        // appsettings.json 에서 설정 로드
+        LoadConfig();
+
+        // 크래시 덤프 핸들러 (Release: .log + .dmp / Debug: .log)
+        CrashDumpHandler.Register();
+
+        // .MinimumLevel.Warning() // Warning 이상만 출력 배포시
         string timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
 
         Log.Logger = new LoggerConfiguration()
             .MinimumLevel.Debug()
             .WriteTo.Console()
-            .WriteTo.File($"logs/log_{timestamp}.txt")
+            .WriteTo.File($"logs2/log_{timestamp}.txt")
             .CreateLogger();
 
-        CancellationTokenSource cts = new CancellationTokenSource();
-        Console.CancelKeyPress += (_, e) =>
+        EcoClientTester tester = new EcoClientTester();
+
+        // CLI 모드: stress 명령
+        if (args.Length > 0 && args[0].Equals("stress", StringComparison.OrdinalIgnoreCase))
         {
-            e.Cancel = true;
-            Log.Warning("[SHUTDOWN] Ctrl+C 감지, 종료 중...");
-            cts.Cancel();
-        };
+            // 기본값
+            // CLIENT_COUNT = 50;
+            int duration = 60;
+            int sendInterval = 100;
+            int rampInterval = 1000;
+            int clientsPerRamp = 10;
 
-        DummyClientService service = new DummyClientService(CLIENT_COUNT, SERVER_IP, SERVER_PORT, CONNECTION_KEY, 100);
-        service.OnAllDisconnected += () =>
+            for (int i = 1; i < args.Length; i++)
+            {
+                switch (args[i])
+                {
+                    case "-c": case "--clients":
+                        if (i + 1 < args.Length) CLIENT_COUNT = int.Parse(args[++i]);
+                        break;
+                    case "-d": case "--duration":
+                        if (i + 1 < args.Length) duration = int.Parse(args[++i]);
+                        break;
+                    case "-i": case "--interval":
+                        if (i + 1 < args.Length) sendInterval = int.Parse(args[++i]);
+                        break;
+                    case "-r": case "--ramp":
+                        if (i + 1 < args.Length) rampInterval = int.Parse(args[++i]);
+                        break;
+                    case "-b": case "--batch":
+                        if (i + 1 < args.Length) clientsPerRamp = int.Parse(args[++i]);
+                        break;
+                    case "--ip":
+                        if (i + 1 < args.Length) SERVER_IP = args[++i];
+                        break;
+                    case "--port":
+                        if (i + 1 < args.Length) SERVER_PORT = int.Parse(args[++i]);
+                        break;
+                    case "-h": case "--help":
+                        PrintUsage();
+                        return;
+                }
+            }
+
+            await tester.StartStressTest(duration, sendInterval, rampInterval, clientsPerRamp);
+            return;
+        }
+
+        // CLI 모드: help
+        if (args.Length > 0 && (args[0] == "-h" || args[0] == "--help"))
         {
-            Log.Warning("[SHUTDOWN] 종료 이벤트 발생, 종료 중...");
-            cts.Cancel();
-        };
+            PrintUsage();
+            return;
+        }
 
-        await service.RunAsync(cts.Token);
+        // 대화형 모드 (기존)
+        Log.Information("========== 더미 클라 테스터 ==========");
+        Log.Information("1. 에코 서버");
+        Log.Information("2. 더미 클라(이동만)");
+        Log.Information("3. 스트레스 테스트 (부하)");
+        Log.Information("====================================");
+        Log.Information("1 / 2 / 3 : ");
 
-        service.PrintStats();
-        service.Stop();
+        string? input = Console.ReadLine();
+        if (!int.TryParse(input, out int choice) || choice < 1 || choice > 3)
+        {
+            Log.Warning("1, 2, 3 중 입력하세요.");
+            return;
+        }
 
-        await Log.CloseAndFlushAsync();
+        if (choice == 1)
+        {
+            await tester.StartEchoDummyTest();
+        }
+        else if (choice == 2)
+        {
+            await tester.StartDummyTest();
+        }
+        else if (choice == 3)
+        {
+            // 대화형 스트레스 테스트 설정
+            Log.Information("클라이언트 수 (기본 50): ");
+            string? countInput = Console.ReadLine();
+            CLIENT_COUNT = string.IsNullOrEmpty(countInput) ? 50 : int.Parse(countInput);
+
+            Log.Information("테스트 시간(초) (기본 60, 0=무제한): ");
+            string? durInput = Console.ReadLine();
+            int dur = string.IsNullOrEmpty(durInput) ? 60 : int.Parse(durInput);
+
+            await tester.StartStressTest(dur, 100, 1000, 10);
+        }
     }
 }

ClientTester/EchoClientTester/StressTest/StressTestClient.cs

@@ -0,0 +1,203 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using ClientTester.DummyService;
+using ClientTester.Packet;
+using LiteNetLib;
+using LiteNetLib.Utils;
+using Serilog;
+
+namespace ClientTester.StressTest;
+
+/// <summary>
+/// 스트레스 테스트용 클라이언트.
+/// Echo RTT 측정 + 이동 패킷 전송을 동시에 수행.
+/// </summary>
+public class StressTestClient
+{
+    private NetManager manager;
+    private EventBasedNetListener listener;
+    private NetDataWriter? writer;
+    public NetPeer? peer;
+    public int clientId;
+
+    // 이동
+    private Vector3 position = new Vector3();
+    private int rotY;
+    private float moveSpeed = 3.5f;
+    private float distance;
+    private float preTime;
+    private readonly Stopwatch moveClock = Stopwatch.StartNew();
+    private float posX, posZ, dirX, dirZ;
+    public MapBounds Map { get; set; } = new MapBounds(-50f, 50f, -50f, 50f);
+
+    // RTT 측정
+    private readonly ConcurrentDictionary<int, long> pendingPings = new();
+    private int seqNumber;
+    private const int MAX_PENDING = 500;
+
+    /// <summary>개별 RTT 기록 (퍼센타일 계산용)</summary>
+    public ConcurrentBag<double> RttSamples { get; } = new();
+
+    // 통계
+    public int SentCount { get; set; }
+    public int ReceivedCount { get; set; }
+    public int RttCount { get; set; }
+    public double TotalRttMs { get; set; }
+    public double LastRttMs { get; set; }
+    public double AvgRttMs => RttCount > 0 ? TotalRttMs / RttCount : 0;
+    public bool IsConnected => peer != null;
+
+    public StressTestClient(int clientId, string ip, int port, string key)
+    {
+        this.clientId = clientId;
+        listener = new EventBasedNetListener();
+        manager = new NetManager(listener);
+        writer = new NetDataWriter();
+
+        listener.PeerConnectedEvent += netPeer =>
+        {
+            peer = netPeer;
+            Log.Debug("[Stress {Id:000}] 연결됨", clientId);
+
+            DummyAccTokenPacket token = new DummyAccTokenPacket { Token = clientId };
+            byte[] data = PacketSerializer.Serialize((ushort)PacketCode.DUMMY_ACC_TOKEN, token);
+            writer!.Put(data);
+            peer.Send(writer, DeliveryMethod.ReliableOrdered);
+            writer.Reset();
+        };
+
+        listener.NetworkReceiveEvent += (p, reader, ch, dm) =>
+        {
+            ReceivedCount++;
+
+            try
+            {
+                byte[] raw = reader.GetRemainingBytes();
+                if (raw.Length >= 4)
+                {
+                    ushort type = BitConverter.ToUInt16(raw, 0);
+                    ushort size = BitConverter.ToUInt16(raw, 2);
+
+                    if (type == (ushort)PacketCode.ECHO && size > 0 && raw.Length >= 4 + size)
+                    {
+                        byte[] payload = new byte[size];
+                        Array.Copy(raw, 4, payload, 0, size);
+                        EchoPacket echo = PacketSerializer.DeserializePayload<EchoPacket>(payload);
+
+                        if (echo.Str.StartsWith("Echo seq:") &&
+                            int.TryParse(echo.Str.AsSpan("Echo seq:".Length), out int seq) &&
+                            pendingPings.TryRemove(seq, out long sentTick))
+                        {
+                            double rttMs = (Stopwatch.GetTimestamp() - sentTick) * 1000.0 / Stopwatch.Frequency;
+                            LastRttMs = rttMs;
+                            TotalRttMs += rttMs;
+                            RttCount++;
+                            RttSamples.Add(rttMs);
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                // 파싱 실패는 무시 (다른 패킷 타입)
+            }
+        };
+
+        listener.PeerDisconnectedEvent += (p, info) =>
+        {
+            Log.Debug("[Stress {Id:000}] 끊김: {Reason}", clientId, info.Reason);
+            peer = null;
+        };
+
+        manager.Start();
+        manager.Connect(ip, port, key);
+    }
+
+    public void UpdateAndSendTransform()
+    {
+        if (peer == null || writer == null)
+        {
+            return;
+        }
+
+        // 이동 업데이트
+        float now = (float)moveClock.Elapsed.TotalSeconds;
+        float delta = preTime > 0f ? now - preTime : 0.1f;
+        preTime = now;
+
+        if (distance <= 0f)
+        {
+            int wallRotY = Map.GetRotYAwayFromWall(posX, posZ);
+            rotY = wallRotY >= 0
+                ? (wallRotY + Random.Shared.Next(-30, 31) + 360) % 360
+                : (rotY + Random.Shared.Next(-30, 31) + 360) % 360;
+            float rad = rotY * MathF.PI / 180f;
+            dirX = MathF.Sin(rad);
+            dirZ = MathF.Cos(rad);
+            distance = moveSpeed * (3f + (float)Random.Shared.NextDouble() * 9f);
+        }
+
+        float step = MathF.Min(moveSpeed * delta, distance);
+        float nextX = posX + dirX * step;
+        float nextZ = posZ + dirZ * step;
+        bool hitWall = Map.Clamp(ref nextX, ref nextZ);
+        posX = nextX;
+        posZ = nextZ;
+        distance = hitWall ? 0f : distance - step;
+        position.X = posX;
+        position.Z = posZ;
+
+        // 전송
+        TransformPlayerPacket pkt = new TransformPlayerPacket
+        {
+            PlayerId = clientId,
+            RotY = rotY,
+            Position = new Packet.Position { X = position.X, Y = -0.5f, Z = position.Z }
+        };
+        byte[] data = PacketSerializer.Serialize((ushort)PacketCode.TRANSFORM_PLAYER, pkt);
+        writer.Put(data);
+        peer.Send(writer, DeliveryMethod.Unreliable);
+        SentCount++;
+        writer.Reset();
+    }
+
+    public void SendPing()
+    {
+        if (peer == null || writer == null)
+        {
+            return;
+        }
+
+        int seq = seqNumber++;
+        pendingPings[seq] = Stopwatch.GetTimestamp();
+
+        if (pendingPings.Count > MAX_PENDING)
+        {
+            int cutoff = seq - MAX_PENDING;
+            foreach (int k in pendingPings.Keys)
+            {
+                if (k < cutoff)
+                {
+                    pendingPings.TryRemove(k, out _);
+                }
+            }
+        }
+
+        EchoPacket echo = new EchoPacket { Str = $"Echo seq:{seq}" };
+        byte[] data = PacketSerializer.Serialize((ushort)PacketCode.ECHO, echo);
+        writer.Put(data);
+        peer.Send(writer, DeliveryMethod.ReliableUnordered);
+        SentCount++;
+        writer.Reset();
+    }
+
+    public void PollEvents()
+    {
+        manager.PollEvents();
+    }
+
+    public void Stop()
+    {
+        manager.Stop();
+    }
+}

ClientTester/EchoClientTester/StressTest/StressTestService.cs

@@ -0,0 +1,398 @@
+using System.Diagnostics;
+using System.Globalization;
+using System.Text;
+using LiteNetLib;
+using Serilog;
+
+namespace ClientTester.StressTest;
+
+/// <summary>
+/// 스트레스/부하 테스트 서비스.
+///
+/// 기능:
+///   - 점진적 Ramp-up (N초 간격으로 클라이언트 추가)
+///   - 테스트 지속시간 제한
+///   - 실시간 처리량 (packets/sec) 측정
+///   - 퍼센타일 레이턴시 (P50, P95, P99) 계산
+///   - CSV 결과 내보내기
+/// </summary>
+public class StressTestService
+{
+    private readonly string ip;
+    private readonly int port;
+    private readonly string key;
+    private readonly int totalClients;
+    private readonly int rampUpIntervalMs;
+    private readonly int clientsPerRamp;
+    private readonly int sendIntervalMs;
+    private readonly int durationSec;
+
+    private readonly List<StressTestClient> clients = new();
+    private readonly object clientsLock = new();
+    private readonly Stopwatch testClock = new();
+
+    // 실시간 처리량 추적
+    private int prevTotalSent;
+    private int prevTotalRecv;
+    private long prevStatsTick;
+
+    public event Action? OnTestCompleted;
+
+    /// <summary>
+    /// 스트레스 테스트 서비스 생성.
+    /// </summary>
+    /// <param name="totalClients">총 클라이언트 수</param>
+    /// <param name="ip">서버 IP</param>
+    /// <param name="port">서버 포트</param>
+    /// <param name="key">연결 키</param>
+    /// <param name="durationSec">테스트 지속 시간 (초). 0 = 무제한</param>
+    /// <param name="sendIntervalMs">패킷 전송 주기 (ms)</param>
+    /// <param name="rampUpIntervalMs">Ramp-up 간격 (ms). 0 = 모두 즉시 접속</param>
+    /// <param name="clientsPerRamp">Ramp-up 당 추가할 클라이언트 수</param>
+    public StressTestService(
+        int totalClients, string ip, int port, string key,
+        int durationSec = 60, int sendIntervalMs = 100,
+        int rampUpIntervalMs = 1000, int clientsPerRamp = 10)
+    {
+        this.totalClients = totalClients;
+        this.ip = ip;
+        this.port = port;
+        this.key = key;
+        this.durationSec = durationSec;
+        this.sendIntervalMs = sendIntervalMs;
+        this.rampUpIntervalMs = rampUpIntervalMs;
+        this.clientsPerRamp = clientsPerRamp;
+    }
+
+    public async Task RunAsync(CancellationToken ct)
+    {
+        Log.Information("╔═══════════════════════════════════════════════╗");
+        Log.Information("║           STRESS TEST 시작                    ║");
+        Log.Information("╠═══════════════════════════════════════════════╣");
+        Log.Information("║ 서버       : {Ip}:{Port}", ip, port);
+        Log.Information("║ 클라이언트  : {Count}명", totalClients);
+        Log.Information("║ 지속시간    : {Dur}초", durationSec == 0 ? "무제한" : durationSec);
+        Log.Information("║ 전송주기    : {Int}ms", sendIntervalMs);
+        Log.Information("║ Ramp-up    : {Per}명 / {Int}ms", clientsPerRamp, rampUpIntervalMs);
+        Log.Information("╚═══════════════════════════════════════════════╝");
+
+        testClock.Start();
+        prevStatsTick = Stopwatch.GetTimestamp();
+
+        using CancellationTokenSource durationCts = durationSec > 0
+            ? new CancellationTokenSource(TimeSpan.FromSeconds(durationSec))
+            : new CancellationTokenSource();
+
+        using CancellationTokenSource linked = CancellationTokenSource.CreateLinkedTokenSource(ct, durationCts.Token);
+
+        await Task.WhenAll(
+            RampUpLoopAsync(linked.Token),
+            PollLoopAsync(linked.Token),
+            SendLoopAsync(linked.Token),
+            StatsLoopAsync(linked.Token)
+        );
+
+        testClock.Stop();
+        OnTestCompleted?.Invoke();
+    }
+
+    /// <summary>점진적으로 클라이언트 추가</summary>
+    private async Task RampUpLoopAsync(CancellationToken ct)
+    {
+        int created = 0;
+
+        while (created < totalClients && !ct.IsCancellationRequested)
+        {
+            int batch = Math.Min(clientsPerRamp, totalClients - created);
+
+            for (int i = 0; i < batch; i++)
+            {
+                int id = created + 1; // 1-based (더미 범위)
+                StressTestClient client = new StressTestClient(id, ip, port, key);
+                lock (clientsLock)
+                {
+                    clients.Add(client);
+                }
+
+                created++;
+            }
+
+            Log.Information("[RAMP-UP] {Created}/{Total} 클라이언트 생성됨 ({Elapsed:F1}s)",
+                created, totalClients, testClock.Elapsed.TotalSeconds);
+
+            if (created < totalClients && rampUpIntervalMs > 0)
+            {
+                await Task.Delay(rampUpIntervalMs, ct).ConfigureAwait(false);
+            }
+        }
+
+        Log.Information("[RAMP-UP] 완료 - 총 {Count}명 접속", created);
+    }
+
+    private async Task PollLoopAsync(CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            List<StressTestClient> snapshot;
+            lock (clientsLock)
+            {
+                snapshot = new List<StressTestClient>(clients);
+            }
+
+            foreach (StressTestClient c in snapshot)
+            {
+                try
+                {
+                    c.PollEvents();
+                }
+                catch
+                {
+                    /* 무시 */
+                }
+            }
+
+            await Task.Delay(10, ct).ConfigureAwait(false);
+        }
+    }
+
+    private async Task SendLoopAsync(CancellationToken ct)
+    {
+        await Task.Delay(500, ct).ConfigureAwait(false);
+
+        while (!ct.IsCancellationRequested)
+        {
+            List<StressTestClient> snapshot;
+            lock (clientsLock)
+            {
+                snapshot = new List<StressTestClient>(clients);
+            }
+
+            foreach (StressTestClient c in snapshot)
+            {
+                c.UpdateAndSendTransform();
+                c.SendPing();
+            }
+
+            await Task.Delay(sendIntervalMs, ct).ConfigureAwait(false);
+        }
+    }
+
+    /// <summary>10초마다 실시간 통계 출력</summary>
+    private async Task StatsLoopAsync(CancellationToken ct)
+    {
+        await Task.Delay(5000, ct).ConfigureAwait(false);
+
+        while (!ct.IsCancellationRequested)
+        {
+            PrintLiveStats();
+            await Task.Delay(10000, ct).ConfigureAwait(false);
+        }
+    }
+
+    private void PrintLiveStats()
+    {
+        List<StressTestClient> snapshot;
+        lock (clientsLock)
+        {
+            snapshot = new List<StressTestClient>(clients);
+        }
+
+        int totalSent = snapshot.Sum(c => c.SentCount);
+        int totalRecv = snapshot.Sum(c => c.ReceivedCount);
+        int connected = snapshot.Count(c => c.IsConnected);
+
+        long now = Stopwatch.GetTimestamp();
+        double elapsedSec = (now - prevStatsTick) * 1.0 / Stopwatch.Frequency;
+        double sendRate = elapsedSec > 0 ? (totalSent - prevTotalSent) / elapsedSec : 0;
+        double recvRate = elapsedSec > 0 ? (totalRecv - prevTotalRecv) / elapsedSec : 0;
+
+        prevTotalSent = totalSent;
+        prevTotalRecv = totalRecv;
+        prevStatsTick = now;
+
+        double avgRtt = 0;
+        int rttClients = 0;
+        foreach (StressTestClient c in snapshot)
+        {
+            if (c.RttCount > 0)
+            {
+                avgRtt += c.AvgRttMs;
+                rttClients++;
+            }
+        }
+
+        if (rttClients > 0)
+        {
+            avgRtt /= rttClients;
+        }
+
+        Log.Information(
+            "[LIVE {Elapsed:F0}s] 접속={Conn}/{Total} | 전송={SendRate:F0}/s 수신={RecvRate:F0}/s | AvgRTT={Rtt:F2}ms",
+            testClock.Elapsed.TotalSeconds, connected, clients.Count, sendRate, recvRate, avgRtt);
+    }
+
+    /// <summary>최종 결과 리포트 출력</summary>
+    public void PrintFinalReport()
+    {
+        List<StressTestClient> snapshot;
+        lock (clientsLock)
+        {
+            snapshot = new List<StressTestClient>(clients);
+        }
+
+        int totalSent = 0, totalRecv = 0, connected = 0;
+        List<double> allRtt = new();
+
+        foreach (StressTestClient c in snapshot)
+        {
+            totalSent += c.SentCount;
+            totalRecv += c.ReceivedCount;
+            if (c.IsConnected)
+            {
+                connected++;
+            }
+
+            foreach (double r in c.RttSamples)
+            {
+                allRtt.Add(r);
+            }
+        }
+
+        allRtt.Sort();
+
+        double p50 = Percentile(allRtt, 0.50);
+        double p95 = Percentile(allRtt, 0.95);
+        double p99 = Percentile(allRtt, 0.99);
+        double avg = allRtt.Count > 0 ? allRtt.Average() : 0;
+        double min = allRtt.Count > 0 ? allRtt[0] : 0;
+        double max = allRtt.Count > 0 ? allRtt[^1] : 0;
+
+        double durSec = testClock.Elapsed.TotalSeconds;
+        double throughput = durSec > 0 ? totalSent / durSec : 0;
+
+        Log.Information("");
+        Log.Information("╔═══════════════════════════════════════════════╗");
+        Log.Information("║           STRESS TEST 최종 리포트              ║");
+        Log.Information("╠═══════════════════════════════════════════════╣");
+        Log.Information("║ 테스트 시간 : {Dur:F1}초", durSec);
+        Log.Information("║ 클라이언트  : {Conn}/{Total} 접속 유지", connected, snapshot.Count);
+        Log.Information("╠═══════════════════════════════════════════════╣");
+        Log.Information("║ [처리량]");
+        Log.Information("║   총 전송    : {Sent:N0} 패킷", totalSent);
+        Log.Information("║   총 수신    : {Recv:N0} 패킷", totalRecv);
+        Log.Information("║   처리량     : {Thr:F1} 패킷/초", throughput);
+        Log.Information("╠═══════════════════════════════════════════════╣");
+        Log.Information("║ [레이턴시] (RTT 샘플: {Count:N0}개)", allRtt.Count);
+        Log.Information("║   Min        : {Min:F2} ms", min);
+        Log.Information("║   Avg        : {Avg:F2} ms", avg);
+        Log.Information("║   P50        : {P50:F2} ms", p50);
+        Log.Information("║   P95        : {P95:F2} ms", p95);
+        Log.Information("║   P99        : {P99:F2} ms", p99);
+        Log.Information("║   Max        : {Max:F2} ms", max);
+        Log.Information("╠═══════════════════════════════════════════════╣");
+
+        // 클라이언트별 요약 (상위 5명 최악 RTT)
+        List<StressTestClient> worstClients = snapshot
+            .Where(c => c.RttCount > 0)
+            .OrderByDescending(c => c.AvgRttMs)
+            .Take(5)
+            .ToList();
+
+        if (worstClients.Count > 0)
+        {
+            Log.Information("║ [최악 RTT 상위 5 클라이언트]");
+            foreach (StressTestClient c in worstClients)
+            {
+                NetStatistics? stats = c.peer?.Statistics;
+                float lossPct = stats?.PacketLossPercent ?? 0f;
+                Log.Information("║   Client {Id:000}: AvgRTT={Rtt:F2}ms Loss={Loss:F1}% Sent={S} Recv={R}",
+                    c.clientId, c.AvgRttMs, lossPct, c.SentCount, c.ReceivedCount);
+            }
+        }
+
+        Log.Information("╚═══════════════════════════════════════════════╝");
+    }
+
+    /// <summary>결과를 CSV 파일로 내보내기</summary>
+    public void ExportCsv(string path)
+    {
+        List<StressTestClient> snapshot;
+        lock (clientsLock)
+        {
+            snapshot = new List<StressTestClient>(clients);
+        }
+
+        StringBuilder sb = new();
+        sb.AppendLine("ClientId,Sent,Received,AvgRttMs,RttCount,PacketLoss,PacketLossPct,Connected");
+
+        foreach (StressTestClient c in snapshot)
+        {
+            NetStatistics? stats = c.peer?.Statistics;
+            long loss = stats?.PacketLoss ?? 0;
+            float lossPct = stats?.PacketLossPercent ?? 0f;
+
+            sb.AppendLine(string.Format(CultureInfo.InvariantCulture,
+                "{0},{1},{2},{3:F3},{4},{5},{6:F1},{7}",
+                c.clientId, c.SentCount, c.ReceivedCount,
+                c.AvgRttMs, c.RttCount, loss, lossPct, c.IsConnected));
+        }
+
+        // 요약 행
+        List<double> allRtt = new();
+        foreach (StressTestClient c in snapshot)
+        foreach (double r in c.RttSamples)
+        {
+            allRtt.Add(r);
+        }
+
+        allRtt.Sort();
+
+        sb.AppendLine();
+        sb.AppendLine("# Summary");
+        sb.AppendLine(string.Format(CultureInfo.InvariantCulture,
+            "# Duration={0:F1}s,Clients={1},TotalSent={2},TotalRecv={3}",
+            testClock.Elapsed.TotalSeconds, snapshot.Count,
+            snapshot.Sum(c => c.SentCount), snapshot.Sum(c => c.ReceivedCount)));
+        sb.AppendLine(string.Format(CultureInfo.InvariantCulture,
+            "# P50={0:F2}ms,P95={1:F2}ms,P99={2:F2}ms",
+            Percentile(allRtt, 0.50), Percentile(allRtt, 0.95), Percentile(allRtt, 0.99)));
+
+        File.WriteAllText(path, sb.ToString());
+        Log.Information("[CSV] 결과 저장: {Path}", path);
+    }
+
+    public void Stop()
+    {
+        List<StressTestClient> snapshot;
+        lock (clientsLock)
+        {
+            snapshot = new List<StressTestClient>(clients);
+        }
+
+        foreach (StressTestClient c in snapshot)
+        {
+            c.Stop();
+        }
+
+        Log.Information("[STRESS] 모든 클라이언트 종료됨.");
+    }
+
+    private static double Percentile(List<double> sorted, double p)
+    {
+        if (sorted.Count == 0)
+        {
+            return 0;
+        }
+
+        double index = p * (sorted.Count - 1);
+        int lower = (int)Math.Floor(index);
+        int upper = (int)Math.Ceiling(index);
+        if (lower == upper)
+        {
+            return sorted[lower];
+        }
+
+        double frac = index - lower;
+        return sorted[lower] * (1 - frac) + sorted[upper] * frac;
+    }
+}

ClientTester/EchoClientTester/Utils/CrashDumpHandler.cs

@@ -0,0 +1,196 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+using Serilog;
+
+namespace ClientTester.Utils;
+
+/// <summary>
+/// 릴리즈 빌드 크래시 덤프 핸들러
+///
+/// Register() 를 Program.cs 최상단에서 한 번 호출.
+///
+/// 생성 파일 (crashes/ 폴더):
+///   Debug   : crash_YYYY-MM-DD_HH-mm-ss.log
+///   Release : crash_YYYY-MM-DD_HH-mm-ss.log
+///             crash_YYYY-MM-DD_HH-mm-ss.dmp  ← 메모리 덤프 추가
+/// </summary>
+public static class CrashDumpHandler
+{
+    private const string CRASH_DIR = "crashes";
+    private static int registered = 0;
+
+    public static void Register()
+    {
+        // 중복 등록 방지
+        if (Interlocked.Exchange(ref registered, 1) != 0)
+        {
+            return;
+        }
+
+        AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
+        TaskScheduler.UnobservedTaskException      += OnUnobservedTaskException;
+
+        Log.Information("[CrashDump] 핸들러 등록 완료 (CrashDir={Dir})", Path.GetFullPath(CRASH_DIR));
+    }
+
+    // ─── 핸들러 ──────────────────────────────────────────────────────────
+
+    private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
+    {
+        Exception? ex = e.ExceptionObject as Exception;
+        bool isTerminating = e.IsTerminating;
+
+        string tag = $"[CrashDump] UnhandledException (IsTerminating={isTerminating})";
+        WriteCrash(tag, ex);
+    }
+
+    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+    {
+        e.SetObserved(); // 프로세스 종료 방지
+
+        string tag = "[CrashDump] UnobservedTaskException";
+        WriteCrash(tag, e.Exception);
+    }
+
+    // ─── 핵심 처리 ───────────────────────────────────────────────────────
+
+    private static void WriteCrash(string tag, Exception? ex)
+    {
+        try
+        {
+            Directory.CreateDirectory(CRASH_DIR);
+
+            string timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
+            string basePath  = Path.Combine(CRASH_DIR, $"crash_{timestamp}");
+
+            // 1. 크래시 로그 작성
+            string logPath = $"{basePath}.log";
+            WriteCrashLog(logPath, ex);
+
+            Log.Fatal("{Tag} → {Log}", tag, logPath);
+
+#if !DEBUG
+            // 2. 메모리 덤프 작성 (Release only)
+            string dmpPath = $"{basePath}.dmp";
+            WriteDumpFile(dmpPath);
+            Log.Fatal("[CrashDump] 덤프 파일 저장 완료 → {Dmp}", dmpPath);
+#endif
+        }
+        catch (Exception writeEx)
+        {
+            // 덤프 저장 실패는 무시 (이미 크래시 중이므로)
+            Log.Error(writeEx, "[CrashDump] 덤프 저장 실패");
+        }
+        finally
+        {
+            Log.CloseAndFlush();
+        }
+    }
+
+    private static void WriteCrashLog(string path, Exception? ex)
+    {
+        StringBuilder sb = new();
+        sb.AppendLine("═══════════════════════════════════════════════════");
+        sb.AppendLine($"  CRASH REPORT  {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
+        sb.AppendLine("═══════════════════════════════════════════════════");
+        sb.AppendLine();
+
+        // 환경 정보
+        sb.AppendLine("[Environment]");
+        sb.AppendLine($"  OS       : {RuntimeInformation.OSDescription}");
+        sb.AppendLine($"  Runtime  : {RuntimeInformation.FrameworkDescription}");
+        sb.AppendLine($"  PID      : {Environment.ProcessId}");
+        sb.AppendLine($"  WorkDir  : {Environment.CurrentDirectory}");
+        sb.AppendLine($"  MachineName: {Environment.MachineName}");
+        sb.AppendLine();
+
+        // 스레드 정보
+        sb.AppendLine("[Thread]");
+        sb.AppendLine($"  ThreadId : {Environment.CurrentManagedThreadId}");
+        sb.AppendLine();
+
+        // 예외 정보
+        sb.AppendLine("[Exception]");
+        if (ex is null)
+        {
+            sb.AppendLine("  (예외 객체 없음)");
+        }
+        else
+        {
+            AppendException(sb, ex, depth: 0);
+        }
+
+        File.WriteAllText(path, sb.ToString(), Encoding.UTF8);
+    }
+
+    private static void AppendException(StringBuilder sb, Exception ex, int depth)
+    {
+        string indent = new string(' ', depth * 2);
+        sb.AppendLine($"{indent}  Type    : {ex.GetType().FullName}");
+        sb.AppendLine($"{indent}  Message : {ex.Message}");
+        sb.AppendLine($"{indent}  Source  : {ex.Source}");
+        sb.AppendLine();
+        sb.AppendLine($"{indent}  StackTrace:");
+
+        if (ex.StackTrace is not null)
+        {
+            foreach (string line in ex.StackTrace.Split('\n'))
+            {
+                sb.AppendLine($"{indent}    {line.TrimEnd()}");
+            }
+        }
+
+        if (ex is AggregateException agg)
+        {
+            foreach (Exception inner in agg.InnerExceptions)
+            {
+                sb.AppendLine();
+                sb.AppendLine($"{indent}  [InnerException]");
+                AppendException(sb, inner, depth + 1);
+            }
+        }
+        else if (ex.InnerException is not null)
+        {
+            sb.AppendLine();
+            sb.AppendLine($"{indent}  [InnerException]");
+            AppendException(sb, ex.InnerException, depth + 1);
+        }
+    }
+
+#if !DEBUG
+    // Windows MiniDumpWriteDump P/Invoke
+    [DllImport("dbghelp.dll", SetLastError = true)]
+    private static extern bool MiniDumpWriteDump(
+        IntPtr hProcess, uint processId, IntPtr hFile,
+        uint dumpType, IntPtr exceptionParam,
+        IntPtr userStreamParam, IntPtr callbackParam);
+
+    private const uint MiniDumpWithFullMemory = 0x00000002;
+
+    private static void WriteDumpFile(string path)
+    {
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            Log.Warning("[CrashDump] 덤프 생성은 Windows만 지원");
+            return;
+        }
+
+        using Process process = Process.GetCurrentProcess();
+        using FileStream fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
+
+        bool success = MiniDumpWriteDump(
+            process.Handle,
+            (uint)process.Id,
+            fs.SafeFileHandle.DangerousGetHandle(),
+            MiniDumpWithFullMemory,
+            IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
+
+        if (!success)
+        {
+            int err = Marshal.GetLastWin32Error();
+            Log.Error("[CrashDump] MiniDumpWriteDump 실패 (Win32 Error={Err})", err);
+        }
+    }
+#endif
+}

ClientTester/EchoClientTester/Vector3.cs

@@ -0,0 +1,8 @@
+namespace ClientTester;
+
+public class Vector3
+{
+    public float X { get; set; }
+    public float Y { get; set; }
+    public float Z { get; set; }
+}

ClientTester/EchoClientTester/appsettings.json

@@ -0,0 +1,6 @@
+{
+  "ServerIp": "localhost",
+  "ServerPort": 9500,
+  "ConnectionKey": "test",
+  "ClientCount": 80
+}

ClientTester/README.md

@@ -0,0 +1,304 @@
+# ClientTester - MMO 서버 테스트 도구
+
+MMO Game Server의 네트워크 성능 검증 및 부하 테스트를 위한 클라이언트 시뮬레이터.
+
+---
+
+## 1. 환경 (라이브러리)
+
+| 항목 | 버전 | 용도 |
+|------|------|------|
+| .NET | 9.0 | 런타임 |
+| LiteNetLib | 2.0.2 | UDP 네트워크 통신 (서버와 동일) |
+| protobuf-net | 3.2.56 | 패킷 직렬화/역직렬화 |
+| Serilog | 4.3.1 | 구조적 로깅 |
+| Serilog.Sinks.Console | 6.0.0 | 콘솔 출력 |
+| Serilog.Sinks.File | 7.0.0 | 파일 로깅 |
+| Microsoft.Diagnostics.NETCore.Client | 0.2.553101 | 크래시 힙 덤프 (Release만) |
+
+### 빌드
+
+```bash
+cd ClientTester/EchoClientTester
+dotnet build
+```
+
+---
+
+## 2. 디렉토리 구조
+
+```
+ClientTester/
+├── EchoClientTester/
+│   ├── Program.cs                          # 진입점 (대화형 + CLI)
+│   ├── EchoClientTester.csproj
+│   ├── Vector3.cs                          # 위치 구조체
+│   │
+│   ├── DummyService/                       # 이동 테스트
+│   │   ├── DummyClientService.cs           # 다중 더미 클라 관리
+│   │   ├── DummyClients.cs                 # 개별 더미 클라 (이동 시뮬)
+│   │   └── MapBounds.cs                    # 맵 경계 / 벽 충돌
+│   │
+│   ├── EchoDummyService/                   # Echo RTT 테스트
+│   │   ├── EchoDummyClientService.cs       # 다중 에코 클라 관리
+│   │   └── EchoDummyClients.cs             # 개별 에코 클라 (RTT 측정)
+│   │
+│   ├── StressTest/                         # 부하/스트레스 테스트
+│   │   ├── StressTestService.cs            # 오케스트레이터 (Ramp-up, 통계, CSV)
+│   │   └── StressTestClient.cs             # 통합 클라 (이동 + Echo 동시)
+│   │
+│   ├── Packet/                             # 패킷 정의 (서버와 동일 프로토콜)
+│   │   ├── PacketHeader.cs                 # PacketCode Enum
+│   │   ├── PacketBody.cs                   # Protobuf 패킷 클래스
+│   │   └── PacketSerializer.cs             # 직렬화 유틸
+│   │
+│   └── Utils/
+│       └── CrashDumpHandler.cs             # 크래시 로그 + 힙 덤프
+│
+└── TempServer/                             # 간이 에코 서버 (독립 테스트용)
+    └── Program.cs
+```
+
+---
+
+## 3. 사용방법
+
+### 3.1 대화형 모드
+
+```bash
+dotnet run
+```
+
+```
+========== 더미 클라 테스터 ==========
+1. 에코 서버
+2. 더미 클라(이동만)
+3. 스트레스 테스트 (부하)
+====================================
+1 / 2 / 3 :
+```
+
+| 모드 | 설명 |
+|------|------|
+| 1. 에코 서버 | Echo 패킷 송수신, RTT(Round-Trip Time) 측정 |
+| 2. 더미 클라 | 이동(Transform) 패킷 전송, 패킷 손실률 측정 |
+| 3. 스트레스 테스트 | Ramp-up + 이동 + Echo 동시, 퍼센타일 레이턴시, CSV 내보내기 |
+
+### 3.2 CLI 모드 (스트레스 테스트)
+
+```bash
+# 기본 실행 (50명, 60초)
+dotnet run -- stress
+
+# 100명 클라이언트, 120초 테스트
+dotnet run -- stress -c 100 -d 120
+
+# 원격 서버 대상, 커스텀 설정
+dotnet run -- stress -c 200 -d 60 -r 500 -b 20 --ip 192.168.0.10 --port 9500
+
+# 도움말
+dotnet run -- --help
+```
+
+#### CLI 옵션
+
+| 옵션 | 축약 | 기본값 | 설명 |
+|------|------|--------|------|
+| `--clients` | `-c` | 50 | 총 클라이언트 수 |
+| `--duration` | `-d` | 60 | 테스트 지속 시간 (초, 0=무제한) |
+| `--interval` | `-i` | 100 | 패킷 전송 주기 (ms) |
+| `--ramp` | `-r` | 1000 | Ramp-up 간격 (ms) |
+| `--batch` | `-b` | 10 | Ramp-up 당 추가 클라이언트 수 |
+| `--ip` | | localhost | 서버 IP 주소 |
+| `--port` | | 9500 | 서버 포트 |
+
+### 3.3 출력 파일
+
+| 경로 | 내용 |
+|------|------|
+| `logs2/log_{timestamp}.txt` | 전체 실행 로그 |
+| `results/stress_{N}clients_{timestamp}.csv` | 스트레스 테스트 결과 (클라이언트별 통계) |
+| `crashes/crash_{timestamp}.log` | 크래시 스택 트레이스 |
+| `crashes/crash_{timestamp}.dmp` | 힙 덤프 (Release 빌드만) |
+
+---
+
+## 4. 파이프라인
+
+### 4.1 에코 테스트 (모드 1)
+
+```
+[클라이언트 N개 동시 생성]
+        ↓
+[연결] UDP Connect → ServerBase.OnConnectionRequest()
+        ↓
+[PollLoop]  10ms 주기로 네트워크 이벤트 처리
+[SendLoop]  100ms 주기로 Echo 패킷 전송
+        ↓
+[송신] EchoPacket { Str = "Echo seq:{N}" }
+       → PacketSerializer.Serialize()
+       → 4바이트 헤더(type + size) + Protobuf 페이로드
+       → DeliveryMethod.ReliableUnordered
+        ↓
+[수신] 서버가 Echo 패킷 그대로 반환
+       → seq 번호로 pendingPings 조회
+       → RTT 계산: (수신시각 - 송신시각) / Stopwatch.Frequency
+        ↓
+[통계] 클라이언트별: AvgRTT, LastRTT, Sent, Recv, PacketLoss%
+       전체: 총 Sent/Recv, 평균 RTT
+```
+
+### 4.2 이동 테스트 (모드 2)
+
+```
+[클라이언트 N개 동시 생성]
+        ↓
+[연결 + 인증]
+       DummyAccTokenPacket { Token = clientId }
+       → DeliveryMethod.ReliableOrdered
+        ↓
+[이동 시뮬레이션 - UpdateDummy()]
+       ┌────────────────────────────────────────┐
+       │ 1. 델타 타임 계산 (Stopwatch)            │
+       │ 2. 남은 거리 = 0 이면:                    │
+       │    - 벽 근처? → 반대 방향 회전              │
+       │    - 아니면 → 현재 방향 ±30도 랜덤 회전      │
+       │    - 목표 거리 = moveSpeed × (3~12초)      │
+       │ 3. 이번 틱 이동 (moveSpeed × delta)       │
+       │ 4. MapBounds.Clamp() → 벽 충돌 처리        │
+       └────────────────────────────────────────┘
+        ↓
+[송신] TransformPlayerPacket { PlayerId, Position(X,0,Z), RotY }
+       → DeliveryMethod.Unreliable (손실 감수)
+        ↓
+[통계] 클라이언트별: Sent, Recv, PacketLoss%
+```
+
+### 4.3 스트레스 테스트 (모드 3 / CLI)
+
+```
+[설정 입력] CLI 인자 또는 대화형 입력
+        ↓
+[Ramp-up Loop]
+       ┌────────────────────────────────────┐
+       │ rampInterval(1000ms)마다             │
+       │ clientsPerRamp(10)명씩 클라이언트 생성  │
+       │ → totalClients 도달 시 중단            │
+       └────────────────────────────────────┘
+        ↓ (병렬 실행)
+[PollLoop]   10ms 주기 네트워크 이벤트
+[SendLoop]   sendInterval(100ms) 주기
+             ├─ UpdateAndSendTransform() (이동 - Unreliable)
+             └─ SendPing()              (Echo - ReliableUnordered)
+[StatsLoop]  10초마다 실시간 통계 출력
+        ↓
+[지속시간 만료 또는 Ctrl+C]
+        ↓
+[최종 리포트]
+       ├─ 처리량: 총 Sent/Recv, 패킷/초
+       ├─ 레이턴시: Min, Avg, P50, P95, P99, Max
+       ├─ 최악 RTT 상위 5 클라이언트 상세
+       └─ CSV 파일 자동 저장
+```
+
+### 4.4 패킷 직렬화 파이프라인
+
+```
+객체 (e.g. TransformPlayerPacket)
+        ↓
+protobuf-net Serialize → byte[] payload
+        ↓
+PacketSerializer.Serialize()
+        ↓
+┌──────────────────────────────┐
+│ [2B type] [2B size] [payload] │
+│  ushort    ushort    byte[]   │
+└──────────────────────────────┘
+        ↓
+NetDataWriter.Put(data)
+        ↓
+peer.Send(writer, DeliveryMethod)
+```
+
+---
+
+## 5. 테스트 모드별 기능 비교
+
+| 기능 | 에코 (1) | 이동 (2) | 스트레스 (3) |
+|------|:--------:|:--------:|:------------:|
+| 동시접속 클라이언트 | 10 (고정) | 10 (고정) | N (설정 가능) |
+| 인증 패킷 전송 | X | O | O |
+| 이동 시뮬레이션 | X | O | O |
+| Echo RTT 측정 | O | X | O |
+| 패킷 손실 추적 | O | O | O |
+| 점진적 Ramp-up | X | X | O |
+| 지속시간 제한 | 무제한 | 무제한 | 설정 가능 |
+| 실시간 통계 | X | X | O (10초 주기) |
+| 퍼센타일 레이턴시 | X (평균만) | X | O (P50/P95/P99) |
+| CSV 내보내기 | X | X | O |
+| CLI 인자 | X | X | O |
+| 최악 클라이언트 분석 | X | X | O (상위 5) |
+
+---
+
+## 6. 구현 진행도
+
+### 완료
+
+| 항목 | 상태 | 설명 |
+|------|:----:|------|
+| Echo RTT 측정 | **완료** | seq 기반 ping/pong, Stopwatch 고정밀 타이머 |
+| 더미 이동 시뮬레이션 | **완료** | 벽 충돌, 랜덤 방향 전환, 델타 타임 기반 이동 |
+| 맵 경계 처리 | **완료** | MapBounds (Clamp, 벽 반대 방향 계산) |
+| 패킷 손실 추적 | **완료** | LiteNetLib.NetStatistics 활용 |
+| 크래시 덤프 | **완료** | Debug: .log / Release: .log + .dmp |
+| 로깅 (콘솔+파일) | **완료** | Serilog 타임스탬프별 로그 파일 |
+| Graceful Shutdown | **완료** | Ctrl+C → CancellationToken → 통계 출력 후 종료 |
+| 스트레스 테스트 | **완료** | Ramp-up, 퍼센타일, CSV, CLI 인자 |
+| CLI 인자 지원 | **완료** | `stress -c N -d T --ip --port` |
+
+### 미구현 / 향후 작업
+
+| 항목 | 상태 | 설명 |
+|------|:----:|------|
+| 채널 입장 시뮬레이션 | 미구현 | INTO_CHANNEL 패킷 전송 후 게임 루프 진입 |
+| 전투 액션 시뮬레이션 | 미구현 | ACTION_PLAYER (공격/스킬) 패킷 전송 |
+| 상태 변경 시뮬레이션 | 미구현 | STATE_PLAYER (HP/MP) 패킷 전송 |
+| JWT 토큰 인증 테스트 | 미구현 | ACC_TOKEN 방식 인증 플로우 검증 |
+| 서버 응답 검증 | 미구현 | 수신 패킷 내용 파싱 및 정합성 체크 |
+| 테스트 시나리오 스크립트 | 미구현 | JSON/YAML 기반 테스트 시나리오 정의 |
+| 그래프 출력 | 미구현 | RTT/처리량 시계열 차트 생성 |
+
+---
+
+## 7. 설정 참고
+
+### 서버 연결 기본값
+
+| 항목 | 값 |
+|------|-----|
+| IP | `localhost` |
+| Port | `9500` |
+| Connection Key | `test` |
+
+### 이동 시뮬레이션 파라미터
+
+| 항목 | 값 | 설명 |
+|------|-----|------|
+| moveSpeed | 3.5 | 이동 속도 (units/sec) |
+| 맵 범위 | -50 ~ 50 (X, Z) | 100x100 영역 |
+| 벽 감지 마진 | 0.5 | 벽 근처 판정 거리 |
+| 목표 거리 | moveSpeed x 3~12초 | 직진 후 방향 전환 |
+| 방향 전환 | 현재 ±30도 랜덤 | 벽 근처 시 반대 방향 강제 |
+
+### 스트레스 테스트 기본값
+
+| 항목 | 값 | 설명 |
+|------|-----|------|
+| 클라이언트 수 | 50 | `-c` 옵션 |
+| 지속 시간 | 60초 | `-d` 옵션 |
+| 전송 주기 | 100ms | `-i` 옵션 |
+| Ramp-up 간격 | 1000ms | `-r` 옵션 |
+| Ramp-up 배치 | 10명 | `-b` 옵션 |
+| 실시간 통계 주기 | 10초 | 고정 |
+| Echo 최대 pending | 500 | 메모리 누수 방지 |

MMORPG_ARCHITECTURE_ANALYSIS.md

@@ -1,424 +0,0 @@
-# MMORPG 아키텍처 적합성 분석 보고서
-
-## 1. 분석 목적
-
-현재 서버 구조가 **다수의 플레이어가 동시 접속하여 실시간으로 상호작용하는 MMORPG**에 적합한지 평가하고, 부족한 부분과 개선 방향을 제시한다.
-
----
-
-## 2. MMORPG 서버의 핵심 요구사항
-
-| 요구사항 | 설명 |
-|----------|------|
-| 대규모 동시접속 (CCU) | 수백~수천 명이 같은 월드에서 실시간 플레이 |
-| 저지연 패킷 처리 | 위치/액션 동기화는 50ms 이내 응답 필요 |
-| 관심 영역 관리 (AOI) | 내 주변 플레이어만 패킷을 주고받아야 대역폭 절약 |
-| 게임 루프 (Tick) | 고정 주기(예: 20~60Hz)로 월드 상태를 업데이트 |
-| 존/채널 분리 | 지역별 부하 분산 및 인스턴스 관리 |
-| 엔티티 관리 | 플레이어, NPC, 몬스터 등의 상태를 중앙에서 관리 |
-| 서버 간 통신 | 로그인/로비/게임/채팅 등 역할별 서버 분리 |
-| 장애 복구 | 서버 크래시 시 세션 복구, 데이터 무결성 보장 |
-
----
-
-## 3. 현재 구조 평가
-
-### 3.1 네트워크 계층
-
-**현재 구조:**
-```
-단일 ServerBase → 단일 NetManager → 단일 스레드 PollEvents()
-```
-
-| 항목 | 현재 상태 | MMORPG 요구 | 평가 |
-|------|-----------|-------------|------|
-| 프로토콜 | UDP (LiteNetLib) | UDP 기반 필수 | **적합** |
-| 직렬화 | ProtoBuf | 고성능 바이너리 직렬화 | **적합** |
-| 폴링 모델 | 단일 스레드 `while + Task.Delay(1)` | 멀티스레드 or 고성능 이벤트 루프 | **부적합** |
-| 패킷 라우팅 | type 기반 if 분기 | 핸들러 매핑 테이블 + 디스패처 | **부적합** |
-
-**문제점:**
-
-- **단일 스레드 병목**: `PollEvents()`가 단일 스레드에서 모든 패킷을 처리한다. CCU 500 이상에서 패킷 큐가 쌓이면 처리 지연이 발생한다. MMORPG에서 플레이어 100명이 초당 10패킷을 보내면 초당 1,000패킷인데, `HandlePacket` 내부에서 DB 조회 같은 블로킹 작업이 끼면 전체 루프가 멈춘다.
-
-- **패킷 디스패처 없음**: `HandlePacket(peer, hashKey, type, payload)` 하나로 모든 게임 패킷을 처리해야 한다. 패킷 종류가 17개인 현재도 거대한 switch문이 필요하며, 패킷이 늘어날수록 유지보수가 어려워진다.
-
-- **`Task.Delay(1)` 해상도**: Windows에서 실제로 ~15ms 간격으로 폴링된다. 60Hz 게임 루프가 필요한 MMORPG에서는 16.6ms마다 정확한 틱이 필요한데, 현재 구조로는 불가능하다.
-
----
-
-### 3.2 세션 관리
-
-**현재 구조:**
-```
-Dictionary<long, NetPeer> sessions  (hashKey → peer)
-Dictionary<int, NetPeer> pendingPeers  (peerId → peer)
-```
-
-| 항목 | 현재 상태 | MMORPG 요구 | 평가 |
-|------|-----------|-------------|------|
-| 자료구조 | 일반 Dictionary | ConcurrentDictionary 또는 락 기반 | **위험** |
-| 인증 | 8byte hashKey raw 전송 | JWT/OAuth + 토큰 갱신 | **부적합** |
-| 세션 정보 | hashKey + NetPeer만 | 플레이어 ID, 존, 위치, 상태 등 | **부족** |
-| 재연결 | hashKey 기반 피어 교체 | 세션 상태 전체 복구 | **부분 구현** |
-
-**문제점:**
-
-- **인증 보안 취약**: 8바이트 hashKey를 평문으로 보내면, 패킷 스니핑으로 다른 사람의 세션을 탈취할 수 있다. MMORPG는 JWT 같은 시간 제한 토큰 + 서버 측 검증이 필수다.
-
-- **세션에 게임 상태 없음**: `Session` 클래스에 `HashKey`와 `Peer`만 있다. MMORPG에서는 세션이 플레이어의 현재 존, 위치, 파티, 인벤토리 캐시 등을 들고 있어야 패킷 처리 시 매번 DB를 조회하지 않는다.
-
-- **재연결 시 상태 미복구**: WiFi→LTE 전환 시 피어만 교체하고 게임 상태(존, 위치, 버프 등)를 클라이언트에 재전송하는 로직이 없다.
-
----
-
-### 3.3 게임 루프 & 월드 관리
-
-**현재 구조:**
-```
-없음. GameServer 클래스는 빈 껍데기.
-```
-
-| 항목 | 현재 상태 | MMORPG 요구 | 평가 |
-|------|-----------|-------------|------|
-| 게임 루프 | 없음 | 고정 틱 (20~60Hz) | **미구현** |
-| 존/맵 관리 | 없음 | Zone/Channel/Instance 분리 | **미구현** |
-| AOI (관심 영역) | 없음 | Grid/Quadtree 기반 영역 관리 | **미구현** |
-| 엔티티 시스템 | 없음 | Player/NPC/Monster 상태 관리 | **미구현** |
-| 물리/충돌 | 없음 | 서버 권위 이동 검증 | **미구현** |
-
-**문제점:**
-
-이것이 가장 큰 갭이다. MMORPG 서버의 핵심인 **게임 루프**가 존재하지 않는다.
-
-- **게임 루프 없음**: 현재는 "클라이언트가 패킷을 보내면 서버가 반응"하는 순수 리액티브 구조다. MMORPG는 클라이언트 입력이 없어도 서버가 자체적으로 NPC AI, 몬스터 이동, 버프 타이머, 리스폰 등을 주기적으로 처리해야 한다.
-
-- **AOI 없음**: 현재 `Broadcast()`는 **모든 접속자**에게 패킷을 보낸다. 플레이어 100명이 모두 움직이면 초당 `100 × 100 = 10,000`패킷이 발생한다. 1,000명이면 `1,000,000`패킷이다. AOI 없이는 CCU 50만 넘어도 대역폭이 폭발한다.
-
-- **존/채널 없음**: 모든 플레이어가 하나의 `sessions` Dictionary에 평면적으로 존재한다. "마을에 있는 플레이어"와 "던전에 있는 플레이어"를 구분할 방법이 없다.
-
----
-
-### 3.4 데이터베이스 계층
-
-**현재 구조:**
-```
-Handler → Service → Repository(Dapper) → MySQL
-매 요청마다 새 커넥션 (풀링은 MySQL 드라이버에 위임)
-```
-
-| 항목 | 현재 상태 | MMORPG 요구 | 평가 |
-|------|-----------|-------------|------|
-| ORM | Dapper (경량) | 경량 ORM 적합 | **적합** |
-| 커넥션 풀링 | MySQL 드라이버 위임 | 명시적 풀 관리 | **보통** |
-| 캐싱 | 없음 | Redis/인메모리 캐시 필수 | **부적합** |
-| 비동기 | async/await | 논블로킹 필수 | **적합** |
-
-**문제점:**
-
-- **캐시 계층 없음**: 플레이어가 스킬을 쓸 때마다 DB에서 스탯을 읽으면 게임이 안 된다. MMORPG는 로그인 시 플레이어 데이터를 메모리에 올리고, 주기적으로 DB에 저장(Write-Back)하는 구조가 필수다.
-
-- **게임 루프에서 DB 호출 위험**: 현재는 패킷 핸들러에서 직접 DB를 호출하는 구조인데, 게임 루프 스레드에서 DB await를 하면 틱 지연이 발생한다. 게임 로직과 DB I/O는 반드시 분리해야 한다.
-
----
-
-### 3.5 서버 구조 (스케일링)
-
-**현재 구조:**
-```
-단일 프로세스, 단일 서버
-```
-
-| 항목 | 현재 상태 | MMORPG 요구 | 평가 |
-|------|-----------|-------------|------|
-| 서버 분리 | 모놀리식 단일 서버 | 로그인/로비/게임/채팅 분리 | **부적합** |
-| 수평 확장 | 불가 | 존별 서버 분산 | **부적합** |
-| 메시지 큐 | 없음 | Redis Pub/Sub, RabbitMQ 등 | **미구현** |
-| 로드밸런싱 | 없음 | 게이트웨이 + 존 서버 라우팅 | **미구현** |
-
-**문제점:**
-
-- **단일 서버 한계**: 하나의 `ServerBase` 인스턴스가 인증, 에코, 게임 패킷을 모두 처리한다. CCU가 늘어나면 서버를 추가할 방법이 없다.
-
-- **서버 간 통신 없음**: "A 서버의 플레이어가 B 서버의 플레이어에게 귓속말"이 불가능하다. 파티, 길드, 거래 등 크로스 존 기능을 구현할 수 없다.
-
----
-
-## 4. 종합 평가
-
-### 적합성 점수
-
-| 영역 | 점수 (10점) | 비고 |
-|------|:-----------:|------|
-| 네트워크 프로토콜 | 8 | UDP + ProtoBuf 조합 우수 |
-| 패킷 처리 파이프라인 | 3 | 단일 스레드, 디스패처 없음 |
-| 세션 / 인증 | 3 | 보안 취약, 게임 상태 없음 |
-| 게임 루프 | 0 | 미구현 |
-| 월드 / 존 관리 | 0 | 미구현 |
-| AOI (관심 영역) | 0 | 미구현 |
-| 엔티티 시스템 | 0 | 미구현 |
-| DB / 캐시 | 4 | Dapper 좋으나 캐시 없음 |
-| 서버 확장성 | 1 | 단일 프로세스 모놀리식 |
-| **종합** | **2.1 / 10** | |
-
-### 결론
-
-> 현재 구조는 **에코 서버 / 소규모 매칭 게임 (10~20명)** 수준에 적합하며,
-> **MMORPG로 사용하기에는 핵심 시스템 대부분이 미구현** 상태이다.
->
-> 네트워크 기반(LiteNetLib + ProtoBuf)과 DB 레이어(Dapper + Repository 패턴)는
-> 좋은 출발점이지만, 그 위에 올라가야 할 게임 서버 계층이 빠져 있다.
-
----
-
-## 5. MMORPG 전환을 위한 로드맵
-
-### Phase 1: 게임 루프 & 엔티티 시스템 (최우선)
-
-```
-현재:  클라이언트 패킷 → ServerBase → GameServer(빈 껍데기)
-목표:  클라이언트 패킷 → 입력 큐 → GameLoop(고정 틱) → 월드 상태 업데이트 → 브로드캐스트
-```
-
-**구현 항목:**
-
-1. **고정 틱 게임 루프**
-   - `Stopwatch` 기반 정밀 타이머로 50ms(20Hz) 또는 33ms(30Hz) 간격 틱
-   - 패킷 수신은 입력 큐에 적재, 게임 루프에서 꺼내서 처리
-   - 네트워크 I/O와 게임 로직 스레드 분리
-
-2. **엔티티 관리자**
-   - `GamePlayer`, `GameNpc`, `GameMonster` 등 인게임 엔티티 클래스
-   - 위치, 상태, 스탯을 서버 메모리에서 관리
-   - 로그인 시 DB → 메모리 로드, 주기적으로 메모리 → DB 저장
-
-3. **패킷 디스패처**
-   - `Dictionary<ushort, Action<NetPeer, long, byte[]>>` 핸들러 매핑 테이블
-   - 패킷 타입별 핸들러 자동 등록 (어트리뷰트 또는 초기화 시 등록)
-
-```
-예시 구조:
-GameLoop
-├── ProcessInputQueue()     // 클라이언트 패킷 처리
-├── UpdateNpcAI()           // NPC 행동 업데이트
-├── UpdateBuffTimers()      // 버프/디버프 타이머
-├── UpdateRespawns()        // 몬스터 리스폰
-├── BroadcastWorldState()   // 변경된 상태만 클라이언트에 전송
-└── SaveDirtyEntities()     // 변경된 엔티티 DB 저장 (N틱마다)
-```
-
-### Phase 2: 존/채널 & AOI
-
-**구현 항목:**
-
-1. **존 시스템**
-   - `Zone` 클래스: 해당 존의 플레이어/NPC/몬스터 목록 관리
-   - 존 진입/퇴장 시 엔티티 이동
-   - 인스턴스 던전은 동적 Zone 생성/파괴
-
-2. **AOI (Area of Interest)**
-   - 그리드 기반 관심 영역: 맵을 NxN 셀로 나누고, 플레이어가 속한 셀 + 인접 셀만 패킷 전송
-   - `Broadcast()` → `BroadcastToNearby(position, radius, data)`로 교체
-   - CCU 1,000명 기준 패킷 수: 1,000,000 → ~50,000 (95% 감소)
-
-```
-예시:
-┌───┬───┬───┐
-│   │ B │   │  B는 A의 AOI 범위 안 → 패킷 수신
-├───┼───┼───┤
-│   │ A │   │  A가 이동 패킷 발신
-├───┼───┼───┤
-│   │   │ C │  C는 AOI 범위 밖 → 패킷 안 받음
-└───┴───┴───┘
-```
-
-### Phase 3: 인증 강화 & 세션 확장
-
-**구현 항목:**
-
-1. **JWT 기반 인증**
-   - 로그인 서버에서 JWT 발급 → 게임 서버에서 검증
-   - hashKey 대신 토큰 기반 인증, 만료/갱신 처리
-
-2. **세션 확장**
-   ```csharp
-   public class GameSession
-   {
-       public long AccountId { get; init; }
-       public NetPeer Peer { get; set; }
-       public GamePlayer? Player { get; set; }    // 인게임 엔티티 참조
-       public Zone? CurrentZone { get; set; }      // 현재 존
-       public DateTime LastActivity { get; set; }  // AFK 감지
-   }
-   ```
-
-3. **재연결 상태 복구**: 재연결 시 현재 존, 위치, 파티 상태를 클라이언트에 재전송
-
-### Phase 4: 캐시 & DB 최적화
-
-**구현 항목:**
-
-1. **인메모리 캐시 도입**
-   - 접속 중인 플레이어 데이터는 메모리에 상주
-   - Write-Back 패턴: 변경 사항을 큐에 쌓고 N초마다 일괄 DB 저장
-   - 아이템/스킬 테이블 등 정적 데이터는 서버 시작 시 로드
-
-2. **DB I/O 분리**
-   - 게임 루프 스레드에서 직접 DB 호출 금지
-   - 별도 DB Worker 스레드에서 저장 큐 처리
-   - 긴급 저장(거래, 결제)만 즉시 처리
-
-### Phase 5: 서버 분산 아키텍처
-
-**구현 항목:**
-
-1. **서버 역할 분리**
-   ```
-   클라이언트
-      ↓
-   게이트웨이 서버 (인증 + 라우팅)
-      ├── 로비 서버 (매칭, 파티, 채팅)
-      ├── 게임 서버 A (마을 존)
-      ├── 게임 서버 B (필드 존)
-      ├── 게임 서버 C (던전 인스턴스)
-      └── DB/캐시 서버 (Redis + MySQL)
-   ```
-
-2. **서버 간 메시지 큐**
-   - Redis Pub/Sub 또는 RabbitMQ로 서버 간 통신
-   - 크로스 존 기능: 귓속말, 길드, 파티 초대, 거래
-
-3. **수평 확장**
-   - 존 단위로 게임 서버 인스턴스 추가
-   - 게이트웨이가 플레이어를 적절한 존 서버로 라우팅
-
----
-
-## 6. 현재 코드에서 재사용 가능한 부분
-
-현재 코드가 완전히 쓸모없는 것은 아니다. 아래 부분은 그대로 또는 약간의 수정으로 재사용 가능하다.
-
-| 컴포넌트 | 재사용성 | 비고 |
-|----------|:--------:|------|
-| LiteNetLib 기반 네트워크 | **높음** | UDP 전송 계층으로 그대로 사용 |
-| ProtoBuf 패킷 정의 | **높음** | PacketBody.cs의 17개 패킷 구조 재사용 |
-| PacketSerializer | **높음** | 직렬화/역직렬화 로직 그대로 사용 |
-| ARepository + Dapper | **높음** | DB 계층 그대로 사용 |
-| ServerBase 인증 흐름 | **보통** | JWT로 교체하되 pending → auth 흐름은 유지 |
-| Session/재연결 로직 | **보통** | 확장 후 재사용 |
-| Docker/compose 설정 | **높음** | 배포 파이프라인 그대로 사용 |
-
----
-
-## 7. 권장 우선순위 요약
-
-```
-[즉시] Phase 1: 게임 루프 + 엔티티 시스템 + 패킷 디스패처
-         → 이것 없이는 어떤 게임 로직도 구현 불가
-
-[단기] Phase 2: 존/채널 + AOI
-         → CCU 50명만 넘어도 Broadcast 폭발
-
-[중기] Phase 3: 인증 강화 + 세션 확장
-         → 보안과 재연결 안정성
-
-[중기] Phase 4: 캐시 + DB 분리
-         → 성능 병목 해소
-
-[장기] Phase 5: 서버 분산
-         → CCU 1,000+ 대응
-```
-
----
-
-## 8. 현재 수용 가능 인원 추정
-
-### 처리 성능 (단일 스레드 기준)
-
-```
-PollEvents() 틱 간격: ~15ms (Task.Delay(1) Windows 해상도)
-초당 틱 수: ~66회
-틱당 처리 가능 시간: 15ms
-```
-
-| 시나리오 | 패킷 1개 처리 시간 | 유저당 초당 패킷 | 예상 CCU |
-|----------|-------------------|-----------------|----------|
-| 에코 테스트 (현재) | ~0.01ms | 10 | **~1,000명** |
-| 간단한 게임 로직 | ~0.1ms | 10 | **~500명** |
-| 실제 MMORPG 로직 | ~1ms | 10 | **~50명** |
-| DB 호출 포함 | ~5ms | 10 | **~10명** |
-
-> HandlePacket 안에 뭘 넣느냐가 전부다.
-> 지금 빈 껍데기라서 수백 명이 되는 거지, 로직이 들어가는 순간 급락한다.
-
-### 개선 시 수용 인원 (단일 서버)
-
-| 개선 단계 | 핵심 변경 | 예상 CCU |
-|-----------|-----------|----------|
-| **현재** | 단일 스레드, 동기 처리 | 30~50명 |
-| **Phase 1** | 게임 루프 + 입력 큐 분리 | **200~500명** |
-| **Phase 1 + 2** | + AOI 적용 | **1,000~2,000명** |
-| **Phase 1~4** | + 캐시 + DB 분리 | **3,000~5,000명** |
-| **Phase 5** | 멀티 서버 분산 | **서버당 5,000 × N대** |
-
-### 개선별 효과 설명
-
-**Phase 1 (게임 루프)** - 4~10배 향상
-```
-현재:  패킷 100개 → 하나씩 순차 처리 (100번 컨텍스트 스위칭)
-개선:  패킷 100개 → 큐에 모아서 → 틱 1번에 일괄 처리 (배치)
-```
-
-**Phase 2 (AOI)** - 가장 극적인 효과
-```
-현재:  유저 1,000명 이동 → 브로드캐스트 1,000 × 1,000 = 1,000,000 패킷/틱
-개선:  유저 1,000명 이동 → AOI 반경 내 ~20명에게만 = 20,000 패킷/틱 (98% 감소)
-```
-
-> AOI가 가장 임팩트가 크다. 네트워크 부하가 O(N²) → O(N)으로 바뀐다.
-
----
-
-## 9. 하드웨어 & 네트워크 요구사항
-
-### M4 Mac Mini 깡통 (16GB RAM) 기준
-
-| 리소스 | M4 Mac Mini | 서버 필요량 (CCU 3,000) | 여유 |
-|--------|-------------|------------------------|------|
-| CPU | 10코어 (4P+6E) | 게임 루프 1~2코어 + 네트워크 1코어 | **충분** |
-| RAM | 16GB | 유저당 ~10KB × 3,000 = 30MB + 앱 ~500MB | **매우 충분** |
-| 디스크 | 256GB SSD | MySQL + 로그 | **충분** |
-
-> M4 싱글코어 성능이 서버용 Xeon보다 빠르다.
-> 게임 루프는 본질적으로 싱글스레드 위주라서 M4로 CCU 3,000~5,000 처리 가능.
-
-### 네트워크 대역폭 계산 (AOI 적용 후)
-
-```
-유저 1명이 받는 패킷:
-- 주변 플레이어 이동: ~20명 × 30Hz × 50byte = 30KB/s
-- NPC/몬스터 상태:    ~10개 × 10Hz × 40byte =  4KB/s
-- 기타 (채팅, 파티):                          =  1KB/s
-──────────────────────────────────────────────────────
-유저 1명 ≈ 35KB/s (다운) + 5KB/s (업) = 40KB/s
-```
-
-| CCU | 필요 대역폭 | 필요 회선 |
-|-----|-------------|-----------|
-| 100명 | 4MB/s (32Mbps) | 100Mbps 충분 |
-| 500명 | 20MB/s (160Mbps) | 1Gbps 필요 |
-| 1,000명 | 40MB/s (320Mbps) | 1Gbps 필요 |
-| 3,000명 | 120MB/s (960Mbps) | 1Gbps 빡빡 |
-| 5,000명 | 200MB/s (1.6Gbps) | 2.5Gbps 이상 |
-
-### 환경별 결론
-
-| 환경 | 병목 | 현실적 CCU |
-|------|------|-----------|
-| M4 Mac Mini + 가정용 기가 인터넷 | 업로드 속도, NAT 테이블 | **100~500명** |
-| M4 Mac Mini + IDC/클라우드 1Gbps 보장 | 대역폭 | **2,000~3,000명** |
-| 클라우드 서버 + 2.5Gbps 이상 | CPU | **3,000~5,000명** |
-
-> **병목은 Mac Mini 성능이 아니라 네트워크다.**
-> CPU/RAM은 남아돌지만, 가정용 인터넷은 업로드 제한(보통 다운의 1/10)과
-> 공유기 NAT 테이블 한계가 있다.

MMOTestServer/MMOserver/Api/BossRaidResult.cs

@@ -0,0 +1,13 @@
+namespace MMOserver.Api;
+
+// RestApi.BossRaidAccesssAsync 반환용 도메인 모델
+// API 응답(BossRaidAccessResponse)을 직접 노출하지 않고 이걸로 매핑해서 반환
+public sealed class BossRaidResult
+{
+    public int RoomId { get; init; }
+    public string SessionName { get; init; } = string.Empty;
+    public int BossId { get; init; }
+    public List<string> Players { get; init; } = new();
+    public string Status { get; init; } = string.Empty;
+    public Dictionary<string, string>? Tokens { get; init; }
+}

MMOTestServer/MMOserver/Api/RestApi.cs

@@ -0,0 +1,239 @@
+using System.Net;
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using MMOserver.Config;
+using MMOserver.Utils;
+using Serilog;
+
+namespace MMOserver.Api;
+
+public class RestApi : Singleton<RestApi>
+{
+    private readonly HttpClient httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(5) };
+
+    private const int MAX_RETRY = 3;
+    private static readonly TimeSpan RETRY_DELAY = TimeSpan.FromSeconds(1);
+
+    public RestApi()
+    {
+        httpClient.DefaultRequestHeaders.Add("X-API-Key", AppConfig.RestApi.ApiKey);
+    }
+
+    // 토큰 검증 - 성공 시 username 반환
+    // 401 → 재시도 없이 즉시 null 반환 (토큰 자체가 무효)
+    // 타임아웃/네트워크 오류 → 최대 MAX_RETRY회 재시도 후 null 반환
+    public async Task<string?> VerifyTokenAsync(string token)
+    {
+        string url = AppConfig.RestApi.BaseUrl + AppConfig.RestApi.VerifyToken;
+        for (int attempt = 1; attempt <= MAX_RETRY; attempt++)
+        {
+            try
+            {
+                HttpResponseMessage response = await httpClient.PostAsJsonAsync(url, new { token });
+
+                // 401: 토큰 자체가 무효 → 재시도해도 같은 결과, 즉시 반환
+                if (response.StatusCode == HttpStatusCode.Unauthorized)
+                {
+                    Log.Warning("[RestApi] 토큰 인증 실패 (401)");
+                    return null;
+                }
+
+                response.EnsureSuccessStatusCode();
+
+                AuthVerifyResponse? result = await response.Content.ReadFromJsonAsync<AuthVerifyResponse>();
+                return result?.Username;
+            }
+            catch (Exception ex) when (attempt < MAX_RETRY)
+            {
+                // 일시적 장애 (타임아웃, 네트워크 오류 등) → 재시도
+                Log.Warning("[RestApi] 통신 실패 (시도 {Attempt}/{Max}): {Message}", attempt, MAX_RETRY, ex.Message);
+                await Task.Delay(RETRY_DELAY);
+            }
+            catch (Exception ex)
+            {
+                // 마지막 시도까지 실패
+                Log.Error("[RestApi] 최종 통신 실패 ({Max}회 시도): {Message}", MAX_RETRY, ex.Message);
+            }
+        }
+
+        return null;
+    }
+
+    // 플레이어 프로필 조회 - 성공 시 PlayerProfileResponse 반환
+    public async Task<PlayerProfileResponse?> GetPlayerProfileAsync(string username)
+    {
+        string url = AppConfig.RestApi.BaseUrl + "/api/internal/player/profile?username=" + Uri.EscapeDataString(username);
+        for (int attempt = 1; attempt <= MAX_RETRY; attempt++)
+        {
+            try
+            {
+                HttpResponseMessage response = await httpClient.GetAsync(url);
+                if (response.StatusCode == HttpStatusCode.NotFound)
+                {
+                    Log.Warning("[RestApi] 프로필 없음 username={Username}", username);
+                    return null;
+                }
+
+                response.EnsureSuccessStatusCode();
+                return await response.Content.ReadFromJsonAsync<PlayerProfileResponse>();
+            }
+            catch (Exception ex) when (attempt < MAX_RETRY)
+            {
+                Log.Warning("[RestApi] 프로필 조회 실패 (시도 {Attempt}/{Max}): {Message}", attempt, MAX_RETRY, ex.Message);
+                await Task.Delay(RETRY_DELAY);
+            }
+            catch (Exception ex)
+            {
+                Log.Error("[RestApi] 프로필 조회 최종 실패 ({Max}회 시도): {Message}", MAX_RETRY, ex.Message);
+            }
+        }
+
+        return null;
+    }
+
+    private sealed class AuthVerifyResponse
+    {
+        [JsonPropertyName("username")]
+        public string? Username
+        {
+            get;
+            set;
+        }
+    }
+
+    public sealed class PlayerProfileResponse
+    {
+        [JsonPropertyName("nickname")]
+        public string Nickname { get; set; } = string.Empty;
+
+        [JsonPropertyName("level")]
+        public int Level { get; set; }
+
+        [JsonPropertyName("experience")]
+        public int Experience { get; set; }
+
+        [JsonPropertyName("nextExp")]
+        public int NextExp { get; set; }
+
+        [JsonPropertyName("maxHp")]
+        public double MaxHp { get; set; }
+
+        [JsonPropertyName("maxMp")]
+        public double MaxMp { get; set; }
+
+        [JsonPropertyName("attackPower")]
+        public double AttackPower { get; set; }
+
+        [JsonPropertyName("attackRange")]
+        public double AttackRange { get; set; }
+
+        [JsonPropertyName("sprintMultiplier")]
+        public double SprintMultiplier { get; set; }
+    }
+
+    // 레이드 채널 접속 여부 체크
+    // 성공 시 BossRaidResult 반환, 실패/거절 시 null 반환
+    public async Task<BossRaidResult?> BossRaidAccessAsync(List<string> userNames, int bossId)
+    {
+        string url = AppConfig.RestApi.BaseUrl + AppConfig.RestApi.BossRaidAccess;
+
+        for (int attempt = 1; attempt <= MAX_RETRY; attempt++)
+        {
+            try
+            {
+                HttpResponseMessage response = await httpClient.PostAsJsonAsync(url, new { usernames = userNames, bossId = bossId });
+
+                // 401: API 키 인증 실패
+                if (response.StatusCode == HttpStatusCode.Unauthorized)
+                {
+                    Log.Warning("[RestApi] 보스 레이드 접속 인증 실패 (401)");
+                    return null;
+                }
+
+                // 400: 입장 조건 미충족 / 409: 이미 레이드 중 등
+                if (response.StatusCode == HttpStatusCode.BadRequest ||
+                    response.StatusCode == HttpStatusCode.Conflict)
+                {
+                    Log.Warning("[RestApi] 보스 레이드 입장 거절 ({Status}) BossId={BossId}",
+                        (int)response.StatusCode, bossId);
+                    return null;
+                }
+
+                response.EnsureSuccessStatusCode();
+
+                BossRaidAccessResponse? raw = await response.Content.ReadFromJsonAsync<BossRaidAccessResponse>();
+                if (raw == null)
+                {
+                    return null;
+                }
+
+                // API 응답 → 도메인 모델 매핑
+                return new BossRaidResult
+                {
+                    RoomId = raw.RoomId,
+                    SessionName = raw.SessionName ?? string.Empty,
+                    BossId = raw.BossId,
+                    Players = raw.Players,
+                    Status = raw.Status ?? string.Empty,
+                    Tokens = raw.Tokens
+                };
+            }
+            catch (Exception ex) when (attempt < MAX_RETRY)
+            {
+                Log.Warning("[RestApi] 보스 레이드 통신 실패 (시도 {Attempt}/{Max}): {Message}", attempt, MAX_RETRY, ex.Message);
+                await Task.Delay(RETRY_DELAY);
+            }
+            catch (Exception ex)
+            {
+                Log.Error("[RestApi] 보스 레이드 최종 통신 실패 ({Max}회 시도): {Message}", MAX_RETRY, ex.Message);
+            }
+        }
+
+        return null;
+    }
+
+    private sealed class BossRaidAccessResponse
+    {
+        [JsonPropertyName("roomId")]
+        public int RoomId
+        {
+            get;
+            set;
+        }
+
+        [JsonPropertyName("sessionName")]
+        public string? SessionName
+        {
+            get;
+            set;
+        }
+
+        [JsonPropertyName("bossId")]
+        public int BossId
+        {
+            get;
+            set;
+        }
+
+        [JsonPropertyName("players")]
+        public List<string> Players
+        {
+            get;
+            set;
+        } = new();
+
+        [JsonPropertyName("status")]
+        public string? Status
+        {
+            get;
+            set;
+        }
+
+        [JsonPropertyName("tokens")]
+        public Dictionary<string, string>? Tokens
+        {
+            get;
+            set;
+        } = new();
+    }
+}

MMOTestServer/MMOserver/Config/AppConfig.cs

@@ -0,0 +1,74 @@
+using Microsoft.Extensions.Configuration;
+
+namespace MMOserver.Config;
+
+public static class AppConfig
+{
+    public static ServerConfig Server
+    {
+        get;
+        private set;
+    } = null!;
+
+    public static RestApiConfig RestApi
+    {
+        get;
+        private set;
+    } = null!;
+
+    public static void Initialize(IConfiguration config)
+    {
+        Server = new ServerConfig(config.GetSection("Server"));
+        RestApi = new RestApiConfig(config.GetSection("RestApi"));
+    }
+}
+
+public sealed class ServerConfig
+{
+    public int Port
+    {
+        get;
+    }
+
+    public int ChannelCount
+    {
+        get;
+    }
+
+    public ServerConfig(IConfigurationSection section)
+    {
+        Port = int.Parse(section["Port"] ?? throw new InvalidOperationException("Server:Port is required in config.json"));
+        ChannelCount =  int.Parse(section["ChannelCount"] ?? "1");
+    }
+}
+
+public sealed class RestApiConfig
+{
+    public string BaseUrl
+    {
+        get;
+    }
+
+    public string VerifyToken
+    {
+        get;
+    }
+
+    public string BossRaidAccess
+    {
+        get;
+    }
+
+    public string ApiKey
+    {
+        get;
+    }
+
+    public RestApiConfig(IConfigurationSection section)
+    {
+        BaseUrl = section["BaseUrl"] ?? throw new InvalidOperationException("RestApi:BaseUrl is required in config.json");
+        VerifyToken = section["VerifyToken"] ?? throw new InvalidOperationException("RestApi:BaseUrl is required in config.json");
+        BossRaidAccess = section["BossRaidAccess"] ?? throw new InvalidOperationException("RestApi:BaseUrl is required in config.json");
+        ApiKey = section["ApiKey"] ?? throw new InvalidOperationException("RestApi:ApiKey is required in config.json");
+    }
+}

MMOTestServer/MMOserver/Dockerfile

@@ -5,7 +5,9 @@ WORKDIR /app
 FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
 ARG BUILD_CONFIGURATION=Release
 WORKDIR /src
+# ServerLib 의존성 포함해서 restore (캐시 레이어 최적화)
 COPY ["MMOserver/MMOserver.csproj", "MMOserver/"]
+COPY ["ServerLib/ServerLib.csproj", "ServerLib/"]
 RUN dotnet restore "MMOserver/MMOserver.csproj"
 COPY . .
 WORKDIR "/src/MMOserver"

MMOTestServer/MMOserver/Game/Channel/Channel.cs

@@ -0,0 +1,207 @@
+using LiteNetLib;
+using MMOserver.Game.Channel.Maps;
+using MMOserver.Game.Channel.Maps.InstanceDungeun;
+using MMOserver.Game.Party;
+
+namespace MMOserver.Game.Channel;
+
+public class Channel
+{
+    // 채널 내 유저 NetPeer (hashKey → NetPeer) — BroadcastToChannel 교차 조회 제거용
+    private readonly Dictionary<int, NetPeer> connectPeers = new();
+
+    // 채널 내 유저 상태 (hashKey → Player)
+    private readonly Dictionary<int, Player> connectUsers = new();
+
+    // 채널 맵 관리
+    private readonly Dictionary<int, AMap> maps = new();
+
+    // 진행중 채널 맵 관리
+    private readonly Dictionary<int, AMap> useInstanceMaps = new();
+
+    // 동적 레이드 맵 할당용 ID 카운터 (사전 생성 10개 이후부터 시작)
+    private int nextDynamicRaidMapId = 1011;
+
+    // 파티
+    private readonly PartyManager partyManager = new();
+
+    public Channel(int channelId)
+    {
+        ChannelId = channelId;
+
+        // 일단 하드코딩으로 맵 생성
+        {
+            // 로비
+            maps.Add(1, new Robby(1));
+
+            // 인던
+            int defaultValue = 1000;
+            for (int i = 1; i <= 10; i++)
+            {
+                maps.Add(i + defaultValue, new BossInstance(i + defaultValue));
+            }
+        }
+    }
+
+    public int ChannelId
+    {
+        get;
+    }
+
+    public int UserCount
+    {
+        get;
+        private set;
+    }
+
+    public int UserCountMax
+    {
+        get;
+        private set;
+    } = 100;
+
+    public void AddUser(int userId, Player player, NetPeer peer)
+    {
+        connectUsers[userId] = player;
+        connectPeers[userId] = peer;
+        UserCount++;
+
+        // 처음 접속 시 1번 맵(로비)으로 입장
+        ChangeMap(userId, player, 1);
+    }
+
+    public void RemoveUser(int userId)
+    {
+        // 현재 맵에서도 제거
+        if (connectUsers.TryGetValue(userId, out Player? player) &&
+            maps.TryGetValue(player.CurrentMapId, out AMap? currentMap))
+        {
+            currentMap.RemoveUser(userId);
+        }
+
+        if (connectUsers.Remove(userId))
+        {
+            UserCount--;
+        }
+
+        connectPeers.Remove(userId);
+    }
+
+    // 맵 이동 (현재 맵 제거 → 새 맵 추가 → CurrentMapId 갱신)
+    public bool ChangeMap(int userId, Player player, int mapId)
+    {
+        if (!maps.TryGetValue(mapId, out AMap? newMap))
+        {
+            return false;
+        }
+
+        // 기존 맵에서 제거
+        if (maps.TryGetValue(player.CurrentMapId, out AMap? oldMap))
+        {
+            oldMap.RemoveUser(userId);
+        }
+
+        newMap.AddUser(userId, player);
+        player.CurrentMapId = mapId;
+        return true;
+    }
+
+    // 재연결(WiFi→LTE 등) 시 동일 유저의 peer 교체
+    public void UpdatePeer(int userId, NetPeer peer)
+    {
+        connectPeers[userId] = peer;
+    }
+
+    // 채널 내 모든 유저의 hashKey 반환 (채널 입장 시 기존 플레이어 목록 조회용)
+    public IEnumerable<int> GetConnectUsers()
+    {
+        return connectUsers.Keys;
+    }
+
+    // 채널 내 모든 Player 반환
+    public IEnumerable<Player> GetPlayers()
+    {
+        return connectUsers.Values;
+    }
+
+    // 채널 내 모든 NetPeer 반환 — BroadcastToChannel 전용 (sessions 교차 조회 불필요)
+    public IEnumerable<NetPeer> GetConnectPeers()
+    {
+        return connectPeers.Values;
+    }
+
+    // 특정 유저의 Player 반환
+    public Player? GetPlayer(int userId)
+    {
+        connectUsers.TryGetValue(userId, out Player? player);
+        return player;
+    }
+
+    public int HasUser(int userId)
+    {
+        if (connectUsers.ContainsKey(userId))
+        {
+            return ChannelId;
+        }
+
+        return -1;
+    }
+
+    // 맵들 가져옴
+    public Dictionary<int, AMap> GetMaps()
+    {
+        return maps;
+    }
+
+    // 맵 가져옴
+    public AMap? GetMap(int mapId)
+    {
+        AMap? map = null;
+        maps.TryGetValue(mapId, out map);
+        return map;
+    }
+
+    // 사용 가능한 레이드 맵 ID 반환
+    // 기존 맵(1001~) 중 미사용 탐색 → 없으면 동적 생성 후 반환
+    public int GetOrCreateAvailableRaidMap()
+    {
+        // 기존 맵 중 미사용 탐색
+        foreach (int mapId in maps.Keys)
+        {
+            if (mapId >= 1001 && !useInstanceMaps.ContainsKey(mapId))
+            {
+                return mapId;
+            }
+        }
+
+        // 모두 사용 중 → 동적 생성
+        int newMapId = nextDynamicRaidMapId++;
+        BossInstance newMap = new(newMapId);
+        maps.Add(newMapId, newMap);
+
+        return newMapId;
+    }
+
+    // 레이드 맵 사용 시작 (진행중 목록에 등록)
+    public void AddInstanceMap(int mapId)
+    {
+        if (maps.TryGetValue(mapId, out AMap? map))
+        {
+            useInstanceMaps[mapId] = map;
+        }
+    }
+
+    // 레이드 맵 사용 종료 (진행중 목록에서 제거)
+    public void RemoveInstanceMap(int mapId)
+    {
+        useInstanceMaps.Remove(mapId);
+    }
+
+    // 파티매니저 가져옴
+    public PartyManager GetPartyManager()
+    {
+        return partyManager;
+    }
+
+    // TODO : 채널 가져오기
+}

MMOTestServer/MMOserver/Game/Channel/ChannelManager.cs

@@ -0,0 +1,85 @@
+using LiteNetLib;
+using MMOserver.Config;
+using MMOserver.Utils;
+
+namespace MMOserver.Game.Channel;
+
+public class ChannelManager : Singleton<ChannelManager>
+{
+    // 채널 관리
+    private Dictionary<int, Channel> channels = new Dictionary<int, Channel>();
+
+    // 채널별 유저 관리 (유저 key, 채널 val)
+    private Dictionary<int, int> connectUsers = new Dictionary<int, int>();
+
+    public ChannelManager()
+    {
+        Initializer(AppConfig.Server.ChannelCount);
+    }
+
+    public void Initializer(int channelSize = 1)
+    {
+        for (int i = 1; i <= channelSize; i++)
+        {
+            channels.Add(i, new Channel(i));
+        }
+    }
+
+    public Channel GetChannel(int channelId)
+    {
+        return channels[channelId];
+    }
+
+    public Dictionary<int, Channel> GetChannels()
+    {
+        return channels;
+    }
+
+    public void AddUser(int channelId, int userId, Player player, NetPeer peer)
+    {
+        // 유저 추가 (채널 이동 시 기존 매핑 덮어쓰기 허용)
+        connectUsers[userId] = channelId;
+        // 채널에 유저 + peer 추가
+        channels[channelId].AddUser(userId, player, peer);
+    }
+
+    public bool RemoveUser(int userId)
+    {
+        // 채널에 없는 유저면 스킵
+        if (!connectUsers.TryGetValue(userId, out int channelId))
+        {
+            return false;
+        }
+
+        // 날린다.
+        if (channelId >= 0)
+        {
+            channels[channelId].RemoveUser(userId);
+            connectUsers.Remove(userId);
+            return true;
+        }
+
+        return false;
+    }
+
+    public int HasUser(int userId)
+    {
+        int channelId = -1;
+        if (connectUsers.ContainsKey(userId))
+        {
+            channelId = connectUsers[userId];
+        }
+
+        if (channelId != -1)
+        {
+            return channels[channelId].HasUser(userId);
+        }
+
+        return channelId;
+    }
+
+    public Dictionary<int, int> GetConnectUsers()
+    {
+        return connectUsers;
+    }
+}

MMOTestServer/MMOserver/Game/Channel/Maps/AMap.cs

@@ -0,0 +1,24 @@
+namespace MMOserver.Game.Channel.Maps;
+
+public abstract class AMap
+{
+    private Dictionary<int, Player> users = new Dictionary<int, Player>();
+
+    public abstract EnumMap GetMapType();
+    public abstract int GetMapId();
+
+    public void AddUser(int userId, Player player)
+    {
+        users[userId] = player;
+    }
+
+    public void RemoveUser(int userId)
+    {
+        users.Remove(userId);
+    }
+
+    public Dictionary<int, Player> GetUsers()
+    {
+        return users;
+    }
+}

MMOTestServer/MMOserver/Game/Channel/Maps/EunmMap.cs

@@ -0,0 +1,8 @@
+namespace MMOserver.Game.Channel.Maps;
+
+public enum EnumMap : int
+{
+    NONE = 0,
+    ROBBY = 1,
+    INSTANCE = 10,
+}

MMOTestServer/MMOserver/Game/Channel/Maps/InstanceDungeun/BossInstance.cs

@@ -0,0 +1,34 @@
+using MMOserver.Game.Channel.Maps;
+using MMOserver.Game.Engine;
+
+namespace MMOserver.Game.Channel.Maps.InstanceDungeun;
+
+// 인스턴스 보스 맵에 들어갈때 쓰는 것
+public class BossInstance : AMap
+{
+    private EnumMap enumMap;
+    private int mapId;
+
+    // 마을 시작 지점 넣어 둔다.
+    public static Vector3 StartPosition
+    {
+        get;
+        set;
+    } = new Vector3(0, 0, 0);
+
+    public BossInstance(int mapId, EnumMap enumMap = EnumMap.INSTANCE)
+    {
+        this.enumMap = enumMap;
+        this.mapId = mapId;
+    }
+
+    public override EnumMap GetMapType()
+    {
+        return enumMap;
+    }
+
+    public override int GetMapId()
+    {
+        return mapId;
+    }
+}

MMOTestServer/MMOserver/Game/Channel/Maps/Robby.cs

@@ -0,0 +1,32 @@
+using MMOserver.Game.Engine;
+
+namespace MMOserver.Game.Channel.Maps;
+
+public class Robby : AMap
+{
+    private EnumMap enumMap;
+    private int mapId;
+
+    // 마을 시작 지점 넣어 둔다.
+    public static Vector3 StartPosition
+    {
+        get;
+        set;
+    } = new Vector3(0, 0, 0);
+
+    public Robby(int  mapId, EnumMap enumMap = EnumMap.ROBBY)
+    {
+        this.enumMap = enumMap;
+        this.mapId = mapId;
+    }
+
+    public override EnumMap GetMapType()
+    {
+        return enumMap;
+    }
+
+    public override int GetMapId()
+    {
+        return mapId;
+    }
+}

MMOTestServer/MMOserver/Game/Engine/Vector3.cs

@@ -0,0 +1,36 @@
+namespace MMOserver.Game.Engine;
+
+public class Vector3
+{
+    public int X
+    {
+        get;
+        set;
+    }
+
+    public int Y
+    {
+        get;
+        set;
+    }
+
+    public int Z
+    {
+        get;
+        set;
+    }
+
+    public Vector3()
+    {
+        X = 0;
+        Y = 0;
+        Z = 0;
+    }
+
+    public Vector3(int x, int y, int z)
+    {
+        X = x;
+        Y = y; // 수직 사실상 안쓰겠다.
+        Z = z;
+    }
+}

MMOTestServer/MMOserver/Game/Party/Party.cs

@@ -0,0 +1,52 @@
+namespace MMOserver.Game.Party;
+
+public class PartyInfo
+{
+    public static readonly int partyMemberMax = 3;
+
+    public int PartyId
+    {
+        get;
+        set;
+    }
+
+    public int LeaderId
+    {
+        get;
+        set;
+    }
+
+    public List<int> PartyMemberIds
+    {
+        get;
+        set;
+    } = new List<int>();
+
+    public string PartyName
+    {
+        get;
+        set;
+    } = "";
+
+    public int GetPartyMemberCount()
+    {
+        return PartyMemberIds.Count;
+    }
+
+    public void DeepCopy(PartyInfo other)
+    {
+        this.PartyId = other.PartyId;
+        this.PartyName = other.PartyName;
+        this.LeaderId = other.LeaderId;
+        this.PartyMemberIds.Clear();
+        this.PartyMemberIds.AddRange(other.PartyMemberIds);
+    }
+
+    public void DeepCopySemi(PartyInfo other)
+    {
+        this.PartyId = other.PartyId;
+        this.PartyName = other.PartyName;
+        this.LeaderId = other.LeaderId;
+        this.PartyMemberIds = new List<int>();
+    }
+}

MMOTestServer/MMOserver/Game/Party/PartyManager.cs

@@ -0,0 +1,196 @@
+using MMOserver.Utils;
+
+namespace MMOserver.Game.Party;
+
+public class PartyManager
+{
+    private readonly UuidGenerator partyUuidGenerator = new UuidGenerator();
+
+    // partyId → PartyInfo
+    private readonly Dictionary<int, PartyInfo> parties = new();
+
+    // playerId → partyId (한 플레이어는 하나의 파티만)
+    private readonly Dictionary<int, int> playerPartyMap = new();
+
+    // 파티 생성
+    public bool CreateParty(int leaderId, string partyName, out PartyInfo? party, List<int>? memeberIds = null)
+    {
+        if (playerPartyMap.ContainsKey(leaderId))
+        {
+            party = null;
+            return false; // 이미 파티에 속해있음
+        }
+
+        int partyId = partyUuidGenerator.Create();
+
+        if (memeberIds == null)
+        {
+            memeberIds = new List<int>();
+        }
+
+        // 리더 중복 방지: 기존 멤버 목록에 리더가 없을 때만 추가
+        if (!memeberIds.Contains(leaderId))
+        {
+            memeberIds.Add(leaderId);
+        }
+
+        party = new PartyInfo
+        {
+            PartyId = partyId,
+            LeaderId = leaderId,
+            PartyName = partyName,
+            PartyMemberIds = memeberIds
+        };
+
+        parties[partyId] = party;
+
+        // 모든 멤버를 playerPartyMap에 등록
+        foreach (int memberId in memeberIds)
+        {
+            playerPartyMap[memberId] = partyId;
+        }
+
+        return true;
+    }
+
+    // 파티 참가
+    public bool JoinParty(int playerId, int partyId, out PartyInfo? party)
+    {
+        party = null;
+
+        if (playerPartyMap.ContainsKey(playerId))
+        {
+            return false; // 이미 파티에 속해있음
+        }
+
+        if (!parties.TryGetValue(partyId, out party))
+        {
+            return false; // 파티 없음
+        }
+
+        if (party.GetPartyMemberCount() >= PartyInfo.partyMemberMax)
+        {
+            party = null;
+            return false; // 파티 인원 초과
+        }
+
+        party.PartyMemberIds.Add(playerId);
+        playerPartyMap[playerId] = partyId;
+
+        return true;
+    }
+
+    // 파티 탈퇴
+    public bool LeaveParty(int playerId, out PartyInfo? party)
+    {
+        party = null;
+
+        if (!playerPartyMap.TryGetValue(playerId, out int partyId))
+        {
+            return false; // 파티에 속해있지 않음
+        }
+
+        if (!parties.TryGetValue(partyId, out party))
+        {
+            return false;
+        }
+
+        party.PartyMemberIds.Remove(playerId);
+        playerPartyMap.Remove(playerId);
+
+        // 마지막 멤버가 나가면 파티 해산
+        if (party.PartyMemberIds.Count == 0)
+        {
+            DeletePartyInternal(partyId, party);
+            // id가 필요하다 그래서 참조해 둔다.
+            // party = null;
+            return true;
+        }
+
+        // 리더가 나갔으면 남은 멤버 중 첫 번째를 리더로 승계
+        if (party.LeaderId == playerId)
+        {
+            party.LeaderId = party.PartyMemberIds[0];
+        }
+
+        return true;
+    }
+
+    // 파티 해산 (리더만)
+    public bool DeleteParty(int leaderId, int partyId, out PartyInfo? party)
+    {
+        party = null;
+
+        if (!parties.TryGetValue(partyId, out party))
+        {
+            return false;
+        }
+
+        if (party.LeaderId != leaderId)
+        {
+            party = null;
+            return false; // 리더만 해산 가능
+        }
+
+        DeletePartyInternal(partyId, party);
+        return true;
+    }
+
+    // 파티 업데이트
+    public bool UpdateParty(int leaderId, int partyId, string newPartyName, out PartyInfo? party)
+    {
+        party = null;
+
+        if (!parties.TryGetValue(partyId, out party))
+        {
+            return false;
+        }
+
+        if (party.LeaderId != leaderId)
+        {
+            party = null;
+            return false; // 리더만 업데이트 가능
+        }
+
+        // 파티 이름 변경
+        party.PartyName = newPartyName;
+        return true;
+    }
+
+    // 전체 파티 목록 조회
+    public IEnumerable<PartyInfo> GetAllParties()
+    {
+        return parties.Values;
+    }
+
+    // 조회
+    public PartyInfo? GetParty(int partyId)
+    {
+        parties.TryGetValue(partyId, out PartyInfo? party);
+        return party;
+    }
+
+    public PartyInfo? GetPartyByPlayer(int playerId)
+    {
+        if (!playerPartyMap.TryGetValue(playerId, out int partyId))
+        {
+            return null;
+        }
+
+        parties.TryGetValue(partyId, out PartyInfo? party);
+        return party;
+    }
+
+    // 삭제
+    private void DeletePartyInternal(int partyId, PartyInfo party)
+    {
+        // 남아 있는인원도 제거
+        foreach (int memberId in party.PartyMemberIds)
+        {
+            playerPartyMap.Remove(memberId);
+        }
+
+        parties.Remove(partyId);
+        partyUuidGenerator.Release(partyId);
+    }
+}

MMOTestServer/MMOserver/Game/Player.cs

@@ -0,0 +1,121 @@
+namespace MMOserver.Game;
+
+public class Player
+{
+    public int HashKey
+    {
+        get;
+        set;
+    }
+
+    public int PlayerId
+    {
+        get;
+        set;
+    }
+
+    public string Nickname
+    {
+        get;
+        set;
+    } = string.Empty;
+
+    public int Level
+    {
+        get;
+        set;
+    }
+
+    public int Hp
+    {
+        get;
+        set;
+    }
+
+    public int MaxHp
+    {
+        get;
+        set;
+    }
+
+    public int Mp
+    {
+        get;
+        set;
+    }
+
+    public int MaxMp
+    {
+        get;
+        set;
+    }
+
+    public int Experience
+    {
+        get;
+        set;
+    }
+
+    public int NextExp
+    {
+        get;
+        set;
+    }
+
+    public float AttackPower
+    {
+        get;
+        set;
+    }
+
+    public float AttackRange
+    {
+        get;
+        set;
+    }
+
+    public float SprintMultiplier
+    {
+        get;
+        set;
+    }
+
+    // 위치/방향 (클라이언트 패킷과 동일하게 float)
+    public float PosX
+    {
+        get;
+        set;
+    }
+
+    public float PosY
+    {
+        get;
+        set;
+    }
+
+    public float PosZ
+    {
+        get;
+        set;
+    }
+
+    public float RotY
+    {
+        get;
+        set;
+    }
+
+    // 현재 위치한 맵 ID
+    public int CurrentMapId
+    {
+        get;
+        set;
+    }
+
+    // 레이드 입장 전 이전 맵 ID (레이드 종료 후 복귀용, 서버 캐싱)
+    public int PreviousMapId
+    {
+        get;
+        set;
+    }
+}

MMOTestServer/MMOserver/MMOserver.csproj

@@ -9,6 +9,11 @@
         <LangVersion>13</LangVersion>
     </PropertyGroup>
 
+    <PropertyGroup>
+        <DebugType>portable</DebugType>
+        <DebugSymbols>true</DebugSymbols>
+    </PropertyGroup>
+
     <ItemGroup>
         <PackageReference Include="LiteNetLib" Version="2.0.2" />
         <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.3" />

MMOTestServer/MMOserver/Packet/PacketBody.cs

@@ -4,12 +4,28 @@ using ProtoBuf;
 
 namespace MMOserver.Packet;
 
+// ============================================================
+// 에코용
+// ============================================================
+
+// ECHO
+[ProtoContract]
+public class EchoPacket
+{
+    [ProtoMember(1)]
+    public string Str
+    {
+        get;
+        set;
+    }
+}
+
 // ============================================================
 // 공통 타입
 // ============================================================
 
 [ProtoContract]
-public class Vector3
+public class Position
 {
     [ProtoMember(1)]
     public float X
@@ -86,7 +102,7 @@ public class PlayerInfo
     }
 
     [ProtoMember(8)]
-    public Vector3 Position
+    public Position Position
     {
         get;
         set;
@@ -98,20 +114,37 @@ public class PlayerInfo
         get;
         set;
     }
-}
 
-[ProtoContract]
-public class ItemInfo
-{
-    [ProtoMember(1)]
-    public int ItemId
+    [ProtoMember(10)]
+    public int Experience
     {
         get;
         set;
     }
 
-    [ProtoMember(2)]
-    public int Count
+    [ProtoMember(11)]
+    public int NextExp
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(12)]
+    public float AttackPower
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(13)]
+    public float AttackRange
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(14)]
+    public float SprintMultiplier
     {
         get;
         set;
@@ -122,9 +155,21 @@ public class ItemInfo
 // 인증
 // ============================================================
 
-// RECV_TOKEN
+// DUMMY_ACC_TOKEN
 [ProtoContract]
-public class RecvTokenPacket
+public class DummyAccTokenPacket
+{
+    [ProtoMember(1)]
+    public int Token
+    {
+        get;
+        set;
+    }
+}
+
+// ACC_TOKEN
+[ProtoContract]
+public class AccTokenPacket
 {
     [ProtoMember(1)]
     public string Token
@@ -134,7 +179,7 @@ public class RecvTokenPacket
     }
 }
 
-// LOAD_GAME
+// LOAD_GAME 내 정보
 [ProtoContract]
 public class LoadGamePacket
 {
@@ -151,155 +196,58 @@ public class LoadGamePacket
         get;
         set;
     }
+
+    [ProtoMember(3)]
+    public int MapId
+    {
+        get;
+        set;
+    }
 }
 
 // ============================================================
 // 로비
 // ============================================================
 
-// INTO_LOBBY
 [ProtoContract]
-public class IntoLobbyPacket
+public class ChannelInfo
 {
     [ProtoMember(1)]
-    public List<PlayerInfo> Players
-    {
-        get;
-        set;
-    }
-}
-
-// EXIT_LOBBY
-[ProtoContract]
-public class ExitLobbyPacket
-{
-    [ProtoMember(1)]
-    public int PlayerId
-    {
-        get;
-        set;
-    }
-}
-
-// ============================================================
-// 인스턴스 던전
-// ============================================================
-
-public enum BossState
-{
-    START,
-    END,
-    PHASE_CHANGE
-}
-
-public enum BossResult
-{
-    SUCCESS,
-    FAIL
-}
-
-// INTO_INSTANCE
-[ProtoContract]
-public class IntoInstancePacket
-{
-    [ProtoMember(1)]
-    public int InstanceId
+    public int ChannelId
     {
         get;
         set;
     }
 
     [ProtoMember(2)]
-    public int BossId
+    public int ChannelUserCount
     {
         get;
         set;
     }
 
     [ProtoMember(3)]
-    public List<int> PlayerIds
+    public int ChannelUserMax
     {
         get;
         set;
     }
 }
 
-// UPDATE_BOSS
 [ProtoContract]
-public class UpdateBossPacket
+public class LoadChannelPacket
 {
     [ProtoMember(1)]
-    public BossState State
+    public List<ChannelInfo> Channels
     {
         get;
         set;
-    }
-
-    [ProtoMember(2)]
-    public int Phase
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
-    public BossResult Result
-    {
-        get;
-        set;
-    } // END일 때만 유효
+    } = new List<ChannelInfo>();
 }
 
-// REWARD_INSTANCE
+// 채널 내 파티 정보 (INTO_CHANNEL 응답에 포함)
 [ProtoContract]
-public class RewardInstancePacket
-{
-    [ProtoMember(1)]
-    public int Exp
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public List<ItemInfo> Items
-    {
-        get;
-        set;
-    }
-}
-
-// EXIT_INSTANCE
-[ProtoContract]
-public class ExitInstancePacket
-{
-    [ProtoMember(1)]
-    public int PlayerId
-    {
-        get;
-        set;
-    }
-}
-
-// ============================================================
-// 파티
-// ============================================================
-
-public enum PartyUpdateType
-{
-    CREATE,
-    DELETE
-}
-
-public enum UserPartyUpdateType
-{
-    JOIN,
-    LEAVE
-}
-
-// UPDATE_PARTY
-[ProtoContract]
-public class UpdatePartyPacket
+public class PartyInfoData
 {
     [ProtoMember(1)]
     public int PartyId
@@ -309,40 +257,112 @@ public class UpdatePartyPacket
     }
 
     [ProtoMember(2)]
-    public PartyUpdateType Type
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
     public int LeaderId
     {
         get;
         set;
     }
+
+    [ProtoMember(3)]
+    public List<int> MemberPlayerIds
+    {
+        get;
+        set;
+    } = new List<int>();
+
+    [ProtoMember(4)]
+    public string PartyName
+    {
+        get;
+        set;
+    }
 }
 
-// UPDATE_USER_PARTY
+// INTO_CHANNEL 클라->서버: 입장할 채널 ID / 서버->클라: 채널 내 나 이외 플레이어 목록
 [ProtoContract]
-public class UpdateUserPartyPacket
+public class IntoChannelPacket
 {
     [ProtoMember(1)]
+    public int ChannelId
+    {
+        get;
+        set;
+    } // 클라->서버: 입장할 채널 ID
+
+    [ProtoMember(2)]
+    public List<PlayerInfo> Players
+    {
+        get;
+        set;
+    } = new List<PlayerInfo>(); // 서버->클라: 채널 내 플레이어 목록
+
+    [ProtoMember(3)]
+    public List<PartyInfoData> Parties
+    {
+        get;
+        set;
+    } = new List<PartyInfoData>(); // 서버->클라: 채널 내 파티 목록
+}
+
+// 파티원 모두 채널이동
+// 클라->서버: 입장할 채널 ID
+[ProtoContract]
+public class IntoChannelPartyPacket
+{
+    [ProtoMember(1)]
+    public int ChannelId
+    {
+        get;
+        set;
+    } // 클라->서버: 입장할 채널 ID
+
+    [ProtoMember(2)]
+    public List<PlayerInfo> Players
+    {
+        get;
+        set;
+    } = new List<PlayerInfo>(); // 서버->클라: 채널 내 플레이어 목록
+
+    [ProtoMember(3)]
+    public List<PartyInfoData> Parties
+    {
+        get;
+        set;
+    } = new List<PartyInfoData>(); // 서버->클라: 채널 내 파티 목록
+
+    [ProtoMember(4)]
     public int PartyId
     {
         get;
         set;
     }
+}
+
+// UPDATE_CHANNEL_USER 유저 접속/나감
+[ProtoContract]
+public class UpdateChannelUserPacket
+{
+    [ProtoMember(1)]
+    public PlayerInfo Players
+    {
+        get;
+        set;
+    }
 
     [ProtoMember(2)]
-    public int PlayerId
+    public bool IsAdd
     {
         get;
         set;
     }
+}
 
-    [ProtoMember(3)]
-    public UserPartyUpdateType Type
+// EXIT_CHANNEL 나가는 유저
+[ProtoContract]
+public class ExitChannelPacket
+{
+    [ProtoMember(1)]
+    public int PlayerId
     {
         get;
         set;
@@ -376,7 +396,7 @@ public class TransformPlayerPacket
     }
 
     [ProtoMember(2)]
-    public Vector3 Position
+    public Position Position
     {
         get;
         set;
@@ -488,7 +508,7 @@ public class TransformNpcPacket
     }
 
     [ProtoMember(2)]
-    public Vector3 Position
+    public Position Position
     {
         get;
         set;
@@ -604,3 +624,262 @@ public class DamagePacket
         set;
     }
 }
+
+// ============================================================
+// 에러
+// ============================================================
+
+public enum ErrorCode : int
+{
+    // 파티 (10021~)
+    PARTY_ALREADY_IN_PARTY = 10021,
+    PARTY_JOIN_FAILED = 10022,
+    PARTY_NOT_IN_PARTY = 10023,
+    PARTY_DELETE_FAILED = 10024,
+    PARTY_UPDATE_FAILED = 10025,
+}
+
+// ERROR (서버 -> 클라)
+[ProtoContract]
+public class ErrorPacket
+{
+    [ProtoMember(1)]
+    public ErrorCode Code
+    {
+        get;
+        set;
+    }
+}
+
+// ============================================================
+// 파티
+// ============================================================
+
+public enum PartyUpdateType
+{
+    CREATE,
+    DELETE,
+    JOIN,
+    LEAVE,
+    UPDATE
+}
+
+// REQUEST_PARTY (클라 -> 서버) - CREATE: PartyName 사용 / JOIN·LEAVE·DELETE: PartyId 사용
+[ProtoContract]
+public class RequestPartyPacket
+{
+    [ProtoMember(1)]
+    public PartyUpdateType Type
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int PartyId
+    {
+        get;
+        set;
+    } // JOIN, LEAVE, DELETE 시 사용
+
+    [ProtoMember(3)]
+    public string PartyName
+    {
+        get;
+        set;
+    } // CREATE 시 사용
+}
+
+// ============================================================
+// 채팅
+// ============================================================
+
+public enum ChatType
+{
+    GLOBAL, // 전체 채널
+    PARTY, // 파티원
+    WHISPER // 귓말
+}
+
+// CHAT (클라 -> 서버 & 서버 -> 클라)
+// 클라->서버: Type, TargetId(WHISPER 시), Message
+// 서버->클라: Type, SenderId, SenderNickname, TargetId(WHISPER 시), Message
+[ProtoContract]
+public class ChatPacket
+{
+    [ProtoMember(1)]
+    public ChatType Type
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int SenderId
+    {
+        get;
+        set;
+    } // 서버에서 채워줌
+
+    [ProtoMember(3)]
+    public string SenderNickname
+    {
+        get;
+        set;
+    } // 서버에서 채워줌
+
+    [ProtoMember(4)]
+    public int TargetId
+    {
+        get;
+        set;
+    } // WHISPER일 때 대상 PlayerId
+
+    [ProtoMember(5)]
+    public string Message
+    {
+        get;
+        set;
+    }
+}
+// ============================================================
+// 맵 이동
+// ============================================================
+
+// CHANGE_MAP (클라 -> 서버 & 서버 -> 클라)
+[ProtoContract]
+public class ChangeMapPacket
+{
+    [ProtoMember(1)]
+    public int MapId
+    {
+        get;
+        set;
+    }
+
+    // 새 맵의 기존 플레이어 목록 (이동한 본인에게 전달)
+    [ProtoMember(2)]
+    public List<PlayerInfo> Players
+    {
+        get;
+        set;
+    } = new List<PlayerInfo>();
+
+    // 입장(true) / 퇴장(false) - 기존 맵 플레이어들에게 전달
+    [ProtoMember(3)]
+    public bool IsAdd
+    {
+        get;
+        set;
+    }
+
+    // 이동한 플레이어 정보 - 기존 맵 플레이어들에게 전달
+    [ProtoMember(4)]
+    public PlayerInfo Player
+    {
+        get;
+        set;
+    }
+}
+
+// INTO_BOSS_RAID
+// 클라->서버: RaidId
+// 서버->클라: RaidId + IsSuccess (파티장에게 결과 전달)
+// 성공 시 파티원 전체에게 CHANGE_MAP 추가 전송
+[ProtoContract]
+public class IntoBossRaidPacket
+{
+    // 입장할 보스 레이드 맵 Id
+    [ProtoMember(1)]
+    public int RaidId
+    {
+        get;
+        set;
+    }
+
+    // 입장 성공 여부 (서버 -> 클라)
+    [ProtoMember(2)]
+    public bool IsSuccess
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(3)]
+    public string Token
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(4)]
+    public string Session
+    {
+        get;
+        set;
+    }
+}
+
+// PARTY_CHANGE_MAP (클라 -> 서버 전용)
+[ProtoContract]
+public class PartyChangeMapPacket
+{
+    [ProtoMember(1)]
+    public int MapId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int PartyId
+    {
+        get;
+        set;
+    }
+}
+
+
+// ============================================================
+// 파티
+// ============================================================
+
+// UPDATE_PARTY (서버 -> 클라) - 파티 생성/삭제: LeaderId 사용 / 파티원 추가/제거: PlayerId 사용
+[ProtoContract]
+public class UpdatePartyPacket
+{
+    [ProtoMember(1)]
+    public int PartyId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public PartyUpdateType Type
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(3)]
+    public int LeaderId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(4)]
+    public int PlayerId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(5)]
+    public string PartyName
+    {
+        get;
+        set;
+    } // CREATE일 때 사용
+}

MMOTestServer/MMOserver/Packet/PacketHeader.cs

@@ -1,61 +1,80 @@
 namespace MMOserver.Packet;
 
-public enum PacketCode : short
+public enum PacketCode : ushort
 {
-    NONE,
     // 초기 클라이언트 시작시 jwt토큰 받아옴
-    RECV_TOKEN,
-    // jwt토큰 검증후 게임에 들어갈지 말지 (내 데이터도 전송)
-    LOAD_GAME,
+    ACC_TOKEN = 1,
 
-    // 마을(로비)진입시 모든 데이터 로드
-    INTO_LOBBY,
+    // 내 정보 로드 (서버 -> 클라)
+    LOAD_GAME = 2,
 
-    // 로비 나가기
-    EXIT_LOBBY,
+    // 모든 채널 로드 - jwt토큰 검증후 게임에 들어갈지 말지 (내 데이터도 전송)
+    // (서버 -> 클라)
+    LOAD_CHANNEL = 3,
 
-    // 인스턴스 던전 입장
-    INTO_INSTANCE,
+    // 나 채널 접속 (클라 -> 서버)
+    INTO_CHANNEL = 4,
 
-    // 결과 보상
-    REWARD_INSTANCE,
+    // 파티 채널 접속 (클라 -> 서버)
+    INTO_CHANNEL_PARTY = 5,
 
-    // 보스전 (시작, 종료)
-    UPDATE_BOSS,
+    // 새로운 유저 채널 접속 (서버 -> 클라) / 유저 채널 나감 (서버 -> 클라)
+    UPDATE_CHANNEL_USER = 6,
 
-    // 인스턴스 던전 퇴장
-    EXIT_INSTANCE,
+    // 채널 나가기 (클라 -> 서버)
+    EXIT_CHANNEL = 7,
 
-    // 파티 (생성, 삭제)
-    UPDATE_PARTY,
+    // 맵 이동
+    CHANGE_MAP = 8,
 
-    // 파티 유저 업데이트(추가 삭제)
-    UPDATE_USER_PARTY,
+    // 단체로 맵 이동
+    PARTY_CHANGE_MAP = 9,
 
-    // 플레이어 위치, 방향
-    TRANSFORM_PLAYER,
+    // 파티장이 보스 레이드(인스턴스 던전) 입장 신청 (클라 -> 서버)
+    INTO_BOSS_RAID = 10,
 
-    // 플레이어 행동 업데이트
-    ACTION_PLAYER,
+    // 플레이어 위치, 방향 (서버 -> 클라 \ 클라 -> 서버)
+    TRANSFORM_PLAYER = 11,
 
-    // 플레이어 스테이트 업데이트
-    STATE_PLAYER,
+    // 플레이어 행동 업데이트 (서버 -> 클라 \ 클라 -> 서버)
+    ACTION_PLAYER = 12,
 
-    // NPC 위치, 방향
-    TRANSFORM_NPC,
+    // 플레이어 스테이트 업데이트 (서버 -> 클라 \ 클라 -> 서버)
+    STATE_PLAYER = 13,
 
-    // NPC 행동 업데이트
-    ACTION_NPC,
+    // NPC 위치, 방향 (서버 -> 클라)
+    TRANSFORM_NPC = 14,
 
-    // NPC 스테이트 업데이트
-    STATE_NPC,
+    // NPC 행동 업데이트 (서버 -> 클라)
+    ACTION_NPC = 15,
 
-    // 데미지 UI 전달
-    DAMAGE
+    // NPC 스테이트 업데이트 (서버 -> 클라)
+    STATE_NPC = 16,
+
+    // 데미지 UI 전달 (서버 -> 클라)
+    DAMAGE = 17,
+
+    // 파티 생성/삭제, 파티원 추가/제거 (서버 -> 클라)
+    UPDATE_PARTY = 18,
+
+    // 파티 참가/탈퇴/생성/해산 요청 (클라 -> 서버)
+    REQUEST_PARTY = 19,
+
+    // 채팅 (클라 -> 서버 & 서버 -> 클라) - GLOBAL / PARTY / WHISPER
+    CHAT = 20,
+
+    // ECHO
+    ECHO = 1000,
+
+    // DUMMY 클라는 이걸로 jwt토큰 안받음
+    DUMMY_ACC_TOKEN = 1001,
+
+    // 요청 실패 응답 (서버 -> 클라)
+    ERROR = 9999
 }
 
 public class PacketHeader
 {
     public PacketCode Code;
-    public int BodyLength;
+    public ushort BodyLength;
 }

MMOTestServer/MMOserver/Program.cs

@@ -1,7 +1,9 @@
 using Microsoft.Extensions.Configuration;
+using MMOserver.Config;
 using MMOserver.Game;
 using MMOserver.RDB;
 using Serilog;
+using ServerLib.Utils;
 
 namespace MMOserver;
 
@@ -9,6 +11,9 @@ class Program
 {
     private static async Task Main()
     {
+        // 크래시 덤프 핸들러 (Release: .log + .dmp / Debug: .log)
+        CrashDumpHandler.Register();
+
         // .MinimumLevel.Warning() // Warning 이상만 출력 배포시
 
         IConfigurationRoot config = new ConfigurationBuilder()
@@ -17,6 +22,8 @@ class Program
             .AddEnvironmentVariables()                                   // 도커 배포용
             .Build();
 
+        AppConfig.Initialize(config);
+
         // DB 연결
         // DbConnectionFactory dbFactory = new DbConnectionFactory(config);
 
@@ -30,7 +37,7 @@ class Program
 
         Log.Information("Write Log Started");
 
-        int port = 9500;
+        int port = AppConfig.Server.Port;
         string connectionString = "test";
         GameServer gameServer = new GameServer(port, connectionString);
 

MMOTestServer/MMOserver/Utils/Singleton.cs

@@ -0,0 +1,12 @@
+namespace MMOserver.Utils;
+
+public abstract class Singleton<T> where T : Singleton<T>, new()
+{
+    private static readonly Lazy<T> instance = new Lazy<T>(static () => new T(), LazyThreadSafetyMode.ExecutionAndPublication);
+
+    public static T Instance => instance.Value;
+
+    protected Singleton()
+    {
+    }
+}

MMOTestServer/MMOserver/Utils/UuidGenerator.cs

@@ -0,0 +1,35 @@
+namespace MMOserver.Utils;
+
+public class UuidGenerator
+{
+    // 0 ~ 1000 은 더미 클라이언트 예약 범위
+    private const int DUMMY_RANGE_MAX = 1000;
+
+    private readonly object idLock = new();
+    private readonly HashSet<int> usedIds = new();
+
+    // 고유 랜덤 int ID 발급 (1001번 이상, 충돌 시 재생성)
+    public int Create()
+    {
+        lock (idLock)
+        {
+            int id;
+            do
+            {
+                id = Random.Shared.Next(DUMMY_RANGE_MAX + 1, int.MaxValue);
+            } while (usedIds.Contains(id));
+
+            usedIds.Add(id);
+            return id;
+        }
+    }
+
+    // 로그아웃 / 세션 만료 시 ID 반납
+    public bool Release(int id)
+    {
+        lock (idLock)
+        {
+            return usedIds.Remove(id);
+        }
+    }
+}

MMOTestServer/MMOserver/config.json

@@ -1,4 +1,14 @@
-{
+{
+  "Server": {
+    "Port": 9500,
+    "ChannelCount": 5
+  },
+  "RestApi": {
+    "BaseUrl": "https://a301.api.tolelom.xyz",
+    "VerifyToken": "/api/internal/auth/verify",
+    "BossRaidAccess": "/api/internal/bossraid/entry",
+    "ApiKey": "017f15b28143fc67d2e5bed283c37d2da858b9f294990a5334238e055e3f5425"
+  },
   "Database": {
     "Host": "localhost",
     "Port": "0000",

MMOTestServer/README.md

@@ -0,0 +1,596 @@
+# A301 MMO Game Server - 프로젝트 보고서
+
+---
+
+## 1. 프로젝트 개요
+
+| 항목 | 내용 |
+|------|------|
+| 프로젝트명 | A301 MMO Game Server |
+| 언어 | C# (.NET 9.0) |
+| 네트워크 | LiteNetLib (UDP 기반) |
+| 직렬화 | Protocol Buffers (protobuf-net) |
+| 데이터베이스 | MySQL (Dapper ORM) |
+| 로깅 | Serilog |
+| 배포 | Docker Compose |
+
+---
+
+## 2. 프로젝트 구현 구성
+
+### 2.1 디렉토리 구조
+
+```
+a301_mmo_game_server/
+├── MMOTestServer/
+│   ├── MMOserver/                    # 게임 서버 실행 프로젝트
+│   │   ├── Api/
+│   │   │   └── RestApi.cs            # JWT 토큰 검증 (외부 API 호출)
+│   │   ├── Game/
+│   │   │   ├── GameServer.cs         # 메인 게임 서버 (ServerBase 상속)
+│   │   │   ├── Player.cs             # 플레이어 엔티티 (상태 + 위치)
+│   │   │   ├── Channel/
+│   │   │   │   ├── Channel.cs        # 단일 게임 채널
+│   │   │   │   ├── ChannelManager.cs # 채널 관리 (Singleton)
+│   │   │   │   └── Maps/
+│   │   │   │       └── Robby.cs      # 로비 맵
+│   │   │   └── Engine/
+│   │   │       └── Vector3.cs        # 3D 위치 구조체
+│   │   ├── Packet/
+│   │   │   ├── PacketHeader.cs       # PacketCode Enum 정의
+│   │   │   └── PacketBody.cs         # 모든 패킷 클래스 (ProtoContract)
+│   │   ├── RDB/                      # 데이터베이스 계층
+│   │   │   ├── DbConnectionFactory.cs
+│   │   │   ├── Models/
+│   │   │   ├── Repositories/
+│   │   │   ├── Services/
+│   │   │   └── Handlers/
+│   │   ├── Utils/
+│   │   │   ├── Singleton.cs
+│   │   │   └── UuidGeneratorManager.cs
+│   │   ├── Program.cs               # 서버 진입점
+│   │   └── config.json              # DB 접속 설정
+│   │
+│   ├── ServerLib/                    # 핵심 네트워크 라이브러리 (DLL)
+│   │   ├── Service/
+│   │   │   ├── ServerBase.cs         # 추상 서버 베이스 클래스
+│   │   │   ├── Session.cs            # 세션 상태 관리
+│   │   │   └── SessionManager.cs     # 세션 매니저
+│   │   ├── Packet/
+│   │   │   ├── PacketSerializer.cs   # Protobuf 직렬화 (4바이트 헤더)
+│   │   │   └── PacketType.cs         # 기본 패킷 타입
+│   │   ├── RDB/
+│   │   │   ├── Database/
+│   │   │   │   └── IDbConnectionFactory.cs
+│   │   │   ├── Repositories/
+│   │   │   │   └── ARepository.cs    # 제네릭 비동기 Repository 베이스
+│   │   │   └── Handlers/
+│   │   │       ├── HelperHandler.cs
+│   │   │       └── Response.cs
+│   │   └── Utils/
+│   │       └── CrashDumpHandler.cs   # 크래시 덤프 핸들러
+│   │
+│   └── MMOserver.sln
+│
+├── ClientTester/                     # 클라이언트 테스트 도구
+│   └── EchoClientTester/
+│       ├── DummyService/             # 더미 플레이어 시뮬레이션
+│       │   ├── DummyClientService.cs
+│       │   ├── DummyClients.cs
+│       │   └── MapBounds.cs
+│       ├── EchoDummyService/         # Echo/Ping 테스트
+│       │   ├── EchoDummyClientService.cs
+│       │   └── EchoDummyClients.cs
+│       └── Packet/
+│
+├── compose.yaml                      # Docker Compose (MySQL + Server)
+└── ReadMe.md                         # DB 아키텍처 문서
+```
+
+### 2.2 핵심 모듈 구성
+
+#### ServerLib (네트워크 코어 라이브러리)
+
+| 모듈 | 파일 | 역할 |
+|------|------|------|
+| ServerBase | `ServerBase.cs` | 추상 서버 - 연결/해제/패킷 수신 이벤트 처리 |
+| Session | `Session.cs` | 인증 상태 + Peer 매핑 (hashKey, token) |
+| PacketSerializer | `PacketSerializer.cs` | 4바이트 헤더(type 2B + size 2B) + Protobuf 페이로드 |
+| ARepository | `ARepository.cs` | 제네릭 비동기 CRUD (Dapper.Contrib 기반) |
+| CrashDumpHandler | `CrashDumpHandler.cs` | 예외 로깅 + 메모리 힙 덤프 생성 |
+
+#### MMOserver (게임 로직)
+
+| 모듈 | 파일 | 역할 |
+|------|------|------|
+| GameServer | `GameServer.cs` | 패킷 라우팅 + 게임 로직 처리 (ServerBase 상속) |
+| Player | `Player.cs` | 플레이어 데이터 (위치, HP/MP, 닉네임 등) |
+| Channel | `Channel.cs` | 채널 단위 플레이어 그룹 관리 |
+| ChannelManager | `ChannelManager.cs` | 전역 채널 관리 (Singleton) |
+| RestApi | `RestApi.cs` | JWT 토큰 검증 (외부 인증 API 연동) |
+| UuidGeneratorManager | `UuidGeneratorManager.cs` | Lock-free 고유 ID 생성기 |
+
+### 2.3 패킷 프로토콜 정의
+
+| 코드 | 패킷명 | 전송 방식 | 설명 |
+|------|--------|-----------|------|
+| 1 | `ACC_TOKEN` | Reliable | 실제 JWT 토큰 인증 |
+| 1001 | `DUMMY_ACC_TOKEN` | Reliable | 더미 클라이언트 인증 |
+| 1000 | `ECHO` | Reliable | 네트워크 테스트 (Ping) |
+| 2 | `LOAD_CHANNEL` | Reliable | 채널 목록 응답 |
+| 3 | `INTO_CHANNEL` | Reliable | 채널 입장 |
+| 5 | `UPDATE_CHANNEL_USER` | Reliable | 유저 입장/퇴장 알림 |
+| 6 | `TRANSFORM_PLAYER` | **Unreliable** | 이동/회전 동기화 |
+| 7 | `ACTION_PLAYER` | Reliable | 공격/스킬/회피 액션 |
+| 8 | `STATE_PLAYER` | Reliable | HP/MP 상태 동기화 |
+
+### 2.4 데이터베이스 계층 (RDB)
+
+**아키텍처 패턴**: `Handler → Service → Repository → DB`
+
+```
+[Handler]  API 요청 수신 / JSON 응답 반환
+    ↓
+[Service]  비즈니스 로직 (검증, 변환)
+    ↓
+[Repository]  데이터 접근 (Dapper CRUD)
+    ↓
+[MySQL]  커넥션 풀 (Min: 5, Max: 100)
+```
+
+### 2.5 스레드 모델
+
+| 구분 | 방식 | 설명 |
+|------|------|------|
+| 네트워크 루프 | **싱글 스레드** | `netManager.PollEvents()` 1ms 주기 호출 |
+| 패킷 처리 | 동기 처리 | Poll 루프 내에서 순차적 처리 |
+| JWT 검증 | async/await | `HttpClient` 비동기 호출 |
+| DB 연산 | async/await | Dapper 비동기 쿼리 |
+| UUID 생성 | lock 기반 | 스레드 안전 ID 할당 |
+
+---
+
+## 3. 파이프라인
+
+### 3.1 클라이언트 접속 ~ 게임 플레이 전체 흐름
+
+```
+[1] 클라이언트 접속 (UDP)
+ │
+ ├─ LiteNetLib ConnectionRequest
+ │   └─ ServerBase.OnConnectionRequest() → 연결 키 검증
+ │
+ ▼
+[2] 인증 (Authentication)
+ │
+ ├─ 클라이언트 → 서버: ACC_TOKEN 또는 DUMMY_ACC_TOKEN 패킷 전송
+ │
+ ├─ [실제 인증] JWT 토큰 → RestApi.VerifyTokenAsync()
+ │   └─ POST https://a301.api.tolelom.xyz/api/auth/verify
+ │       ├─ 성공 → username 반환, hashKey 생성
+ │       ├─ 401 → 즉시 실패 (토큰 무효)
+ │       └─ 기타 오류 → 3회 재시도 (1초 간격)
+ │
+ ├─ [더미 인증] hashKey 직접 수신 (≤1000 범위)
+ │
+ ├─ Session 객체 생성 (hashKey, token, peer)
+ │   └─ peer.Tag에 Session 저장
+ │
+ ▼
+[3] 채널 선택
+ │
+ ├─ 서버 → 클라이언트: LOAD_CHANNEL (채널 목록)
+ ├─ 클라이언트 → 서버: INTO_CHANNEL (채널 선택)
+ │
+ ├─ 서버 처리:
+ │   ├─ 채널에 플레이어 추가
+ │   ├─ 기존 플레이어 목록 조회
+ │   └─ 서버 → 클라이언트: INTO_CHANNEL 응답 (기존 플레이어 리스트)
+ │
+ ├─ 서버 → 채널 전체: UPDATE_CHANNEL_USER (새 플레이어 입장 알림)
+ │
+ ▼
+[4] 게임 루프 (실시간 동기화)
+ │
+ ├─ TRANSFORM_PLAYER [Unreliable]
+ │   └─ 위치(X,Y,Z) + 회전(RotY) → 채널 내 브로드캐스트
+ │
+ ├─ ACTION_PLAYER [ReliableOrdered]
+ │   └─ 공격/스킬/회피 → 채널 내 브로드캐스트
+ │
+ ├─ STATE_PLAYER [ReliableOrdered]
+ │   └─ HP/MP 상태 변경 → 채널 내 브로드캐스트
+ │
+ ▼
+[5] 연결 종료
+ │
+ ├─ 클라이언트 → 서버: EXIT_CHANNEL
+ ├─ 서버: 채널에서 플레이어 제거
+ ├─ 서버 → 채널 전체: UPDATE_CHANNEL_USER (퇴장 알림)
+ └─ 세션 정리 및 Peer 해제
+```
+
+### 3.2 패킷 처리 파이프라인
+
+```
+수신 (OnNetworkReceive)
+   ↓
+┌─────────────────────────────────────┐
+│  4바이트 헤더 파싱                    │
+│  ├─ type: ushort (2B) → 패킷 종류   │
+│  └─ size: ushort (2B) → 페이로드 크기 │
+└─────────────────────────────────────┘
+   ↓
+┌─────────────────────────────────────┐
+│  Protobuf 역직렬화                    │
+│  └─ byte[] → 패킷 객체              │
+└─────────────────────────────────────┘
+   ↓
+┌─────────────────────────────────────┐
+│  타입별 분기                          │
+│  ├─ ECHO (1000) → HandleEcho()     │
+│  ├─ AUTH (1/1001) → HandleAuth()   │
+│  └─ GAME (2~8) → HandlePacket()   │
+└─────────────────────────────────────┘
+   ↓
+┌─────────────────────────────────────┐
+│  게임 로직 처리                       │
+│  └─ 채널 내 브로드캐스트               │
+└─────────────────────────────────────┘
+   ↓
+송신 (SendTo / BroadcastToChannel)
+```
+
+### 3.3 세션 관리 파이프라인
+
+```
+PendingPeers (미인증)           Sessions (인증 완료)
+Dictionary<int, NetPeer>       Dictionary<long, NetPeer>
+
+  접속 시 등록 ──────────────→  인증 성공 시 이동
+  (peerId 기반)                 (hashKey 기반)
+
+                               TokenHash (토큰 매핑)
+                               Dictionary<string, long>
+                               token → hashKey 조회
+```
+
+- **재접속 처리**: 동일 hashKey로 재접속 시 기존 Peer 강제 해제 → 새 Peer로 교체
+- **채널 유지**: 재접속 시 기존 채널 멤버십 유지 (채널 선택 스킵)
+
+### 3.4 빌드 및 배포 파이프라인
+
+```
+소스 코드
+   ↓
+dotnet build (MMOserver.sln)
+   ├─ ServerLib.csproj → ServerLib.dll
+   └─ MMOserver.csproj → MMOserver.exe
+   ↓
+Docker Build (Dockerfile)
+   ↓
+Docker Compose (compose.yaml)
+   ├─ MySQL 컨테이너
+   └─ MMOServer 컨테이너
+       └─ UDP 포트: 9050, 9500
+```
+
+---
+
+## 4. 버그 및 잠재적 이슈
+
+> 코드 정적 분석을 통해 발견된 버그 및 잠재적 문제점 목록입니다.
+
+### 4.1 버그 목록
+
+#### [B1] Engine Vector3 타입 불일치 (HIGH)
+
+- **파일**: `MMOserver/Game/Engine/Vector3.cs` vs `MMOserver/Packet/PacketBody.cs`
+- **문제**: 두 Vector3 클래스가 다른 타입으로 정의됨
+  - `Engine/Vector3.cs`: 좌표가 `int` 타입
+  - `Packet/PacketBody.cs` (PacketVector3): 좌표가 `float` 타입
+- **영향**: 실제 코드에서는 Packet Vector3만 사용되고 Engine Vector3는 사용되지 않음. 향후 Engine Vector3를 사용하는 코드가 생기면 타입 캐스팅 오류 발생
+- **권장 조치**: Engine Vector3 제거 또는 float 기반으로 통일
+
+#### [B2] ChannelManager.AddUser() 스레드 안전성 문제 (MEDIUM)
+
+- **파일**: `MMOserver/Game/Channel/ChannelManager.cs`
+- **문제**: 비동기 인증 흐름(JWT 검증 → AddUser) 후 두 요청이 동시에 같은 userId로 `connectUsers.Add()`를 호출할 경우 `ArgumentException` 발생 가능
+  ```csharp
+  public void AddUser(int channelId, long userId, Player player)
+  {
+      connectUsers.Add(userId, channelId);  // 중복 키 시 예외 발생
+      channels[channelId].AddUser(userId, player);
+  }
+  ```
+- **영향**: 동시 재접속 시나리오에서 서버 크래시 가능성
+- **권장 조치**: `TryAdd()` 사용 또는 `lock` 추가
+
+#### [B3] PlayerId 정수 오버플로우로 인한 중복 ID (LOW)
+
+- **파일**: `MMOserver/Game/GameServer.cs`
+- **문제**: `PlayerId = (int)(hashKey & 0x7FFFFFFF)` 계산으로 서로 다른 hashKey가 동일한 PlayerId를 생성할 수 있음
+  - 예: `hashKey=1` → PlayerId=1, `hashKey=2147483649` → PlayerId=1 (동일)
+- **영향**: ID 기반 플레이어 조회 오작동
+- **권장 조치**: PlayerId로 hashKey 원본(long) 사용
+
+#### [B4] TokenHash 딕셔너리 무한 증가 (MEDIUM)
+
+- **파일**: `ServerLib/Service/ServerBase.cs`
+- **문제**: 토큰 만료 또는 로그아웃 시 `tokenHash` 딕셔너리에서 항목이 제거되지 않음. 장기 운영 시 모든 누적 토큰이 메모리에 남음
+- **영향**: 장기 운영 서버에서 메모리 누수 (ex. 100만 로그인 이후 100만 항목 유지)
+- **권장 조치**: 로그아웃/연결 해제 시 `tokenHash.Remove()` 호출, 또는 TTL 기반 만료 캐시 도입
+
+#### [B5] 패킷 역직렬화 크기 검증 없음 (MEDIUM)
+
+- **파일**: `ServerLib/Service/ServerBase.cs`
+- **문제**: 패킷 페이로드가 `null`인지는 확인하지만, 역직렬화된 객체의 필드 크기는 검증하지 않음
+- **영향**: 악의적으로 구성된 패킷(예: PlayerInfo 리스트 내 수만 개의 항목)이 메모리 과소비 유발 가능
+- **권장 조치**: 역직렬화 전 페이로드 바이트 크기 상한 검증 추가
+
+#### [B6] Echo 패킷에 레이트 리미팅 미적용 (MEDIUM)
+
+- **파일**: `MMOserver/Game/GameServer.cs`
+- **문제**: Echo 패킷 처리 경로가 세션 인증 및 레이트 리미팅 검사를 우회함
+- **영향**: 인증 전 클라이언트가 Echo 패킷을 무제한으로 전송하여 서버 자원 소모 가능 (DoS)
+- **권장 조치**: Echo 처리 경로에도 레이트 리미팅 적용
+
+---
+
+## 5. 최적화 미비점
+
+### 5.1 성능 병목
+
+#### ~~[O1] BroadcastToChannel 내 반복적 딕셔너리 조회~~ ✅ 해결됨
+
+- **해결**: `Channel`에 `Dictionary<long, NetPeer> connectPeers` 추가, `BroadcastToChannel`이 `GetConnectPeers()`를 직접 순회하도록 변경
+- **변경 파일**: `Channel.cs`, `ChannelManager.cs`, `GameServer.cs`
+- **효과**: 100명 채널 브로드캐스트 시 `sessions` 딕셔너리 교차 조회 100회 → 0회 제거
+- **추가 처리**: 재연결(WiFi→LTE) 시 `Channel.UpdatePeer()`로 peer 참조 갱신
+
+#### [O2] Transform 패킷 객체 풀링 미구현
+
+- **파일**: `ServerLib/Packet/PacketSerializer.cs`
+- **문제**: 매 패킷마다 새 객체 생성 및 Protobuf 리플렉션 수행. Transform 패킷은 초당 수백~수천 회 발생하는 고빈도 패킷
+- **권장 조치**: `ObjectPool<T>` 도입으로 GC 압박 감소
+
+#### [O3] Dictionary 열거 시 Enumerator 힙 할당
+
+- **현황**: 모든 열거 메서드(`GetConnectUsers`, `GetPlayers`, `GetConnectPeers`)를 `IEnumerable<T>`로 통일
+- **판단 근거**: 박싱 비용(수 나노초)이 실질적으로 무시 가능한 수준이며, `IEnumerable<T>`가 가독성과 인터페이스 일관성 면에서 유리
+- **미적용 사유**: 가독성 > 마이크로 최적화 우선
+
+#### [O4] 레이트 리미터 고정 윈도우 방식
+
+- **파일**: `ServerLib/Service/Session.cs`
+- **문제**: 현재 고정 윈도우(Fixed Window) 방식 사용. 윈도우 경계에서 최대 2배 패킷 폭주 허용 가능
+  - 예: 윈도우 끝 120개 + 새 윈도우 시작 120개 = 240개/초 순간 처리
+- **권장 조치**: 슬라이딩 윈도우 또는 토큰 버킷 알고리즘으로 교체
+
+#### [O5] 로깅 문자열 할당
+
+- **현황**: 모든 패킷 처리마다 Serilog 메시지 템플릿 평가 발생
+- **권장 조치**: `if (Log.IsEnabled(LogEventLevel.Debug))` 가드 추가로 Debug 레벨 불필요한 평가 방지
+
+---
+
+## 6. 문제점 - 해결
+
+### 6.1 해결된 문제
+
+#### [P1] 이동 패킷 재전송 문제
+- **문제**: 이동(Transform) 패킷이 `ReliableOrdered`로 전송되어 패킷 손실 시 재전송 발생 → 위치 동기화 지연, Head-of-Line 블로킹
+- **해결**: 이동 패킷을 `Unreliable` 전송으로 변경 (`commit: 42f0ef1`)
+- **효과**: 실시간성 향상, 네트워크 지연 최소화 (오래된 위치 데이터는 폐기)
+
+#### [P2] 로그인 인증 실패 시 재시도 부재
+- **문제**: JWT 토큰 검증 API 호출이 일시적 네트워크 오류로 실패 시 즉시 인증 실패 처리
+- **해결**: 3회 재시도 로직 추가 (1초 간격), 401 응답은 즉시 실패 (`commit: c8ce36a`)
+- **효과**: 일시적 API 장애에 대한 내결함성 확보
+
+#### [P3] 토큰 → HashKey 매핑 구조
+- **문제**: 토큰과 hashKey 간의 매핑이 명확하지 않아 재접속/중복 접속 처리 어려움
+- **해결**: `TokenHash` 딕셔너리 도입, 토큰 관리 로직 구조화 (`commit: bfa3394`)
+- **효과**: 동일 토큰 재접속 시 기존 세션 정리 및 hashKey 재활용
+
+#### [P4] 에코 클라이언트 수신 버그
+- **문제**: 에코 테스트 클라이언트에서 수신 패킷 처리 오류
+- **해결**: 수신 로직 버그 수정 (`commit: 18fd8a0`)
+
+#### [P5] 서버 크래시 시 디버깅 정보 부족
+- **문제**: 서버 비정상 종료 시 원인 파악 불가
+- **해결**: `CrashDumpHandler` 구현 (`commit: 2be1302`)
+  - Debug 빌드: `.log` 파일 (스택 트레이스)
+  - Release 빌드: `.log` + `.dmp` 파일 (힙 덤프)
+  - UnhandledException, UnobservedTaskException 모두 캡처
+- **효과**: 프로덕션 환경 크래시 사후 분석 가능
+
+#### [P6] 패킷 레이트 리미팅 부재
+- **문제**: 클라이언트의 패킷 전송 빈도 제한 없음 → 패킷 플러딩 공격에 취약
+- **해결**: `Session` 클래스에 슬라이딩 윈도우 방식 레이트 리미터 구현
+  - 초당 최대 120 패킷 허용 (`MaxPacketsPerSecond`)
+  - 초과 시 해당 패킷 드롭 + 경고 로그
+  - 3회 연속 초과 시 강제 연결 해제
+  - `ServerBase.OnNetworkReceive()`에서 인증된 패킷 처리 전 체크
+- **적용 파일**: `Session.cs`, `ServerBase.cs`
+- **효과**: 악의적 패킷 플러딩 방어, 서버 안정성 향상
+
+#### [P7] 부하 테스트 도구 부재
+- **문제**: 대규모 동시접속 시나리오 검증 도구 없음, 기존 더미 클라이언트는 10명 고정
+- **해결**: `StressTest` 모듈 신규 구현 (`ClientTester/EchoClientTester/StressTest/`)
+  - `StressTestClient.cs`: 이동 + Echo RTT 동시 측정 클라이언트
+  - `StressTestService.cs`: 점진적 Ramp-up, 퍼센타일 레이턴시(P50/P95/P99), CSV 내보내기
+  - `Program.cs`: CLI 인자 지원 (`stress -c 100 -d 60 --ip ...`) + 대화형 모드 3번 메뉴
+- **효과**: N명 동시접속 시나리오 자동 검증, 성능 병목 지점 파악
+
+### 6.2 현재 남아 있는 문제
+
+#### [I1] 서버 사이드 위치 검증 미구현
+- **현상**: 클라이언트가 전송하는 위치를 서버에서 검증하지 않음
+- **영향**: 스피드핵, 텔레포트 등 치트 방어 불가
+- **권장**: `MapBounds` 로직을 서버 사이드에 적용, 비정상 이동 감지 시 보정
+
+#### [I2] 플레이어 데이터 DB 연동 미완성
+- **현상**: 플레이어 데이터가 하드코딩된 기본값 사용 (GameServer.cs 내 TODO 주석 존재)
+- **영향**: 캐릭터 정보 저장/불러오기 불가, 레벨·닉네임·HP/MP 등 지속성 없음
+- **권장**: Player 모델 DB 테이블 생성, 로그인 시 DB 조회
+
+#### [I3] NPC / 파티 시스템 미구현
+- **현상**: 패킷 코드(`TRANSFORM_NPC`, `ACTION_NPC`, `UPDATE_PARTY` 등)는 정의되어 있으나 핸들러 없음
+- **영향**: 수신 시 경고 로그만 출력되고 무시됨
+- **권장**: NPC AI 시스템, 파티 매칭 로직 순차 구현
+
+---
+
+## 7. 정리
+
+### 7.1 아키텍처 요약
+
+```
+┌──────────────────────────────────────────────────────┐
+│                    클라이언트 (Unity)                   │
+└──────────────┬───────────────────────────┬────────────┘
+               │ UDP (LiteNetLib)          │
+┌──────────────▼───────────────────────────▼────────────┐
+│                  ServerBase (네트워크 코어)              │
+│  ┌────────────┐  ┌────────────┐  ┌─────────────────┐ │
+│  │ 연결 관리    │  │ 패킷 직렬화  │  │   세션 관리      │ │
+│  └────────────┘  └────────────┘  └─────────────────┘ │
+└──────────────┬───────────────────────────┬────────────┘
+               │                           │
+┌──────────────▼───────────────┐  ┌────────▼────────────┐
+│      GameServer (게임 로직)    │  │   RestApi (인증)     │
+│  ┌─────────┐  ┌────────────┐ │  │  JWT 토큰 검증       │
+│  │ Channel  │  │  Player    │ │  │  (외부 API 호출)     │
+│  │ Manager  │  │  State     │ │  └─────────────────────┘
+│  └─────────┘  └────────────┘ │
+└──────────────┬───────────────┘
+               │
+┌──────────────▼───────────────┐
+│     RDB Layer (데이터베이스)    │
+│  Handler → Service → Repo    │
+│         → MySQL              │
+└──────────────────────────────┘
+```
+
+### 7.2 기술적 강점
+
+| 항목 | 내용 |
+|------|------|
+| UDP 기반 통신 | LiteNetLib으로 TCP 오버헤드 없이 실시간 통신 |
+| Protobuf 직렬화 | 컴팩트 바이너리 인코딩으로 대역폭 절약 |
+| 이동 패킷 Unreliable | HOL 블로킹 방지, 최신 위치만 유효 |
+| 싱글 스레드 이벤트 루프 | Lock 불필요, 동시성 이슈 최소화 |
+| 비동기 DB/API | async/await로 네트워크 루프 블로킹 방지 |
+| 크래시 덤프 | 프로덕션 환경 사후 분석 지원 |
+| 계층화된 DB 구조 | Handler-Service-Repository 패턴 |
+| Docker 배포 | 컨테이너화된 일관된 배포 환경 |
+
+### 7.3 향후 작업 (Roadmap)
+
+| 우선순위 | 작업 | 설명 |
+|---------|------|------|
+| **높음** | 플레이어 DB 연동 | 캐릭터 정보 저장/불러오기 완성 (I2) |
+| **높음** | 버그 수정 | B2 스레드 안전성, B4 메모리 누수, B6 Echo 레이트 리미팅 |
+| **높음** | 서버 사이드 위치 검증 | 치트 방어를 위한 이동 유효성 검사 (I1) |
+| **중간** | NPC 시스템 | AI 기반 NPC 이동/전투 로직 (I3) |
+| **중간** | 성능 최적화 | ~~O1 브로드캐스트 최적화 (완료)~~, O2 객체 풀링, O4 레이트 리미터 개선 |
+| **낮음** | 파티 시스템 | 파티 생성/참여/매칭 (I3) |
+| **낮음** | 모니터링 대시보드 | 서버 상태/접속자 수 실시간 모니터링 |
+
+> **완료된 항목**: 패킷 레이트 리미팅 (적용 완료), 부하 테스트 도구 (구현 완료), 크래시 덤프 (적용 완료), O1 브로드캐스트 최적화 (적용 완료)
+
+### 7.4 부하 테스트 도구 (StressTest)
+
+`ClientTester/EchoClientTester/StressTest/` 에 구현됨.
+
+#### 구성 파일
+
+| 파일 | 역할 |
+|------|------|
+| `StressTestClient.cs` | 개별 스트레스 클라이언트 (이동 + Echo RTT 동시 측정) |
+| `StressTestService.cs` | 테스트 오케스트레이터 (Ramp-up, 통계, CSV 내보내기) |
+
+#### 기능
+
+| 기능 | 설명 |
+|------|------|
+| 점진적 Ramp-up | N초 간격으로 클라이언트 추가 (서버 부하 단계적 증가) |
+| 지속시간 제한 | 테스트 자동 종료 (초 단위, 0 = 무제한) |
+| 실시간 통계 | 10초마다 접속수, 전송/수신 rate, AvgRTT 출력 |
+| 퍼센타일 레이턴시 | P50, P95, P99, Min, Max, Avg RTT 계산 |
+| 최악 클라이언트 분석 | RTT 상위 5명 상세 리포트 |
+| CSV 내보내기 | `results/stress_{N}clients_{timestamp}.csv` 자동 저장 |
+
+#### 사용법
+
+**CLI 모드:**
+```bash
+# 기본 (50명, 60초)
+dotnet run -- stress
+
+# 커스텀
+dotnet run -- stress -c 100 -d 120 --ip 192.168.0.10 --port 9500
+
+# 전체 옵션
+dotnet run -- stress \
+  -c 200          # 클라이언트 수
+  -d 60           # 테스트 시간 (초, 0=무제한)
+  -i 100          # 전송 주기 (ms)
+  -r 1000         # Ramp-up 간격 (ms)
+  -b 20           # Ramp-up 당 추가 수
+  --ip localhost  # 서버 IP
+  --port 9500     # 서버 포트
+```
+
+**대화형 모드:**
+```
+메뉴에서 3번 선택 → 클라이언트 수, 테스트 시간 입력
+```
+
+#### 출력 예시
+
+```
+╔═══════════════════════════════════════════════╗
+║           STRESS TEST 최종 리포트              ║
+╠═══════════════════════════════════════════════╣
+║ 테스트 시간 : 60.0초
+║ 클라이언트  : 98/100 접속 유지
+╠═══════════════════════════════════════════════╣
+║ [처리량]
+║   총 전송    : 118,200 패킷
+║   총 수신    : 117,850 패킷
+║   처리량     : 1,970.0 패킷/초
+╠═══════════════════════════════════════════════╣
+║ [레이턴시] (RTT 샘플: 59,100개)
+║   Min        : 0.15 ms
+║   Avg        : 1.23 ms
+║   P50        : 0.89 ms
+║   P95        : 3.45 ms
+║   P99        : 8.12 ms
+║   Max        : 25.67 ms
+╚═══════════════════════════════════════════════╝
+```
+
+### 7.5 최근 개발 이력
+
+| 커밋 | 내용 |
+|------|------|
+| `85c3276` | 세션 끊길 때 같은 채널에 퇴장 메시지 전송 |
+| `c27e846` | 채널 버그 수정 |
+| `d4c5a70` | 채널 버그 수정 |
+| `ea3f64a` | 스트레스 테스트 기능 추가 / 패킷 처리량 제한 / 프로젝트 상황 README 추가 |
+| `2be1302` | 크래시 덤프 기능 추가 (Release: 힙 덤프) |
+| `42f0ef1` | 이동 패킷 Unreliable 전송으로 변경 |
+| `bfa3394` | 토큰 → HashKey 생성 로직 구조 변경 |
+| `c8ce36a` | 로그인 실패 시 재시도 로직 추가 |
+| `18fd8a0` | 에코 클라이언트 수신 버그 수정 |
+
+---
+
+> **작성일**: 2026-03-06
+> **프로젝트 상태**: 핵심 네트워크 인프라 완성, 게임 콘텐츠 확장 단계
+>
+> **구현 완료**: 네트워크 코어, 세션 관리, 채널 시스템, 인증, 레이트 리미팅, 크래시 덤프, 부하 테스트 도구
+> **미구현**: 플레이어 DB 연동, NPC/파티 시스템, 서버 사이드 위치 검증, 전투/아이템 시스템
+> **알려진 버그**: B1 Vector3 타입 불일치, B2 ChannelManager 스레드 안전성, B4 TokenHash 메모리 누수, B6 Echo DoS 취약점

MMOTestServer/ServerLib/Packet/PacketSerializer.cs

@@ -43,7 +43,7 @@ namespace ServerLib.Packet
 
             // 헤더에 명시된 size와 실제 데이터 길이 검증
             int actualPayloadLen = data.Length - 4;
-            if (size > actualPayloadLen)
+            if (size != actualPayloadLen)
             {
                 Log.Warning("[PacketSerializer] 페이로드 크기 불일치 HeaderSize={Size} ActualSize={Actual}", size, actualPayloadLen);
                 return (0, 0, null)!;

MMOTestServer/ServerLib/Packet/PacketType.cs

@@ -6,6 +6,7 @@ namespace ServerLib.Packet;
 /// </summary>
 public enum PacketType : ushort
 {
-    Auth = 1,       // 클라 → 서버: 최초 인증 (HashKey 전달)
+    ACC_TOKEN = 1,       // 클라 → 서버: 최초 인증 (HashKey 전달)
+    DUMMY_ACC_TOKEN = 1001,
     // 1000번 이상은 게임 패킷으로 예약
 }

MMOTestServer/ServerLib/Service/ServerBase.cs

@@ -15,7 +15,7 @@ namespace ServerLib.Service;
 ///
 /// 흐름:
 ///   OnPeerConnected  → 대기 목록 등록
-///   OnNetworkReceive → Auth 패킷(type=1)이면 HashKey(8byte long) 읽어 인증
+///   OnNetworkReceive → Auth 패킷(type=1)이면 HashKey(4byte int) 읽어 인증
 ///                    → 이미 같은 HashKey 세션 있으면 이전 피어 끊고 재연결 (WiFi→LTE)
 ///                    → 그 외 패킷은 HandlePacket() 으로 전달
 ///   OnPeerDisconnected → 세션/대기 목록에서 제거
@@ -30,17 +30,37 @@ public abstract class ServerBase : INetEventListener
     protected NetManager netManager = null!;
 
     // 인증 전 대기 피어  (peer.Id → NetPeer)
-    private readonly Dictionary<int, NetPeer> pendingPeers = new();
+    protected readonly Dictionary<int, NetPeer> pendingPeers = new();
 
     // 인증된 세션      (hashKey → NetPeer)  재연결 조회용
     // peer → hashKey 역방향은 peer.Tag as Session 으로 대체
-    private readonly Dictionary<long, NetPeer> sessions = new();
+    protected readonly Dictionary<int, NetPeer> sessions = new();
+
+    // Token / HashKey 관리
+    protected readonly Dictionary<string, int> tokenHash = new();
+
+    // 재사용 NetDataWriter (단일 스레드 폴링이므로 안전)
+    private readonly NetDataWriter cachedWriter = new();
+
+    // async 메서드(HandleAuth 등)의 await 이후 공유 자원 접근 보호용
+    protected readonly object sessionLock = new();
 
     // 핑 로그 출력 여부
-    public bool PingLogRtt { get; set; }
+    public bool PingLogRtt
+    {
+        get;
+        set;
+    }
 
-    public int Port { get; }
-    public string ConnectionString { get; }
+    public int Port
+    {
+        get;
+    }
+
+    public string ConnectionString
+    {
+        get;
+    }
 
     private volatile bool isListening = false;
 
@@ -71,6 +91,7 @@ public abstract class ServerBase : INetEventListener
             netManager.PollEvents();
             await Task.Delay(1);
         }
+
         netManager.Stop();
         Log.Information("[Server] 종료 Port={Port}", Port);
     }
@@ -100,19 +121,29 @@ public abstract class ServerBase : INetEventListener
     // 클라이언트가 연결 해제됐을 때 (타임아웃, 명시적 끊기 등)
     public void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
     {
-        pendingPeers.Remove(peer.Id);
-
-        if (peer.Tag is Session session)
+        lock (sessionLock)
         {
-            // 현재 인증된 피어가 이 peer일 때만 세션 제거
-            // (재연결로 이미 교체된 경우엔 건드리지 않음)
-            if (sessions.TryGetValue(session.HashKey, out NetPeer? current) && current.Id == peer.Id)
+            pendingPeers.Remove(peer.Id);
+
+            if (peer.Tag is Session session)
             {
-                sessions.Remove(session.HashKey);
-                Log.Information("[Server] 세션 해제 HashKey={Key} Reason={Reason}", session.HashKey, disconnectInfo.Reason);
-                OnSessionDisconnected(peer, session.HashKey, disconnectInfo);
+                // 현재 인증된 피어가 이 peer일 때만 세션 제거
+                // (재연결로 이미 교체된 경우엔 건드리지 않음)
+                if (sessions.TryGetValue(session.HashKey, out NetPeer? current) && current.Id == peer.Id)
+                {
+                    // 더미 클라 아니면 token관리
+                    if (!string.IsNullOrEmpty(session.Token))
+                    {
+                        tokenHash.Remove(session.Token);
+                    }
+
+                    sessions.Remove(session.HashKey);
+                    Log.Information("[Server] 세션 해제 HashKey={Key} Reason={Reason}", session.HashKey, disconnectInfo.Reason);
+                    OnSessionDisconnected(peer, session.HashKey, disconnectInfo);
+                }
+
+                peer.Tag = null;
             }
-            peer.Tag = null;
         }
     }
 
@@ -133,16 +164,25 @@ public abstract class ServerBase : INetEventListener
             }
 
             // 0이라면 에코 서버 테스트용 따로 처리
-            if (type == 0)
+            if (type == 1000)
             {
                 HandleEcho(peer, data);
                 return;
             }
 
             // Auth 패킷은 베이스에서 처리 (raw 8-byte long, protobuf 불필요)
-            if (type == (ushort)PacketType.Auth)
+            if (type == (ushort)PacketType.ACC_TOKEN)
             {
-                HandleAuth(peer, payload);
+                _ = HandleAuth(peer, payload).ContinueWith(t =>
+                {
+                    if (t.IsFaulted)
+                        Log.Error(t.Exception, "[Server] HandleAuth 예외 PeerId={Id}", peer.Id);
+                }, TaskContinuationOptions.OnlyOnFaulted);
+                return;
+            }
+            else if (type == (ushort)PacketType.DUMMY_ACC_TOKEN)
+            {
+                HandleAuthDummy(peer, payload);
                 return;
             }
 
@@ -154,6 +194,22 @@ public abstract class ServerBase : INetEventListener
                 return;
             }
 
+            // 패킷 레이트 리미팅 체크
+            if (session.CheckRateLimit())
+            {
+                // 3회 연속 초과 시 강제 연결 해제
+                if (session.RateLimitViolations >= 3)
+                {
+                    Log.Warning("[Server] 레이트 리밋 초과 강제 해제 HashKey={Key} PeerId={Id}", session.HashKey, peer.Id);
+                    peer.Disconnect();
+                    return;
+                }
+
+                Log.Warning("[Server] 레이트 리밋 초과 ({Count}회) HashKey={Key} PeerId={Id}", session.RateLimitViolations, session.HashKey,
+                    peer.Id);
+                return; // 패킷 드롭
+            }
+
             HandlePacket(peer, session.HashKey, type, payload);
         }
         catch (Exception ex)
@@ -186,58 +242,18 @@ public abstract class ServerBase : INetEventListener
 
     // Echo 서버 테스트
 
-    private void HandleEcho(NetPeer peer, byte[] payload)
-    {
-        if (payload.Length < 4)
-        {
-            Log.Warning("[Server] Echo 페이로드 크기 오류 PeerId={Id} Length={Len}", peer.Id, payload.Length);
-            return;
-        }
+    protected abstract void HandleEcho(NetPeer peer, byte[] payload);
 
-        // 세션에 넣지는 않는다.
-        NetDataReader reader = new NetDataReader(payload);
-        short code = reader.GetShort();
-        short bodyLength = reader.GetShort();
-        Log.Debug("[Echo] : addr={Addr}, str={Str}", peer.Address, reader.GetString());
-        // Echo메시지는 순서보장 안함 HOL Blocking 제거
-        SendTo(peer, payload, DeliveryMethod.ReliableUnordered);
-    }
+    // ─── Auth 처리 (더미) ────────────────────────────────────────────────
 
-    // ─── Auth 처리 (내부) ────────────────────────────────────────────────
+    protected abstract void HandleAuthDummy(NetPeer peer, byte[] payload);
 
-    private void HandleAuth(NetPeer peer, byte[] payload)
-    {
-        if (payload.Length < sizeof(long))
-        {
-            Log.Warning("[Server] Auth 페이로드 크기 오류 PeerId={Id} Length={Len}", peer.Id, payload.Length);
-            peer.Disconnect();
-            return;
-        }
+    // ─── Auth 처리 ────────────────────────────────────────────────
 
-        long hashKey = BitConverter.ToInt64(payload, 0);
-
-        if (sessions.TryGetValue(hashKey, out NetPeer? existing))
-        {
-            // WiFi → LTE 전환 등 재연결: 이전 피어 교체
-            existing.Tag = null;
-            sessions.Remove(hashKey);
-            Log.Information("[Server] 재연결 HashKey={Key} Old={Old} New={New}", hashKey, existing.Id, peer.Id);
-            existing.Disconnect();
-        }
-
-        peer.Tag = new Session(hashKey, peer);
-        sessions[hashKey] = peer;
-        pendingPeers.Remove(peer.Id);
-
-        Log.Information("[Server] 인증 완료 HashKey={Key} PeerId={Id}", hashKey, peer.Id);
-        OnSessionConnected(peer, hashKey);
-    }
+    protected abstract Task HandleAuth(NetPeer peer, byte[] payload);
 
     // ─── 전송 헬퍼 ───────────────────────────────────────────────────────
 
-    // 재사용 NetDataWriter (단일 스레드 폴링이므로 안전)
-    private readonly NetDataWriter cachedWriter = new();
-
     // peer에게 전송
     protected void SendTo(NetPeer peer, byte[] data, DeliveryMethod method = DeliveryMethod.ReliableOrdered)
     {
@@ -265,11 +281,11 @@ public abstract class ServerBase : INetEventListener
     // ─── 서브클래스 구현 ─────────────────────────────────────────────────
 
     // 인증(Auth) 완료 후 호출
-    protected abstract void OnSessionConnected(NetPeer peer, long hashKey);
+    protected abstract void OnSessionConnected(NetPeer peer, int hashKey);
 
     // 세션 정상 해제 시 호출 (재연결 교체 시에는 호출되지 않음)
-    protected abstract void OnSessionDisconnected(NetPeer peer, long hashKey, DisconnectInfo info);
+    protected abstract void OnSessionDisconnected(NetPeer peer, int hashKey, DisconnectInfo info);
 
     // 인증된 피어의 게임 패킷 수신 / payload는 헤더 제거된 raw bytes → 실행 프로젝트에서 protobuf 역직렬화
-    protected abstract void HandlePacket(NetPeer peer, long hashKey, ushort type, byte[] payload);
+    protected abstract void HandlePacket(NetPeer peer, int hashKey, ushort type, byte[] payload);
 }

MMOTestServer/ServerLib/Service/Session.cs

@@ -4,12 +4,77 @@ namespace ServerLib.Service;
 
 public class Session
 {
-    public long HashKey { get; init; }
-    public NetPeer Peer  { get; set; }
+    public string? Token
+    {
+        get;
+        set;
+    }
 
-    public Session(long hashKey, NetPeer peer)
+    public string? Username
+    {
+        get;
+        set;
+    }
+
+    public int HashKey
+    {
+        get;
+        init;
+    }
+
+    public NetPeer Peer
+    {
+        get;
+        set;
+    }
+
+    // 패킷 레이트 리미팅
+    private int packetCount;
+    private long windowStartTicks;
+
+    // 초당 허용 패킷 수
+    public int MaxPacketsPerSecond { get; set; }
+
+    // 연속 초과 횟수
+    public int RateLimitViolations { get; private set; }
+
+    // 패킷 수신 시 호출. 초당 제한 초과 시 true 반환.
+    public bool CheckRateLimit()
+    {
+        long now = Environment.TickCount64;
+
+        // 1초(1000ms) 윈도우 초과 시 리셋
+        if (now - windowStartTicks >= 1000)
+        {
+            windowStartTicks = now;
+            packetCount = 0;
+        }
+
+        packetCount++;
+
+        if (packetCount > MaxPacketsPerSecond)
+        {
+            RateLimitViolations++;
+            return true; // 제한 초과
+        }
+
+        return false;
+    }
+
+    // 위반 카운트 초기화
+    public void ResetViolations()
+    {
+        RateLimitViolations = 0;
+    }
+
+    public Session(int hashKey, NetPeer peer, int maxPacketsPerSecond = 60)
     {
         HashKey = hashKey;
-        Peer    = peer;
+        Peer = peer;
+        Token = null;
+        MaxPacketsPerSecond = maxPacketsPerSecond;
+        packetCount = 0;
+        windowStartTicks = Environment.TickCount64;
+        RateLimitViolations = 0;
     }
 }

MMOTestServer/ServerLib/Utils/CrashDumpHandler.cs

@@ -0,0 +1,145 @@
+using System.Runtime.InteropServices;
+using System.Text;
+using Serilog;
+
+namespace ServerLib.Utils;
+
+/// <summary>
+///     크래시 핸들러 (Windows / Linux 공통)
+///     Register() 를 Program.cs 최상단에서 한 번 호출.
+///
+///     덤프 생성은 CLR 환경변수로 처리 (스택 언와인드 전에 찍힘):
+///       DOTNET_DbgEnableMiniDump=1
+///       DOTNET_DbgMiniDumpType=4
+///       DOTNET_DbgMiniDumpName=crashes/crash_%p_%t.dmp
+///
+///     생성 파일 (crashes/ 폴더):
+///       crash_YYYY-MM-DD_HH-mm-ss.log  ← 항상 생성
+///       crash_%p_%t.dmp                ← CLR이 직접 생성 (정확한 크래시 위치)
+/// </summary>
+public static class CrashDumpHandler
+{
+    private const string CRASH_DIR = "crashes";
+    private static int registered;
+
+    public static void Register()
+    {
+        // 중복 등록 방지
+        if (Interlocked.Exchange(ref registered, 1) != 0)
+        {
+            return;
+        }
+
+        AppDomain.CurrentDomain.UnhandledException += OnUnhandledException;
+        TaskScheduler.UnobservedTaskException      += OnUnobservedTaskException;
+
+        Log.Information("[CrashDump] 핸들러 등록 완료 (CrashDir={Dir})", Path.GetFullPath(CRASH_DIR));
+    }
+
+    // ─── 핸들러 ──────────────────────────────────────────────────────────
+
+    private static void OnUnhandledException(object sender, UnhandledExceptionEventArgs e)
+    {
+        Exception? ex = e.ExceptionObject as Exception;
+        string tag = $"[CrashDump] UnhandledException (IsTerminating={e.IsTerminating})";
+        WriteCrash(tag, ex);
+    }
+
+    private static void OnUnobservedTaskException(object? sender, UnobservedTaskExceptionEventArgs e)
+    {
+        e.SetObserved(); // 프로세스 종료 방지
+        string tag = "[CrashDump] UnobservedTaskException";
+        WriteCrash(tag, e.Exception);
+    }
+
+    // ─── 핵심 처리 ───────────────────────────────────────────────────────
+
+    private static void WriteCrash(string tag, Exception? ex)
+    {
+        try
+        {
+            Directory.CreateDirectory(CRASH_DIR);
+
+            string timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
+            string logPath = Path.Combine(CRASH_DIR, $"crash_{timestamp}.log");
+
+            WriteCrashLog(logPath, ex);
+            Log.Fatal("{Tag} → {Log}", tag, logPath);
+        }
+        catch (Exception writeEx)
+        {
+            Log.Error(writeEx, "[CrashDump] 로그 저장 실패");
+        }
+        finally
+        {
+            Log.CloseAndFlush();
+        }
+    }
+
+    private static void WriteCrashLog(string path, Exception? ex)
+    {
+        StringBuilder sb = new();
+        sb.AppendLine("═══════════════════════════════════════════════════");
+        sb.AppendLine($"  CRASH REPORT  {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
+        sb.AppendLine("═══════════════════════════════════════════════════");
+        sb.AppendLine();
+
+        sb.AppendLine("[Environment]");
+        sb.AppendLine($"  OS         : {RuntimeInformation.OSDescription}");
+        sb.AppendLine($"  Runtime    : {RuntimeInformation.FrameworkDescription}");
+        sb.AppendLine($"  PID        : {Environment.ProcessId}");
+        sb.AppendLine($"  WorkDir    : {Environment.CurrentDirectory}");
+        sb.AppendLine($"  MachineName: {Environment.MachineName}");
+        sb.AppendLine();
+
+        sb.AppendLine("[Thread]");
+        sb.AppendLine($"  ThreadId : {Environment.CurrentManagedThreadId}");
+        sb.AppendLine();
+
+        sb.AppendLine("[Exception]");
+        if (ex is null)
+        {
+            sb.AppendLine("  (예외 객체 없음)");
+        }
+        else
+        {
+            AppendException(sb, ex, 0);
+        }
+
+        File.WriteAllText(path, sb.ToString(), Encoding.UTF8);
+    }
+
+    private static void AppendException(StringBuilder sb, Exception ex, int depth)
+    {
+        string indent = new(' ', depth * 2);
+        sb.AppendLine($"{indent}  Type    : {ex.GetType().FullName}");
+        sb.AppendLine($"{indent}  Message : {ex.Message}");
+        sb.AppendLine($"{indent}  Source  : {ex.Source}");
+        sb.AppendLine();
+        sb.AppendLine($"{indent}  StackTrace:");
+
+        if (ex.StackTrace is not null)
+        {
+            foreach (string line in ex.StackTrace.Split('\n'))
+            {
+                sb.AppendLine($"{indent}    {line.TrimEnd()}");
+            }
+        }
+
+        if (ex is AggregateException agg)
+        {
+            foreach (Exception inner in agg.InnerExceptions)
+            {
+                sb.AppendLine();
+                sb.AppendLine($"{indent}  [InnerException]");
+                AppendException(sb, inner, depth + 1);
+            }
+        }
+        else if (ex.InnerException is not null)
+        {
+            sb.AppendLine();
+            sb.AppendLine($"{indent}  [InnerException]");
+            AppendException(sb, ex.InnerException, depth + 1);
+        }
+    }
+}

MMOTestServer/compose.yaml

@@ -7,4 +7,20 @@
     ports:
       - "9050:9050/udp"   # LiteNetLib UDP 포트
       - "9500:9500/udp"   # LiteNetLib UDP 포트
+      - "40001:9500/udp"   # LiteNetLib UDP 포트
+      - "40002:9500/udp"   # LiteNetLib UDP 포트
+      - "40003:9500/udp"   # LiteNetLib UDP 포트
+      - "40004:9500/udp"   # LiteNetLib UDP 포트
+      - "40005:9500/udp"   # LiteNetLib UDP 포트
+      - "40006:9500/udp"   # LiteNetLib UDP 포트
+      - "40007:9500/udp"   # LiteNetLib UDP 포트
+      - "40008:9500/udp"   # LiteNetLib UDP 포트
+      - "40009:9500/udp"   # LiteNetLib UDP 포트
+      - "40100:9500/udp"   # LiteNetLib UDP 포트
+    environment:
+      - DOTNET_DbgEnableMiniDump=1      # 크래시 시 덤프 자동 생성
+      - DOTNET_DbgMiniDumpType=4        # 4 = Full dump
+      - DOTNET_DbgMiniDumpName=/app/crashes/crash_%p_%t.dmp
+    volumes:
+      - ./crashes:/app/crashes          # 덤프/로그 로컬 마운트
     restart: unless-stopped