main.py

from __future__ import annotations

import asyncio
import json
import math
import os
import re
import signal
import sys
import threading
import time
import traceback
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, List, Optional, Set, Tuple

try:
    from blessed import Terminal
except ModuleNotFoundError:
    if os.environ.get("TERMINALMC_LANG", "en").lower() == "it":
        print("ERRORE: dipendenza mancante: blessed")
        print("Installa le dipendenze con:")
        print("    python -m pip install -r requirements.txt")
        print("oppure:")
        print("    python -m pip install blessed")
        prompt = "Premi INVIO per chiudere..."
    else:
        print("ERROR: missing dependency: blessed")
        print("Install dependencies with:")
        print("    python -m pip install -r requirements.txt")
        print("or:")
        print("    python -m pip install blessed")
        prompt = "Press ENTER to close..."
    try:
        input(prompt)
    except EOFError:
        pass
    raise SystemExit(1)

try:
    from pynput import mouse as pynput_mouse
except Exception:
    pynput_mouse = None

Vec3 = Tuple[float, float, float]
IVec3 = Tuple[int, int, int]
RGB = Tuple[int, int, int]

SCRIPT_FILE = os.path.abspath(__file__)
SCRIPT_DIR = os.path.dirname(SCRIPT_FILE)
APP_DIR = os.path.dirname(SCRIPT_DIR) if os.path.basename(SCRIPT_DIR).lower() == "scripts" else SCRIPT_DIR
SCRIPTS_DIR = os.path.join(APP_DIR, "scripts")
DEPS_DIR = os.path.join(APP_DIR, "deps")
DOCS_DIR = os.path.join(APP_DIR, "docs")
LOG_DIR = os.path.join(APP_DIR, "log")
WORLDS_DIR = os.path.join(APP_DIR, "worlds")
VERSION_FILE = os.path.join(SCRIPTS_DIR, "version")
WORLD_FILE_CACHE: Dict[str, str] = {}
AUTHOR_NAME = "PiBOH"


def ensure_log_dir() -> None:
    os.makedirs(os.environ.get("TERMINALMC_LOG_DIR", LOG_DIR), exist_ok=True)


def current_log_stamp() -> str:
    stamp = os.environ.get("TERMINALMC_LOG_STAMP", "").strip()
    if stamp:
        return stamp
    return time.strftime("%Y%m%d_%H%M%S")


def log_dir() -> str:
    return os.environ.get("TERMINALMC_LOG_DIR", LOG_DIR)


class ActionLogger:
    def __init__(self) -> None:
        ensure_log_dir()
        configured = os.environ.get("TERMINALMC_ACTION_LOG", "").strip()
        self.path = configured if configured else os.path.join(log_dir(), f"actions_{current_log_stamp()}.log")

    def write(self, source: str, message: str) -> None:
        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
        try:
            with open(self.path, "a", encoding="utf-8") as action_file:
                action_file.write(f"[{timestamp}] [{source}] {message}\n")
        except OSError:
            pass


ACTION_LOGGER = ActionLogger()


def log_action(source: str, message: str) -> None:
    ACTION_LOGGER.write(source, message)


def read_game_version() -> str:
    try:
        with open(VERSION_FILE, "r", encoding="utf-8") as version_file:
            value = version_file.read().strip()
            return value if value else "0.1.6-alpha"
    except OSError:
        return "0.1.6-alpha"


GAME_VERSION = read_game_version()
PROJECT_LINKS = [
    "Author website: https://piboh.github.io/",
    "Repository locale: ./",
    "Terminale consigliato: https://alacritty.org",
    "Libreria blessed: https://pypi.org/project/blessed/",
]


class BlockKind(Enum):
    GRASS = "Erba"
    DIRT = "Terra"
    STONE = "Pietra"
    WOOD = "Legno"
    LEAVES = "Foglie"


@dataclass(frozen=True)
class Block:
    kind: BlockKind
    color: RGB


@dataclass(frozen=True)
class RayHit:
    position: IVec3
    previous_position: IVec3
    block: Block
    distance: float
    normal: IVec3


@dataclass
class Player:
    x: float
    y: float
    z: float
    yaw: float
    pitch: float
    velocity_y: float
    grounded: bool


@dataclass(frozen=True)
class Config:
    target_fps: int = 60
    world_radius: int = 52
    max_world_height: int = 28
    min_world_height: int = 2
    render_distance: float = 36.0
    interaction_distance: float = 6.0
    fov_degrees: float = 72.0
    turn_speed: float = 2.6
    pitch_speed: float = 2.1
    move_speed: float = 7.0
    jump_speed: float = 7.2
    gravity: float = 18.0
    # Il giocatore è alto esattamente 2 blocchi; l'occhio resta poco sotto la testa.
    eye_height: float = 1.62
    player_height: float = 2.0
    player_radius: float = 0.25
    input_hold_seconds: float = 0.115


class Palette:
    GRASS: RGB = (75, 185, 65)
    DIRT: RGB = (132, 88, 48)
    STONE: RGB = (130, 132, 136)
    WOOD: RGB = (88, 56, 28)
    LEAVES: RGB = (35, 120, 48)
    SKY_TOP: RGB = (78, 142, 220)
    SKY_BOTTOM: RGB = (170, 210, 255)
    VOID: RGB = (10, 12, 18)
    HUD: RGB = (235, 238, 245)
    HUD_ACCENT: RGB = (255, 220, 90)
    CROSSHAIR: RGB = (255, 255, 255)


BLOCKS: Dict[BlockKind, Block] = {
    BlockKind.GRASS: Block(BlockKind.GRASS, Palette.GRASS),
    BlockKind.DIRT: Block(BlockKind.DIRT, Palette.DIRT),
    BlockKind.STONE: Block(BlockKind.STONE, Palette.STONE),
    BlockKind.WOOD: Block(BlockKind.WOOD, Palette.WOOD),
    BlockKind.LEAVES: Block(BlockKind.LEAVES, Palette.LEAVES),
}

HOTBAR: List[BlockKind] = [
    BlockKind.GRASS,
    BlockKind.DIRT,
    BlockKind.STONE,
    BlockKind.WOOD,
    BlockKind.LEAVES,
]


LANGUAGE = "en"

L10N: Dict[str, Dict[str, str]] = {
    "en": {
        "new_world": "Create new world",
        "load_world": "Load world",
        "info_links": "Info, author and links",
        "language": "Language: English",
        "exit": "Exit",
        "menu_subtitle": "",
        "author": "Author",
        "menu_help": "Menu: Arrows/W/S select, ENTER/Space confirm, mouse click supported, ESC exits",
        "save_hint": "Select an option",
        "saves_log": "",
        "enter_world_name": "Enter world name",
        "confirm": "ENTER confirms | ESC cancels",
        "no_worlds": "No saved worlds found. Create a new world first.",
        "choose_world": "Choose a world to load",
        "back": "Back",
        "info_title": "TerminalMC - Info, author and links",
        "version": "Version",
        "progress_path": "Progress: automatically saved in ./worlds/<world_name>.json",
        "manual_save": "Manual in-game save: P or F5",
        "links": "Links",
        "saved_worlds": "Saved worlds",
        "none": "None",
        "press_key": "Press any key to return to the menu",
        "block": "Block",
        "controls": "WASD move | Arrows/mouse view | Space jump | E/LeftClick mine | Q/RightClick build | P/F5 save | O autosave | ESC pause",
        "grass": "Grass",
        "dirt": "Dirt",
        "stone": "Stone",
        "wood": "Wood",
        "leaves": "Leaves",
        "saved_in": "Progress saved in: ",
        "world": "World",
        "save": "Save",
        "saving": "Saving in progress...",
        "saved": "Saved",
        "world_border": "You reached the end of the world",
        "autosave_option": "Autosave interval",
        "autosave_disabled": "Autosave: disabled",
        "autosave_10": "Autosave: every 10 min",
        "autosave_20": "Autosave: every 20 min",
        "autosave_30": "Autosave: every 30 min",
        "autosave_done": "Autosave completed",
        "pause_title": "Paused",
        "continue_game": "Continue game",
        "save_and_exit": "Save and exit",
        "exit_game": "Exit without saving",
        "pause_help": "Arrows/W/S select | ENTER/Space confirm | ESC continue",
    },
    "it": {
        "new_world": "Crea nuovo mondo",
        "load_world": "Carica mondo",
        "info_links": "Info, autore e collegamenti",
        "language": "Lingua: Italiano",
        "exit": "Esci",
        "menu_subtitle": "",
        "author": "Autore",
        "menu_help": "Menu: Frecce/W/S selezione, INVIO/Spazio conferma, click mouse supportato, ESC esce",
        "save_hint": "Seleziona un'opzione",
        "saves_log": "",
        "enter_world_name": "Inserisci il nome del mondo",
        "confirm": "INVIO conferma | ESC annulla",
        "no_worlds": "Nessun mondo salvato trovato. Crea prima un nuovo mondo.",
        "choose_world": "Scegli un mondo da caricare",
        "back": "Indietro",
        "info_title": "TerminalMC - Info, autore e collegamenti",
        "version": "Versione",
        "progress_path": "Progressi: salvati automaticamente in ./worlds/<nome_mondo>.json",
        "manual_save": "Salvataggio manuale in gioco: P oppure F5",
        "links": "Collegamenti",
        "saved_worlds": "Mondi salvati",
        "none": "Nessuno",
        "press_key": "Premi un tasto per tornare al menu",
        "block": "Blocco",
        "controls": "WASD movimento | Frecce/mouse visuale | Spazio salto | E/ClickSx mina | Q/ClickDx piazza | P/F5 salva | O autosave | ESC pausa",
        "grass": "Erba",
        "dirt": "Terra",
        "stone": "Pietra",
        "wood": "Legno",
        "leaves": "Foglie",
        "saved_in": "Progressi salvati in: ",
        "world": "Mondo",
        "save": "Salvataggio",
        "saving": "Salvataggio in corso...",
        "saved": "Salvato",
        "world_border": "Hai raggiunto la fine del mondo",
        "autosave_option": "Intervallo salvataggio automatico",
        "autosave_disabled": "Salvataggio automatico: disattivato",
        "autosave_10": "Salvataggio automatico: ogni 10 min",
        "autosave_20": "Salvataggio automatico: ogni 20 min",
        "autosave_30": "Salvataggio automatico: ogni 30 min",
        "autosave_done": "Salvataggio automatico completato",
        "pause_title": "Pausa",
        "continue_game": "Continua il gioco",
        "save_and_exit": "Salva ed esci",
        "exit_game": "Esci senza salvare",
        "pause_help": "Frecce/W/S selezione | INVIO/Spazio conferma | ESC continua",
    },
}

BLOCK_LABEL_KEYS: Dict[BlockKind, str] = {
    BlockKind.GRASS: "grass",
    BlockKind.DIRT: "dirt",
    BlockKind.STONE: "stone",
    BlockKind.WOOD: "wood",
    BlockKind.LEAVES: "leaves",
}


def tr(key: str) -> str:
    return L10N.get(LANGUAGE, L10N["en"]).get(key, key)


def block_label(kind: BlockKind) -> str:
    return tr(BLOCK_LABEL_KEYS[kind])


def autosave_label(minutes: Optional[int]) -> str:
    if minutes == 10:
        return tr("autosave_10")
    if minutes == 20:
        return tr("autosave_20")
    if minutes == 30:
        return tr("autosave_30")
    return tr("autosave_disabled")


def clamp(value: float, low: float, high: float) -> float:
    return max(low, min(high, value))


def lerp(a: int, b: int, t: float) -> int:
    return int(a + (b - a) * t)


def rgb_lerp(a: RGB, b: RGB, t: float) -> RGB:
    t = clamp(t, 0.0, 1.0)
    return (lerp(a[0], b[0], t), lerp(a[1], b[1], t), lerp(a[2], b[2], t))


def shade_color(color: RGB, factor: float) -> RGB:
    factor = clamp(factor, 0.0, 1.4)
    return (
        int(clamp(color[0] * factor, 0, 255)),
        int(clamp(color[1] * factor, 0, 255)),
        int(clamp(color[2] * factor, 0, 255)),
    )


def fg_rgb(color: RGB) -> str:
    return f"\x1b[38;2;{color[0]};{color[1]};{color[2]}m"


def bg_rgb(color: RGB) -> str:
    return f"\x1b[48;2;{color[0]};{color[1]};{color[2]}m"


def ansi_reset() -> str:
    return "\x1b[0m"


@dataclass(frozen=True)
class MouseEvent:
    button: int
    x: int
    y: int
    pressed: bool
    motion: bool


def parse_sgr_mouse(sequence: str) -> Optional[MouseEvent]:
    # Decodifica eventi mouse SGR: ESC [ < button ; x ; y M/m.
    match = re.search(r"\x1b\[<(\d+);(\d+);(\d+)([Mm])", sequence)
    if match is None:
        return None
    button = int(match.group(1))
    x = int(match.group(2))
    y = int(match.group(3))
    pressed = match.group(4) == "M"
    motion = (button & 32) == 32
    base_button = button & 3
    return MouseEvent(button=base_button, x=x, y=y, pressed=pressed, motion=motion)


def enable_mouse_reporting() -> str:
    # 1000: click, 1002: drag con pulsante premuto, 1006: coordinate SGR estese.
    # Nota: 1003 any-motion resta disabilitato perché su Windows/Alacritty può saturare la TUI.
    return "\x1b[?1000h\x1b[?1002h\x1b[?1006h"


def disable_mouse_reporting() -> str:
    return "\x1b[?1006l\x1b[?1002l\x1b[?1000l"


def collect_escape_sequence(term: Terminal, first_key: object, max_wait_seconds: float = 0.035) -> str:
    # Blessed può restituire ESC separato dal resto della sequenza mouse.
    # Senza questo accumulo, un click mouse può sembrare un ESC e chiudere il gioco/menu.
    sequence = str(first_key)
    if not sequence.startswith("\x1b"):
        return sequence

    deadline = time.perf_counter() + max_wait_seconds
    while time.perf_counter() < deadline:
        next_key = term.inkey(timeout=0.002)
        if not next_key:
            break
        sequence += str(next_key)

        # Mouse SGR completo: ESC [ < b ; x ; y M/m.
        if parse_sgr_mouse(sequence) is not None:
            break

        # Sequenza tastiera ANSI generica completa.
        if re.search(r"\x1b\[[0-9;?]*[A-Za-z~]$", sequence):
            break

    return sequence


class NativeMouseBridge:
    def __init__(self) -> None:
        self.available = pynput_mouse is not None
        self.listener: Any = None
        self.lock = threading.Lock()
        self.last_x: Optional[int] = None
        self.last_y: Optional[int] = None
        self.delta_x = 0.0
        self.delta_y = 0.0
        self.left_clicks = 0
        self.right_clicks = 0

    def start(self) -> None:
        # Fallback mouse nativo: utile su Windows/Alacritty quando ConPTY non inoltra mouse SGR.
        if not self.available or self.listener is not None:
            return
        try:
            self.listener = pynput_mouse.Listener(on_move=self.on_move, on_click=self.on_click)
            self.listener.start()
        except Exception:
            self.available = False
            self.listener = None

    def stop(self) -> None:
        if self.listener is not None:
            try:
                self.listener.stop()
            except Exception:
                pass
            self.listener = None

    def on_move(self, x: int, y: int) -> None:
        # Accumulo movimento nativo con clamp: evita flood ma rende il mouse utilizzabile.
        with self.lock:
            if self.last_x is not None and self.last_y is not None:
                self.delta_x = clamp(self.delta_x + float(x - self.last_x), -120.0, 120.0)
                self.delta_y = clamp(self.delta_y + float(y - self.last_y), -120.0, 120.0)
            self.last_x = x
            self.last_y = y

    def on_click(self, _x: int, _y: int, button: object, pressed: bool) -> None:
        if not pressed or pynput_mouse is None:
            return
        with self.lock:
            if button == pynput_mouse.Button.left:
                self.left_clicks += 1
            elif button == pynput_mouse.Button.right:
                self.right_clicks += 1

    def consume(self) -> Tuple[float, float, int, int]:
        with self.lock:
            dx = self.delta_x
            dy = self.delta_y
            left = self.left_clicks
            right = self.right_clicks
            self.delta_x = 0.0
            self.delta_y = 0.0
            self.left_clicks = 0
            self.right_clicks = 0
            return dx, dy, left, right


class VoxelWorld:
    def __init__(self, config: Config, generate: bool = True) -> None:
        self.config = config
        self.blocks: Dict[IVec3, Block] = {}
        if generate:
            self.generate()

    def generate(self) -> None:
        radius = self.config.world_radius
        for x in range(-radius, radius + 1):
            for z in range(-radius, radius + 1):
                height = self.terrain_height(x, z)
                for y in range(0, height + 1):
                    if y == height:
                        block = BLOCKS[BlockKind.GRASS]
                    elif y >= height - 3:
                        block = BLOCKS[BlockKind.DIRT]
                    else:
                        block = BLOCKS[BlockKind.STONE]
                    self.blocks[(x, y, z)] = block
                if self.should_place_tree(x, z, height):
                    self.place_tree(x, height + 1, z)

    def terrain_height(self, x: int, z: int) -> int:
        # Rumore procedurale deterministico tramite sinusoidi stratificate.
        n1 = math.sin(x * 0.135 + z * 0.071) * 3.2
        n2 = math.sin((x + z) * 0.055) * 4.0
        n3 = math.cos(math.sqrt(float(x * x + z * z)) * 0.155) * 2.3
        n4 = math.sin(x * 0.031) * math.cos(z * 0.047) * 5.2
        radial = -0.018 * math.sqrt(float(x * x + z * z))
        raw = 8.0 + n1 + n2 + n3 + n4 + radial
        return int(clamp(round(raw), self.config.min_world_height, self.config.max_world_height))

    def should_place_tree(self, x: int, z: int, height: int) -> bool:
        if abs(x) < 3 and abs(z) < 3 or height < 5:
            return False
        value = (x * 734287 + z * 912271 + x * z * 1013) & 0xFFFFFFFF
        return value % 97 == 0

    def place_tree(self, x: int, y: int, z: int) -> None:
        trunk_height = 4 + abs((x * 17 + z * 31) % 3)
        for dy in range(trunk_height):
            self.blocks[(x, y + dy, z)] = BLOCKS[BlockKind.WOOD]
        leaf_center_y = y + trunk_height
        for lx in range(-2, 3):
            for ly in range(-2, 3):
                for lz in range(-2, 3):
                    if abs(lx) + abs(ly) + abs(lz) <= 4 and not (lx == 0 and lz == 0 and ly < 0):
                        pos = (x + lx, leaf_center_y + ly, z + lz)
                        if pos not in self.blocks:
                            self.blocks[pos] = BLOCKS[BlockKind.LEAVES]

    def get_block(self, position: IVec3) -> Optional[Block]:
        return self.blocks.get(position)

    def set_block(self, position: IVec3, block_kind: BlockKind) -> None:
        self.blocks[position] = BLOCKS[block_kind]

    def remove_block(self, position: IVec3) -> None:
        self.blocks.pop(position, None)

    def is_solid(self, position: IVec3) -> bool:
        return position in self.blocks

    def highest_solid_y(self, x: int, z: int) -> Optional[int]:
        highest: Optional[int] = None
        for bx, by, bz in self.blocks.keys():
            if bx == x and bz == z and (highest is None or by > highest):
                highest = by
        return highest

    def to_save_data(self) -> List[List[Any]]:
        # Serializza i blocchi in una forma JSON semplice e portabile.
        return [[x, y, z, block.kind.name] for (x, y, z), block in self.blocks.items()]

    @classmethod
    def from_save_data(cls, config: Config, block_data: List[List[Any]]) -> "VoxelWorld":
        # Ricostruisce il mondo senza rigenerarlo proceduralmente.
        world = cls(config, generate=False)
        for item in block_data:
            if len(item) != 4:
                continue
            x = int(item[0])
            y = int(item[1])
            z = int(item[2])
            kind_name = str(item[3])
            if kind_name in BlockKind.__members__:
                world.blocks[(x, y, z)] = BLOCKS[BlockKind[kind_name]]
        return world


def ensure_worlds_dir() -> None:
    os.makedirs(WORLDS_DIR, exist_ok=True)


def candidate_world_dirs() -> List[str]:
    # Directory corrente ufficiale + vecchie posizioni usate durante le riorganizzazioni.
    dirs = [
        WORLDS_DIR,
        os.path.join(SCRIPTS_DIR, "worlds"),
        os.path.join(os.getcwd(), "worlds"),
    ]
    unique: List[str] = []
    for directory in dirs:
        normalized = os.path.abspath(directory)
        if normalized not in unique:
            unique.append(normalized)
    return unique


def sanitize_world_name(world_name: str) -> str:
    safe_name = "".join(ch if ch.isalnum() or ch in {"_", "-"} else "_" for ch in world_name).strip("_")
    return safe_name[:48]


def world_path(world_name: str) -> str:
    safe_name = sanitize_world_name(world_name)
    if not safe_name:
        safe_name = "world" if LANGUAGE == "en" else "mondo"
    ensure_worlds_dir()
    return os.path.join(WORLDS_DIR, f"{safe_name}.json")


def existing_world_path(world_name: str) -> Optional[str]:
    cached = WORLD_FILE_CACHE.get(world_name)
    if cached and os.path.exists(cached):
        return cached
    safe_name = sanitize_world_name(world_name)
    for directory in candidate_world_dirs():
        candidate = os.path.join(directory, f"{safe_name}.json")
        if os.path.exists(candidate):
            WORLD_FILE_CACHE[world_name] = candidate
            return candidate
    return None


def list_saved_worlds() -> List[str]:
    ensure_worlds_dir()
    WORLD_FILE_CACHE.clear()
    discovered: Dict[str, str] = {}
    for directory in candidate_world_dirs():
        if not os.path.isdir(directory):
            continue
        for filename in os.listdir(directory):
            if not filename.lower().endswith(".json"):
                continue
            full_path = os.path.join(directory, filename)
            if not os.path.isfile(full_path):
                continue
            name = filename[:-5]
            previous = discovered.get(name)
            if previous is None or os.path.getmtime(full_path) > os.path.getmtime(previous):
                discovered[name] = full_path
    for name, path in discovered.items():
        WORLD_FILE_CACHE[name] = path
    worlds = list(discovered.keys())
    worlds.sort(key=lambda name: os.path.getmtime(discovered[name]), reverse=True)
    log_action("worlds", f"list_saved_worlds found={len(worlds)} dirs={candidate_world_dirs()} names={worlds}")
    return worlds


def default_world_name() -> str:
    prefix = "world" if LANGUAGE == "en" else "mondo"
    return prefix + "_" + time.strftime("%Y%m%d_%H%M%S")


class InputState:
    def __init__(self, config: Config) -> None:
        self.config = config
        self.active_until: Dict[str, float] = {}
        self.just_pressed: Set[str] = set()

    def begin_frame(self) -> None:
        self.just_pressed.clear()

    def press(self, action: str, now: float) -> None:
        self.active_until[action] = now + self.config.input_hold_seconds
        self.just_pressed.add(action)

    def is_active(self, action: str, now: float) -> bool:
        return self.active_until.get(action, 0.0) >= now

    def consume_just_pressed(self, action: str) -> bool:
        return action in self.just_pressed


class Raycaster:
    def __init__(self, world: VoxelWorld, config: Config) -> None:
        self.world = world
        self.config = config

    def camera_forward(self, yaw: float, pitch: float) -> Vec3:
        cp = math.cos(pitch)
        return (math.sin(yaw) * cp, math.sin(pitch), math.cos(yaw) * cp)

    def normalize(self, vector: Vec3) -> Vec3:
        x, y, z = vector
        length = math.sqrt(x * x + y * y + z * z)
        if length <= 0.000001:
            return (0.0, 0.0, 1.0)
        return (x / length, y / length, z / length)

    def basis(self, yaw: float, pitch: float) -> Tuple[Vec3, Vec3, Vec3]:
        forward = self.camera_forward(yaw, pitch)
        right = (math.cos(yaw), 0.0, -math.sin(yaw))
        fx, fy, fz = forward
        rx, ry, rz = right

        # Vettore alto della camera.
        # Nota importante: usare forward x right, non right x forward.
        # Con yaw=0 e pitch=0 vogliamo up=(0, 1, 0); invertire l'ordine
        # produce up=(0, -1, 0) e rende il mondo visivamente sottosopra.
        up = (fy * rz - fz * ry, fz * rx - fx * rz, fx * ry - fy * rx)
        return self.normalize(forward), self.normalize(right), self.normalize(up)

    def screen_ray(self, player: Player, column: int, row: int, width: int, height: int) -> Vec3:
        forward, right, up = self.basis(player.yaw, player.pitch)
        fov = math.radians(self.config.fov_degrees)
        aspect = max(0.1, width / max(1.0, height * 2.0))
        sx = ((column + 0.5) / max(1, width) * 2.0 - 1.0) * math.tan(fov / 2.0) * aspect
        sy = (1.0 - (row + 0.5) / max(1, height) * 2.0) * math.tan(fov / 2.0)
        dx = forward[0] + right[0] * sx + up[0] * sy
        dy = forward[1] + right[1] * sx + up[1] * sy
        dz = forward[2] + right[2] * sx + up[2] * sy
        return self.normalize((dx, dy, dz))

    def cast(self, origin: Vec3, direction: Vec3, max_distance: float) -> Optional[RayHit]:
        ox, oy, oz = origin
        dx, dy, dz = direction
        x = math.floor(ox)
        y = math.floor(oy)
        z = math.floor(oz)
        step_x = 1 if dx > 0.0 else -1
        step_y = 1 if dy > 0.0 else -1
        step_z = 1 if dz > 0.0 else -1
        inv_dx = 1.0 / abs(dx) if abs(dx) > 0.000001 else float("inf")
        inv_dy = 1.0 / abs(dy) if abs(dy) > 0.000001 else float("inf")
        inv_dz = 1.0 / abs(dz) if abs(dz) > 0.000001 else float("inf")
        t_max_x = ((math.floor(ox) + 1.0 - ox) if dx > 0.0 else (ox - math.floor(ox))) * inv_dx
        t_max_y = ((math.floor(oy) + 1.0 - oy) if dy > 0.0 else (oy - math.floor(oy))) * inv_dy
        t_max_z = ((math.floor(oz) + 1.0 - oz) if dz > 0.0 else (oz - math.floor(oz))) * inv_dz
        t_delta_x = inv_dx
        t_delta_y = inv_dy
        t_delta_z = inv_dz
        distance = 0.0
        previous = (x, y, z)
        normal: IVec3 = (0, 0, 0)
        while distance <= max_distance:
            position = (x, y, z)
            block = self.world.get_block(position)
            if block is not None:
                real_distance = math.sqrt((x + 0.5 - ox) ** 2 + (y + 0.5 - oy) ** 2 + (z + 0.5 - oz) ** 2)
                return RayHit(position, previous, block, real_distance, normal)
            previous = position
            if t_max_x < t_max_y and t_max_x < t_max_z:
                x += step_x
                distance = t_max_x
                t_max_x += t_delta_x
                normal = (-step_x, 0, 0)
            elif t_max_y < t_max_z:
                y += step_y
                distance = t_max_y
                t_max_y += t_delta_y
                normal = (0, -step_y, 0)
            else:
                z += step_z
                distance = t_max_z
                t_max_z += t_delta_z
                normal = (0, 0, -step_z)
        return None


class Renderer:
    def __init__(self, term: Terminal, raycaster: Raycaster, config: Config) -> None:
        self.term = term
        self.raycaster = raycaster
        self.config = config

    def render(self, player: Player, selected: BlockKind, fps: float, status_message: str = "") -> str:
        width = max(20, int(self.term.width or 80))
        height = max(10, int(self.term.height or 24))
        pixel_count = width * height

        # Campionamento adattivo: quando lo zoom del terminale è molto basso la griglia diventa enorme.
        # Calcoliamo meno raggi e ripetiamo il carattere per mantenere il frame-rate più fluido.
        if pixel_count >= 14000:
            step_x = 3
        elif pixel_count >= 6500:
            step_x = 2
        else:
            step_x = 1

        lines: List[str] = []
        origin = (player.x, player.y, player.z)
        max_distance = self.config.render_distance * (0.85 if step_x > 1 else 1.0)

        for row in range(height):
            cells: List[str] = []
            column = 0
            while column < width:
                ray = self.raycaster.screen_ray(player, column, row, width, height)
                hit = self.raycaster.cast(origin, ray, max_distance)
                if hit is None:
                    color = self.sky_color(row, height, ray)
                    cell = f"{bg_rgb(color)} "
                else:
                    color = self.hit_color(hit)
                    cell = f"{fg_rgb(color)}{self.hit_glyph(hit)}"
                repeat = min(step_x, width - column)
                cells.append(cell * repeat)
                column += repeat
            lines.append("".join(cells) + ansi_reset())
        self.overlay_hud(lines, player, selected, fps, width, height, status_message)
        return "\x1b[H" + "\n".join(lines) + ansi_reset()

    def sky_color(self, row: int, height: int, ray: Vec3) -> RGB:
        t = row / max(1, height - 1)
        sky = rgb_lerp(Palette.SKY_TOP, Palette.SKY_BOTTOM, t)
        if ray[1] < -0.20:
            return rgb_lerp(sky, Palette.VOID, clamp((-ray[1] - 0.20) / 0.8, 0.0, 1.0))
        return sky

    def hit_color(self, hit: RayHit) -> RGB:
        fog = clamp(hit.distance / self.config.render_distance, 0.0, 1.0)
        distance_factor = 1.0 - fog * 0.72
        nx, ny, nz = hit.normal

        # Luce direzionale più ricca per una lettura 3D migliore nel terminale.
        sun = self.raycaster.normalize((-0.35, 0.85, -0.40))
        lambert = max(0.0, nx * sun[0] + ny * sun[1] + nz * sun[2])
        ambient = 0.52
        face_boost = 0.22 if ny > 0 else (-0.16 if ny < 0 else 0.0)
        light = ambient + lambert * 0.58 + face_boost

        color = shade_color(hit.block.color, distance_factor * light)
        return rgb_lerp(color, Palette.SKY_TOP, fog * 0.24)

    def hit_glyph(self, hit: RayHit) -> str:
        # Dithering ASCII/Unicode leggero: aumenta la percezione di dettaglio.
        fog = clamp(hit.distance / self.config.render_distance, 0.0, 1.0)
        if fog > 0.82:
            return "░"
        if fog > 0.62:
            return "▒"
        if fog > 0.38:
            return "▓"
        return "█"

    def overlay_hud(self, lines: List[str], player: Player, selected: BlockKind, fps: float, width: int, height: int, status_message: str = "") -> None:
        self.overlay_text(lines, 1, 0, f"TerminalMC FPS:{fps:5.1f} XYZ:{player.x:6.2f},{player.y:5.2f},{player.z:6.2f}", Palette.HUD)
        self.overlay_text(lines, 1, 1, f"{tr('block')}: {block_label(selected)} | [1]{tr('grass')} [2]{tr('dirt')} [3]{tr('stone')} [4]{tr('wood')} [5]{tr('leaves')}", Palette.HUD_ACCENT)
        self.overlay_text(lines, 1, 2, tr("controls"), Palette.HUD)
        if status_message:
            self.overlay_text(lines, 1, max(0, height - 2), status_message, Palette.HUD_ACCENT)
        self.overlay_text(lines, width // 2, height // 2, "+", Palette.CROSSHAIR)

    def overlay_text(self, lines: List[str], x: int, y: int, text: str, color: RGB) -> None:
        if y < 0 or y >= len(lines):
            return
        visible_width = len(strip_ansi(lines[y]))
        if x >= visible_width:
            return
        safe_text = text[: max(0, visible_width - x)]
        prefix = take_visible_prefix(lines[y], x)
        suffix = take_visible_suffix(lines[y], x + len(safe_text))
        lines[y] = f"{prefix}{fg_rgb(color)}{safe_text}{ansi_reset()}{suffix}"


def strip_ansi(text: str) -> str:
    result: List[str] = []
    i = 0
    while i < len(text):
        if text[i] == "\x1b":
            i += 1
            while i < len(text) and text[i] != "m":
                i += 1
            i += 1
        else:
            result.append(text[i])
            i += 1
    return "".join(result)


def take_visible_prefix(text: str, count: int) -> str:
    result: List[str] = []
    visible = 0
    i = 0
    while i < len(text) and visible < count:
        if text[i] == "\x1b":
            start = i
            i += 1
            while i < len(text) and text[i] != "m":
                i += 1
            if i < len(text):
                i += 1
            result.append(text[start:i])
        else:
            result.append(text[i])
            visible += 1
            i += 1
    return "".join(result)


def take_visible_suffix(text: str, start_visible: int) -> str:
    result: List[str] = []
    visible = 0
    i = 0
    copying = False
    while i < len(text):
        if text[i] == "\x1b":
            esc_start = i
            i += 1
            while i < len(text) and text[i] != "m":
                i += 1
            if i < len(text):
                i += 1
            if copying:
                result.append(text[esc_start:i])
        else:
            if visible >= start_visible:
                copying = True
                result.append(text[i])
            visible += 1
            i += 1
    return "".join(result)


class Game:
    def __init__(self, world_name: str, load_existing: bool, language: str, autosave_minutes: Optional[int]) -> None:
        global LANGUAGE
        LANGUAGE = language
        self.config = Config()
        self.term = Terminal()
        self.world_name = world_name
        self.save_path = existing_world_path(world_name) if load_existing else None
        if self.save_path is None:
            self.save_path = world_path(world_name)
        self.autosave_minutes = autosave_minutes
        self.last_autosave_time = time.perf_counter()
        self.status_flash_until = 0.0
        self.selected_index = 0

        loaded_player: Optional[Player] = None
        if load_existing and os.path.exists(self.save_path):
            loaded_player = self.load_game_state()
        else:
            self.world = VoxelWorld(self.config)

        self.raycaster = Raycaster(self.world, self.config)
        self.renderer = Renderer(self.term, self.raycaster, self.config)
        self.input_state = InputState(self.config)
        self.native_mouse = NativeMouseBridge()
        self.player = loaded_player if loaded_player is not None else self.create_player()
        self.running = True
        self.save_on_exit = True
        self.fps = 0.0
        self.frame_counter = 0
        self.fps_accumulator = 0.0
        self.last_mouse_x: Optional[int] = None
        self.last_mouse_y: Optional[int] = None
        self.world_border_last_warning = 0.0
        self.status_message = f"{tr('world')}: {self.world_name} | {autosave_label(self.autosave_minutes)}"
        log_action("game", f"game started world={self.world_name} autosave={self.autosave_minutes}")

    def create_player(self) -> Player:
        ground = self.world.highest_solid_y(0, 0)
        start_y = float((ground if ground is not None else 8) + 1) + self.config.eye_height
        return Player(0.5, start_y, 0.5, 0.0, 0.0, 0.0, True)

    def load_game_state(self) -> Optional[Player]:
        # Carica mondo, giocatore e hotbar da file JSON.
        with open(self.save_path, "r", encoding="utf-8") as save_file:
            data = json.load(save_file)

        block_data = data.get("blocks", [])
        if not isinstance(block_data, list):
            block_data = []
        self.world = VoxelWorld.from_save_data(self.config, block_data)

        selected = data.get("selected_index", 0)
        if isinstance(selected, int):
            self.selected_index = int(clamp(float(selected), 0.0, float(len(HOTBAR) - 1)))

        saved_autosave = data.get("autosave_minutes", self.autosave_minutes)
        if saved_autosave in (None, 10, 20, 30):
            self.autosave_minutes = saved_autosave
        elif isinstance(saved_autosave, int) and saved_autosave in {10, 20, 30}:
            self.autosave_minutes = saved_autosave
        log_action("game", f"loaded autosave setting: {self.autosave_minutes}")

        player_data = data.get("player", {})
        if not isinstance(player_data, dict):
            return None

        return Player(
            x=float(player_data.get("x", 0.5)),
            y=float(player_data.get("y", 12.0)),
            z=float(player_data.get("z", 0.5)),
            yaw=float(player_data.get("yaw", 0.0)),
            pitch=float(player_data.get("pitch", 0.0)),
            velocity_y=0.0,
            grounded=bool(player_data.get("grounded", True)),
        )

    def save_game_state(self) -> None:
        # Salva i progressi in ./worlds/<nome_mondo>.json.
        self.flash_status(tr("saving"), 1.0)
        log_action("game", "save started")
        ensure_worlds_dir()
        data: Dict[str, Any] = {
            "format_version": "1",
            "game_version": GAME_VERSION,
            "language": LANGUAGE,
            "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"),
            "world_name": self.world_name,
            "selected_index": self.selected_index,
            "autosave_minutes": self.autosave_minutes,
            "player": {
                "x": self.player.x,
                "y": self.player.y,
                "z": self.player.z,
                "yaw": self.player.yaw,
                "pitch": self.player.pitch,
                "grounded": self.player.grounded,
            },
            "blocks": self.world.to_save_data(),
        }
        tmp_path = self.save_path + ".tmp"
        with open(tmp_path, "w", encoding="utf-8") as save_file:
            json.dump(data, save_file, ensure_ascii=False, separators=(",", ":"))
        os.replace(tmp_path, self.save_path)
        self.flash_status(f"{tr('saved')}: {self.save_path}", 3.0)
        self.last_autosave_time = time.perf_counter()
        log_action("game", f"world saved: {self.save_path}")

    async def run(self) -> None:
        signal.signal(signal.SIGINT, self.handle_signal)
        frame_time = 1.0 / self.config.target_fps
        last_time = time.perf_counter()
        with self.term.fullscreen(), self.term.hidden_cursor(), self.term.cbreak():
            self.native_mouse.start()
            sys.stdout.write(enable_mouse_reporting() + "\x1b[2J\x1b[H")
            sys.stdout.flush()
            while self.running:
                frame_start = time.perf_counter()
                delta_time = clamp(frame_start - last_time, 0.0, 0.05)
                last_time = frame_start
                self.input_state.begin_frame()
                self.poll_input()
                self.update(delta_time)
                frame = self.renderer.render(self.player, HOTBAR[self.selected_index], self.fps, self.visible_status_message())
                sys.stdout.write(f"\x1b]0;TerminalMC · {self.fps:5.1f} FPS\x07" + frame)
                sys.stdout.flush()
                self.update_fps(delta_time)
                elapsed = time.perf_counter() - frame_start
                sleep_time = frame_time - elapsed
                await asyncio.sleep(sleep_time if sleep_time > 0.0 else 0.0)
            self.native_mouse.stop()
            if self.save_on_exit:
                self.save_game_state()
            sys.stdout.write("\x1b]0;TerminalMC\x07" + disable_mouse_reporting() + ansi_reset() + "\x1b[2J\x1b[H")
            sys.stdout.flush()

    def handle_signal(self, _signum: int, _frame: object) -> None:
        self.running = False

    def visible_status_message(self) -> str:
        if time.perf_counter() <= self.status_flash_until:
            return self.status_message
        return f"{tr('world')}: {self.world_name} | {autosave_label(self.autosave_minutes)}"

    def flash_status(self, message: str, seconds: float = 2.5) -> None:
        self.status_message = message
        self.status_flash_until = time.perf_counter() + seconds

    def poll_input(self) -> None:
        now = time.perf_counter()
        while True:
            key = self.term.inkey(timeout=0)
            if not key:
                break
            name = key.name or ""
            value = collect_escape_sequence(self.term, key)
            mouse_event = parse_sgr_mouse(value)
            if mouse_event is not None:
                self.handle_mouse_event(mouse_event)
                continue
            if name == "KEY_ESCAPE" and value != "\x1b":
                # Se Blessed ha classificato una sequenza estesa come ESC ma abbiamo letto altri byte,
                # non chiudiamo il gioco: lasciamo gestire sotto le sequenze riconosciute.
                pass
            if name == "KEY_ESCAPE" and value == "\x1b":
                log_action("game", "pause menu requested by ESC")
                self.pause_menu()
                return
            if value == "\x03":
                log_action("game", "exit requested by CTRL+C")
                self.running = False
                return
            lower = value.lower() if value else ""
            if lower == "w":
                self.input_state.press("forward", now)
            elif lower == "s":
                self.input_state.press("backward", now)
            elif lower == "a":
                self.input_state.press("left", now)
            elif lower == "d":
                self.input_state.press("right", now)
            elif lower == " ":
                self.input_state.press("jump", now)
            elif lower == "e":
                log_action("game", "keyboard mine requested: E")
                self.input_state.press("mine", now)
            elif lower == "q":
                log_action("game", "keyboard build requested: Q")
                self.input_state.press("build", now)
            elif lower == "p":
                log_action("game", "manual save requested: P")
                self.input_state.press("save", now)
            elif lower == "o":
                self.cycle_autosave_interval()
            elif lower in {"1", "2", "3", "4", "5"}:
                self.selected_index = int(lower) - 1
                log_action("game", f"hotbar selected: {lower} {block_label(HOTBAR[self.selected_index])}")
            if name == "KEY_F5":
                log_action("game", "manual save requested: F5")
                self.input_state.press("save", now)
            elif name == "KEY_LEFT" or value == "\x1b[D":
                self.input_state.press("turn_left", now)
            elif name == "KEY_RIGHT" or value == "\x1b[C":
                self.input_state.press("turn_right", now)
            elif name == "KEY_UP" or value == "\x1b[A":
                self.input_state.press("look_up", now)
            elif name == "KEY_DOWN" or value == "\x1b[B":
                self.input_state.press("look_down", now)

    def handle_mouse_event(self, event: MouseEvent) -> None:
        # Mouse in gioco: click sinistro mina, click destro piazza.
        # Il movimento libero viene ignorato per evitare flood di eventi e blocchi della TUI.
        if event.motion and event.button != 3 and self.last_mouse_x is not None and self.last_mouse_y is not None:
            dx = event.x - self.last_mouse_x
            dy = event.y - self.last_mouse_y
            self.player.yaw += dx * 0.010
            self.player.pitch -= dy * 0.007
            self.player.pitch = clamp(self.player.pitch, -1.25, 1.25)

        if event.pressed and not event.motion:
            if event.button == 0:
                log_action("game", f"mouse left click mine at terminal x={event.x} y={event.y}")
                self.mine_target_block()
            elif event.button == 2:
                log_action("game", f"mouse right click build at terminal x={event.x} y={event.y}")
                self.build_target_block()

        self.last_mouse_x = event.x
        self.last_mouse_y = event.y


    def pause_menu(self) -> None:
        # Mini menu di pausa aperto con ESC durante il gioco.
        selected = 0
        log_action("pause-menu", "opened")
        while self.running:
            options = [tr("continue_game"), autosave_label(self.autosave_minutes), tr("save_and_exit"), tr("exit_game")]
            self.draw_pause_menu(options, selected)
            key = self.term.inkey(timeout=None)
            name = key.name or ""
            raw_value = collect_escape_sequence(self.term, key)
            value = raw_value.lower()

            if name == "KEY_ESCAPE" and raw_value == "\x1b":
                log_action("pause-menu", "closed by ESC -> continue")
                return
            if value == "\x03":
                log_action("pause-menu", "CTRL+C -> exit")
                self.running = False
                return
            if name == "KEY_UP" or value in {"w", "\x1b[a"}:
                selected = (selected - 1) % len(options)
                log_action("pause-menu", f"selection up -> {selected} {options[selected]}")
            elif name == "KEY_DOWN" or value in {"s", "\x1b[b"}:
                selected = (selected + 1) % len(options)
                log_action("pause-menu", f"selection down -> {selected} {options[selected]}")
            elif name == "KEY_ENTER" or value in {"\n", "\r", " "}:
                log_action("pause-menu", f"activate index={selected} option={options[selected]}")
                if selected == 0:
                    return
                if selected == 1:
                    self.cycle_autosave_interval()
                    selected = 1
                elif selected == 2:
                    log_action("pause-menu", "save and exit selected")
                    self.save_game_state()
                    self.save_on_exit = False
                    self.running = False
                    return
                elif selected == 3:
                    log_action("pause-menu", "exit without saving selected")
                    self.save_on_exit = False
                    self.running = False
                    return

    def draw_pause_menu(self, options: List[str], selected: int) -> None:
        width = max(60, int(self.term.width or 80))
        height = max(18, int(self.term.height or 24))
        lines = [" " * width for _ in range(height)]

        def put(y: int, text: str, color: RGB = Palette.HUD, center: bool = True) -> None:
            if 0 <= y < height:
                safe = text[: max(1, width - 2)]
                x = max(1, (width - len(safe)) // 2) if center else 1
                lines[y] = lines[y][:x] + fg_rgb(color) + safe + ansi_reset() + lines[y][x + len(safe):]

        put(3, "==============================", Palette.HUD_ACCENT)
        put(4, f"TerminalMC - {tr('pause_title')}", Palette.HUD_ACCENT)
        put(5, "==============================", Palette.HUD_ACCENT)
        put(7, f"{tr('world')}: {self.world_name}", Palette.HUD)
        put(8, autosave_label(self.autosave_minutes), Palette.HUD)

        base_y = 10
        for index, option in enumerate(options):
            marker = "▶" if index == selected else " "
            color = Palette.HUD_ACCENT if index == selected else Palette.HUD
            put(base_y + index, f"{marker} {option}", color)

        put(height - 3, tr("pause_help"), Palette.HUD)
        sys.stdout.write("\x1b[2J\x1b[H" + "\n".join(lines) + ansi_reset())
        sys.stdout.flush()

    def update(self, delta_time: float) -> None:
        now = time.perf_counter()
        self.update_camera(now, delta_time)
        self.apply_native_mouse()
        self.update_movement(now, delta_time)
        self.check_world_border_warning()
        self.update_interactions()
        self.update_autosave()

    def apply_native_mouse(self) -> None:
        dx, dy, left_clicks, right_clicks = self.native_mouse.consume()
        if dx != 0.0 or dy != 0.0:
            self.player.yaw += clamp(dx, -60.0, 60.0) * 0.0022
            self.player.pitch -= clamp(dy, -60.0, 60.0) * 0.0018
            self.player.pitch = clamp(self.player.pitch, -1.25, 1.25)
        for _ in range(min(left_clicks, 3)):
            log_action("game", "native mouse left click mine")
            self.mine_target_block()
        for _ in range(min(right_clicks, 3)):
            log_action("game", "native mouse right click build")
            self.build_target_block()

    def cycle_autosave_interval(self) -> None:
        options: List[Optional[int]] = [None, 10, 20, 30]
        current = options.index(self.autosave_minutes) if self.autosave_minutes in options else 0
        self.autosave_minutes = options[(current + 1) % len(options)]
        self.last_autosave_time = time.perf_counter()
        self.flash_status(autosave_label(self.autosave_minutes), 3.0)
        log_action("game", f"autosave changed in-game: {self.autosave_minutes}")

    def update_autosave(self) -> None:
        if self.autosave_minutes is None:
            return
        interval = float(self.autosave_minutes * 60)
        if time.perf_counter() - self.last_autosave_time >= interval:
            log_action("game", f"autosave triggered interval_minutes={self.autosave_minutes}")
            self.save_game_state()
            self.flash_status(tr("autosave_done"), 3.0)

    def update_camera(self, now: float, delta_time: float) -> None:
        if self.input_state.is_active("turn_left", now):
            self.player.yaw -= self.config.turn_speed * delta_time
        if self.input_state.is_active("turn_right", now):
            self.player.yaw += self.config.turn_speed * delta_time
        if self.input_state.is_active("look_up", now):
            self.player.pitch += self.config.pitch_speed * delta_time
        if self.input_state.is_active("look_down", now):
            self.player.pitch -= self.config.pitch_speed * delta_time
        self.player.pitch = clamp(self.player.pitch, -1.25, 1.25)
        if self.player.yaw > math.tau:
            self.player.yaw -= math.tau
        elif self.player.yaw < -math.tau:
            self.player.yaw += math.tau

    def update_movement(self, now: float, delta_time: float) -> None:
        forward_x = math.sin(self.player.yaw)
        forward_z = math.cos(self.player.yaw)
        right_x = math.cos(self.player.yaw)
        right_z = -math.sin(self.player.yaw)
        move_x = 0.0
        move_z = 0.0
        if self.input_state.is_active("forward", now):
            move_x += forward_x
            move_z += forward_z
        if self.input_state.is_active("backward", now):
            move_x -= forward_x
            move_z -= forward_z
        if self.input_state.is_active("right", now):
            move_x += right_x
            move_z += right_z
        if self.input_state.is_active("left", now):
            move_x -= right_x
            move_z -= right_z
        length = math.sqrt(move_x * move_x + move_z * move_z)
        if length > 0.0001:
            move_x /= length
            move_z /= length
        target_x = self.player.x + move_x * self.config.move_speed * delta_time
        target_z = self.player.z + move_z * self.config.move_speed * delta_time
        if self.can_move_to(target_x, self.player.z):
            self.player.x = target_x
        if self.can_move_to(self.player.x, target_z):
            self.player.z = target_z
        if self.input_state.consume_just_pressed("jump") and self.player.grounded:
            self.player.velocity_y = self.config.jump_speed
            self.player.grounded = False
        self.player.velocity_y -= self.config.gravity * delta_time
        self.player.y += self.player.velocity_y * delta_time
        self.resolve_vertical_physics()

    def check_world_border_warning(self) -> None:
        border = float(self.config.world_radius) - 1.0
        warning_distance = 2.0
        now = time.perf_counter()
        if abs(self.player.x) >= border - warning_distance or abs(self.player.z) >= border - warning_distance:
            if now - self.world_border_last_warning >= 2.0:
                self.world_border_last_warning = now
                self.flash_status(tr("world_border"), 2.5)
                log_action("game", f"world border warning position=({self.player.x:.2f},{self.player.z:.2f}) border={border:.2f}")

    def can_move_to(self, x: float, z: float) -> bool:
        border = float(self.config.world_radius) - 1.0
        if x < -border or x > border or z < -border or z > border:
            self.flash_status(tr("world_border"), 2.5)
            log_action("game", f"world border reached target_x={x:.2f} target_z={z:.2f}")
            return False
        feet_y = self.player.y - self.config.eye_height
        highest = self.world.highest_solid_y(math.floor(x), math.floor(z))
        if highest is None:
            return True
        top = highest + 1.0
        return top <= feet_y + 0.65 or feet_y >= top

    def resolve_vertical_physics(self) -> None:
        highest = self.world.highest_solid_y(math.floor(self.player.x), math.floor(self.player.z))
        if highest is None:
            self.player.grounded = False
            return
        ground_top = float(highest + 1)
        feet_y = self.player.y - self.config.eye_height
        if feet_y <= ground_top:
            self.player.y = ground_top + self.config.eye_height
            self.player.velocity_y = 0.0
            self.player.grounded = True
        else:
            self.player.grounded = False

    def update_interactions(self) -> None:
        if self.input_state.consume_just_pressed("mine"):
            self.mine_target_block()
        if self.input_state.consume_just_pressed("build"):
            self.build_target_block()
        if self.input_state.consume_just_pressed("save"):
            self.save_game_state()

    def center_hit(self) -> Optional[RayHit]:
        direction = self.raycaster.camera_forward(self.player.yaw, self.player.pitch)
        origin = (self.player.x, self.player.y, self.player.z)
        return self.raycaster.cast(origin, direction, self.config.interaction_distance)

    def mine_target_block(self) -> None:
        hit = self.center_hit()
        if hit is not None:
            self.world.remove_block(hit.position)
            log_action("game", f"mined block at {hit.position}")
        else:
            log_action("game", "mine requested but no target block hit")

    def build_target_block(self) -> None:
        hit = self.center_hit()
        if hit is None:
            return
        target = hit.previous_position
        if self.world.is_solid(target) or self.position_intersects_player(target):
            log_action("game", f"build rejected at {target}")
            return
        self.world.set_block(target, HOTBAR[self.selected_index])
        log_action("game", f"placed {block_label(HOTBAR[self.selected_index])} at {target}")

    def position_intersects_player(self, block_pos: IVec3) -> bool:
        bx, by, bz = block_pos
        px = self.player.x
        pz = self.player.z
        feet = self.player.y - self.config.eye_height
        head = feet + self.config.player_height
        closest_x = clamp(px, bx, bx + 1)
        closest_z = clamp(pz, bz, bz + 1)
        dx = px - closest_x
        dz = pz - closest_z
        horizontal = dx * dx + dz * dz <= self.config.player_radius * self.config.player_radius

        # Corpo del giocatore alto esattamente 2 blocchi: [feet, feet + 2).
        # Il contatto esatto sul bordo non conta come occupazione di un terzo blocco.
        vertical = not (head <= by or feet >= by + 1)
        return horizontal and vertical

    def update_fps(self, delta_time: float) -> None:
        self.frame_counter += 1
        self.fps_accumulator += delta_time
        if self.fps_accumulator >= 0.25:
            self.fps = self.frame_counter / self.fps_accumulator if self.fps_accumulator > 0.0 else 0.0
            self.frame_counter = 0
            self.fps_accumulator = 0.0

class MainMenu:
    def __init__(self) -> None:
        self.term = Terminal()
        self.language = "en"
        self.autosave_minutes: Optional[int] = None
        self.options = self.build_options()
        self.selected = 0
        self.message = tr("save_hint")
        self.last_option_rows: Dict[int, int] = {}

    def build_options(self) -> List[str]:
        global LANGUAGE
        LANGUAGE = self.language
        return [
            tr("new_world"),
            tr("load_world"),
            tr("info_links"),
            tr("language"),
            autosave_label(self.autosave_minutes),
            tr("exit"),
        ]

    async def run(self) -> Optional[Tuple[str, bool, str, Optional[int]]]:
        global LANGUAGE
        with self.term.fullscreen(), self.term.hidden_cursor(), self.term.cbreak():
            sys.stdout.write(enable_mouse_reporting())
            sys.stdout.flush()
            try:
                while True:
                    LANGUAGE = self.language
                    self.options = self.build_options()
                    self.draw()
                    key = self.term.inkey(timeout=0.1)
                    if not key:
                        await asyncio.sleep(0)
                        continue

                    name = key.name or ""
                    raw_value = collect_escape_sequence(self.term, key)
                    value = raw_value.lower()
                    mouse_event = parse_sgr_mouse(raw_value)
                    if mouse_event is not None and mouse_event.pressed and not mouse_event.motion:
                        clicked = self.menu_index_from_y(mouse_event.y)
                        log_action("main-menu", f"mouse click x={mouse_event.x} y={mouse_event.y} clicked_index={clicked}")
                        if clicked is not None:
                            self.selected = clicked
                            result = await self.activate_selected()
                            if result == "continue":
                                continue
                            return result

                    if (name == "KEY_ESCAPE" and raw_value == "\x1b") or value == "\x03":
                        log_action("main-menu", "exit requested")
                        return None
                    if name == "KEY_UP" or value in {"w", "\x1b[a"}:
                        self.selected = (self.selected - 1) % len(self.options)
                        log_action("main-menu", f"keyboard selection up -> index={self.selected} option={self.options[self.selected]}")
                    elif name == "KEY_DOWN" or value in {"s", "\x1b[b"}:
                        self.selected = (self.selected + 1) % len(self.options)
                        log_action("main-menu", f"keyboard selection down -> index={self.selected} option={self.options[self.selected]}")
                    elif name == "KEY_ENTER" or value in {"\n", "\r", " "}:
                        log_action("main-menu", f"activate option index={self.selected} option={self.options[self.selected]}")
                        result = await self.activate_selected()
                        if result == "continue":
                            continue
                        return result
            finally:
                sys.stdout.write(disable_mouse_reporting() + ansi_reset())
                sys.stdout.flush()

    async def activate_selected(self) -> Optional[Tuple[str, bool, str, Optional[int]]] | str:
        global LANGUAGE
        LANGUAGE = self.language
        if self.selected == 0:
            log_action("main-menu", "create new world selected")
            name = await self.prompt_world_name()
            if name is None:
                return "continue"
            log_action("main-menu", f"new world name confirmed: {name}")
            return (name, False, self.language, self.autosave_minutes)
        if self.selected == 1:
            log_action("main-menu", "load world selected")
            result = await self.choose_world()
            if result is None:
                return "continue"
            log_action("main-menu", f"load world confirmed: {result}")
            return (result, True, self.language, self.autosave_minutes)
        if self.selected == 2:
            log_action("main-menu", "info selected")
            await self.show_info()
            return "continue"
        if self.selected == 3:
            self.language = "it" if self.language == "en" else "en"
            LANGUAGE = self.language
            log_action("main-menu", f"language changed: {self.language}")
            self.message = tr("save_hint")
            return "continue"
        if self.selected == 4:
            options: List[Optional[int]] = [None, 10, 20, 30]
            current = options.index(self.autosave_minutes) if self.autosave_minutes in options else 0
            self.autosave_minutes = options[(current + 1) % len(options)]
            log_action("main-menu", f"autosave changed: {self.autosave_minutes}")
            self.message = autosave_label(self.autosave_minutes)
            return "continue"
        return None

    def menu_index_from_y(self, y: int) -> Optional[int]:
        for index, row in self.last_option_rows.items():
            if y - 1 == row:
                return index
        return None

    async def prompt_world_name(self) -> Optional[str]:
        global LANGUAGE
        LANGUAGE = self.language
        name = ""
        while True:
            self.draw_prompt(name)
            key = self.term.inkey(timeout=None)
            name_key = key.name or ""
            value = str(key)
            if name_key == "KEY_ESCAPE":
                log_action("main-menu", "world name prompt cancelled")
                return None
            if name_key == "KEY_ENTER" or value in {"\n", "\r"}:
                safe = sanitize_world_name(name)
                final_name = safe if safe else default_world_name()
                log_action("main-menu", f"world name prompt enter: raw={name!r} sanitized={final_name!r}")
                return final_name
            if name_key in {"KEY_BACKSPACE", "KEY_DELETE"} or value in {"\x7f", "\b"}:
                name = name[:-1]
            elif value and value.isprintable() and len(name) < 32:
                name += value
            await asyncio.sleep(0)

    async def choose_world(self) -> Optional[str]:
        global LANGUAGE
        LANGUAGE = self.language
        worlds = list_saved_worlds()
        if not worlds:
            self.message = tr("no_worlds")
            await self.show_info()
            return None

        selected = 0
        while True:
            self.draw_world_selector(worlds, selected)
            key = self.term.inkey(timeout=0.1)
            if not key:
                await asyncio.sleep(0)
                continue
            name = key.name or ""
            raw_value = collect_escape_sequence(self.term, key)
            value = raw_value.lower()
            mouse_event = parse_sgr_mouse(raw_value)
            if mouse_event is not None and mouse_event.pressed and not mouse_event.motion:
                row = mouse_event.y - 1
                first = 5
                idx = row - first
                log_action("main-menu", f"world selector mouse click x={mouse_event.x} y={mouse_event.y} idx={idx}")
                if 0 <= idx < len(worlds):
                    log_action("main-menu", f"world selector chose by mouse: {worlds[idx]}")
                    return worlds[idx]
            if name == "KEY_ESCAPE" and raw_value == "\x1b":
                log_action("main-menu", "world selector cancelled")
                return None
            if name == "KEY_UP" or value in {"w", "\x1b[a"}:
                selected = (selected - 1) % len(worlds)
                log_action("main-menu", f"world selector up -> {selected} {worlds[selected]}")
            elif name == "KEY_DOWN" or value in {"s", "\x1b[b"}:
                selected = (selected + 1) % len(worlds)
                log_action("main-menu", f"world selector down -> {selected} {worlds[selected]}")
            elif name == "KEY_ENTER" or value in {"\n", "\r", " "}:
                log_action("main-menu", f"world selector chose by keyboard: {worlds[selected]}")
                return worlds[selected]

    def draw_prompt(self, current_name: str) -> None:
        width = max(60, int(self.term.width or 80))
        height = max(20, int(self.term.height or 24))
        lines = [" " * width for _ in range(height)]

        def put(y: int, text: str, color: RGB = Palette.HUD) -> None:
            if 0 <= y < height:
                safe = text[: width - 2]
                x = max(1, (width - len(safe)) // 2)
                lines[y] = lines[y][:x] + fg_rgb(color) + safe + ansi_reset() + lines[y][x + len(safe):]

        put(4, tr("enter_world_name"), Palette.HUD_ACCENT)
        put(6, "> " + current_name + "_", Palette.HUD)
        put(8, tr("confirm"), Palette.HUD_ACCENT)
        sys.stdout.write("\x1b[2J\x1b[H" + "\n".join(lines) + ansi_reset())
        sys.stdout.flush()

    def draw_world_selector(self, worlds: List[str], selected: int) -> None:
        width = max(60, int(self.term.width or 80))
        height = max(20, int(self.term.height or 24))
        lines = [" " * width for _ in range(height)]

        def put(y: int, text: str, color: RGB = Palette.HUD) -> None:
            if 0 <= y < height:
                safe = text[: width - 2]
                lines[y] = " " + fg_rgb(color) + safe + ansi_reset() + lines[y][1 + len(safe):]

        put(2, tr("choose_world"), Palette.HUD_ACCENT)
        visible = worlds[: max(1, height - 8)]
        for index, name in enumerate(visible):
            marker = "▶" if index == selected else " "
            color = Palette.HUD_ACCENT if index == selected else Palette.HUD
            path = existing_world_path(name) or world_path(name)
            mtime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(os.path.getmtime(path))) if os.path.exists(path) else "?"
            location = os.path.relpath(path, APP_DIR) if os.path.exists(path) else "missing"
            put(5 + index, f"{marker} {name}  ({mtime})  [{location}]", color)
        put(height - 2, tr("menu_help"), Palette.HUD)
        sys.stdout.write("\x1b[2J\x1b[H" + "\n".join(lines) + ansi_reset())
        sys.stdout.flush()

    def draw(self) -> None:
        width = max(60, int(self.term.width or 80))
        height = max(20, int(self.term.height or 24))
        lines: List[str] = []
        for _ in range(height):
            lines.append(" " * width)
        self.last_option_rows.clear()

        def put(y: int, text: str, color: RGB = Palette.HUD) -> None:
            if 0 <= y < height:
                x = max(0, (width - len(text)) // 2)
                visible = text[:width]
                lines[y] = lines[y][:x] + fg_rgb(color) + visible + ansi_reset() + lines[y][x + len(visible):]

        logo = [
            "████████╗███████╗██████╗ ███╗   ███╗██╗███╗   ██╗ █████╗ ██╗     ███╗   ███╗ ██████╗",
            "╚══██╔══╝██╔════╝██╔══██╗████╗ ████║██║████╗  ██║██╔══██╗██║     ████╗ ████║██╔════╝",
            "   ██║   █████╗  ██████╔╝██╔████╔██║██║██╔██╗ ██║███████║██║     ██╔████╔██║██║     ",
            "   ██║   ██╔══╝  ██╔══██╗██║╚██╔╝██║██║██║╚██╗██║██╔══██║██║     ██║╚██╔╝██║██║     ",
            "   ██║   ███████╗██║  ██║██║ ╚═╝ ██║██║██║ ╚████║██║  ██║███████╗██║ ╚═╝ ██║╚██████╗",
            "   ╚═╝   ╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝ ╚═════╝",
        ]
        for i, row in enumerate(logo):
            put(2 + i, row, Palette.HUD_ACCENT)
        put(9, f"{tr('author')}: {AUTHOR_NAME}", Palette.HUD)

        base_y = 12
        for index, option in enumerate(self.options):
            marker = "▶" if index == self.selected else " "
            color = Palette.HUD_ACCENT if index == self.selected else Palette.HUD
            row = base_y + index
            self.last_option_rows[index] = row
            put(row, f"{marker} {option}", color)

        put(height - 4, tr("menu_help"), Palette.HUD)
        if self.message:
            put(height - 3, self.message, Palette.HUD_ACCENT)
        sys.stdout.write("\x1b[2J\x1b[H" + "\n".join(lines) + ansi_reset())
        sys.stdout.flush()

    async def show_info(self) -> None:
        width = max(60, int(self.term.width or 80))
        height = max(20, int(self.term.height or 24))
        saved = list_saved_worlds()
        lines = [" " * width for _ in range(height)]

        def put(y: int, text: str, color: RGB = Palette.HUD) -> None:
            if 0 <= y < height:
                safe = text[: width - 2]
                lines[y] = " " + fg_rgb(color) + safe + ansi_reset() + lines[y][1 + len(safe):]

        put(1, tr("info_title"), Palette.HUD_ACCENT)
        put(3, f"{tr('author')}: {AUTHOR_NAME}")
        put(4, f"{tr('version')}: {GAME_VERSION}")
        put(5, tr("progress_path"))
        put(6, tr("manual_save"))
        put(8, tr("links") + ":", Palette.HUD_ACCENT)
        for i, link in enumerate(PROJECT_LINKS):
            put(9 + i, "- " + link)
        put(14, tr("saved_worlds") + ":", Palette.HUD_ACCENT)
        if saved:
            for i, name in enumerate(saved[:5]):
                put(15 + i, f"- {name}")
        else:
            put(15, "- " + tr("none"))
        put(height - 2, tr("press_key"), Palette.HUD_ACCENT)
        sys.stdout.write("\x1b[2J\x1b[H" + "\n".join(lines) + ansi_reset())
        sys.stdout.flush()
        self.term.inkey(timeout=None)
        await asyncio.sleep(0)


async def async_main() -> None:
    menu = MainMenu()
    selection = await menu.run()
    if selection is None:
        return
    world_name, load_existing, language, autosave_minutes = selection
    game = Game(world_name, load_existing, language, autosave_minutes)
    await game.run()


def main() -> None:
    try:
        asyncio.run(async_main())
    except KeyboardInterrupt:
        sys.stdout.write(ansi_reset() + "\x1b[2J\x1b[H")
        sys.stdout.flush()
    except Exception as exc:
        # Se il gioco viene avviato da doppio click o da Alacritty senza shell,
        # il traceback rischia di sparire subito: lo salviamo su file.
        ensure_log_dir()
        log_path = os.path.join(log_dir(), f"terminalmc_crash_{current_log_stamp()}.log")
        with open(log_path, "w", encoding="utf-8") as log_file:
            log_file.write("TerminalMC crash log\n")
            log_file.write("====================\n\n")
            log_file.write(traceback.format_exc())

        sys.stdout.write(ansi_reset() + "\x1b[2J\x1b[H")
        sys.stdout.flush()
        if os.environ.get("TERMINALMC_LANG", "en").lower() == "it":
            print("TerminalMC è andato in errore.")
            print(f"Errore: {exc}")
            print(f"Crash log salvato in: {log_path}")
            print()
            print("Comando consigliato:")
            print("    python -m pip install -r requirements.txt")
            print("    python main.py")
            prompt = "Premi INVIO per chiudere..."
        else:
            print("TerminalMC crashed.")
            print(f"Error: {exc}")
            print(f"Crash log saved to: {log_path}")
            print()
            print("Recommended command:")
            print("    python -m pip install -r requirements.txt")
            print("    python main.py")
            prompt = "Press ENTER to close..."
        try:
            input(prompt)
        except EOFError:
            pass


if __name__ == "__main__":
    main()