diff --git a/clases/ClasePregunta.php b/clases/ClasePregunta.php
index 937331f..cfd2049 100644
--- a/clases/ClasePregunta.php
+++ b/clases/ClasePregunta.php
@@ -1,88 +1,53 @@
 <?php
 require_once '../includes/conexionBD.php';
 
-// Definición de la clase Pregunta que representará las preguntas de la trivia
 class Pregunta {
-    // ATRIBUTOS (Propiedades privadas para encapsular el estado de cada pregunta)
-    private ?int $id_pregunta;     // El ID de la pregunta (autoincremental en la BD)
-    private int $id_categoria;     // El ID de la categoría a la que pertenece la pregunta
-    private string $texto_pregunta; // El enunciado de la pregunta
-    private array $respuestas;     // Array que guardará la lista de respuestas posibles asociadas a esta pregunta
+    private ?int $idPregunta;
+    private int $idCategoria;
+    private string $nombrePregunta;
+    private array $respuestas; 
 
-    // CONSTRUCTOR: Inicializa una nueva instancia de la clase Pregunta (sin pedir PDO de forma externa)
-    public function __construct(int $id_categoria = 0, string $texto_pregunta = "", ?int $id_pregunta = null) {
-        $this->id_pregunta = $id_pregunta;       // Asigna el ID (null si es una nueva pregunta que no se ha guardado)
-        $this->id_categoria = $id_categoria;     // Asigna la categoría correspondiente
-        $this->texto_pregunta = $texto_pregunta; // Asigna el texto de la pregunta
-        $this->respuestas = [];                  // Inicializa el contenedor de respuestas como un array vacío
+    public function __construct(int $idCategoria = 0, string $nombrePregunta = "", ?int $idPregunta = null) {
+        $this->idPregunta = $idPregunta;
+        $this->idCategoria = $idCategoria;
+        $this->nombrePregunta = $nombrePregunta;
+        $this->respuestas = [];
     }
 
-    // --- GETTERS Y SETTERS ---
-
-    // Getter para obtener el ID de la pregunta (solo lectura)
-    public function getIdPregunta(): ?int { 
-        return $this->id_pregunta; 
-    }
+    public function getIdPregunta(): ?int { return $this->idPregunta; }
     
-    // Getter para obtener el ID de la categoría
-    public function getIdCategoria(): int { 
-        return $this->id_categoria; 
-    }
-    
-    // Setter para cambiar la categoría de la pregunta
-    public function setIdCategoria(int $id_categoria): void { 
-        $this->id_categoria = $id_categoria; 
-    }
+    public function getIdCategoria(): int { return $this->idCategoria; }
+    public function setIdCategoria(int $idCategoria): void { $this->idCategoria = $idCategoria; }
 
-    // Getter para obtener el texto de la pregunta
-    public function getTextoPregunta(): string { 
-        return $this->texto_pregunta; 
-    }
-    
-    // Setter para cambiar el texto de la pregunta
-    public function setTextoPregunta(string $texto_pregunta): void { 
-        $this->texto_pregunta = $texto_pregunta; 
-    }
+    public function getNombrePregunta(): string { return $this->nombrePregunta; }
+    public function setNombrePregunta(string $nombrePregunta): void { $this->nombrePregunta = $nombrePregunta; }
 
-    // Getter para obtener el array con todas las respuestas cargadas de esta pregunta
-    public function getRespuestas(): array { 
-        return $this->respuestas; 
-    }
+    public function getRespuestas(): array { return $this->respuestas; }
 
-    // --- MÉTODOS DE BASE DE DATOS ---
-
-    // Método para guardar una nueva pregunta en la base de datos
     public function guardar() {
-        // Obtenemos la conexión llamando a tu función unificada del proyecto
         $conexion = conexionBD();
 
-        // Si devuelve un array significa que ocurrió un error controlado al conectar
         if (is_array($conexion)) {
             return $conexion;
         }
 
         try {
-            // Preparamos la consulta SQL para insertar la categoría y el texto de la pregunta
-            $sql = "INSERT INTO pregunta (id_categoria, texto_pregunta) VALUES (:id_cat, :texto)";
+            $sql = "INSERT INTO pregunta (idCategoria, nombrePregunta) VALUES (:idCat, :texto)";
             $stmt = $conexion->prepare($sql);
             
-            // Ejecutamos la consulta asociando los atributos actuales del objeto a los marcadores SQL
             $stmt->execute([
-                ':id_cat' => $this->id_categoria,
-                ':texto' => $this->texto_pregunta
+                ':idCat' => $this->idCategoria,
+                ':texto' => $this->nombrePregunta
             ]);
 
-            // Si se guardó correctamente, actualizamos el atributo id_pregunta del objeto con el ID generado en la BD
-            $this->id_pregunta = (int)$conexion->lastInsertId();
+            $this->idPregunta = (int)$conexion->lastInsertId();
 
-            // Devolvemos la respuesta formateada con éxito e ID técnico para tu proyecto
             return [
                 'exito' => 'Pregunta guardada correctamente',
-                'exito_tecnico' => $this->id_pregunta
+                'exito_tecnico' => $this->idPregunta
             ];
 
         } catch (PDOException $error) {
-            // Si falla la inserción en MySQL, capturamos el error
             return [
                 'error' => 'Ocurrió un error al guardar la pregunta.',
                 'error_tecnico' => $error->getMessage()
@@ -90,30 +55,23 @@ class Pregunta {
         }
     }
 
-    // Método para buscar y cargar en memoria todas las respuestas asociadas a esta pregunta concreta
     public function cargarRespuestas() {
-        // Si la pregunta aún no está guardada en la BD (su ID es null), no podemos buscar sus respuestas
-        if ($this->id_pregunta === null) return;
+        if ($this->idPregunta === null) return;
 
-        // Obtenemos la conexión llamando a tu función unificada del proyecto
         $conexion = conexionBD();
 
-        // Si devuelve un array significa que ocurrió un error al conectar
         if (is_array($conexion)) {
             return $conexion;
         }
 
         try {
-            // Consulta SQL adaptada exactamente a tus columnas reales: texto_respuesta y es_correcta
-            $sql = "SELECT id_respuesta, texto_respuesta, es_correcta FROM respuesta WHERE id_pregunta = :id_preg";
+            $sql = "SELECT idRespuesta, nombreRespuesta, correcta FROM respuesta WHERE idPregunta = :idPreg";
             $stmt = $conexion->prepare($sql);
-            $stmt->execute([':id_preg' => $this->id_pregunta]);
+            $stmt->execute([':idPreg' => $this->idPregunta]);
             
-            // Guardamos todas las filas encontradas directamente dentro del array de respuestas del objeto
             $this->respuestas = $stmt->fetchAll(PDO::FETCH_ASSOC);
 
         } catch (PDOException $error) {
-            // Capturamos cualquier excepción de base de datos
             return [
                 'error' => 'Ocurrió un error al cargar las respuestas.',
                 'error_tecnico' => $error->getMessage()
@@ -121,43 +79,30 @@ class Pregunta {
         }
     }
 
-    // Método estático para obtener un listado de preguntas aleatorias filtradas por una categoría
-    public static function obtenerPorCategoria(int $id_categoria, int $limite = 10) {
-        // Obtenemos la conexión llamando a tu función unificada del proyecto
+    public static function obtenerPorCategoria(int $idCategoria, int $limite = 10) {
         $conexion = conexionBD();
 
-        // Si devuelve un array significa que ocurrió un error al conectar
         if (is_array($conexion)) {
             return $conexion;
         }
 
         try {
-            // Consulta SQL que filtra por categoría, desordena los resultados al azar (RAND()) y limita la cantidad
-            $sql = "SELECT * FROM pregunta WHERE id_categoria = :id_cat ORDER BY RAND() LIMIT :limite";
+            $sql = "SELECT * FROM pregunta WHERE idCategoria = :idCat ORDER BY RAND() LIMIT :limite";
             $stmt = $conexion->prepare($sql);
             
-            // Vinculamos los parámetros asegurando que el límite sea interpretado estrictamente como un número entero (PARAM_INT)
-            $stmt->bindValue(':id_cat', $id_categoria, PDO::PARAM_INT);
+            $stmt->bindValue(':idCat', $idCategoria, PDO::PARAM_INT);
             $stmt->bindValue(':limite', $limite, PDO::PARAM_INT);
-            $stmt->execute(); // Ejecutamos la consulta
+            $stmt->execute();
 
-            $preguntas = []; // Array donde amontonaremos los objetos Pregunta resultantes
-            
-            // Recorremos fila por fila los resultados devueltos por la base de datos
+            $preguntas = [];
             while ($datos = $stmt->fetch(PDO::FETCH_ASSOC)) {
-                // Creamos un nuevo objeto Pregunta con los datos de la fila actual
-                $preg = new Pregunta($datos['id_categoria'], $datos['texto_pregunta'], $datos['id_pregunta']);
-                
-                // Llamamos al método interno del objeto para que busque y le pegue sus opciones de respuesta correspondientes
-                $preg->cargarRespuestas(); 
-                
-                // Añadimos el objeto completamente armado al array final
+                $preg = new Pregunta((int)$datos['idCategoria'], $datos['nombrePregunta'], (int)$datos['idPregunta']);
+                $preg->cargarRespuestas();
                 $preguntas[] = $preg;
             }
-            return $preguntas; // Devolvemos la lista de objetos Pregunta listos para jugar
+            return $preguntas;
 
         } catch (PDOException $error) {
-            // Capturamos cualquier error en la consulta aleatoria
             return [
                 'error' => 'Ocurrió un error al obtener las preguntas aleatorias.',
                 'error_tecnico' => $error->getMessage()
diff --git a/clases/ClaseUsuario.php b/clases/ClaseUsuario.php
index 8c7b6eb..3b31c6d 100644
--- a/clases/ClaseUsuario.php
+++ b/clases/ClaseUsuario.php
@@ -1,97 +1,98 @@
 <?php
 require_once '../includes/conexionBD.php';
 
-// Definición de la clase Usuario que representará a los usuarios del sistema
 class Usuario {
-    // ATRIBUTOS (Propiedades privadas para proteger los datos de accesos directos externos)
-    private ?int $id_usuario;      // El ID del usuario (puede ser null si aún no se ha guardado en la base de datos)
-    private string $nombre_usuario; // El nombre de usuario en texto
-    private string $contrasena;     // La contraseña (normalmente encriptada)
-    private string $email;          // El correo electrónico del 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;
 
-    // CONSTRUCTOR: Se ejecuta automáticamente al crear un nuevo objeto (ya no pide base de datos por parámetro)
-    public function __construct(string $nombre_usuario = "", string $contrasena = "", string $email = "", ?int $id_usuario = null) {
-        $this->id_usuario = $id_usuario;         // Asigna el ID (por defecto es null si es un registro nuevo)
-        $this->nombre_usuario = $nombre_usuario; // Asigna el nombre de usuario recibido
-        $this->contrasena = $contrasena;         // Asigna la contraseña recibida
-        $this->email = $email;                   // Asigna el email recibido
+    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;
     }
 
-    // --- GETTERS Y SETTERS (Métodos públicos para acceder y modificar los datos privados de forma segura) ---
-
-    // Getter para obtener el ID del usuario (es de solo lectura, no tiene setter)
-    public function getIdUsuario(): ?int { 
-        return $this->id_usuario; 
-    }
+    public function getIdUsuario(): ?int { return $this->idUsuario; }
     
-    // Getter para obtener el nombre de usuario
-    public function getNombreUsuario(): string { 
-        return $this->nombre_usuario; 
-    }
-    
-    // Setter para cambiar el nombre de usuario desde fuera de la clase
-    public function setNombreUsuario(string $nombre_usuario): void { 
-        $this->nombre_usuario = $nombre_usuario; 
-    }
+    public function getNombreUsuario(): string { return $this->nombreUsuario; }
+    public function setNombreUsuario(string $nombreUsuario): void { $this->nombreUsuario = $nombreUsuario; }
 
-    // Getter para obtener la contraseña
-    public function getContrasena(): string { 
-        return $this->contrasena; 
-    }
-    
-    // Setter para cambiar la contraseña desde fuera de la clase
-    public function setContrasena(string $contrasena): void { 
-        $this->contrasena = $contrasena; 
-    }
+    public function getContrasena(): string { return $this->contrasena; }
+    public function setContrasena(string $contrasena): void { $this->contrasena = $contrasena; }
 
-    // Getter para obtener el correo electrónico
-    public function getEmail(): string { 
-        return $this->email; 
-    }
-    
-    // Setter para cambiar el correo electrónico desde fuera de la clase
-    public function setEmail(string $email): void { 
-        $this->email = $email; 
-    }
+    public function getEmail(): string { return $this->email; }
+    public function setEmail(string $email): void { $this->email = $email; }
 
-    // --- MÉTODOS DE BASE DE DATOS (Lógica de negocio e interacción con SQL) ---
+    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; }
 
-    // Método para registrar/insertar el usuario actual en la base de datos
     public function registrar() {
-        // Obtenemos la conexión llamando a tu función unificada del proyecto
         $conexion = conexionBD();
 
-        // Si devuelve un array significa que ocurrió un error controlado al conectar
         if (is_array($conexion)) {
             return $conexion;
         }
 
         try {
-            // Preparamos la consulta SQL usando marcadores (:nombre, :pass, :email) para evitar inyecciones SQL
-            $sql = "INSERT INTO usuario (nombre_usuario, contrasena, email) VALUES (:nombre, :pass, :email)";
-            $stmt = $conexion->prepare($sql); // Prepara la consulta en el servidor de la base de datos
+            $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);
             
-            // Encriptamos la contraseña con el algoritmo BCRYPT antes de guardarla por seguridad
             $passHash = password_hash($this->contrasena, PASSWORD_BCRYPT);
 
-            // Ejecutamos la consulta pasando los valores reales que sustituirán a los marcadores
             $stmt->execute([
-                ':nombre' => $this->nombre_usuario,
-                ':pass' => $passHash, // Guardamos la contraseña ya encriptada
-                ':email' => $this->email
+                ':nombre' => $this->nombreUsuario,
+                ':pass' => $passHash,
+                ':email' => $this->email,
+                ':avatar' => $this->avatar,
+                ':cookie' => $this->cookie,
+                ':aciertos' => $this->aciertos,
+                ':victorias' => $this->victorias,
+                ':derrotas' => $this->derrotas
             ]);
 
-            // Si la inserción fue exitosa, recuperamos el ID generado por la base de datos y lo asignamos al objeto
-            $this->id_usuario = (int)$conexion->lastInsertId();
+            $this->idUsuario = (int)$conexion->lastInsertId();
 
-            // Devolvemos una respuesta de éxito idéntica al formato del resto de tus clases
             return [
                 'exito' => 'Usuario registrado correctamente',
-                'exito_tecnico' => $this->id_usuario
+                'exito_tecnico' => $this->idUsuario
             ];
 
         } catch (PDOException $error) {
-            // Si ocurre algún fallo en la consulta, capturamos el error y devolvemos la respuesta controlada
             return [
                 'error' => 'Ocurrió un error al registrar el usuario.',
                 'error_tecnico' => $error->getMessage()
@@ -99,41 +100,43 @@ class Usuario {
         }
     }
 
-    // Método estático para buscar un usuario por su ID sin necesidad de instanciar el objeto previamente
     public static function buscarPorId($id) {
-        // Obtenemos la conexión llamando a tu función unificada del proyecto
         $conexion = conexionBD();
 
-        // Si devuelve un array significa que ocurrió un error controlado al conectar
         if (is_array($conexion)) {
             return $conexion;
         }
 
         try {
-            // Preparamos la consulta SQL filtrando por el ID recibido
-            $sql = "SELECT * FROM usuario WHERE id_usuario = :id";
+            $sql = "SELECT * FROM usuario WHERE idUsuario = :id";
             $stmt = $conexion->prepare($sql);
-            $stmt->execute([':id' => $id]); // Ejecutamos la consulta
+            $stmt->execute([':id' => $id]);
             
-            // Obtenemos el registro en forma de array asociativo
             $datos = $stmt->fetch(PDO::FETCH_ASSOC);
 
-            // Si el usuario existe en la base de datos, creamos y devolvemos un nuevo objeto Usuario con sus datos
             if ($datos) {
-                return new Usuario($datos['nombre_usuario'], $datos['contrasena'], $datos['email'], $datos['id_usuario']);
+                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']
+                );
             }
             
-            // Si la consulta termina pero no encuentra filas, devolvemos un aviso de error controlado
             return [
                 'error' => 'No se encontró ningún usuario con ese ID.'
             ];
 
         } catch (PDOException $error) {
-            // Si ocurre algún fallo en la consulta SQL, capturamos el error
             return [
                 'error' => 'Ocurrió un error al buscar el usuario.',
                 'error_tecnico' => $error->getMessage()
             ];
         }
     }
-}
+}
\ No newline at end of file