🎮 게임 서버 프로그래밍 학습 허브

🔷

1. C# 프로그래밍 기초

⭐ 입문

C#은 게임 개발에서 가장 널리 사용되는 언어입니다. Unity 게임 엔진도 C#을 사용하죠. 서버 개발에서도 ASP.NET을 활용한 고성능 서버 구축이 가능합니다.

💡 왜 C#을 배워야 하나요?

게임 업계 표준: Unity + 서버 양쪽에서 사용
강력한 타입 시스템: 버그를 줄여줌
비동기 지원: async/await로 효율적인 서버 구현
높은 성능: .NET 8+ 에서 매우 빠름

C#

// C# 기본 자료형 (Data Types)

// 숫자형
int hp = 100;           // 정수: -21억 ~ 21억
float speed = 3.5f;      // 실수 (소수점)
double damage = 125.75;   // 정밀 실수

// 문자열
string name = "전사";     // 텍스트

// 참/거짓
bool isAlive = true;     // true 또는 false

// 게임에서 자주 쓰이는 패턴
int[] scores = { 100, 85, 92 };  // 배열
List<string> players = new();    // 동적 리스트

// 딕셔너리 (key-value 쌍)
Dictionary<string, int> inventory = new()
{
    { "검", 1 },
    { "포션", 5 }
};

// 게임에서 사용 예시
Console.WriteLine($"{name}의 HP: {hp}");
// 출력: 전사의 HP: 100

🎯 실전 포인트

게임 서버에서는 int로 HP/점수, float로 좌표/속도, string으로 유저ID, Dictionary로 플레이어 데이터를 관리합니다.

C#

// 함수 (Method) - 동작을 정의

// 기본 함수
static int CalculateDamage(int attack, int defense)
{
    int damage = attack - defense;
    return Math.Max(damage, 0); // 최소 0
}

// 기본값이 있는 매개변수
static void Heal(ref int hp, int amount = 20)
{
    hp += amount;
    Console.WriteLine($"회복! HP: {hp}");
}

// 여러 값 반환 (튜플)
static (int x, int y) GetPosition()
{
    return (100, 200);
}

// 사용 예시
int dmg = CalculateDamage(50, 20);
Console.WriteLine($"데미지: {dmg}");  // 데미지: 30

int playerHp = 80;
Heal(ref playerHp);        // 회복! HP: 100

var pos = GetPosition();
Console.WriteLine($"위치: ({pos.x}, {pos.y})");

C#

// 클래스 - 게임 객체를 만들기 위한 설계도

class Player
{
    // 속성 (Properties)
    public string Name { get; set; }
    public int Hp { get; private set; }
    public int Attack { get; set; }

    // 생성자 (Constructor)
    public Player(string name, int hp, int attack)
    {
        Name = name;
        Hp = hp;
        Attack = attack;
    }

    // 메서드
    public void TakeDamage(int damage)
    {
        Hp -= damage;
        if (Hp < 0) Hp = 0;
        Console.WriteLine($"{Name}이 {damage} 데미지! HP: {Hp}");
    }

    public bool IsAlive() => Hp > 0;
}

// 사용 예시
var warrior = new Player("전사", 100, 25);
var mage = new Player("마법사", 70, 40);

warrior.TakeDamage(mage.Attack);
// 출력: 전사이 40 데미지! HP: 60

🏗️ 게임 서버에서 클래스 활용

Player: 접속한 유저 정보 관리
GameRoom: 매치/방 관리
Unit: 게임 속 유닛 (병사, 건물 등)
Packet: 서버-클라이언트 간 주고받는 데이터

C#

// 비동기 프로그래밍 - 게임 서버의 핵심!
// async/await = 기다리는 동안 다른 일을 할 수 있음

class GameServer
{
    // 비동기로 클라이언트 연결 받기
    public async Task StartServer()
    {
        Console.WriteLine("서버 시작!");
        
        while (true)
        {
            // 플레이어 연결을 기다림 (다른 작업 가능)
            var player = await AcceptPlayer();
            Console.WriteLine($"{player} 접속!");
            
            // 비동기로 게임 처리 (blocking 없음)
            _ = HandlePlayer(player); // fire-and-forget
        }
    }

    async Task<string> AcceptPlayer()
    {
        await Task.Delay(1000); // 1초 대기
        return "Player_001";
    }

    async Task HandlePlayer(string player)
    {
        // 비동기로 DB에서 유저 데이터 로드
        var data = await LoadFromDB(player);
        await SendToClient(player, data);
    }

    async Task<string> LoadFromDB(string playerId)
    {
        await Task.Delay(100);
        return $"{{\"hp\": 100, \"score\": 0}}";
    }

    async Task SendToClient(string player, string data)
    {
        await Task.Delay(50);
        Console.WriteLine($"{player}에게 데이터 전송 완료");
    }
}

⚡ 왜 비동기가 중요할까요?

동기(Sync) 방식은 한 명의 요청을 처리하는 동안 다른 모든 플레이어가 기다려야 합니다. 비동기(Async)는 기다리는 동안 다른 플레이어를 처리할 수 있어 수천 명 동시접속이 가능합니다.

🟢

2. Node.js 서버 기초

⭐ 입문

Node.js는 JavaScript로 서버를 만드는 런타임입니다. 비동기에 최적화되어 있어 실시간 게임 서버에 적합합니다.

💡 Node.js 장점

쉬운 문법: JavaScript를 이미 알면 바로 시작
이벤트 기반: 실시간 처리에 탁월
npm 생태계: 필요한 라이브러리가 풍부
빠른 개발: C#보다 prototype이 빠름

JavaScript (Node.js)

// server.js - 가장 기본적인 HTTP 서버
const http = require('http');

// 서버 생성
const server = http.createServer((req, res) => {
  // 모든 요청에 응답
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({
    message: '게임 서버가 실행중입니다!',
    status: 'online',
    players: 0
  }));
});

// 포트 3000에서 대기
server.listen(3000, () => {
  console.log('🎮 서버 시작: http://localhost:3000');
});

실행: node server.js → 브라우저에서 localhost:3000 접속

JavaScript (Express)

// Express로 게임 API 서버 만들기
// 설치: npm install express
const express = require('express');
const app = express();
app.use(express.json());

// 플레이어 데이터 (메모리에 저장)
const players = new Map();

// [POST] 플레이어 생성
app.post('/api/players', (req, res) => {
  const { name } = req.body;
  const player = {
    id: P${players.size + 1},
    name,
    hp: 100,
    score: 0,
    createdAt: new Date()
  };
  players.set(player.id, player);
  res.json({ success: true, player });
});

// [GET] 플레이어 조회
app.get('/api/players/:id', (req, res) => {
  const player = players.get(req.params.id);
  if (!player) {
    return res.status(404).json({ error: '플레이어 없음' });
  }
  res.json(player);
});

// 서버 시작
app.listen(3000, () => {
  console.log('🎮 API 서버 시작!');
});

JavaScript (Event)

// EventEmitter - 게임 이벤트 시스템
const EventEmitter = require('events');
const gameEvents = new EventEmitter();

// 이벤트 리스너 등록
gameEvents.on('playerJoin', (player) => {
  console.log(`🎮 ${player}님이 입장!`);
});

gameEvents.on('playerAttack', (attacker, target, damage) => {
  console.log(`⚔️ ${attacker} → ${target}: ${damage} 데미지`);
});

gameEvents.on('gameOver', (winner) => {
  console.log(`🏆 ${winner} 승리!`);
});

// 게임 시뮬레이션
gameEvents.emit('playerJoin', '전사');
gameEvents.emit('playerJoin', '마법사');
gameEvents.emit('playerAttack', '전사', '마법사', 25);
gameEvents.emit('gameOver', '전사');

🎯 이벤트 기반이란?

"A가 일어나면 B를 해라"를 미리 등록해두는 방식. 게임에서 플레이어 접속, 공격, 죽음 등을 이벤트로 처리하면 코드가 깔끔해집니다.

🌐

3. 네트워크 기초 (TCP/UDP)

⭐⭐ 중급

게임 서버의 핵심은 네트워크입니다. 데이터를 어떻게 주고받을지 이해해야 해요.

항목	TCP	UDP
신뢰성	✅ 데이터 보장 (재전송)	❌ 보장 안 됨 (丢失 가능)
속도	상대적으로 느림	매우 빠름
연결	연결 필요 (3-way handshake)	연결 없이 전송
게임 용도	로그인, 채팅, 아이템, 결제	실시간 전투, 이동, 스킬

🎮 게임에서의 활용

TCP: "아이템을 구매했다" → 데이터丢失되면 안 됨
UDP: "캐릭터가 x,y로 이동중" →丢了? 다음 패킷이 곧 옴
RTS 게임: 대부분 TCP 사용 (명령顺序가 중요)

Node.js - TCP 서버

// TCP 소켓 서버 - 게임 서버의 기본 구조
const net = require('net');
const clients = new Set();

const server = net.createServer((socket) => {
  console.log('🔗 새 플레이어 연결!');
  clients.add(socket);

  // 데이터 수신
  socket.on('data', (data) => {
    const message = data.toString();
    console.log(`📨 수신: ${message}`);
    
    // 모든 클라이언트에게 브로드캐스트
    for (const client of clients) {
      if (client !== socket) {
        client.write(message);
      }
    }
  });

  // 연결 해제
  socket.on('end', () => {
    clients.delete(socket);
    console.log('👋 플레이어 퇴장');
  });
});

server.listen(5000, () => {
  console.log('🎮 TCP 게임 서버: 포트 5000');
});

🔌

4. WebSocket 실시간 통신

⭐⭐ 중급

WebSocket은 HTTP를 업그레이드하여 양방향 실시간 통신을 가능하게 합니다. 게임에서 가장 많이 사용되는 통신 방식이에요.

📡 HTTP vs WebSocket

HTTP: 클라이언트가 요청 → 서버가 응답 (단방향, 일회성)
WebSocket: 연결 유지 → 양쪽이 자유롭게 전송 (실시간)
게임: WebSocket으로 실시간으로 게임 상태를 주고받음

Node.js + ws 라이브러리

// WebSocket 게임 서버
// 설치: npm install ws
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

// 게임 상태
const gameState = {
  players: new Map(),
  bullets: []
};

wss.on('connection', (ws) => {
  const playerId = P${gameState.players.size + 1};
  console.log(`🎮 ${playerId} 접속!`);

  // 초기 상태 전송
  ws.send(JSON.stringify({
    type: 'init',
    playerId,
    players: Object.fromEntries(gameState.players)
  }));

  // 메시지 수신
  ws.on('message', (data) => {
    const msg = JSON.parse(data);
    
    switch (msg.type) {
      case 'move':
        // 이동 → 모든 플레이어에게 알림
        gameState.players.set(playerId, {
          x: msg.x, y: msg.y
        });
        broadcast({
          type: 'playerMoved',
          playerId,
          x: msg.x,
          y: msg.y
        });
        break;

      case 'attack':
        // 공격 → 데미지 계산 후 전파
        broadcast({
          type: 'attack',
          attacker: playerId,
          target: msg.targetId,
          damage: msg.damage
        });
        break;
    }
  });

  // 연결 해제
  ws.on('close', () => {
    gameState.players.delete(playerId);
    broadcast({ type: 'playerLeft', playerId });
  });
});

// 모든 클라이언트에게 전송
function broadcast(data) {
  const msg = JSON.stringify(data);
  wss.clients.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(msg);
    }
  });
}

console.log('🔌 WebSocket 서버: ws://localhost:8080');

HTML + JavaScript

<!-- 게임 클라이언트 (브라우저) -->
<script>
const ws = new WebSocket('ws://localhost:8080');

ws.onopen = () => {
  console.log('서버에 연결됨!');
};

// 서버에서 메시지 수신
ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);
  
  switch (msg.type) {
    case 'init':
      console.log(`내 ID: ${msg.playerId}`);
      break;
    case 'playerMoved':
      updatePlayerPosition(msg.playerId, msg.x, msg.y);
      break;
    case 'attack':
      showAttackEffect(msg.attacker, msg.target, msg.damage);
      break;
  }
};

// 서버로 이동 데이터 전송
function sendMove(x, y) {
  ws.send(JSON.stringify({ type: 'move', x, y }));
}

// 서버로 공격 전송
function sendAttack(targetId, damage) {
  ws.send(JSON.stringify({
    type: 'attack', targetId, damage
  }));
}
</script>

🗄️

5. 데이터베이스 (MySQL)

⭐⭐ 중급

플레이어 정보, 아이템, 전적 등을 영구 저장하려면 데이터베이스가 필요합니다.

DB	특징	게임에서의 용도
MySQL	관계형, SQL 문법	유저 정보, 아이템, 전적
MongoDB	NoSQL, JSON 형태	로그, 설정, 유연한 데이터

SQL

-- 게임 데이터베이스 생성
CREATE DATABASE game_server;
USE game_server;

-- 플레이어 테이블
CREATE TABLE players (
  id        INT AUTO_INCREMENT PRIMARY KEY,
  username  VARCHAR(50) UNIQUE NOT NULL,
  email     VARCHAR(100),
  level     INT DEFAULT 1,
  gold      INT DEFAULT 0,
  hp        INT DEFAULT 100,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 아이템 테이블
CREATE TABLE items (
  id        INT AUTO_INCREMENT PRIMARY KEY,
  name      VARCHAR(50),
  type      ENUM('weapon', 'armor', 'potion'),
  power     INT
);

-- CRUD 기본 예제
-- 생성 (Create)
INSERT INTO players (username, email) VALUES ('전사', 'warrior@game.com');

-- 조회 (Read)
SELECT * FROM players WHERE level >= 10;

-- 수정 (Update)
UPDATE players SET gold = gold + 100 WHERE username = '전사';

-- 삭제 (Delete)
DELETE FROM players WHERE hp <= 0;

Node.js + MySQL

// MySQL 연동 - 설치: npm install mysql2
const mysql = require('mysql2/promise');

// 연결 풀 생성 (성능 최적화)
const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'game_server',
  waitForConnections: true,
  connectionLimit: 10
});

// 플레이어 조회
async function getPlayer(username) {
  const [rows] = await pool.execute(
    'SELECT * FROM players WHERE username = ?',
    [username]
  );
  return rows[0];
}

// 플레이어 생성
async function createPlayer(username, email) {
  const [result] = await pool.execute(
    'INSERT INTO players (username, email) VALUES (?, ?)',
    [username, email]
  );
  return result.insertId;
}

// 골드 업데이트
async function addGold(playerId, amount) {
  await pool.execute(
    'UPDATE players SET gold = gold + ? WHERE id = ?',
    [amount, playerId]
  );
}

// 사용 예시
async function main() {
  const id = await createPlayer('마법사', 'mage@game.com');
  await addGold(id, 500);
  const player = await getPlayer('마법사');
  console.log(player);
  // { id: 1, username: '마법사', gold: 500, ... }
}

🐧

6. Linux 서버 운영

⭐ 입문

게임 서버는 대부분 Linux에서 실행됩니다. 기본 명령어를 알아두면 서버를 관리할 수 있어요.

Bash

# 파일 & 디렉토리
ls -la          # 파일 목록 (숨김 파일 포함)
cd /home        # 디렉토리 이동
mkdir game      # 폴더 생성
cp file1 file2  # 파일 복사
mv old new      # 파일 이동/이름 변경
rm file.txt     # 파일 삭제

# 파일 내용 보기
cat server.log  # 전체 출력
tail -f log.txt # 실시간 로그 모니터링 ⭐
head -20 log.txt # 앞 20줄
grep "error" log.txt # "error" 포함 줄 찾기

# 네트워크
curl http://localhost:3000  # HTTP 요청 테스트
netstat -tlnp    # 열린 포트 확인
ping google.com  # 네트워크 연결 확인

# 파일 편집 (nano 에디터)
nano server.js   # 파일 편집 (Ctrl+X → Y → Enter 저장)

# 권한 관리
chmod +x start.sh  # 실행 권한 부여
ls -la            # 권한 확인

Bash - 프로세스 관리

# 프로세스 확인
ps aux           # 모든 프로세스 목록
ps aux | grep node # node 프로세스만 찾기
top              # 실시간 CPU/메모리 모니터

# 프로세스 종료
kill PID         # 정상 종료 (시그널 15)
kill -9 PID      # 강제 종료 (시그널 9)

# ★ 게임 서버를 백그라운드로 실행 (중요!)
nohup node server.js > output.log 2>&1 &
# nohup: 터미널 닫아도 계속 실행
# > output.log: 로그를 파일로 저장
# &: 백그라운드 실행

# ★ systemd로 서버 자동 시작 (프로덕션용)
# /etc/systemd/system/game-server.service 생성:
cat > /etc/systemd/system/game-server.service << 'EOF'
[Unit]
Description=Game Server
After=network.target

[Service]
Type=simple
User=root
WorkingDirectory=/opt/game-server
ExecStart=/usr/bin/node server.js
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 서비스 등록 & 시작
systemctl daemon-reload
systemctl enable game-server
systemctl start game-server
systemctl status game-server # 상태 확인

💡 왜 systemd를 써야 하나요?

nohup은 간단하지만 서버가 죽으면 자동으로 재시작 안 됩니다. systemd는 서버가 죽어도 자동으로 살리고, 부팅 시 자동 시작됩니다. 실무에서 필수!

🎯

7. 게임 서버 특화 개념

⭐⭐⭐ 심화

이제 진짜 게임 서버의 핵심 개념들을 배워봅시다!

🔄 게임 루프 (Game Loop)란?

게임 서버는 1초에 여러 번(틱) 상태를 업데이트합니다. 보통 20~60틱/초로 동작합니다. 틱마다 모든 유닛의 위치, HP, 상태를 계산해요.

Node.js - 게임 루프

// 간단한 게임 루프 (20틱/초)
const TICK_RATE = 20; // 초당 20회
const TICK_INTERVAL = 1000 / TICK_RATE; // 50ms

const gameWorld = {
  units: new Map(),
  
  update() {
    // 모든 유닛 업데이트
    for (const [id, unit] of this.units) {
      // 이동 처리
      unit.x += unit.vx;
      unit.y += unit.vy;
      
      // 충돌 검사
      this.checkCollisions(unit);
      
      // 버프/디버프 타이머
      this.updateEffects(unit);
    }
    
    // 게임 승리 조건 체크
    this.checkWinCondition();
  },
  
  broadcastState(clients) {
    const state = {
      type: 'gameState',
      tick: this.tickCount,
      units: Array.from(this.units.values())
    };
    const data = JSON.stringify(state);
    clients.forEach(c => c.send(data));
  }
};

// 게임 루프 시작
let tickCount = 0;
const gameLoop = setInterval(() => {
  gameWorld.update();
  gameWorld.broadcastState(wss.clients);
  tickCount++;
}, TICK_INTERVAL);

console.log(`🎮 게임 루프 시작 (${TICK_RATE} tick/s)`);

📡 상태 동기화 (State Synchronization)

모든 플레이어가 같은 게임 화면을 보려면 서버가 게임 상태를 모든 클라이언트에게 전송해야 합니다.

동기화 전략

// 전략 1: 전체 상태 전송 (단순하지만 데이터量 큼)
// 매 틱 모든 유닛의 전체 상태를 보냄
// 장점: 구현 쉬움 / 단점: 대역폭 많이 사용

// 전략 2: 델타 전송 (변경분만 전송) ⭐ 권장
function getDeltaState(prevState, currentState) {
  const delta = {};
  for (const [id, unit] of currentState) {
    const prev = prevState.get(id);
    if (!prev || JSON.stringify(prev) !== JSON.stringify(unit)) {
      delta[id] = unit; // 변경된 것만 포함
    }
  }
  return delta;
}

// 전략 3: 보간 (Interpolation)
// 클라이언트에서 부드러운 움직임을 위해
// 서버: 50ms마다 위치 전송
// 클라이언트: 중간 위치를 계산해서 부드럽게 표시
function interpolate(from, to, t) {
  return from + (to - from) * t; // t: 0~1
}

🤝 매치메이킹이란?

PvP 게임에서 실력이 비슷한 플레이어끼리 매칭해주는 시스템입니다.

Node.js - 간단한 매치메이킹

// 매치메이킹 큐 시스템
class MatchMaker {
  constructor() {
    this.queue = []; // 대기열
    this.ratingRange = 100; // 매칭 허용 범위
  }

  // 플레이어 큐에 추가
  addPlayer(player) {
    this.queue.push({
      ...player,
      joinedAt: Date.now()
    });
    console.log(`[매치메이킹] ${player.name} 대기열 진입 (rating: ${player.rating})`);
    this.tryMatch();
  }

  // 매칭 시도
  tryMatch() {
    // rating 순으로 정렬
    this.queue.sort((a, b) => a.rating - b.rating);

    for (let i = 0; i < this.queue.length - 1; i++) {
      const p1 = this.queue[i];
      const p2 = this.queue[i + 1];

      // rating 차이가 범위 안이면 매칭!
      if (Math.abs(p1.rating - p2.rating) <= this.ratingRange) {
        this.queue.splice(i, 2); // 큐에서 제거
        this.createMatch(p1, p2);
        return;
      }
    }
  }

  // 매치 생성
  createMatch(p1, p2) {
    console.log(`🎮 매치 성사! ${p1.name} vs ${p2.name}`);
    // 여기서 게임 룸을 만들고 두 플레이어를 초대
  }
}

// 사용 예시
const matchmaker = new MatchMaker();
matchmaker.addPlayer({ name: '전사', rating: 1200 });
matchmaker.addPlayer({ name: '마법사', rating: 1180 });
// 출력: 🎮 매치 성사! 마법사 vs 전사

🎮 게임 서버 프로그래밍
학습 허브

🗺️ 학습 로드맵

C# 기초

Node.js

네트워크

WebSocket

데이터베이스

Linux 서버

게임 서버

📚 학습 주제

1. C# 프로그래밍 기초

💡 왜 C#을 배워야 하나요?

🎯 실전 포인트

🏗️ 게임 서버에서 클래스 활용

⚡ 왜 비동기가 중요할까요?

2. Node.js 서버 기초

💡 Node.js 장점

🎯 이벤트 기반이란?

3. 네트워크 기초 (TCP/UDP)

🎮 게임에서의 활용

4. WebSocket 실시간 통신

📡 HTTP vs WebSocket

5. 데이터베이스 (MySQL)

6. Linux 서버 운영

💡 왜 systemd를 써야 하나요?

7. 게임 서버 특화 개념

🔄 게임 루프 (Game Loop)란?

📡 상태 동기화 (State Synchronization)

🤝 매치메이킹이란?

❓ 학습 퀴즈

🎮 게임 서버 프로그래밍학습 허브

🗺️ 학습 로드맵

C# 기초

Node.js

네트워크

WebSocket

데이터베이스

Linux 서버

게임 서버

📚 학습 주제

1. C# 프로그래밍 기초

💡 왜 C#을 배워야 하나요?

🎯 실전 포인트

🏗️ 게임 서버에서 클래스 활용

⚡ 왜 비동기가 중요할까요?

2. Node.js 서버 기초

💡 Node.js 장점

🎯 이벤트 기반이란?

3. 네트워크 기초 (TCP/UDP)

🎮 게임에서의 활용

4. WebSocket 실시간 통신

📡 HTTP vs WebSocket

5. 데이터베이스 (MySQL)

6. Linux 서버 운영

💡 왜 systemd를 써야 하나요?

7. 게임 서버 특화 개념

🔄 게임 루프 (Game Loop)란?

📡 상태 동기화 (State Synchronization)

🤝 매치메이킹이란?

❓ 학습 퀴즈

🎮 게임 서버 프로그래밍
학습 허브