fix : 수정후 리드미 정리

feat : 채널 매니저(각 채널, 유저 관리) 구현 / 유저 정보 구현 / 패킷 이동 채널 접속 구현
2026-03-03 17:43:32 +09:00 · 2026-03-03 17:43:07 +09:00
11 changed files with 748 additions and 831 deletions
--- a/ANALYSIS.md
+++ b/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` 무한 증가 방지 - 오래된 항목 자동 정리 |
--- a/MMORPG_ARCHITECTURE_ANALYSIS.md
+++ b/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 테이블 한계가 있다.
--- a/MMOTestServer/MMOserver/Game/Channel/Channel.cs
+++ b/MMOTestServer/MMOserver/Game/Channel/Channel.cs
@@ -0,0 +1,82 @@
+using MMOserver.Game.Channel.Maps;
+
+namespace MMOserver.Game.Channel;
+
+public class Channel
+{
+    // 로비
+    private Robby robby = new Robby();
+
+    // 채널 내 유저 상태 (hashKey → Player)
+    private Dictionary<long, Player> connectUsers = new Dictionary<long, Player>();
+
+    public int ChannelId
+    {
+        get;
+        private set;
+    }
+
+    public int UserCount
+    {
+        get;
+        private set;
+    }
+
+    public int UserCountMax
+    {
+        get;
+        private set;
+    } = 100;
+
+    public Channel(int channelId)
+    {
+        ChannelId = channelId;
+    }
+
+    public void AddUser(long userId, Player player)
+    {
+        connectUsers[userId] = player;
+        UserCount++;
+    }
+
+    public void RemoveUser(long userId)
+    {
+        connectUsers.Remove(userId);
+        UserCount--;
+    }
+
+    // 채널 내 모든 유저의 hashKey 반환
+    public IEnumerable<long> GetConnectUsers()
+    {
+        return connectUsers.Keys;
+    }
+
+    // 채널 내 모든 Player 반환
+    public IEnumerable<Player> GetPlayers()
+    {
+        return connectUsers.Values;
+    }
+
+    // 특정 유저의 Player 반환
+    public Player? GetPlayer(long userId)
+    {
+        connectUsers.TryGetValue(userId, out Player? player);
+        return player;
+    }
+
+    public int HasUser(long userId)
+    {
+        if (connectUsers.ContainsKey(userId))
+        {
+            return ChannelId;
+        }
+
+        return -1;
+    }
+
+    // 로비 가져옴
+    public Robby GetRobby()
+    {
+        return robby;
+    }
+}
--- a/MMOTestServer/MMOserver/Game/Channel/ChannelManager.cs
+++ b/MMOTestServer/MMOserver/Game/Channel/ChannelManager.cs
@@ -0,0 +1,84 @@
+namespace MMOserver.Game.Channel;
+
+public class ChannelManager
+{
+    // 일단은 채널은 서버 켤때 고정으로간다 1개
+    public static ChannelManager Instance
+    {
+        get;
+    } = new ChannelManager();
+
+    // 채널 관리
+    private List<Channel> channels = new List<Channel>();
+
+    // 채널별 유저 관리 (유저 key, 채널 val)
+    private Dictionary<long, int> connectUsers = new Dictionary<long, int>();
+
+    public ChannelManager()
+    {
+        Initializer();
+    }
+
+    public void Initializer(int channelSize = 1)
+    {
+        for (int i = 0; i < channelSize; i++)
+        {
+            channels.Add(new Channel(i));
+        }
+    }
+
+    public Channel GetChannel(int channelId)
+    {
+        return channels[channelId];
+    }
+
+    public List<Channel> GetChannels()
+    {
+        return channels;
+    }
+
+    public void AddUser(int channelId, long userId, Player player)
+    {
+        // 유저 추가
+        connectUsers[userId] = channelId;
+        // 채널에 유저 추가
+        channels[channelId].AddUser(userId, player);
+    }
+
+    public bool RemoveUser(long userId)
+    {
+        // 채널 있으면
+        int channelId = connectUsers[userId];
+
+        // 날린다.
+        if (channelId >= 0)
+        {
+            channels[channelId].RemoveUser(userId);
+            connectUsers.Remove(userId);
+            return true;
+        }
+
+        return false;
+    }
+
+    public int HasUser(long userId)
+    {
+        int channelId = -1;
+        if (connectUsers.ContainsKey(userId))
+        {
+            channelId = connectUsers[userId];
+        }
+
+        if (channelId != -1)
+        {
+            return channels[channelId].HasUser(userId);
+        }
+
+        return channelId;
+    }
+
+    public Dictionary<long, int> GetConnectUsers()
+    {
+        return connectUsers;
+    }
+}
--- a/MMOTestServer/MMOserver/Game/Channel/Maps/Robby.cs
+++ b/MMOTestServer/MMOserver/Game/Channel/Maps/Robby.cs
@@ -0,0 +1,17 @@
+using MMOserver.Game.Engine;
+
+namespace MMOserver.Game.Channel.Maps;
+
+public class Robby
+{
+    // 마을 시작 지점 넣어 둔다.
+    public static Vector3 StartPosition
+    {
+        get;
+        set;
+    } = new Vector3(0, 0, 0);
+
+    public Robby()
+    {
+    }
+}
--- a/MMOTestServer/MMOserver/Game/Engine/Vector3.cs
+++ b/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;
+    }
+}
--- a/MMOTestServer/MMOserver/Game/GameServer.cs
+++ b/MMOTestServer/MMOserver/Game/GameServer.cs
@@ -1,28 +1,300 @@
-using LiteNetLib;
+using LiteNetLib;
+using MMOserver.Game.Channel;
+using MMOserver.Packet;
+using ProtoBuf;
 using Serilog;
+using ServerLib.Packet;
 using ServerLib.Service;

 namespace MMOserver.Game;

 public class GameServer : ServerBase
 {
+    private readonly Dictionary<ushort, Action<NetPeer, long, byte[]>> _packetHandlers;
+
    public GameServer(int port, string connectionString) : base(port, connectionString)
    {
-
+        _packetHandlers = new Dictionary<ushort, Action<NetPeer, long, byte[]>>
+        {
+            [(ushort)PacketCode.INTO_CHANNEL] = OnIntoChannel,
+            [(ushort)PacketCode.EXIT_CHANNEL] = OnExitChannel,
+            [(ushort)PacketCode.TRANSFORM_PLAYER] = OnTransformPlayer,
+            [(ushort)PacketCode.ACTION_PLAYER] = OnActionPlayer,
+            [(ushort)PacketCode.STATE_PLAYER] = OnStatePlayer,
+        };
    }

    protected override void OnSessionConnected(NetPeer peer, long hashKey)
    {
        Log.Information("[GameServer] 세션 연결 HashKey={Key} PeerId={Id}", hashKey, peer.Id);
+
+        // 만약 wifi-lte 로 바꿔졌다 이때 이미 로비에 들어가 있다면 넘긴다.
+        ChannelManager cm = ChannelManager.Instance;
+        int channelId = cm.HasUser(hashKey);
+
+        if (channelId >= 0)
+        {
+            // 재연결: 채널 유저 목록 전송 (채널 선택 스킵, 바로 마을로)
+            SendIntoChannelPacket(peer, hashKey);
+        }
+        else
+        {
+            // 모든 채널 정보 던진다
+            SendLoadChannelPacket(peer, hashKey);
+        }
    }

    protected override void OnSessionDisconnected(NetPeer peer, long hashKey, DisconnectInfo info)
    {
-        Log.Information("[GameServer] 세션 해제 HashKey={Key} Reason={Reason}", hashKey, info.Reason);
+        ChannelManager cm = ChannelManager.Instance;
+        if (cm.RemoveUser(hashKey))
+        {
+            Log.Information("[GameServer] 세션 해제 HashKey={Key} Reason={Reason}", hashKey, info.Reason);
+        }
    }

    protected override void HandlePacket(NetPeer peer, long hashKey, ushort type, byte[] payload)
    {
-        Log.Debug("[GameServer] 패킷 수신 HashKey={Key} Type={Type} Size={Size}", hashKey, type, payload.Length);
+        if (_packetHandlers.TryGetValue(type, out Action<NetPeer, long, byte[]>? handler))
+        {
+            handler(peer, hashKey, payload);
+        }
+        else
+        {
+            Log.Warning("[GameServer] 알 수 없는 패킷 Type={Type}", type);
+        }
+    }
+
+    // ============================================================
+    // 보내는 패킷
+    // ============================================================
+
+    private void SendLoadChannelPacket(NetPeer peer, long hashKey)
+    {
+        LoadChannelPacket loadChannelPacket = new LoadChannelPacket();
+        foreach (Channel.Channel channel in ChannelManager.Instance.GetChannels())
+        {
+            ChannelInfo info = new ChannelInfo();
+            info.ChannelId = channel.ChannelId;
+            info.ChannelUserConut = channel.UserCount;
+            info.ChannelUserMax = channel.UserCountMax;
+            loadChannelPacket.Channels.Add(info);
+        }
+
+        byte[] data = PacketSerializer.Serialize<LoadChannelPacket>((ushort)PacketCode.LOAD_CHANNEL, loadChannelPacket);
+        SendTo(peer, data);
+    }
+
+    // 나간 유저를 같은 채널 유저들에게 알림 (UPDATE_CHANNEL_USER IsAdd=false)
+    private void SendExitChannelPacket(NetPeer peer, long hashKey, int channelId, Player player)
+    {
+        UpdateChannelUserPacket packet = new UpdateChannelUserPacket
+        {
+            Players = ToPlayerInfo(player),
+            IsAdd = false
+        };
+        byte[] data = PacketSerializer.Serialize<UpdateChannelUserPacket>((ushort)PacketCode.UPDATE_CHANNEL_USER, packet);
+        // 이미 채널에서 제거된 후라 나간 본인에게는 전송되지 않음
+        BroadcastToChannel(channelId, data);
+    }
+
+    // 채널 입장 시 패킷 전송
+    //  - 새 유저에게 : 기존 채널 유저 목록 (INTO_CHANNEL)
+    //  - 기존 유저들에게 : 새 유저 입장 알림 (UPDATE_CHANNEL_USER IsAdd=true)
+    private void SendIntoChannelPacket(NetPeer peer, long hashKey)
+    {
+        ChannelManager cm = ChannelManager.Instance;
+        int channelId = cm.HasUser(hashKey);
+        if (channelId < 0)
+        {
+            return;
+        }
+
+        Channel.Channel channel = cm.GetChannel(channelId);
+        Player? myPlayer = channel.GetPlayer(hashKey);
+
+        // 1. 새 유저에게: 자신을 제외한 기존 채널 유저 목록 전송
+        IntoChannelPacket response = new IntoChannelPacket { ChannelId = channelId };
+        foreach (long userId in channel.GetConnectUsers())
+        {
+            if (userId == hashKey)
+            {
+                continue;
+            }
+
+            Player? p = channel.GetPlayer(userId);
+            if (p != null)
+            {
+                response.Players.Add(ToPlayerInfo(p));
+            }
+        }
+
+        byte[] toNewUser = PacketSerializer.Serialize<IntoChannelPacket>((ushort)PacketCode.INTO_CHANNEL, response);
+        SendTo(peer, toNewUser);
+
+        // 2. 기존 유저들에게: 새 유저 입장 알림
+        if (myPlayer != null)
+        {
+            UpdateChannelUserPacket notify = new UpdateChannelUserPacket
+            {
+                Players = ToPlayerInfo(myPlayer),
+                IsAdd = true
+            };
+            byte[] toOthers = PacketSerializer.Serialize<UpdateChannelUserPacket>((ushort)PacketCode.UPDATE_CHANNEL_USER, notify);
+            BroadcastToChannel(channelId, toOthers, peer);
+        }
+    }
+
+    // ============================================================
+    // 채널 브로드캐스트 헬퍼
+    // ============================================================
+
+    // 특정 채널의 모든 유저에게 전송 (exclude 지정 시 해당 피어 제외)
+    private void BroadcastToChannel(int channelId, byte[] data, NetPeer? exclude = null)
+    {
+        Channel.Channel channel = ChannelManager.Instance.GetChannel(channelId);
+        foreach (long userId in channel.GetConnectUsers())
+        {
+            if (!sessions.TryGetValue(userId, out NetPeer? targetPeer))
+            {
+                continue;
+            }
+
+            if (exclude != null && targetPeer.Id == exclude.Id)
+            {
+                continue;
+            }
+
+            SendTo(targetPeer, data);
+        }
+    }
+
+    // ============================================================
+    // Player ↔ PlayerInfo 변환 (패킷 전송 시에만 사용)
+    // ============================================================
+
+    private static PlayerInfo ToPlayerInfo(Player player) => new PlayerInfo
+    {
+        PlayerId = player.PlayerId,
+        Nickname = player.Nickname,
+        Level = player.Level,
+        Hp = player.Hp,
+        MaxHp = player.MaxHp,
+        Mp = player.Mp,
+        MaxMp = player.MaxMp,
+        Position = new MMOserver.Packet.Vector3 { X = player.PosX, Y = player.PosY, Z = player.PosZ },
+        RotY = player.RotY,
+    };
+
+    // ============================================================
+    // 패킷 핸들러
+    // ============================================================
+
+    private void OnIntoChannel(NetPeer peer, long hashKey, byte[] payload)
+    {
+        IntoChannelPacket packet = Serializer.Deserialize<IntoChannelPacket>(new ReadOnlyMemory<byte>(payload));
+
+        ChannelManager cm = ChannelManager.Instance;
+
+        // TODO: 실제 서비스에서는 DB/세션에서 플레이어 정보 로드 필요
+        Player newPlayer = new Player
+        {
+            HashKey = hashKey,
+            PlayerId = (int)(hashKey & 0x7FFFFFFF),
+        };
+
+        cm.AddUser(packet.ChannelId, hashKey, newPlayer);
+        Log.Debug("[GameServer] INTO_CHANNEL HashKey={Key} ChannelId={ChannelId}", hashKey, packet.ChannelId);
+
+        // 접속된 모든 유저 정보 전달
+        SendIntoChannelPacket(peer, hashKey);
+    }
+
+    private void OnExitChannel(NetPeer peer, long hashKey, byte[] payload)
+    {
+        ExitChannelPacket packet = Serializer.Deserialize<ExitChannelPacket>(new ReadOnlyMemory<byte>(payload));
+
+        ChannelManager cm = ChannelManager.Instance;
+
+        // 제거 전에 채널/플레이어 정보 저장 (브로드캐스트에 필요)
+        int channelId = cm.HasUser(hashKey);
+        Player? player = channelId >= 0 ? cm.GetChannel(channelId).GetPlayer(hashKey) : null;
+
+        cm.RemoveUser(hashKey);
+        Log.Debug("[GameServer] EXIT_CHANNEL HashKey={Key} PlayerId={PlayerId}", hashKey, packet.PlayerId);
+
+        // 같은 채널 유저들에게 나갔다고 알림
+        if (channelId >= 0 && player != null)
+        {
+            SendExitChannelPacket(peer, hashKey, channelId, player);
+        }
+    }
+
+    private void OnTransformPlayer(NetPeer peer, long hashKey, byte[] payload)
+    {
+        TransformPlayerPacket packet = Serializer.Deserialize<TransformPlayerPacket>(new ReadOnlyMemory<byte>(payload));
+
+        ChannelManager cm = ChannelManager.Instance;
+        int channelId = cm.HasUser(hashKey);
+        if (channelId < 0)
+        {
+            return;
+        }
+
+        // 채널 내 플레이어 위치/방향 상태 갱신
+        Player? player = cm.GetChannel(channelId).GetPlayer(hashKey);
+        if (player != null)
+        {
+            player.PosX = packet.Position.X;
+            player.PosY = packet.Position.Y;
+            player.PosZ = packet.Position.Z;
+            player.RotY = packet.RotY;
+        }
+
+        // 같은 채널 유저들에게 위치/방향 브로드캐스트 (나 제외)
+        byte[] data = PacketSerializer.Serialize<TransformPlayerPacket>((ushort)PacketCode.TRANSFORM_PLAYER, packet);
+        BroadcastToChannel(channelId, data, peer);
+    }
+
+    private void OnActionPlayer(NetPeer peer, long hashKey, byte[] payload)
+    {
+        ActionPlayerPacket packet = Serializer.Deserialize<ActionPlayerPacket>(new ReadOnlyMemory<byte>(payload));
+
+        ChannelManager cm = ChannelManager.Instance;
+        int channelId = cm.HasUser(hashKey);
+        if (channelId < 0)
+        {
+            return;
+        }
+
+        // 같은 채널 유저들에게 행동 브로드캐스트 (나 제외)
+        byte[] data = PacketSerializer.Serialize<ActionPlayerPacket>((ushort)PacketCode.ACTION_PLAYER, packet);
+        BroadcastToChannel(channelId, data, peer);
+    }
+
+    private void OnStatePlayer(NetPeer peer, long hashKey, byte[] payload)
+    {
+        StatePlayerPacket packet = Serializer.Deserialize<StatePlayerPacket>(new ReadOnlyMemory<byte>(payload));
+
+        ChannelManager cm = ChannelManager.Instance;
+        int channelId = cm.HasUser(hashKey);
+        if (channelId < 0)
+        {
+            return;
+        }
+
+        // 채널 내 플레이어 HP/MP 상태 갱신
+        Player? player = cm.GetChannel(channelId).GetPlayer(hashKey);
+        if (player != null)
+        {
+            player.Hp = packet.Hp;
+            player.MaxHp = packet.MaxHp;
+            player.Mp = packet.Mp;
+            player.MaxMp = packet.MaxMp;
+        }
+
+        // 같은 채널 유저들에게 스테이트 브로드캐스트 (나 제외)
+        byte[] data = PacketSerializer.Serialize<StatePlayerPacket>((ushort)PacketCode.STATE_PLAYER, packet);
+        BroadcastToChannel(channelId, data, peer);
    }
 }
--- a/MMOTestServer/MMOserver/Game/Player.cs
+++ b/MMOTestServer/MMOserver/Game/Player.cs
@@ -0,0 +1,77 @@
+namespace MMOserver.Game;
+
+public class Player
+{
+    public long 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;
+    }
+
+    // 위치/방향 (클라이언트 패킷과 동일하게 float)
+    public float PosX
+    {
+        get;
+        set;
+    }
+
+    public float PosY
+    {
+        get;
+        set;
+    }
+
+    public float PosZ
+    {
+        get;
+        set;
+    }
+
+    public float RotY
+    {
+        get;
+        set;
+    }
+}
--- a/MMOTestServer/MMOserver/Packet/PacketBody.cs
+++ b/MMOTestServer/MMOserver/Packet/PacketBody.cs
@@ -100,24 +100,6 @@ public class PlayerInfo
    }
 }

-[ProtoContract]
-public class ItemInfo
-{
-    [ProtoMember(1)]
-    public int ItemId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public int Count
-    {
-        get;
-        set;
-    }
-}
-
 // ============================================================
 // 인증
 // ============================================================
@@ -134,7 +116,7 @@ public class RecvTokenPacket
    }
 }

-// LOAD_GAME
+// LOAD_GAME 내 정보
 [ProtoContract]
 public class LoadGamePacket
 {
@@ -151,27 +133,96 @@ public class LoadGamePacket
        get;
        set;
    }
+
+    [ProtoMember(3)]
+    public int MaplId
+    {
+        get;
+        set;
+    }
 }

 // ============================================================
 // 로비
 // ============================================================

-// INTO_LOBBY
 [ProtoContract]
-public class IntoLobbyPacket
+public class ChannelInfo
 {
    [ProtoMember(1)]
+    public int ChannelId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int ChannelUserConut
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(3)]
+    public int ChannelUserMax
+    {
+        get;
+        set;
+    }
+}
+
+[ProtoContract]
+public class LoadChannelPacket
+{
+    [ProtoMember(1)]
+    public List<ChannelInfo> Channels
+    {
+        get;
+        set;
+    } = new List<ChannelInfo>();
+}
+
+// INTO_CHANNEL 클라->서버: 입장할 채널 ID / 서버->클라: 채널 내 나 이외 플레이어 목록
+[ProtoContract]
+public class IntoChannelPacket
+{
+    [ProtoMember(1)]
+    public int ChannelId
+    {
+        get;
+        set;
+    } // 클라->서버: 입장할 채널 ID
+
+    [ProtoMember(2)]
    public List<PlayerInfo> Players
+    {
+        get;
+        set;
+    } = new List<PlayerInfo>(); // 서버->클라: 채널 내 플레이어 목록
+}
+
+// UPDATE_CHANNEL_USER 유저 접속/나감
+[ProtoContract]
+public class UpdateChannelUserPacket
+{
+    [ProtoMember(1)]
+    public PlayerInfo Players
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public bool IsAdd
    {
        get;
        set;
    }
 }

-// EXIT_LOBBY
+// EXIT_CHANNEL 나가는 유저
 [ProtoContract]
-public class ExitLobbyPacket
+public class ExitChannelPacket
 {
    [ProtoMember(1)]
    public int PlayerId
@@ -181,174 +232,6 @@ public class ExitLobbyPacket
    }
 }

-// ============================================================
-// 인스턴스 던전
-// ============================================================
-
-public enum BossState
-{
-    START,
-    END,
-    PHASE_CHANGE
-}
-
-public enum BossResult
-{
-    SUCCESS,
-    FAIL
-}
-
-// INTO_INSTANCE
-[ProtoContract]
-public class IntoInstancePacket
-{
-    [ProtoMember(1)]
-    public int InstanceId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public int BossId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
-    public List<int> PlayerIds
-    {
-        get;
-        set;
-    }
-}
-
-// UPDATE_BOSS
-[ProtoContract]
-public class UpdateBossPacket
-{
-    [ProtoMember(1)]
-    public BossState State
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public int Phase
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
-    public BossResult Result
-    {
-        get;
-        set;
-    } // END일 때만 유효
-}
-
-// REWARD_INSTANCE
-[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
-{
-    [ProtoMember(1)]
-    public int PartyId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public PartyUpdateType Type
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
-    public int LeaderId
-    {
-        get;
-        set;
-    }
-}
-
-// UPDATE_USER_PARTY
-[ProtoContract]
-public class UpdateUserPartyPacket
-{
-    [ProtoMember(1)]
-    public int PartyId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(2)]
-    public int PlayerId
-    {
-        get;
-        set;
-    }
-
-    [ProtoMember(3)]
-    public UserPartyUpdateType Type
-    {
-        get;
-        set;
-    }
-}
-
 // ============================================================
 // 플레이어
 // ============================================================
@@ -604,3 +487,71 @@ public class DamagePacket
        set;
    }
 }
+
+// ============================================================
+// 파티
+// ============================================================
+
+public enum PartyUpdateType
+{
+    CREATE,
+    DELETE
+}
+
+public enum UserPartyUpdateType
+{
+    JOIN,
+    LEAVE
+}
+
+// UPDATE_PARTY
+[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;
+    }
+}
+
+// UPDATE_USER_PARTY
+[ProtoContract]
+public class UpdateUserPartyPacket
+{
+    [ProtoMember(1)]
+    public int PartyId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(2)]
+    public int PlayerId
+    {
+        get;
+        set;
+    }
+
+    [ProtoMember(3)]
+    public UserPartyUpdateType Type
+    {
+        get;
+        set;
+    }
+}
--- a/MMOTestServer/MMOserver/Packet/PacketHeader.cs
+++ b/MMOTestServer/MMOserver/Packet/PacketHeader.cs
@@ -1,61 +1,56 @@
 namespace MMOserver.Packet;

-public enum PacketCode : short
+public enum PacketCode : ushort
 {
-    NONE,
    // 초기 클라이언트 시작시 jwt토큰 받아옴
    RECV_TOKEN,
-    // jwt토큰 검증후 게임에 들어갈지 말지 (내 데이터도 전송)
+
+    // 내 정보 로드 (서버 -> 클라)
    LOAD_GAME,

-    // 마을(로비)진입시 모든 데이터 로드
-    INTO_LOBBY,
+    // 모든 채널 로드 - jwt토큰 검증후 게임에 들어갈지 말지 (내 데이터도 전송)
+    // (서버 -> 클라)
+    LOAD_CHANNEL,

-    // 로비 나가기
-    EXIT_LOBBY,
+    // 나 채널 접속 (클라 -> 서버)
+    INTO_CHANNEL,

-    // 인스턴스 던전 입장
-    INTO_INSTANCE,
+    // 새로운 유저 채널 접속 (서버 -> 클라) / 유저 채널 나감 (서버 -> 클라)
+    UPDATE_CHANNEL_USER,

-    // 결과 보상
-    REWARD_INSTANCE,
+    // 채널 나가기 (클라 -> 서버)
+    EXIT_CHANNEL,

-    // 보스전 (시작, 종료)
-    UPDATE_BOSS,
+    // 플레이어 위치, 방향 (서버 -> 클라 \ 클라 -> 서버)
+    TRANSFORM_PLAYER,

-    // 인스턴스 던전 퇴장
-    EXIT_INSTANCE,
+    // 플레이어 행동 업데이트 (서버 -> 클라 \ 클라 -> 서버)
+    ACTION_PLAYER,
+
+    // 플레이어 스테이트 업데이트 (서버 -> 클라 \ 클라 -> 서버)
+    STATE_PLAYER,
+
+    // NPC 위치, 방향 (서버 -> 클라)
+    TRANSFORM_NPC,
+
+    // NPC 행동 업데이트 (서버 -> 클라)
+    ACTION_NPC,
+
+    // NPC 스테이트 업데이트 (서버 -> 클라)
+    STATE_NPC,
+
+    // 데미지 UI 전달 (서버 -> 클라)
+    DAMAGE,

    // 파티 (생성, 삭제)
    UPDATE_PARTY,

    // 파티 유저 업데이트(추가 삭제)
-    UPDATE_USER_PARTY,
-
-    // 플레이어 위치, 방향
-    TRANSFORM_PLAYER,
-
-    // 플레이어 행동 업데이트
-    ACTION_PLAYER,
-
-    // 플레이어 스테이트 업데이트
-    STATE_PLAYER,
-
-    // NPC 위치, 방향
-    TRANSFORM_NPC,
-
-    // NPC 행동 업데이트
-    ACTION_NPC,
-
-    // NPC 스테이트 업데이트
-    STATE_NPC,
-
-    // 데미지 UI 전달
-    DAMAGE
+    UPDATE_USER_PARTY
 }

 public class PacketHeader
 {
    public PacketCode Code;
-    public int BodyLength;
+    public ushort BodyLength;
 }
--- a/MMOTestServer/ServerLib/Service/ServerBase.cs
+++ b/MMOTestServer/ServerLib/Service/ServerBase.cs
@@ -34,7 +34,7 @@ public abstract class ServerBase : INetEventListener

    // 인증된 세션      (hashKey → NetPeer)  재연결 조회용
    // peer → hashKey 역방향은 peer.Tag as Session 으로 대체
-    private readonly Dictionary<long, NetPeer> sessions = new();
+    protected readonly Dictionary<long, NetPeer> sessions = new();

    // 재사용 NetDataWriter (단일 스레드 폴링이므로 안전)
    private readonly NetDataWriter cachedWriter = new();
Author	SHA1	Message	Date
qornwh1	27f3832894	fix : 수정후 리드미 정리	2026-03-03 17:43:32 +09:00
qornwh1	f75d71c1ee	feat : 채널 매니저(각 채널, 유저 관리) 구현 / 유저 정보 구현 / 패킷 이동 채널 접속 구현	2026-03-03 17:43:07 +09:00