MazeFx

Índice

1. Descripción
2. Características
3. Tecnologías utilizadas
4. Requisitos
5. Ejecución del proyecto
6. Estructura
7. Mejoras Futuras

Descripción

MazeFx es un juego interactivo desarrollado en Java utilizando el framework JavaFX para crear interfaces gráficas. El juego permite al usuario generar laberintos personalizados y explorarlos.

El jugador puede configurar el laberinto especificando el tamaño y la semilla (seed) que se utiliza para generar el mapa, se puede introducir tanto un número como una cadena de carácteres. A continuación, se presenta un algoritmo de Backtracking que visualiza la generación del laberinto en tiempo real. Una vez generado el laberinto, el jugador controla un pequeño cuadrado que representa al personaje, y su objetivo es llegar desde la casilla de entrada hasta la salida, utilizando las teclas W, A, S y D para moverse.

El desempeño del jugador se mide en función de los movimientos realizados, y se calcula una puntuación en función del tamaño del laberinto y la cantidad de movimientos utilizados para alcanzar la meta.

Características

• Generación de laberintos aleatorios: Puedes generar laberintos personalizados mediante la elección del tamaño y la semilla.
• Algoritmo de Backtracking: Utiliza el algoritmo de Backtracking para generar el laberinto de manera eficiente y visual.
• Interfaz gráfica: Desarrollado con JavaFX, lo que proporciona una interfaz visual atractiva y moderna.
• Contador de movimientos y puntuación: El jugador recibe una puntuación basada en el número de movimientos realizados y el tamaño del laberinto.
• Control con teclado: El jugador puede mover al personaje usando las teclas W (arriba), A (izquierda), S (abajo) y D (derecha).
• Validación de entradas: Asegura que los parámetros ingresados por el usuario para el laberinto sean válidos (tamaño mínimo de 5, semilla numérica).

Tecnologías Utilizadas

• Lenguaje: Java
• Framework: JavaFX para la creación de la interfaz gráfica y renderizado del laberinto
• Algoritmo: Backtracking para la generación de laberintos

Requisitos

• Tener instalado Java 11 o superior.
• Tener configurado JavaFX en tu entorno de desarrollo.

Ejecución del Proyecto

1. Compilar y ejecutar el proyecto: Desde tu IDE favorito (Eclipse, IntelliJ, etc.) o desde la línea de comandos utilizando Maven o Gradle.
2. Configurar el laberinto: Al iniciar el juego y pulsar start, se abrirá una ventana de diálogo para establecer el tamaño (mínimo 5) y la seed. La seed puede ser cualquier valor entero o incluso una cadena de carácteres (el valor de la cadena se convierte a un hash numérico).
3. Disfrutar del juego: Una vez generado el laberinto, puedes comenzar a jugar moviendo el jugador con las teclas W, A, S y D.

Estructura del Proyecto

E:.
├───java
│   │   module-info.java                            // Define el módulo del proyecto y sus dependencias
│   │
│   └───com
│       └───mazefx                                  // Paquete principal de la aplicación
│           ├───controller                          // Controladores (MVC - Lógica de interfaz)
│           │   │   LoadViewController.java         // Controlador de la vista de carga de laberintos
│           │   │   MainController.java             // Controlador de la vista principal
│           │   │   MazeController.java             // Controlador para interactuar con el laberinto durante el juego
│           │
│           ├───logic                               // Lógica para la generación y resolución del laberinto
│           │   ├───model                           // Modelos (MVC - Lógica de datos)
│           │   │   │   Maze.java                   // Representa el laberinto, sus características y mapa
│           │   │   │   MapCoordinates.java         // Representa las coordenadas de una celda en el laberinto
│           │   │   │   TileType.java               // Enum que define los tipos de tiles (piso, pared, etc.)
│           │   │   │   Player.java                 // Representa al jugador
│           │   │
│           │   ├───maze                            // Lógica relacionada con la generación y resolución del laberinto
│           │   │   │   MazeGenerator.java          // Genera el laberinto usando el algoritmo de Backtracking
│           │   │   │   Direction.java             // Enum que define las direcciones posibles en el laberinto
│           │   │   │   MazeManager.java           // Gestiona la configuración y regeneración del laberinto
│           │   │
│           │   └───player                          // Lógica relacionada con el jugador
│           │       │   PlayerController.java      // Controla el movimiento del jugador
│           │       │   ScoreManager.java          // Gestiona el puntaje del jugador
│           │       │   Timer.java                 // Clase para simular tiempo transcurrido, sirve para limitar acciones.
│           │
│           ├───util                                // Clases utilitarias para la vista y la lógica de juego
│           │   │   ViewConstants.java              // Contiene las constantes utilizadas en la vista
│           │   │   CanvasRenderer.java             // Clase para renderizar en el canvas
│           │   │   TileManager.java                // Singletón que administra los tiles del laberinto
│           │   │   SceneManager.java               // Gestiona las escenas y transiciones entre vistas
│           │
│           └───view                                // Vistas (MVC - Interfaz gráfica)
│               │   │   MainView.java               // Clase que representa la vista principal del juego
│               │   │   MazeConfigurationDialog.java// Cuadro de diálogo para configurar el laberinto
    │               │   VictoryDialog.java          // Dialogo de emergente que sale cuando se escapa del laberinto
│
└───resources                                      // Carpeta que contiene los recursos (archivos FXML, imágenes, etc.)
    │   load-view.fxml                             // Archivo FXML para la vista de carga de laberintos
    │   main-view.fxml                             // Archivo FXML para la vista principal del juego
    │   maze-view.fxml                             // Archivo FXML para la vista del laberinto

Mejoras Futuras

Debido a la falta de tiempo, algunas mecánicas importantes no han podido ser desarrolladas, como el sistema de victoria/derrota. Sin embargo, existen varias ideas que se podrían implementar en el futuro para mejorarlo:

Mecánicas y Jugabilidad

• Sistema de derrota: Implementación de un sistema que permita detectar cuándo el jugador se queda atrapado cuando su puntuación llega a 0.

Mejoras Técnicas

• Algoritmos de generación de laberintos: Integrar algoritmos como Prim o Kruskal para ofrecer diferentes experiencias de generación de laberintos.
• Sistema de semillas secretas: Establecer semillas especiales que generen laberintos únicos o con características inusuales, creando desafíos adicionales para los jugadores.

Mejoras Visuales

• Interfaz gráfica mejorada: Añadir animaciones y efectos visuales complejos para hacer que la experiencia sea más atractiva y dinámica.
• Uso de sprites: Reemplazar los colores planos por un sistema de sprites (imágenes) para dar un aspecto visual más rico y variado.

Otras Ideas

• Guardar y cargar laberintos: Implementar una funcionalidad para guardar laberintos generados y permitir que los jugadores los carguen y jueguen en cualquier momento.