GRATIS
DE PAGO
DOCUMENTACIÓN
ARTÍCULO
FUNDAMENTOS SÓLIDOS 0–3 meses
Temas a dominar
- TCP vs UDP — diferencias fundamentalesred
- Modelo cliente-servidorarch
- Sockets en C# (TcpListener, TcpClient)c#
- async/await profundo en .NETc#
- Concurrencia: Tasks, ThreadPool, Channelsc#
- Serialización binaria (protobuf / MessagePack)datos
TCP vs UDP — cuándo usar cada uno
TCP — Fiable, ordenado
Conexión persistente. Garantiza entrega y orden. Más overhead. Usa para: login, chat, inventario, estados críticos.
C#: TcpListener / TcpClient / NetworkStream
UDP — Rápido, sin garantías
Sin conexión. Paquetes pueden perderse o llegar desordenados. Menor latencia. Usa para: posiciones, inputs, audio.
C#: UdpClient / Socket con SocketType.Dgram
Conceptos clave — click para expandir
async/await
No bloquea el hilo
await suspende la ejecución sin bloquear el hilo. El ThreadPool puede usar ese hilo para otra cosa mientras espera I/O.
// Manejar cliente sin bloquear
async Task HandleClientAsync(TcpClient client) {
var stream = client.GetStream();
var buffer = new byte[1024];
while (true) {
int read = await stream.ReadAsync(buffer);
if (read == 0) break; // cliente desconectado
await ProcessMessageAsync(buffer[..read]);
}
}
TcpListener
Acepta conexiones entrantes
El servidor escucha en un puerto. Cada cliente que conecta genera un
TcpClient independiente que debes manejar en su propia tarea.
var listener = new TcpListener(IPAddress.Any, 5000);
listener.Start();
while (true) {
var client = await listener.AcceptTcpClientAsync();
// No esperes — maneja en paralelo
_ = Task.Run(() => HandleClientAsync(client));
}
NetworkStream
Canal de bytes del socket
Un socket TCP es un stream de bytes continuo. No hay "mensajes" — debes definir un protocolo para saber dónde empieza y termina cada mensaje. Técnica común: length-prefix.
// Protocolo: [4 bytes longitud][N bytes datos]
async Task SendMessageAsync(Stream s, byte[] data) {
var len = BitConverter.GetBytes(data.Length);
await s.WriteAsync(len);
await s.WriteAsync(data);
}
async Task<byte[]> ReadMessageAsync(Stream s) {
var lenBuf = new byte[4];
await s.ReadExactlyAsync(lenBuf);
var len = BitConverter.ToInt32(lenBuf);
var data = new byte[len];
await s.ReadExactlyAsync(data);
return data;
}
CancellationToken
Para cerrar conexiones limpiamente
Cuando un cliente desconecta o el servidor cierra, necesitas cancelar todas las operaciones async pendientes. CancellationToken es el mecanismo estándar.
var cts = new CancellationTokenSource();
async Task HandleClient(TcpClient c, CancellationToken ct) {
try {
while (!ct.IsCancellationRequested) {
await stream.ReadAsync(buf, ct);
}
} catch (OperationCanceledException) {
// salida limpia
}
}
// Para cerrar: cts.Cancel();
Simulador — Servidor TCP multi-cliente
0
Clientes activos
0
Mensajes recibidos
0
Bytes procesados
📚 RECURSOS DE APRENDIZAJE — FASE 1
Async/Await en C# ESENCIAL
Tutorial oficial de Microsoft sobre programación asíncrona con async/await. Cubre Task, ValueTask y patrones TAP.
📖 Microsoft Learn
How Async/Await Really Works
Deep-dive del blog oficial de .NET que explica el funcionamiento interno de async/await.
📝 .NET Blog
Beginner's Guide to Game Networking
Guía completa para principiantes sobre TCP vs UDP, arquitecturas cliente-servidor y conceptos de netcode.
🆓 Gratis
Gabriel Gambetta - Client-Server Architecture
Serie de artículos legendaria sobre arquitectura de juegos multiplayer. Cubre predicción, interpolación y compensación.
🆓 Gratis · Imprescindible
Gaffer On Games - Networking
Glenn Fiedler's blog con artículos profundos sobre networking para juegos, UDP confiable y física en red.
🆓 Gratis · Avanzado
Awesome Game Networking
Lista curada de recursos sobre networking para juegos: artículos, charlas GDC, librerías y ejemplos.
🆓 GitHub
Source Multiplayer Networking
Documentación de Valve sobre el netcode del motor Source. Cubre todos los conceptos esenciales de multiplayer.
📖 Valve Wiki
Introduction to Async Programming in C#
Tutorial completo de Auth0 sobre async/await, Task-based patterns y buenas prácticas.
🆓 Auth0 Blog
Servidor TCP multi-cliente en C#
01TcpListener acepta conexiones en puerto 5000pendiente
02Cada cliente manejado en Task independientependiente
03Protocolo length-prefix para mensajespendiente
04Broadcast: servidor reenvía a todos los clientespendiente
05Manejo limpio de desconexión con CancellationTokenpendiente
TIEMPO REAL 3–6 meses
Construir
- Servidor UDP para posicionesred
- Game loop con tick rate fijocore
- Sincronización de posición de jugadoressync
- Simulación de física simple en servidorsim
- Tick rate configurable (20/30/60hz)perf
Tick rate — el corazón del servidor
TICK RATE:
20 ticks/s
50ms por tick
Mayor tick rate = más suave pero más CPU y más ancho de banda. CS2 usa 64hz. Valorant usa 128hz en servidores premium.
Conceptos de tiempo real — click para expandir
Client-side Prediction
El cliente actúa antes de confirmar
En vez de esperar que el servidor confirme tu movimiento, el cliente lo aplica localmente de inmediato. Cuando llega la confirmación del servidor, se reconcilia.
// Cliente: aplica input localmente
void OnInput(Vector2 dir) {
// 1. Aplica localmente ya
localPlayer.Position += dir * speed;
// 2. Envía al servidor
SendInput(new InputPacket {
Seq = inputSeq++, Direction = dir
});
// 3. Guarda para reconciliación
pendingInputs.Add(input);
}
Interpolación
Suaviza el movimiento entre snapshots
Los otros jugadores se muestran en el pasado (con buffer). Interpolamos entre la última posición conocida y la anterior para movimiento suave.
// Renderizar otros jugadores con delay
var renderTime = Time.now - interpolationDelay;
// Encontrar los dos snapshots que rodean renderTime
var from = snapshots.Last(s => s.Time <= renderTime);
var to = snapshots.First(s => s.Time >= renderTime);
float t = (renderTime - from.Time) / (to.Time - from.Time);
player.RenderPos = Vector2.Lerp(from.Pos, to.Pos, t);
Server Authority
El servidor siempre tiene razón
El cliente puede predecir, pero el servidor valida todo. Si el servidor dice que estás en X, vas a X. Esto previene cheating.
// Servidor: valida y corrige
void ProcessInput(Player p, InputPacket input) {
var newPos = p.Position + input.Direction * speed;
// Validar: ¿es un movimiento posible?
if (IsValidMove(p.Position, newPos)) {
p.Position = newPos;
}
// Si no es válido, el servidor no actualiza
// El cliente recibirá la posición real en el siguiente snapshot
}
Lag Compensation
Rebobina el mundo para verificar hits
Cuando un cliente dispara, apuntaba a donde estaba el enemigo hace Xms. El servidor rebobina el mundo a ese timestamp para validar el hit.
// Servidor: compensar latencia para hitscan
bool ValidateShot(Player shooter, ShotPacket shot) {
var latency = GetClientLatency(shooter);
var histTime = shot.ClientTime - latency;
// Rebobinar posición del objetivo
var historicPos = GetHistoricPosition(
shot.TargetId, histTime);
// Verificar con la posición histórica
return RayIntersects(shot.Ray, historicPos);
}
Simulador — Sync de posiciones en tiempo real
click para añadir jugador · los jugadores se mueven solos
📚 RECURSOS DE APRENDIZAJE — FASE 2
Fast-Paced Multiplayer IMPRESCINDIBLE
Serie completa de Gabriel Gambetta. Cubre client-side prediction, entity interpolation y lag compensation con demo interactiva.
🆓 Demo Interactiva
Overwatch - Let's Talk Netcode (GDC)
Charla de Blizzard sobre el netcode de Overwatch. Cubre predicción, reconciliación y lag compensation.
🆓 YouTube
I Shot You First (Halo: Reach) - GDC
David Aldridge de Bungie explica el sistema de hit detection y lag compensation de Halo: Reach.
🆓 GDC Vault
Quake 3 Network Model
Análisis del código fuente de Quake 3 por Fabien Sanglard. Explica el modelo de networking que revolucionó los FPS.
🆓 Artículo
Networked Physics (Glenn Fiedler)
Serie de artículos sobre cómo sincronizar física entre cliente y servidor. Determinismo y snapshots.
🆓 Gaffer on Games
Game Networking for Physics Programmers - GDC 2015
Glenn Fiedler (Respawn Entertainment) explica networking para juegos con física compleja.
🆓 YouTube
Multiplayer Networking Resources
Colección exhaustiva de recursos sobre game networking: charlas, artículos, librerías y más.
🆓 gamenetcode.com
Valorant Netcode & 128-tick Servers
Riot Games explica los conceptos básicos de networking en Valorant y por qué usan 128hz.
🆓 Riot Tech Blog
Servidor UDP + Game Loop
01UdpClient recibe paquetes de posiciónpendiente
02Game loop a 20hz con precisión de tiempopendiente
03Servidor broadcast snapshots del mundopendiente
04Cliente implementa interpolaciónpendiente
05Client-side prediction básico para movimientopendiente
INFRAESTRUCTURA REAL 6–9 meses
Aprender
- Docker — containerizar el servidorinfra
- Kubernetes básico — orquestar contenedoresk8s
- Redis — caché y pub/sub entre instanciasdatos
- gRPC — comunicación entre serviciosproto
- Load balancing — distribuir conexionesinfra
- Observabilidad: logs estructurados + métricasops
Stack de infraestructura
🐳
Docker
Empaqueta tu servidor en una imagen. Mismo entorno en local y prod.
☸️
Kubernetes
Orquesta múltiples instancias. Auto-scaling cuando hay más jugadores.
⚡
Redis
Estado compartido entre instancias. Pub/Sub para eventos entre servidores.
Conceptos clave — click para expandir
Dockerfile
Tu servidor en un contenedor
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY --from=build /app/publish .
EXPOSE 5000/tcp
EXPOSE 5001/udp
ENTRYPOINT ["dotnet", "GameServer.dll"]
Redis Pub/Sub
Eventos entre instancias del servidor
Si tienes múltiples instancias del servidor, necesitan comunicarse. Redis pub/sub permite que un evento en el Servidor A llegue al Servidor B.
// Publicar evento desde servidor A
await redis.PublishAsync("player.joined",
JsonSerializer.Serialize(new {
playerId, serverInstance
}));
// Suscribirse en servidor B
var sub = redis.GetSubscriber();
await sub.SubscribeAsync("player.joined",
(channel, msg) => HandlePlayerJoined(msg));
gRPC
Comunicación entre microservicios
Para comunicación interna entre servicios (matchmaking → servidor de juego). Más eficiente que REST para llamadas frecuentes.
// Definición proto
service GameService {
rpc AssignPlayer(PlayerRequest)
returns (ServerAssignment);
rpc GetServerStatus(Empty)
returns (ServerStatus);
}
// Uso en .NET
var client = new GameService.GameServiceClient(channel);
var response = await client.AssignPlayerAsync(
new PlayerRequest { PlayerId = id });
Observabilidad
Ver qué pasa en producción
Los tres pilares: Logs (qué pasó), Métricas (cuánto/cuántos), Traces (latencia end-to-end).
// OpenTelemetry en .NET
builder.Services.AddOpenTelemetry()
.WithMetrics(m => m
.AddMeter("GameServer.Connections")
.AddPrometheusExporter())
.WithTracing(t => t
.AddSource("GameServer")
.AddOtlpExporter());
// Registrar métrica propia
var connections = meter.CreateCounter<int>(
"active_connections");
connections.Add(1, tag("region", "us-east"));
Simulador — escalado horizontal
Añade instancias →
0
Instancias
0
Clientes totales
0%
Load promedio
📚 RECURSOS DE APRENDIZAJE — FASE 3
Docker & Kubernetes Full Course 6 HORAS
Curso completo de freeCodeCamp que cubre Docker y Kubernetes desde cero con proyectos prácticos.
🆓 freeCodeCamp
IBM Containers Course (Coursera)
Curso de IBM sobre Docker, Kubernetes y OpenShift. Gratis con certificado de auditoría.
🆓 Coursera (audit)
Kubernetes Official Training
Cursos oficiales de la Linux Foundation sobre Kubernetes. Incluye certificaciones CKA/CKAD.
📖 kubernetes.io
Docker & Kubernetes: The Practical Guide
Curso bestseller de Udemy por Maximilian Schwarzmüller. Muy completo y actualizado.
💰 Udemy (~$15)
Redis .NET Development Guide
Guía oficial de Redis para .NET con StackExchange.Redis. Cubre strings, hashes, pub/sub y más.
📖 Redis Docs
Redis Streams in .NET Tutorial
Tutorial práctico sobre Redis Streams para mensajería entre servicios con C#.
🆓 Redis Tutorial
gRPC Services with C#
Documentación oficial de Microsoft sobre gRPC en .NET. Cubre protobuf, servicios y streaming.
📖 Microsoft Learn
gRPC C# Master Class (Udemy)
Curso completo de gRPC con C#. Cubre todos los tipos de RPC, error handling y SSL.
💰 Udemy (~$15)
Building a gRPC Server in .NET
Tutorial paso a paso para crear un servidor gRPC en .NET con ejemplos prácticos.
🆓 Blog Tutorial
100 Clientes — Escalado Horizontal
01Dockerfile del servidor de juegopendiente
02docker-compose con servidor + Redispendiente
03Test de carga: 100 clientes simuladospendiente
04Escalar a 3 instancias con load balancerpendiente
05Dashboard de métricas en Grafanapendiente
PROYECTO FUERTE 9–12 meses
Componentes del juego multiplayer
- Movement sync con server authoritycore
- Sistema de matchmaking simplelobby
- Reconciliación cliente-servidorsync
- Deploy en cloud (GCP/AWS/Azure)infra
- Métricas y alertas en producciónops
Arquitectura del proyecto final
┌─── CLIENTE ──────────────┐
│ Prediction + Interp │
│ Input buffer │
└──────────┬───────────────┘
│ TCP + UDP
┌──────────▼───────────────┐
│ GAME SERVER │
│ Game loop 30hz │
│ Server authority │
└──────┬───────────┬───────┘
│
Redis
│
Matchmaking
Mini simulador — movement sync con server authority
click para mover · el servidor valida la posición
■ Servidor (autoritativo)
○ Cliente (predicción)
ping: 0ms
aguardando input
📚 RECURSOS DE APRENDIZAJE — FASE 4
AWS Game Tech
Recursos de AWS para game development. Incluye GameLift para matchmaking y servidores dedicados.
📖 AWS Docs
Azure PlayFab
Backend-as-a-Service de Microsoft para juegos. Matchmaking, leaderboards, analytics y más.
📖 PlayFab Docs
Open Match (Google)
Framework open-source de Google para matchmaking. Escalable y personalizable.
🆓 Open Source
Agones - Game Server Hosting on K8s
Kubernetes controller para hostear servidores de juegos dedicados. Usado por empresas AAA.
🆓 Open Source
Building a Turn-Based Game Server
Artículo sobre arquitectura de servidores para juegos turn-based con sincronización determinística.
🆓 Blog
Prometheus + Grafana para Game Servers
Stack de monitoreo estándar de la industria. Perfecto para métricas de servidores de juegos.
📖 Prometheus Docs
Nakama - Open Source Game Server
Servidor de juegos open-source con matchmaking, realtime multiplayer, leaderboards y más.
🆓 Open Source
Mirror Networking (Unity)
Librería de networking para Unity. Buen recurso para entender patrones de netcode incluso si no usas Unity.
🆓 Docs
Mini Multiplayer — Deploy Completo
01Servidor completo: TCP lobby + UDP gameplaypendiente
02Matchmaking: sala de 2–4 jugadorespendiente
03Movement con prediction + reconciliaciónpendiente
04Dockerizado y corriendo en cloudpendiente
05Amigos pueden conectarse desde Internetpendiente