Feat/game logic

.gitignore

@@ -10,7 +10,6 @@ target/
 ### IntelliJ IDEA ###
 .idea/modules.xml
 .idea/jarRepositories.xml
-.idea/compiler.xml
 .idea/libraries/
 *.iws
 *.iml

TEST_GAME.md

@@ -0,0 +1,159 @@
+# 🎮 Prueba de la Vista de Partida - InazumaGo
+
+## Cómo ejecutar y probar la aplicación
+
+### Opción 1: Ejecutar desde el IDE (JetBrains IntelliJ IDEA)
+
+1. Abre el proyecto en JetBrains IDEA
+2. Navega a `src/main/java/es/iesquevedo/MainGUI.java`
+3. Haz clic derecho → "Run 'MainGUI.main()'"
+4. La aplicación mostrará la pantalla de Login
+
+### Opción 2: Ejecutar desde línea de comandos
+
+```bash
+cd C:\Users\Usuario\IdeaProjects\InazumaGo
+mvn compile
+java -cp target/classes es.iesquevedo.MainGUI
+```
+
+---
+
+## Flujo de Prueba
+
+### Paso 1: Pantalla de Login
+- Verás la pantalla de Login con campos de Email y Contraseña
+- Ingresa cualquier email (ej: `usuario@example.com`)
+- Ingresa cualquier contraseña (ej: `password123`)
+- Haz clic en "Iniciar sesión"
+
+### Paso 2: Pantalla de Partida (Nueva Vista)
+Tras login exitoso, verás la nueva vista de partida con:
+
+#### 📊 Encabezado (Top)
+- **Jugador 1 (Negro)**
+  - Nombre: usuario@example.com
+  - Puntos: 0
+  - Tiempo: 00:00
+
+- **VS** (separador visual)
+
+- **Jugador 2 (Blanco)**
+  - Nombre: Oponente
+  - Puntos: 0
+  - Tiempo: 00:00
+
+- **Turno Actual**: Turno: usuario@example.com
+
+#### 🎯 Centro (Canvas)
+- Tablero 19x19 con líneas de cuadrícula
+- Haz clic en cualquier intersección para colocar una piedra
+- Las piedras aparecerán en negro (Jugador 1) o blanco (Jugador 2)
+
+#### 🎮 Controles (Bottom)
+- **Pasar turno**: Cambia de jugador
+- **Deshacer**: No disponible en esta versión
+- **Rendirse**: Marca fin de la partida con ganador
+- **Volver al menú**: Cierra la ventana de partida
+
+---
+
+## Características Implementadas ✅
+
+### Vista FXML (Game.fxml)
+- ✅ Diseño BorderPane con 3 secciones (Top, Center, Bottom)
+- ✅ Encabezado con información de jugadores
+- ✅ Canvas para dibujar el tablero 19x19
+- ✅ Botones de control con eventos onAction
+- ✅ Labels dinámicos para puntuación y tiempo
+
+### Controlador (GameController.java)
+- ✅ Inicialización del tablero vacío (Stone[19][19])
+- ✅ Dibujo del tablero con líneas de cuadrícula
+- ✅ Detección de clics del ratón en el Canvas
+- ✅ Colocación de piedras (negro/blanco)
+- ✅ Control de turnos alternantes
+- ✅ Cálculo de puntuación en tiempo real
+- ✅ Temporizador con AnimationTimer que cuenta segundos/minutos
+- ✅ Métodos para acciones (pasar turno, rendirse)
+- ✅ Inyección de nombres de jugadores
+- ✅ Inyección de puntuaciones iniciales
+
+### Navegación (LoginController.java modificado)
+- ✅ Carga automática de Game.fxml tras login exitoso
+- ✅ Paso de nombres de jugadores al GameController
+- ✅ Cambio del título de la ventana a "InazumaGo - Partida"
+
+---
+
+## Pruebas Recomendadas
+
+### Prueba 1: Colocar piedras
+1. Haz clic en varias intersecciones del tablero
+2. Verifica que aparecen piedras negras (jugador 1) y blancas (jugador 2) alternadamente
+3. Comprueba que no se pueden colocar dos piedras en la misma posición
+
+**Resultado esperado**: Las piedras aparecen correctamente en color y posición
+
+### Prueba 2: Cambio de turno
+1. Coloca una piedra
+2. Verifica que el turno cambió al otro jugador
+3. Comprueba que el color de la siguiente piedra es diferente
+
+**Resultado esperado**: Los turnos se alternan correctamente
+
+### Prueba 3: Puntuación
+1. Coloca varias piedras
+2. Verifica que el contador de puntos aumenta para cada jugador
+
+**Resultado esperado**: Cada piedra colocada suma 1 punto al jugador
+
+### Prueba 4: Temporizador
+1. Espera 10-20 segundos
+2. Verifica que el tiempo avanza (HH:MM)
+3. Coloca una piedra y mira que el temporizador del otro jugador comienza
+
+**Resultado esperado**: El tiempo se actualiza correctamente por segundo
+
+### Prueba 5: Pasar turno
+1. Haz clic en "Pasar turno"
+2. Verifica que cambia el jugador actual sin colocar piedra
+
+**Resultado esperado**: El turno cambia, pero no hay nueva piedra
+
+### Prueba 6: Rendirse
+1. Haz clic en "Rendirse"
+2. Verifica que aparece un mensaje de ganador
+
+**Resultado esperado**: Se muestra "[Ganador] ganó. [Perdedor] se rindió"
+
+---
+
+## Archivos Generados
+
+```
+✅ src/main/resources/fxml/Game.fxml (4,188 bytes)
+✅ src/main/java/es/iesquevedo/controller/GameController.java (8,447 bytes)
+📝 src/main/java/es/iesquevedo/controller/LoginController.java (modificado)
+```
+
+## Estado de Compilación
+
+```
+✅ BUILD SUCCESS
+✅ GameController.class compilado
+✅ GameController$Stone.class compilado
+✅ GameController$1.class compilado (clase interna anónima)
+```
+
+---
+
+## Notas Técnicas
+
+- **Framework**: JavaFX 21.0.2
+- **Compilador**: Maven Compiler Plugin 3.13.0 con `javac`
+- **Versión Java**: 21 (LTS)
+- **Patrón de Diseño**: MVC (Model-View-Controller)
+- **Threading**: AnimationTimer para actualización de UI en tiempo real
+
+

ci/pipeline.yml

@@ -13,11 +13,12 @@ jobs:
     image: eclipse-temurin:21
     steps:
       - checkout
+      - run: java -version
       - restore_cache:
           key: maven-cache
           paths:
             - ~/.m2/repository
-      - run: ./mvnw -B -DskipTests=false test
+      - run: ./mvnw -B clean test
       - save_cache:
           key: maven-cache
           paths:

doc/firebase-setup.md

@@ -0,0 +1,149 @@
+# Configuración Firebase para InazumaGo
+
+## Estado Actual
+- ✅ Repositorio HTTP en OkHttp (FirebaseMainRepository) implementado
+- ✅ AuthService mock para desarrollo
+- ✅ Tests básicos pasando (sin dependencia de Firebase real)
+- ⏳ **Falta: Configurar Firebase Console**
+
+---
+
+## Pasos para Configurar Firebase (10-15 min)
+
+### 1. Crear Proyecto en Firebase Console
+1. Ve a **https://console.firebase.google.com**
+2. Click **"Crear proyecto"**
+3. Nombre: `InazumaGo`
+4. Deshabilita Analytics (por ahora, opcional)
+5. Click **"Crear"**
+
+### 2. Habilitar Realtime Database
+1. En el proyecto, ve a **"Realtime Database"** (en el menú lateral)
+2. Click **"Crear base de datos"**
+3. Ubicación: **Europe (europe-west1)** o **us-central1**
+4. Modo: **Start in test mode** (por ahora, abierta para desarrollo)
+5. Click **"Crear"**
+
+Firebase generará una URL como:
+```
+https://inazumago-abc123.firebaseio.com
+```
+
+### 3. Copiar URL a `application.properties`
+
+**Archivo:** `src/main/resources/application.properties`
+
+```properties
+# Firebase URL (sin .json)
+firebase.url=https://inazumago-abc123.firebaseio.com
+firebase.timeout.seconds=30
+firebase.auth.token=
+```
+
+### 4. (Alternativa) Usar Variable de Entorno
+
+```powershell
+# PowerShell
+$env:FIREBASE_URL="https://inazumago-abc123.firebaseio.com"
+```
+
+O en `.env`:
+```
+FIREBASE_URL=https://inazumago-abc123.firebaseio.com
+FIREBASE_AUTH_TOKEN=
+```
+
+### 5. Reglas de Seguridad RTDB (Desarrollo)
+
+**Para DESARROLLO:** En Firebase Console → Realtime Database → Rules
+
+```json
+{
+  "rules": {
+    ".read": true,
+    ".write": true,
+    "games": {
+      "$gameId": {
+        ".validate": "newData.hasChild('players')",
+        "players": {
+          ".validate": "newData.val().length() <= 2"
+        },
+        "moves": {
+          ".validate": "!data.exists() || newData.val().length() >= data.val().length()"
+        }
+      }
+    }
+  }
+}
+```
+
+**Para PRODUCCIÓN:** (después, con autenticación real)
+
+```json
+{
+  "rules": {
+    ".read": "auth != null",
+    ".write": "auth != null",
+    "games": {
+      "$gameId": {
+        ".validate": "newData.hasChildren(['id', 'players', 'status'])",
+        "players": {
+          ".validate": "newData.val().length() >= 2 && newData.val().length() <= 2"
+        },
+        "moves": {
+          ".validate": "root.child('games').child($gameId).child('currentTurn') != null"
+        }
+      }
+    }
+  }
+}
+```
+
+---
+
+## Testing con Firebase Real
+
+**Una vez configurado, Red puede hacer:**
+
+1. Tests WireMock (ya listos en `FirebaseMainRepositoryTest`)
+2. Tests contra Firebase real (descomenta tras configurar):
+
+```java
+@Test
+void testCreateGameAgainstFirebase() throws Exception {
+    GameDto game = new GameDto("game-real-123", "Test", 
+        Arrays.asList("p1", "p2"), "IN_PROGRESS", System.currentTimeMillis());
+
+    FirebaseMainRepository repo = new FirebaseMainRepository(
+        System.getenv("FIREBASE_URL")
+    );
+    CompletableFuture<GameDto> result = repo.createGame(game);
+    GameDto created = result.get();
+
+    assertNotNull(created);
+    assertEquals("game-real-123", created.getId());
+}
+```
+
+---
+
+## Checklist para Red
+
+- [ ] Firebase Console: Proyecto creado
+- [ ] RTDB: Base de datos creada (EU o US)
+- [ ] RTDB URL: Copiada a `application.properties`
+- [ ] Reglas: Aplicadas (desarrollo first)
+- [ ] Tests: Ejecutados contra Firebase real (opcional ahora, hacer después)
+
+---
+
+## Próximo Paso (E2-US3)
+
+Cuando Firebase esté configurado, Red implementa:
+- AuthService real (Firebase Authentication)
+- Integración de tokens en peticiones
+- SSE o WebSocket para listeners en tiempo real
+
+**Responsable:** Red Team  
+**Estimación:** 1-2 sprints  
+**Bloqueador:** Firebase configurado