Initial commit: DeathWatch, an Elden Ring death counter for OBS
Reads the game's process memory read-only (AOB signature scanning, re-resolved every tick — never a cached pointer) and serves a live death counter as a browser-source overlay plus a status panel. Supports co-op: each player runs the program locally, one acts as hub. The peer link is authenticated (HMAC challenge/response, no token on the wire, constant-time compare) but not yet encrypted — see CLAUDE.md's TODO section for the planned TLS+pinning split. Zero external dependencies — including a hand-rolled WebSocket implementation — so the whole thing ships as one .exe.
This commit is contained in:
emmatherock committed
commit
e1f7e6f529
18 files changed
+3690
No files matched your search
+11
@@ -0,0 +1,11 @@
|
|||||||
|
# binarios y estado local, no van al repo
|
||||||
|
deathwatch.exe
|
||||||
|
*.exe
|
||||||
|
totals.json
|
||||||
|
client-id.txt
|
||||||
|
config.toml
|
||||||
|
offset.txt
|
||||||
|
token.txt
|
||||||
|
|
||||||
|
# config local de Claude Code (auto mode), especifica de esta maquina
|
||||||
|
.claude/settings.local.json
|
||||||
@@ -0,0 +1,276 @@
|
|||||||
|
# DeathWatch — contador de muertes de Elden Ring
|
||||||
|
|
||||||
|
Lee en **solo lectura** la memoria del proceso de Elden Ring y expone el
|
||||||
|
contador de muertes como overlay web para OBS. Soporta co-op: cada jugador
|
||||||
|
corre el programa en su PC y uno hace de hub.
|
||||||
|
|
||||||
|
## Comandos
|
||||||
|
|
||||||
|
```bash
|
||||||
|
GOOS=windows GOARCH=amd64 go build -o deathwatch.exe . # el binario (hoy, unico soportado)
|
||||||
|
go test ./... # tests (corren en cualquier SO)
|
||||||
|
gofmt -l *.go # formato
|
||||||
|
GOOS=windows GOARCH=amd64 go vet . # vet: SIEMPRE con GOOS=windows
|
||||||
|
```
|
||||||
|
|
||||||
|
`go vet` sin `GOOS=windows` falla con `syscall.Handle undefined`. No es un
|
||||||
|
error del código: es que `main.go` e `i18n.go` solo compilan para Windows.
|
||||||
|
|
||||||
|
## Idioma del código
|
||||||
|
|
||||||
|
El repo va a publicarse en GitHub. **Identificadores, comentarios y
|
||||||
|
mensajes de log/consola van en inglés** — código nuevo se escribe
|
||||||
|
directamente en inglés, sin excepción. `names.go` y `names_test.go` son
|
||||||
|
el primer archivo escrito bajo esta regla; úsenlo de referencia.
|
||||||
|
|
||||||
|
El resto del código (`main.go`, `i18n.go`, `counter.go`, `totals.go`,
|
||||||
|
`config.go`, `duo.go`, `ws.go`, `auth.go`, comentarios de `overlay.html`)
|
||||||
|
todavía está en español — ver el pendiente de traducción más abajo. Esto
|
||||||
|
**no** afecta a los textos que ve el usuario final en el overlay/panel
|
||||||
|
(`locales/*.json`, `overlay.html`): esos siguen soportando español e
|
||||||
|
inglés vía el sistema de i18n existente, elegido por idioma del sistema.
|
||||||
|
|
||||||
|
## Estructura
|
||||||
|
|
||||||
|
| Archivo | Qué hace | Plataforma |
|
||||||
|
|---|---|---|
|
||||||
|
| `main.go` | Lectura de memoria, escaneo de firmas, loop de polling, HTTP | solo Windows |
|
||||||
|
| `i18n.go` | Carga de `locales/*.json`, idioma del sistema | solo Windows |
|
||||||
|
| `counter.go` | **Contabilidad**: a qué personaje va cada muerte | portable |
|
||||||
|
| `names.go` | `looksLikeName`: filtra basura binaria leída como nombre | portable |
|
||||||
|
| `totals.go` | Persistencia por personaje (`totals.json`) | portable |
|
||||||
|
| `config.go` | Parser TOML propio + `config.toml` | portable |
|
||||||
|
| `duo.go` | Modo co-op: registro de peers, hub y peer | portable |
|
||||||
|
| `ws.go` | WebSocket hecho a mano (RFC 6455, subconjunto) | portable |
|
||||||
|
| `overlay.html` | Overlay e interfaz, embebido con `go:embed` | — |
|
||||||
|
|
||||||
|
`counter.go` está separado de `main.go` **a propósito**: es donde vivieron
|
||||||
|
los tres bugs de conteo, y separarlo es lo que permite testearlo sin una PC
|
||||||
|
con el juego abierto. Si agregás reglas de conteo, van ahí, con test.
|
||||||
|
`names.go` sigue el mismo principio para `looksLikeName`.
|
||||||
|
|
||||||
|
## Offsets de memoria
|
||||||
|
|
||||||
|
Todo se resuelve escaneando firmas AOB en el módulo del juego. Los tres
|
||||||
|
punteros se **re-dereferencian en cada tick**, nunca se cachea la dirección
|
||||||
|
final (ver "Reglas" abajo).
|
||||||
|
|
||||||
|
| Qué | Firma | Uso |
|
||||||
|
|---|---|---|
|
||||||
|
| `GameDataMan` | `48 8B 05 ?? ?? ?? ?? 48 85 C0 74 05 48 8B 40 58 C3 C3` | `+0x94` muertes (int32), `+0xC0` flag de jefe (byte) |
|
||||||
|
| `WorldChrMan` | `48 8B 35 ?? ?? ?? ?? 48 85 F6 ?? ?? BB 01 00 00 00 89 5C 24 20 48 8B B6` | `+0x1E508` → `PlayerIns`; si es nulo, no hay personaje en el mundo |
|
||||||
|
| `GameMan` | `48 8B 05 ?? ?? ?? ?? 80 B8 ?? ?? ?? ?? 0D 0F 94 C0 C3` | `+0xAC0` (byte) = slot de guardado 0-9 |
|
||||||
|
|
||||||
|
Nombre del personaje: `[GameDataMan+0x08]+0x9C`, UTF-16, máx 19 caracteres.
|
||||||
|
Se prueban tres variantes y gana la que devuelva algo que parezca un nombre
|
||||||
|
dos lecturas seguidas. "Parecer un nombre" (`looksLikeName` en `names.go`)
|
||||||
|
exige **coherencia de escritura**: todo el texto tiene que venir de una
|
||||||
|
sola familia (Latina, Cirílica, Hangul, o Han+Hiragana+Katakana como una
|
||||||
|
sola familia porque el japonés las mezcla) más dígitos/espacio/puntuación.
|
||||||
|
Mezclar familias — como griego + han, que es lo que sale de decodificar un
|
||||||
|
puntero crudo como si fuera UTF-16 — se rechaza.
|
||||||
|
|
||||||
|
Procedencia: `GameDataMan` y `WorldChrMan` salen de
|
||||||
|
[SoulMemory](https://github.com/FrankvdStam/SoulSplitter) (el que usa el
|
||||||
|
auto-splitter de LiveSplit). `GameMan` y el nombre salen de una tabla de
|
||||||
|
Cheat Engine.
|
||||||
|
|
||||||
|
## Seguridad del enlace entre hub y peer
|
||||||
|
|
||||||
|
El transporte **no se asume confiable**: puede ser Tailscale, ZeroTier,
|
||||||
|
WireGuard, o un puerto abierto directo a internet. La conexión se defiende
|
||||||
|
sola (`auth.go`).
|
||||||
|
|
||||||
|
- El token es **obligatorio**. Lo genera el programa (`token.txt`, 128
|
||||||
|
bits); `token` en `config.toml` lo pisa si alguien quiere elegirlo.
|
||||||
|
- **El token nunca viaja.** El hub manda un nonce al azar y el peer
|
||||||
|
responde `HMAC-SHA256(token, nonce)`. Quien escuche el tráfico no se
|
||||||
|
lleva el token, y una respuesta capturada no sirve en otra conexión
|
||||||
|
porque el nonce cambia.
|
||||||
|
- Comparación en **tiempo constante** (`subtle.ConstantTimeCompare`).
|
||||||
|
- Sin autenticar no se acepta ningún mensaje; hay plazo de 10 s para
|
||||||
|
autenticarse y techo de 8 conexiones simultáneas.
|
||||||
|
- El `id` que vale es el de la conexión autenticada, no el que declare
|
||||||
|
cada mensaje.
|
||||||
|
|
||||||
|
**Lo que esto NO hace: cifrar.** Los mensajes (nombre y número de muertes)
|
||||||
|
viajan en claro, y un atacante activo en el medio podría alterarlos. El
|
||||||
|
token garantiza que nadie **inyecte** datos falsos, no que nadie los lea.
|
||||||
|
Está pendiente cifrarlo (ver Pendientes).
|
||||||
|
|
||||||
|
Los tests de esto están en `auth_test.go` y cubren: token correcto, token
|
||||||
|
equivocado, mensajes sin autenticar, que el token no aparezca en el
|
||||||
|
tráfico, y que una respuesta vieja no se pueda repetir.
|
||||||
|
|
||||||
|
## Reglas que salieron de bugs reales
|
||||||
|
|
||||||
|
No son preferencias de estilo. Cada una costó un bug en producción.
|
||||||
|
|
||||||
|
1. **Re-dereferenciar los punteros en cada tick.** Cachear la dirección de
|
||||||
|
`GameDataMan` hacía que, tras volver al menú, se siguiera leyendo con
|
||||||
|
éxito una dirección que ya era otra cosa: el contador subía solo. La
|
||||||
|
clase `Pointer` de SoulMemory también resuelve la cadena en cada lectura.
|
||||||
|
|
||||||
|
2. **El nombre NO es identidad.** Cambia al cargar otro personaje. La
|
||||||
|
identidad de un personaje es el **slot** (`characterKey`); la de una
|
||||||
|
instalación es el **client-id** (`client-id.txt`). Indexar por nombre
|
||||||
|
produjo jugadores fantasma dos veces, una en Go y otra en el DOM.
|
||||||
|
|
||||||
|
3. **Las columnas del overlay se indexan por posición, nunca por nombre.**
|
||||||
|
Mismo bug que el anterior, del lado del navegador.
|
||||||
|
|
||||||
|
4. **No recalibrar en pantallas de carga.** Hay una pantalla de carga en
|
||||||
|
cada muerte; tratarlas como cambio de partida se come muertes.
|
||||||
|
|
||||||
|
5. **Descartar lecturas imposibles.** Dentro de una misma partida el
|
||||||
|
contador no baja ni sube de a más de 3 por segundo. Si pasa, es memoria
|
||||||
|
inválida: descartar y re-escanear las firmas.
|
||||||
|
|
||||||
|
6. **Nada de timeouts como heurística.** Un watchdog basado en "pasaron N
|
||||||
|
minutos" dio falso positivo con el juego parado en el menú. Si hace
|
||||||
|
falta detectar que algo anda mal, usar evidencia (¿subió el contador?),
|
||||||
|
no el reloj.
|
||||||
|
|
||||||
|
7. **Los logs de consola no se traducen.** Son diagnóstico; conviene que un
|
||||||
|
log pegado en un issue se lea igual venga de donde venga.
|
||||||
|
|
||||||
|
## Detalles que sorprenden
|
||||||
|
|
||||||
|
- **La versión del exe no es la del juego.** El exe dice `2.7.1.0` mientras
|
||||||
|
el juego muestra `1.17.1`. Por eso el offset de `PlayerIns` no se elige
|
||||||
|
por número de versión: se prueban los candidatos conocidos y se verifica
|
||||||
|
leyendo memoria.
|
||||||
|
- **El parser TOML es propio y acotado** (`config.go`): sin arrays, tablas
|
||||||
|
inline, strings multilínea ni claves con puntos. Se hizo así porque el
|
||||||
|
entorno donde se compiló no tenía acceso a `proxy.golang.org`. Si se
|
||||||
|
puede usar `BurntSushi/toml`, se cambia sólo `loadConfig`.
|
||||||
|
- **Cero dependencias externas**, incluido el WebSocket. Es deliberado: el
|
||||||
|
programa se reparte como un único `.exe`.
|
||||||
|
|
||||||
|
## Pendientes
|
||||||
|
|
||||||
|
- Pasada completa a inglés: identificadores, comentarios, mensajes de
|
||||||
|
log/consola y el README (hoy todo está en español salvo `names.go` y
|
||||||
|
`names_test.go`, ver "Idioma del código" arriba). Conviene que sea un
|
||||||
|
commit aparte del resto, dado el volumen del diff.
|
||||||
|
- La identificación por nombre (respaldo cuando no se lee el slot) mezcla
|
||||||
|
personajes homónimos. Documentado, no resuelto.
|
||||||
|
- **Compilar y correr en Linux (Proton).** Mucha gente juega Elden Ring
|
||||||
|
con Proton, y hoy el programa sólo existe para Windows. El juego sigue
|
||||||
|
siendo el mismo binario de Windows corriendo bajo Wine, así que **las
|
||||||
|
firmas AOB y todos los offsets valen igual**: lo único que cambia es
|
||||||
|
cómo se encuentra el proceso y cómo se lee su memoria.
|
||||||
|
|
||||||
|
**Refactor primero.** Hoy `main.go` mezcla lo específico de Windows con
|
||||||
|
lo que no lo es. Separar en `process_windows.go` y `process_linux.go`
|
||||||
|
detrás de unas pocas funciones — `findProcessID`, `openProcess`,
|
||||||
|
`readMemory`, `findModuleBase`, `productVersion`, `systemLang` — y dejar
|
||||||
|
el resto (escaneo de firmas, resolución de punteros, loop de polling,
|
||||||
|
lectura del nombre) en un archivo portable. Beneficio extra que vale por
|
||||||
|
sí solo: con eso el escaneo y el polling **se pueden testear con un
|
||||||
|
lector de memoria falso**, que es justo la parte que hoy no tiene tests.
|
||||||
|
|
||||||
|
Lo específico de Linux:
|
||||||
|
|
||||||
|
1. **Encontrar el proceso por sus mapeos, no por el nombre.** Proton
|
||||||
|
levanta varios procesos. Lo robusto es recorrer `/proc/*/maps` y
|
||||||
|
quedarse con el pid que tenga mapeado un archivo terminado en
|
||||||
|
`eldenring.exe`. De paso, esos mismos mapeos dan la base y el tamaño
|
||||||
|
del módulo, que es lo que `findModuleBase` necesita. Puede venir
|
||||||
|
partido en varios tramos (`.text`, `.rdata`, `.data`) con permisos
|
||||||
|
distintos: tomar el span completo alcanza, porque el escáner ya lee
|
||||||
|
por chunks y saltea los que no puede leer.
|
||||||
|
2. **Leer con `process_vm_readv(2)`**, que no necesita adjuntarse al
|
||||||
|
proceso. `/proc/<pid>/mem` sirve de alternativa.
|
||||||
|
3. **El obstáculo real es `ptrace_scope`.** En casi todas las distros
|
||||||
|
vale `1`, y con eso `process_vm_readv` sobre un proceso ajeno falla
|
||||||
|
con `EPERM`. La salida recomendada es darle la capacidad al binario:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
sudo setcap cap_sys_ptrace+ep ./deathwatch
|
||||||
|
```
|
||||||
|
|
||||||
|
**No** recomendar `sysctl kernel.yama.ptrace_scope=0`, que baja la
|
||||||
|
defensa de todo el sistema, ni correrlo como root. Y que el mensaje
|
||||||
|
de error diga exactamente esto cuando falle: sin eso el programa
|
||||||
|
parece simplemente roto, y es el primer problema que va a tener
|
||||||
|
cualquiera que lo pruebe.
|
||||||
|
4. **`productVersion` no tiene equivalente** (usa `version.dll` sobre el
|
||||||
|
exe). En Linux devolver `ok=false` y listo: la versión es sólo una
|
||||||
|
corazonada para decidir qué offset de `PlayerIns` probar primero, y
|
||||||
|
el valor bueno se confirma leyendo memoria igual. Una decisión vieja
|
||||||
|
que acá se paga sola.
|
||||||
|
5. **`systemLang`** sale de `$LC_ALL` / `$LANG` en vez de
|
||||||
|
`GetUserDefaultLocaleName`.
|
||||||
|
|
||||||
|
No hay que tocar: los offsets, las firmas, `counter.go`, `names.go`,
|
||||||
|
`totals.go`, `duo.go`, `ws.go`, `config.go` ni el overlay. Ya son
|
||||||
|
portables.
|
||||||
|
|
||||||
|
**Modo sólo-hub, de regalo.** Un hub que no lee memoria —que sólo junta
|
||||||
|
lo de los peers y sirve el overlay— no necesita `setcap` ni permiso
|
||||||
|
alguno. Es exactamente el caso de quien tiene el OBS en una PC con Linux
|
||||||
|
y juega en otra, y sale casi gratis una vez separado lo de arriba.
|
||||||
|
|
||||||
|
Referencias de gente que ya leyó memoria de juegos bajo Proton:
|
||||||
|
[pika](https://github.com/delfianto/pika),
|
||||||
|
[cheat-engine-linux](https://github.com/wleeaf/cheat-engine-linux),
|
||||||
|
[un trainer para D2R en Linux paso a paso](https://axiom0x0.sh/posts/d2r-memory-trainer-part2/).
|
||||||
|
|
||||||
|
- **Cifrar el enlace con TLS (certificado propio + pinning).** Hoy la
|
||||||
|
conexión está autenticada pero no cifrada.
|
||||||
|
|
||||||
|
La forma seria es **TLS 1.3 de la biblioteca estándar**, no un protocolo
|
||||||
|
hecho a mano. El obstáculo aparente es que no hay dominio ni autoridad
|
||||||
|
certificadora posible: nadie emite un certificado para `100.x.y.z`. Pero
|
||||||
|
eso deja de importar al ver que **el problema de confianza ya está
|
||||||
|
resuelto fuera de banda**: los dos jugadores ya se pasan un secreto a
|
||||||
|
mano. Ese mismo canal puede llevar la huella del certificado.
|
||||||
|
|
||||||
|
1. El hub genera un certificado autofirmado en el primer arranque
|
||||||
|
(`crypto/x509` + `ed25519`) y lo guarda junto al token.
|
||||||
|
2. El peer se conecta con `tls.Client` usando `InsecureSkipVerify: true`
|
||||||
|
**y** un `VerifyPeerCertificate` que exige que la huella SHA-256 sea
|
||||||
|
exactamente la esperada. El nombre del flag asusta y en una revisión
|
||||||
|
parece un error: no lo es. Apaga la validación por CA y nombre de
|
||||||
|
dominio, que acá no aplican, y la reemplaza por *pinning*, que para
|
||||||
|
este caso es **más** estricto que la validación normal.
|
||||||
|
3. Un solo **código de invitación** que el hub imprime y el peer pega:
|
||||||
|
base64 de `{host, puerto, huella, token}`. Como ya tenían que copiar
|
||||||
|
algo, esto no agrega ni un paso, y a cambio la conexión pasa a estar
|
||||||
|
cifrada de verdad. Para quien lo usa, el tema desaparece.
|
||||||
|
|
||||||
|
Con eso se obtiene TLS 1.3 real: forward secrecy, AEAD y un handshake
|
||||||
|
revisado por medio mundo, sin dependencias externas y sin que nadie
|
||||||
|
tenga que entender nada.
|
||||||
|
|
||||||
|
**Dos puertos, no uno.** No se puede servir HTTP y HTTPS en el mismo
|
||||||
|
puerto, así que la separación no es un detalle de implementación sino
|
||||||
|
parte del diseño:
|
||||||
|
|
||||||
|
| Puerto | Sirve | Protocolo | Audiencia |
|
||||||
|
|---|---|---|---|
|
||||||
|
| 47822 | overlay, panel, `/deaths`, `/strings.json` | HTTP plano | OBS y el navegador, local o LAN |
|
||||||
|
| 47823 | sólo `/ws` | TLS + pinning | el peer, cruzando redes ajenas |
|
||||||
|
|
||||||
|
Esto resuelve lo obvio — un certificado autofirmado hace que OBS y el
|
||||||
|
navegador tiren advertencias o no carguen, y con puertos separados el
|
||||||
|
overlay nunca ve un certificado — pero el beneficio mayor es otro y
|
||||||
|
conviene no perderlo de vista:
|
||||||
|
|
||||||
|
**Achica lo que queda expuesto.** Hoy, quien abra el 47822 a internet
|
||||||
|
para que entre su compañero está publicando también el panel y
|
||||||
|
`/deaths`, que no piden nada y encima responden con
|
||||||
|
`Access-Control-Allow-Origin: *`: cualquiera puede leer los nombres de
|
||||||
|
los personajes y los contadores. Con la separación, el único puerto que
|
||||||
|
hace falta exponer sirve exclusivamente el endpoint autenticado, y el
|
||||||
|
del overlay se queda en casa. Si se implementa TLS, esta parte va
|
||||||
|
primero: vale por sí sola aunque el cifrado quede para después.
|
||||||
|
|
||||||
|
Implica una clave nueva en el config (algo como `peer_listen`), y que el
|
||||||
|
código de invitación lleve ese puerto y no el del overlay.
|
||||||
|
|
||||||
|
Detalles: si se regenera el certificado (reinstalación, borrado del
|
||||||
|
archivo) cambia la huella y hay que pasar un código nuevo; documentarlo.
|
||||||
|
Y el README igual debería mencionar que meter todo adentro de una VPN
|
||||||
|
sigue siendo una opción perfectamente válida.
|
||||||
@@ -0,0 +1,105 @@
|
|||||||
|
// auth.go: autenticacion entre el hub y los peers.
|
||||||
|
//
|
||||||
|
// El transporte NO se asume confiable. Puede ser Tailscale, ZeroTier,
|
||||||
|
// WireGuard, o un puerto abierto directo a internet: eso lo decide quien
|
||||||
|
// lo usa, no nosotros. Asi que la conexion se defiende sola.
|
||||||
|
//
|
||||||
|
// El token es OBLIGATORIO y lo genera el programa (nadie elige "1234"), y
|
||||||
|
// nunca viaja por la red: el hub manda un desafio al azar y el peer
|
||||||
|
// responde con un HMAC del desafio usando el token como clave. Quien
|
||||||
|
// escuche el trafico no se lleva el token, y no puede repetir una
|
||||||
|
// respuesta vieja porque el desafio cambia en cada conexion.
|
||||||
|
//
|
||||||
|
// Lo que esto NO hace: cifrar. Los mensajes (nombre y numero de muertes)
|
||||||
|
// viajan en claro. Para un contador de muertes en un stream es
|
||||||
|
// aceptable, pero si te importa, poné la conexion adentro de una VPN o
|
||||||
|
// un tunel con TLS. Lo que el token garantiza es que nadie pueda
|
||||||
|
// INYECTAR datos falsos en tu overlay.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/hmac"
|
||||||
|
"crypto/rand"
|
||||||
|
"crypto/sha256"
|
||||||
|
"crypto/subtle"
|
||||||
|
"encoding/hex"
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
tokenBytes = 16 // 128 bits
|
||||||
|
nonceBytes = 16
|
||||||
|
// Plazo para autenticarse. Una conexion que se queda callada tras el
|
||||||
|
// desafio se cierra en vez de ocupar un lugar para siempre.
|
||||||
|
authTimeoutSeconds = 10
|
||||||
|
// Techo de conexiones simultaneas: evita que alguien deje el puerto
|
||||||
|
// sin recursos abriendo sockets.
|
||||||
|
maxPeerConns = 8
|
||||||
|
)
|
||||||
|
|
||||||
|
func tokenPath() string {
|
||||||
|
if dir, ok := exeDir(); ok {
|
||||||
|
return filepath.Join(dir, "token.txt")
|
||||||
|
}
|
||||||
|
return "token.txt"
|
||||||
|
}
|
||||||
|
|
||||||
|
func randomHex(n int) (string, error) {
|
||||||
|
b := make([]byte, n)
|
||||||
|
if _, err := rand.Read(b); err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
return hex.EncodeToString(b), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// resolveToken decide el token efectivo. Si el config trae uno, manda ese
|
||||||
|
// (para quien quiera elegirlo a mano o compartir uno ya acordado). Si no,
|
||||||
|
// se usa el de token.txt, y si tampoco existe se genera uno y se guarda.
|
||||||
|
//
|
||||||
|
// Devuelve tambien si lo acaba de generar, para avisarlo fuerte en la
|
||||||
|
// consola: es lo que hay que pasarle al compañero.
|
||||||
|
func resolveToken(cfg config) (token string, generated bool, err error) {
|
||||||
|
if t := strings.TrimSpace(cfg.Token); t != "" {
|
||||||
|
return t, false, nil
|
||||||
|
}
|
||||||
|
path := tokenPath()
|
||||||
|
if data, rerr := os.ReadFile(path); rerr == nil {
|
||||||
|
if t := strings.TrimSpace(string(data)); t != "" {
|
||||||
|
return t, false, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
t, gerr := randomHex(tokenBytes)
|
||||||
|
if gerr != nil {
|
||||||
|
return "", false, fmt.Errorf("no pude generar un token: %w", gerr)
|
||||||
|
}
|
||||||
|
if werr := os.WriteFile(path, []byte(t), 0600); werr != nil {
|
||||||
|
return "", false, fmt.Errorf("no pude guardar token.txt: %w", werr)
|
||||||
|
}
|
||||||
|
return t, true, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// proofFor calcula la respuesta al desafio: HMAC-SHA256(token, nonce).
|
||||||
|
func proofFor(token, nonce string) string {
|
||||||
|
m := hmac.New(sha256.New, []byte(token))
|
||||||
|
m.Write([]byte(nonce))
|
||||||
|
return hex.EncodeToString(m.Sum(nil))
|
||||||
|
}
|
||||||
|
|
||||||
|
// proofValid compara en tiempo constante. Con == la comparacion corta en
|
||||||
|
// el primer byte distinto, y eso filtra informacion por tiempos.
|
||||||
|
func proofValid(token, nonce, got string) bool {
|
||||||
|
want := proofFor(token, nonce)
|
||||||
|
return subtle.ConstantTimeCompare([]byte(want), []byte(got)) == 1
|
||||||
|
}
|
||||||
|
|
||||||
|
func logTokenBanner(token string, generated bool) {
|
||||||
|
if generated {
|
||||||
|
log.Printf("generé un token nuevo y lo guardé en token.txt")
|
||||||
|
}
|
||||||
|
log.Printf("token de conexion: %s", token)
|
||||||
|
log.Printf("tu compañero tiene que poner ESE token en su config.toml; sin el, su conexion se rechaza")
|
||||||
|
}
|
||||||
+192
@@ -0,0 +1,192 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"net"
|
||||||
|
"net/http"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
// arrancaHub levanta un hub con un token dado y devuelve su direccion.
|
||||||
|
func arrancaHub(t *testing.T, token string) (*peerRegistry, string) {
|
||||||
|
t.Helper()
|
||||||
|
reg := newPeerRegistry()
|
||||||
|
ln, err := net.Listen("tcp", "127.0.0.1:0")
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
mux := http.NewServeMux()
|
||||||
|
mux.HandleFunc("/ws", reg.wsHandler(token))
|
||||||
|
srv := &http.Server{Handler: mux}
|
||||||
|
go srv.Serve(ln)
|
||||||
|
t.Cleanup(func() { srv.Close() })
|
||||||
|
return reg, ln.Addr().String()
|
||||||
|
}
|
||||||
|
|
||||||
|
func peers(reg *peerRegistry) int { return len(reg.views()) }
|
||||||
|
|
||||||
|
// El token correcto entra y sus datos llegan.
|
||||||
|
func TestTokenCorrectoEntra(t *testing.T) {
|
||||||
|
reg, addr := arrancaHub(t, "el-bueno")
|
||||||
|
c, err := wsDial(addr, "/ws", 3*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defer c.Close()
|
||||||
|
if err := authenticate(c, config{Token: "el-bueno", clientID: "abc"}); err != nil {
|
||||||
|
t.Fatalf("deberia haber autenticado: %v", err)
|
||||||
|
}
|
||||||
|
msg, _ := json.Marshal(peerMessage{Type: "state", ID: "abc", Name: "Fulano", Deaths: 7})
|
||||||
|
if err := c.WriteText(msg); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
esperarHasta(t, func() bool { return peers(reg) == 1 }, "el peer nunca aparecio")
|
||||||
|
if got := reg.views()[0].Deaths; got != 7 {
|
||||||
|
t.Fatalf("esperaba 7 muertes, dio %d", got)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// El token equivocado NO entra y no deja rastro.
|
||||||
|
func TestTokenEquivocadoNoEntra(t *testing.T) {
|
||||||
|
reg, addr := arrancaHub(t, "el-bueno")
|
||||||
|
c, err := wsDial(addr, "/ws", 3*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defer c.Close()
|
||||||
|
_ = authenticate(c, config{Token: "el-malo", clientID: "x"})
|
||||||
|
msg, _ := json.Marshal(peerMessage{Type: "state", ID: "x", Name: "Intruso", Deaths: 999})
|
||||||
|
c.WriteText(msg)
|
||||||
|
time.Sleep(700 * time.Millisecond)
|
||||||
|
if peers(reg) != 0 {
|
||||||
|
t.Fatalf("el hub acepto datos con el token equivocado: %+v", reg.views())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Mandar datos SIN autenticarse tampoco funciona.
|
||||||
|
func TestSinAutenticarNoEntra(t *testing.T) {
|
||||||
|
reg, addr := arrancaHub(t, "el-bueno")
|
||||||
|
c, err := wsDial(addr, "/ws", 3*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defer c.Close()
|
||||||
|
msg, _ := json.Marshal(peerMessage{Type: "state", ID: "x", Name: "Intruso", Deaths: 999})
|
||||||
|
c.WriteText(msg)
|
||||||
|
time.Sleep(700 * time.Millisecond)
|
||||||
|
if peers(reg) != 0 {
|
||||||
|
t.Fatalf("el hub acepto datos sin autenticacion: %+v", reg.views())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// El token no viaja: lo unico que sale del peer es un HMAC del desafio.
|
||||||
|
func TestElTokenNoViajaPorLaRed(t *testing.T) {
|
||||||
|
_, addr := arrancaHub(t, "secreto-muy-secreto")
|
||||||
|
c, err := wsDial(addr, "/ws", 3*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defer c.Close()
|
||||||
|
|
||||||
|
raw, err := c.ReadMessage() // el desafio
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
var ch authChallenge
|
||||||
|
json.Unmarshal(raw, &ch)
|
||||||
|
if ch.Nonce == "" {
|
||||||
|
t.Fatal("el hub no mando desafio")
|
||||||
|
}
|
||||||
|
reply, _ := json.Marshal(authReply{Type: "auth", ID: "x", Proof: proofFor("secreto-muy-secreto", ch.Nonce)})
|
||||||
|
if string(reply) == "" {
|
||||||
|
t.Fatal("respuesta vacia")
|
||||||
|
}
|
||||||
|
for _, b := range [][]byte{raw, reply} {
|
||||||
|
if contiene(string(b), "secreto-muy-secreto") {
|
||||||
|
t.Fatalf("el token aparece en el trafico: %s", b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Una respuesta capturada no sirve en otra conexion: el desafio cambia.
|
||||||
|
func TestNoSePuedeRepetirUnaRespuestaVieja(t *testing.T) {
|
||||||
|
reg, addr := arrancaHub(t, "el-bueno")
|
||||||
|
|
||||||
|
c1, err := wsDial(addr, "/ws", 3*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
raw, _ := c1.ReadMessage()
|
||||||
|
var ch1 authChallenge
|
||||||
|
json.Unmarshal(raw, &ch1)
|
||||||
|
proofViejo := proofFor("el-bueno", ch1.Nonce)
|
||||||
|
c1.Close()
|
||||||
|
|
||||||
|
c2, err := wsDial(addr, "/ws", 3*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
defer c2.Close()
|
||||||
|
raw2, _ := c2.ReadMessage()
|
||||||
|
var ch2 authChallenge
|
||||||
|
json.Unmarshal(raw2, &ch2)
|
||||||
|
if ch2.Nonce == ch1.Nonce {
|
||||||
|
t.Fatal("el desafio se repitio entre conexiones: el nonce tiene que ser distinto")
|
||||||
|
}
|
||||||
|
reply, _ := json.Marshal(authReply{Type: "auth", ID: "x", Proof: proofViejo})
|
||||||
|
c2.WriteText(reply)
|
||||||
|
msg, _ := json.Marshal(peerMessage{Type: "state", ID: "x", Name: "Repetidor", Deaths: 1})
|
||||||
|
c2.WriteText(msg)
|
||||||
|
time.Sleep(700 * time.Millisecond)
|
||||||
|
if peers(reg) != 0 {
|
||||||
|
t.Fatalf("el hub acepto una respuesta repetida: %+v", reg.views())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// El token generado es aleatorio y de largo razonable.
|
||||||
|
func TestTokenGeneradoEsFuerte(t *testing.T) {
|
||||||
|
testExeDir = t.TempDir()
|
||||||
|
a, gen, err := resolveToken(config{})
|
||||||
|
if err != nil || !gen {
|
||||||
|
t.Fatalf("deberia haber generado uno: gen=%v err=%v", gen, err)
|
||||||
|
}
|
||||||
|
if len(a) != tokenBytes*2 {
|
||||||
|
t.Fatalf("largo inesperado: %d", len(a))
|
||||||
|
}
|
||||||
|
// la segunda vez lo lee del archivo, no genera otro
|
||||||
|
b, gen2, _ := resolveToken(config{})
|
||||||
|
if gen2 || a != b {
|
||||||
|
t.Fatalf("deberia reusar el guardado: %q vs %q (gen=%v)", a, b, gen2)
|
||||||
|
}
|
||||||
|
// y en otra instalacion sale distinto
|
||||||
|
testExeDir = t.TempDir()
|
||||||
|
c, _, _ := resolveToken(config{})
|
||||||
|
if c == a {
|
||||||
|
t.Fatal("dos instalaciones generaron el mismo token")
|
||||||
|
}
|
||||||
|
testExeDir = ""
|
||||||
|
}
|
||||||
|
|
||||||
|
func contiene(s, sub string) bool {
|
||||||
|
return len(sub) > 0 && len(s) >= len(sub) && (func() bool {
|
||||||
|
for i := 0; i+len(sub) <= len(s); i++ {
|
||||||
|
if s[i:i+len(sub)] == sub {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
})()
|
||||||
|
}
|
||||||
|
|
||||||
|
func esperarHasta(t *testing.T, cond func() bool, msg string) {
|
||||||
|
t.Helper()
|
||||||
|
deadline := time.Now().Add(4 * time.Second)
|
||||||
|
for time.Now().Before(deadline) {
|
||||||
|
if cond() {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
time.Sleep(50 * time.Millisecond)
|
||||||
|
}
|
||||||
|
t.Fatal(msg)
|
||||||
|
}
|
||||||
@@ -0,0 +1,312 @@
|
|||||||
|
// config.go: lectura de config.toml.
|
||||||
|
//
|
||||||
|
// Parser de TOML hecho a mano y a proposito ACOTADO. La razon de no usar
|
||||||
|
// una libreria (BurntSushi/toml o similar) es que el entorno donde se
|
||||||
|
// compila esto no tiene acceso al proxy de modulos de Go, y ademas
|
||||||
|
// mantiene el programa como un unico .exe sin dependencias.
|
||||||
|
//
|
||||||
|
// Soporta: comentarios (#), cabeceras de seccion ([algo]), y claves
|
||||||
|
// "clave = valor" donde el valor es un string ("..." o '...'), un
|
||||||
|
// booleano o un entero. NO soporta arrays, tablas inline, strings
|
||||||
|
// multilinea ni claves con puntos. Cualquier cosa fuera de ese subconjunto
|
||||||
|
// se reporta con numero de linea en vez de ignorarse en silencio: es
|
||||||
|
// preferible enterarse al arrancar y no a mitad de un stream.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/rand"
|
||||||
|
"encoding/hex"
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
// Escucha en todas las interfaces: OBS suele correr en otra PC de la
|
||||||
|
// LAN, asi que 127.0.0.1 (solo local) no alcanza.
|
||||||
|
listenAddr = "0.0.0.0:47822"
|
||||||
|
buildTag = "build-20-auth-obligatoria"
|
||||||
|
)
|
||||||
|
|
||||||
|
type config struct {
|
||||||
|
Name string // como se muestra este jugador; vacio = nombre del personaje
|
||||||
|
Mode string // "hub" o "peer"
|
||||||
|
Listen string // donde se sirve el panel/overlay
|
||||||
|
Hub string // modo peer: direccion del hub
|
||||||
|
Token string // secreto compartido opcional
|
||||||
|
Partner string // opcional: fuerza el modo coop reservando este nombre
|
||||||
|
Language string // idioma de la interfaz: "auto", "en", "es", ...
|
||||||
|
|
||||||
|
clientID string // no viene del archivo: ver clientID()
|
||||||
|
}
|
||||||
|
|
||||||
|
func defaultConfig() config {
|
||||||
|
return config{
|
||||||
|
Mode: "hub",
|
||||||
|
Listen: listenAddr,
|
||||||
|
Language: "auto",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func configPath() string {
|
||||||
|
exe, err := os.Executable()
|
||||||
|
if err != nil {
|
||||||
|
return "config.toml"
|
||||||
|
}
|
||||||
|
return filepath.Join(filepath.Dir(exe), "config.toml")
|
||||||
|
}
|
||||||
|
|
||||||
|
// tomlValue es un valor ya parseado: guardamos el texto crudo porque
|
||||||
|
// todas nuestras claves son strings, pero validamos el tipo igual.
|
||||||
|
type tomlValue struct {
|
||||||
|
str string
|
||||||
|
line int
|
||||||
|
}
|
||||||
|
|
||||||
|
// parseTOML devuelve el mapa de claves de la tabla raiz. Las claves
|
||||||
|
// dentro de una seccion quedan como "seccion.clave".
|
||||||
|
func parseTOML(src string) (map[string]tomlValue, []string) {
|
||||||
|
out := map[string]tomlValue{}
|
||||||
|
var problems []string
|
||||||
|
section := ""
|
||||||
|
|
||||||
|
for i, raw := range strings.Split(src, "\n") {
|
||||||
|
lineNo := i + 1
|
||||||
|
line := strings.TrimSpace(raw)
|
||||||
|
if line == "" || strings.HasPrefix(line, "#") {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if strings.HasPrefix(line, "[") {
|
||||||
|
if !strings.HasSuffix(line, "]") || strings.HasPrefix(line, "[[") {
|
||||||
|
problems = append(problems, fmt.Sprintf("linea %d: cabecera de seccion que no entiendo: %s", lineNo, line))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
section = strings.TrimSpace(line[1 : len(line)-1])
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
key, rest, ok := strings.Cut(line, "=")
|
||||||
|
if !ok {
|
||||||
|
problems = append(problems, fmt.Sprintf("linea %d: esperaba \"clave = valor\" y encontre: %s", lineNo, line))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
key = strings.TrimSpace(key)
|
||||||
|
if key == "" {
|
||||||
|
problems = append(problems, fmt.Sprintf("linea %d: falta el nombre de la clave", lineNo))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if section != "" {
|
||||||
|
key = section + "." + key
|
||||||
|
}
|
||||||
|
|
||||||
|
val, err := parseTOMLValue(strings.TrimSpace(rest))
|
||||||
|
if err != nil {
|
||||||
|
problems = append(problems, fmt.Sprintf("linea %d (%s): %v", lineNo, key, err))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
out[strings.ToLower(key)] = tomlValue{str: val, line: lineNo}
|
||||||
|
}
|
||||||
|
return out, problems
|
||||||
|
}
|
||||||
|
|
||||||
|
func parseTOMLValue(s string) (string, error) {
|
||||||
|
if s == "" {
|
||||||
|
return "", fmt.Errorf("falta el valor")
|
||||||
|
}
|
||||||
|
switch s[0] {
|
||||||
|
case '"':
|
||||||
|
return parseQuoted(s, '"', true)
|
||||||
|
case '\'':
|
||||||
|
return parseQuoted(s, '\'', false)
|
||||||
|
case '[', '{':
|
||||||
|
return "", fmt.Errorf("este programa no soporta listas ni tablas inline")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sin comillas: booleano o entero. Cortamos un comentario al final.
|
||||||
|
if idx := strings.Index(s, "#"); idx >= 0 {
|
||||||
|
s = strings.TrimSpace(s[:idx])
|
||||||
|
}
|
||||||
|
switch strings.ToLower(s) {
|
||||||
|
case "true":
|
||||||
|
return "true", nil
|
||||||
|
case "false":
|
||||||
|
return "false", nil
|
||||||
|
}
|
||||||
|
if _, err := strconv.ParseInt(s, 10, 64); err == nil {
|
||||||
|
return s, nil
|
||||||
|
}
|
||||||
|
return "", fmt.Errorf("valor sin comillas que no es booleano ni entero: %q (¿te faltaron las comillas?)", s)
|
||||||
|
}
|
||||||
|
|
||||||
|
// parseQuoted lee un string entre comillas y descarta lo que venga
|
||||||
|
// despues si es un comentario. Con comillas dobles interpreta los
|
||||||
|
// escapes mas comunes; con simples el contenido es literal, como en TOML.
|
||||||
|
func parseQuoted(s string, quote byte, escapes bool) (string, error) {
|
||||||
|
var sb strings.Builder
|
||||||
|
for i := 1; i < len(s); i++ {
|
||||||
|
c := s[i]
|
||||||
|
if escapes && c == '\\' {
|
||||||
|
if i+1 >= len(s) {
|
||||||
|
return "", fmt.Errorf("la barra invertida final no escapa nada")
|
||||||
|
}
|
||||||
|
i++
|
||||||
|
switch s[i] {
|
||||||
|
case 'n':
|
||||||
|
sb.WriteByte('\n')
|
||||||
|
case 't':
|
||||||
|
sb.WriteByte('\t')
|
||||||
|
case 'r':
|
||||||
|
sb.WriteByte('\r')
|
||||||
|
case '"':
|
||||||
|
sb.WriteByte('"')
|
||||||
|
case '\\':
|
||||||
|
sb.WriteByte('\\')
|
||||||
|
default:
|
||||||
|
return "", fmt.Errorf("escape no soportado: \\%c", s[i])
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if c == quote {
|
||||||
|
trailing := strings.TrimSpace(s[i+1:])
|
||||||
|
if trailing != "" && !strings.HasPrefix(trailing, "#") {
|
||||||
|
return "", fmt.Errorf("sobra texto despues del valor: %q", trailing)
|
||||||
|
}
|
||||||
|
return sb.String(), nil
|
||||||
|
}
|
||||||
|
sb.WriteByte(c)
|
||||||
|
}
|
||||||
|
return "", fmt.Errorf("falta la comilla de cierre")
|
||||||
|
}
|
||||||
|
|
||||||
|
var knownKeys = map[string]bool{
|
||||||
|
"name": true, "mode": true, "listen": true,
|
||||||
|
"hub": true, "token": true, "partner": true,
|
||||||
|
"language": true,
|
||||||
|
}
|
||||||
|
|
||||||
|
func loadConfig() config {
|
||||||
|
cfg := defaultConfig()
|
||||||
|
|
||||||
|
data, err := os.ReadFile(configPath())
|
||||||
|
if err != nil {
|
||||||
|
if !os.IsNotExist(err) {
|
||||||
|
log.Printf("no pude leer config.toml (%v): sigo con los valores por defecto", err)
|
||||||
|
}
|
||||||
|
return cfg
|
||||||
|
}
|
||||||
|
|
||||||
|
values, problems := parseTOML(string(data))
|
||||||
|
for _, p := range problems {
|
||||||
|
log.Printf("config.toml: %s", p)
|
||||||
|
}
|
||||||
|
|
||||||
|
for k, v := range values {
|
||||||
|
if !knownKeys[k] {
|
||||||
|
log.Printf("config.toml: clave desconocida %q (linea %d), la ignoro", k, v.line)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
switch k {
|
||||||
|
case "name":
|
||||||
|
cfg.Name = v.str
|
||||||
|
case "mode":
|
||||||
|
cfg.Mode = strings.ToLower(v.str)
|
||||||
|
case "listen":
|
||||||
|
if v.str != "" {
|
||||||
|
cfg.Listen = v.str
|
||||||
|
}
|
||||||
|
case "hub":
|
||||||
|
cfg.Hub = v.str
|
||||||
|
case "token":
|
||||||
|
cfg.Token = v.str
|
||||||
|
case "partner":
|
||||||
|
cfg.Partner = v.str
|
||||||
|
case "language":
|
||||||
|
cfg.Language = v.str
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if cfg.Mode != "hub" && cfg.Mode != "peer" {
|
||||||
|
log.Printf("config.toml: mode = %q no es ni \"hub\" ni \"peer\", uso \"hub\"", cfg.Mode)
|
||||||
|
cfg.Mode = "hub"
|
||||||
|
}
|
||||||
|
return cfg
|
||||||
|
}
|
||||||
|
|
||||||
|
const sampleConfig = `# DeathWatch - Elden Ring death counter
|
||||||
|
# Edit this file and restart the program to apply changes.
|
||||||
|
|
||||||
|
# Name shown in the overlay.
|
||||||
|
# Leave it empty to use your in-game character name.
|
||||||
|
name = ""
|
||||||
|
|
||||||
|
# "hub" = this PC serves the overlay to OBS and receives partners.
|
||||||
|
# "peer" = this PC only reads its own game and pushes to the hub.
|
||||||
|
mode = "hub"
|
||||||
|
|
||||||
|
# Address the panel and overlay listen on.
|
||||||
|
listen = "0.0.0.0:47822"
|
||||||
|
|
||||||
|
# Peer mode only: the hub's address, e.g. "100.101.102.103:47822"
|
||||||
|
hub = ""
|
||||||
|
|
||||||
|
# Connection secret. REQUIRED for co-op.
|
||||||
|
# The hub generates one on first run and saves it to token.txt; it is
|
||||||
|
# also printed in the console. Peers must set that exact value here.
|
||||||
|
# The token itself never travels over the network: the hub sends a random
|
||||||
|
# challenge and the peer answers with an HMAC of it.
|
||||||
|
token = ""
|
||||||
|
|
||||||
|
# Interface language. "auto" follows your Windows language and falls
|
||||||
|
# back to English. Any file in locales/ is a valid value, e.g. "en", "es".
|
||||||
|
language = "auto"
|
||||||
|
|
||||||
|
# Optional. Hub only: your partner's name. Setting it forces the co-op
|
||||||
|
# layout from startup, with their slot reserved before they connect.
|
||||||
|
# Leave it empty to switch to co-op automatically when they show up.
|
||||||
|
partner = ""
|
||||||
|
`
|
||||||
|
|
||||||
|
// clientID devuelve un identificador estable de ESTA instalacion,
|
||||||
|
// guardado en client-id.txt al lado del programa.
|
||||||
|
//
|
||||||
|
// Existe porque el nombre no sirve para identificar a un jugador: desde
|
||||||
|
// que lo leemos del personaje, cambia cada vez que cargan otra partida.
|
||||||
|
// Con un id propio, el hub sigue viendo al mismo compañero aunque cambie
|
||||||
|
// de personaje, se reconecte o reinicie el programa.
|
||||||
|
func clientID() string {
|
||||||
|
path := "client-id.txt"
|
||||||
|
if exe, err := os.Executable(); err == nil {
|
||||||
|
path = filepath.Join(filepath.Dir(exe), "client-id.txt")
|
||||||
|
}
|
||||||
|
if data, err := os.ReadFile(path); err == nil {
|
||||||
|
if id := strings.TrimSpace(string(data)); id != "" {
|
||||||
|
return id
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var b [8]byte
|
||||||
|
if _, err := rand.Read(b[:]); err != nil {
|
||||||
|
// Sin aleatoriedad igual devolvemos algo estable dentro de la corrida.
|
||||||
|
return fmt.Sprintf("pid-%d", os.Getpid())
|
||||||
|
}
|
||||||
|
id := hex.EncodeToString(b[:])
|
||||||
|
if err := os.WriteFile(path, []byte(id), 0644); err != nil {
|
||||||
|
log.Printf("no pude guardar client-id.txt (%v): uso un id nuevo en cada arranque", err)
|
||||||
|
}
|
||||||
|
return id
|
||||||
|
}
|
||||||
|
|
||||||
|
// writeSampleConfig deja un config.toml comentado la primera vez.
|
||||||
|
func writeSampleConfig() {
|
||||||
|
path := configPath()
|
||||||
|
if _, err := os.Stat(path); err == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if err := os.WriteFile(path, []byte(sampleConfig), 0644); err != nil {
|
||||||
|
log.Printf("no pude escribir el config.toml de ejemplo: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
log.Printf("dejé un config.toml de ejemplo al lado del programa")
|
||||||
|
}
|
||||||
+198
@@ -0,0 +1,198 @@
|
|||||||
|
// counter.go: la contabilidad de muertes.
|
||||||
|
//
|
||||||
|
// A proposito NO tiene nada especifico de Windows: toda la lectura de
|
||||||
|
// memoria vive en main.go. Asi esta parte, que es la que concentra las
|
||||||
|
// reglas (a que personaje va cada muerte, que pasa al cambiar de
|
||||||
|
// partida, que se muestra con el juego cerrado), se puede compilar y
|
||||||
|
// testear en cualquier plataforma. Las tres veces que algo conto mal, el
|
||||||
|
// error estuvo aca.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"log"
|
||||||
|
"strings"
|
||||||
|
"sync"
|
||||||
|
)
|
||||||
|
|
||||||
|
// El total que se muestra ES el que lleva el juego para el personaje
|
||||||
|
// cargado. No hay ajustes ni acumuladores propios: al cambiar de
|
||||||
|
// personaje el numero salta al suyo en la misma lectura.
|
||||||
|
type state struct {
|
||||||
|
mu sync.Mutex
|
||||||
|
connected bool
|
||||||
|
playerLoaded bool
|
||||||
|
rawDeaths int32
|
||||||
|
haveReading bool
|
||||||
|
bossFight bool
|
||||||
|
charName string
|
||||||
|
charKey string
|
||||||
|
slot int
|
||||||
|
total int64
|
||||||
|
announced bool
|
||||||
|
lastErr string
|
||||||
|
}
|
||||||
|
|
||||||
|
type stateSnapshot struct {
|
||||||
|
RawDeaths int32
|
||||||
|
Slot int
|
||||||
|
Total int64
|
||||||
|
BossFight bool
|
||||||
|
Connected bool
|
||||||
|
PlayerLoaded bool
|
||||||
|
CharName string
|
||||||
|
}
|
||||||
|
|
||||||
|
var st state
|
||||||
|
var totals *totalsStore
|
||||||
|
|
||||||
|
// init arranca mostrando el ultimo personaje conocido, para que el
|
||||||
|
// overlay tenga un numero con sentido antes de que abras el juego.
|
||||||
|
func (s *state) init(store *totalsStore) {
|
||||||
|
key, name, total := store.lastKnownTotal()
|
||||||
|
s.mu.Lock()
|
||||||
|
s.charName = name
|
||||||
|
s.charKey = key
|
||||||
|
s.slot = -1
|
||||||
|
s.total = total
|
||||||
|
s.mu.Unlock()
|
||||||
|
if name != "" {
|
||||||
|
log.Printf("ultimo personaje conocido: %s con %d muertes", name, total)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *state) snapshot() stateSnapshot {
|
||||||
|
s.mu.Lock()
|
||||||
|
defer s.mu.Unlock()
|
||||||
|
total := s.total
|
||||||
|
if s.haveReading {
|
||||||
|
total = int64(s.rawDeaths)
|
||||||
|
}
|
||||||
|
return stateSnapshot{
|
||||||
|
RawDeaths: s.rawDeaths,
|
||||||
|
Slot: s.slot,
|
||||||
|
Total: total,
|
||||||
|
BossFight: s.bossFight,
|
||||||
|
Connected: s.connected,
|
||||||
|
PlayerLoaded: s.playerLoaded,
|
||||||
|
CharName: s.charName,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *state) name() string {
|
||||||
|
s.mu.Lock()
|
||||||
|
defer s.mu.Unlock()
|
||||||
|
return s.charName
|
||||||
|
}
|
||||||
|
|
||||||
|
// nombreMostrado: lo que diga el config manda; si esta vacio usamos el
|
||||||
|
// nombre del personaje que leemos del juego.
|
||||||
|
func nombreMostrado(cfg config) string {
|
||||||
|
if n := strings.TrimSpace(cfg.Name); n != "" {
|
||||||
|
return n
|
||||||
|
}
|
||||||
|
if n := st.name(); n != "" {
|
||||||
|
return n
|
||||||
|
}
|
||||||
|
// Vacio a proposito: que la etiqueta la elija la interfaz, que es la
|
||||||
|
// que sabe si esta mostrando un jugador o dos.
|
||||||
|
return ""
|
||||||
|
}
|
||||||
|
|
||||||
|
// setCharacter se llama cuando cambia el personaje cargado: el total
|
||||||
|
// pasa a ser el que el juego lleva para ese personaje.
|
||||||
|
func (s *state) setCharacter(slot int, name string, raw int32) {
|
||||||
|
key := characterKey(slot, name)
|
||||||
|
if key == "" {
|
||||||
|
return // ni slot ni nombre: no sabemos a quien imputarle esto
|
||||||
|
}
|
||||||
|
|
||||||
|
s.mu.Lock()
|
||||||
|
if key == s.charKey && s.haveReading {
|
||||||
|
// Mismo personaje: el nombre puede haber aparecido recien, porque
|
||||||
|
// el slot se lee antes que el nombre.
|
||||||
|
if name != "" && name != s.charName {
|
||||||
|
s.charName = name
|
||||||
|
total := s.total
|
||||||
|
s.mu.Unlock()
|
||||||
|
totals.save(key, charTotal{Name: name, Total: total})
|
||||||
|
return
|
||||||
|
}
|
||||||
|
s.mu.Unlock()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
s.charKey = key
|
||||||
|
s.slot = slot
|
||||||
|
if name != "" {
|
||||||
|
s.charName = name
|
||||||
|
}
|
||||||
|
name = s.charName
|
||||||
|
// Adoptamos ya la lectura del personaje nuevo: si no, el snapshot
|
||||||
|
// seguiria mostrando las muertes del personaje ANTERIOR hasta la
|
||||||
|
// siguiente muerte.
|
||||||
|
s.rawDeaths = raw
|
||||||
|
s.haveReading = true
|
||||||
|
s.total = int64(raw)
|
||||||
|
total := s.total
|
||||||
|
s.mu.Unlock()
|
||||||
|
|
||||||
|
log.Printf("personaje: %s (slot %d) -> %d muertes", name, slot, total)
|
||||||
|
totals.save(key, charTotal{Name: name, Total: total})
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *state) setReading(raw int32, boss bool) {
|
||||||
|
s.mu.Lock()
|
||||||
|
s.connected = true
|
||||||
|
s.playerLoaded = true
|
||||||
|
s.announced = false
|
||||||
|
changed := !s.haveReading || s.rawDeaths != raw
|
||||||
|
s.haveReading = true
|
||||||
|
s.rawDeaths = raw
|
||||||
|
s.bossFight = boss
|
||||||
|
s.lastErr = ""
|
||||||
|
total := int64(raw)
|
||||||
|
grew := total > s.total
|
||||||
|
s.total = total
|
||||||
|
key, name := s.charKey, s.charName
|
||||||
|
s.mu.Unlock()
|
||||||
|
|
||||||
|
if !changed {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if grew {
|
||||||
|
log.Printf("nueva muerte de %s -> %d", name, total)
|
||||||
|
}
|
||||||
|
totals.save(key, charTotal{Name: name, Total: total})
|
||||||
|
}
|
||||||
|
|
||||||
|
// setPlayerUnloaded: el juego sigue abierto pero no hay personaje en el
|
||||||
|
// mundo (menu principal o pantalla de carga). A diferencia de una
|
||||||
|
// desconexion, NO apagamos connected: el overlay tiene que seguir
|
||||||
|
// mostrando el total y no un guion, porque si no parpadearia en cada
|
||||||
|
// pantalla de carga (o sea, en cada muerte).
|
||||||
|
func (s *state) setPlayerUnloaded(reason string) {
|
||||||
|
s.mu.Lock()
|
||||||
|
was := s.playerLoaded
|
||||||
|
first := !s.announced
|
||||||
|
s.announced = true
|
||||||
|
s.connected = true
|
||||||
|
s.playerLoaded = false
|
||||||
|
s.bossFight = false
|
||||||
|
s.lastErr = reason
|
||||||
|
s.mu.Unlock()
|
||||||
|
if was || first {
|
||||||
|
log.Printf("sin personaje cargado (%s) - el total queda congelado hasta que vuelvas al mundo", reason)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *state) setDisconnected(reason string) {
|
||||||
|
s.mu.Lock()
|
||||||
|
wasConnected := s.connected
|
||||||
|
s.connected = false
|
||||||
|
s.playerLoaded = false
|
||||||
|
s.bossFight = false
|
||||||
|
s.lastErr = reason
|
||||||
|
s.mu.Unlock()
|
||||||
|
if wasConnected {
|
||||||
|
log.Printf("se perdio la conexion con el juego: %s", reason)
|
||||||
|
}
|
||||||
|
}
|
||||||
+113
@@ -0,0 +1,113 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
// cada test corre en su propio directorio: totals.json y offset.txt
|
||||||
|
// se resuelven contra el ejecutable, asi que lo apuntamos al temporal.
|
||||||
|
func fresh(t *testing.T, legacy string) {
|
||||||
|
t.Helper()
|
||||||
|
dir := t.TempDir()
|
||||||
|
testExeDir = dir
|
||||||
|
if legacy != "" {
|
||||||
|
if err := os.WriteFile(filepath.Join(dir, "offset.txt"), []byte(legacy), 0644); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
totals = newTotalsStore()
|
||||||
|
st = state{}
|
||||||
|
st.init(totals)
|
||||||
|
}
|
||||||
|
|
||||||
|
func total(t *testing.T) int64 { t.Helper(); return st.snapshot().Total }
|
||||||
|
|
||||||
|
// EL CASO DE EMMA: cambiar de personaje tiene que mover el numero YA,
|
||||||
|
// sin esperar a que alguien se muera.
|
||||||
|
func TestCambioDePersonajeActualizaAlInstante(t *testing.T) {
|
||||||
|
fresh(t, "")
|
||||||
|
|
||||||
|
st.setCharacter(0, "emma", 40)
|
||||||
|
st.setReading(40, false)
|
||||||
|
if got := total(t); got != 40 {
|
||||||
|
t.Fatalf("emma deberia arrancar con sus 40 muertes, dio %d", got)
|
||||||
|
}
|
||||||
|
|
||||||
|
// se va al menu y carga otro personaje, con otro conteo propio
|
||||||
|
st.setPlayerUnloaded("menu")
|
||||||
|
st.setCharacter(1, "emmatherock", 7)
|
||||||
|
if got := total(t); got != 7 {
|
||||||
|
t.Fatalf("al cargar emmatherock el total tenia que saltar a 7 SIN morir, dio %d", got)
|
||||||
|
}
|
||||||
|
st.setReading(7, false)
|
||||||
|
if got := total(t); got != 7 {
|
||||||
|
t.Fatalf("tras la lectura deberia seguir en 7, dio %d", got)
|
||||||
|
}
|
||||||
|
|
||||||
|
// y volver muestra lo que el juego lleva para emma
|
||||||
|
st.setPlayerUnloaded("menu")
|
||||||
|
st.setCharacter(0, "emma", 41)
|
||||||
|
st.setReading(41, false)
|
||||||
|
if got := total(t); got != 41 {
|
||||||
|
t.Fatalf("volviendo a emma deberia dar 41, dio %d", got)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Dos personajes con el MISMO nombre no se tienen que mezclar.
|
||||||
|
func TestHomonimosNoSeMezclan(t *testing.T) {
|
||||||
|
fresh(t, "")
|
||||||
|
st.setCharacter(0, "Tarnished", 100)
|
||||||
|
st.setReading(100, false)
|
||||||
|
st.setCharacter(3, "Tarnished", 5)
|
||||||
|
st.setReading(5, false)
|
||||||
|
if got := total(t); got != 5 {
|
||||||
|
t.Fatalf("el del slot 3 deberia dar 5, dio %d", got)
|
||||||
|
}
|
||||||
|
if c, ok := totals.get("slot0"); !ok || c.Total != 100 {
|
||||||
|
t.Fatalf("el del slot 0 deberia seguir en 100, dio %+v", c)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// El total es el del juego, sin importar que haya un offset.txt viejo
|
||||||
|
// dando vueltas al lado del programa.
|
||||||
|
func TestIgnoraElOffsetViejo(t *testing.T) {
|
||||||
|
fresh(t, "124")
|
||||||
|
st.setCharacter(0, "emma", 30)
|
||||||
|
st.setReading(30, false)
|
||||||
|
if got := total(t); got != 30 {
|
||||||
|
t.Fatalf("deberia mostrar las 30 del juego y no las 124 del archivo viejo, dio %d", got)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sin poder leer el slot, cae al nombre y sigue funcionando.
|
||||||
|
func TestSinSlotCaeAlNombre(t *testing.T) {
|
||||||
|
fresh(t, "")
|
||||||
|
st.setCharacter(-1, "emma", 40)
|
||||||
|
st.setReading(40, false)
|
||||||
|
if got := total(t); got != 40 {
|
||||||
|
t.Fatalf("deberia dar 40, dio %d", got)
|
||||||
|
}
|
||||||
|
if _, ok := totals.get("name:emma"); !ok {
|
||||||
|
t.Fatal("deberia haberlo guardado por nombre")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Al reabrir el programa con el juego cerrado, muestra el ultimo
|
||||||
|
// personaje conocido en vez de un cero.
|
||||||
|
func TestRecuerdaElUltimoAlReabrir(t *testing.T) {
|
||||||
|
fresh(t, "")
|
||||||
|
st.setCharacter(2, "emma", 88)
|
||||||
|
st.setReading(88, false)
|
||||||
|
|
||||||
|
totals = newTotalsStore() // simula reabrir el programa
|
||||||
|
st = state{}
|
||||||
|
st.init(totals)
|
||||||
|
if got := total(t); got != 88 {
|
||||||
|
t.Fatalf("al reabrir deberia mostrar 88, dio %d", got)
|
||||||
|
}
|
||||||
|
if st.snapshot().CharName != "emma" {
|
||||||
|
t.Fatalf("y recordar el nombre, dio %q", st.snapshot().CharName)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,417 @@
|
|||||||
|
// duo.go: modo cooperativo. Cada jugador corre el programa en su propia
|
||||||
|
// PC leyendo su propio Elden Ring; uno hace de "hub" (sirve el overlay a
|
||||||
|
// OBS) y el resto se conectan a el por WebSocket y le empujan su contador.
|
||||||
|
//
|
||||||
|
// La conexion la abre SIEMPRE el peer hacia el hub, que es lo comodo con
|
||||||
|
// Tailscale: alcanza con que el hub tenga una IP estable en la tailnet.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"net/http"
|
||||||
|
"strings"
|
||||||
|
"sync"
|
||||||
|
"sync/atomic"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Si un peer no manda nada en este tiempo, lo damos por desconectado.
|
||||||
|
// El peer empuja una vez por segundo, asi que es holgado.
|
||||||
|
const peerTimeout = 6 * time.Second
|
||||||
|
|
||||||
|
// Cuanto seguimos mostrando la interfaz de coop despues de que el
|
||||||
|
// compañero desaparece. Ver coopMode() para el porque.
|
||||||
|
const coopGrace = 2 * time.Minute
|
||||||
|
|
||||||
|
// --------------------------- registro de peers ---------------------------
|
||||||
|
|
||||||
|
type playerView struct {
|
||||||
|
Name string `json:"name"`
|
||||||
|
Deaths int64 `json:"deaths"`
|
||||||
|
BossFight bool `json:"bossFight"`
|
||||||
|
PlayerLoaded bool `json:"playerLoaded"`
|
||||||
|
Connected bool `json:"connected"`
|
||||||
|
Self bool `json:"self"`
|
||||||
|
}
|
||||||
|
|
||||||
|
// peerEntry: OJO con la identidad. El nombre NO sirve como clave: desde
|
||||||
|
// que lo leemos del personaje, cambia cuando el jugador carga otra
|
||||||
|
// partida, y si indexaramos por nombre cada cambio de personaje crearia
|
||||||
|
// un jugador nuevo y dejaria el anterior colgado en pantalla. La
|
||||||
|
// identidad es el id que manda cada instancia (ver clientID), estable
|
||||||
|
// entre reconexiones y reinicios; el nombre es solo algo que mostramos.
|
||||||
|
type peerEntry struct {
|
||||||
|
key string // como lo indexamos: el id, o "name:x" si es viejo
|
||||||
|
name string
|
||||||
|
deaths int64
|
||||||
|
bossFight bool
|
||||||
|
playerLoaded bool
|
||||||
|
lastSeen time.Time
|
||||||
|
everSeen bool
|
||||||
|
reserved bool // lugar apartado por config, todavia sin dueño
|
||||||
|
}
|
||||||
|
|
||||||
|
type peerRegistry struct {
|
||||||
|
mu sync.Mutex
|
||||||
|
peers map[string]*peerEntry
|
||||||
|
order []string // orden de aparicion, para que el overlay no baile
|
||||||
|
|
||||||
|
forced bool // el config nombro un compañero: coop desde el arranque
|
||||||
|
latched bool // ya vimos un compañero en esta corrida
|
||||||
|
lastCoop time.Time // ultima vez que hubo alguien conectado
|
||||||
|
}
|
||||||
|
|
||||||
|
func newPeerRegistry() *peerRegistry {
|
||||||
|
return &peerRegistry{peers: map[string]*peerEntry{}}
|
||||||
|
}
|
||||||
|
|
||||||
|
// declare reserva el lugar de un compañero antes de que se conecte y
|
||||||
|
// fija el modo coop desde el arranque. Es opcional: sirve cuando querés
|
||||||
|
// que el overlay tenga el tamaño definitivo desde el minuto cero en vez
|
||||||
|
// de cambiar cuando el otro aparece.
|
||||||
|
func (r *peerRegistry) declare(name string) {
|
||||||
|
if name == "" {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
r.mu.Lock()
|
||||||
|
defer r.mu.Unlock()
|
||||||
|
key := "reserved:" + name
|
||||||
|
if _, ok := r.peers[key]; !ok {
|
||||||
|
r.peers[key] = &peerEntry{key: key, name: name, reserved: true}
|
||||||
|
r.order = append(r.order, key)
|
||||||
|
}
|
||||||
|
r.forced = true
|
||||||
|
}
|
||||||
|
|
||||||
|
// coopMode decide si el overlay va en dos columnas o en una.
|
||||||
|
//
|
||||||
|
// Se engancha cuando aparece un compañero y NO se suelta al primer
|
||||||
|
// bache: si volviera a modo solo cada vez que se corta la red un
|
||||||
|
// segundo, el overlay se redibujaria en vivo en pleno stream. Recien
|
||||||
|
// vuelve al modo de un jugador cuando el otro estuvo ausente un buen
|
||||||
|
// rato, que es la señal de "se fue a dormir", no de "se le colgo el wifi".
|
||||||
|
func (r *peerRegistry) coopMode() bool {
|
||||||
|
r.mu.Lock()
|
||||||
|
defer r.mu.Unlock()
|
||||||
|
if r.forced {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
now := time.Now()
|
||||||
|
for _, p := range r.peers {
|
||||||
|
if p.everSeen && now.Sub(p.lastSeen) < peerTimeout {
|
||||||
|
if !r.latched {
|
||||||
|
r.latched = true
|
||||||
|
log.Printf("hay un compañero conectado: paso el overlay a modo coop")
|
||||||
|
}
|
||||||
|
r.lastCoop = now
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if r.latched {
|
||||||
|
if now.Sub(r.lastCoop) < coopGrace {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
r.latched = false
|
||||||
|
log.Printf("hace %v que no aparece ningun compañero: vuelvo al overlay de un jugador", coopGrace)
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// keyFor: el id manda. Si viniera vacio (una version vieja del otro
|
||||||
|
// lado) caemos al nombre, que es lo que habia antes.
|
||||||
|
func keyFor(m peerMessage) string {
|
||||||
|
if id := strings.TrimSpace(m.ID); id != "" {
|
||||||
|
return "id:" + id
|
||||||
|
}
|
||||||
|
return "name:" + strings.ToLower(strings.TrimSpace(m.Name))
|
||||||
|
}
|
||||||
|
|
||||||
|
// rekey mueve una entrada a otra clave conservando su lugar en el orden,
|
||||||
|
// para que el overlay no reordene columnas por debajo.
|
||||||
|
func (r *peerRegistry) rekey(p *peerEntry, newKey string) {
|
||||||
|
delete(r.peers, p.key)
|
||||||
|
for i, k := range r.order {
|
||||||
|
if k == p.key {
|
||||||
|
r.order[i] = newKey
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
p.key = newKey
|
||||||
|
r.peers[newKey] = p
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *peerRegistry) update(m peerMessage) {
|
||||||
|
r.mu.Lock()
|
||||||
|
defer r.mu.Unlock()
|
||||||
|
|
||||||
|
key := keyFor(m)
|
||||||
|
p := r.peers[key]
|
||||||
|
|
||||||
|
// Sin entrada propia: si hay un lugar apartado por config todavia sin
|
||||||
|
// dueño, lo toma el primero que llega. Apartarlo por nombre exacto no
|
||||||
|
// serviria, porque el nombre que manda es el del personaje.
|
||||||
|
if p == nil {
|
||||||
|
for _, k := range r.order {
|
||||||
|
if e := r.peers[k]; e.reserved && !e.everSeen {
|
||||||
|
e.reserved = false
|
||||||
|
r.rekey(e, key)
|
||||||
|
p = e
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if p == nil {
|
||||||
|
p = &peerEntry{key: key}
|
||||||
|
r.peers[key] = p
|
||||||
|
r.order = append(r.order, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
if n := strings.TrimSpace(m.Name); n != "" && n != p.name {
|
||||||
|
if p.name != "" && p.everSeen {
|
||||||
|
log.Printf("%s cambio de personaje: ahora es %s", p.name, n)
|
||||||
|
}
|
||||||
|
p.name = n
|
||||||
|
}
|
||||||
|
p.deaths = m.Deaths
|
||||||
|
p.bossFight = m.BossFight
|
||||||
|
p.playerLoaded = m.PlayerLoaded
|
||||||
|
p.lastSeen = time.Now()
|
||||||
|
p.everSeen = true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *peerRegistry) views() []playerView {
|
||||||
|
r.mu.Lock()
|
||||||
|
defer r.mu.Unlock()
|
||||||
|
now := time.Now()
|
||||||
|
out := make([]playerView, 0, len(r.order))
|
||||||
|
for _, k := range r.order {
|
||||||
|
p := r.peers[k]
|
||||||
|
// Los que hace mucho que no aparecen se van del overlay: es el
|
||||||
|
// mismo umbral con el que volvemos al modo de un jugador.
|
||||||
|
if p.everSeen && now.Sub(p.lastSeen) > coopGrace {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
out = append(out, playerView{
|
||||||
|
Name: p.name,
|
||||||
|
Deaths: p.deaths,
|
||||||
|
BossFight: p.bossFight,
|
||||||
|
PlayerLoaded: p.playerLoaded,
|
||||||
|
Connected: p.everSeen && now.Sub(p.lastSeen) < peerTimeout,
|
||||||
|
Self: false,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
// ------------------------- mensaje entre los dos -------------------------
|
||||||
|
|
||||||
|
// authChallenge lo manda el hub apenas se abre la conexion.
|
||||||
|
type authChallenge struct {
|
||||||
|
Type string `json:"type"` // "challenge"
|
||||||
|
Nonce string `json:"nonce"`
|
||||||
|
}
|
||||||
|
|
||||||
|
// authReply es la respuesta del peer: prueba que conoce el token sin
|
||||||
|
// mandarlo. Ver auth.go.
|
||||||
|
type authReply struct {
|
||||||
|
Type string `json:"type"` // "auth"
|
||||||
|
ID string `json:"id"`
|
||||||
|
Proof string `json:"proof"`
|
||||||
|
}
|
||||||
|
|
||||||
|
type peerMessage struct {
|
||||||
|
// ID identifica a la instalacion, no al personaje: es lo que permite
|
||||||
|
// que cambiar de personaje no cree un jugador nuevo en el overlay.
|
||||||
|
ID string `json:"id,omitempty"`
|
||||||
|
Type string `json:"type,omitempty"` // "state"
|
||||||
|
Name string `json:"name"`
|
||||||
|
Deaths int64 `json:"deaths"`
|
||||||
|
BossFight bool `json:"bossFight"`
|
||||||
|
PlayerLoaded bool `json:"playerLoaded"`
|
||||||
|
}
|
||||||
|
|
||||||
|
// ------------------------------- lado hub -------------------------------
|
||||||
|
|
||||||
|
func (r *peerRegistry) wsHandler(token string) http.HandlerFunc {
|
||||||
|
var activas atomic.Int32
|
||||||
|
|
||||||
|
return func(w http.ResponseWriter, req *http.Request) {
|
||||||
|
if n := activas.Add(1); n > maxPeerConns {
|
||||||
|
activas.Add(-1)
|
||||||
|
log.Printf("rechazo conexion de %s: ya hay %d conexiones abiertas", req.RemoteAddr, maxPeerConns)
|
||||||
|
http.Error(w, "too many connections", http.StatusServiceUnavailable)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
defer activas.Add(-1)
|
||||||
|
|
||||||
|
c, err := wsUpgrade(w, req)
|
||||||
|
if err != nil {
|
||||||
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
defer c.Close()
|
||||||
|
|
||||||
|
remote := c.RemoteAddr()
|
||||||
|
|
||||||
|
// --- autenticacion: desafio al azar, el token no viaja ---
|
||||||
|
nonce, err := randomHex(nonceBytes)
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("no pude generar el desafio para %s: %v", remote, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
ch, _ := json.Marshal(authChallenge{Type: "challenge", Nonce: nonce})
|
||||||
|
if err := c.WriteText(ch); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
c.SetReadDeadline(time.Now().Add(authTimeoutSeconds * time.Second))
|
||||||
|
raw, err := c.ReadMessage()
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("%s se fue sin autenticarse: %v", remote, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var reply authReply
|
||||||
|
if err := json.Unmarshal(raw, &reply); err != nil || reply.Type != "auth" {
|
||||||
|
log.Printf("rechazo %s: no mando una respuesta de autenticacion valida", remote)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if !proofValid(token, nonce, reply.Proof) {
|
||||||
|
log.Printf("rechazo %s: el token no coincide", remote)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
log.Printf("se autentico un compañero desde %s", remote)
|
||||||
|
|
||||||
|
var who string
|
||||||
|
for {
|
||||||
|
c.SetReadDeadline(time.Now().Add(15 * time.Second))
|
||||||
|
raw, err := c.ReadMessage()
|
||||||
|
if err != nil {
|
||||||
|
if who != "" {
|
||||||
|
log.Printf("se desconecto %s (%s): %v", who, remote, err)
|
||||||
|
} else {
|
||||||
|
log.Printf("se desconecto %s: %v", remote, err)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var m peerMessage
|
||||||
|
if err := json.Unmarshal(raw, &m); err != nil {
|
||||||
|
log.Printf("mensaje ilegible de %s: %v", remote, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
// El id de la conexion autenticada manda: que un mensaje
|
||||||
|
// declare otro id no lo convierte en otro jugador.
|
||||||
|
if reply.ID != "" {
|
||||||
|
m.ID = reply.ID
|
||||||
|
}
|
||||||
|
if strings.TrimSpace(m.Name) == "" {
|
||||||
|
m.Name = "Jugador 2"
|
||||||
|
}
|
||||||
|
if who == "" {
|
||||||
|
who = m.Name
|
||||||
|
log.Printf("%s entro al contador compartido", who)
|
||||||
|
}
|
||||||
|
r.update(m)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ------------------------------ lado peer ------------------------------
|
||||||
|
|
||||||
|
// peerLoop mantiene viva la conexion con el hub y le empuja el estado
|
||||||
|
// local una vez por segundo. Reintenta solo para siempre: si el hub se
|
||||||
|
// reinicia en medio del stream, se vuelve a enganchar sin tocar nada.
|
||||||
|
func peerLoop(cfg config) {
|
||||||
|
id := clientID()
|
||||||
|
log.Printf("mi id de cliente es %s (cambiar de personaje no crea un jugador nuevo del otro lado)", id)
|
||||||
|
cfg.clientID = id
|
||||||
|
for {
|
||||||
|
c, err := wsDial(cfg.Hub, "/ws", 8*time.Second)
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("no me pude conectar al hub %s (%v) - reintento en 5s", cfg.Hub, err)
|
||||||
|
time.Sleep(5 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if err := authenticate(c, cfg); err != nil {
|
||||||
|
c.Close()
|
||||||
|
log.Printf("el hub no me acepto (%v) - reintento en 5s", err)
|
||||||
|
time.Sleep(5 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
log.Printf("conectado y autenticado con el hub %s", cfg.Hub)
|
||||||
|
|
||||||
|
err = pushLoop(c, cfg)
|
||||||
|
c.Close()
|
||||||
|
log.Printf("se corto la conexion con el hub (%v) - reintento en 5s", err)
|
||||||
|
time.Sleep(5 * time.Second)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// authenticate responde el desafio del hub. El token no se manda: se
|
||||||
|
// manda un HMAC del desafio hecho con el token.
|
||||||
|
func authenticate(c *wsConn, cfg config) error {
|
||||||
|
c.SetReadDeadline(time.Now().Add(authTimeoutSeconds * time.Second))
|
||||||
|
raw, err := c.ReadMessage()
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("no llego el desafio: %w", err)
|
||||||
|
}
|
||||||
|
var ch authChallenge
|
||||||
|
if err := json.Unmarshal(raw, &ch); err != nil || ch.Type != "challenge" || ch.Nonce == "" {
|
||||||
|
return fmt.Errorf("el desafio del hub no se entiende")
|
||||||
|
}
|
||||||
|
if strings.TrimSpace(cfg.Token) == "" {
|
||||||
|
return fmt.Errorf("te falta el token en config.toml: pedíselo a quien corre el hub")
|
||||||
|
}
|
||||||
|
reply, _ := json.Marshal(authReply{
|
||||||
|
Type: "auth",
|
||||||
|
ID: cfg.clientID,
|
||||||
|
Proof: proofFor(cfg.Token, ch.Nonce),
|
||||||
|
})
|
||||||
|
if err := c.WriteText(reply); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
c.SetReadDeadline(time.Time{})
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func pushLoop(c *wsConn, cfg config) error {
|
||||||
|
// Un lector en segundo plano: no esperamos mensajes del hub, pero hay
|
||||||
|
// que atender sus pings y enterarnos si corta.
|
||||||
|
readErr := make(chan error, 1)
|
||||||
|
go func() {
|
||||||
|
for {
|
||||||
|
if _, err := c.ReadMessage(); err != nil {
|
||||||
|
readErr <- err
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
|
||||||
|
tick := time.NewTicker(1 * time.Second)
|
||||||
|
defer tick.Stop()
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case err := <-readErr:
|
||||||
|
return err
|
||||||
|
case <-tick.C:
|
||||||
|
snap := st.snapshot()
|
||||||
|
msg := peerMessage{
|
||||||
|
Type: "state",
|
||||||
|
ID: cfg.clientID,
|
||||||
|
Name: nombreMostrado(cfg),
|
||||||
|
Deaths: snap.Total,
|
||||||
|
BossFight: snap.BossFight,
|
||||||
|
PlayerLoaded: snap.PlayerLoaded,
|
||||||
|
}
|
||||||
|
b, err := json.Marshal(msg)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err := c.WriteText(b); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,122 @@
|
|||||||
|
//go:build windows
|
||||||
|
|
||||||
|
// i18n.go: idiomas de la interfaz.
|
||||||
|
//
|
||||||
|
// Las traducciones viven en locales/*.json y se embeben en el ejecutable.
|
||||||
|
// La razon de elegir archivos sueltos en vez de un mapa en el codigo es
|
||||||
|
// que agregar un idioma sea "copiar en.json, traducirlo, y listo": quien
|
||||||
|
// traduce no necesita saber Go ni tocar una linea de codigo.
|
||||||
|
//
|
||||||
|
// Los mensajes de la consola NO pasan por aca a proposito: son
|
||||||
|
// diagnostico, y conviene que esten siempre en el mismo idioma para que
|
||||||
|
// un log pegado en un issue se pueda leer sin importar de donde venga.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"embed"
|
||||||
|
"encoding/json"
|
||||||
|
"log"
|
||||||
|
"path"
|
||||||
|
"sort"
|
||||||
|
"strings"
|
||||||
|
"syscall"
|
||||||
|
"unsafe"
|
||||||
|
)
|
||||||
|
|
||||||
|
//go:embed locales/*.json
|
||||||
|
var localeFS embed.FS
|
||||||
|
|
||||||
|
const fallbackLang = "en"
|
||||||
|
|
||||||
|
var locales = map[string]map[string]string{}
|
||||||
|
|
||||||
|
func loadLocales() {
|
||||||
|
entries, err := localeFS.ReadDir("locales")
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("no pude leer los idiomas embebidos: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
for _, e := range entries {
|
||||||
|
name := e.Name()
|
||||||
|
if !strings.HasSuffix(name, ".json") {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
data, err := localeFS.ReadFile(path.Join("locales", name))
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("no pude leer locales/%s: %v", name, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
var m map[string]string
|
||||||
|
if err := json.Unmarshal(data, &m); err != nil {
|
||||||
|
log.Printf("locales/%s tiene JSON invalido: %v", name, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
locales[strings.TrimSuffix(name, ".json")] = m
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func availableLangs() []string {
|
||||||
|
out := make([]string, 0, len(locales))
|
||||||
|
for k := range locales {
|
||||||
|
out = append(out, k)
|
||||||
|
}
|
||||||
|
sort.Strings(out)
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
var procGetUserDefaultLocaleName = kernel32.NewProc("GetUserDefaultLocaleName")
|
||||||
|
|
||||||
|
// systemLang devuelve el idioma de Windows ("es-AR" -> "es").
|
||||||
|
func systemLang() string {
|
||||||
|
buf := make([]uint16, 85) // LOCALE_NAME_MAX_LENGTH
|
||||||
|
r, _, _ := procGetUserDefaultLocaleName.Call(uintptr(unsafe.Pointer(&buf[0])), uintptr(len(buf)))
|
||||||
|
if r == 0 {
|
||||||
|
return ""
|
||||||
|
}
|
||||||
|
name := syscall.UTF16ToString(buf[:r])
|
||||||
|
if base, _, ok := strings.Cut(name, "-"); ok {
|
||||||
|
return strings.ToLower(base)
|
||||||
|
}
|
||||||
|
return strings.ToLower(name)
|
||||||
|
}
|
||||||
|
|
||||||
|
// resolveLang decide el idioma final. "auto" (o vacio) usa el de
|
||||||
|
// Windows; si ese idioma no esta traducido, cae a ingles.
|
||||||
|
func resolveLang(want string) string {
|
||||||
|
want = strings.ToLower(strings.TrimSpace(want))
|
||||||
|
if want == "" || want == "auto" {
|
||||||
|
want = systemLang()
|
||||||
|
}
|
||||||
|
if want == "" {
|
||||||
|
return fallbackLang
|
||||||
|
}
|
||||||
|
if _, ok := locales[want]; ok {
|
||||||
|
return want
|
||||||
|
}
|
||||||
|
// "es-AR" o "es_AR" igual tienen que encontrar "es".
|
||||||
|
if base, _, ok := strings.Cut(strings.NewReplacer("_", "-").Replace(want), "-"); ok {
|
||||||
|
if _, ok := locales[base]; ok {
|
||||||
|
return base
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return fallbackLang
|
||||||
|
}
|
||||||
|
|
||||||
|
// stringsFor devuelve el diccionario del idioma pedido, completado con
|
||||||
|
// el ingles: si una traduccion quedo a medias, se ve la clave que falta
|
||||||
|
// en ingles y no la clave cruda.
|
||||||
|
func stringsFor(lang string) map[string]string {
|
||||||
|
out := map[string]string{}
|
||||||
|
for k, v := range locales[fallbackLang] {
|
||||||
|
out[k] = v
|
||||||
|
}
|
||||||
|
if lang != fallbackLang {
|
||||||
|
for k, v := range locales[lang] {
|
||||||
|
if v != "" {
|
||||||
|
out[k] = v
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
out["_lang"] = lang
|
||||||
|
return out
|
||||||
|
}
|
||||||
@@ -0,0 +1,30 @@
|
|||||||
|
{
|
||||||
|
"_language": "English",
|
||||||
|
"overlay.deaths": "deaths",
|
||||||
|
"overlay.boss": "boss",
|
||||||
|
"overlay.offline": "no connection",
|
||||||
|
"overlay.waiting": "waiting for the game…",
|
||||||
|
"overlay.you": "You",
|
||||||
|
"overlay.partner": "Partner",
|
||||||
|
"panel.title": "Elden Ring",
|
||||||
|
"panel.subtitle": "Death Counter · live reading",
|
||||||
|
"panel.total": "Total deaths",
|
||||||
|
"panel.raw": "Read from process",
|
||||||
|
"panel.slot": "Save slot",
|
||||||
|
"panel.boss": "⚔ In a boss fight",
|
||||||
|
"panel.partners": "Partners",
|
||||||
|
"panel.obsUrl": "URL for OBS (Browser Source)",
|
||||||
|
"panel.copy": "Copy",
|
||||||
|
"panel.copied": "Copied",
|
||||||
|
"panel.copyManual": "Select and copy",
|
||||||
|
"panel.obsHint": "Paste this URL into a Browser source in OBS. Transparent background, updates on its own as long as this console window stays open.",
|
||||||
|
"panel.build": "Build",
|
||||||
|
"status.connecting": "Connecting…",
|
||||||
|
"status.waitingGame": "Waiting for you to open Elden Ring…",
|
||||||
|
"status.menu": "Elden Ring open — main menu or loading screen",
|
||||||
|
"status.live": "Live — reading Elden Ring",
|
||||||
|
"status.noServer": "No connection to the local program",
|
||||||
|
"peer.playing": "playing",
|
||||||
|
"peer.menu": "in the menu",
|
||||||
|
"peer.offline": "no connection"
|
||||||
|
}
|
||||||
@@ -0,0 +1,30 @@
|
|||||||
|
{
|
||||||
|
"_language": "Español",
|
||||||
|
"overlay.deaths": "muertes",
|
||||||
|
"overlay.boss": "jefe",
|
||||||
|
"overlay.offline": "sin conexión",
|
||||||
|
"overlay.waiting": "esperando al juego…",
|
||||||
|
"overlay.you": "Vos",
|
||||||
|
"overlay.partner": "Compañero",
|
||||||
|
"panel.title": "Elden Ring",
|
||||||
|
"panel.subtitle": "Death Counter · lectura en vivo",
|
||||||
|
"panel.total": "Total muertes",
|
||||||
|
"panel.raw": "Leído del proceso",
|
||||||
|
"panel.slot": "Slot de guardado",
|
||||||
|
"panel.boss": "⚔ En combate contra jefe",
|
||||||
|
"panel.partners": "Compañeros",
|
||||||
|
"panel.obsUrl": "URL para OBS (Browser Source)",
|
||||||
|
"panel.copy": "Copiar",
|
||||||
|
"panel.copied": "Copiado",
|
||||||
|
"panel.copyManual": "Seleccioná y copiá",
|
||||||
|
"panel.obsHint": "Pegá esta URL en una fuente Navegador de OBS. Fondo transparente, se actualiza sola mientras esta ventanita de consola siga abierta.",
|
||||||
|
"panel.build": "Compilación",
|
||||||
|
"status.connecting": "Conectando…",
|
||||||
|
"status.waitingGame": "Esperando a que abras Elden Ring…",
|
||||||
|
"status.menu": "Elden Ring abierto — menú o pantalla de carga",
|
||||||
|
"status.live": "En vivo — leyendo Elden Ring",
|
||||||
|
"status.noServer": "Sin conexión con el programa local",
|
||||||
|
"peer.playing": "jugando",
|
||||||
|
"peer.menu": "en el menú",
|
||||||
|
"peer.offline": "sin conexión"
|
||||||
|
}
|
||||||
@@ -0,0 +1,939 @@
|
|||||||
|
//go:build windows
|
||||||
|
|
||||||
|
// deathwatch: lee en solo-lectura el contador de muertes de Elden Ring
|
||||||
|
// directamente del proceso (mismo patron de bytes / offset que usa el
|
||||||
|
// script ASL "eldenring_boss_timer.asl" de LiveSplit, ya verificado a
|
||||||
|
// mano en esta PC). No escribe nada en la memoria del juego.
|
||||||
|
//
|
||||||
|
// Expone:
|
||||||
|
//
|
||||||
|
// GET / -> panel de estado (HTML)
|
||||||
|
// GET /?view=overlay -> version transparente para OBS Browser Source
|
||||||
|
// GET /deaths -> {"deaths":N,"players":[...],"character":"...","slot":N,...}
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
_ "embed"
|
||||||
|
"encoding/binary"
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"log"
|
||||||
|
"net/http"
|
||||||
|
"os"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"syscall"
|
||||||
|
"time"
|
||||||
|
"unicode/utf16"
|
||||||
|
"unsafe"
|
||||||
|
)
|
||||||
|
|
||||||
|
//go:embed overlay.html
|
||||||
|
var overlayHTML []byte
|
||||||
|
|
||||||
|
const (
|
||||||
|
processName = "eldenring.exe"
|
||||||
|
|
||||||
|
processQueryInformation = 0x0400
|
||||||
|
processVMRead = 0x0010
|
||||||
|
th32csSnapProcess = 0x00000002
|
||||||
|
th32csSnapModule = 0x00000008
|
||||||
|
th32csSnapModule32 = 0x00000010
|
||||||
|
maxPath = 260
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
kernel32 = syscall.NewLazyDLL("kernel32.dll")
|
||||||
|
procOpenProcess = kernel32.NewProc("OpenProcess")
|
||||||
|
procCloseHandle = kernel32.NewProc("CloseHandle")
|
||||||
|
procReadProcessMemory = kernel32.NewProc("ReadProcessMemory")
|
||||||
|
procCreateToolhelp32Snapshot = kernel32.NewProc("CreateToolhelp32Snapshot")
|
||||||
|
procModule32FirstW = kernel32.NewProc("Module32FirstW")
|
||||||
|
procModule32NextW = kernel32.NewProc("Module32NextW")
|
||||||
|
procProcess32FirstW = kernel32.NewProc("Process32FirstW")
|
||||||
|
procProcess32NextW = kernel32.NewProc("Process32NextW")
|
||||||
|
|
||||||
|
versionDLL = syscall.NewLazyDLL("version.dll")
|
||||||
|
procGetFileVersionInfoSizeW = versionDLL.NewProc("GetFileVersionInfoSizeW")
|
||||||
|
procGetFileVersionInfoW = versionDLL.NewProc("GetFileVersionInfoW")
|
||||||
|
procVerQueryValueW = versionDLL.NewProc("VerQueryValueW")
|
||||||
|
)
|
||||||
|
|
||||||
|
// vsFixedFileInfo es la estructura VS_FIXEDFILEINFO de Windows: la usamos
|
||||||
|
// para sacar la version del juego del propio eldenring.exe, igual que
|
||||||
|
// SoulMemory (que lee MainModule.FileVersionInfo.ProductVersion).
|
||||||
|
type vsFixedFileInfo struct {
|
||||||
|
Signature uint32
|
||||||
|
StrucVersion uint32
|
||||||
|
FileVersionMS uint32
|
||||||
|
FileVersionLS uint32
|
||||||
|
ProductVersionMS uint32
|
||||||
|
ProductVersionLS uint32
|
||||||
|
FileFlagsMask uint32
|
||||||
|
FileFlags uint32
|
||||||
|
FileOS uint32
|
||||||
|
FileType uint32
|
||||||
|
FileSubtype uint32
|
||||||
|
FileDateMS uint32
|
||||||
|
FileDateLS uint32
|
||||||
|
}
|
||||||
|
|
||||||
|
type processEntry32 struct {
|
||||||
|
Size uint32
|
||||||
|
CntUsage uint32
|
||||||
|
ProcessID uint32
|
||||||
|
DefaultHeapID uintptr
|
||||||
|
ModuleID uint32
|
||||||
|
CntThreads uint32
|
||||||
|
ParentProcessID uint32
|
||||||
|
PriorityClassBase int32
|
||||||
|
Flags uint32
|
||||||
|
ExeFile [maxPath]uint16
|
||||||
|
}
|
||||||
|
|
||||||
|
type moduleEntry32 struct {
|
||||||
|
Size uint32
|
||||||
|
ModuleID uint32
|
||||||
|
ProcessID uint32
|
||||||
|
GlblcntUsage uint32
|
||||||
|
ProccntUsage uint32
|
||||||
|
ModBaseAddr uintptr
|
||||||
|
ModBaseSize uint32
|
||||||
|
HModule syscall.Handle
|
||||||
|
ModuleName [256]uint16
|
||||||
|
ExePath [maxPath]uint16
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------- Windows API helpers ----------------------------
|
||||||
|
|
||||||
|
func findProcessID(name string) (uint32, error) {
|
||||||
|
snap, _, _ := procCreateToolhelp32Snapshot.Call(uintptr(th32csSnapProcess), 0)
|
||||||
|
if snap == 0 || snap == uintptr(^uintptr(0)) {
|
||||||
|
return 0, fmt.Errorf("no se pudo tomar snapshot de procesos")
|
||||||
|
}
|
||||||
|
defer procCloseHandle.Call(snap)
|
||||||
|
|
||||||
|
var pe processEntry32
|
||||||
|
pe.Size = uint32(unsafe.Sizeof(pe))
|
||||||
|
r, _, _ := procProcess32FirstW.Call(snap, uintptr(unsafe.Pointer(&pe)))
|
||||||
|
if r == 0 {
|
||||||
|
return 0, fmt.Errorf("Process32First fallo")
|
||||||
|
}
|
||||||
|
for {
|
||||||
|
exe := syscall.UTF16ToString(pe.ExeFile[:])
|
||||||
|
if strings.EqualFold(exe, name) {
|
||||||
|
return pe.ProcessID, nil
|
||||||
|
}
|
||||||
|
r, _, _ := procProcess32NextW.Call(snap, uintptr(unsafe.Pointer(&pe)))
|
||||||
|
if r == 0 {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0, fmt.Errorf("proceso no encontrado: %s", name)
|
||||||
|
}
|
||||||
|
|
||||||
|
func findModuleBase(pid uint32, name string) (uintptr, uint32, string, error) {
|
||||||
|
snap, _, _ := procCreateToolhelp32Snapshot.Call(uintptr(th32csSnapModule|th32csSnapModule32), uintptr(pid))
|
||||||
|
if snap == 0 || snap == uintptr(^uintptr(0)) {
|
||||||
|
return 0, 0, "", fmt.Errorf("no se pudo tomar snapshot de modulos")
|
||||||
|
}
|
||||||
|
defer procCloseHandle.Call(snap)
|
||||||
|
|
||||||
|
var me moduleEntry32
|
||||||
|
me.Size = uint32(unsafe.Sizeof(me))
|
||||||
|
r, _, _ := procModule32FirstW.Call(snap, uintptr(unsafe.Pointer(&me)))
|
||||||
|
if r == 0 {
|
||||||
|
return 0, 0, "", fmt.Errorf("Module32First fallo")
|
||||||
|
}
|
||||||
|
for {
|
||||||
|
mname := syscall.UTF16ToString(me.ModuleName[:])
|
||||||
|
if strings.EqualFold(mname, name) {
|
||||||
|
return me.ModBaseAddr, me.ModBaseSize, syscall.UTF16ToString(me.ExePath[:]), nil
|
||||||
|
}
|
||||||
|
r, _, _ := procModule32NextW.Call(snap, uintptr(unsafe.Pointer(&me)))
|
||||||
|
if r == 0 {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return 0, 0, "", fmt.Errorf("modulo no encontrado: %s", name)
|
||||||
|
}
|
||||||
|
|
||||||
|
// productVersion lee la version del ejecutable del juego. label trae las
|
||||||
|
// dos versiones completas (producto y archivo) porque no siempre
|
||||||
|
// coinciden, y sirve para diagnosticar si algun dia hay que ajustar el
|
||||||
|
// offset de PlayerIns.
|
||||||
|
func productVersion(path string) (major, minor uint16, label string, ok bool) {
|
||||||
|
if path == "" {
|
||||||
|
return 0, 0, "", false
|
||||||
|
}
|
||||||
|
p, err := syscall.UTF16PtrFromString(path)
|
||||||
|
if err != nil {
|
||||||
|
return 0, 0, "", false
|
||||||
|
}
|
||||||
|
size, _, _ := procGetFileVersionInfoSizeW.Call(uintptr(unsafe.Pointer(p)), 0)
|
||||||
|
if size == 0 {
|
||||||
|
return 0, 0, "", false
|
||||||
|
}
|
||||||
|
buf := make([]byte, size)
|
||||||
|
r, _, _ := procGetFileVersionInfoW.Call(uintptr(unsafe.Pointer(p)), 0, size, uintptr(unsafe.Pointer(&buf[0])))
|
||||||
|
if r == 0 {
|
||||||
|
return 0, 0, "", false
|
||||||
|
}
|
||||||
|
sub, err := syscall.UTF16PtrFromString(`\`)
|
||||||
|
if err != nil {
|
||||||
|
return 0, 0, "", false
|
||||||
|
}
|
||||||
|
var info *vsFixedFileInfo
|
||||||
|
var infoLen uint32
|
||||||
|
r, _, _ = procVerQueryValueW.Call(
|
||||||
|
uintptr(unsafe.Pointer(&buf[0])),
|
||||||
|
uintptr(unsafe.Pointer(sub)),
|
||||||
|
uintptr(unsafe.Pointer(&info)),
|
||||||
|
uintptr(unsafe.Pointer(&infoLen)),
|
||||||
|
)
|
||||||
|
if r == 0 || info == nil || infoLen == 0 {
|
||||||
|
return 0, 0, "", false
|
||||||
|
}
|
||||||
|
quad := func(ms, ls uint32) string {
|
||||||
|
return fmt.Sprintf("%d.%d.%d.%d", ms>>16, ms&0xFFFF, ls>>16, ls&0xFFFF)
|
||||||
|
}
|
||||||
|
label = fmt.Sprintf("producto %s / archivo %s",
|
||||||
|
quad(info.ProductVersionMS, info.ProductVersionLS),
|
||||||
|
quad(info.FileVersionMS, info.FileVersionLS))
|
||||||
|
return uint16(info.ProductVersionMS >> 16), uint16(info.ProductVersionMS & 0xFFFF), label, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// playerInsOffsetForVersion replica la tabla de SoulMemory
|
||||||
|
// (InitializeOffsets): hasta 1.06 el offset de PlayerIns dentro de
|
||||||
|
// WorldChrMan es 0x18468, de 1.07 en adelante 0x1E508.
|
||||||
|
//
|
||||||
|
// OJO: la version que reporta el exe NO es la que muestra el juego en
|
||||||
|
// pantalla (el exe puede decir 2.7.1.0 mientras el juego dice 1.17.1), y
|
||||||
|
// la tabla de SoulMemory esta escrita con los numeros del juego. Por eso
|
||||||
|
// esto es solo una CORAZONADA para decidir cual probar primero: quien
|
||||||
|
// decide de verdad es playerInsCandidates + la verificacion en memoria.
|
||||||
|
func playerInsOffsetForVersion(major, minor uint16, ok bool) uintptr {
|
||||||
|
if ok && major == 1 && minor <= 6 {
|
||||||
|
return 0x18468
|
||||||
|
}
|
||||||
|
return 0x1E508
|
||||||
|
}
|
||||||
|
|
||||||
|
// playerInsCandidates devuelve los offsets conocidos a probar, con el que
|
||||||
|
// sugiere la version primero.
|
||||||
|
func playerInsCandidates(major, minor uint16, ok bool) []uintptr {
|
||||||
|
if playerInsOffsetForVersion(major, minor, ok) == 0x18468 {
|
||||||
|
return []uintptr{0x18468, 0x1E508}
|
||||||
|
}
|
||||||
|
return []uintptr{0x1E508, 0x18468}
|
||||||
|
}
|
||||||
|
|
||||||
|
func openProcessHandle(pid uint32) (syscall.Handle, error) {
|
||||||
|
h, _, err := procOpenProcess.Call(uintptr(processQueryInformation|processVMRead), 0, uintptr(pid))
|
||||||
|
if h == 0 {
|
||||||
|
return 0, err
|
||||||
|
}
|
||||||
|
return syscall.Handle(h), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func readMemory(h syscall.Handle, addr uintptr, size int) ([]byte, bool) {
|
||||||
|
if addr == 0 {
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
buf := make([]byte, size)
|
||||||
|
var n uintptr
|
||||||
|
r, _, _ := procReadProcessMemory.Call(uintptr(h), addr, uintptr(unsafe.Pointer(&buf[0])), uintptr(size), uintptr(unsafe.Pointer(&n)))
|
||||||
|
if r == 0 || int(n) != size {
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
return buf, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// ------------------------- signature scans -------------------------
|
||||||
|
//
|
||||||
|
// Dos firmas, las dos con la misma forma: instruccion de 7 bytes
|
||||||
|
// "mov reg,[rip+disp32]", donde los 3 primeros bytes son el opcode y los
|
||||||
|
// 4 siguientes el desplazamiento. El slot estatico resuelto contiene el
|
||||||
|
// puntero al objeto (una dereferencia mas).
|
||||||
|
//
|
||||||
|
// GameDataMan -> tiene el contador de muertes (+0x94) y el flag de jefe (+0xC0).
|
||||||
|
// Mismo patron que usa eldenring_boss_timer.asl (LiveSplit).
|
||||||
|
// WorldChrMan -> tiene el puntero a PlayerIns (+playerInsOffset). Si ese
|
||||||
|
// puntero es nulo, no hay personaje en el mundo: estas en el
|
||||||
|
// menu principal o en una pantalla de carga. Es exactamente
|
||||||
|
// lo que hace SoulMemory.IsPlayerLoaded().
|
||||||
|
|
||||||
|
type patByte struct {
|
||||||
|
val byte
|
||||||
|
wildcard bool
|
||||||
|
}
|
||||||
|
|
||||||
|
// parsePattern acepta "48 8B 05 ?? ?? ?? ??" (?? = comodin).
|
||||||
|
func parsePattern(s string) []patByte {
|
||||||
|
var out []patByte
|
||||||
|
for _, tok := range strings.Fields(s) {
|
||||||
|
if strings.HasPrefix(tok, "?") {
|
||||||
|
out = append(out, patByte{wildcard: true})
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
v, err := strconv.ParseUint(tok, 16, 8)
|
||||||
|
if err != nil {
|
||||||
|
panic("patron invalido: " + tok)
|
||||||
|
}
|
||||||
|
out = append(out, patByte{val: byte(v)})
|
||||||
|
}
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
var (
|
||||||
|
// mov rax,[rip+disp32]; test rax,rax; jz +5; mov rax,[rax+58]; ret; ret
|
||||||
|
gameDataManPattern = parsePattern("48 8B 05 ?? ?? ?? ?? 48 85 C0 74 05 48 8B 40 58 C3 C3")
|
||||||
|
// mov rsi,[rip+disp32]; test rsi,rsi; ... (WorldChrManImp, igual que SoulMemory)
|
||||||
|
worldChrManPattern = parsePattern("48 8B 35 ?? ?? ?? ?? 48 85 F6 ?? ?? BB 01 00 00 00 89 5C 24 20 48 8B B6")
|
||||||
|
// mov rax,[rip+disp32]; cmp byte ptr [rax+disp32],0D; sete al; ret
|
||||||
|
// (GameMan: en +0xAC0 tiene el slot de guardado del personaje cargado)
|
||||||
|
gameManPattern = parsePattern("48 8B 05 ?? ?? ?? ?? 80 B8 ?? ?? ?? ?? 0D 0F 94 C0 C3")
|
||||||
|
)
|
||||||
|
|
||||||
|
// saveSlotOffset: donde GameMan guarda el indice de slot (0-9) de la
|
||||||
|
// partida cargada. Es la identidad REAL de un personaje: no depende del
|
||||||
|
// nombre, asi que dos personajes que se llamen igual no se mezclan.
|
||||||
|
const saveSlotOffset = 0xAC0
|
||||||
|
|
||||||
|
func matchAt(buf []byte, i int, pattern []patByte) bool {
|
||||||
|
if i+len(pattern) > len(buf) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
for j, p := range pattern {
|
||||||
|
if !p.wildcard && buf[i+j] != p.val {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
// scanModule busca varios patrones en una sola pasada por el modulo,
|
||||||
|
// leyendolo en chunks (con solape, por si un patron cae justo en el borde
|
||||||
|
// de un chunk). Devuelve, por cada patron, la direccion del match o 0.
|
||||||
|
func scanModule(h syscall.Handle, base uintptr, size uint32, patterns [][]patByte) []uintptr {
|
||||||
|
const chunk = 1 << 20 // 1 MiB
|
||||||
|
const overlap = 64
|
||||||
|
|
||||||
|
found := make([]uintptr, len(patterns))
|
||||||
|
remaining := len(patterns)
|
||||||
|
|
||||||
|
var pos uint32
|
||||||
|
for pos < size && remaining > 0 {
|
||||||
|
readSize := chunk
|
||||||
|
if rem := int(size - pos); readSize > rem {
|
||||||
|
readSize = rem
|
||||||
|
}
|
||||||
|
buf, ok := readMemory(h, base+uintptr(pos), readSize)
|
||||||
|
if ok {
|
||||||
|
for i := 0; i < len(buf); i++ {
|
||||||
|
for p := range patterns {
|
||||||
|
if found[p] != 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if matchAt(buf, i, patterns[p]) {
|
||||||
|
found[p] = base + uintptr(pos) + uintptr(i)
|
||||||
|
remaining--
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if uint32(readSize) <= overlap {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
pos += uint32(readSize) - overlap
|
||||||
|
}
|
||||||
|
return found
|
||||||
|
}
|
||||||
|
|
||||||
|
// ripSlot convierte la direccion de una instruccion "mov reg,[rip+disp32]"
|
||||||
|
// de 7 bytes en la direccion del slot estatico al que apunta.
|
||||||
|
func ripSlot(h syscall.Handle, matchAddr uintptr) (uintptr, error) {
|
||||||
|
if matchAddr == 0 {
|
||||||
|
return 0, fmt.Errorf("patron no encontrado")
|
||||||
|
}
|
||||||
|
codeLocation := matchAddr + 3 // los 3 primeros bytes son el opcode
|
||||||
|
dispBytes, ok := readMemory(h, codeLocation, 4)
|
||||||
|
if !ok {
|
||||||
|
return 0, fmt.Errorf("no se pudo leer el desplazamiento RIP-relativo")
|
||||||
|
}
|
||||||
|
disp := int32(binary.LittleEndian.Uint32(dispBytes))
|
||||||
|
return codeLocation + 4 + uintptr(int64(disp)), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// gamePointers junta todo lo que se resuelve una sola vez por sesion de
|
||||||
|
// proceso: los slots estaticos (que no se mueven) y la version del juego.
|
||||||
|
type gamePointers struct {
|
||||||
|
gameDataManSlot uintptr
|
||||||
|
worldChrManSlot uintptr // 0 si no se encontro el patron (seguimos sin el chequeo de menu)
|
||||||
|
gameManSlot uintptr // 0 si no se encontro: caemos a identificar por nombre
|
||||||
|
playerInsOffset uintptr // el que estamos usando (o el candidato preferido)
|
||||||
|
playerInsTried []uintptr
|
||||||
|
offsetConfirmed bool // true cuando lo verificamos leyendo memoria de verdad
|
||||||
|
versionLabel string
|
||||||
|
|
||||||
|
nameChain nameCandidate // como llegamos al nombre del personaje
|
||||||
|
nameConfirmed bool
|
||||||
|
namePending string // candidato a la espera de repetirse (ver resolveCharName)
|
||||||
|
namePendingOf nameCandidate
|
||||||
|
}
|
||||||
|
|
||||||
|
// resolvePointers hace los escaneos de firma (caro: recorre todo el
|
||||||
|
// modulo) una sola vez por sesion de proceso. A proposito NO devuelve los
|
||||||
|
// objetos ya resueltos: esos punteros se re-leen en cada tick, porque el
|
||||||
|
// juego puede destruir y recrear GameDataMan (por ejemplo al volver al
|
||||||
|
// menu principal y cargar de nuevo). Si nos quedaramos con una direccion
|
||||||
|
// vieja en cache, seguiriamos leyendola con exito (la pagina de memoria
|
||||||
|
// sigue siendo valida) pero el contenido pasaria a ser datos de otra cosa
|
||||||
|
// - la causa mas probable de un contador que "sube solo" sin que hayas
|
||||||
|
// muerto en verdad. SoulMemory hace lo mismo: su clase Pointer resuelve la
|
||||||
|
// cadena entera en cada lectura, no cachea la direccion final.
|
||||||
|
func resolvePointers(h syscall.Handle, pid uint32) (gamePointers, error) {
|
||||||
|
var gp gamePointers
|
||||||
|
|
||||||
|
base, size, exePath, err := findModuleBase(pid, processName)
|
||||||
|
if err != nil {
|
||||||
|
return gp, err
|
||||||
|
}
|
||||||
|
|
||||||
|
major, minor, label, okVer := productVersion(exePath)
|
||||||
|
gp.playerInsTried = playerInsCandidates(major, minor, okVer)
|
||||||
|
gp.playerInsOffset = gp.playerInsTried[0]
|
||||||
|
gp.versionLabel = label
|
||||||
|
if !okVer {
|
||||||
|
gp.versionLabel = "desconocida"
|
||||||
|
}
|
||||||
|
|
||||||
|
matches := scanModule(h, base, size, [][]patByte{gameDataManPattern, worldChrManPattern, gameManPattern})
|
||||||
|
|
||||||
|
gp.gameDataManSlot, err = ripSlot(h, matches[0])
|
||||||
|
if err != nil {
|
||||||
|
return gp, fmt.Errorf("no se encontro el patron de GameDataMan (¿cambio de version del juego?)")
|
||||||
|
}
|
||||||
|
|
||||||
|
// WorldChrMan es opcional: si no aparece, seguimos contando muertes,
|
||||||
|
// solo perdemos la deteccion de menu/pantalla de carga.
|
||||||
|
if slot, werr := ripSlot(h, matches[1]); werr == nil {
|
||||||
|
gp.worldChrManSlot = slot
|
||||||
|
}
|
||||||
|
// GameMan tambien es opcional: sin el, identificamos por nombre.
|
||||||
|
if slot, gerr := ripSlot(h, matches[2]); gerr == nil {
|
||||||
|
gp.gameManSlot = slot
|
||||||
|
}
|
||||||
|
return gp, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// derefPointer lee un slot estatico (barato: 8 bytes) y devuelve la
|
||||||
|
// direccion ACTUAL del objeto. Se llama en cada tick, no solo una vez.
|
||||||
|
func derefPointer(h syscall.Handle, slot uintptr) (uintptr, bool) {
|
||||||
|
if slot == 0 {
|
||||||
|
return 0, false
|
||||||
|
}
|
||||||
|
buf, ok := readMemory(h, slot, 8)
|
||||||
|
if !ok {
|
||||||
|
return 0, false
|
||||||
|
}
|
||||||
|
return uintptr(binary.LittleEndian.Uint64(buf)), true
|
||||||
|
}
|
||||||
|
|
||||||
|
// ------------------------- nombre del personaje -------------------------
|
||||||
|
//
|
||||||
|
// Dato sacado de la tabla de Cheat Engine: "GameDataMan +0C +9C, unicode,
|
||||||
|
// largo 19". Esa notacion admite mas de una lectura (¿0x0C es un puntero
|
||||||
|
// que hay que dereferenciar, o los dos offsets se suman?), y ademas la
|
||||||
|
// comunidad/el ASL usan GameDataMan+0x08 para llegar a PlayerGameData.
|
||||||
|
// Asi que no elegimos: probamos las tres y nos quedamos con la que
|
||||||
|
// devuelva algo que parezca un nombre de verdad.
|
||||||
|
|
||||||
|
type nameCandidate struct {
|
||||||
|
ptrOffset uintptr // offset donde vive el puntero (0 = sin dereferencia)
|
||||||
|
nameOffset uintptr // offset del texto dentro del objeto
|
||||||
|
label string
|
||||||
|
}
|
||||||
|
|
||||||
|
var nameCandidates = []nameCandidate{
|
||||||
|
{0x08, 0x9C, "[GameDataMan+0x08]+0x9C (PlayerGameData)"},
|
||||||
|
{0x0C, 0x9C, "[GameDataMan+0x0C]+0x9C"},
|
||||||
|
{0x00, 0xA8, "GameDataMan+0xA8 (0x0C y 0x9C sumados)"},
|
||||||
|
}
|
||||||
|
|
||||||
|
// looksLikeName (y charNameMaxChars) viven en names.go: no dependen de
|
||||||
|
// Windows, asi que quedan afuera de este archivo para poder testearlos
|
||||||
|
// sin una PC con el juego abierto.
|
||||||
|
|
||||||
|
func readCharName(h syscall.Handle, gameDataMan uintptr, c nameCandidate) (string, bool) {
|
||||||
|
base := gameDataMan
|
||||||
|
if c.ptrOffset != 0 {
|
||||||
|
p, ok := derefPointer(h, gameDataMan+c.ptrOffset)
|
||||||
|
if !ok || p == 0 {
|
||||||
|
return "", false
|
||||||
|
}
|
||||||
|
base = p
|
||||||
|
}
|
||||||
|
buf, ok := readMemory(h, base+c.nameOffset, charNameMaxChars*2)
|
||||||
|
if !ok {
|
||||||
|
return "", false
|
||||||
|
}
|
||||||
|
u16 := make([]uint16, 0, charNameMaxChars)
|
||||||
|
for i := 0; i+1 < len(buf); i += 2 {
|
||||||
|
ch := binary.LittleEndian.Uint16(buf[i : i+2])
|
||||||
|
if ch == 0 {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
u16 = append(u16, ch)
|
||||||
|
}
|
||||||
|
s := strings.TrimSpace(string(utf16.Decode(u16)))
|
||||||
|
if !looksLikeName(s) {
|
||||||
|
return "", false
|
||||||
|
}
|
||||||
|
return s, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// resolveCharName devuelve el nombre del personaje. Antes de fijar una
|
||||||
|
// variante exige verla dar el MISMO texto dos lecturas seguidas: el
|
||||||
|
// nombre real no cambia de un segundo a otro, pero un pedazo de memoria
|
||||||
|
// que casualmente pasa el filtro es mucho menos probable que se repita.
|
||||||
|
func resolveCharName(h syscall.Handle, gameDataMan uintptr, gp *gamePointers) (string, bool) {
|
||||||
|
if gp.nameConfirmed {
|
||||||
|
return readCharName(h, gameDataMan, gp.nameChain)
|
||||||
|
}
|
||||||
|
for _, c := range nameCandidates {
|
||||||
|
s, ok := readCharName(h, gameDataMan, c)
|
||||||
|
if !ok {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if gp.namePending == s && gp.namePendingOf == c {
|
||||||
|
gp.nameChain = c
|
||||||
|
gp.nameConfirmed = true
|
||||||
|
gp.namePending = ""
|
||||||
|
log.Printf("nombre del personaje: \"%s\" (leido con %s)", s, c.label)
|
||||||
|
return s, true
|
||||||
|
}
|
||||||
|
gp.namePending = s
|
||||||
|
gp.namePendingOf = c
|
||||||
|
return "", false
|
||||||
|
}
|
||||||
|
gp.namePending = ""
|
||||||
|
return "", false
|
||||||
|
}
|
||||||
|
|
||||||
|
// readSaveSlot devuelve el indice de slot (0-9) de la partida cargada, o
|
||||||
|
// -1 si no lo pudimos leer. Elden Ring tiene 10 slots, asi que cualquier
|
||||||
|
// otro valor es basura y se descarta.
|
||||||
|
func readSaveSlot(h syscall.Handle, gp gamePointers) int {
|
||||||
|
if gp.gameManSlot == 0 {
|
||||||
|
return -1
|
||||||
|
}
|
||||||
|
gameMan, ok := derefPointer(h, gp.gameManSlot)
|
||||||
|
if !ok || gameMan == 0 {
|
||||||
|
return -1
|
||||||
|
}
|
||||||
|
buf, ok := readMemory(h, gameMan+saveSlotOffset, 1)
|
||||||
|
if !ok {
|
||||||
|
return -1
|
||||||
|
}
|
||||||
|
slot := int(buf[0])
|
||||||
|
if slot < 0 || slot > 9 {
|
||||||
|
return -1
|
||||||
|
}
|
||||||
|
return slot
|
||||||
|
}
|
||||||
|
|
||||||
|
// isPlayerLoaded replica SoulMemory.IsPlayerLoaded(): resuelve
|
||||||
|
// WorldChrMan y lee el puntero a PlayerIns; si es nulo, no hay personaje
|
||||||
|
// en el mundo. El segundo valor indica si pudimos evaluarlo.
|
||||||
|
//
|
||||||
|
// Mientras no tengamos confirmado el offset, en vez de confiar en el
|
||||||
|
// numero de version (que en Elden Ring no coincide con el que muestra el
|
||||||
|
// juego) probamos los offsets conocidos y nos quedamos con el primero que
|
||||||
|
// apunte a memoria realmente legible. Eso lo decide la maquina, no una
|
||||||
|
// tabla que puede envejecer mal.
|
||||||
|
func isPlayerLoaded(h syscall.Handle, gp *gamePointers) (loaded bool, known bool) {
|
||||||
|
if gp.worldChrManSlot == 0 {
|
||||||
|
return true, false
|
||||||
|
}
|
||||||
|
worldChrMan, ok := derefPointer(h, gp.worldChrManSlot)
|
||||||
|
if !ok {
|
||||||
|
return true, false
|
||||||
|
}
|
||||||
|
if worldChrMan == 0 {
|
||||||
|
return false, true
|
||||||
|
}
|
||||||
|
|
||||||
|
if gp.offsetConfirmed {
|
||||||
|
playerIns, ok := derefPointer(h, worldChrMan+gp.playerInsOffset)
|
||||||
|
if !ok {
|
||||||
|
return true, false
|
||||||
|
}
|
||||||
|
return playerIns != 0, true
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, cand := range gp.playerInsTried {
|
||||||
|
playerIns, ok := derefPointer(h, worldChrMan+cand)
|
||||||
|
if !ok || playerIns == 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
// Un puntero de verdad apunta a memoria mapeada; uno de basura
|
||||||
|
// casi nunca sobrevive esta lectura.
|
||||||
|
if _, ok := readMemory(h, playerIns, 8); !ok {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
gp.playerInsOffset = cand
|
||||||
|
gp.offsetConfirmed = true
|
||||||
|
log.Printf("PlayerIns confirmado en +0x%X (verificado leyendo el objeto, no por el numero de version)", cand)
|
||||||
|
return true, true
|
||||||
|
}
|
||||||
|
return false, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// -------------------------------- poller loop --------------------------------
|
||||||
|
|
||||||
|
// maxPlausibleDeltaPerTick: entre dos lecturas separadas por ~1s, con el
|
||||||
|
// personaje cargado todo el tiempo, el contador de muertes real no puede
|
||||||
|
// subir mas que esto (ni bajar nunca). Un salto mas grande casi siempre
|
||||||
|
// significa que agarramos memoria que ya no es GameDataMan (direccion
|
||||||
|
// vieja/invalida) y no una muerte real.
|
||||||
|
const maxPlausibleDeltaPerTick = 3
|
||||||
|
|
||||||
|
func pollLoop() {
|
||||||
|
var (
|
||||||
|
handle syscall.Handle
|
||||||
|
pid uint32
|
||||||
|
gp gamePointers
|
||||||
|
resolved bool
|
||||||
|
lastRaw int32
|
||||||
|
haveLastRaw bool
|
||||||
|
sawUnloaded bool
|
||||||
|
warnedNoWCM bool
|
||||||
|
lastBossRead bool
|
||||||
|
|
||||||
|
// Vigilancia de la deteccion de menu: mientras creemos que no hay
|
||||||
|
// personaje cargado, igual espiamos el contador de muertes. Si sube
|
||||||
|
// como sube una muerte de verdad, entonces nuestra deteccion esta
|
||||||
|
// mintiendo (estabas jugando) y la desactivamos.
|
||||||
|
unloadedRaw int32
|
||||||
|
unloadedRawFirst int32
|
||||||
|
haveUnloadedRaw bool
|
||||||
|
)
|
||||||
|
|
||||||
|
closeHandle := func() {
|
||||||
|
if handle != 0 {
|
||||||
|
procCloseHandle.Call(uintptr(handle))
|
||||||
|
handle = 0
|
||||||
|
}
|
||||||
|
pid = 0
|
||||||
|
gp = gamePointers{}
|
||||||
|
resolved = false
|
||||||
|
haveLastRaw = false
|
||||||
|
sawUnloaded = false
|
||||||
|
haveUnloadedRaw = false
|
||||||
|
}
|
||||||
|
|
||||||
|
for {
|
||||||
|
if handle == 0 {
|
||||||
|
newPid, err := findProcessID(processName)
|
||||||
|
if err != nil {
|
||||||
|
st.setDisconnected("esperando a eldenring.exe")
|
||||||
|
time.Sleep(3 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
h, err := openProcessHandle(newPid)
|
||||||
|
if err != nil {
|
||||||
|
st.setDisconnected("no se pudo abrir el proceso (¿permisos?): " + err.Error())
|
||||||
|
time.Sleep(3 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
pid = newPid
|
||||||
|
handle = h
|
||||||
|
log.Printf("eldenring.exe encontrado (PID %d), escaneando firmas...", pid)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !resolved {
|
||||||
|
p, err := resolvePointers(handle, pid)
|
||||||
|
if err != nil {
|
||||||
|
st.setDisconnected(err.Error())
|
||||||
|
time.Sleep(2 * time.Second)
|
||||||
|
// si el proceso murio, soltamos el handle para reintentar desde cero
|
||||||
|
if _, ferr := findProcessID(processName); ferr != nil {
|
||||||
|
closeHandle()
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
gp = p
|
||||||
|
resolved = true
|
||||||
|
haveLastRaw = false
|
||||||
|
log.Printf("version del juego: %s | GameDataMan slot 0x%X", gp.versionLabel, gp.gameDataManSlot)
|
||||||
|
if gp.gameManSlot != 0 {
|
||||||
|
log.Printf("GameMan slot 0x%X (identifico personajes por su slot de guardado)", gp.gameManSlot)
|
||||||
|
} else {
|
||||||
|
log.Printf("aviso: no encontre el patron de GameMan; identifico personajes por nombre")
|
||||||
|
}
|
||||||
|
if gp.worldChrManSlot != 0 {
|
||||||
|
log.Printf("WorldChrMan slot 0x%X | PlayerIns: pruebo +0x%X y confirmo contra la memoria", gp.worldChrManSlot, gp.playerInsOffset)
|
||||||
|
} else if !warnedNoWCM {
|
||||||
|
warnedNoWCM = true
|
||||||
|
log.Printf("aviso: no se encontro el patron de WorldChrMan; sigo contando muertes pero sin detectar menu/pantalla de carga")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Igual que el ASL de LiveSplit, que hace "if (!IsPlayerLoaded) return;":
|
||||||
|
// sin personaje en el mundo no leemos nada. El total queda congelado en
|
||||||
|
// pantalla (no mostramos guion) para no parpadear en cada carga.
|
||||||
|
if loaded, known := isPlayerLoaded(handle, &gp); known && !loaded {
|
||||||
|
// Red de seguridad. El offset de PlayerIns depende de la version
|
||||||
|
// del juego: si algun parche lo mueve, leeriamos nulo para
|
||||||
|
// siempre y el contador quedaria congelado en pleno stream.
|
||||||
|
//
|
||||||
|
// El unico juez confiable es el contador de muertes en si: en el
|
||||||
|
// menu de inicio NO sube nunca. Asi que espiamos el crudo sin
|
||||||
|
// usarlo, y si sube como sube una muerte real (+1, +2, +3),
|
||||||
|
// entonces estabas jugando y nuestra deteccion estaba mintiendo.
|
||||||
|
// A diferencia de un timeout, esto no puede dispararse por dejar
|
||||||
|
// el juego parado en el menu un rato largo.
|
||||||
|
if gdm, ok := derefPointer(handle, gp.gameDataManSlot); ok && gdm != 0 {
|
||||||
|
if buf, ok := readMemory(handle, gdm+0x94, 4); ok {
|
||||||
|
raw := int32(binary.LittleEndian.Uint32(buf))
|
||||||
|
if raw >= 0 && raw < 1_000_000 {
|
||||||
|
if haveUnloadedRaw {
|
||||||
|
if d := raw - unloadedRaw; d >= 1 && d <= maxPlausibleDeltaPerTick {
|
||||||
|
log.Printf("el contador de muertes subio de %d a %d mientras yo creia que no habia personaje cargado: la deteccion de menu esta equivocada en esta version, la desactivo y sigo contando", unloadedRaw, raw)
|
||||||
|
gp.worldChrManSlot = 0
|
||||||
|
// Rescatamos lo ocurrido durante el rato confundido:
|
||||||
|
// dejamos la referencia en la primera lectura de ese
|
||||||
|
// periodo para que la logica de "cruce de carga"
|
||||||
|
// acredite las muertes si fueron pocas.
|
||||||
|
lastRaw = unloadedRawFirst
|
||||||
|
haveLastRaw = true
|
||||||
|
sawUnloaded = true
|
||||||
|
haveUnloadedRaw = false
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
unloadedRawFirst = raw
|
||||||
|
}
|
||||||
|
unloadedRaw = raw
|
||||||
|
haveUnloadedRaw = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Ojo: NO tocamos haveLastRaw/lastRaw, justamente para poder
|
||||||
|
// comparar contra la ultima lectura buena cuando vuelva el mundo.
|
||||||
|
st.setPlayerUnloaded("menu principal o pantalla de carga")
|
||||||
|
sawUnloaded = true
|
||||||
|
time.Sleep(1 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
haveUnloadedRaw = false
|
||||||
|
|
||||||
|
// Re-dereferenciamos el slot en CADA tick (no solo al conectar) para
|
||||||
|
// nunca quedarnos con una direccion vieja de GameDataMan.
|
||||||
|
gameDataMan, ok := derefPointer(handle, gp.gameDataManSlot)
|
||||||
|
if !ok {
|
||||||
|
st.setDisconnected("se perdio la lectura de memoria (el juego se cerro o reinicio)")
|
||||||
|
closeHandle()
|
||||||
|
time.Sleep(2 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if gameDataMan == 0 {
|
||||||
|
st.setPlayerUnloaded("sin partida cargada")
|
||||||
|
sawUnloaded = true
|
||||||
|
time.Sleep(1 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
deathsBuf, ok1 := readMemory(handle, gameDataMan+0x94, 4)
|
||||||
|
bossBuf, ok2 := readMemory(handle, gameDataMan+0xC0, 1)
|
||||||
|
if !ok1 {
|
||||||
|
st.setDisconnected("se perdio la lectura de memoria (el juego se cerro o reinicio)")
|
||||||
|
closeHandle()
|
||||||
|
time.Sleep(2 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
raw := int32(binary.LittleEndian.Uint32(deathsBuf))
|
||||||
|
boss := lastBossRead
|
||||||
|
if ok2 {
|
||||||
|
boss = bossBuf[0] != 0
|
||||||
|
lastBossRead = boss
|
||||||
|
}
|
||||||
|
if raw < 0 || raw > 1_000_000 {
|
||||||
|
log.Printf("lectura imposible descartada (raw %d) - re-escaneando firmas", raw)
|
||||||
|
resolved = false
|
||||||
|
haveLastRaw = false
|
||||||
|
time.Sleep(1 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// Dentro de una misma partida el contador no baja ni pega saltos:
|
||||||
|
// si pasa, es memoria que ya no es GameDataMan. Cruzando una carga
|
||||||
|
// en cambio puede cambiar a cualquier cosa, porque puede ser otro
|
||||||
|
// personaje, y de eso se encarga setCharacter.
|
||||||
|
if haveLastRaw && !sawUnloaded {
|
||||||
|
delta := int64(raw) - int64(lastRaw)
|
||||||
|
if delta < 0 || delta > maxPlausibleDeltaPerTick {
|
||||||
|
log.Printf("lectura sospechosa descartada (raw %d, anterior %d) - re-escaneando firmas", raw, lastRaw)
|
||||||
|
resolved = false
|
||||||
|
haveLastRaw = false
|
||||||
|
time.Sleep(1 * time.Second)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Quien es este personaje se resuelve ANTES de registrar la
|
||||||
|
// lectura: si cambiaste de personaje, el total salta al suyo en
|
||||||
|
// esta misma vuelta y no hay que esperar a que alguien muera.
|
||||||
|
name, _ := resolveCharName(handle, gameDataMan, &gp)
|
||||||
|
st.setCharacter(readSaveSlot(handle, gp), name, raw)
|
||||||
|
|
||||||
|
st.setReading(raw, boss)
|
||||||
|
|
||||||
|
lastRaw = raw
|
||||||
|
haveLastRaw = true
|
||||||
|
sawUnloaded = false
|
||||||
|
|
||||||
|
time.Sleep(1 * time.Second)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------------------------------- HTTP ----------------------------------
|
||||||
|
|
||||||
|
// puertoDe saca el puerto de una direccion tipo "0.0.0.0:47822", para
|
||||||
|
// poder decirle al compañero exactamente que escribir en su config.
|
||||||
|
func puertoDe(addr string) string {
|
||||||
|
if _, port, ok := strings.Cut(addr, ":"); ok {
|
||||||
|
return port
|
||||||
|
}
|
||||||
|
return addr
|
||||||
|
}
|
||||||
|
|
||||||
|
func withCORS(w http.ResponseWriter) {
|
||||||
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||||
|
w.Header().Set("Cache-Control", "no-store")
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
log.SetFlags(log.Ltime)
|
||||||
|
log.Println("=== Elden Ring Death Counter (lectura local, solo lectura) ===")
|
||||||
|
|
||||||
|
loadLocales()
|
||||||
|
cfg := loadConfig()
|
||||||
|
writeSampleConfig()
|
||||||
|
esPeer := cfg.Mode == "peer"
|
||||||
|
|
||||||
|
lang := resolveLang(cfg.Language)
|
||||||
|
log.Printf("version: %s | PID %d | modo %s | idioma %s (disponibles: %s)",
|
||||||
|
buildTag, os.Getpid(), cfg.Mode, lang, strings.Join(availableLangs(), ", "))
|
||||||
|
|
||||||
|
totals = newTotalsStore()
|
||||||
|
st.init(totals)
|
||||||
|
|
||||||
|
go pollLoop()
|
||||||
|
|
||||||
|
registro := newPeerRegistry()
|
||||||
|
|
||||||
|
// El token es obligatorio en las dos puntas: sin el, cualquiera que
|
||||||
|
// alcance el puerto podria inyectar datos en el overlay.
|
||||||
|
var token string
|
||||||
|
if !esPeer {
|
||||||
|
t, generado, err := resolveToken(cfg)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("no pude preparar el token: %v", err)
|
||||||
|
}
|
||||||
|
token = t
|
||||||
|
logTokenBanner(token, generado)
|
||||||
|
}
|
||||||
|
|
||||||
|
if esPeer {
|
||||||
|
if cfg.Hub == "" {
|
||||||
|
log.Println("¡ojo! modo peer sin 'hub' en el config.toml: no tengo a donde mandar el contador")
|
||||||
|
} else if strings.TrimSpace(cfg.Token) == "" {
|
||||||
|
log.Println("¡ojo! modo peer sin 'token' en el config.toml: el hub te va a rechazar. Pedíle el token a quien lo corre.")
|
||||||
|
} else {
|
||||||
|
go peerLoop(cfg)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
registro.declare(cfg.Partner)
|
||||||
|
}
|
||||||
|
|
||||||
|
mux := http.NewServeMux()
|
||||||
|
|
||||||
|
if !esPeer {
|
||||||
|
mux.HandleFunc("/ws", registro.wsHandler(token))
|
||||||
|
}
|
||||||
|
|
||||||
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
||||||
|
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||||
|
w.Header().Set("X-Build", buildTag)
|
||||||
|
w.Write(overlayHTML)
|
||||||
|
})
|
||||||
|
|
||||||
|
// Los textos de la interfaz: la pagina los pide una vez al cargar.
|
||||||
|
// ?lang= permite forzar un idioma sin tocar el config, comodo para
|
||||||
|
// tener el overlay en un idioma y el panel en otro.
|
||||||
|
mux.HandleFunc("/strings.json", func(w http.ResponseWriter, r *http.Request) {
|
||||||
|
withCORS(w)
|
||||||
|
want := lang
|
||||||
|
if q := r.URL.Query().Get("lang"); q != "" {
|
||||||
|
want = resolveLang(q)
|
||||||
|
}
|
||||||
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
||||||
|
json.NewEncoder(w).Encode(stringsFor(want))
|
||||||
|
})
|
||||||
|
|
||||||
|
mux.HandleFunc("/deaths", func(w http.ResponseWriter, r *http.Request) {
|
||||||
|
withCORS(w)
|
||||||
|
snap := st.snapshot()
|
||||||
|
|
||||||
|
// Este jugador primero, despues los compañeros en orden de aparicion.
|
||||||
|
players := []playerView{{
|
||||||
|
Name: nombreMostrado(cfg),
|
||||||
|
Deaths: snap.Total,
|
||||||
|
BossFight: snap.BossFight,
|
||||||
|
PlayerLoaded: snap.PlayerLoaded,
|
||||||
|
Connected: snap.Connected,
|
||||||
|
Self: true,
|
||||||
|
}}
|
||||||
|
// Modo coop solo cuando hay (o hubo recien) un compañero conectado.
|
||||||
|
if registro.coopMode() {
|
||||||
|
players = append(players, registro.views()...)
|
||||||
|
}
|
||||||
|
|
||||||
|
var combined int64
|
||||||
|
for _, p := range players {
|
||||||
|
combined += p.Deaths
|
||||||
|
}
|
||||||
|
|
||||||
|
resp := map[string]interface{}{
|
||||||
|
"players": players,
|
||||||
|
"combined": combined,
|
||||||
|
"build": buildTag,
|
||||||
|
// Campos de la version de un solo jugador: los dejamos para no
|
||||||
|
// romper nada que ya este apuntando aca.
|
||||||
|
"deaths": snap.Total,
|
||||||
|
"rawDeaths": snap.RawDeaths,
|
||||||
|
"character": snap.CharName,
|
||||||
|
"slot": snap.Slot,
|
||||||
|
"bossFight": snap.BossFight,
|
||||||
|
"connected": snap.Connected,
|
||||||
|
"playerLoaded": snap.PlayerLoaded,
|
||||||
|
}
|
||||||
|
w.Header().Set("Content-Type", "application/json")
|
||||||
|
json.NewEncoder(w).Encode(resp)
|
||||||
|
})
|
||||||
|
|
||||||
|
log.Printf("Panel: http://%s/", cfg.Listen)
|
||||||
|
if esPeer {
|
||||||
|
log.Printf("Mandando el contador al hub %s. Esta ventana tiene que quedar abierta mientras jugás.", cfg.Hub)
|
||||||
|
} else {
|
||||||
|
log.Printf("OBS URL: http://%s/?view=overlay", cfg.Listen)
|
||||||
|
log.Printf("Tu compañero tiene que poner en su config.toml: hub = \"<tu IP>:%s\" y el token de arriba", puertoDe(cfg.Listen))
|
||||||
|
log.Println("Dejá esta ventana abierta mientras streameás. Ctrl+C para cerrar.")
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := http.ListenAndServe(cfg.Listen, mux); err != nil {
|
||||||
|
log.Fatalf("no se pudo iniciar el servidor local: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,90 @@
|
|||||||
|
// looksLikeName decides whether text read from the game's memory looks
|
||||||
|
// like a real character name, and not binary garbage decoded as if it
|
||||||
|
// were UTF-16. It lives apart from main.go (which is Windows-only)
|
||||||
|
// because it's pure string logic: it can be tested without a PC with the
|
||||||
|
// game open.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"unicode"
|
||||||
|
"unicode/utf8"
|
||||||
|
)
|
||||||
|
|
||||||
|
// charNameMaxChars: from the Cheat Engine table, "GameDataMan
|
||||||
|
// +0C +9C, unicode, length 19".
|
||||||
|
const charNameMaxChars = 19
|
||||||
|
|
||||||
|
// script identifies the writing-system family of a character in the name.
|
||||||
|
type script int
|
||||||
|
|
||||||
|
const (
|
||||||
|
scriptNone script = iota
|
||||||
|
scriptLatin
|
||||||
|
scriptCyrillic
|
||||||
|
scriptHangul
|
||||||
|
scriptCJK // Han, Hiragana, and Katakana count as a single family
|
||||||
|
)
|
||||||
|
|
||||||
|
func scriptOf(r rune) script {
|
||||||
|
switch {
|
||||||
|
case unicode.In(r, unicode.Latin):
|
||||||
|
return scriptLatin
|
||||||
|
case unicode.In(r, unicode.Cyrillic):
|
||||||
|
return scriptCyrillic
|
||||||
|
case unicode.In(r, unicode.Hangul):
|
||||||
|
return scriptHangul
|
||||||
|
case unicode.In(r, unicode.Han, unicode.Hiragana, unicode.Katakana):
|
||||||
|
return scriptCJK
|
||||||
|
default:
|
||||||
|
return scriptNone
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// looksLikeName guards against garbage. "Printable" isn't nearly enough:
|
||||||
|
// a 64-bit pointer read as UTF-16 decodes into things like "ᾘ䱷翶", which
|
||||||
|
// is printable and would pass a filter that only checked that.
|
||||||
|
//
|
||||||
|
// This used to require the Latin alphabet, which left out Chinese,
|
||||||
|
// Korean, and Japanese names. Instead it requires SCRIPT COHERENCE: the
|
||||||
|
// whole name has to come from a single family (Latin, Cyrillic, Hangul,
|
||||||
|
// or Han+Hiragana+Katakana as one family, since Japanese mixes all three
|
||||||
|
// in one name) plus digits/space/punctuation (which don't belong to any
|
||||||
|
// particular family). Mixing families — like Greek + Han in "ᾘ䱷翶" — is
|
||||||
|
// still rejected: that's exactly the signature of binary garbage.
|
||||||
|
func looksLikeName(s string) bool {
|
||||||
|
n := utf8.RuneCountInString(s)
|
||||||
|
if n < 2 || n > charNameMaxChars {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
sc := scriptNone
|
||||||
|
hadLetter := false
|
||||||
|
|
||||||
|
for i, r := range s {
|
||||||
|
if r == utf8.RuneError || !unicode.IsPrint(r) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
if unicode.IsDigit(r) {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if r == ' ' || r == '-' || r == '_' || r == '.' || r == '\'' {
|
||||||
|
if i == 0 {
|
||||||
|
return false // a name doesn't start with punctuation
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
f := scriptOf(r)
|
||||||
|
if f == scriptNone {
|
||||||
|
return false // script not accepted
|
||||||
|
}
|
||||||
|
if sc == scriptNone {
|
||||||
|
sc = f
|
||||||
|
} else if sc != f {
|
||||||
|
return false // mixed families: the signature of binary garbage
|
||||||
|
}
|
||||||
|
hadLetter = true
|
||||||
|
}
|
||||||
|
|
||||||
|
return hadLetter
|
||||||
|
}
|
||||||
@@ -0,0 +1,54 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import "testing"
|
||||||
|
|
||||||
|
func TestLooksLikeName(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
name string
|
||||||
|
ok bool
|
||||||
|
}{
|
||||||
|
// Latin: the usual case.
|
||||||
|
{"Vaike", true},
|
||||||
|
{"Jean-Paul", true},
|
||||||
|
{"O'Brien", true},
|
||||||
|
{"Tarnished 2", true},
|
||||||
|
|
||||||
|
// Cyrillic.
|
||||||
|
{"Иван", true},
|
||||||
|
{"Мария Петровна", true},
|
||||||
|
|
||||||
|
// Hangul.
|
||||||
|
{"지우", true},
|
||||||
|
{"김민준", true},
|
||||||
|
|
||||||
|
// CJK: Han, Hiragana, and Katakana count as a single family
|
||||||
|
// because Japanese mixes them in one name.
|
||||||
|
{"田中", true}, // Han alone (also valid in Chinese)
|
||||||
|
{"たろう", true}, // Hiragana alone
|
||||||
|
{"タロウ", true}, // Katakana alone
|
||||||
|
{"田中たかし", true}, // Han + Hiragana, typical Japanese name
|
||||||
|
|
||||||
|
// Cases that MUST keep failing (regression, see CLAUDE.md):
|
||||||
|
// Greek + Han mixed, the garbage a 64-bit pointer decodes into
|
||||||
|
// when read as UTF-16.
|
||||||
|
{"ᾘ䱷翶", false},
|
||||||
|
|
||||||
|
// Mixing two ACCEPTED families is still mixing: not a valid
|
||||||
|
// name in any real language.
|
||||||
|
{"Аnna", false}, // Cyrillic А + Latin nna
|
||||||
|
|
||||||
|
// The usual rules: length, leading punctuation, digits-only.
|
||||||
|
{"", false},
|
||||||
|
{"A", false},
|
||||||
|
{"WayTooLongOfANameToBeRealHonestly", false},
|
||||||
|
{"-Starts", false},
|
||||||
|
{"123", false},
|
||||||
|
{"Ok 123", true},
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, c := range cases {
|
||||||
|
if got := looksLikeName(c.name); got != c.ok {
|
||||||
|
t.Errorf("looksLikeName(%q) = %v, wanted %v", c.name, got, c.ok)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
+377
@@ -0,0 +1,377 @@
|
|||||||
|
<!doctype html>
|
||||||
|
<html lang="es">
|
||||||
|
<head>
|
||||||
|
<meta charset="utf-8">
|
||||||
|
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||||
|
<title>Elden Ring Death Counter</title>
|
||||||
|
<style>
|
||||||
|
:root{
|
||||||
|
--bg:#0b0906;
|
||||||
|
--bg-elevated:#17130f;
|
||||||
|
--bg-card:#1d1712;
|
||||||
|
--gold:#c9a24b;
|
||||||
|
--gold-bright:#e8c874;
|
||||||
|
--ash-red:#8a2a2a;
|
||||||
|
--ash-red-bright:#b23a3a;
|
||||||
|
--parchment:#e9e2cf;
|
||||||
|
--muted:#948a76;
|
||||||
|
--rule:#3a3226;
|
||||||
|
--ok:#7fae6e;
|
||||||
|
--shadow:0 20px 60px rgba(0,0,0,.55);
|
||||||
|
}
|
||||||
|
*{box-sizing:border-box;}
|
||||||
|
html,body{background:var(--bg);}
|
||||||
|
body{
|
||||||
|
margin:0; min-height:100vh; background:var(--bg); color:var(--parchment);
|
||||||
|
font-family:'EB Garamond', Georgia, 'Times New Roman', serif;
|
||||||
|
-webkit-font-smoothing:antialiased;
|
||||||
|
}
|
||||||
|
[hidden]{display:none!important;}
|
||||||
|
.display,h1,.num{font-family:'Cinzel', Georgia, serif;}
|
||||||
|
.eyebrow{font-family:'Cinzel', Georgia, serif;font-size:.72rem;letter-spacing:.32em;text-transform:uppercase;color:var(--muted);}
|
||||||
|
.num{font-variant-numeric:tabular-nums;font-feature-settings:"tnum";}
|
||||||
|
@media (prefers-reduced-motion: reduce){*{animation-duration:.001ms!important;transition-duration:.001ms!important;}}
|
||||||
|
|
||||||
|
/* overlay (OBS) */
|
||||||
|
html.mode-overlay,html.mode-overlay body{background:transparent;}
|
||||||
|
#overlay{background:transparent;min-height:100vh;display:flex;align-items:flex-start;justify-content:flex-start;padding:16px;}
|
||||||
|
.plate{
|
||||||
|
background:rgba(9,7,5,.9); backdrop-filter:blur(8px); -webkit-backdrop-filter:blur(8px);
|
||||||
|
border-top:1px solid var(--gold); border-bottom:1px solid var(--gold);
|
||||||
|
padding:18px 24px; width:600px; box-sizing:border-box; box-shadow:var(--shadow);
|
||||||
|
}
|
||||||
|
/* Con un solo jugador la placa se angosta; el canvas de OBS no cambia,
|
||||||
|
simplemente ocupa menos. Asi las dimensiones se configuran una vez. */
|
||||||
|
.plate.solo{width:420px;}
|
||||||
|
.players{display:flex;align-items:stretch;justify-content:center;}
|
||||||
|
.pcol{flex:1 1 0;min-width:0;text-align:center;}
|
||||||
|
.pname{
|
||||||
|
font-family:'Cinzel', Georgia, serif;font-size:.78rem;letter-spacing:.24em;text-transform:uppercase;
|
||||||
|
color:var(--gold);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;
|
||||||
|
}
|
||||||
|
.pnum{
|
||||||
|
display:block;font-family:'Cinzel', Georgia, serif;font-variant-numeric:tabular-nums;
|
||||||
|
font-size:3.6rem;line-height:1.05;font-weight:600;color:var(--parchment);margin-top:.25rem;
|
||||||
|
transition:color .15s ease, transform .15s ease;
|
||||||
|
}
|
||||||
|
.pnum.pulse{color:var(--gold-bright);transform:scale(1.06);}
|
||||||
|
/* Una sola linea bajo el numero: dice "muertes" y, cuando hay algo que
|
||||||
|
contar (jefe, sin conexion), lo agrega ahi mismo. Asi la palabra
|
||||||
|
siempre esta y el alto del overlay no cambia nunca. */
|
||||||
|
.pnote{
|
||||||
|
font-family:'Cinzel', Georgia, serif;font-size:.7rem;letter-spacing:.22em;text-transform:uppercase;
|
||||||
|
color:var(--muted);min-height:1.5em;margin-top:.35rem;
|
||||||
|
}
|
||||||
|
.pnote .st{color:var(--ash-red-bright);font-style:italic;}
|
||||||
|
.pnote .sep{opacity:.5;margin:0 .45em;}
|
||||||
|
.pcol.off .pname,.pcol.off .pnum{color:var(--muted);}
|
||||||
|
.pdiv{width:1px;flex:0 0 1px;margin:0 20px;background:linear-gradient(180deg,transparent,var(--gold),transparent);opacity:.75;}
|
||||||
|
|
||||||
|
/* control / status */
|
||||||
|
#control{min-height:100vh;display:flex;align-items:center;justify-content:center;padding:3rem 1.25rem;}
|
||||||
|
.card{width:100%;max-width:560px;background:var(--bg-card);border:1px solid var(--rule);box-shadow:var(--shadow);padding:2.4rem 2.4rem 2rem;position:relative;}
|
||||||
|
.card::before,.card::after{content:"";position:absolute;left:2.4rem;right:2.4rem;height:1px;background:linear-gradient(90deg,transparent,var(--gold),transparent);opacity:.6;}
|
||||||
|
.card::before{top:1.35rem;} .card::after{bottom:1.35rem;}
|
||||||
|
.title{text-align:center;font-size:1.05rem;letter-spacing:.28em;text-transform:uppercase;color:var(--gold);margin:0 0 .3rem;}
|
||||||
|
.title small{display:block;font-family:'EB Garamond', Georgia, serif;letter-spacing:0;text-transform:none;font-style:italic;color:var(--muted);font-size:.95rem;margin-top:.3rem;}
|
||||||
|
.hero{text-align:center;margin:2.1rem 0 1.6rem;}
|
||||||
|
.hero .num{font-size:6rem;line-height:1;font-weight:700;color:var(--parchment);transition:color .15s ease, transform .15s ease;}
|
||||||
|
.hero .num.pulse{color:var(--gold-bright);transform:scale(1.05);}
|
||||||
|
.hero .eyebrow{margin-top:.5rem;}
|
||||||
|
.stats{display:grid;grid-template-columns:1fr 1fr;gap:1px;background:var(--rule);margin:1.6rem 0;border:1px solid var(--rule);}
|
||||||
|
.stat{background:var(--bg-elevated);padding:.9rem 1rem;text-align:center;}
|
||||||
|
.stat .stat-num{font-size:1.5rem;font-weight:600;color:var(--gold);}
|
||||||
|
.stat .stat-label{font-size:.65rem;letter-spacing:.18em;text-transform:uppercase;color:var(--muted);margin-top:.2rem;}
|
||||||
|
.field{margin:1.4rem 0;}
|
||||||
|
.field label{display:block;font-size:.7rem;letter-spacing:.2em;text-transform:uppercase;color:var(--muted);margin-bottom:.4rem;}
|
||||||
|
.field .row{display:flex;gap:.5rem;}
|
||||||
|
.field input[type=number],.field input[type=text]{
|
||||||
|
width:100%;background:var(--bg-elevated);border:1px solid var(--rule);color:var(--parchment);
|
||||||
|
font-family:'EB Garamond', Georgia, serif;font-size:1.05rem;padding:.55rem .75rem;
|
||||||
|
}
|
||||||
|
.field input:focus{border-color:var(--gold);outline:none;}
|
||||||
|
.btn{border:1px solid var(--gold);background:transparent;color:var(--gold-bright);padding:.6rem 1rem;font-size:.85rem;letter-spacing:.1em;text-transform:uppercase;cursor:pointer;transition:background .15s ease;}
|
||||||
|
.btn:hover{background:rgba(201,162,75,.12);}
|
||||||
|
.hint{font-size:.78rem;color:var(--muted);margin-top:.5rem;line-height:1.5;}
|
||||||
|
.obs-box{margin-top:1.8rem;padding-top:1.3rem;border-top:1px solid var(--rule);}
|
||||||
|
.obs-url-row{display:flex;gap:.5rem;}
|
||||||
|
.obs-url-row input{flex:1;background:var(--bg-elevated);border:1px solid var(--rule);color:var(--muted);font-family:'EB Garamond', monospace;font-size:.85rem;padding:.5rem .6rem;}
|
||||||
|
.copy-btn{border:1px solid var(--rule);background:transparent;color:var(--muted);padding:.5rem .9rem;font-size:.8rem;letter-spacing:.08em;text-transform:uppercase;cursor:pointer;}
|
||||||
|
.copy-btn:hover{border-color:var(--gold);color:var(--gold);}
|
||||||
|
.status{text-align:center;font-size:.75rem;color:var(--muted);margin-top:1.3rem;letter-spacing:.05em;}
|
||||||
|
.status .dot{display:inline-block;width:.45em;height:.45em;border-radius:50%;background:var(--muted);margin-right:.4em;}
|
||||||
|
.status.live .dot{background:var(--ok);}
|
||||||
|
.status.err .dot{background:var(--ash-red-bright);}
|
||||||
|
.build{text-align:center;font-size:.68rem;color:var(--muted);margin-top:.4rem;letter-spacing:.04em;opacity:.7;}
|
||||||
|
.boss-flag{display:none;text-align:center;color:var(--ash-red-bright);font-style:italic;letter-spacing:.08em;margin-top:.3rem;}
|
||||||
|
.boss-flag.on{display:block;}
|
||||||
|
.peer-row{display:flex;justify-content:space-between;align-items:baseline;gap:1rem;padding:.45rem .75rem;background:var(--bg-elevated);border:1px solid var(--rule);margin-bottom:.35rem;}
|
||||||
|
.peer-row .pn{color:var(--parchment);}
|
||||||
|
.peer-row .pv{font-family:'Cinzel', Georgia, serif;color:var(--gold);font-variant-numeric:tabular-nums;}
|
||||||
|
.peer-row.off .pn,.peer-row.off .pv{color:var(--muted);}
|
||||||
|
.peer-row .ps{font-size:.72rem;letter-spacing:.12em;text-transform:uppercase;color:var(--muted);}
|
||||||
|
</style>
|
||||||
|
<link rel="preconnect" href="https://fonts.googleapis.com">
|
||||||
|
<link href="https://fonts.googleapis.com/css2?family=Cinzel:wght@500;600;700&family=EB+Garamond:ital,wght@0,400;0,500;0,600;1,400&display=swap" rel="stylesheet">
|
||||||
|
<script>
|
||||||
|
(function(){
|
||||||
|
var params = new URLSearchParams(location.search);
|
||||||
|
var mode = (params.get('view') || 'control').toLowerCase();
|
||||||
|
if (mode !== 'overlay') mode = 'control';
|
||||||
|
document.documentElement.classList.add('mode-' + mode);
|
||||||
|
window.__mode = mode;
|
||||||
|
})();
|
||||||
|
</script>
|
||||||
|
</head>
|
||||||
|
<body>
|
||||||
|
|
||||||
|
<div id="overlay" hidden>
|
||||||
|
<div class="plate solo" id="ov-plate">
|
||||||
|
<div class="players" id="ov-players"></div>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<div id="control" hidden>
|
||||||
|
<div class="card">
|
||||||
|
<p class="title"><span data-i18n="panel.title">Elden Ring</span><small data-i18n="panel.subtitle">Death Counter</small></p>
|
||||||
|
<div class="hero">
|
||||||
|
<span class="num" id="c-total">–</span>
|
||||||
|
<div class="eyebrow" data-i18n="panel.total">Total deaths</div>
|
||||||
|
</div>
|
||||||
|
<div class="boss-flag" id="c-boss" data-i18n="panel.boss">⚔ In a boss fight</div>
|
||||||
|
<div class="stats">
|
||||||
|
<div class="stat"><div class="stat-num" id="c-raw">–</div><div class="stat-label" data-i18n="panel.raw">Read from process</div></div>
|
||||||
|
<div class="stat"><div class="stat-num" id="c-slot">–</div><div class="stat-label" data-i18n="panel.slot">Save slot</div></div>
|
||||||
|
</div>
|
||||||
|
<div class="field" id="c-peers-box" hidden>
|
||||||
|
<label data-i18n="panel.partners">Partners</label>
|
||||||
|
<div id="c-peers"></div>
|
||||||
|
</div>
|
||||||
|
<div class="obs-box">
|
||||||
|
<div class="field">
|
||||||
|
<label data-i18n="panel.obsUrl">URL for OBS (Browser Source)</label>
|
||||||
|
<div class="obs-url-row">
|
||||||
|
<input type="text" id="obs-url" readonly>
|
||||||
|
<button class="copy-btn" id="copy-btn" data-i18n="panel.copy">Copy</button>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
<p class="hint" data-i18n="panel.obsHint"></p>
|
||||||
|
</div>
|
||||||
|
<p class="status" id="status"><span class="dot"></span><span id="status-text" data-i18n="status.connecting">Connecting…</span></p>
|
||||||
|
<p class="build" id="c-build"></p>
|
||||||
|
</div>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<script>
|
||||||
|
(function(){
|
||||||
|
var mode = window.__mode || 'control';
|
||||||
|
|
||||||
|
// Textos de la interfaz. El diccionario real viene de /strings.json
|
||||||
|
// (ver i18n.go y locales/*.json). Este de aca es el bote salvavidas:
|
||||||
|
// si esa peticion falla, se ve ingles y nunca una clave cruda.
|
||||||
|
var FALLBACK = {
|
||||||
|
"overlay.deaths": "deaths",
|
||||||
|
"overlay.boss": "boss",
|
||||||
|
"overlay.offline": "no connection",
|
||||||
|
"overlay.waiting": "waiting for the game…",
|
||||||
|
"overlay.you": "You",
|
||||||
|
"overlay.partner": "Partner",
|
||||||
|
"panel.title": "Elden Ring",
|
||||||
|
"panel.subtitle": "Death Counter · live reading",
|
||||||
|
"panel.total": "Total deaths",
|
||||||
|
"panel.raw": "Read from process",
|
||||||
|
"panel.slot": "Save slot",
|
||||||
|
"panel.boss": "⚔ In a boss fight",
|
||||||
|
"panel.partners": "Partners",
|
||||||
|
"panel.obsUrl": "URL for OBS (Browser Source)",
|
||||||
|
"panel.copy": "Copy",
|
||||||
|
"panel.copied": "Copied",
|
||||||
|
"panel.copyManual": "Select and copy",
|
||||||
|
"panel.obsHint": "Paste this URL into a Browser source in OBS. Transparent background, updates on its own as long as this console window stays open.",
|
||||||
|
"panel.build": "Build",
|
||||||
|
"status.connecting": "Connecting…",
|
||||||
|
"status.waitingGame": "Waiting for you to open Elden Ring…",
|
||||||
|
"status.menu": "Elden Ring open — main menu or loading screen",
|
||||||
|
"status.live": "Live — reading Elden Ring",
|
||||||
|
"status.noServer": "No connection to the local program",
|
||||||
|
"peer.playing": "playing",
|
||||||
|
"peer.menu": "in the menu",
|
||||||
|
"peer.offline": "no connection"
|
||||||
|
};
|
||||||
|
var STR = {};
|
||||||
|
function t(k){ return STR[k] || FALLBACK[k] || k; }
|
||||||
|
|
||||||
|
function applyStrings(){
|
||||||
|
var nodes = document.querySelectorAll('[data-i18n]');
|
||||||
|
for (var i = 0; i < nodes.length; i++){
|
||||||
|
nodes[i].textContent = t(nodes[i].getAttribute('data-i18n'));
|
||||||
|
}
|
||||||
|
document.documentElement.lang = STR['_lang'] || 'en';
|
||||||
|
}
|
||||||
|
document.getElementById(mode === 'overlay' ? 'overlay' : 'control').hidden = false;
|
||||||
|
|
||||||
|
function fmtElapsed(ms){
|
||||||
|
if (ms == null) return '—';
|
||||||
|
var s = Math.floor(ms/1000);
|
||||||
|
var h = Math.floor(s/3600), m = Math.floor((s%3600)/60), ss = s%60;
|
||||||
|
function pad(n){return (n<10?'0':'')+n;}
|
||||||
|
return h>0 ? (h+':'+pad(m)+':'+pad(ss)) : (pad(m)+':'+pad(ss));
|
||||||
|
}
|
||||||
|
|
||||||
|
var prevTotal = null;
|
||||||
|
function pulse(el){ el.classList.add('pulse'); setTimeout(function(){el.classList.remove('pulse');},260); }
|
||||||
|
|
||||||
|
if (mode === 'control'){
|
||||||
|
document.getElementById('obs-url').value = location.origin + '/?view=overlay';
|
||||||
|
document.getElementById('copy-btn').addEventListener('click', function(){
|
||||||
|
var btn=this, url=document.getElementById('obs-url');
|
||||||
|
function done(ok){ btn.textContent = ok?t('panel.copied'):t('panel.copyManual'); setTimeout(function(){btn.textContent=t('panel.copy');},1400); }
|
||||||
|
if (navigator.clipboard && navigator.clipboard.writeText){
|
||||||
|
navigator.clipboard.writeText(url.value).then(function(){done(true);}, function(){url.select();done(false);});
|
||||||
|
} else { url.select(); done(false); }
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function setStatus(text, cls){
|
||||||
|
var el = document.getElementById('status');
|
||||||
|
if (!el) return;
|
||||||
|
document.getElementById('status-text').textContent = text;
|
||||||
|
el.className = 'status' + (cls ? ' ' + cls : '');
|
||||||
|
}
|
||||||
|
|
||||||
|
// Cache de las columnas: reconstruir el DOM en cada tick haria
|
||||||
|
// parpadear el overlay y perderia la animacion del pulso.
|
||||||
|
//
|
||||||
|
// Se indexan por POSICION, nunca por nombre. Indexarlas por nombre fue
|
||||||
|
// un bug real: al cambiar de personaje cambiaba la clave, se creaba una
|
||||||
|
// columna nueva y la vieja quedaba colgada en el DOM, asi que un mismo
|
||||||
|
// jugador aparecia dos veces. El nombre es contenido, no identidad.
|
||||||
|
var slots = [];
|
||||||
|
var prevByName = {};
|
||||||
|
|
||||||
|
// ensureSlots deja exactamente n columnas, creando o sacando las que
|
||||||
|
// hagan falta (con su divisor).
|
||||||
|
function ensureSlots(list, n){
|
||||||
|
while (slots.length > n){
|
||||||
|
var old = slots.pop();
|
||||||
|
if (old.div) list.removeChild(old.div);
|
||||||
|
list.removeChild(old.col);
|
||||||
|
}
|
||||||
|
while (slots.length < n){
|
||||||
|
var i = slots.length;
|
||||||
|
var div = null;
|
||||||
|
if (i > 0){
|
||||||
|
div = document.createElement('div');
|
||||||
|
div.className = 'pdiv';
|
||||||
|
list.appendChild(div);
|
||||||
|
}
|
||||||
|
var col = document.createElement('div'); col.className = 'pcol';
|
||||||
|
var nm = document.createElement('div'); nm.className = 'pname';
|
||||||
|
var vl = document.createElement('span'); vl.className = 'pnum';
|
||||||
|
var nt = document.createElement('div'); nt.className = 'pnote';
|
||||||
|
col.appendChild(nm); col.appendChild(vl); col.appendChild(nt);
|
||||||
|
list.appendChild(col);
|
||||||
|
slots.push({col:col, div:div, name:nm, num:vl, note:nt});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function playersOf(d){
|
||||||
|
if (d.players && d.players.length) return d.players;
|
||||||
|
// Respuesta de la version de un solo jugador.
|
||||||
|
return [{name:'Deaths', deaths:d.deaths, bossFight:d.bossFight,
|
||||||
|
playerLoaded:d.playerLoaded, connected:d.connected, self:true}];
|
||||||
|
}
|
||||||
|
|
||||||
|
function renderOverlay(d){
|
||||||
|
var players = playersOf(d);
|
||||||
|
var list = document.getElementById('ov-players');
|
||||||
|
document.getElementById('ov-plate').className = 'plate' + (players.length < 2 ? ' solo' : '');
|
||||||
|
ensureSlots(list, players.length);
|
||||||
|
|
||||||
|
for (var i = 0; i < players.length; i++){
|
||||||
|
var p = players[i];
|
||||||
|
var slot = slots[i];
|
||||||
|
// Sin nombre de personaje todavía: etiqueta según el modo.
|
||||||
|
slot.name.textContent = p.name ||
|
||||||
|
(players.length < 2 ? t('overlay.deaths') : (p.self ? t('overlay.you') : t('overlay.partner')));
|
||||||
|
slot.num.textContent = p.connected ? p.deaths : '–';
|
||||||
|
slot.col.className = 'pcol' + (p.connected ? '' : ' off');
|
||||||
|
|
||||||
|
slot.note.textContent = '';
|
||||||
|
if (!p.connected){
|
||||||
|
slot.note.textContent = p.self ? t('overlay.waiting') : t('overlay.offline');
|
||||||
|
} else {
|
||||||
|
slot.note.appendChild(document.createTextNode(t('overlay.deaths')));
|
||||||
|
if (p.bossFight){
|
||||||
|
var sep = document.createElement('span');
|
||||||
|
sep.className = 'sep'; sep.textContent = '·';
|
||||||
|
var st = document.createElement('span');
|
||||||
|
st.className = 'st'; st.textContent = '⚔ ' + t('overlay.boss');
|
||||||
|
slot.note.appendChild(sep); slot.note.appendChild(st);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var prev = prevByName[p.name];
|
||||||
|
if (p.connected && prev !== undefined && p.deaths > prev) pulse(slot.num);
|
||||||
|
prevByName[p.name] = p.connected ? p.deaths : undefined;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function render(d){
|
||||||
|
var total = d.deaths;
|
||||||
|
var display = d.connected ? total : '–';
|
||||||
|
if (mode === 'overlay'){
|
||||||
|
renderOverlay(d);
|
||||||
|
} else {
|
||||||
|
var cTotal = document.getElementById('c-total');
|
||||||
|
cTotal.textContent = display;
|
||||||
|
document.getElementById('c-raw').textContent = d.connected ? d.rawDeaths : '–';
|
||||||
|
document.getElementById('c-slot').textContent = (d.slot === undefined || d.slot < 0) ? '–' : d.slot;
|
||||||
|
document.getElementById('c-boss').classList.toggle('on', !!d.bossFight);
|
||||||
|
document.getElementById('c-build').textContent = d.build ? (t('panel.build') + ': ' + d.build) : '';
|
||||||
|
if (d.connected && prevTotal !== null && total > prevTotal) pulse(cTotal);
|
||||||
|
if (!d.connected) setStatus(t('status.waitingGame'), '');
|
||||||
|
else if (d.playerLoaded === false) setStatus(t('status.menu'), '');
|
||||||
|
else setStatus(t('status.live'), 'live');
|
||||||
|
|
||||||
|
var peers = (d.players || []).filter(function(p){ return !p.self; });
|
||||||
|
document.getElementById('c-peers-box').hidden = peers.length === 0;
|
||||||
|
var box = document.getElementById('c-peers');
|
||||||
|
box.textContent = '';
|
||||||
|
peers.forEach(function(p){
|
||||||
|
var row = document.createElement('div');
|
||||||
|
row.className = 'peer-row' + (p.connected ? '' : ' off');
|
||||||
|
var n = document.createElement('span'); n.className = 'pn'; n.textContent = p.name;
|
||||||
|
var s = document.createElement('span'); s.className = 'ps';
|
||||||
|
s.textContent = p.connected ? (p.playerLoaded ? t('peer.playing') : t('peer.menu')) : t('peer.offline');
|
||||||
|
var v = document.createElement('span'); v.className = 'pv';
|
||||||
|
v.textContent = p.connected ? p.deaths : '–';
|
||||||
|
var left = document.createElement('span');
|
||||||
|
left.appendChild(n); left.appendChild(document.createTextNode(' ')); left.appendChild(s);
|
||||||
|
row.appendChild(left); row.appendChild(v);
|
||||||
|
box.appendChild(row);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
prevTotal = d.connected ? total : null;
|
||||||
|
}
|
||||||
|
|
||||||
|
function poll(){
|
||||||
|
fetch('/deaths', {cache:'no-store'}).then(function(r){ return r.json(); }).then(function(d){
|
||||||
|
render(d);
|
||||||
|
}).catch(function(){
|
||||||
|
setStatus(t('status.noServer'), 'err');
|
||||||
|
}).finally(function(){
|
||||||
|
setTimeout(poll, 1000);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
// ?lang= en la URL pisa el idioma del config, comodo para tener el
|
||||||
|
// overlay en un idioma y el panel en otro sin tocar archivos.
|
||||||
|
var langParam = new URLSearchParams(location.search).get('lang');
|
||||||
|
fetch('/strings.json' + (langParam ? '?lang=' + encodeURIComponent(langParam) : ''), {cache:'no-store'})
|
||||||
|
.then(function(r){ return r.json(); })
|
||||||
|
.then(function(d){ if (d && typeof d === 'object') STR = d; })
|
||||||
|
.catch(function(){ /* nos quedamos con FALLBACK */ })
|
||||||
|
.finally(function(){ applyStrings(); poll(); });
|
||||||
|
})();
|
||||||
|
</script>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
@@ -0,0 +1,142 @@
|
|||||||
|
// totals.go: los totales, uno por personaje.
|
||||||
|
//
|
||||||
|
// El juego ya lleva la cuenta de muertes de cada personaje por separado
|
||||||
|
// (esta en la partida, no en la PC), asi que el programa hace lo mismo:
|
||||||
|
// para cada personaje guarda un "base", y el numero que se muestra es
|
||||||
|
// siempre total = muertes que lee del juego + base.
|
||||||
|
//
|
||||||
|
// El numero que se muestra es, sin intermediarios, el que lleva el juego
|
||||||
|
// para ese personaje. Lo que se guarda en disco NO es un ajuste: es solo
|
||||||
|
// lo ultimo que se vio, para poder mostrar algo cuando abris el contador
|
||||||
|
// antes que el juego y todavia no hay nada que leer.
|
||||||
|
//
|
||||||
|
// Hubo dos modelos anteriores. Primero un unico total de por vida que
|
||||||
|
// nunca bajaba, que con varios personajes dejaba el numero quieto hasta
|
||||||
|
// la siguiente muerte. Despues un "base" por personaje que se sumaba a
|
||||||
|
// la lectura, heredado de cuando no confiabamos en lo que leiamos: una
|
||||||
|
// vez que el total sale del juego en cada lectura, corregir a mano dejo
|
||||||
|
// de arreglar nada y solo servia para que el numero mintiera en silencio.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"log"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"sync"
|
||||||
|
)
|
||||||
|
|
||||||
|
type charTotal struct {
|
||||||
|
Name string `json:"name"`
|
||||||
|
Total int64 `json:"total"` // ultimo total visto: para mostrar algo antes de leer el juego
|
||||||
|
}
|
||||||
|
|
||||||
|
type totalsFile struct {
|
||||||
|
LastCharacter string `json:"lastCharacter"`
|
||||||
|
Characters map[string]*charTotal `json:"characters"`
|
||||||
|
}
|
||||||
|
|
||||||
|
type totalsStore struct {
|
||||||
|
mu sync.Mutex
|
||||||
|
path string
|
||||||
|
data totalsFile
|
||||||
|
}
|
||||||
|
|
||||||
|
// testExeDir permite a los tests apuntar a un directorio temporal.
|
||||||
|
var testExeDir string
|
||||||
|
|
||||||
|
func exeDir() (string, bool) {
|
||||||
|
if testExeDir != "" {
|
||||||
|
return testExeDir, true
|
||||||
|
}
|
||||||
|
if exe, err := os.Executable(); err == nil {
|
||||||
|
return filepath.Dir(exe), true
|
||||||
|
}
|
||||||
|
return "", false
|
||||||
|
}
|
||||||
|
|
||||||
|
func totalsPath() string {
|
||||||
|
if dir, ok := exeDir(); ok {
|
||||||
|
return filepath.Join(dir, "totals.json")
|
||||||
|
}
|
||||||
|
return "totals.json"
|
||||||
|
}
|
||||||
|
|
||||||
|
func newTotalsStore() *totalsStore {
|
||||||
|
s := &totalsStore{path: totalsPath()}
|
||||||
|
s.data.Characters = map[string]*charTotal{}
|
||||||
|
|
||||||
|
data, err := os.ReadFile(s.path)
|
||||||
|
if err == nil {
|
||||||
|
if err := json.Unmarshal(data, &s.data); err != nil {
|
||||||
|
log.Printf("totals.json ilegible (%v): arranco de cero, no lo piso hasta la proxima escritura", err)
|
||||||
|
s.data = totalsFile{Characters: map[string]*charTotal{}}
|
||||||
|
}
|
||||||
|
if s.data.Characters == nil {
|
||||||
|
s.data.Characters = map[string]*charTotal{}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return s
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *totalsStore) get(key string) (*charTotal, bool) {
|
||||||
|
s.mu.Lock()
|
||||||
|
defer s.mu.Unlock()
|
||||||
|
c, ok := s.data.Characters[key]
|
||||||
|
if !ok {
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
cp := *c
|
||||||
|
return &cp, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// lastKnownTotal: que mostrar mientras el juego no este abierto.
|
||||||
|
func (s *totalsStore) lastKnownTotal() (key, name string, total int64) {
|
||||||
|
s.mu.Lock()
|
||||||
|
defer s.mu.Unlock()
|
||||||
|
if c, ok := s.data.Characters[s.data.LastCharacter]; ok {
|
||||||
|
return s.data.LastCharacter, c.Name, c.Total
|
||||||
|
}
|
||||||
|
return "", "", 0
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *totalsStore) save(key string, c charTotal) {
|
||||||
|
s.mu.Lock()
|
||||||
|
s.data.Characters[key] = &c
|
||||||
|
s.data.LastCharacter = key
|
||||||
|
blob, err := json.MarshalIndent(s.data, "", " ")
|
||||||
|
s.mu.Unlock()
|
||||||
|
if err != nil {
|
||||||
|
log.Printf("no pude serializar totals.json: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
// Escritura atomica: si se corta la luz a mitad, el archivo viejo
|
||||||
|
// queda entero en vez de quedar un JSON cortado por la mitad.
|
||||||
|
tmp := s.path + ".tmp"
|
||||||
|
if err := os.WriteFile(tmp, blob, 0644); err != nil {
|
||||||
|
log.Printf("no pude escribir totals.json: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if err := os.Rename(tmp, s.path); err != nil {
|
||||||
|
log.Printf("no pude reemplazar totals.json: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// characterKey: la identidad de un personaje.
|
||||||
|
//
|
||||||
|
// El slot de guardado (GameMan+0xAC0) es la identidad buena: no cambia
|
||||||
|
// nunca y dos personajes que se llamen igual siguen siendo distintos. El
|
||||||
|
// nombre queda solo como respaldo para cuando no podemos leer el slot,
|
||||||
|
// con la limitacion conocida de que ahi si dos homonimos comparten
|
||||||
|
// contador.
|
||||||
|
func characterKey(slot int, name string) string {
|
||||||
|
if slot >= 0 {
|
||||||
|
return "slot" + strconv.Itoa(slot)
|
||||||
|
}
|
||||||
|
if n := strings.ToLower(strings.TrimSpace(name)); n != "" {
|
||||||
|
return "name:" + n
|
||||||
|
}
|
||||||
|
return ""
|
||||||
|
}
|
||||||
@@ -0,0 +1,279 @@
|
|||||||
|
// ws.go: implementacion minima de WebSocket (RFC 6455) con la libreria
|
||||||
|
// estandar, servidor y cliente. No usamos gorilla/websocket para que el
|
||||||
|
// programa siga siendo un unico .exe sin dependencias que haya que
|
||||||
|
// repartir ni vendorear.
|
||||||
|
//
|
||||||
|
// Alcance a proposito acotado a lo que necesitamos: mensajes de texto
|
||||||
|
// chicos, sin fragmentacion, sin compresion, sin TLS (va por Tailscale,
|
||||||
|
// que ya cifra el tramo entre las dos PCs).
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bufio"
|
||||||
|
"crypto/rand"
|
||||||
|
"crypto/sha1"
|
||||||
|
"encoding/base64"
|
||||||
|
"encoding/binary"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"net"
|
||||||
|
"net/http"
|
||||||
|
"strings"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
wsGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
|
||||||
|
|
||||||
|
opContinuation = 0x0
|
||||||
|
opText = 0x1
|
||||||
|
opBinary = 0x2
|
||||||
|
opClose = 0x8
|
||||||
|
opPing = 0x9
|
||||||
|
opPong = 0xA
|
||||||
|
|
||||||
|
maxFrameSize = 1 << 20 // 1 MiB: nuestros mensajes son de ~100 bytes
|
||||||
|
)
|
||||||
|
|
||||||
|
type wsConn struct {
|
||||||
|
conn net.Conn
|
||||||
|
br *bufio.Reader
|
||||||
|
isClient bool // solo el cliente enmascara, segun el RFC
|
||||||
|
wmu sync.Mutex
|
||||||
|
closed bool
|
||||||
|
}
|
||||||
|
|
||||||
|
func wsAcceptKey(key string) string {
|
||||||
|
h := sha1.New()
|
||||||
|
io.WriteString(h, key+wsGUID)
|
||||||
|
return base64.StdEncoding.EncodeToString(h.Sum(nil))
|
||||||
|
}
|
||||||
|
|
||||||
|
// wsUpgrade convierte una peticion HTTP entrante en una conexion
|
||||||
|
// WebSocket (lado servidor).
|
||||||
|
func wsUpgrade(w http.ResponseWriter, r *http.Request) (*wsConn, error) {
|
||||||
|
if !strings.Contains(strings.ToLower(r.Header.Get("Connection")), "upgrade") ||
|
||||||
|
!strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
|
||||||
|
return nil, fmt.Errorf("no es un upgrade a websocket")
|
||||||
|
}
|
||||||
|
key := r.Header.Get("Sec-WebSocket-Key")
|
||||||
|
if key == "" {
|
||||||
|
return nil, fmt.Errorf("falta la cabecera Sec-WebSocket-Key")
|
||||||
|
}
|
||||||
|
hj, ok := w.(http.Hijacker)
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("este servidor no soporta hijack")
|
||||||
|
}
|
||||||
|
conn, brw, err := hj.Hijack()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
resp := "HTTP/1.1 101 Switching Protocols\r\n" +
|
||||||
|
"Upgrade: websocket\r\n" +
|
||||||
|
"Connection: Upgrade\r\n" +
|
||||||
|
"Sec-WebSocket-Accept: " + wsAcceptKey(key) + "\r\n\r\n"
|
||||||
|
if _, err := conn.Write([]byte(resp)); err != nil {
|
||||||
|
conn.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return &wsConn{conn: conn, br: brw.Reader}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// wsDial abre una conexion WebSocket contra un hub (lado cliente).
|
||||||
|
func wsDial(addr, path string, timeout time.Duration) (*wsConn, error) {
|
||||||
|
conn, err := net.DialTimeout("tcp", addr, timeout)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
var keyBytes [16]byte
|
||||||
|
if _, err := rand.Read(keyBytes[:]); err != nil {
|
||||||
|
conn.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
key := base64.StdEncoding.EncodeToString(keyBytes[:])
|
||||||
|
|
||||||
|
req := "GET " + path + " HTTP/1.1\r\n" +
|
||||||
|
"Host: " + addr + "\r\n" +
|
||||||
|
"Upgrade: websocket\r\n" +
|
||||||
|
"Connection: Upgrade\r\n" +
|
||||||
|
"Sec-WebSocket-Key: " + key + "\r\n" +
|
||||||
|
"Sec-WebSocket-Version: 13\r\n\r\n"
|
||||||
|
|
||||||
|
conn.SetDeadline(time.Now().Add(timeout))
|
||||||
|
if _, err := conn.Write([]byte(req)); err != nil {
|
||||||
|
conn.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
br := bufio.NewReader(conn)
|
||||||
|
resp, err := http.ReadResponse(br, nil)
|
||||||
|
if err != nil {
|
||||||
|
conn.Close()
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
resp.Body.Close()
|
||||||
|
if resp.StatusCode != http.StatusSwitchingProtocols {
|
||||||
|
conn.Close()
|
||||||
|
return nil, fmt.Errorf("el hub respondio %s (esperaba 101)", resp.Status)
|
||||||
|
}
|
||||||
|
if !strings.EqualFold(resp.Header.Get("Sec-WebSocket-Accept"), wsAcceptKey(key)) {
|
||||||
|
conn.Close()
|
||||||
|
return nil, fmt.Errorf("el handshake no valida (¿del otro lado hay un websocket?)")
|
||||||
|
}
|
||||||
|
conn.SetDeadline(time.Time{})
|
||||||
|
return &wsConn{conn: conn, br: br, isClient: true}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *wsConn) writeFrame(opcode byte, payload []byte) error {
|
||||||
|
hdr := make([]byte, 0, 14)
|
||||||
|
hdr = append(hdr, 0x80|opcode) // FIN + opcode
|
||||||
|
|
||||||
|
maskBit := byte(0)
|
||||||
|
if c.isClient {
|
||||||
|
maskBit = 0x80
|
||||||
|
}
|
||||||
|
n := len(payload)
|
||||||
|
switch {
|
||||||
|
case n <= 125:
|
||||||
|
hdr = append(hdr, maskBit|byte(n))
|
||||||
|
case n <= 65535:
|
||||||
|
var ext [2]byte
|
||||||
|
binary.BigEndian.PutUint16(ext[:], uint16(n))
|
||||||
|
hdr = append(hdr, maskBit|126)
|
||||||
|
hdr = append(hdr, ext[:]...)
|
||||||
|
default:
|
||||||
|
var ext [8]byte
|
||||||
|
binary.BigEndian.PutUint64(ext[:], uint64(n))
|
||||||
|
hdr = append(hdr, maskBit|127)
|
||||||
|
hdr = append(hdr, ext[:]...)
|
||||||
|
}
|
||||||
|
|
||||||
|
body := payload
|
||||||
|
if c.isClient {
|
||||||
|
var mask [4]byte
|
||||||
|
if _, err := rand.Read(mask[:]); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
hdr = append(hdr, mask[:]...)
|
||||||
|
body = make([]byte, n)
|
||||||
|
for i := 0; i < n; i++ {
|
||||||
|
body[i] = payload[i] ^ mask[i%4]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
c.wmu.Lock()
|
||||||
|
defer c.wmu.Unlock()
|
||||||
|
if c.closed {
|
||||||
|
return io.ErrClosedPipe
|
||||||
|
}
|
||||||
|
if _, err := c.conn.Write(hdr); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if n > 0 {
|
||||||
|
if _, err := c.conn.Write(body); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *wsConn) readFrame() (opcode byte, payload []byte, err error) {
|
||||||
|
var h [2]byte
|
||||||
|
if _, err = io.ReadFull(c.br, h[:]); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
fin := h[0]&0x80 != 0
|
||||||
|
opcode = h[0] & 0x0F
|
||||||
|
masked := h[1]&0x80 != 0
|
||||||
|
n := int(h[1] & 0x7F)
|
||||||
|
|
||||||
|
switch n {
|
||||||
|
case 126:
|
||||||
|
var ext [2]byte
|
||||||
|
if _, err = io.ReadFull(c.br, ext[:]); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
n = int(binary.BigEndian.Uint16(ext[:]))
|
||||||
|
case 127:
|
||||||
|
var ext [8]byte
|
||||||
|
if _, err = io.ReadFull(c.br, ext[:]); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
v := binary.BigEndian.Uint64(ext[:])
|
||||||
|
if v > maxFrameSize {
|
||||||
|
err = fmt.Errorf("frame demasiado grande (%d bytes)", v)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
n = int(v)
|
||||||
|
}
|
||||||
|
if n > maxFrameSize {
|
||||||
|
err = fmt.Errorf("frame demasiado grande (%d bytes)", n)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
var mask [4]byte
|
||||||
|
if masked {
|
||||||
|
if _, err = io.ReadFull(c.br, mask[:]); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
payload = make([]byte, n)
|
||||||
|
if n > 0 {
|
||||||
|
if _, err = io.ReadFull(c.br, payload); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if masked {
|
||||||
|
for i := range payload {
|
||||||
|
payload[i] ^= mask[i%4]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !fin || opcode == opContinuation {
|
||||||
|
err = fmt.Errorf("frames fragmentados no soportados")
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// ReadMessage devuelve el proximo mensaje de texto/binario, respondiendo
|
||||||
|
// los pings por dentro. Un close del otro lado se reporta como io.EOF.
|
||||||
|
func (c *wsConn) ReadMessage() ([]byte, error) {
|
||||||
|
for {
|
||||||
|
op, payload, err := c.readFrame()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
switch op {
|
||||||
|
case opText, opBinary:
|
||||||
|
return payload, nil
|
||||||
|
case opPing:
|
||||||
|
if err := c.writeFrame(opPong, payload); err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
case opPong:
|
||||||
|
// nada que hacer
|
||||||
|
case opClose:
|
||||||
|
c.writeFrame(opClose, nil)
|
||||||
|
return nil, io.EOF
|
||||||
|
default:
|
||||||
|
return nil, fmt.Errorf("opcode desconocido: 0x%X", op)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *wsConn) WriteText(b []byte) error { return c.writeFrame(opText, b) }
|
||||||
|
func (c *wsConn) Ping() error { return c.writeFrame(opPing, nil) }
|
||||||
|
|
||||||
|
func (c *wsConn) SetReadDeadline(t time.Time) error { return c.conn.SetReadDeadline(t) }
|
||||||
|
|
||||||
|
func (c *wsConn) RemoteAddr() string { return c.conn.RemoteAddr().String() }
|
||||||
|
|
||||||
|
func (c *wsConn) Close() error {
|
||||||
|
c.wmu.Lock()
|
||||||
|
if c.closed {
|
||||||
|
c.wmu.Unlock()
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
c.closed = true
|
||||||
|
c.wmu.Unlock()
|
||||||
|
return c.conn.Close()
|
||||||
|
}
|
||||||
Reference in new issue
Block a user