Tu primer juego con un LLM, y cómo saber si está bien#

Porque todavía no hay ninguna regla. Un verde sin reglas diría «está todo bien» sin haber mirado nada. Oracle prefiere decir lo que pasó: no midió.

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Batalla Naval · HTML5 con Auditoría Formal</title>
  <link rel="stylesheet" href="css/style.css">
</head>
<body>

  <!-- Encabezado de la Sala de Operaciones Navales -->
  <header>
    <div class="brand">
      <div class="radar-logo"></div>
      <div class="brand-text">
        <h1>Batalla <span>Naval</span></h1>
        <div class="tagline">Tácticas Navales · Auditoría Formal con Oracle</div>
      </div>
    </div>

    <div class="header-controls">
      <button id="btnOpenAudit" class="btn btn-accent" title="Verificar formalmente las reglas sobre la traza">
        <span>⚖</span> Auditoría & Traza Oracle
      </button>
      <button id="btnToggleSound" class="btn" title="Activar/desactivar efectos sonoros">
        🔊 Sonido
      </button>
      <button id="btnNewGame" class="btn btn-danger" title="Reiniciar y comenzar una nueva batalla">
        ↻ Nueva Partida
      </button>
    </div>
  </header>

  <!-- Contenedor Principal -->
  <main>
    <!-- Barra de Estado / Turnos / Métricas -->
    <section class="status-banner">
      <div class="status-info">
        <div id="statusIndicator" class="status-indicator"></div>
        <div class="status-text">
          <h2 id="statusTitle">Fase de Despliegue</h2>
          <p id="statusSubtitle">Ubicá tus 5 buques en el tablero o pulsá "Auto-Desplegar"</p>
        </div>
      </div>

      <div class="game-metrics">
        <div class="metric-item">
          <span class="metric-label">Turno</span>
          <span id="metricTurns" class="metric-value">0</span>
        </div>
        <div class="metric-item">
          <span class="metric-label">Impactos</span>
          <span id="metricHits" class="metric-value">0 / 17</span>
        </div>
        <div class="metric-item">
          <span class="metric-label">Precisión</span>
          <span id="metricAccuracy" class="metric-value">0%</span>
        </div>
      </div>
    </section>

    <!-- Herramientas para la fase de colocación de buques -->
    <section id="placementTools" class="placement-tools">
      <div class="placement-header">
        <h3>Despliegue de la Flota Aliada</h3>
        <div class="placement-actions">
          <button id="btnRotate" class="btn" title="Rotar orientación del barco (tecla R)">
            Rotar [R]: <strong id="orientationBadge">HORIZONTAL</strong>
          </button>
          <button id="btnAutoPlace" class="btn" title="Colocar todos los barcos al azar">
            🎲 Auto-Desplegar
          </button>
          <button id="btnClearPlacement" class="btn" title="Limpiar todas las posiciones">
            Limpiar
          </button>
          <button id="btnStartBattle" class="btn btn-primary" disabled title="Comenzar el combate">
            ⚔ Iniciar Batalla
          </button>
        </div>
      </div>
      <div id="shipsDock" class="ships-dock">
        <!-- Generado dinámicamente por ui.js -->
      </div>
    </section>

    <!-- Zona de Batalla: Tableros Navales y Paneles -->
    <section class="battlefield">

      <!-- Tablero Aliado (Tu Flota) -->
      <div class="board-card">
        <div class="board-header">
          <div class="board-title">
            <span>🛡 Tu Flota</span>
          </div>
          <span class="badge badge-player">Defensa</span>
        </div>
        <div class="grid-container">
          <table id="playerGrid" class="grid-table player-grid">
            <!-- Celdas generadas por JS -->
          </table>
        </div>
      </div>

      <!-- Tablero Hostil (Radar Enemigo) -->
      <div class="board-card enemy-card">
        <div class="board-header">
          <div class="board-title">
            <span>🎯 Radar Enemigo</span>
          </div>
          <span class="badge badge-enemy">Ataque</span>
        </div>
        <div class="grid-container">
          <table id="enemyGrid" class="grid-table enemy-grid">
            <!-- Celdas generadas por JS -->
          </table>
        </div>
      </div>

      <!-- Panel Lateral: Rastreador de Barcos y Bitácora -->
      <aside class="side-panel">
        <div class="side-card">
          <h3>Estado de Flotas</h3>
          <div class="fleet-roster">
            <div class="roster-group-title">Enemigo (Objetivos)</div>
            <div id="cpuRoster"></div>

            <div class="roster-group-title" style="margin-top: 10px;">Aliados</div>
            <div id="playerRoster"></div>
          </div>
        </div>

        <div class="side-card">
          <h3>Bitácora de Combate</h3>
          <div id="combatLog" class="combat-log">
            <!-- Entradas de registro -->
          </div>
        </div>
      </aside>

    </section>
  </main>

  <!-- Modal de Auditoría Formal de Reglas con Oracle -->
  <div id="auditModal" class="modal-overlay">
    <div class="modal-container">
      <div class="modal-header">
        <h3><span>⚖</span> Auditoría Formal de Reglas (Oracle Metalenguaje)</h3>
        <button id="btnCloseAudit" class="modal-close">&times;</button>
      </div>

      <div class="modal-body">
        <div class="modal-tabs">
          <button class="tab-btn active" data-tab="tabRules">11 Medidas Formales</button>
          <button class="tab-btn" data-tab="tabJson">Traza de Hechos (`hechos.json`)</button>
          <button class="tab-btn" data-tab="tabCli">Verificar con CLI</button>
        </div>

        <!-- Pestaña 1: Medidas Formales Evaluadas -->
        <div id="tabRules" class="tab-content active">
          <p style="font-size: 0.82rem; color: var(--text-muted);">
            Cada movimiento de la partida es registrado de forma inmutable. Estas 11 medidas formales
            garantizan que ninguna regla del juego sea violada (espacialidad, alternancia, no-duplicación, veracidad de impacto y hundimiento).
          </p>
          <div id="rulesList" class="rules-list">
            <!-- Generado dinámicamente por trace.js / ui.js -->
          </div>
        </div>

        <!-- Pestaña 2: Traza JSON en Crudo -->
        <div id="tabJson" class="tab-content">
          <p style="font-size: 0.82rem; color: var(--text-muted);">
            Esta es la evidencia relacional exacta producida por el juego, compuesta por las relaciones:
            <code>celda_barco</code>, <code>tiro</code> y <code>partida</code>.
          </p>
          <pre id="jsonViewer" class="json-viewer"></pre>
        </div>

        <!-- Pestaña 3: Instrucciones de Verificación CLI con Oracle -->
        <div id="tabCli" class="tab-content">
          <div class="cli-instruction">
            <strong>1. Descargá el archivo de evidencia:</strong>
            <span>Pulsá el botón "Descargar hechos.json" abajo para guardar la traza de la partida.</span>
          </div>
          <div class="cli-instruction">
            <strong>2. Ejecutá el evaluador independiente de Oracle en tu terminal:</strong>
            <div class="cli-code">oracle juzgar --con hechos_partida.json</div>
            <span>Oracle evaluará las 11 medidas del catálogo sobre tu archivo y emitirá el veredicto formal independiente con sus testigos y alcances.</span>
          </div>
          <div class="cli-instruction">
            <strong>3. O corré el script de auditoría completa del proyecto:</strong>
            <div class="cli-code">python3 verificar_oraculo.py</div>
            <span>Ejecuta una partida legítima y además prueba que el oráculo detecta infracciones (falsabilidad).</span>
          </div>
        </div>
      </div>

      <div class="modal-footer">
        <button id="btnCopyJson" class="btn">Copiar JSON</button>
        <button id="btnDownloadJson" class="btn btn-primary">⬇ Descargar hechos_partida.json</button>
      </div>
    </div>
  </div>

  <!-- Modal de Fin de Partida -->
  <div id="gameOverModal" class="modal-overlay">
    <div class="modal-container" style="max-width: 500px;">
      <div class="gameover-modal-content">
        <h2 id="gameOverTitle" class="gameover-title win">¡VICTORIA NAVAL!</h2>
        <p style="color: var(--text-muted); font-size: 0.88rem;">
          El combate ha concluido. Todas las operaciones han quedado registradas en la traza relacional.
        </p>

        <div class="gameover-stats">
          <div class="gameover-stat-box">
            <div id="goWinner" class="gameover-stat-val">JUGADOR</div>
            <div class="gameover-stat-lbl">Ganador</div>
          </div>
          <div class="gameover-stat-box">
            <div id="goTurns" class="gameover-stat-val">42</div>
            <div class="gameover-stat-lbl">Turnos Totales</div>
          </div>
          <div class="gameover-stat-box">
            <div id="goAccuracy" class="gameover-stat-val">48%</div>
            <div class="gameover-stat-lbl">Precisión</div>
          </div>
        </div>

        <div style="display: flex; gap: 10px; width: 100%; justify-content: center; margin-top: 10px;">
          <button id="btnVerifyFromGameOver" class="btn btn-accent" style="flex: 1;">
            ⚖ Auditar con Oracle
          </button>
          <button id="btnRestart" class="btn btn-primary" style="flex: 1;">
            ↻ Jugar de Nuevo
          </button>
        </div>
      </div>
    </div>
  </div>

  <!-- Scripts del Juego -->
  <script src="js/audio.js"></script>
  <script src="js/trace.js"></script>
  <script src="js/engine.js"></script>
  <script src="js/ui.js"></script>
</body>
</html>

/* ==========================================================================
   style.css - Batalla Naval: Tactical Naval Operations Theme
   ========================================================================== */

:root {
  --bg-primary: #0a0f1d;
  --bg-surface: #111a2e;
  --bg-card: #16223b;
  --bg-card-hover: #1c2b4a;
  --border-color: #233554;
  --border-active: #00f0ff;

  --accent-cyan: #00f0ff;
  --accent-blue: #0077b6;
  --accent-green: #00f59b;
  --accent-red: #ff3366;
  --accent-yellow: #ffb703;
  --accent-orange: #fb8500;

  --text-main: #e2e8f0;
  --text-muted: #8da2c0;
  --text-bright: #ffffff;

  --cell-size: 34px;
  --font-mono: 'JetBrains Mono', 'Fira Code', 'Courier New', monospace;
  --font-sans: 'Inter', system-ui, -apple-system, sans-serif;
  --radius: 8px;
  --shadow: 0 8px 24px rgba(0, 0, 0, 0.4);
  --glow-cyan: 0 0 12px rgba(0, 240, 255, 0.45);
  --glow-red: 0 0 12px rgba(255, 51, 102, 0.5);
  --glow-green: 0 0 12px rgba(0, 245, 155, 0.45);
}

* {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
}

body {
  background-color: var(--bg-primary);
  color: var(--text-main);
  font-family: var(--font-sans);
  min-height: 100vh;
  display: flex;
  flex-direction: column;
  background-image: 
    radial-gradient(circle at 50% 0%, rgba(0, 119, 182, 0.15) 0%, transparent 70%),
    linear-gradient(rgba(10, 15, 29, 0.96), rgba(10, 15, 29, 0.98));
  overflow-x: hidden;
}

/* Header */
header {
  background: var(--bg-surface);
  border-bottom: 1px solid var(--border-color);
  padding: 12px 24px;
  display: flex;
  justify-content: space-between;
  align-items: center;
  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3);
  position: sticky;
  top: 0;
  z-index: 100;
}

.brand {
  display: flex;
  align-items: center;
  gap: 14px;
}

.radar-logo {
  width: 38px;
  height: 38px;
  border-radius: 50%;
  border: 2px solid var(--accent-cyan);
  position: relative;
  box-shadow: var(--glow-cyan);
  display: flex;
  align-items: center;
  justify-content: center;
  overflow: hidden;
}

.radar-logo::after {
  content: '';
  position: absolute;
  width: 100%;
  height: 100%;
  background: conic-gradient(from 0deg, transparent 75%, rgba(0, 240, 255, 0.4) 100%);
  animation: radar-sweep 2.5s linear infinite;
  border-radius: 50%;
}

@keyframes radar-sweep {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

.brand-text h1 {
  font-size: 1.3rem;
  letter-spacing: 2px;
  font-weight: 800;
  color: var(--text-bright);
  text-transform: uppercase;
}

.brand-text h1 span {
  color: var(--accent-cyan);
}

.brand-text .tagline {
  font-size: 0.75rem;
  color: var(--text-muted);
  font-family: var(--font-mono);
}

.header-controls {
  display: flex;
  align-items: center;
  gap: 10px;
}

/* Botones */
.btn {
  background: var(--bg-card);
  color: var(--text-main);
  border: 1px solid var(--border-color);
  padding: 8px 14px;
  border-radius: var(--radius);
  font-family: var(--font-sans);
  font-size: 0.85rem;
  font-weight: 600;
  cursor: pointer;
  transition: all 0.2s ease;
  display: inline-flex;
  align-items: center;
  gap: 6px;
}

.btn:hover {
  background: var(--bg-card-hover);
  border-color: var(--accent-cyan);
  color: var(--accent-cyan);
  box-shadow: var(--glow-cyan);
}

.btn:disabled {
  opacity: 0.4;
  cursor: not-allowed;
  pointer-events: none;
}

.btn-primary {
  background: linear-gradient(135deg, var(--accent-blue), #0096c7);
  border-color: var(--accent-cyan);
  color: var(--text-bright);
}

.btn-primary:hover {
  background: linear-gradient(135deg, #0096c7, var(--accent-cyan));
  color: #000;
}

.btn-accent {
  background: rgba(0, 245, 155, 0.15);
  border-color: var(--accent-green);
  color: var(--accent-green);
}

.btn-accent:hover {
  background: var(--accent-green);
  color: #000;
  box-shadow: var(--glow-green);
}

.btn-danger {
  background: rgba(255, 51, 102, 0.15);
  border-color: var(--accent-red);
  color: var(--accent-red);
}

.btn-danger:hover {
  background: var(--accent-red);
  color: #fff;
  box-shadow: var(--glow-red);
}

.btn-icon {
  padding: 8px 10px;
}

/* Contenedor Principal */
main {
  flex: 1;
  max-width: 1300px;
  width: 100%;
  margin: 0 auto;
  padding: 16px 20px;
  display: flex;
  flex-direction: column;
  gap: 16px;
}

/* Barra de Estado / Turno */
.status-banner {
  background: var(--bg-surface);
  border: 1px solid var(--border-color);
  border-radius: var(--radius);
  padding: 12px 20px;
  display: flex;
  justify-content: space-between;
  align-items: center;
  position: relative;
  overflow: hidden;
}

.status-banner::before {
  content: '';
  position: absolute;
  left: 0;
  top: 0;
  bottom: 0;
  width: 4px;
  background: var(--accent-cyan);
  box-shadow: var(--glow-cyan);
}

.status-info {
  display: flex;
  align-items: center;
  gap: 14px;
}

.status-indicator {
  width: 12px;
  height: 12px;
  border-radius: 50%;
  background: var(--accent-green);
  box-shadow: var(--glow-green);
  animation: pulse-dot 1.8s infinite;
}

.status-indicator.waiting {
  background: var(--accent-yellow);
  box-shadow: 0 0 10px rgba(255, 183, 3, 0.5);
}

.status-indicator.cpu {
  background: var(--accent-red);
  box-shadow: var(--glow-red);
}

@keyframes pulse-dot {
  0%, 100% { transform: scale(1); opacity: 1; }
  50% { transform: scale(1.25); opacity: 0.7; }
}

.status-text h2 {
  font-size: 1.05rem;
  font-weight: 700;
  color: var(--text-bright);
}

.status-text p {
  font-size: 0.8rem;
  color: var(--text-muted);
}

.game-metrics {
  display: flex;
  gap: 18px;
  font-family: var(--font-mono);
  font-size: 0.8rem;
}

.metric-item {
  display: flex;
  flex-direction: column;
  align-items: flex-end;
}

.metric-label {
  color: var(--text-muted);
  font-size: 0.7rem;
  text-transform: uppercase;
}

.metric-value {
  color: var(--accent-cyan);
  font-weight: 700;
}

/* Área de Juego: Tableros y Paneles */
.battlefield {
  display: grid;
  grid-template-columns: auto auto 320px;
  gap: 20px;
  align-items: start;
  justify-content: center;
}

@media (max-width: 1180px) {
  .battlefield {
    grid-template-columns: 1fr 1fr;
  }
  .side-panel {
    grid-column: 1 / -1;
  }
}

@media (max-width: 820px) {
  .battlefield {
    grid-template-columns: 1fr;
  }
}

/* Tarjetas de Tablero */
.board-card {
  background: var(--bg-surface);
  border: 1px solid var(--border-color);
  border-radius: var(--radius);
  padding: 16px;
  box-shadow: var(--shadow);
  display: flex;
  flex-direction: column;
  align-items: center;
}

.board-card.active-target {
  border-color: var(--accent-cyan);
  box-shadow: var(--glow-cyan);
}

.board-header {
  width: 100%;
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 12px;
  padding-bottom: 8px;
  border-bottom: 1px solid var(--border-color);
}

.board-title {
  display: flex;
  align-items: center;
  gap: 8px;
  font-size: 0.95rem;
  font-weight: 700;
  text-transform: uppercase;
  letter-spacing: 1px;
}

.badge {
  font-size: 0.65rem;
  padding: 2px 8px;
  border-radius: 12px;
  font-weight: 700;
  font-family: var(--font-mono);
  text-transform: uppercase;
}

.badge-player {
  background: rgba(0, 119, 182, 0.3);
  color: var(--accent-cyan);
  border: 1px solid var(--accent-cyan);
}

.badge-enemy {
  background: rgba(255, 51, 102, 0.2);
  color: var(--accent-red);
  border: 1px solid var(--accent-red);
}

/* Grilla Naval 10x10 */
.grid-container {
  display: inline-block;
  background: #0d1527;
  padding: 10px;
  border-radius: 6px;
  border: 1px solid #1a2948;
}

.grid-table {
  border-collapse: collapse;
}

.grid-label {
  width: var(--cell-size);
  height: 22px;
  text-align: center;
  vertical-align: middle;
  font-family: var(--font-mono);
  font-size: 0.72rem;
  font-weight: 600;
  color: var(--text-muted);
}

.grid-label-row {
  width: 22px;
  height: var(--cell-size);
  text-align: center;
  vertical-align: middle;
  font-family: var(--font-mono);
  font-size: 0.72rem;
  font-weight: 600;
  color: var(--text-muted);
}

.grid-cell {
  width: var(--cell-size);
  height: var(--cell-size);
  border: 1px solid #1b2845;
  background-color: #0f192c;
  position: relative;
  cursor: default;
  transition: all 0.15s ease;
  user-select: none;
}

/* Celdas del Radar Enemigo (Interactivas) */
.enemy-grid .grid-cell {
  cursor: crosshair;
}

.enemy-grid .grid-cell:hover:not(.shot) {
  background-color: rgba(0, 240, 255, 0.2);
  border-color: var(--accent-cyan);
  box-shadow: inset 0 0 8px rgba(0, 240, 255, 0.4);
}

/* Estados de Casilla */
.grid-cell.ship-present {
  background-color: #2a3d5e;
  border-color: #3b537e;
}

.grid-cell.ship-present::before {
  content: '';
  position: absolute;
  top: 3px;
  left: 3px;
  right: 3px;
  bottom: 3px;
  background: #3e5884;
  border-radius: 3px;
  border: 1px solid #5a7ea8;
}

.grid-cell.shot.miss {
  background-color: #0b1424;
}

.grid-cell.shot.miss::after {
  content: '';
  position: absolute;
  top: 50%;
  left: 50%;
  width: 8px;
  height: 8px;
  transform: translate(-50%, -50%);
  background-color: #48cae4;
  border-radius: 50%;
  box-shadow: 0 0 6px rgba(72, 202, 228, 0.8);
  animation: splash-pop 0.3s ease-out;
}

.grid-cell.shot.hit {
  background-color: rgba(255, 51, 102, 0.25);
  border-color: var(--accent-red);
}

.grid-cell.shot.hit::after {
  content: '✕';
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  color: var(--accent-red);
  font-weight: 900;
  font-size: 1.1rem;
  text-shadow: 0 0 8px var(--accent-red);
  animation: hit-shake 0.3s ease-in-out;
}

.grid-cell.sunk {
  background-color: rgba(255, 51, 102, 0.45) !important;
  border-color: #ff0044 !important;
  animation: sunk-flash 0.8s ease-in-out;
}

/* Hover de colocación de barcos */
.grid-cell.placement-valid {
  background-color: rgba(0, 245, 155, 0.35) !important;
  border-color: var(--accent-green) !important;
}

.grid-cell.placement-invalid {
  background-color: rgba(255, 51, 102, 0.35) !important;
  border-color: var(--accent-red) !important;
}

@keyframes splash-pop {
  0% { transform: translate(-50%, -50%) scale(0); opacity: 0; }
  60% { transform: translate(-50%, -50%) scale(1.4); opacity: 1; }
  100% { transform: translate(-50%, -50%) scale(1); opacity: 1; }
}

@keyframes hit-shake {
  0%, 100% { transform: translate(-50%, -50%) scale(1); }
  25% { transform: translate(-45%, -55%) scale(1.3); }
  50% { transform: translate(-55%, -45%) scale(1.2); }
  75% { transform: translate(-48%, -52%) scale(1.1); }
}

@keyframes sunk-flash {
  0%, 100% { opacity: 1; }
  50% { opacity: 0.4; }
}

/* Panel de Preparación / Colocación */
.placement-tools {
  background: var(--bg-surface);
  border: 1px solid var(--border-color);
  border-radius: var(--radius);
  padding: 14px 20px;
  display: flex;
  flex-direction: column;
  gap: 12px;
}

.placement-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.placement-header h3 {
  font-size: 0.95rem;
  font-weight: 700;
  color: var(--text-bright);
}

.ships-dock {
  display: flex;
  gap: 12px;
  flex-wrap: wrap;
}

.ship-dock-item {
  background: var(--bg-card);
  border: 1px solid var(--border-color);
  border-radius: 6px;
  padding: 8px 12px;
  cursor: pointer;
  display: flex;
  flex-direction: column;
  gap: 6px;
  transition: all 0.2s;
  min-width: 110px;
}

.ship-dock-item:hover:not(.placed) {
  border-color: var(--accent-cyan);
  background: var(--bg-card-hover);
}

.ship-dock-item.selected {
  border-color: var(--accent-cyan);
  background: rgba(0, 240, 255, 0.1);
  box-shadow: var(--glow-cyan);
}

.ship-dock-item.placed {
  opacity: 0.45;
  border-color: #2a3a5a;
  cursor: not-allowed;
}

.ship-dock-name {
  font-size: 0.8rem;
  font-weight: 600;
  display: flex;
  justify-content: space-between;
}

.ship-dock-name span {
  color: var(--text-muted);
  font-family: var(--font-mono);
}

.ship-preview-blocks {
  display: flex;
  gap: 3px;
}

.preview-block {
  width: 14px;
  height: 14px;
  background: #3e5884;
  border-radius: 2px;
}

.placement-actions {
  display: flex;
  gap: 10px;
  align-items: center;
}

/* Panel Lateral: Rastreador de Flotas & Bitácora */
.side-panel {
  display: flex;
  flex-direction: column;
  gap: 14px;
}

.side-card {
  background: var(--bg-surface);
  border: 1px solid var(--border-color);
  border-radius: var(--radius);
  padding: 14px;
  box-shadow: var(--shadow);
}

.side-card h3 {
  font-size: 0.88rem;
  font-weight: 700;
  color: var(--text-bright);
  text-transform: uppercase;
  letter-spacing: 1px;
  margin-bottom: 10px;
  display: flex;
  align-items: center;
  justify-content: space-between;
}

/* Rastreador de Barcos */
.fleet-roster {
  display: flex;
  flex-direction: column;
  gap: 8px;
}

.roster-group-title {
  font-size: 0.7rem;
  font-family: var(--font-mono);
  color: var(--text-muted);
  text-transform: uppercase;
  margin-top: 4px;
}

.roster-item {
  display: flex;
  justify-content: space-between;
  align-items: center;
  font-size: 0.78rem;
  padding: 4px 8px;
  background: var(--bg-card);
  border-radius: 4px;
  border: 1px solid #1a2742;
}

.roster-item.sunk {
  opacity: 0.4;
  text-decoration: line-through;
  border-color: var(--accent-red);
}

.roster-blocks {
  display: flex;
  gap: 3px;
}

.roster-block {
  width: 8px;
  height: 8px;
  border-radius: 1px;
  background: var(--accent-green);
}

.roster-block.hit {
  background: var(--accent-red);
}

/* Bitácora de Combate */
.combat-log {
  height: 220px;
  overflow-y: auto;
  background: #0b1120;
  border: 1px solid #18233c;
  border-radius: 6px;
  padding: 8px;
  font-family: var(--font-mono);
  font-size: 0.75rem;
  display: flex;
  flex-direction: column;
  gap: 4px;
}

.combat-log::-webkit-scrollbar {
  width: 5px;
}

.combat-log::-webkit-scrollbar-thumb {
  background: var(--border-color);
  border-radius: 4px;
}

.log-entry {
  padding: 4px 6px;
  border-radius: 3px;
  line-height: 1.3;
}

.log-entry.player-shot {
  border-left: 2px solid var(--accent-cyan);
  background: rgba(0, 240, 255, 0.05);
}

.log-entry.cpu-shot {
  border-left: 2px solid var(--accent-red);
  background: rgba(255, 51, 102, 0.05);
}

.log-entry.sunk-event {
  border-left: 2px solid var(--accent-yellow);
  background: rgba(255, 183, 3, 0.1);
  font-weight: 700;
  color: var(--accent-yellow);
}

.log-turn {
  color: var(--text-muted);
  margin-right: 4px;
}

/* Modales */
.modal-overlay {
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background: rgba(5, 8, 16, 0.85);
  backdrop-filter: blur(4px);
  display: flex;
  align-items: center;
  justify-content: center;
  z-index: 1000;
  padding: 20px;
  opacity: 0;
  pointer-events: none;
  transition: opacity 0.25s ease;
}

.modal-overlay.open {
  opacity: 1;
  pointer-events: auto;
}

.modal-container {
  background: var(--bg-surface);
  border: 1px solid var(--border-color);
  border-radius: 10px;
  width: 100%;
  max-width: 820px;
  max-height: 90vh;
  display: flex;
  flex-direction: column;
  box-shadow: 0 16px 40px rgba(0, 0, 0, 0.6);
  animation: modal-enter 0.25s ease-out;
}

@keyframes modal-enter {
  0% { transform: scale(0.95); opacity: 0; }
  100% { transform: scale(1); opacity: 1; }
}

.modal-header {
  padding: 16px 20px;
  border-bottom: 1px solid var(--border-color);
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.modal-header h3 {
  font-size: 1.15rem;
  color: var(--text-bright);
  display: flex;
  align-items: center;
  gap: 10px;
}

.modal-close {
  background: transparent;
  border: none;
  color: var(--text-muted);
  font-size: 1.3rem;
  cursor: pointer;
  line-height: 1;
}

.modal-close:hover {
  color: var(--text-bright);
}

.modal-body {
  padding: 20px;
  overflow-y: auto;
  display: flex;
  flex-direction: column;
  gap: 16px;
}

.modal-tabs {
  display: flex;
  gap: 8px;
  border-bottom: 1px solid var(--border-color);
  padding-bottom: 8px;
}

.tab-btn {
  background: transparent;
  border: none;
  color: var(--text-muted);
  font-family: var(--font-sans);
  font-size: 0.88rem;
  font-weight: 600;
  padding: 6px 14px;
  border-radius: 4px;
  cursor: pointer;
  transition: all 0.2s;
}

.tab-btn.active {
  background: var(--bg-card);
  color: var(--accent-cyan);
  border: 1px solid var(--border-color);
}

.tab-content {
  display: none;
}

.tab-content.active {
  display: flex;
  flex-direction: column;
  gap: 14px;
}

/* Auditoría de Reglas Lista */
.rules-list {
  display: flex;
  flex-direction: column;
  gap: 8px;
}

.rule-item {
  background: var(--bg-card);
  border: 1px solid var(--border-color);
  border-radius: 6px;
  padding: 10px 14px;
  display: flex;
  flex-direction: column;
  gap: 4px;
}

.rule-item.passed {
  border-left: 3px solid var(--accent-green);
}

.rule-item.failed {
  border-left: 3px solid var(--accent-red);
}

.rule-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.rule-title {
  font-size: 0.88rem;
  font-weight: 700;
  color: var(--text-bright);
}

.rule-id {
  font-family: var(--font-mono);
  font-size: 0.72rem;
  color: var(--text-muted);
}

.rule-status {
  font-family: var(--font-mono);
  font-size: 0.75rem;
  font-weight: 700;
  padding: 2px 8px;
  border-radius: 10px;
}

.rule-status.green {
  background: rgba(0, 245, 155, 0.15);
  color: var(--accent-green);
}

.rule-status.red {
  background: rgba(255, 51, 102, 0.15);
  color: var(--accent-red);
}

.rule-desc {
  font-size: 0.78rem;
  color: var(--text-muted);
}

.json-viewer {
  background: #080d19;
  border: 1px solid #16223b;
  border-radius: 6px;
  padding: 14px;
  font-family: var(--font-mono);
  font-size: 0.75rem;
  color: #a5d6a7;
  max-height: 380px;
  overflow: auto;
  white-space: pre-wrap;
  word-break: break-word;
}

.cli-instruction {
  background: var(--bg-card);
  border: 1px solid var(--border-color);
  border-radius: 6px;
  padding: 12px;
  font-size: 0.82rem;
  display: flex;
  flex-direction: column;
  gap: 6px;
}

.cli-code {
  background: #080d19;
  padding: 6px 10px;
  border-radius: 4px;
  font-family: var(--font-mono);
  color: var(--accent-cyan);
  font-size: 0.82rem;
  user-select: all;
}

.modal-footer {
  padding: 14px 20px;
  border-top: 1px solid var(--border-color);
  display: flex;
  justify-content: flex-end;
  gap: 10px;
}

/* Modal de Fin de Juego */
.gameover-modal-content {
  text-align: center;
  padding: 30px 20px;
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 16px;
}

.gameover-title {
  font-size: 2rem;
  font-weight: 900;
  text-transform: uppercase;
  letter-spacing: 2px;
}

.gameover-title.win {
  color: var(--accent-green);
  text-shadow: var(--glow-green);
}

.gameover-title.loss {
  color: var(--accent-red);
  text-shadow: var(--glow-red);
}

.gameover-stats {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  gap: 12px;
  width: 100%;
  max-width: 440px;
  margin: 10px 0;
}

.gameover-stat-box {
  background: var(--bg-card);
  padding: 10px;
  border-radius: 6px;
  border: 1px solid var(--border-color);
}

.gameover-stat-val {
  font-size: 1.3rem;
  font-weight: 800;
  font-family: var(--font-mono);
  color: var(--accent-cyan);
}

.gameover-stat-lbl {
  font-size: 0.72rem;
  color: var(--text-muted);
}

/**
 * audio.js - Sintetizador de efectos de sonido con Web Audio API
 * Genera efectos militares/navales proceduralmente sin depender de archivos de audio externos.
 */

class SoundEffects {
  constructor() {
    this.ctx = null;
    this.enabled = true;
  }

  _initContext() {
    if (!this.ctx) {
      const AudioCtx = window.AudioContext || window.webkitAudioContext;
      if (AudioCtx) {
        this.ctx = new AudioCtx();
      }
    }
    if (this.ctx && this.ctx.state === 'suspended') {
      this.ctx.resume();
    }
  }

  toggleSound() {
    this.enabled = !this.enabled;
    return this.enabled;
  }

  playSonarPing() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const t = this.ctx.currentTime;
    const osc = this.ctx.createOscillator();
    const gain = this.ctx.createGain();

    osc.type = 'sine';
    osc.frequency.setValueAtTime(800, t);
    osc.frequency.exponentialRampToValueAtTime(840, t + 0.08);
    osc.frequency.exponentialRampToValueAtTime(800, t + 0.6);

    gain.gain.setValueAtTime(0.25, t);
    gain.gain.exponentialRampToValueAtTime(0.001, t + 1.2);

    osc.connect(gain);
    gain.connect(this.ctx.destination);

    osc.start(t);
    osc.stop(t + 1.2);
  }

  playShot() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const t = this.ctx.currentTime;
    // Cañonazo: oscilador descendente + golpe
    const osc = this.ctx.createOscillator();
    const gain = this.ctx.createGain();

    osc.type = 'triangle';
    osc.frequency.setValueAtTime(180, t);
    osc.frequency.exponentialRampToValueAtTime(30, t + 0.35);

    gain.gain.setValueAtTime(0.35, t);
    gain.gain.exponentialRampToValueAtTime(0.001, t + 0.35);

    osc.connect(gain);
    gain.connect(this.ctx.destination);

    osc.start(t);
    osc.stop(t + 0.35);
  }

  playMiss() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const t = this.ctx.currentTime;
    // Chapuzón de agua (ruido blanco filtrado paso bajo)
    const bufferSize = this.ctx.sampleRate * 0.4;
    const buffer = this.ctx.createBuffer(1, bufferSize, this.ctx.sampleRate);
    const data = buffer.getChannelData(0);
    for (let i = 0; i < bufferSize; i++) {
      data[i] = (Math.random() * 2 - 1) * Math.exp(-i / (bufferSize * 0.25));
    }

    const noise = this.ctx.createBufferSource();
    noise.buffer = buffer;

    const filter = this.ctx.createBiquadFilter();
    filter.type = 'lowpass';
    filter.frequency.setValueAtTime(450, t);
    filter.frequency.linearRampToValueAtTime(150, t + 0.4);

    const gain = this.ctx.createGain();
    gain.gain.setValueAtTime(0.3, t);
    gain.gain.exponentialRampToValueAtTime(0.01, t + 0.4);

    noise.connect(filter);
    filter.connect(gain);
    gain.connect(this.ctx.destination);

    noise.start(t);
  }

  playHit() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const t = this.ctx.currentTime;
    // Explosión: ruido distorsionado + oscilador subgrave
    const osc = this.ctx.createOscillator();
    const oscGain = this.ctx.createGain();
    osc.type = 'sawtooth';
    osc.frequency.setValueAtTime(120, t);
    osc.frequency.exponentialRampToValueAtTime(25, t + 0.5);
    oscGain.gain.setValueAtTime(0.4, t);
    oscGain.gain.exponentialRampToValueAtTime(0.01, t + 0.5);

    osc.connect(oscGain);
    oscGain.connect(this.ctx.destination);
    osc.start(t);
    osc.stop(t + 0.5);

    // Ruido metálico/explosivo
    const bufferSize = this.ctx.sampleRate * 0.45;
    const buffer = this.ctx.createBuffer(1, bufferSize, this.ctx.sampleRate);
    const data = buffer.getChannelData(0);
    for (let i = 0; i < bufferSize; i++) {
      data[i] = Math.random() * 2 - 1;
    }
    const noise = this.ctx.createBufferSource();
    noise.buffer = buffer;

    const filter = this.ctx.createBiquadFilter();
    filter.type = 'bandpass';
    filter.frequency.setValueAtTime(500, t);
    filter.Q.value = 1.2;

    const noiseGain = this.ctx.createGain();
    noiseGain.gain.setValueAtTime(0.5, t);
    noiseGain.gain.exponentialRampToValueAtTime(0.01, t + 0.45);

    noise.connect(filter);
    filter.connect(noiseGain);
    noiseGain.connect(this.ctx.destination);

    noise.start(t);
  }

  playSunk() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const t = this.ctx.currentTime;
    // Alarma / bocina naval grave
    const osc1 = this.ctx.createOscillator();
    const osc2 = this.ctx.createOscillator();
    const gain = this.ctx.createGain();

    osc1.type = 'sawtooth';
    osc2.type = 'square';
    osc1.frequency.setValueAtTime(95, t);
    osc2.frequency.setValueAtTime(98, t);

    gain.gain.setValueAtTime(0.3, t);
    gain.gain.linearRampToValueAtTime(0.35, t + 0.4);
    gain.gain.exponentialRampToValueAtTime(0.001, t + 0.9);

    osc1.connect(gain);
    osc2.connect(gain);
    gain.connect(this.ctx.destination);

    osc1.start(t);
    osc2.start(t);
    osc1.stop(t + 0.9);
    osc2.stop(t + 0.9);
  }

  playVictory() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const notes = [261.63, 329.63, 392.00, 523.25]; // Do, Mi, Sol, Do agudo
    notes.forEach((freq, idx) => {
      const t = this.ctx.currentTime + idx * 0.14;
      const osc = this.ctx.createOscillator();
      const gain = this.ctx.createGain();
      osc.type = 'triangle';
      osc.frequency.setValueAtTime(freq, t);
      gain.gain.setValueAtTime(0.25, t);
      gain.gain.exponentialRampToValueAtTime(0.001, t + 0.4);
      osc.connect(gain);
      gain.connect(this.ctx.destination);
      osc.start(t);
      osc.stop(t + 0.4);
    });
  }

  playDefeat() {
    if (!this.enabled) return;
    this._initContext();
    if (!this.ctx) return;

    const notes = [392.00, 369.99, 329.63, 277.18]; // Descenso menor
    notes.forEach((freq, idx) => {
      const t = this.ctx.currentTime + idx * 0.18;
      const osc = this.ctx.createOscillator();
      const gain = this.ctx.createGain();
      osc.type = 'sawtooth';
      osc.frequency.setValueAtTime(freq, t);
      gain.gain.setValueAtTime(0.2, t);
      gain.gain.exponentialRampToValueAtTime(0.001, t + 0.45);
      osc.connect(gain);
      gain.connect(this.ctx.destination);
      osc.start(t);
      osc.stop(t + 0.45);
    });
  }
}

// Instancia global compartida
window.soundFX = new SoundEffects();

/**
 * trace.js - Recolector de evidencia relacional formal y auditor de reglas
 * Emite la traza de la partida en formato de hechos (JSON) compatible con oracle-metalenguaje.
 */

class TraceRecorder {
  constructor() {
    this.reset();
  }

  reset() {
    this.celdaBarco = [];
    this.tiros = [];
    this.partida = [];
    this._nextSegmentId = 0;
  }

  recordFleet(jugador, ships) {
    for (const ship of ships) {
      ship.coordinates.forEach((coord, idx) => {
        this.celdaBarco.push({
          id: this._nextSegmentId++,
          jugador: jugador,
          barco_id: ship.id,
          segmento_idx: idx,
          fila: coord.row,
          columna: coord.col
        });
      });
    }
  }

  recordShot(turno, tirador, receptor, fila, columna, esImpacto, hundioBarco, barcoHundido) {
    this.tiros.push({
      turno: turno,
      tirador: tirador,
      receptor: receptor,
      fila: fila,
      columna: columna,
      es_impacto: Boolean(esImpacto),
      hundio_barco: Boolean(hundioBarco),
      barco_hundido: barcoHundido || 'ninguno'
    });
  }

  recordGameOver(ganador, perdedor, impactosGanador, impactosPerdedor) {
    const finalTurn = this.tiros.length > 0 ? this.tiros[this.tiros.length - 1].turno : 0;
    this.partida = [{
      estado: 'terminada',
      ganador: ganador,
      perdedor: perdedor,
      turno_final: finalTurn,
      total_tiros: this.tiros.length,
      impactos_ganador: impactosGanador,
      impactos_perdedor: impactosPerdedor
    }];
  }

  toFactsObject() {
    return {
      celda_barco: this.celdaBarco,
      tiro: this.tiros,
      partida: this.partida.length > 0 ? this.partida : [{
        estado: 'en_curso',
        ganador: 'ninguno',
        perdedor: 'ninguno',
        turno_final: this.tiros.length > 0 ? this.tiros[this.tiros.length - 1].turno : 0,
        total_tiros: this.tiros.length,
        impactos_ganador: 0,
        impactos_perdedor: 0
      }]
    };
  }

  toJSON(indent = 2) {
    return JSON.stringify(this.toFactsObject(), null, indent);
  }

  downloadJSON(filename = 'hechos_partida.json') {
    const jsonStr = this.toJSON(2);
    const blob = new Blob([jsonStr], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = filename;
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    URL.revokeObjectURL(url);
  }

  /**
   * Auditoría espejo de las 11 medidas de Oracle evaluadas directamente en JavaScript.
   * Permite al usuario ver el veredicto formal dentro de la interfaz web además del CLI.
   */
  evaluateRules() {
    const facts = this.toFactsObject();
    const celdas = facts.celda_barco;
    const tiros = facts.tiro;
    const partida = facts.partida[0] || {};

    const results = [];

    // 1. naval.tiros_dentro_del_tablero
    const invalidShots = tiros.filter(t => t.fila < 0 || t.fila > 9 || t.columna < 0 || t.columna > 9);
    results.push({
      id: 'naval.tiros_dentro_del_tablero',
      name: 'Tiros dentro del tablero [0..9]',
      passed: invalidShots.length === 0,
      value: invalidShots.length,
      threshold: '<= 0',
      reason: 'El tablero reglamentario es de 10x10; cualquier disparo fuera de [0, 9] es inválido.',
      witnesses: invalidShots
    });

    // 2. naval.tiros_sin_repeticion
    const dupShots = [];
    for (let i = 0; i < tiros.length; i++) {
      for (let j = i + 1; j < tiros.length; j++) {
        if (tiros[i].tirador === tiros[j].tirador &&
            tiros[i].fila === tiros[j].fila &&
            tiros[i].columna === tiros[j].columna) {
          dupShots.push({ original: tiros[i], duplicado: tiros[j] });
        }
      }
    }
    results.push({
      id: 'naval.tiros_sin_repeticion',
      name: 'Sin disparos duplicados a la misma casilla',
      passed: dupShots.length === 0,
      value: dupShots.length,
      threshold: '<= 0',
      reason: 'Ningún jugador puede disparar dos veces a la misma casilla en una partida.',
      witnesses: dupShots
    });

    // 3. naval.alternancia_turnos
    const nonAlternating = [];
    for (let i = 0; i < tiros.length - 1; i++) {
      if (tiros[i + 1].turno === tiros[i].turno + 1 && tiros[i + 1].tirador === tiros[i].tirador) {
        nonAlternating.push({ turno1: tiros[i], turno2: tiros[i + 1] });
      }
    }
    results.push({
      id: 'naval.alternancia_turnos',
      name: 'Alternancia estricta de turnos',
      passed: nonAlternating.length === 0,
      value: nonAlternating.length,
      threshold: '<= 0',
      reason: 'Los turnos deben alternar estrictamente entre ambos jugadores en turnos consecutivos.',
      witnesses: nonAlternating
    });

    // 4. naval.turnos_sin_huecos
    let turnGaps = 0;
    if (tiros.length > 0) {
      const maxTurn = Math.max(...tiros.map(t => t.turno));
      if (tiros.length !== maxTurn + 1) {
        turnGaps = Math.abs(tiros.length - (maxTurn + 1));
      }
    }
    results.push({
      id: 'naval.turnos_sin_huecos',
      name: 'Turnos continuos sin huecos ni saltos',
      passed: turnGaps === 0,
      value: turnGaps,
      threshold: '<= 0',
      reason: 'La secuencia de turnos debe ser continua, arrancando en 0 y avanzando de a 1.',
      witnesses: turnGaps > 0 ? [{ tirosRegistrados: tiros.length }] : []
    });

    // 5. naval.barcos_dentro_del_tablero
    const invalidCells = celdas.filter(c => c.fila < 0 || c.fila > 9 || c.columna < 0 || c.columna > 9);
    results.push({
      id: 'naval.barcos_dentro_del_tablero',
      name: 'Barcos dentro de la cuadrícula [0..9]',
      passed: invalidCells.length === 0,
      value: invalidCells.length,
      threshold: '<= 0',
      reason: 'Todas las celdas ocupadas por barcos deben ubicarse dentro de 10x10.',
      witnesses: invalidCells
    });

    // 6. naval.barcos_sin_solapamiento
    const overlapping = [];
    for (let i = 0; i < celdas.length; i++) {
      for (let j = i + 1; j < celdas.length; j++) {
        if (celdas[i].jugador === celdas[j].jugador &&
            celdas[i].fila === celdas[j].fila &&
            celdas[i].columna === celdas[j].columna) {
          overlapping.push({ c1: celdas[i], c2: celdas[j] });
        }
      }
    }
    results.push({
      id: 'naval.barcos_sin_solapamiento',
      name: 'Barcos sin solapamiento entre sí',
      passed: overlapping.length === 0,
      value: overlapping.length,
      threshold: '<= 0',
      reason: 'Dos casillas de barco del mismo jugador no pueden coincidir en la misma celda.',
      witnesses: overlapping
    });

    // 7. naval.flota_reglamentaria
    const jugadorCeldas = celdas.filter(c => c.jugador === 'jugador').length;
    const cpuCeldas = celdas.filter(c => c.jugador === 'cpu').length;
    const flotaFlaws = [];
    if (jugadorCeldas !== 17) flotaFlaws.push({ jugador: 'jugador', celdas: jugadorCeldas, esperado: 17 });
    if (cpuCeldas !== 17) flotaFlaws.push({ jugador: 'cpu', celdas: cpuCeldas, esperado: 17 });
    results.push({
      id: 'naval.flota_reglamentaria',
      name: 'Flota reglamentaria de 17 casillas por bando',
      passed: flotaFlaws.length === 0,
      value: flotaFlaws.length,
      threshold: '<= 0',
      reason: 'Cada bando debe tener exactamente 17 casillas (5+4+3+3+2).',
      witnesses: flotaFlaws
    });

    // 8. naval.veracidad_impacto_positivo (Falso impacto / fantasma)
    const ghostHits = [];
    for (const t of tiros) {
      if (t.es_impacto) {
        const match = celdas.find(c => c.jugador === t.receptor && c.fila === t.fila && c.columna === t.columna);
        if (!match) {
          ghostHits.push(t);
        }
      }
    }
    results.push({
      id: 'naval.veracidad_impacto_positivo',
      name: 'Veracidad de impacto: ningún impacto fantasma',
      passed: ghostHits.length === 0,
      value: ghostHits.length,
      threshold: '<= 0',
      reason: 'Un disparo no puede declararse impacto si no había un segmento de barco rival.',
      witnesses: ghostHits
    });

    // 9. naval.veracidad_impacto_negativo (Agua falsa / impacto omitido)
    const falseMisses = [];
    for (const t of tiros) {
      if (!t.es_impacto) {
        const match = celdas.find(c => c.jugador === t.receptor && c.fila === t.fila && c.columna === t.columna);
        if (match) {
          falseMisses.push({ tiro: t, celdaReal: match });
        }
      }
    }
    results.push({
      id: 'naval.veracidad_impacto_negativo',
      name: 'Veracidad de agua: ningún impacto omitido',
      passed: falseMisses.length === 0,
      value: falseMisses.length,
      threshold: '<= 0',
      reason: 'Un disparo en una casilla con barco no puede ser reportado como agua.',
      witnesses: falseMisses
    });

    // 10. naval.fin_de_juego_sin_tiros_posteriores
    const postGameShots = [];
    if (partida.estado === 'terminada') {
      const finalTurn = partida.turno_final;
      for (const t of tiros) {
        if (t.turno > finalTurn) {
          postGameShots.push(t);
        }
      }
    }
    results.push({
      id: 'naval.fin_de_juego_sin_tiros_posteriores',
      name: 'Fin de partida: sin disparos posteriores',
      passed: postGameShots.length === 0,
      value: postGameShots.length,
      threshold: '<= 0',
      reason: 'Una vez finalizada la partida no se permiten más disparos.',
      witnesses: postGameShots
    });

    // 11. naval.ganador_legitimo
    let winnerValid = true;
    const winnerWitnesses = [];
    if (partida.estado === 'terminada') {
      if (partida.impactos_ganador !== 17) {
        winnerValid = false;
        winnerWitnesses.push(partida);
      }
    }
    results.push({
      id: 'naval.ganador_legitimo',
      name: 'Ganador legítimo: exactamente 17 impactos',
      passed: winnerValid,
      value: winnerValid ? 0 : 1,
      threshold: '<= 0',
      reason: 'El ganador debe haber destruido la totalidad de las 17 casillas enemigas.',
      witnesses: winnerWitnesses
    });

    return results;
  }
}

// Exportable para browser y Node
if (typeof module !== 'undefined' && module.exports) {
  module.exports = { TraceRecorder };
} else {
  window.TraceRecorder = TraceRecorder;
}

/**
 * engine.js - Lógica pura del juego de Batalla Naval
 * Diseñado para ejecutarse tanto en el navegador como en Node.js para testing y auditoría formal.
 */

const GRID_SIZE = 10;

const SHIPS_CONFIG = [
  { id: 'portaaviones', name: 'Portaaviones', length: 5 },
  { id: 'acorazado', name: 'Acorazado', length: 4 },
  { id: 'crucero', name: 'Crucero', length: 3 },
  { id: 'submarino', name: 'Submarino', length: 3 },
  { id: 'destructor', name: 'Destructor', length: 2 }
];

const TOTAL_FLEET_CELLS = SHIPS_CONFIG.reduce((acc, s) => acc + s.length, 0); // 17

class Ship {
  constructor(config) {
    this.id = config.id;
    this.name = config.name;
    this.length = config.length;
    this.row = null;
    this.col = null;
    this.orientation = 'horizontal'; // 'horizontal' | 'vertical'
    this.coordinates = [];
    this.hits = 0;
  }

  place(row, col, orientation) {
    this.row = row;
    this.col = col;
    this.orientation = orientation;
    this.coordinates = [];
    for (let i = 0; i < this.length; i++) {
      if (orientation === 'horizontal') {
        this.coordinates.push({ row: row, col: col + i });
      } else {
        this.coordinates.push({ row: row + i, col: col });
      }
    }
  }

  isSunk() {
    return this.hits >= this.length;
  }
}

class Board {
  constructor(owner) {
    this.owner = owner; // 'jugador' | 'cpu'
    this.grid = Array.from({ length: GRID_SIZE }, () =>
      Array.from({ length: GRID_SIZE }, () => ({
        ship: null,
        shot: false,
        hit: false
      }))
    );
    this.ships = [];
  }

  reset() {
    for (let r = 0; r < GRID_SIZE; r++) {
      for (let c = 0; c < GRID_SIZE; c++) {
        this.grid[r][c] = { ship: null, shot: false, hit: false };
      }
    }
    this.ships = [];
  }

  canPlaceShip(shipId, length, row, col, orientation) {
    for (let i = 0; i < length; i++) {
      const r = orientation === 'horizontal' ? row : row + i;
      const c = orientation === 'horizontal' ? col + i : col;

      // Fuera de límites
      if (r < 0 || r >= GRID_SIZE || c < 0 || c >= GRID_SIZE) {
        return false;
      }
      // Solapamiento
      if (this.grid[r][c].ship !== null) {
        return false;
      }
    }
    return true;
  }

  placeShip(ship) {
    if (!this.canPlaceShip(ship.id, ship.length, ship.row, ship.col, ship.orientation)) {
      throw new Error(`Posición inválida para ${ship.name} en (${ship.row}, ${ship.col})`);
    }

    for (const coord of ship.coordinates) {
      this.grid[coord.row][coord.col].ship = ship;
    }
    this.ships.push(ship);
    return true;
  }

  receiveShot(row, col) {
    if (row < 0 || row >= GRID_SIZE || col < 0 || col >= GRID_SIZE) {
      throw new Error(`Coordenadas de disparo (${row}, ${col}) fuera de rango`);
    }

    const cell = this.grid[row][col];
    if (cell.shot) {
      return { alreadyShot: true, hit: false, sunk: false, ship: null };
    }

    cell.shot = true;
    if (cell.ship !== null) {
      cell.hit = true;
      cell.ship.hits += 1;
      const sunk = cell.ship.isSunk();
      return {
        alreadyShot: false,
        hit: true,
        sunk: sunk,
        ship: cell.ship
      };
    } else {
      return {
        alreadyShot: false,
        hit: false,
        sunk: false,
        ship: null
      };
    }
  }

  isAllSunk() {
    return this.ships.length === SHIPS_CONFIG.length && this.ships.every(s => s.isSunk());
  }

  totalHitsReceived() {
    return this.ships.reduce((acc, s) => acc + s.hits, 0);
  }

  autoPlaceFleet() {
    this.reset();
    for (const cfg of SHIPS_CONFIG) {
      const ship = new Ship(cfg);
      let placed = false;
      let attempts = 0;
      while (!placed && attempts < 500) {
        attempts++;
        const orientation = Math.random() < 0.5 ? 'horizontal' : 'vertical';
        const maxR = orientation === 'horizontal' ? GRID_SIZE : GRID_SIZE - ship.length;
        const maxC = orientation === 'horizontal' ? GRID_SIZE - ship.length : GRID_SIZE;
        const r = Math.floor(Math.random() * maxR);
        const c = Math.floor(Math.random() * maxC);

        if (this.canPlaceShip(ship.id, ship.length, r, c, orientation)) {
          ship.place(r, c, orientation);
          this.placeShip(ship);
          placed = true;
        }
      }
      if (!placed) {
        throw new Error(`No se pudo colocar automáticamente el barco ${ship.name}`);
      }
    }
  }
}

/**
 * Inteligencia Artificial para el CPU
 * Estrategia de Caza y Blanco (Hunt and Target) con paridad matemática.
 */
class NavalAI {
  constructor() {
    this.reset();
  }

  reset() {
    this.targetQueue = []; // Cola de celdas adyacentes a impactos no hundidos
    this.currentShipHits = []; // Coordenadas de impactos del barco actual bajo ataque
  }

  getNextShot(opponentBoard) {
    // 1. Modo Blanco: si tenemos celdas candidatas prioritarias en la cola
    while (this.targetQueue.length > 0) {
      const candidate = this.targetQueue.shift();
      if (!opponentBoard.grid[candidate.row][candidate.col].shot) {
        return candidate;
      }
    }

    // 2. Modo Caza: búsqueda probabilística con paridad (celdas de tablero de ajedrez)
    // Ya que el barco más chico mide 2 casillas, alcanza con disparar a (r + c) % 2 === 0
    const parityCandidates = [];
    const otherCandidates = [];

    for (let r = 0; r < GRID_SIZE; r++) {
      for (let c = 0; c < GRID_SIZE; c++) {
        if (!opponentBoard.grid[r][c].shot) {
          if ((r + c) % 2 === 0) {
            parityCandidates.push({ row: r, col: c });
          } else {
            otherCandidates.push({ row: r, col: c });
          }
        }
      }
    }

    const pool = parityCandidates.length > 0 ? parityCandidates : otherCandidates;
    const chosenIndex = Math.floor(Math.random() * pool.length);
    return pool[chosenIndex];
  }

  recordShotResult(row, col, hit, sunk) {
    if (hit) {
      this.currentShipHits.push({ row, col });

      if (sunk) {
        // Barco destruido: limpiar objetivos del barco y volver a cazar
        this.currentShipHits = [];
        this.targetQueue = [];
      } else {
        // Agregar vecinos ortogonales válidos
        const neighbors = [
          { row: row - 1, col: col },
          { row: row + 1, col: col },
          { row: row, col: col - 1 },
          { row: row, col: col + 1 }
        ].filter(p => p.row >= 0 && p.row < GRID_SIZE && p.col >= 0 && p.col < GRID_SIZE);

        if (this.currentShipHits.length >= 2) {
          // Ya sabemos si el barco es horizontal o vertical
          const isHorizontal = this.currentShipHits[0].row === this.currentShipHits[1].row;
          const alignedNeighbors = neighbors.filter(n =>
            isHorizontal ? n.row === this.currentShipHits[0].row : n.col === this.currentShipHits[0].col
          );
          // Poner los alineados al frente de la cola
          this.targetQueue.unshift(...alignedNeighbors);
        } else {
          this.targetQueue.push(...neighbors);
        }
      }
    }
  }
}

/**
 * Gestor de la partida (GameManager)
 */
class NavalGame {
  constructor(traceRecorder) {
    this.trace = traceRecorder;
    this.playerBoard = new Board('jugador');
    this.cpuBoard = new Board('cpu');
    this.ai = new NavalAI();
    this.phase = 'placement'; // 'placement' | 'battle' | 'game_over'
    this.currentTurn = 'jugador';
    this.turnNumber = 0;
    this.winner = null;
    this.stats = {
      playerShots: 0,
      playerHits: 0,
      cpuShots: 0,
      cpuHits: 0
    };
  }

  newGame() {
    this.trace.reset();
    this.playerBoard.reset();
    this.cpuBoard.reset();
    this.ai.reset();
    this.phase = 'placement';
    this.currentTurn = 'jugador';
    this.turnNumber = 0;
    this.winner = null;
    this.stats = {
      playerShots: 0,
      playerHits: 0,
      cpuShots: 0,
      cpuHits: 0
    };

    // La CPU siempre coloca su flota automáticamente
    this.cpuBoard.autoPlaceFleet();
    this.trace.recordFleet('cpu', this.cpuBoard.ships);
  }

  startBattle() {
    if (this.playerBoard.ships.length !== SHIPS_CONFIG.length) {
      throw new Error('Debés colocar los 5 barcos antes de iniciar la batalla.');
    }
    this.trace.recordFleet('jugador', this.playerBoard.ships);
    this.phase = 'battle';
    this.currentTurn = 'jugador';
    this.turnNumber = 0;
  }

  firePlayerShot(row, col) {
    if (this.phase !== 'battle') {
      throw new Error('La partida no está en fase de batalla.');
    }
    if (this.currentTurn !== 'jugador') {
      throw new Error('No es el turno del jugador.');
    }

    const shotResult = this.cpuBoard.receiveShot(row, col);
    if (shotResult.alreadyShot) {
      return { valid: false, message: 'Casilla ya atacada previamente.' };
    }

    this.stats.playerShots++;
    if (shotResult.hit) this.stats.playerHits++;

    this.trace.recordShot(
      this.turnNumber,
      'jugador',
      'cpu',
      row,
      col,
      shotResult.hit,
      shotResult.sunk,
      shotResult.sunk ? shotResult.ship.id : 'ninguno'
    );

    this.turnNumber++;

    if (this.cpuBoard.isAllSunk()) {
      this.endGame('jugador');
      return {
        valid: true,
        hit: shotResult.hit,
        sunk: shotResult.sunk,
        ship: shotResult.ship,
        gameOver: true,
        winner: 'jugador'
      };
    }

    // Pasa turno a la CPU
    this.currentTurn = 'cpu';
    return {
      valid: true,
      hit: shotResult.hit,
      sunk: shotResult.sunk,
      ship: shotResult.ship,
      gameOver: false
    };
  }

  executeCpuTurn() {
    if (this.phase !== 'battle' || this.currentTurn !== 'cpu') {
      return null;
    }

    const shotCoords = this.ai.getNextShot(this.playerBoard);
    const shotResult = this.playerBoard.receiveShot(shotCoords.row, shotCoords.col);

    this.stats.cpuShots++;
    if (shotResult.hit) this.stats.cpuHits++;

    this.ai.recordShotResult(shotCoords.row, shotCoords.col, shotResult.hit, shotResult.sunk);

    this.trace.recordShot(
      this.turnNumber,
      'cpu',
      'jugador',
      shotCoords.row,
      shotCoords.col,
      shotResult.hit,
      shotResult.sunk,
      shotResult.sunk ? shotResult.ship.id : 'ninguno'
    );

    this.turnNumber++;

    if (this.playerBoard.isAllSunk()) {
      this.endGame('cpu');
      return {
        coords: shotCoords,
        hit: shotResult.hit,
        sunk: shotResult.sunk,
        ship: shotResult.ship,
        gameOver: true,
        winner: 'cpu'
      };
    }

    this.currentTurn = 'jugador';
    return {
      coords: shotCoords,
      hit: shotResult.hit,
      sunk: shotResult.sunk,
      ship: shotResult.ship,
      gameOver: false
    };
  }

  endGame(winner) {
    this.phase = 'game_over';
    this.winner = winner;
    const loser = winner === 'jugador' ? 'cpu' : 'jugador';
    const hitsWinner = winner === 'jugador' ? this.stats.playerHits : this.stats.cpuHits;
    const hitsLoser = winner === 'jugador' ? this.stats.cpuHits : this.stats.playerHits;

    this.trace.recordGameOver(winner, loser, hitsWinner, hitsLoser);
  }
}

// Exportable para Node y Browser
if (typeof module !== 'undefined' && module.exports) {
  module.exports = {
    GRID_SIZE,
    SHIPS_CONFIG,
    TOTAL_FLEET_CELLS,
    Ship,
    Board,
    NavalAI,
    NavalGame
  };
} else {
  window.GRID_SIZE = GRID_SIZE;
  window.SHIPS_CONFIG = SHIPS_CONFIG;
  window.TOTAL_FLEET_CELLS = TOTAL_FLEET_CELLS;
  window.Ship = Ship;
  window.Board = Board;
  window.NavalAI = NavalAI;
  window.NavalGame = NavalGame;
}

/**
 * ui.js - Interfaz de Usuario y Controlador de Eventos de Batalla Naval
 */

document.addEventListener('DOMContentLoaded', () => {
  const trace = new TraceRecorder();
  const game = new NavalGame(trace);

  // Elementos DOM
  const playerGridEl = document.getElementById('playerGrid');
  const enemyGridEl = document.getElementById('enemyGrid');
  const statusIndicator = document.getElementById('statusIndicator');
  const statusTitle = document.getElementById('statusTitle');
  const statusSubtitle = document.getElementById('statusSubtitle');
  const metricTurns = document.getElementById('metricTurns');
  const metricHits = document.getElementById('metricHits');
  const metricAccuracy = document.getElementById('metricAccuracy');
  const combatLog = document.getElementById('combatLog');

  // Herramientas de colocación
  const placementTools = document.getElementById('placementTools');
  const shipsDock = document.getElementById('shipsDock');
  const btnRotate = document.getElementById('btnRotate');
  const btnAutoPlace = document.getElementById('btnAutoPlace');
  const btnClearPlacement = document.getElementById('btnClearPlacement');
  const btnStartBattle = document.getElementById('btnStartBattle');
  const orientationBadge = document.getElementById('orientationBadge');

  // Rastreador de barcos
  const playerRoster = document.getElementById('playerRoster');
  const cpuRoster = document.getElementById('cpuRoster');

  // Modales
  const auditModal = document.getElementById('auditModal');
  const gameOverModal = document.getElementById('gameOverModal');
  const btnOpenAudit = document.getElementById('btnOpenAudit');
  const btnCloseAudit = document.getElementById('btnCloseAudit');
  const btnCloseGameOver = document.getElementById('btnCloseGameOver');
  const btnDownloadJson = document.getElementById('btnDownloadJson');
  const btnCopyJson = document.getElementById('btnCopyJson');
  const btnNewGame = document.getElementById('btnNewGame');
  const btnRestart = document.getElementById('btnRestart');
  const btnToggleSound = document.getElementById('btnToggleSound');
  const btnVerifyFromGameOver = document.getElementById('btnVerifyFromGameOver');

  // Tabs del modal de auditoría
  const tabBtns = document.querySelectorAll('.tab-btn');
  const tabContents = document.querySelectorAll('.tab-content');
  const rulesListEl = document.getElementById('rulesList');
  const jsonViewerEl = document.getElementById('jsonViewer');

  // Estado local de UI para fase de colocación
  let currentPlacementOrientation = 'horizontal'; // 'horizontal' | 'vertical'
  let selectedShipConfig = null;
  let playerPlacedShips = [];

  const ROW_LABELS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'];

  // Inicializar
  initGame();

  function initGame() {
    game.newGame();
    playerPlacedShips = [];
    selectedShipConfig = SHIPS_CONFIG[0];
    currentPlacementOrientation = 'horizontal';

    renderEmptyGrid(playerGridEl, 'player');
    renderEmptyGrid(enemyGridEl, 'enemy');
    renderDock();
    renderRosters();
    updateHUD();
    updateStatus('Fase de Despliegue', 'Ubicá tus 5 buques en el tablero o pulsá "Auto-Desplegar"', 'waiting');
    clearCombatLog();
    addLogEntry('Sistema listo. Desplegá tu flota de combate para iniciar las operaciones.', 'sunk-event');

    placementTools.style.display = 'flex';
    btnStartBattle.disabled = true;
  }

  // Renderizar Grilla con etiquetas A-J y 1-10
  function renderEmptyGrid(tableEl, type) {
    tableEl.innerHTML = '';

    // Fila de encabezado numérico (1-10)
    const headerRow = document.createElement('tr');
    const cornerCell = document.createElement('th');
    cornerCell.className = 'grid-label';
    headerRow.appendChild(cornerCell);

    for (let c = 1; c <= GRID_SIZE; c++) {
      const th = document.createElement('th');
      th.className = 'grid-label';
      th.textContent = c;
      headerRow.appendChild(th);
    }
    tableEl.appendChild(headerRow);

    // Filas A-J con casillas
    for (let r = 0; r < GRID_SIZE; r++) {
      const tr = document.createElement('tr');
      const rowLabel = document.createElement('th');
      rowLabel.className = 'grid-label-row';
      rowLabel.textContent = ROW_LABELS[r];
      tr.appendChild(rowLabel);

      for (let c = 0; c < GRID_SIZE; c++) {
        const td = document.createElement('td');
        td.className = 'grid-cell';
        td.dataset.row = r;
        td.dataset.col = c;
        td.dataset.grid = type;

        if (type === 'player') {
          td.addEventListener('mouseenter', handlePlayerCellHover);
          td.addEventListener('mouseleave', handlePlayerCellLeave);
          td.addEventListener('click', handlePlayerCellClick);
        } else {
          td.addEventListener('click', handleEnemyCellClick);
        }

        tr.appendChild(td);
      }
      tableEl.appendChild(tr);
    }
  }

  // Renderizar el Dock de selección de barcos para colocar
  function renderDock() {
    shipsDock.innerHTML = '';
    const placedIds = playerPlacedShips.map(s => s.id);

    SHIPS_CONFIG.forEach(cfg => {
      const isPlaced = placedIds.includes(cfg.id);
      const isSelected = selectedShipConfig && selectedShipConfig.id === cfg.id;

      const item = document.createElement('div');
      item.className = `ship-dock-item ${isPlaced ? 'placed' : ''} ${isSelected ? 'selected' : ''}`;
      item.dataset.shipId = cfg.id;

      const nameRow = document.createElement('div');
      nameRow.className = 'ship-dock-name';
      nameRow.innerHTML = `${cfg.name} <span>${cfg.length}</span>`;
      item.appendChild(nameRow);

      const blocks = document.createElement('div');
      blocks.className = 'ship-preview-blocks';
      for (let i = 0; i < cfg.length; i++) {
        const b = document.createElement('div');
        b.className = 'preview-block';
        blocks.appendChild(b);
      }
      item.appendChild(blocks);

      if (!isPlaced) {
        item.addEventListener('click', () => {
          selectedShipConfig = cfg;
          renderDock();
        });
      }

      shipsDock.appendChild(item);
    });

    orientationBadge.textContent = currentPlacementOrientation === 'horizontal' ? 'HORIZONTAL' : 'VERTICAL';
  }

  // Manejo de eventos de colocación en el tablero propio
  function handlePlayerCellHover(e) {
    if (game.phase !== 'placement' || !selectedShipConfig) return;
    const row = parseInt(e.target.dataset.row, 10);
    const col = parseInt(e.target.dataset.col, 10);

    clearPlacementHover();
    const canPlace = game.playerBoard.canPlaceShip(
      selectedShipConfig.id,
      selectedShipConfig.length,
      row,
      col,
      currentPlacementOrientation
    );

    for (let i = 0; i < selectedShipConfig.length; i++) {
      const r = currentPlacementOrientation === 'horizontal' ? row : row + i;
      const c = currentPlacementOrientation === 'horizontal' ? col + i : col;
      if (r < GRID_SIZE && c < GRID_SIZE) {
        const cell = playerGridEl.querySelector(`[data-row="${r}"][data-col="${c}"]`);
        if (cell) {
          cell.classList.add(canPlace ? 'placement-valid' : 'placement-invalid');
        }
      }
    }
  }

  function handlePlayerCellLeave() {
    clearPlacementHover();
  }

  function clearPlacementHover() {
    playerGridEl.querySelectorAll('.placement-valid, .placement-invalid').forEach(el => {
      el.classList.remove('placement-valid', 'placement-invalid');
    });
  }

  function handlePlayerCellClick(e) {
    if (game.phase !== 'placement' || !selectedShipConfig) return;
    const row = parseInt(e.target.dataset.row, 10);
    const col = parseInt(e.target.dataset.col, 10);

    if (game.playerBoard.canPlaceShip(selectedShipConfig.id, selectedShipConfig.length, row, col, currentPlacementOrientation)) {
      const ship = new Ship(selectedShipConfig);
      ship.place(row, col, currentPlacementOrientation);
      game.playerBoard.placeShip(ship);
      playerPlacedShips.push(ship);

      window.soundFX.playSonarPing();
      renderPlayerShips();

      // Seleccionar siguiente barco no colocado
      const placedIds = playerPlacedShips.map(s => s.id);
      selectedShipConfig = SHIPS_CONFIG.find(c => !placedIds.includes(c.id)) || null;
      renderDock();

      if (playerPlacedShips.length === SHIPS_CONFIG.length) {
        btnStartBattle.disabled = false;
        updateStatus('Flota Completa', 'Pulsá "Iniciar Batalla" para trabar combate.', 'waiting');
      }
    } else {
      window.soundFX.playMiss();
    }
  }

  function renderPlayerShips() {
    // Limpiar celdas previas de barco
    playerGridEl.querySelectorAll('.grid-cell').forEach(c => c.classList.remove('ship-present'));
    for (const ship of game.playerBoard.ships) {
      for (const coord of ship.coordinates) {
        const cell = playerGridEl.querySelector(`[data-row="${coord.row}"][data-col="${coord.col}"]`);
        if (cell) cell.classList.add('ship-present');
      }
    }
  }

  // Rotar orientación
  btnRotate.addEventListener('click', toggleOrientation);
  window.addEventListener('keydown', (e) => {
    if (e.key === 'r' || e.key === 'R') {
      toggleOrientation();
    }
  });

  function toggleOrientation() {
    currentPlacementOrientation = currentPlacementOrientation === 'horizontal' ? 'vertical' : 'horizontal';
    orientationBadge.textContent = currentPlacementOrientation === 'horizontal' ? 'HORIZONTAL' : 'VERTICAL';
    window.soundFX.playSonarPing();
  }

  // Auto-despliegue
  btnAutoPlace.addEventListener('click', () => {
    game.playerBoard.autoPlaceFleet();
    playerPlacedShips = [...game.playerBoard.ships];
    selectedShipConfig = null;
    renderPlayerShips();
    renderDock();
    btnStartBattle.disabled = false;
    window.soundFX.playSonarPing();
    updateStatus('Flota Desplegada Automáticamente', 'Todos los buques en posición. Pulsá "Iniciar Batalla"', 'waiting');
  });

  // Limpiar colocación
  btnClearPlacement.addEventListener('click', () => {
    game.playerBoard.reset();
    playerPlacedShips = [];
    selectedShipConfig = SHIPS_CONFIG[0];
    renderPlayerShips();
    renderDock();
    btnStartBattle.disabled = true;
    updateStatus('Tablero Limpio', 'Seleccioná un barco y colocalo en la cuadrícula.', 'waiting');
  });

  // Iniciar Batalla
  btnStartBattle.addEventListener('click', () => {
    try {
      game.startBattle();
      placementTools.style.display = 'none';
      document.querySelector('.enemy-card').classList.add('active-target');
      window.soundFX.playSonarPing();
      updateStatus('¡Combate Iniciado!', 'Tu turno: hacé clic en las coordenadas del radar enemigo.', 'player');
      addLogEntry('¡Bafles abiertos! Batalla iniciada. Fuego a discreción.', 'sunk-event');
      updateHUD();
      renderRosters();
    } catch (err) {
      alert(err.message);
    }
  });

  // Disparo del Jugador
  function handleEnemyCellClick(e) {
    if (game.phase !== 'battle') return;
    if (game.currentTurn !== 'jugador') return;

    const row = parseInt(e.target.dataset.row, 10);
    const col = parseInt(e.target.dataset.col, 10);
    const cellEl = e.target;

    if (cellEl.classList.contains('shot')) return;

    window.soundFX.playShot();
    const result = game.firePlayerShot(row, col);
    if (!result.valid) return;

    // Pintar celda
    cellEl.classList.add('shot');
    const coordName = `${ROW_LABELS[row]}${col + 1}`;

    if (result.hit) {
      cellEl.classList.add('hit');
      if (result.sunk) {
        window.soundFX.playSunk();
        markShipAsSunkOnGrid(enemyGridEl, result.ship);
        addLogEntry(`[T-${game.turnNumber - 1}] ¡HUNDIDO! Has destruido el ${result.ship.name} enemigo en ${coordName}!`, 'sunk-event');
      } else {
        window.soundFX.playHit();
        addLogEntry(`[T-${game.turnNumber - 1}] Jugador disparó a ${coordName}: ¡IMPACTO!`, 'player-shot');
      }
    } else {
      cellEl.classList.add('miss');
      window.soundFX.playMiss();
      addLogEntry(`[T-${game.turnNumber - 1}] Jugador disparó a ${coordName}: Agua.`, 'player-shot');
    }

    updateHUD();
    renderRosters();

    if (result.gameOver) {
      handleGameOver(result.winner);
      return;
    }

    // Turno de la CPU
    updateStatus('Turno Enemigo', 'El comandante enemigo está calculando vector de ataque...', 'cpu');
    setTimeout(() => {
      runCpuTurn();
    }, 650);
  }

  // Turno de la CPU
  function runCpuTurn() {
    if (game.phase !== 'battle' || game.currentTurn !== 'cpu') return;

    window.soundFX.playShot();
    const cpuResult = game.executeCpuTurn();
    if (!cpuResult) return;

    const { row, col } = cpuResult.coords;
    const playerCell = playerGridEl.querySelector(`[data-row="${row}"][data-col="${col}"]`);
    const coordName = `${ROW_LABELS[row]}${col + 1}`;

    playerCell.classList.add('shot');

    if (cpuResult.hit) {
      playerCell.classList.add('hit');
      if (cpuResult.sunk) {
        window.soundFX.playSunk();
        markShipAsSunkOnGrid(playerGridEl, cpuResult.ship);
        addLogEntry(`[T-${game.turnNumber - 1}] ¡ALERTA! El enemigo hundió nuestro ${cpuResult.ship.name}!`, 'sunk-event');
      } else {
        window.soundFX.playHit();
        addLogEntry(`[T-${game.turnNumber - 1}] CPU disparó a ${coordName}: ¡Impacto en nuestro casco!`, 'cpu-shot');
      }
    } else {
      playerCell.classList.add('miss');
      window.soundFX.playMiss();
      addLogEntry(`[T-${game.turnNumber - 1}] CPU disparó a ${coordName}: Agua.`, 'cpu-shot');
    }

    updateHUD();
    renderRosters();

    if (cpuResult.gameOver) {
      handleGameOver(cpuResult.winner);
      return;
    }

    updateStatus('Tu Turno', 'Elegí una coordenada en el radar enemigo para abrir fuego.', 'player');
  }

  function markShipAsSunkOnGrid(gridEl, ship) {
    for (const coord of ship.coordinates) {
      const cell = gridEl.querySelector(`[data-row="${coord.row}"][data-col="${coord.col}"]`);
      if (cell) cell.classList.add('sunk');
    }
  }

  // Fin de Juego
  function handleGameOver(winner) {
    const isPlayerWin = winner === 'jugador';
    if (isPlayerWin) {
      window.soundFX.playVictory();
      updateStatus('¡VICTORIA NAVAL!', 'Toda la flota enemiga ha sido destruida.', 'player');
      addLogEntry('¡VICTORIA TOTAL! Todos los barcos hostiles han sido enviados al fondo del mar.', 'sunk-event');
    } else {
      window.soundFX.playDefeat();
      updateStatus('DERROTA NAVAL', 'Nuestra flota ha sido completamente aniquilada.', 'cpu');
      addLogEntry('DERROTA: Hemos perdido todos nuestros navíos. Fin de las operaciones.', 'sunk-event');
    }

    document.getElementById('gameOverTitle').textContent = isPlayerWin ? '¡VICTORIA NAVAL!' : 'FLOTA HUNDIDA';
    document.getElementById('gameOverTitle').className = `gameover-title ${isPlayerWin ? 'win' : 'loss'}`;
    document.getElementById('goTurns').textContent = game.turnNumber;
    document.getElementById('goAccuracy').textContent = `${calcAccuracy(game.stats.playerHits, game.stats.playerShots)}%`;
    document.getElementById('goWinner').textContent = isPlayerWin ? 'JUGADOR' : 'CPU';

    gameOverModal.classList.add('open');
  }

  // HUD y Métricas
  function updateHUD() {
    metricTurns.textContent = game.turnNumber;
    metricHits.textContent = `${game.stats.playerHits} / 17`;
    metricAccuracy.textContent = `${calcAccuracy(game.stats.playerHits, game.stats.playerShots)}%`;
  }

  function calcAccuracy(hits, shots) {
    if (!shots || shots === 0) return 0;
    return Math.round((hits / shots) * 100);
  }

  function updateStatus(title, sub, type) {
    statusTitle.textContent = title;
    statusSubtitle.textContent = sub;
    statusIndicator.className = 'status-indicator';
    if (type === 'waiting') statusIndicator.classList.add('waiting');
    else if (type === 'cpu') statusIndicator.classList.add('cpu');
  }

  // Rosters de buques
  function renderRosters() {
    renderRosterList(playerRoster, game.playerBoard.ships, 'jugador');
    renderRosterList(cpuRoster, game.cpuBoard.ships, 'cpu');
  }

  function renderRosterList(container, ships, owner) {
    container.innerHTML = '';
    const configToDisplay = SHIPS_CONFIG;

    configToDisplay.forEach(cfg => {
      const ship = ships.find(s => s.id === cfg.id);
      const isSunk = ship ? ship.isSunk() : false;
      const hits = ship ? ship.hits : 0;

      const item = document.createElement('div');
      item.className = `roster-item ${isSunk ? 'sunk' : ''}`;

      const nameSpan = document.createElement('span');
      nameSpan.textContent = cfg.name;
      item.appendChild(nameSpan);

      const blocks = document.createElement('div');
      blocks.className = 'roster-blocks';
      for (let i = 0; i < cfg.length; i++) {
        const b = document.createElement('div');
        b.className = `roster-block ${i < hits ? 'hit' : ''}`;
        blocks.appendChild(b);
      }
      item.appendChild(blocks);
      container.appendChild(item);
    });
  }

  // Bitácora de combate
  function clearCombatLog() {
    combatLog.innerHTML = '';
  }

  function addLogEntry(msg, type = '') {
    const entry = document.createElement('div');
    entry.className = `log-entry ${type}`;
    entry.textContent = msg;
    combatLog.appendChild(entry);
    combatLog.scrollTop = combatLog.scrollHeight;
  }

  // Modal de Auditoría y Verificación
  btnOpenAudit.addEventListener('click', openAuditModal);
  btnCloseAudit.addEventListener('click', () => auditModal.classList.remove('open'));
  btnVerifyFromGameOver.addEventListener('click', () => {
    gameOverModal.classList.remove('open');
    openAuditModal();
  });

  function openAuditModal() {
    renderAuditData();
    auditModal.classList.add('open');
  }

  function renderAuditData() {
    // 1. Evaluar las 11 medidas formalmente
    const rules = trace.evaluateRules();
    rulesListEl.innerHTML = '';

    rules.forEach(r => {
      const item = document.createElement('div');
      item.className = `rule-item ${r.passed ? 'passed' : 'failed'}`;

      const header = document.createElement('div');
      header.className = 'rule-header';

      const left = document.createElement('div');
      left.innerHTML = `<div class="rule-title">${r.name}</div><div class="rule-id">${r.id}</div>`;

      const badge = document.createElement('div');
      badge.className = `rule-status ${r.passed ? 'green' : 'red'}`;
      badge.textContent = r.passed ? 'VERDE ✓' : `ROJO ✗ (${r.value})`;

      header.appendChild(left);
      header.appendChild(badge);
      item.appendChild(header);

      const desc = document.createElement('div');
      desc.className = 'rule-desc';
      desc.textContent = r.reason;
      item.appendChild(desc);

      if (!r.passed && r.witnesses.length > 0) {
        const witnessEl = document.createElement('div');
        witnessEl.style.fontSize = '0.72rem';
        witnessEl.style.color = '#ff6b8b';
        witnessEl.style.fontFamily = 'monospace';
        witnessEl.textContent = `Testigo del defecto: ${JSON.stringify(r.witnesses[0])}`;
        item.appendChild(witnessEl);
      }

      rulesListEl.appendChild(item);
    });

    // 2. Traza JSON
    jsonViewerEl.textContent = trace.toJSON(2);
  }

  // Tabs
  tabBtns.forEach(btn => {
    btn.addEventListener('click', () => {
      tabBtns.forEach(b => b.classList.remove('active'));
      tabContents.forEach(c => c.classList.remove('active'));
      btn.classList.add('active');
      const target = document.getElementById(btn.dataset.tab);
      if (target) target.classList.add('active');
    });
  });

  // Descarga y Copia de JSON
  btnDownloadJson.addEventListener('click', () => {
    trace.downloadJSON('hechos_partida.json');
  });

  btnCopyJson.addEventListener('click', () => {
    navigator.clipboard.writeText(trace.toJSON(2)).then(() => {
      btnCopyJson.textContent = '¡Copiado!';
      setTimeout(() => { btnCopyJson.textContent = 'Copiar JSON'; }, 2000);
    });
  });

  // Reiniciar / Nueva Partida
  btnNewGame.addEventListener('click', () => {
    if (confirm('¿Reiniciar y comenzar una nueva partida?')) {
      initGame();
    }
  });

  btnRestart.addEventListener('click', () => {
    gameOverModal.classList.remove('open');
    initGame();
  });

  btnCloseGameOver.addEventListener('click', () => {
    gameOverModal.classList.remove('open');
  });

  // Mute Sonido
  btnToggleSound.addEventListener('click', () => {
    const isEnabled = window.soundFX.toggleSound();
    btnToggleSound.textContent = isEnabled ? '🔊 Sonido' : '🔇 Mute';
  });
});

No. Quiere decir que anda. Jugando una vez no sabés si un barco puede quedar fuera del tablero, si dos barcos se pueden pisar, si los turnos alternan siempre o si un «¡impacto!» tenía un barco abajo. En programación, los tests son programas automáticos diseñados para verificar si otra aplicación anda bien o tiene fallas. Y si le pedís al mismo modelo que escribió el juego que también escriba los tests, los tests van a confirmar lo que el modelo ya creía.

El turno, quién tiró, a quién, en qué casilla, y si el juego lo dio por impacto. Para juzgar si ese impacto era verdad, también dónde estaba cada barco. Y para juzgar el final, quién ganó y con cuántos impactos.

Una con un barco en una casilla que no existe: por ejemplo, en la fila 10 (las filas van de 0 a 9). Escribir primero ese ejemplo te obliga a decir qué es un defecto antes de escribir cómo buscarlo.

Lo dice su alcance: no mira si dos barcos se pisan ni si un barco es una línea continua. Un verde de esta regla no promete eso. Por eso el alcance es obligatorio: un verde que no dice qué dejó sin mirar se lee como «está todo bien».

Uno verde: una partida con todos los barcos dentro, que la regla sin filtro pondría roja. Y conviene que esté en el borde (fila 9), para que también se note si alguien corre el límite.

ninguno naval.tiros_dentro_del_tablero:
    de tiro t
    donde t.fila < 0 o t.fila > 9 o t.columna < 0 o t.columna > 9
    umbral <= 0 segun contrato porque "el tablero reglamentario es de 10x10; cualquier coordenada con fila o columna fuera de [0, 9] es un tiro inválido"
    ambito universal
    alcance "comprueba que las coordenadas de cada disparo estén en el rango [0, 9]. No comprueba si el casillero ya fue disparado previamente ni la validez del turno."

medida naval.barcos_sin_solapamiento:
    de celda_barco c1
    unir celda_barco c2
    donde c1.jugador == c2.jugador y c1.id < c2.id y c1.fila == c2.fila y c1.columna == c2.columna
    resumen contar(1)
    umbral <= 0 segun contrato porque "dos casillas de barco del mismo jugador no pueden coincidir en la misma fila y columna"
    ambito universal
    alcance "detecta pares de celdas distintas del mismo jugador con id1 < id2 que colisionan en la misma coordenada. No comprueba barcos de jugadores opuestos."

medida naval.flota_reglamentaria:
    de celda_barco c
    agrupar:
        clave jugador = c.jugador
        agregado celdas = contar(1)
    donde celdas != 17
    resumen contar(1)
    umbral <= 0 segun contrato porque "la flota reglamentaria de cada jugador debe sumar exactamente 17 casillas (portaaviones 5 + acorazado 4 + crucero 3 + submarino 3 + destructor 2)"
    requiere celda_barco
    ambito universal
    alcance "agrupa las casillas de barco por jugador y exige exactamente 17 casillas por flota. No comprueba la orientación lineal de los barcos."

medida naval.alternancia_turnos:
    de tiro t1
    unir tiro t2
    donde t2.turno == t1.turno + 1 y t1.tirador == t2.tirador
    resumen contar(1)
    umbral <= 0 segun contrato porque "los turnos deben alternar estrictamente entre ambos jugadores en turnos consecutivos"
    ambito universal
    alcance "compara el tirador del turno k con el tirador del turno k+1. No valida la ausencia de saltos si falta un turno completo."

medida naval.turnos_sin_huecos:
    de tiro t
    agrupar:
        agregado registrados = contar(1)
        agregado ultimo = max(t.turno)
    donde registrados != ultimo + 1
    resumen contar(1)
    umbral <= 0 segun contrato porque "la secuencia de turnos debe ser continua, arrancando en 0 y avanzando de a 1 sin huecos ni saltos"
    requiere tiro
    ambito universal
    alcance "compara la cantidad total de tiros registrados contra el turno máximo reportado más uno. No valida la alternancia de tiradores."

medida naval.tiros_sin_repeticion:
    de tiro t1
    unir tiro t2
    donde t1.tirador == t2.tirador y t1.turno < t2.turno y t1.fila == t2.fila y t1.columna == t2.columna
    resumen contar(1)
    umbral <= 0 segun contrato porque "un jugador no puede disparar dos veces a la misma casilla en una partida"
    ambito universal
    alcance "detecta disparos repetidos del mismo jugador a la misma celda con diferente número de turno. No evalúa si el tiro fue agua o impacto."

medida naval.veracidad_impacto_positivo:
    de tiro t
    sin celda_barco c donde c.jugador == t.receptor y c.fila == t.fila y c.columna == t.columna
    donde t.es_impacto == true
    resumen contar(1)
    umbral <= 0 segun contrato porque "un disparo no puede declararse impacto si en esa casilla no había un segmento de barco rival"
    ambito universal
    alcance "detecta disparos registrados como impacto que no corresponden a ninguna celda ocupada por la flota del receptor. No verifica si el barco ya estaba completamente hundido."

medida naval.veracidad_impacto_negativo:
    de tiro t
    unir celda_barco c
    donde c.jugador == t.receptor y c.fila == t.fila y c.columna == t.columna y t.es_impacto == false
    resumen contar(1)
    umbral <= 0 segun contrato porque "un disparo en una casilla que contiene un barco no puede ser reportado como agua"
    ambito universal
    alcance "cruza cada disparo contra las celdas de la flota rival y detecta impactos omitidos registrados falsamente como agua. No verifica la secuencia de turnos."

ninguno naval.ganador_legitimo:
    de partida p
    donde p.impactos_ganador != 17
    umbral <= 0 segun contrato porque "el ganador de la partida debe haber destruido la totalidad de las 17 casillas de la flota enemiga"
    ambito universal
    alcance "comprueba que los impactos acumulados por el ganador sean exactamente 17. No valida si los tiros fueron asignados al tirador correcto."

medida naval.fin_de_juego_sin_tiros_posteriores:
    de tiro t
    unir partida p
    donde t.turno > p.turno_final
    resumen contar(1)
    umbral <= 0 segun contrato porque "una vez finalizada la partida no se permiten más disparos"
    ambito universal
    alcance "compara el turno de cada tiro contra el turno final registrado en el estado de la partida. No valida si la partida debió terminar antes."

Que la mayoría de las reglas no las prueba nadie. Una regla sin casos que puedan romperla es decoración: puede estar mal escrita y dar verde siempre, y nunca te vas a enterar.

caso 023-columna-desbordada:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "columna desbordada"
    etiqueta: falso_verde
    sintoma:
        La columna 10 está fuera del tablero.
    como_se_detecto: persona
    medida: naval.tiros_dentro_del_tablero
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 5, 10, false
    leccion:
        La columna 10 está fuera del tablero.

caso 024-fila-negativa:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "fila negativa"
    etiqueta: falso_verde
    sintoma:
        La fila negativa está fuera del tablero.
    como_se_detecto: persona
    medida: naval.tiros_dentro_del_tablero
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", -1, 5, false
    leccion:
        La fila negativa está fuera del tablero.

caso 025-columna-negativa:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "columna negativa"
    etiqueta: falso_verde
    sintoma:
        La columna negativa está fuera del tablero.
    como_se_detecto: persona
    medida: naval.tiros_dentro_del_tablero
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 5, -1, false
    leccion:
        La columna negativa está fuera del tablero.

caso 007-barcos-superpuestos:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "barcos superpuestos"
    etiqueta: falso_verde
    sintoma:
        Dos barcos del mismo jugador comparten una casilla.
    como_se_detecto: persona
    medida: naval.barcos_sin_solapamiento
    evidencia:
        celda_barco: id, jugador, fila, columna
            "a", "jugador", 3, 4
            "b", "jugador", 3, 4
    leccion:
        Dos barcos del mismo jugador comparten una casilla.

caso 008-barcos-separados:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "barcos separados"
    etiqueta: verde_correcto
    sintoma:
        Dos barcos del mismo jugador ocupan casillas distintas.
    como_se_detecto: persona
    medida: naval.barcos_sin_solapamiento
    evidencia:
        celda_barco: id, jugador, fila, columna
            "a", "jugador", 3, 4
            "b", "jugador", 3, 5
    leccion:
        Dos barcos del mismo jugador ocupan casillas distintas.

caso 011-flota-de-dieciseis:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "flota de dieciseis"
    etiqueta: falso_verde
    sintoma:
        La flota registra 16 casillas y necesita 17.
    como_se_detecto: persona
    medida: naval.flota_reglamentaria
    evidencia:
        celda_barco: id, jugador, fila, columna
            "b0", "jugador", 0, 0
            "b1", "jugador", 0, 1
            "b2", "jugador", 0, 2
            "b3", "jugador", 0, 3
            "b4", "jugador", 0, 4
            "b5", "jugador", 0, 5
            "b6", "jugador", 0, 6
            "b7", "jugador", 0, 7
            "b8", "jugador", 0, 8
            "b9", "jugador", 0, 9
            "b10", "jugador", 1, 0
            "b11", "jugador", 1, 1
            "b12", "jugador", 1, 2
            "b13", "jugador", 1, 3
            "b14", "jugador", 1, 4
            "b15", "jugador", 1, 5
    leccion:
        La flota registra 16 casillas y necesita 17.

caso 012-flota-de-diecisiete:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "flota de diecisiete"
    etiqueta: verde_correcto
    sintoma:
        La flota registra exactamente 17 casillas.
    como_se_detecto: persona
    medida: naval.flota_reglamentaria
    evidencia:
        celda_barco: id, jugador, fila, columna
            "b0", "jugador", 0, 0
            "b1", "jugador", 0, 1
            "b2", "jugador", 0, 2
            "b3", "jugador", 0, 3
            "b4", "jugador", 0, 4
            "b5", "jugador", 0, 5
            "b6", "jugador", 0, 6
            "b7", "jugador", 0, 7
            "b8", "jugador", 0, 8
            "b9", "jugador", 0, 9
            "b10", "jugador", 1, 0
            "b11", "jugador", 1, 1
            "b12", "jugador", 1, 2
            "b13", "jugador", 1, 3
            "b14", "jugador", 1, 4
            "b15", "jugador", 1, 5
            "b16", "jugador", 1, 6
    leccion:
        La flota registra exactamente 17 casillas.

caso 029-flota-sin-celdas:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "flota sin celdas"
    etiqueta: falso_verde
    espera: sin_evidencia
    sintoma:
        Sin ninguna celda de barco no se puede declarar reglamentaria la flota.
    como_se_detecto: persona
    medida: naval.flota_reglamentaria
    evidencia:
        celda_barco:
    leccion:
        Sin ninguna celda de barco no se puede declarar reglamentaria la flota.

caso 003-mismo-tirador-seguido:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "mismo tirador seguido"
    etiqueta: falso_verde
    sintoma:
        Dos turnos consecutivos pertenecen al mismo tirador.
    como_se_detecto: persona
    medida: naval.alternancia_turnos
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 1, 1, false
            1, "jugador", "cpu", 2, 2, false
    leccion:
        Dos turnos consecutivos pertenecen al mismo tirador.

caso 004-tiradores-alternos:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "tiradores alternos"
    etiqueta: verde_correcto
    sintoma:
        Los turnos consecutivos cambian de tirador.
    como_se_detecto: persona
    medida: naval.alternancia_turnos
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 1, 1, false
            1, "cpu", "jugador", 2, 2, false
    leccion:
        Los turnos consecutivos cambian de tirador.

caso 017-turno-saltado:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "turno saltado"
    etiqueta: falso_verde
    sintoma:
        La secuencia salta el turno 1.
    como_se_detecto: persona
    medida: naval.turnos_sin_huecos
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 1, 1, false
            2, "cpu", "jugador", 2, 2, false
    leccion:
        La secuencia salta el turno 1.

caso 018-turnos-contiguos:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "turnos contiguos"
    etiqueta: verde_correcto
    sintoma:
        La secuencia comienza en 0 y no tiene huecos.
    como_se_detecto: persona
    medida: naval.turnos_sin_huecos
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 1, 1, false
            1, "cpu", "jugador", 2, 2, false
    leccion:
        La secuencia comienza en 0 y no tiene huecos.

caso 030-sin-tiros-registrados:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "sin tiros registrados"
    etiqueta: falso_verde
    espera: sin_evidencia
    sintoma:
        Sin tiros registrados no se puede afirmar continuidad de turnos.
    como_se_detecto: persona
    medida: naval.turnos_sin_huecos
    evidencia:
        tiro:
    leccion:
        Sin tiros registrados no se puede afirmar continuidad de turnos.

caso 015-tiro-repetido:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "tiro repetido"
    etiqueta: falso_verde
    sintoma:
        El mismo tirador repite la misma casilla.
    como_se_detecto: persona
    medida: naval.tiros_sin_repeticion
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, false
            2, "jugador", "cpu", 2, 3, false
    leccion:
        El mismo tirador repite la misma casilla.

caso 016-tiros-distintos:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "tiros distintos"
    etiqueta: verde_correcto
    sintoma:
        El mismo tirador elige dos casillas distintas.
    como_se_detecto: persona
    medida: naval.tiros_sin_repeticion
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, false
            2, "jugador", "cpu", 2, 4, false
    leccion:
        El mismo tirador elige dos casillas distintas.

caso 031-distinta-fila-igual-turno-ajeno:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "distinta fila igual turno ajeno"
    etiqueta: verde_correcto
    sintoma:
        La fila cambia aunque coincida con el número de turno previo.
    como_se_detecto: persona
    medida: naval.tiros_sin_repeticion
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 1, 3, false
            2, "jugador", "cpu", 0, 3, false
    leccion:
        La fila cambia aunque coincida con el número de turno previo.

caso 033-fila-confundida-con-turno:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "fila confundida con turno"
    etiqueta: verde_correcto
    sintoma:
        La fila del primer tiro coincide con el turno del segundo, pero las casillas son distintas.
    como_se_detecto: persona
    medida: naval.tiros_sin_repeticion
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, false
            2, "jugador", "cpu", 3, 3, false
    leccion:
        La fila del primer tiro coincide con el turno del segundo, pero las casillas son distintas.

caso 021-impacto-fantasma:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "impacto fantasma"
    etiqueta: falso_verde
    sintoma:
        El disparo se declara impacto sin barco rival en la casilla.
    como_se_detecto: persona
    medida: naval.veracidad_impacto_positivo
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, true
        celda_barco: id, jugador, fila, columna
            "a", "cpu", 2, 4
    leccion:
        El disparo se declara impacto sin barco rival en la casilla.

caso 022-impacto-real:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "impacto real"
    etiqueta: verde_correcto
    sintoma:
        El impacto declarado coincide con un barco rival.
    como_se_detecto: persona
    medida: naval.veracidad_impacto_positivo
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, true
        celda_barco: id, jugador, fila, columna
            "a", "cpu", 2, 3
    leccion:
        El impacto declarado coincide con un barco rival.

caso 032-agua-declarada-agua:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "agua declarada agua"
    etiqueta: verde_correcto
    sintoma:
        Una casilla de agua declarada agua no es impacto fantasma.
    como_se_detecto: persona
    medida: naval.veracidad_impacto_positivo
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, false
        celda_barco: id, jugador, fila, columna
            "a", "cpu", 2, 4
    leccion:
        Una casilla de agua declarada agua no es impacto fantasma.

caso 019-barco-reportado-como-agua:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "barco reportado como agua"
    etiqueta: falso_verde
    sintoma:
        El disparo toca un barco rival y se registra como agua.
    como_se_detecto: persona
    medida: naval.veracidad_impacto_negativo
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, false
        celda_barco: id, jugador, fila, columna
            "a", "cpu", 2, 3
    leccion:
        El disparo toca un barco rival y se registra como agua.

caso 020-agua-reportada-como-agua:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "agua reportada como agua"
    etiqueta: verde_correcto
    sintoma:
        El disparo cae en agua y se registra como agua.
    como_se_detecto: persona
    medida: naval.veracidad_impacto_negativo
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            0, "jugador", "cpu", 2, 3, false
        celda_barco: id, jugador, fila, columna
            "a", "cpu", 2, 4
    leccion:
        El disparo cae en agua y se registra como agua.

caso 013-ganador-con-dieciseis-impactos:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "ganador con dieciseis impactos"
    etiqueta: falso_verde
    sintoma:
        El ganador sólo acumuló 16 impactos.
    como_se_detecto: persona
    medida: naval.ganador_legitimo
    evidencia:
        partida: turno_final, impactos_ganador
            30, 16
    leccion:
        El ganador sólo acumuló 16 impactos.

caso 014-ganador-con-diecisiete-impactos:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "ganador con diecisiete impactos"
    etiqueta: verde_correcto
    sintoma:
        El ganador acumuló los 17 impactos exigidos.
    como_se_detecto: persona
    medida: naval.ganador_legitimo
    evidencia:
        partida: turno_final, impactos_ganador
            30, 17
    leccion:
        El ganador acumuló los 17 impactos exigidos.

caso 009-tiro-despues-del-final:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "tiro despues del final"
    etiqueta: falso_verde
    sintoma:
        El turno del tiro supera el turno final.
    como_se_detecto: persona
    medida: naval.fin_de_juego_sin_tiros_posteriores
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            5, "jugador", "cpu", 1, 1, false
        partida: turno_final, impactos_ganador
            4, 17
    leccion:
        El turno del tiro supera el turno final.

caso 010-tiro-en-turno-final:
    fecha: "2026-09-25"
    origen:
        repo: "ejemplo/batalla-naval"
        commit: "sin-commit"
    procedencia: construida
    titulo: "tiro en turno final"
    etiqueta: verde_correcto
    sintoma:
        El tiro ocurre en el turno final permitido.
    como_se_detecto: persona
    medida: naval.fin_de_juego_sin_tiros_posteriores
    evidencia:
        tiro: turno, tirador, receptor, fila, columna, es_impacto
            4, "jugador", "cpu", 1, 1, false
        partida: turno_final, impactos_ganador
            4, 17
    leccion:
        El tiro ocurre en el turno final permitido.

{
  "celda_barco": [
    {
      "id": 0,
      "jugador": "cpu",
      "barco_id": "portaaviones",
      "segmento_idx": 0,
      "fila": 3,
      "columna": 0
    },
    {
      "id": 1,
      "jugador": "cpu",
      "barco_id": "portaaviones",
      "segmento_idx": 1,
      "fila": 4,
      "columna": 0
    },
    {
      "id": 2,
      "jugador": "cpu",
      "barco_id": "portaaviones",
      "segmento_idx": 2,
      "fila": 5,
      "columna": 0
    },
    {
      "id": 3,
      "jugador": "cpu",
      "barco_id": "portaaviones",
      "segmento_idx": 3,
      "fila": 6,
      "columna": 0
    },
    {
      "id": 4,
      "jugador": "cpu",
      "barco_id": "portaaviones",
      "segmento_idx": 4,
      "fila": 7,
      "columna": 0
    },
    {
      "id": 5,
      "jugador": "cpu",
      "barco_id": "acorazado",
      "segmento_idx": 0,
      "fila": 0,
      "columna": 9
    },
    {
      "id": 6,
      "jugador": "cpu",
      "barco_id": "acorazado",
      "segmento_idx": 1,
      "fila": 1,
      "columna": 9
    },
    {
      "id": 7,
      "jugador": "cpu",
      "barco_id": "acorazado",
      "segmento_idx": 2,
      "fila": 2,
      "columna": 9
    },
    {
      "id": 8,
      "jugador": "cpu",
      "barco_id": "acorazado",
      "segmento_idx": 3,
      "fila": 3,
      "columna": 9
    },
    {
      "id": 9,
      "jugador": "cpu",
      "barco_id": "crucero",
      "segmento_idx": 0,
      "fila": 3,
      "columna": 7
    },
    {
      "id": 10,
      "jugador": "cpu",
      "barco_id": "crucero",
      "segmento_idx": 1,
      "fila": 4,
      "columna": 7
    },
    {
      "id": 11,
      "jugador": "cpu",
      "barco_id": "crucero",
      "segmento_idx": 2,
      "fila": 5,
      "columna": 7
    },
    {
      "id": 12,
      "jugador": "cpu",
      "barco_id": "submarino",
      "segmento_idx": 0,
      "fila": 1,
      "columna": 2
    },
    {
      "id": 13,
      "jugador": "cpu",
      "barco_id": "submarino",
      "segmento_idx": 1,
      "fila": 1,
      "columna": 3
    },
    {
      "id": 14,
      "jugador": "cpu",
      "barco_id": "submarino",
      "segmento_idx": 2,
      "fila": 1,
      "columna": 4
    },
    {
      "id": 15,
      "jugador": "cpu",
      "barco_id": "destructor",
      "segmento_idx": 0,
      "fila": 1,
      "columna": 6
    },
    {
      "id": 16,
      "jugador": "cpu",
      "barco_id": "destructor",
      "segmento_idx": 1,
      "fila": 2,
      "columna": 6
    },
    {
      "id": 17,
      "jugador": "jugador",
      "barco_id": "portaaviones",
      "segmento_idx": 0,
      "fila": 9,
      "columna": 2
    },
    {
      "id": 18,
      "jugador": "jugador",
      "barco_id": "portaaviones",
      "segmento_idx": 1,
      "fila": 9,
      "columna": 3
    },
    {
      "id": 19,
      "jugador": "jugador",
      "barco_id": "portaaviones",
      "segmento_idx": 2,
      "fila": 9,
      "columna": 4
    },
    {
      "id": 20,
      "jugador": "jugador",
      "barco_id": "portaaviones",
      "segmento_idx": 3,
      "fila": 9,
      "columna": 5
    },
    {
      "id": 21,
      "jugador": "jugador",
      "barco_id": "portaaviones",
      "segmento_idx": 4,
      "fila": 9,
      "columna": 6
    },
    {
      "id": 22,
      "jugador": "jugador",
      "barco_id": "acorazado",
      "segmento_idx": 0,
      "fila": 7,
      "columna": 5
    },
    {
      "id": 23,
      "jugador": "jugador",
      "barco_id": "acorazado",
      "segmento_idx": 1,
      "fila": 7,
      "columna": 6
    },
    {
      "id": 24,
      "jugador": "jugador",
      "barco_id": "acorazado",
      "segmento_idx": 2,
      "fila": 7,
      "columna": 7
    },
    {
      "id": 25,
      "jugador": "jugador",
      "barco_id": "acorazado",
      "segmento_idx": 3,
      "fila": 7,
      "columna": 8
    },
    {
      "id": 26,
      "jugador": "jugador",
      "barco_id": "crucero",
      "segmento_idx": 0,
      "fila": 8,
      "columna": 1
    },
    {
      "id": 27,
      "jugador": "jugador",
      "barco_id": "crucero",
      "segmento_idx": 1,
      "fila": 8,
      "columna": 2
    },
    {
      "id": 28,
      "jugador": "jugador",
      "barco_id": "crucero",
      "segmento_idx": 2,
      "fila": 8,
      "columna": 3
    },
    {
      "id": 29,
      "jugador": "jugador",
      "barco_id": "submarino",
      "segmento_idx": 0,
      "fila": 4,
      "columna": 4
    },
    {
      "id": 30,
      "jugador": "jugador",
      "barco_id": "submarino",
      "segmento_idx": 1,
      "fila": 4,
      "columna": 5
    },
    {
      "id": 31,
      "jugador": "jugador",
      "barco_id": "submarino",
      "segmento_idx": 2,
      "fila": 4,
      "columna": 6
    },
    {
      "id": 32,
      "jugador": "jugador",
      "barco_id": "destructor",
      "segmento_idx": 0,
      "fila": 1,
      "columna": 8
    },
    {
      "id": 33,
      "jugador": "jugador",
      "barco_id": "destructor",
      "segmento_idx": 1,
      "fila": 2,
      "columna": 8
    }
  ],
  "tiro": [
    {
      "turno": 0,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 1,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 5,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 2,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 3,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 3,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 3,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 4,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 6,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 5,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 6,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 6,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 7,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 8,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 9,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 1,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 10,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 11,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 0,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 12,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 5,
      "columna": 0,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 13,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 14,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 3,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 15,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 4,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 16,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 17,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 3,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 18,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 0,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 19,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 5,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 20,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 21,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 22,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 23,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 5,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 24,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 25,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 6,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "submarino"
    },
    {
      "turno": 26,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 3,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 27,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 28,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 29,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 5,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 30,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 31,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 6,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 32,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 5,
      "columna": 7,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 33,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 0,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 34,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 35,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 7,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 36,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 3,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 37,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 6,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 38,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 4,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 39,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 40,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 7,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 41,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 6,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 42,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 6,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "destructor"
    },
    {
      "turno": 43,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 5,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 44,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 45,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 46,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 9,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 47,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 8,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "acorazado"
    },
    {
      "turno": 48,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 49,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 3,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 50,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 51,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 52,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 53,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 54,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 55,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 2,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 56,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 57,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 3,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 58,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 3,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 59,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 2,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 60,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 5,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 61,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 62,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 5,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 63,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 0,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 64,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 65,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 1,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 66,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 67,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 2,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 68,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 9,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 69,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 70,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 9,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 71,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 2,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 72,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 0,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 73,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 1,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 74,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 7,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 75,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 3,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "crucero"
    },
    {
      "turno": 76,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 0,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 77,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 3,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 78,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 2,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 79,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 5,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 80,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 81,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 6,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 82,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 0,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 83,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 84,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 85,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 1,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 86,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 0,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 87,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 8,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 88,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 9,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 89,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 2,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 90,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 7,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 91,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 1,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 92,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 9,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 93,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 6,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 94,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 5,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 95,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 96,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 0,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 97,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 7,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 98,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 7,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 99,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 0,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 100,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 5,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 101,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 2,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 102,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 9,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 103,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 3,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 104,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 8,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 105,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 4,
      "columna": 0,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 106,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 107,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 1,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 108,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 0,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 109,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 5,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 110,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 7,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 111,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 6,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 112,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 113,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 7,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 114,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 1,
      "columna": 2,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "submarino"
    },
    {
      "turno": 115,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 3,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 116,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 9,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 117,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 4,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 118,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 7,
      "columna": 4,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 119,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 5,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 120,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 3,
      "columna": 3,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 121,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 6,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "portaaviones"
    },
    {
      "turno": 122,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 6,
      "columna": 2,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 123,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 9,
      "columna": 1,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 124,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 8,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 125,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 0,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 126,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 4,
      "columna": 6,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 127,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 2,
      "columna": 8,
      "es_impacto": true,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 128,
      "tirador": "jugador",
      "receptor": "cpu",
      "fila": 0,
      "columna": 5,
      "es_impacto": false,
      "hundio_barco": false,
      "barco_hundido": "ninguno"
    },
    {
      "turno": 129,
      "tirador": "cpu",
      "receptor": "jugador",
      "fila": 1,
      "columna": 8,
      "es_impacto": true,
      "hundio_barco": true,
      "barco_hundido": "destructor"
    }
  ],
  "partida": [
    {
      "estado": "terminada",
      "ganador": "cpu",
      "perdedor": "jugador",
      "turno_final": 129,
      "total_tiros": 130,
      "impactos_ganador": 17,
      "impactos_perdedor": 12
    }
  ]
}

Quiere decir que esas once reglas se cumplieron en esta partida. La lista SIN MIRAR dice lo que ninguna regla garantiza, por ejemplo que cada barco sea una línea recta. Esa lista no es letra chica: es la mitad de la respuesta.

requisito naval.flota:
    texto "Las flotas ocupan 17 casillas por bando, dentro del tablero y sin solaparse"
    medido_por naval.barcos_dentro_del_tablero, naval.barcos_sin_solapamiento, naval.flota_reglamentaria
    sin_medir "la forma recta y continua de cada barco"

requisito naval.disparos:
    texto "Cada tirador dispara a casillas válidas y no repite una coordenada"
    medido_por naval.tiros_dentro_del_tablero, naval.tiros_sin_repeticion

requisito naval.turnos:
    texto "Los tiros se registran sin huecos y alternan entre los jugadores"
    medido_por naval.alternancia_turnos, naval.turnos_sin_huecos

requisito naval.impactos:
    texto "Un impacto reportado corresponde a un barco rival y un tiro al barco no figura como agua"
    medido_por naval.veracidad_impacto_negativo, naval.veracidad_impacto_positivo

requisito naval.final:
    texto "El ganador registra 17 impactos y no se dispara después del turno final"
    medido_por naval.fin_de_juego_sin_tiros_posteriores, naval.ganador_legitimo

requisito naval.barcos_rectos:
    texto "Cada barco ocupa una línea recta y continua"
    sin_medir "todavía no hay una medida para comprobar la forma de cada barco"

Todavía no. oracle cobertura muestra qué promesas tienen medidas; con --con juzga los hechos de esta partida y dice cuáles se cumplieron. Una promesa puede quedar sólo en parte medida.

Las reglas de tiros no tendrían nada que mirar. Un sistema descuidado las daría por buenas; Oracle las lista aparte, en NO SE APLICARON, y falla la corrida completa. Si ejecutás sólo una parte del catálogo a propósito, --parcial permite esa omisión. Probalo:

Git guarda el antes; oracle cambios revisa el después. Un límite más permisivo con el mismo porque es un error aunque el resto del catálogo siga igual.

# Batalla Naval en HTML5 con Auditoría Formal

Juego táctico de **Batalla Naval (Battleship)** en HTML5/CSS3/JavaScript con verificación formal de reglas mediante **Oracle** (`oracle-metalenguaje`).

---

## 1. Cómo jugar

Podés abrir [`index.html`](index.html) directamente en cualquier navegador moderno:

```bash
# Podés abrirlo con xdg-open o con un servidor web local:
xdg-open index.html
# o
python3 -m http.server 8080
```

### Características del juego:
- **Tableros 10x10** reglamentarios (filas A–J, columnas 1–10).
- **Flota estándar de 5 navíos** (17 casillas en total):
  - Portaaviones (5 casillas)
  - Acorazado (4 casillas)
  - Crucero (3 casillas)
  - Submarino (3 casillas)
  - Destructor (2 casillas)
- **Fase de Despliegue**: colocación interactiva de buques, rotación horizontal/vertical con tecla `R` o botón, o botón **"🎲 Auto-Desplegar"** para despliegue rápido.
- **Fase de Batalla**: radar hostil interactivo con retícula táctica, efectos sonoros sintetizados proceduralmente vía **Web Audio API** (cañonazos, salpicaduras de agua, explosiones, sirenas navales), animaciones de impacto y bitácora cronológica de combate.
- **Inteligencia Artificial**: CPU con estrategia de Caza y Blanco (*Hunt & Target*) y búsqueda con paridad de tablero.
- **Panel de Auditoría integrado**: botón **"⚖ Auditoría & Traza Oracle"** para ver el estado de las reglas en vivo, inspeccionar el JSON de hechos relacionales y descargarlo para auditarlo en terminal.

---

## 2. ¿Cómo comprobamos que las reglas se cumplen de verdad?

Para no depender de afirmaciones de confianza ("funciona porque yo lo digo") ni de aserciones atrapadas dentro del mismo código que ejecuta el juego (que podrían compartir los mismos sesgos y errores lógicos), implementamos una **separación estricta entre ejecución y juicio**:

1. **El juego actúa como sensor fáctico puro**: Durante la partida no se valida a sí mismo; en cambio, emite una **traza relacional inmutable de hechos objetivos**:
   - `celda_barco`: qué casillas `(fila, columna)` ocupa cada buque de cada jugador.
   - `tiro`: la secuencia ordenada de disparos `(turno, tirador, receptor, fila, columna, es_impacto, hundio_barco)`.
   - `partida`: el resultado final `(estado, ganador, perdedor, turno_final, total_tiros, impactos_ganador, impactos_perdedor)`.
2. **Oracle actúa como juez formal externo**: Un catálogo declarativo de 11 medidas en lenguaje Oracle evalúa la evidencia relacional de forma independiente.

---

## 3. ¿Por qué usamos `oracle-metalenguaje`?

Elegimos usar `oracle-metalenguaje` por cuatro razones metodológicas fundamentales:

1. **Independencia del evaluador (Desacoplamiento)**:
   Si las pruebas se limitan a `assert` dentro de JavaScript, cualquier error conceptual en el diseño del modelo suele propagarse al verificador. Oracle corre fuera del runtime de JavaScript, evaluando únicamente la evidencia relacional sin conocer las estructuras de datos internas del juego.
2. **Declaratividad y álgebra relacional**:
   En vez de escribir bucles imperativos con estados mutables, las reglas se declaran mediante álgebra relacional pura (`de`, `unir`, `sin`, `donde`, `agrupar`, `resumen contar(1)`, `umbral <= 0`).
3. **Honestidad epistémica (`alcance` y `porque`)**:
   En Oracle cada medida declara explícitamente su justificación contractual (`porque`) y lo que **NO** mira (`alcance`). Un veredicto verde no oculta supuestos invisibles.
4. **Auditabilidad directa para el usuario**:
   Cualquier jugador puede descargar el archivo `hechos_partida.json` desde la interfaz web o desde el script y ejecutar directamente:
   ```bash
   oracle juzgar --con hechos_partida.json
   ```
   obteniendo un informe matemático con veredicto, umbrales y testigos.

---

## 4. Las 11 Reglas Formalizadas en el Catálogo

Las medidas se encuentran en el directorio [`catalogos/naval/`](catalogos/naval/):

| Medida | Qué verifica |
| :--- | :--- |
| `naval.tiros_dentro_del_tablero` | Ningún disparo tiene coordenadas fuera de $[0, 9] \times [0, 9]$. |
| `naval.tiros_sin_repeticion` | Ningún jugador dispara más de una vez a la misma casilla. |
| `naval.alternancia_turnos` | Los turnos consecutivos alternan estrictamente entre `jugador` y `cpu`. |
| `naval.turnos_sin_huecos` | La secuencia de turnos es monótona y continua desde $0$ hasta $N-1$ sin saltos ni pérdidas. |
| `naval.barcos_dentro_del_tablero` | Todas las casillas ocupadas por buques pertenecen a la cuadrícula de $10 \times 10$. |
| `naval.barcos_sin_solapamiento` | Dos buques del mismo bando no pueden compartir casillas. |
| `naval.flota_reglamentaria` | Cada bando cuenta con exactamente 17 casillas de barco ($5 + 4 + 3 + 3 + 2$). |
| `naval.veracidad_impacto_positivo` | Un disparo reportado como impacto debe tener un barco rival en esa coordenada (prohíbe impactos fantasma). |
| `naval.veracidad_impacto_negativo` | Un disparo en una celda donde hay un barco rival no puede ser reportado como agua (prohíbe impactos omitidos). |
| `naval.fin_de_juego_sin_tiros_posteriores` | No se registran disparos con turno posterior a la finalización de la partida. |
| `naval.ganador_legitimo` | El bando declarado ganador acumula exactamente 17 impactos (destrucción total de la flota rival). |

---

## 5. Demostración práctica y Falsabilidad

Para comprobar que el oráculo funciona y **no es complaciente** (es decir, que sabe ponerse en **ROJO** cuando se rompen las reglas), creamos el script [`verificar_oraculo.py`](verificar_oraculo.py):

```bash
python3 verificar_oraculo.py
```

En Windows, si `python3` no se reconoce, usá `python verificar_oraculo.py`.
El script busca `partida_real.json` (incluido en el ejemplo del repositorio). Si no lo encuentra,
lee `hechos_partida.json`, el nombre que usa la guía y que descarga el juego. No hace falta renombrarlo.

El script realiza:
1. **Partida real guardada**: lee el archivo de partida y ejecuta `oracle juzgar`, confirmando **VEREDICTO: verde en 11 medidas**.
2. **Inyección de infracciones (contraejemplos)**:
   - Inyecta un disparo duplicado $\rightarrow$ Atrapado por `naval.tiros_sin_repeticion` (ROJO).
   - Inyecta un disparo en fila 14 $\rightarrow$ Atrapado por `naval.tiros_dentro_del_tablero` (ROJO).
   - Inyecta un impacto fantasma en agua $\rightarrow$ Atrapado por `naval.veracidad_impacto_positivo` (ROJO).
   - Inyecta turnos consecutivos del mismo tirador $\rightarrow$ Atrapado por `naval.alternancia_turnos` (ROJO).

### Cómo juzgar cualquier partida manualmente:
```bash
oracle juzgar --con partida_real.json
```
Salida esperada:
```
✓ naval.alternancia_turnos                            0 (<= 0)
✓ naval.barcos_dentro_del_tablero                     0 (<= 0)
✓ naval.barcos_sin_solapamiento                       0 (<= 0)
✓ naval.fin_de_juego_sin_tiros_posteriores            0 (<= 0)
✓ naval.flota_reglamentaria                           0 (<= 0)
✓ naval.ganador_legitimo                              0 (<= 0)
✓ naval.tiros_dentro_del_tablero                      0 (<= 0)
✓ naval.tiros_sin_repeticion                          0 (<= 0)
✓ naval.turnos_sin_huecos                             0 (<= 0)
✓ naval.veracidad_impacto_negativo                    0 (<= 0)
✓ naval.veracidad_impacto_positivo                    0 (<= 0)

VEREDICTO: verde en 11 medidas.
```

#!/usr/bin/env python3
"""
verificar_oraculo.py - Demostración de verificación rigurosa de reglas con Oracle

Este script:
1. Lee 'partida_real.json' o, en la carpeta armada con la guía, 'hechos_partida.json'.
2. Ejecuta `oracle juzgar --con <partida>` para comprobar que las 11 reglas se cumplen (VERDE).
4. Genera variantes con infracciones deliberadas (trampas/errores) para demostrar
   que el oráculo es falsable y no un sello complaciente:
   a) Disparo duplicado a la misma celda.
   b) Disparo fuera de los límites del tablero (fila 10).
   c) Impacto fantasma (mentir diciendo que dio en un barco cuando era agua).
   d) Turnos consecutivos del mismo tirador sin alternar.
   e) Disparo posterior al fin de la partida.
   f) Ganador ilegítimo (con menos de 17 impactos).
"""

import copy
import json
import subprocess
import sys
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent
CLI = BASE_DIR.parents[1] / "tools" / "cli.py"


def simular_partida():
    """Ejecuta una partida automática usando el motor del juego en Node.js."""
    script = """
    const { TraceRecorder } = require("./js/trace.js");
    const { NavalGame } = require("./js/engine.js");

    const trace = new TraceRecorder();
    const game = new NavalGame(trace);
    game.newGame();
    game.playerBoard.autoPlaceFleet();
    game.startBattle();

    while (game.phase === "battle") {
      if (game.currentTurn === "jugador") {
        const unshot = [];
        for (let r = 0; r < 10; r++) {
          for (let c = 0; c < 10; c++) {
            if (!game.cpuBoard.grid[r][c].shot) unshot.push({ r, c });
          }
        }
        const target = unshot[Math.floor(Math.random() * unshot.length)];
        game.firePlayerShot(target.r, target.c);
      } else {
        game.executeCpuTurn();
      }
    }
    console.log(trace.toJSON(2));
    """
    res = subprocess.run(
        ["node", "-e", script],
        cwd=BASE_DIR,
        capture_output=True,
        text=True,
        check=True
    )
    return json.loads(res.stdout)


def ejecutar_oracle_juzgar(ruta_json):
    """Ejecuta `oracle juzgar --con <ruta_json>` y retorna (codigo, salida)."""
    comando = [sys.executable, str(CLI)] if CLI.is_file() else ["oracle"]
    res = subprocess.run(
        [*comando, "juzgar", "--proyecto", str(BASE_DIR),
         "--con", str(ruta_json)],
        cwd=BASE_DIR,
        capture_output=True,
        text=True
    )
    return res.returncode, res.stdout.strip() or res.stderr.strip()


def main():
    print("=" * 70)
    print("DEMOSTRACIÓN DE VERIFICACIÓN FORMAL DE BATALLA NAVAL")
    print("Herramienta: Oracle Metalenguaje (oracle juzgar)")
    print("=" * 70)

    # 1. Partida real legítima
    print("\n[1/3] Leyendo partida real guardada...")
    ruta_real = BASE_DIR / "partida_real.json"
    if not ruta_real.is_file():
        ruta_real = BASE_DIR / "hechos_partida.json"
    evidencia_real = json.loads(ruta_real.read_text(encoding="utf-8"))
    print(f" -> Leída de {ruta_real.name}")
    print(f"    - Celdas de barco: {len(evidencia_real['celda_barco'])}")
    print(f"    - Tiros jugados: {len(evidencia_real['tiro'])}")
    print(f"    - Ganador: {evidencia_real['partida'][0]['ganador']}")

    print("\n[2/3] Juzgando la partida legítima contra el catálogo de Oracle...")
    rc, salida = ejecutar_oracle_juzgar(ruta_real)
    print(salida)
    if rc == 0 and "VEREDICTO: verde en 11 medidas" in salida:
        print("\n>>> RESULTADO: ÉXITO. Todas las 11 reglas se cumplen formalmente.")
    else:
        print("\n>>> RESULTADO: Error en la evaluación de la partida real.")
        sys.exit(1)

    # 2. Pruebas de falsabilidad (contraejemplos / inyección de faltas)
    print("\n" + "=" * 70)
    print("[3/3] DEMOSTRACIÓN DE FALSIBILIDAD: Inyectando infracciones a propósito")
    print("      (Probamos que el oráculo no aprueba cualquier cosa)")
    print("=" * 70)

    escenarios_infraccion = [
        (
            "Disparo duplicado a la misma casilla (fila 3, col 3)",
            "naval.tiros_sin_repeticion",
            lambda e: e["tiro"].append({
                "turno": len(e["tiro"]),
                "tirador": e["tiro"][0]["tirador"],
                "receptor": e["tiro"][0]["receptor"],
                "fila": e["tiro"][0]["fila"],
                "columna": e["tiro"][0]["columna"],
                "es_impacto": False,
                "hundio_barco": False,
                "barco_hundido": "ninguno"
            })
        ),
        (
            "Disparo fuera del tablero reglamentario (fila 14, col 2)",
            "naval.tiros_dentro_del_tablero",
            lambda e: e["tiro"].append({
                "turno": len(e["tiro"]),
                "tirador": "jugador",
                "receptor": "cpu",
                "fila": 14,
                "columna": 2,
                "es_impacto": False,
                "hundio_barco": False,
                "barco_hundido": "ninguno"
            })
        ),
        (
            "Impacto fantasma (afirmar impacto en casilla donde no había barco)",
            "naval.veracidad_impacto_positivo",
            lambda e: e["tiro"].append({
                "turno": len(e["tiro"]),
                "tirador": "jugador",
                "receptor": "cpu",
                "fila": 0,
                "columna": 9,  # Supongamos agua
                "es_impacto": True,
                "hundio_barco": False,
                "barco_hundido": "ninguno"
            }) if not any(c["jugador"] == "cpu" and c["fila"] == 0 and c["columna"] == 9 for c in e["celda_barco"])
            else e["tiro"].append({
                "turno": len(e["tiro"]),
                "tirador": "jugador",
                "receptor": "cpu",
                "fila": 0,
                "columna": 8,
                "es_impacto": True,
                "hundio_barco": False,
                "barco_hundido": "ninguno"
            })
        ),
        (
            "Turnos consecutivos del mismo tirador sin alternar",
            "naval.alternancia_turnos",
            lambda e: e["tiro"].insert(1, {
                "turno": 1,
                "tirador": e["tiro"][0]["tirador"],  # Mismo tirador consecutivo
                "receptor": e["tiro"][0]["receptor"],
                "fila": 8,
                "columna": 8,
                "es_impacto": False,
                "hundio_barco": False,
                "barco_hundido": "ninguno"
            }) or [t.__setitem__("turno", i) for i, t in enumerate(e["tiro"])]
        )
    ]

    fallas = 0
    for titulo, medida_esperada, inyector in escenarios_infraccion:
        evidencia_rota = copy.deepcopy(evidencia_real)
        inyector(evidencia_rota)
        ruta_rota = BASE_DIR / "partida_con_infraccion.json"
        ruta_rota.write_text(json.dumps(evidencia_rota, indent=2), encoding="utf-8")

        rc, salida = ejecutar_oracle_juzgar(ruta_rota)
        ruta_rota.unlink(missing_ok=True)

        if medida_esperada in salida and ("✗" in salida or "en rojo" in salida):
            print(f"  ✓ {titulo}")
            print(f"    -> Atrapado con éxito por medida: {medida_esperada}")
        else:
            fallas += 1
            print(f"  ✗ Falló detección para: {titulo}")
            print(salida)

    if fallas:
        sys.exit(1)

    print("\n" + "=" * 70)
    print("VERIFICACIÓN COMPLETA FINALIZADA CON ÉXITO")
    print("=" * 70)


if __name__ == "__main__":
    main()

Con celda_barco alcanza: las casillas de un mismo barco_id tienen que compartir la fila (y tener columnas consecutivas) o compartir la columna (y tener filas consecutivas). Una fila ofende si su barco tiene casillas en dos filas y dos columnas distintas a la vez. El caso rojo: un destructor con una casilla en (2,3) y otra en (3,4), en diagonal.