Merge branch 'backend'

clases/ClaseCategoria.php

@@ -0,0 +1,148 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+class Categoria{
+
+    public $idCategoria;
+    public $nombreCategoria;
+
+    function __construct($idCategoria=null, $nombreCategoria=null){
+        $this->idCategoria = $idCategoria;
+        $this->nombreCategoria = $nombreCategoria;
+    }
+
+
+    function crear(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("INSERT INTO categoria (nombreCategoria) VALUES (:nombreCategoria)");
+
+                $consulta->bindParam(':nombreCategoria', $this->nombreCategoria);
+
+                $consulta->execute();
+
+                $respuesta = [
+                    'exito' => 'Categoría creada correctamente',
+                    'exito_tecnico' => $this->nombreCategoria
+                ];
+
+                return $respuesta;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al guardar la categoría.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+
+    function listar(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $sql = 'SELECT * FROM categoria';
+
+                $consulta = $conexion->prepare($sql);
+                $consulta->execute();
+
+                $resultado = $consulta->fetchAll(PDO::FETCH_ASSOC);
+
+                return $resultado;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al obtener el listado de categorías.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+
+    function buscar(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("SELECT * FROM categoria WHERE idCategoria = :idCategoria");
+
+                $consulta->bindParam(':idCategoria', $this->idCategoria);
+
+                $consulta->execute();
+
+                $resultado = $consulta->fetch(PDO::FETCH_ASSOC);
+
+                return $resultado;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al buscar la categoría.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+
+    function borrar(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("DELETE FROM categoria WHERE idCategoria = :idCategoria");
+
+                $consulta->bindParam(':idCategoria', $this->idCategoria);
+
+                $consulta->execute();
+
+                if($consulta->rowCount() > 0){
+                    $respuesta = [
+                        'exito' => 'Se eliminó correctamente la categoría',
+                        'exito_tecnico' => $this->idCategoria
+                    ];
+                }else{
+                    $respuesta = [
+                        'error' => 'No existe ninguna categoría con ese ID.',
+                        'error_tecnico' => $this->idCategoria
+                    ];
+                }
+
+                return $respuesta;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al eliminar la categoría.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+}
+
+?>

clases/ClaseEquipo.php

@@ -0,0 +1,148 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+class Equipo{
+
+    public $idEquipo;
+    public $nombreEquipo;
+
+    function __construct($idEquipo=null, $nombreEquipo=null){
+        $this->idEquipo = $idEquipo;
+        $this->nombreEquipo = $nombreEquipo;
+    }
+
+
+    function crear(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("INSERT INTO equipo (nombreEquipo) VALUES (:nombreEquipo)");
+
+                $consulta->bindParam(':nombreEquipo', $this->nombreEquipo);
+
+                $consulta->execute();
+
+                $respuesta = [
+                    'exito' => 'Equipo creado correctamente',
+                    'exito_tecnico' => $this->nombreEquipo
+                ];
+
+                return $respuesta;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al guardar el equipo.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+
+    function listar(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $sql = 'SELECT * FROM equipo';
+
+                $consulta = $conexion->prepare($sql);
+                $consulta->execute();
+
+                $resultado = $consulta->fetchAll(PDO::FETCH_ASSOC);
+
+                return $resultado;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al obtener el listado de equipos.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+
+    function buscar(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("SELECT * FROM equipo WHERE idEquipo = :idEquipo");
+
+                $consulta->bindParam(':idEquipo', $this->idEquipo);
+
+                $consulta->execute();
+
+                $resultado = $consulta->fetch(PDO::FETCH_ASSOC);
+
+                return $resultado;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al buscar el equipo.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+
+    function borrar(){
+        $conexion = conexionBD();
+
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("DELETE FROM equipo WHERE idEquipo = :idEquipo");
+
+                $consulta->bindParam(':idEquipo', $this->idEquipo);
+
+                $consulta->execute();
+
+                if($consulta->rowCount() > 0){
+                    $respuesta = [
+                        'exito' => 'Se eliminó correctamente el equipo',
+                        'exito_tecnico' => $this->idEquipo
+                    ];
+                }else{
+                    $respuesta = [
+                        'error' => 'No existe ningún equipo con ese ID.',
+                        'error_tecnico' => $this->idEquipo
+                    ];
+                }
+
+                return $respuesta;
+
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al eliminar el equipo.',
+                    'error_tecnico' => $error
+                ];
+
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }
+
+}
+
+?>

clases/ClaseEquipoxUsuario.php

@@ -0,0 +1,58 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+class EquipoxUsuario {
+    public $idEquipoxUsuario;
+    public $idUsuario;
+    public $idEquipo;
+
+    public function __construct($idEquipoxUsuario = null, $idUsuario = null, $idEquipo = null) {
+        $this->idEquipoxUsuario = $idEquipoxUsuario;
+        $this->idUsuario = $idUsuario;
+        $this->idEquipo = $idEquipo;
+    }
+
+    public function registrarUsuarioEnEquipo() {
+        $conexion = conexionBD();
+        if (is_array($conexion)) return $conexion;
+
+        try {
+            $sql = "INSERT INTO equipoxusuario (idUsuario, idEquipo) VALUES (:idUsuario, :idEquipo)";
+            $consulta = $conexion->prepare($sql);
+            $consulta->bindParam(':idUsuario', $this->idUsuario);
+            $consulta->bindParam(':idEquipo', $this->idEquipo);
+            $consulta->execute();
+
+            return [
+                'exito' => 'Usuario vinculado al equipo correctamente.',
+                'exito_tecnico' => $conexion->lastInsertId()
+            ];
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al unir al usuario con el equipo.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public static function listarUsuariosPorEquipo($idEquipo) {
+        $conexion = conexionBD();
+        if (is_array($conexion)) return $conexion;
+
+        try {
+            $sql = "SELECT u.* FROM equipoxusuario exu 
+                    INNER JOIN usuario u ON exu.idUsuario = u.idUsuario 
+                    WHERE exu.idEquipo = :idEquipo";
+            $consulta = $conexion->prepare($sql);
+            $consulta->bindParam(':idEquipo', $idEquipo);
+            $consulta->execute();
+
+            return $consulta->fetchAll(PDO::FETCH_ASSOC);
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al obtener los miembros del equipo.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+}

clases/ClasePartida.php

@@ -0,0 +1,452 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+class Partida
+{
+
+    public $idPartida;
+    public $nombrePartida;
+    public $idUsuario;
+
+    public function __construct(
+        $idPartida = null,
+        $nombrePartida = null,
+        $idUsuario = null
+    ) {
+        $this->idPartida = $idPartida;
+        $this->nombrePartida = $nombrePartida;
+        $this->idUsuario = $idUsuario;
+    }
+
+    public function insertar()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                INSERT INTO partida
+                (nombrePartida,idUsuario)
+                VALUES
+                (:nombrePartida,:idUsuario)
+            ");
+            $consulta->bindParam(":nombrePartida", $this->nombrePartida);
+            $consulta->bindParam(":idUsuario", $this->idUsuario);
+            $consulta->execute();
+            return [
+                "exito" => "La partida se creó correctamente.",
+                "exito_tecnico" => $conexion->lastInsertId()
+            ];
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al guardar la partida.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function listar()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("SELECT * FROM partida");
+            $consulta->execute();
+            return $consulta->fetchAll(PDO::FETCH_ASSOC);
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al obtener el listado.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function buscar()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                SELECT *
+                FROM partida
+                WHERE idPartida=:idPartida
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->execute();
+            return $consulta->fetch(PDO::FETCH_ASSOC);
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al buscar la partida.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function editar()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                UPDATE partida
+                SET
+                    nombrePartida=:nombrePartida,
+                    idUsuario=:idUsuario
+                WHERE idPartida=:idPartida
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->bindParam(":nombrePartida", $this->nombrePartida);
+            $consulta->bindParam(":idUsuario", $this->idUsuario);
+            $consulta->execute();
+            return [
+                "exito" => "La partida se editó correctamente.",
+                "exito_tecnico" => $this->idPartida
+            ];
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al editar la partida.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function eliminar()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                DELETE FROM partida
+                WHERE idPartida=:idPartida
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->execute();
+            return [
+                "exito" => "La partida se eliminó correctamente.",
+                "exito_tecnico" => $this->idPartida
+            ];
+        } catch (PDOException $error) {
+            return [
+                "error" => "No se pudo eliminar la partida.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    /**
+     * Devuelve las preguntas asignadas a la partida, junto con el
+     * idPartidaxPregunta (necesario para guardar respuestas después).
+     */
+    public function getPreguntas()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                SELECT
+                    pxp.idPartidaxPregunta,
+                    p.*
+                FROM partidaxpregunta pxp
+                INNER JOIN pregunta p
+                    ON pxp.idPregunta=p.idPregunta
+                WHERE pxp.idPartida=:idPartida
+                ORDER BY pxp.idPartidaxPregunta
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->execute();
+            return $consulta->fetchAll(PDO::FETCH_ASSOC);
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al recuperar las preguntas de la partida.",
+                'error_tecnico' => $error->getMessage() 
+            ];
+        }
+    }
+
+    /**
+     * Asocia una pregunta ya existente a esta partida.
+     */
+    public function asignarPregunta($idPregunta)
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                INSERT INTO partidaxpregunta
+                (idPartida,idPregunta)
+                VALUES
+                (:idPartida,:idPregunta)
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->bindParam(":idPregunta", $idPregunta);
+            $consulta->execute();
+            return [
+                "exito" => "La pregunta se asignó correctamente.",
+                "exito_tecnico" => $conexion->lastInsertId()
+            ];
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al asignar la pregunta.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+    //Cuenta cuántas preguntas tiene la partida en total. Es la primera mitad de la comprobación "¿ha terminado el usuario de jugar?".
+    public function contarPreguntasAsignadas()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                SELECT COUNT(*) AS total
+                FROM partidaxpregunta
+                WHERE idPartida=:idPartida
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->execute();
+            $fila = $consulta->fetch(PDO::FETCH_ASSOC);
+            return (int)$fila["total"];
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al contar las preguntas.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function contarRespuestasUsuario($idUsuario)
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                SELECT COUNT(*) AS total
+                FROM respuestaalmacenada ra
+                INNER JOIN partidaxpregunta pxp
+                    ON ra.idPartidaxPregunta=pxp.idPartidaxPregunta
+                WHERE pxp.idPartida=:idPartida
+                AND ra.idUsuario=:idUsuario
+            ");
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->bindParam(":idUsuario", $idUsuario);
+            $consulta->execute();
+            $fila = $consulta->fetch(PDO::FETCH_ASSOC);
+            return (int)$fila["total"];
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al contar las respuestas del usuario.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    /**
+     * Sustituye al antiguo campo `terminada`: compara cuántas preguntas
+     * tiene la partida contra cuántas ha respondido este usuario.
+     */
+    public function estaFinalizadaParaUsuario($idUsuario)
+    {
+        $totalPreguntas = $this->contarPreguntasAsignadas();
+        if (is_array($totalPreguntas)) {
+            return $totalPreguntas;
+        }
+        $totalRespondidas = $this->contarRespuestasUsuario($idUsuario);
+        if (is_array($totalRespondidas)) {
+            return $totalRespondidas;
+        }
+        return $totalPreguntas > 0 && $totalPreguntas === $totalRespondidas;
+    }
+
+    /**
+     * Partidas creadas por un usuario, de más reciente a más antigua.
+     */
+    public function listarDelUsuario()
+    {
+        $conexion = conexionBD();
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        try {
+            $consulta = $conexion->prepare("
+                SELECT *
+                FROM partida
+                WHERE idUsuario=:idUsuario
+                ORDER BY idPartida DESC
+            ");
+            $consulta->bindParam(":idUsuario", $this->idUsuario);
+            $consulta->execute();
+            return $consulta->fetchAll(PDO::FETCH_ASSOC);
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al recuperar las partidas del usuario.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function preguntaAsignada($idPregunta)
+    {
+        $conexion = conexionBD();
+
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+
+        try {
+            $consulta = $conexion->prepare("
+                SELECT COUNT(*) AS total
+                FROM partidaxpregunta
+                WHERE idPartida=:idPartida
+                AND idPregunta=:idPregunta
+            ");
+
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->bindParam(":idPregunta", $idPregunta);
+            $consulta->execute();
+
+            $fila = $consulta->fetch(PDO::FETCH_ASSOC);
+
+            return (int)$fila["total"] > 0;
+        } catch (PDOException $error) {
+
+            return [
+                "error" => "Ocurrió un error al comprobar la pregunta.",
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+        /**
+     * Vincula un equipo a esta partida en la tabla intermedia 'equipoxpartida'.
+     * Permite registrar qué grupos están participando en este torneo.
+     */
+    public function registrarEquipoEnPartida($idEquipo) {
+        $conexion = conexionBD(); // Obtenemos la conexión modular del proyecto
+        
+        if (is_array($conexion)) {
+            return $conexion; // Si hay error en la conexión, lo devuelve
+        }
+        
+        try {
+            // Preparamos la consulta para insertar la relación en la tabla intermedia real
+            $consulta = $conexion->prepare("
+                INSERT INTO equipoxpartida 
+                (idPartida, idEquipo) 
+                VALUES 
+                (:idPartida, :idEquipo)
+            ");
+            
+            // Vinculamos los parámetros con el objeto de la partida actual y el equipo recibido
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->bindParam(":idEquipo", $idEquipo);
+            $consulta->execute();
+            
+            return [
+                "exito" => "El equipo se vinculó a la partida correctamente.",
+                "exito_tecnico" => $conexion->lastInsertId()
+            ];
+        } catch (PDOException $error) {
+            // Capturamos el error extrayendo solo el mensaje de texto limpio
+            return [
+                "error" => "Ocurrió un error al asignar el equipo a la partida.",
+                "error_tecnico" => $error->getMessage()
+            ];
+        }
+    }
+
+    /**
+     * Obtiene todos los equipos que están compitiendo en esta partida.
+     * Es útil para mostrar la lista de rivales antes de empezar a responder.
+     */
+    public function getEquiposParticipantes() {
+        $conexion = conexionBD();
+        
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        
+        try {
+            // Hacemos un INNER JOIN para traer los nombres de los equipos desde la tabla intermedia
+            $consulta = $conexion->prepare("
+                SELECT 
+                    exp.idEquipoxPartida,
+                    e.idEquipo,
+                    e.nombreEquipo
+                FROM equipoxpartida exp
+                INNER JOIN equipo e 
+                    ON exp.idEquipo = e.idEquipo
+                WHERE exp.idPartida = :idPartida
+                ORDER BY e.nombreEquipo ASC
+            ");
+            
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->execute();
+            
+            return $consulta->fetchAll(PDO::FETCH_ASSOC); // Devuelve el array con los equipos rivales
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al recuperar los equipos de la partida.",
+                "error_tecnico" => $error->getMessage()
+            ];
+        }
+    }
+
+    /**
+     * Obtiene todos los jugadores reales (Usuarios) que están jugando en esta partida.
+     * Utiliza la tabla 'equipoxusuario' en SQL para cruzar los datos.
+     */
+    public function getJugadoresDeLaPartida() {
+        $conexion = conexionBD();
+        
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+        
+        try {
+            // Cruza la partida con los equipos, y luego los equipos con los usuarios
+            // para saber los nombres de todas las personas que están jugando el torneo.
+            $consulta = $conexion->prepare("
+                SELECT DISTINCT
+                    u.idUsuario,
+                    u.nombreUsuario,
+                    u.email,
+                    e.nombreEquipo
+                FROM equipoxpartida exp
+                INNER JOIN equipoxusuario exu 
+                    ON exp.idEquipo = exu.idEquipo
+                INNER JOIN usuario u 
+                    ON exu.idUsuario = u.idUsuario
+                INNER JOIN equipo e 
+                    ON exu.idEquipo = e.idEquipo
+                WHERE exp.idPartida = :idPartida
+            ");
+            
+            $consulta->bindParam(":idPartida", $this->idPartida);
+            $consulta->execute();
+            
+            return $consulta->fetchAll(PDO::FETCH_ASSOC);
+        } catch (PDOException $error) {
+            return [
+                "error" => "Ocurrió un error al obtener la lista de jugadores.",
+                "error_tecnico" => $error->getMessage()
+            ];
+        }
+    }
+
+}

clases/ClasePregunta.php

@@ -0,0 +1,112 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+class Pregunta {
+    private ?int $idPregunta;
+    private int $idCategoria;
+    private string $nombrePregunta;
+    private array $respuestas; 
+
+    public function __construct(int $idCategoria = 0, string $nombrePregunta = "", ?int $idPregunta = null) {
+        $this->idPregunta = $idPregunta;
+        $this->idCategoria = $idCategoria;
+        $this->nombrePregunta = $nombrePregunta;
+        $this->respuestas = [];
+    }
+
+    public function getIdPregunta(): ?int { return $this->idPregunta; }
+    
+    public function getIdCategoria(): int { return $this->idCategoria; }
+    public function setIdCategoria(int $idCategoria): void { $this->idCategoria = $idCategoria; }
+
+    public function getNombrePregunta(): string { return $this->nombrePregunta; }
+    public function setNombrePregunta(string $nombrePregunta): void { $this->nombrePregunta = $nombrePregunta; }
+
+    public function getRespuestas(): array { return $this->respuestas; }
+
+    public function guardar() {
+        $conexion = conexionBD();
+
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+
+        try {
+            $sql = "INSERT INTO pregunta (idCategoria, nombrePregunta) VALUES (:idCat, :texto)";
+            $stmt = $conexion->prepare($sql);
+            
+            $stmt->execute([
+                ':idCat' => $this->idCategoria,
+                ':texto' => $this->nombrePregunta
+            ]);
+
+            $this->idPregunta = (int)$conexion->lastInsertId();
+
+            return [
+                'exito' => 'Pregunta guardada correctamente',
+                'exito_tecnico' => $this->idPregunta
+            ];
+
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al guardar la pregunta.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public function cargarRespuestas() {
+        if ($this->idPregunta === null) return;
+
+        $conexion = conexionBD();
+
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+
+        try {
+            $sql = "SELECT idRespuesta, nombreRespuesta, correcta FROM respuesta WHERE idPregunta = :idPreg";
+            $stmt = $conexion->prepare($sql);
+            $stmt->execute([':idPreg' => $this->idPregunta]);
+            
+            $this->respuestas = $stmt->fetchAll(PDO::FETCH_ASSOC);
+
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al cargar las respuestas.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public static function obtenerPorCategoria(int $idCategoria, int $limite = 10) {
+        $conexion = conexionBD();
+
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+
+        try {
+            $sql = "SELECT * FROM pregunta WHERE idCategoria = :idCat ORDER BY RAND() LIMIT :limite";
+            $stmt = $conexion->prepare($sql);
+            
+            $stmt->bindValue(':idCat', $idCategoria, PDO::PARAM_INT);
+            $stmt->bindValue(':limite', $limite, PDO::PARAM_INT);
+            $stmt->execute();
+
+            $preguntas = [];
+            while ($datos = $stmt->fetch(PDO::FETCH_ASSOC)) {
+                $preg = new Pregunta((int)$datos['idCategoria'], $datos['nombrePregunta'], (int)$datos['idPregunta']);
+                $preg->cargarRespuestas();
+                $preguntas[] = $preg;
+            }
+            return $preguntas;
+
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al obtener las preguntas aleatorias.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+}

clases/ClaseRespuesta.php

@@ -0,0 +1,168 @@
+<?php
+require_once '../includes/conexionBD.php'; 
+class Respuesta{
+    public $idRespuesta;
+    public $idPregunta;
+    public $nombreRespuesta;
+    public $correcta;
+ 
+    public function __construct($idRespuesta=null, $idPregunta=null, $nombreRespuesta=null, $correcta=null){
+        $this->idRespuesta=$idRespuesta;
+        $this->idPregunta=$idPregunta;
+        $this->nombreRespuesta=$nombreRespuesta;
+        $this->correcta=$correcta;
+    }//fin constructor
+ 
+    public function insertar(){
+        $conexion = conexionBD();
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("INSERT INTO respuesta (idPregunta, nombreRespuesta, correcta) VALUES (:idPregunta, :nombreRespuesta, :correcta)");
+                $consulta->bindParam(':idPregunta', $this->idPregunta);
+                $consulta->bindParam(':nombreRespuesta', $this->nombreRespuesta);
+                $consulta->bindParam(':correcta', $this->correcta);
+                $consulta->execute();
+                $respuesta = [
+                    'exito' => 'La respuesta se guardó correctamente.',
+                    'exito_tecnico' => $conexion->lastInsertId()
+                ];
+                return $respuesta;
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al guardar la respuesta.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }//fin método insertar
+ 
+    public function listar(){
+        $conexion = conexionBD();
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("SELECT * FROM respuesta");
+                $consulta->execute();
+                return $consulta->fetchAll(PDO::FETCH_ASSOC);
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al obtener el listado.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }//fin método listar
+ 
+    public function eliminar(){
+        $conexion = conexionBD();
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("DELETE FROM respuesta WHERE idRespuesta=:idRespuesta");
+                $consulta->bindParam(':idRespuesta', $this->idRespuesta);
+                $consulta->execute();
+                $respuesta = [
+                    'exito' => 'La respuesta se eliminó correctamente.',
+                    'exito_tecnico' => $this->idRespuesta
+                ];
+                return $respuesta;
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'No se pudo eliminar la respuesta.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }//fin método eliminar
+ 
+    public function editar(){
+        $conexion = conexionBD();
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("UPDATE respuesta SET idPregunta=:idPregunta, nombreRespuesta=:nombreRespuesta, correcta=:correcta WHERE idRespuesta=:idRespuesta");
+                $consulta->bindParam(':idRespuesta', $this->idRespuesta);
+                $consulta->bindParam(':idPregunta', $this->idPregunta);
+                $consulta->bindParam(':nombreRespuesta', $this->nombreRespuesta);
+                $consulta->bindParam(':correcta', $this->correcta);
+                $consulta->execute();
+                $respuesta = [
+                    'exito' => 'La respuesta se editó correctamente.',
+                    'exito_tecnico' => $this->idRespuesta
+                ];
+                return $respuesta;
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al editar la respuesta.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }//fin método editar
+ 
+    public function buscar(){
+        $conexion = conexionBD();
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("SELECT * FROM respuesta WHERE idRespuesta=:idRespuesta");
+                $consulta->bindParam(':idRespuesta', $this->idRespuesta);
+                $consulta->execute();
+                return $consulta->fetchAll(PDO::FETCH_ASSOC);
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al buscar la respuesta.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }//fin método buscar
+ 
+    public function listarPorPregunta(){//trae todas las respuestas posibles de una pregunta
+        $conexion = conexionBD();
+        if(is_array($conexion)){
+            return $conexion;
+        }else{
+            try{
+                $consulta = $conexion->prepare("SELECT * FROM respuesta WHERE idPregunta=:idPregunta");
+                $consulta->bindParam(':idPregunta', $this->idPregunta);
+                $consulta->execute();
+                $resultado = $consulta->fetchAll(PDO::FETCH_ASSOC);
+                if(!isset($resultado[0])){
+                    $respuesta = [
+                        'error' => 'La pregunta no tiene respuestas.'
+                    ];
+                    return $respuesta;
+                }else{
+                    return $resultado;
+                }
+            }catch(PDOException $error){
+                $respuesta = [
+                    'error' => 'Ocurrió un error al obtener las respuestas de la pregunta.',
+                    'error_tecnico' => $error->getMessage()
+                ];
+                $conexion = null;
+                return $respuesta;
+            }
+        }
+    }//fin método listarPorPregunta
+ 
+}//fin clase
+ 
+?>

clases/ClaseRespuestaAlmacenada.php

@@ -0,0 +1,79 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+// Clase encargada de registrar las respuestas de los jugadores en tiempo real durante la partida
+class RespuestaAlmacenada {
+    public $idRespuestaAlmacenada;
+    public $idPartidaxPregunta;
+    public $idUsuario;
+    public $idRespuesta;
+    public $primero; // Indica con 1 o 0 si fue el más rápido en responder correctamente
+
+    public function __construct($idRespuestaAlmacenada = null, $idPartidaxPregunta = null, $idUsuario = null, $idRespuesta = null, $primero = 0) {
+        $this->idRespuestaAlmacenada = $idRespuestaAlmacenada;
+        $this->idPartidaxPregunta = $idPartidaxPregunta;
+        $this->idUsuario = $idUsuario;
+        $this->idRespuesta = $idRespuesta;
+        $this->primero = $primero;
+    }
+
+    /**
+     * Guarda la respuesta que ha seleccionado un usuario en una pregunta de la partida.
+     */
+    public function guardarRespuesta() {
+        $conexion = conexionBD();
+        if (is_array($conexion)) return $conexion;
+
+        try {
+            $sql = "INSERT INTO respuestaalmacenada (idPartidaxPregunta, idUsuario, idRespuesta, primero) 
+                    VALUES (:idPartidaxPregunta, :idUsuario, :idRespuesta, :primero)";
+            $consulta = $conexion->prepare($sql);
+            
+            $consulta->bindParam(':idPartidaxPregunta', $this->idPartidaxPregunta);
+            $consulta->bindParam(':idUsuario', $this->idUsuario);
+            $consulta->bindParam(':idRespuesta', $this->idRespuesta);
+            $consulta->bindParam(':primero', $this->primero, PDO::PARAM_INT);
+            $consulta->execute();
+
+            return [
+                'exito' => 'Respuesta del usuario almacenada correctamente.',
+                'exito_tecnico' => $conexion->lastInsertId()
+            ];
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al guardar la respuesta del jugador.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    /**
+     * Obtiene los aciertos totales de un usuario en una partida específica.
+     * Útil para calcular las estadísticas individuales al terminar el juego.
+     */
+    public static function obtenerAciertosUsuarioEnPartida($idPartida, $idUsuario) {
+        $conexion = conexionBD();
+        if (is_array($conexion)) return $conexion;
+
+        try {
+            $sql = "SELECT COUNT(*) AS aciertos 
+                    FROM respuestaalmacenada ra
+                    INNER JOIN partidaxpregunta pxp ON ra.idPartidaxPregunta = pxp.idPartidaxPregunta
+                    INNER JOIN respuesta r ON ra.idRespuesta = r.idRespuesta
+                    WHERE pxp.idPartida = :idPartida AND ra.idUsuario = :idUsuario AND r.correcta = 1";
+            
+            $consulta = $conexion->prepare($sql);
+            $consulta->bindParam(':idPartida', $idPartida);
+            $consulta->bindParam(':idUsuario', $idUsuario);
+            $consulta->execute();
+            
+            $resultado = $consulta->fetch(PDO::FETCH_ASSOC);
+            return (int)$resultado['aciertos'];
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al calcular los aciertos.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+}

clases/ClaseUsuario.php

@@ -0,0 +1,142 @@
+<?php
+require_once '../includes/conexionBD.php';
+
+class Usuario {
+    private ?int $idUsuario;
+    private string $nombreUsuario;
+    private string $contrasena;
+    private string $email;
+    private ?string $avatar;
+    private ?string $cookie;
+    private int $aciertos;
+    private int $victorias;
+    private int $derrotas;
+
+    public function __construct(
+        string $nombreUsuario = "", 
+        string $contrasena = "", 
+        string $email = "", 
+        ?string $avatar = null, 
+        ?string $cookie = null, 
+        int $aciertos = 0, 
+        int $victorias = 0, 
+        int $derrotas = 0, 
+        ?int $idUsuario = null
+    ) {
+        $this->idUsuario = $idUsuario;
+        $this->nombreUsuario = $nombreUsuario;
+        $this->contrasena = $contrasena;
+        $this->email = $email;
+        $this->avatar = $avatar;
+        $this->cookie = $cookie;
+        $this->aciertos = $aciertos;
+        $this->victorias = $victorias;
+        $this->derrotas = $derrotas;
+    }
+
+    public function getIdUsuario(): ?int { return $this->idUsuario; }
+    
+    public function getNombreUsuario(): string { return $this->nombreUsuario; }
+    public function setNombreUsuario(string $nombreUsuario): void { $this->nombreUsuario = $nombreUsuario; }
+
+    public function getContrasena(): string { return $this->contrasena; }
+    public function setContrasena(string $contrasena): void { $this->contrasena = $contrasena; }
+
+    public function getEmail(): string { return $this->email; }
+    public function setEmail(string $email): void { $this->email = $email; }
+
+    public function getAvatar(): ?string { return $this->avatar; }
+    public function setAvatar(?string $avatar): void { $this->avatar = $avatar; }
+
+    public function getCookie(): ?string { return $this->cookie; }
+    public function setCookie(?string $cookie): void { $this->cookie = $cookie; }
+
+    public function getAciertos(): int { return $this->aciertos; }
+    public function setAciertos(int $aciertos): void { $this->aciertos = $aciertos; }
+
+    public function getVictorias(): int { return $this->victorias; }
+    public function setVictorias(int $victorias): void { $this->victorias = $victorias; }
+
+    public function getDerrotas(): int { return $this->derrotas; }
+    public function setDerrotas(int $derrotas): void { $this->derrotas = $derrotas; }
+
+    public function registrar() {
+        $conexion = conexionBD();
+
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+
+        try {
+            $sql = "INSERT INTO usuario (nombreUsuario, contrasena, email, avatar, cookie, aciertos, victorias, derrotas) 
+                    VALUES (:nombre, :pass, :email, :avatar, :cookie, :aciertos, :victorias, :derrotas)";
+            $stmt = $conexion->prepare($sql);
+            
+            $passHash = password_hash($this->contrasena, PASSWORD_BCRYPT);
+
+            $stmt->execute([
+                ':nombre' => $this->nombreUsuario,
+                ':pass' => $passHash,
+                ':email' => $this->email,
+                ':avatar' => $this->avatar,
+                ':cookie' => $this->cookie,
+                ':aciertos' => $this->aciertos,
+                ':victorias' => $this->victorias,
+                ':derrotas' => $this->derrotas
+            ]);
+
+            $this->idUsuario = (int)$conexion->lastInsertId();
+
+            return [
+                'exito' => 'Usuario registrado correctamente',
+                'exito_tecnico' => $this->idUsuario
+            ];
+
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al registrar el usuario.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+
+    public static function buscarPorId($id) {
+        $conexion = conexionBD();
+
+        if (is_array($conexion)) {
+            return $conexion;
+        }
+
+        try {
+            $sql = "SELECT * FROM usuario WHERE idUsuario = :id";
+            $stmt = $conexion->prepare($sql);
+            $stmt->execute([':id' => $id]);
+            
+            $datos = $stmt->fetch(PDO::FETCH_ASSOC);
+
+            if ($datos) {
+                return new Usuario(
+                    $datos['nombreUsuario'], 
+                    $datos['contrasena'], 
+                    $datos['email'], 
+                    $datos['avatar'], 
+                    $datos['cookie'], 
+                    (int)$datos['aciertos'], 
+                    (int)$datos['victorias'], 
+                    (int)$datos['derrotas'], 
+                    (int)$datos['idUsuario']
+                );
+            }
+            
+            return [
+                'error' => 'No se encontró ningún usuario con ese ID.'
+            ];
+
+        } catch (PDOException $error) {
+            return [
+                'error' => 'Ocurrió un error al buscar el usuario.',
+                'error_tecnico' => $error->getMessage()
+            ];
+        }
+    }
+}

controladores/controladorEquipoxUsuario.php

@@ -0,0 +1,47 @@
+<?php
+
+session_start();
+
+require_once '../clases/ClaseEquipoxUsuario.php';
+
+switch($_POST['orden']){
+
+    case 'registrarUsuarioEnEquipo':
+        if (!isset($_SESSION['idUsuario'])) {
+            echo json_encode([
+                'error' => 'No hay una sesión activa de usuario. Por favor, inicie sesión.'
+            ]);
+            break;
+        }
+        $idUsuario = $_SESSION['idUsuario'];
+        $idEquipo = intval($_POST['idEquipo'] ?? 0);
+        break;
+        if ($idEquipo <= 0) {
+            echo json_encode([
+                'error' => 'El ID del equipo proporcionado no es válido.'
+            ]);
+            break;
+        }
+        $equipoxusuario = new EquipoxUsuario();
+        $resultado = $equipoxusuario->registrarUsuarioEnEquipo($idEquipo, $idUsuario);
+        echo json_encode($resultado);
+        break;
+
+    case 'listarUsuariosPorEquipo':
+        $idEquipo = intval($_POST['idEquipo'] ?? 0);
+
+        if ($idEquipo <= 0) {
+            echo json_encode(['error' => 'ID de equipo no válido']);
+            break;
+        }
+        $equipoxusuario = new EquipoxUsuario();
+        $listado = $equipoxusuario->listarUsuariosPorEquipo($idEquipo);
+        break;
+        echo json_encode($listado);
+        break;
+    
+
+}
+
+
+?>

controladores/controladorUsuario.php

@@ -0,0 +1,86 @@
+<?php
+
+session_start();
+
+require_once '../clases/Usuario.php';
+
+switch ($_POST['orden']) {
+
+    case 'registrarUsuario':
+
+        $nombreUsuario = trim($_POST['nombreUsuario'] ?? '');
+        $email = trim($_POST['email'] ?? '');
+        $contrasena = $_POST['contrasena'] ?? '';
+
+        if ($nombreUsuario == '' || $email == '' || $contrasena == '') {
+
+            echo json_encode([
+                'error' => 'Todos los campos son obligatorios'
+            ]);
+
+            break;
+        }
+
+        $usuarioExistente = Usuario::buscarPorEmail($email);
+
+        if ($usuarioExistente instanceof Usuario) {
+
+            echo json_encode([
+                'error' => 'Ya existe una cuenta con ese correo electrónico'
+            ]);
+
+            break;
+        }
+
+        $usuario = new Usuario(
+            $nombreUsuario,
+            $contrasena,
+            $email
+        );
+
+        $resultado = $usuario->registrar();
+
+        echo json_encode($resultado);
+
+        break;
+
+
+    case 'comprobarUsuario':
+
+        $email = trim($_POST['email'] ?? '');
+        $contrasena = $_POST['contrasena'] ?? '';
+
+        $resultado = Usuario::login($email, $contrasena);
+
+        if ($resultado instanceof Usuario) {
+
+            $_SESSION['idUsuario'] = $resultado->getIdUsuario();
+            $_SESSION['email'] = $resultado->getEmail();
+            $_SESSION['nombreUsuario'] = $resultado->getNombreUsuario();
+
+            echo json_encode([
+                'exito' => 'Login correcto',
+                'idUsuario' => $resultado->getIdUsuario(),
+                'nombreUsuario' => $resultado->getNombreUsuario()
+            ]);
+
+        } else {
+
+            echo json_encode([
+                'error' => 'Usuario o contraseña incorrectos'
+            ]);
+        }
+
+        break;
+
+
+    case 'cerrarSesion':
+
+        session_destroy();
+
+        echo json_encode([
+            'exito' => 'Sesión cerrada'
+        ]);
+
+        break;
+}

includes/conexionBD.php

@@ -0,0 +1,29 @@
+<?php
+
+function conexionBD() {
+    // Configuración para Laragon
+    $servidor = "localhost";
+    $bd       = "triviagmatico"; // Asegúrate de que este sea el nombre de tu BD en HeidiSQL / phpMyAdmin
+    $usuario  = "root";
+    $pass     = "";            // Laragon deja la contraseña de root vacía por defecto
+    $puerto   = "3306";
+
+    try {
+        $dsn = "mysql:host=$servidor;port=$puerto;dbname=$bd;charset=utf8mb4";
+
+        $opciones = [
+            PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
+            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
+            PDO::ATTR_EMULATE_PREPARES   => false,
+        ];
+
+        return new PDO($dsn, $usuario, $pass, $opciones);
+
+    } catch (PDOException $error) {
+        return [
+            'error'         => 'No se pudo conectar a la base de datos.',
+            'error_tecnico' => $error->getMessage()
+        ];
+    }
+}
+?>