juegos

protocol.sh (3984B)

---

 #!/usr/bin/env bash
 # ============================================================================
 #  lib/protocol.sh  --  El "idioma" que hablan dos computadoras y como leerlo.
 # ============================================================================
 #
 # Cuando dos personas juegan en red, sus dos programas se mandan MENSAJES de
 # texto, uno por linea. Para entenderse, los dos tienen que usar el mismo
 # vocabulario. Eso es un "protocolo": una lista acordada de mensajes posibles.
 #
 # Estos son todos los mensajes que existen (cada uno ocupa una linea):
 #   HELLO <id>      saludo inicial / negociar quien juega cada color
 #   HELLO host <tc> del que hace de servidor al que se conecta: ademas lleva el
 #                   control de tiempo ("off" o "BASE:INC" en segundos, ej "300:5")
 #   HELLO join      del que se conecta al servidor, al conectarse
 #   HELLO rejoin    de quien vuelve, al reconectarse a una partida cortada
 #   COLOR <w|b>     el lider le dice al otro que color le toca jugar
 #   TIME <tc>       modo relay: las blancas avisan el control de tiempo elegido
 #   STATE <st>      el lider manda el estado COMPLETO de la partida (posicion,
 #                   relojes, etc.) para que el otro arranque igual o se reconecte
 #   MOVE <uci>      una jugada, ej "MOVE e2e4" o "MOVE e7e8q" (coronacion)
 #   RESIGN          quien lo manda, se rinde
 #   DRAW50          quien lo manda, reclama tablas por la regla de 50 movimientos
 #   DRAWOFFER       quien lo manda, ofrece tablas de comun acuerdo
 #   DRAWYES/DRAWNO  el otro acepta / rechaza la oferta de tablas
 #   TIMEOUT         a quien lo manda se le acabo el tiempo (pierde por tiempo)
 #   QUIT            quien lo manda salio prolijamente (no es rendicion)
 #
 # COMO VIAJAN LOS MENSAJES (un poco de tecnica):
 #   Usamos un "coprocess" de bash: un segundo programa (ncat) que corre EN
 #   PARALELO al nuestro y mantiene la conexion de red abierta. Bash nos da dos
 #   "file descriptors" (numeritos que identifican canales de comunicacion) para
 #   hablarle: NET_R para LEER lo que llega, NET_W para ESCRIBIR lo que mandamos.
 #   Si NET_W esta vacio, quiere decir que no estamos jugando en red.
 
 NET_R=""   # canal de lectura (por aca nos llega lo que manda el otro)
 NET_W=""   # canal de escritura (por aca le mandamos cosas al otro)
 
 # net_send: mandar un mensaje (una linea de texto) al otro jugador.
 net_send() {
     # Si no estamos en red (NET_W vacio), no hacemos nada y devolvemos exito.
     # Asi el mismo codigo del juego sirve para una partida local sin tocar nada.
     [[ -n "$NET_W" ]] || return 0
     # "printf '%s\n' "$1"" imprime el mensaje y un salto de linea; ">&$NET_W"
     # redirige esa salida hacia el canal de escritura (en vez de a la pantalla).
     printf '%s\n' "$1" >&"$NET_W"
 }
 
 # net_recv: esperar y leer UNA linea del otro jugador. Se queda "bloqueado"
 # (frenado) hasta que llegue algo. Devuelve 1 (error) si el otro corto (EOF).
 net_recv() {
     local line
     # "read -r -u "$NET_R" line" lee una linea desde el canal NET_R y la guarda en
     # "line". "IFS=" antes del read evita que se recorten espacios. Si el read
     # falla (no hay mas datos, el otro se desconecto), devolvemos 1.
     IFS= read -r -u "$NET_R" line || return 1
     printf '%s' "$line"
 }
 
 # net_recv_timeout: igual que net_recv, pero con un LIMITE DE TIEMPO en segundos
 # (1er argumento). Es util para no quedarnos esperando para siempre.
 # Importante: conserva el codigo de error del read para que quien llama pueda
 # distinguir DOS situaciones distintas:
 #   - se acabo el tiempo de espera  -> read devuelve un numero MAYOR a 128
 #   - el otro se desconecto (EOF)    -> read devuelve 1
 # (Esa diferencia es clave para el reloj y para detectar caidas de conexion.)
 net_recv_timeout() {
     local line rc
     IFS= read -r -t "$1" -u "$NET_R" line; rc=$?   # "$?" es el codigo del ultimo comando
     (( rc != 0 )) && return $rc                    # si fallo, devolvemos el MISMO codigo
     printf '%s' "$line"
 }