docs: add SM64, N64 Netplay, and Dolphin Traversal server documentation

Updated game-servers.md with full setup guides for:
- SM64 Coop DX (headless, UDP 7777, build patches, mods)
- N64 Netplay / gopher64 (Mario Party 1-3, relay server, client setup)
- Dolphin Traversal (GC/Wii NAT hole-punching, all Dolphin games)

Updated README.md service table and game listings.
Updated deployment.md with new ports and connection info.
Fixed MapleStory 2 ports (20002→20003) to match INSTANCED_CONTENT fix.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

README.md

@@ -14,11 +14,14 @@ Plataforma de preservacion de videojuegos con documentales interactivos. Servido
 | **MapleStory 2 - World** | En linea | 21001 | ~126 MB |
 | **MapleStory 2 - Login** | En linea | 20001 | ~100 MB |
 | **MapleStory 2 - Web** | En linea | 4000 | ~70 MB |
-| **MapleStory 2 - Game Ch0** | En linea | 20002/21002 | ~341 MB |
+| **MapleStory 2 - Game Ch0** | En linea | 20003/21003 | ~341 MB |
 | **MapleStory 2 - MySQL** | En linea | 3307 | ~733 MB |
 | **Minecraft FTB Evolution** | En linea | 25565 | ~3.5 GB |
+| **SM64 Coop DX** | En linea | 7777/udp | ~45 MB |
+| **N64 Netplay** (Mario Party) | En linea | 45000-45004 | <1 MB |
+| **Dolphin Traversal** (GC/Wii) | En linea | 6262/udp, 6226/udp | <10 MB |
 
-**Total**: ~5.6 GB RAM / 40 GB disponibles | 31 GB disco / 96 GB disponibles
+**Total**: ~6 GB RAM / 40 GB disponibles | 35 GB disco / 96 GB disponibles
 
 ## Juegos Preservados
 
@@ -40,6 +43,23 @@ Plataforma de preservacion de videojuegos con documentales interactivos. Servido
 - **Cliente**: FTB App o launcher compatible con FTB Evolution v1.29.1
 - **Modpack**: 200+ mods, Minecraft 1.21.1 + NeoForge 21.1.218
 
+### Super Mario 64 Coop
+- **Servidor**: [sm64coopdx](https://github.com/coop-deluxe/sm64coopdx) (C, headless)
+- **Conexion**: `play.consultoria-as.com:7777` (o `192.168.10.234:7777` en LAN)
+- **Cliente**: sm64coopdx (compilado con la misma ROM)
+- **Jugadores**: Hasta 16, con mods incluidos (star-road, arena, character-select)
+
+### Mario Party 1-3 (N64 Netplay)
+- **Servidor**: [gopher64-netplay-server](https://github.com/gopher64/gopher64-netplay-server) (Go)
+- **Conexion**: `play.consultoria-as.com:45000` (o `192.168.10.234:45000` en LAN)
+- **Cliente**: [gopher64](https://github.com/gopher64/gopher64) o RMG + ROM de Mario Party
+- **Jugadores**: 4 por sala, 4 salas concurrentes
+
+### GameCube / Wii (Dolphin Netplay)
+- **Servidor**: Dolphin Traversal Server (NAT hole-punching)
+- **Config en Dolphin**: Traversal Server = `play.consultoria-as.com`, Port = `6262`
+- **Juegos**: Mario Party 4-7, MKDD, Smash Melee, F-Zero GX, y cualquier juego de GC/Wii
+
 ## Arquitectura
 
 ```
@@ -51,7 +71,9 @@ project-afterlife/
 │   └── shared/                 # Tipos TypeScript compartidos
 ├── servers/
 │   ├── openfusion/             # Servidor FusionFall (C++)
-│   └── maple2/                 # Servidor MapleStory 2 (C# .NET 8)
+│   ├── maple2/                 # Servidor MapleStory 2 (C# .NET 8)
+│   ├── sm64coopdx/             # Super Mario 64 Coop (C, headless)
+│   └── dolphin-traversal/      # Dolphin Traversal Server (C++)
 ├── docker/
 │   ├── docker-compose.dev.yml  # Stack local (web + CMS + juegos)
 │   ├── docker-compose.maple2.yml # MapleStory 2 (separado)

docs/deployment.md

@@ -41,11 +41,14 @@ docker ps
 | 23000-23001 | OpenFusion |
 | 20001 | MapleStory 2 Login |
 | 21001 | MapleStory 2 World |
-| 20002 | MapleStory 2 Game |
+| 20003 | MapleStory 2 Game |
-| 21002 | MapleStory 2 Game gRPC |
+| 21003 | MapleStory 2 Game gRPC |
 | 3307 | MySQL (MapleStory 2) |
 | 4000 | MapleStory 2 Web |
 | 25565 | Minecraft FTB Evolution |
+| 7777 (UDP) | SM64 Coop DX |
+| 45000-45004 | N64 Netplay (TCP + UDP) |
+| 6262, 6226 (UDP) | Dolphin Traversal (GC/Wii) |
 
 ## Acceso Externo (fuera de la red local)
 
@@ -81,8 +84,11 @@ Abrir estos puertos TCP en el router, apuntando a la IP local del servidor (192.
 | 23000 | OpenFusion (login) | TCP |
 | 23001 | OpenFusion (shard) | TCP |
 | 20001 | MapleStory 2 (login) | TCP |
-| 20002 | MapleStory 2 (game) | TCP |
+| 20003 | MapleStory 2 (game) | TCP |
 | 25565 | Minecraft FTB Evolution | TCP |
+| 7777 | SM64 Coop DX | UDP |
+| 45000-45004 | N64 Netplay (Mario Party) | TCP + UDP |
+| 6262, 6226 | Dolphin Traversal (GC/Wii) | UDP |
 
 **No forwardear**: PostgreSQL (5432), MinIO (9000/9001), Strapi (1337), Next.js (3000), MySQL (3307). Estos son servicios internos.
 
@@ -101,6 +107,9 @@ El contenedor `cloudflare-ddns` actualizara automaticamente el registro DNS `pla
 | Minecraft FTB Evolution | `play.consultoria-as.com:25565` |
 | OpenFusion (FusionFall) | `play.consultoria-as.com:23000` |
 | MapleStory 2 | `play.consultoria-as.com:20001` |
+| SM64 Coop DX | `play.consultoria-as.com:7777` (UDP) |
+| N64 Netplay (Mario Party) | `play.consultoria-as.com:45000` |
+| Dolphin Netplay (GC/Wii) | Traversal Server: `play.consultoria-as.com:6262` |
 
 ### Detener servicios
 ```bash

docs/game-servers.md

@@ -46,7 +46,7 @@ Variables de entorno en `docker-compose.dev.yml`:
 |------|-------|
 | Emulador | [Maple2](https://github.com/MS2Community/Maple2) |
 | Lenguaje | C# / .NET 8 |
-| Puertos | 20001 (login), 21001 (world), 20002/21002 (game), 4000 (web) |
+| Puertos | 20001 (login), 21001 (world), 20003/21003 (game ch0), 4000 (web) |
 | Base de datos | MySQL 8.0 (puerto 3307) |
 | RAM total | ~1.4 GB (5 contenedores) |
 
@@ -58,7 +58,7 @@ maple2-mysql (3307)
     │       │
     │       ├── maple2-login (20001) ← Autenticacion, seleccion de personaje
     │       │
-    │       └── maple2-game-ch0 (20002/21002) ← Canal de juego
+    │       └── maple2-game-ch0 (20003/21003) ← Canal de juego (channelId=1)
     │
     └── maple2-web (4000)        ← API web auxiliar
 ```
@@ -127,13 +127,16 @@ docker compose -f docker-compose.maple2.yml up -d
 - **"Scripting/Scripts not found"**: Ya corregido — se removio la linea COPY del Dockerfile del Game server
 - **"project.assets.json not found" en file-ingest**: Ejecutar `dotnet restore` antes de `dotnet run`
 - **Servidores no se conectan entre si**: Verificar que `GRPC_WORLD_IP=maple2-world` y `GRPC_GAME_IP=maple2-game-ch0` estan configurados en el compose
+- **"Server not found" al seleccionar personaje**: `INSTANCED_CONTENT` debe ser `"false"` para que el canal se registre como non-instanced. Con `"false"`, el channelId es 1 y los puertos son 20003/21003 (base + channelId)
 
 ### Agregar mas canales de juego
 Para agregar un segundo canal, duplicar el servicio `maple2-game-ch0` en el compose cambiando:
 - Nombre: `maple2-game-ch1`
-- Puertos: `20003:20003` y `21003:21003`
+- Puertos: `20004:20004` y `21004:21004` (channelId=2)
 - `GRPC_GAME_IP: maple2-game-ch1`
 
+> **Nota sobre puertos**: Con `INSTANCED_CONTENT: "false"`, el primer canal es channelId=1 (puertos 20003/21003), el segundo seria channelId=2 (20004/21004), etc. Los puertos se calculan como `BasePort + channelId`.
+
 ---
 
 ## Minecraft: FTB Evolution
@@ -189,6 +192,169 @@ Con 200+ mods, el mod Hexerei tarda mas de 60 segundos generando recetas al inic
 
 ---
 
+## Super Mario 64 Coop (sm64coopdx)
+
+### Resumen
+| Dato | Valor |
+|------|-------|
+| Proyecto | [sm64coopdx](https://github.com/coop-deluxe/sm64coopdx) |
+| Lenguaje | C |
+| Puerto | 7777 (UDP) |
+| Jugadores | Hasta 16 |
+| RAM | ~45 MB |
+
+### Archivos
+```
+servers/sm64coopdx/
+├── Dockerfile           # Multi-stage: compila desde fuente + runtime
+├── .dockerignore
+├── .gitignore           # Excluye ROMs (*.z64, *.n64, *.v64)
+└── baserom.us.z64       # ROM de SM64 US (no en git, requerida para build)
+```
+
+### Requisitos
+Se necesita la ROM de Super Mario 64 US (`baserom.us.z64`, MD5: `20b854b239203baf6c961b850a4a51a2`) en `servers/sm64coopdx/` antes de construir la imagen Docker.
+
+### Cómo funciona
+El Dockerfile compila sm64coopdx desde fuente con `HEADLESS=1 DISCORD_SDK=0 COOPNET=0`. Incluye dos parches:
+1. **float.h** — GCC 11 requiere include explícito de `<float.h>` para `FLT_EPSILON`
+2. **platform.c** — El fallback headless (sin SDL2) tiene funciones renombradas que upstream no actualizo (`sys_exe_path_dir`, `sys_resource_path`)
+
+La ROM es necesaria tanto en build (extracción de assets) como en runtime (validación MD5 al iniciar).
+
+### Configuracion
+Variables de entorno en `docker-compose.dev.yml`:
+- `SM64_PORT`: Puerto UDP del servidor (default: 7777)
+- `SM64_PLAYERS`: Maximo de jugadores (default: 16)
+
+### Conexion de cliente
+1. Descargar [sm64coopdx](https://github.com/coop-deluxe/sm64coopdx) (requiere compilar con la misma ROM)
+2. Abrir sm64coopdx → Join → Direct Connection
+3. Ingresar `play.consultoria-as.com:7777` (o `192.168.10.234:7777` en LAN)
+
+### Mods incluidos
+El build incluye mods bundled del repositorio: character-select, star-road, arena, day-night-cycle, sm74.
+
+### Troubleshooting
+- **"could not find valid vanilla us sm64 rom"**: La ROM debe estar tanto en el build como en el runtime. Verificar que el Dockerfile copia `baserom.us.z64` al stage de runtime
+- **100% CPU**: Normal — el game loop headless no tiene frame limiter porque no renderiza graficos
+- **No se conectan jugadores**: Verificar que el puerto 7777/UDP esta abierto en el router y que el firewall permite UDP
+
+---
+
+## N64 Netplay (gopher64 — Mario Party 1-3)
+
+### Resumen
+| Dato | Valor |
+|------|-------|
+| Proyecto | [gopher64-netplay-server](https://github.com/gopher64/gopher64-netplay-server) |
+| Imagen Docker | k4rian/gopher64-netplay-server |
+| Lenguaje | Go |
+| Puertos | 45000-45004 (TCP + UDP) |
+| Jugadores | 4 por sala, 4 salas concurrentes |
+| RAM | <1 MB (heap ~660 KB) |
+
+### Cómo funciona
+Servidor relay headless que retransmite inputs de controles N64 entre jugadores via WebSocket (lobby) + UDP (gameplay). No ejecuta el juego — cada jugador corre su propio emulador con su ROM. El servidor solo coordina la sincronización.
+
+- **Puerto 45000**: WebSocket lobby (creación de salas, chat, conexión)
+- **Puertos 45001-45004**: Sesiones de juego individuales (TCP + UDP)
+- **LAN discovery**: Activado por defecto, los emuladores en la misma red lo detectan automáticamente
+
+### Configuracion
+Variables de entorno en `docker-compose.dev.yml`:
+- `G64NS_NAME`: Nombre del servidor ("Afterlife N64 - Mario Party")
+- `G64NS_PORT`: Puerto base (default: 45000)
+- `G64NS_MAXGAMES`: Partidas concurrentes (default: 4)
+- `G64NS_MOTD`: Mensaje de bienvenida
+- `G64NS_DISABLEBROADCAST`: Desactivar LAN discovery (default: false)
+- `G64NS_ENABLEAUTH`: Activar autenticación (default: false)
+
+### Juegos soportados
+Cualquier juego de N64, pero diseñado especialmente para:
+- **Mario Party 1** (N64)
+- **Mario Party 2** (N64)
+- **Mario Party 3** (N64)
+
+Todos los jugadores deben usar el **mismo emulador** y el **mismo ROM** (se verifica MD5).
+
+### Emuladores compatibles (cliente)
+| Emulador | Custom server | Estado |
+|----------|---------------|--------|
+| **gopher64** | Si (v1.1.1+) | Activo, recomendado |
+| **RMG** (Rosalie's Mupen GUI) | Si (v0.8.0+) | Activo |
+| **simple64** | Si | Archivado (usar gopher64) |
+
+### Conexion de cliente
+1. Descargar [gopher64](https://github.com/gopher64/gopher64) o RMG
+2. Tener el ROM de Mario Party
+3. Netplay → Server: seleccionar "Custom"
+4. Ingresar `play.consultoria-as.com:45000` (o `192.168.10.234:45000` en LAN)
+5. Un jugador crea sala, los demás se unen
+
+### Troubleshooting
+- **"Different ROM" error**: Todos los jugadores deben tener exactamente el mismo archivo ROM (se compara MD5)
+- **No se puede conectar**: Verificar puertos TCP+UDP 45000-45004 abiertos en router
+- **Cross-emulator no funciona**: Todos deben usar el mismo emulador (no mezclar gopher64 con RMG)
+
+---
+
+## Dolphin Traversal Server (GameCube / Wii)
+
+### Resumen
+| Dato | Valor |
+|------|-------|
+| Proyecto | [Dolphin Emulator](https://github.com/dolphin-emu/dolphin) (componente traversal_server) |
+| Lenguaje | C++ |
+| Puertos | 6262, 6226 (UDP) |
+| RAM | <10 MB |
+
+### Cómo funciona
+Servidor de NAT hole-punching para Dolphin netplay. **No retransmite datos de juego** — solo facilita la conexión inicial entre dos instancias de Dolphin que están detrás de NAT/firewall. Una vez conectados, el tráfico de juego fluye directamente peer-to-peer.
+
+- **Puerto 6262 (UDP)**: Puerto principal de traversal
+- **Puerto 6226 (UDP)**: Puerto alternativo para probar tipo de NAT
+
+El servidor es completamente stateless (sin persistencia), single-threaded, y las entradas de clientes expiran después de 30 segundos de inactividad.
+
+### Build
+Multi-stage Docker build que compila solo el target `traversal_server` del repositorio completo de Dolphin. La build es pesada (~20 min) pero el binary final es tiny.
+
+```
+servers/dolphin-traversal/
+├── Dockerfile           # Multi-stage: debian build + debian-slim runtime
+└── .dockerignore
+```
+
+### Configuracion
+El traversal server **no tiene opciones de configuración**. Los puertos (6262/6226) están hardcodeados en el código fuente. No acepta argumentos de línea de comandos ni variables de entorno.
+
+### Juegos soportados
+**TODOS** los juegos de GameCube y Wii que se pueden jugar en Dolphin, incluyendo:
+- Mario Party 4, 5, 6, 7
+- Mario Kart: Double Dash
+- Super Smash Bros. Melee
+- F-Zero GX
+- Kirby Air Ride
+- The Legend of Zelda: Wind Waker
+- Y cualquier otro juego de GC/Wii
+
+### Conexion de cliente
+1. Descargar [Dolphin Emulator](https://dolphin-emu.org/)
+2. Ir a Config → General → Netplay (o Config → Network en versiones nuevas)
+3. Cambiar **Traversal Server** a: `play.consultoria-as.com`
+4. **Traversal Port**: `6262`
+5. Un jugador hostea (NetPlay → Host), los demás se unen con el **Host Code** generado
+6. Todos necesitan la misma ISO/ROM del juego
+
+### Troubleshooting
+- **No se genera Host Code**: Verificar que los puertos UDP 6262 y 6226 están abiertos
+- **Conexión lenta o fallida**: El traversal solo facilita el handshake; si la conexión P2P falla, los jugadores pueden intentar Direct Connection (requiere que el host abra puertos)
+- **Sin logs**: Normal — el servidor no logea nada por defecto (solo errores a stderr)
+- **Desyncs en juego**: Ambos jugadores deben usar la misma versión de Dolphin y la misma ISO
+
+---
+
 ## Operaciones Comunes
 
 ### Ver logs de un servidor
@@ -196,6 +362,9 @@ Con 200+ mods, el mod Hexerei tarda mas de 60 segundos generando recetas al inic
 docker logs -f minecraft-ftb          # Minecraft
 docker logs -f maple2-world           # MapleStory 2 World
 docker logs -f docker-openfusion-1    # OpenFusion
+docker logs -f sm64coopdx             # SM64 Coop
+docker logs -f n64-netplay            # N64 Netplay (Mario Party)
+docker logs -f dolphin-traversal      # Dolphin Traversal (GC/Wii)
 ```
 
 ### Reiniciar un servidor
@@ -203,6 +372,9 @@ docker logs -f docker-openfusion-1    # OpenFusion
 docker restart minecraft-ftb
 docker restart maple2-world maple2-login docker-maple2-game-ch0-1
 docker restart docker-openfusion-1
+docker restart sm64coopdx
+docker restart n64-netplay
+docker restart dolphin-traversal
 ```
 
 ### Ver uso de recursos