Unicode chess over Gemini

import socket
import ssl
import base64
import json
from urllib.parse import urlparse, parse_qs, urlencode, unquote

import chess
import chess.engine

HOST = "0.0.0.0"
PORT = 1965

# Requires stockfish download from https://stockfishchess.org/download/
ENGINE_PATH = "./stockfish"
VALID_ELOS = [1320, 1500, 1800, 2000]

HELP_BODY = b"""# Chess over Gemini (help page)

=> gemini:/// Back

## How does this work?

This Gemini capsule lets you play chess against Stockfish.

The current game state is stored in the URL using FEN notation. For move input, the state is encoded into the /move/ URL path so Gemini input does not erase it. As a result, the server is stateless.

## Quirks

1. Moves must be in SAN notation.
2. Minimum Elo is 1320 due to a Stockfish requirement.
3. Your client needs to support Gemini's 10 input, monospace font, and prevent caching.
"""

def fancy_row(r):
    translator = {"K": "♔", "Q": "♕", "R": "♖", "B": "♗", "N": "♘", "P": "♙", "k": "♚", "q": "♛", "r": "♜", "b": "♝", "n": "♞", "p": "♟", ".": ".",}
    return [translator[i] for i in r]

def generate_board_ascii(board, fancy):
    ascii_board = []
    ascii_board.append(f"   {' '.join([chr(i) for i in range(97, 105)])}")
    ascii_board.append(f"  ╔{'═' * 15}╗")

    for i, r in enumerate(board):
        row = " ".join(fancy_row(r) if fancy else r)
        ascii_board.append(f"{8 - i} ║{row}║")

    ascii_board.append(f"  ╚{'═' * 15}╝")
    return ascii_board

def plot(frame, x, y, content):
    updated_frame = frame

    for curr_y in range(y, y + len(content)):
        if curr_y < 0 or curr_y >= len(frame):
            continue

        left_part = frame[curr_y][:x]
        insert_part = content[curr_y - y]
        right_part = (
            frame[curr_y][x + len(insert_part):]
            if len(frame[curr_y]) > x + len(insert_part)
            else ""
        )

        updated_frame[curr_y] = left_part + insert_part + right_part

    return updated_frame


def game_body(board, engine_elo, fancy=False, w=60, h=20, message=None):
    frame = [" " * w for _ in range(h)]

    frame[0] = f"┌{'─' * (w - 2)}┐"
    frame[h - 1] = f"└{'─' * (w - 2)}┘"

    for y in range(1, h - 1):
        frame[y] = "│" + frame[y][1:-1] + "│"

    board_arr = board_to_arr(board)
    ascii_board = generate_board_ascii(board_arr, fancy)
    frame = plot(frame, 3, 2, ascii_board)

    frame = plot(frame, 6, 14, ["Options", "─"*7, "Fancy mode: " + ("YES" if fancy else "NO"), f"Engine Elo: {engine_elo}"])
    frame = plot(frame, 25, 4, ["Welcome to chess over Gemini"])
    frame = plot(frame, 25, 7, ["Latest moves", "─"*12])

    moves = get_san_moves(board)
    move_text = ", ".join(moves)

    if len(move_text) > 30:
        move_text = move_text[-30:]

    frame = plot(frame, 25, 9, [move_text])
    frame = plot(frame, 25, 16, ["Controls and information", "below this rectangle"])

    body = "\n".join(frame) + "\n"

    if message:
        body += f"\n{message}\n"

    if board.is_game_over():
        body += f"\nGame over: {board.result()}\n"

    body += f"\n=> {move_prompt_url(board, fancy, engine_elo)} Enter a move (SAN)"
    body += f"\n=> {game_url(board, not fancy, engine_elo)} {'Disable' if fancy else 'Enable'} fancy mode"

    body += "".join([f"\n=> {game_url(board, fancy, elo)} Set engine Elo to {elo}" for elo in VALID_ELOS])

    body += "\n=> gemini://localhost/ Reset game"
    #body += "\n=> gemini://localhost/help Help"

    body += "\n\nThis project was heavily inspired by existing chess over Gemini projects:\n\n=> gemini://jsreed5.org/log/2024/202406/20240604-announcement-upcoming-closure-of-chess-over-gemini.gmi jsreed5's (former) Chess over Gemini\n=> gemini://dev.spool-five.com/src/app/chess spool-five's Chess"

    return body


def parse_bool(value, default=False):
    if value is None:
        return default
    return value.lower() in ("1", "true", "yes", "on")


def encode_state(board, fancy, engine_elo):
    state = { "fen": board.fen(), "fancy": fancy, "elo": engine_elo }
    raw = json.dumps(state).encode("utf-8")
    return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")

def decode_state(token):
    try:
        padding = "=" * (-len(token) % 4)
        raw = base64.urlsafe_b64decode(token + padding)
        state = json.loads(raw.decode("utf-8"))

        board = chess.Board(state.get("fen"))
        fancy = bool(state.get("fancy", True))

        engine_elo = int(state.get("elo", 1320))
        if engine_elo not in VALID_ELOS:
            engine_elo = 1320

        return board, fancy, engine_elo

    except Exception:
        return chess.Board(), True, 1320

def parse_request(request_bytes):
    request_line = request_bytes.decode("utf-8", errors="replace").strip()
    parsed = urlparse(request_line)
    params = parse_qs(parsed.query)

    path = parsed.path or "/"

    fen = params.get("fen", [None])[0]
    fancy = parse_bool(params.get("fancy", [None])[0], default=True)

    try:
        engine_elo = int(params.get("elo", [1320])[0])
    except ValueError:
        engine_elo = 1320

    if engine_elo not in VALID_ELOS:
        engine_elo = 1320

    try:
        board = chess.Board(fen) if fen else chess.Board()
    except ValueError:
        board = chess.Board()

    move = params.get("move", [None])[0]

    return path, board, fancy, engine_elo, move, parsed


def game_url(board, fancy, engine_elo):
    params = { "fen": board.fen(), "fancy": "1" if fancy else "0", "elo": str(engine_elo) }
    return "gemini://localhost/?" + urlencode(params)


def move_prompt_url(board, fancy, engine_elo):
    token = encode_state(board, fancy, engine_elo)
    return f"gemini://localhost/move/{token}"

def board_to_arr(board):
    arr = []
    for rank in range(7, -1, -1):
        row = []
        for file in range(8):
            square = chess.square(file, rank)
            piece = board.piece_at(square)
            row.append(piece.symbol() if piece else ".")
        arr.append(row)
    return arr

def get_san_moves(board):
    temp = chess.Board()
    san_moves = []

    for move in board.move_stack:
        san_moves.append(temp.san(move))
        temp.push(move)

    return san_moves

def play_san(board, move_text):
    try:
        move = board.parse_san(move_text)
        board.push(move)
        return True
    except ValueError:
        return False

def bot_move(board, engine_elo):
    with chess.engine.SimpleEngine.popen_uci(ENGINE_PATH) as engine:
        engine.configure({ "UCI_LimitStrength": True, "UCI_Elo": engine_elo })
        result = engine.play( board, chess.engine.Limit(time=0.2))
    return result.move

context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain("cert.pem", "key.pem")

with socket.socket() as sock:
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind((HOST, PORT))
    sock.listen()

    print(f"Listening on {PORT}...")

    while True:
        conn, addr = sock.accept()
        with context.wrap_socket(conn, server_side=True) as tls:
            request = tls.recv(1024)
            path, board, fancy, engine_elo, move, parsed = parse_request(request)
            if path == "/help":
                response = b"20 text/gemini\r\n" + HELP_BODY + b"\r\n"
                tls.sendall(response)
                continue

            message = None
            if path.startswith("/move/"):
                token = path.removeprefix("/move/")
                board, fancy, engine_elo = decode_state(token)
                if not parsed.query:
                    response = "10 Enter your move in SAN notation. Example: e4\r\n"
                    tls.sendall(response.encode("utf-8"))
                    continue
                move = unquote(parsed.query)

            if move:
                if board.is_game_over():
                    message = "The game is already over. Reset to start a new game."
                elif not play_san(board, move):
                    message = f"Invalid move: {move}"
                else:
                    if not board.is_game_over():
                        engine_move = bot_move(board, engine_elo)
                        board.push(engine_move)

            body = game_body(board, engine_elo, fancy=fancy, message=message)

            response = f"20 text/gemini\r\n{body}\r\n"
            tls.sendall(response.encode("utf-8"))