Aprendiendo programación (en java) a través de (un plugin para) Minecraft

1. Tema 1: Introducción a Java y sintaxis básica

   Conceptos básicos: tipos de datos, variables, operadores y estructura general de un programa Java.

2. Tema 2: Estructuras de control y flujo

   Condicionales, bucles y manejo del flujo de ejecución en programas Java simples.

3. Tema 3: Conceptos de orientación a objetos

   Clases, objetos, encapsulación y visibilidad; primeros acercamientos a modelos orientados a objetos aplicables a plugins.

4. Tema 4: Visión general de Spigot/Bukkit y plugins

   Arquitectura básica de un plugin, roles de la API y el entorno de desarrollo recomendado.

• Actividad 1: Configuración del entorno de desarrollo

  Instalar JDK, escoger un IDE (IntelliJ IDEA o Eclipse) y configurar un proyecto de ejemplo para compilar código Java básico. Objetivo: que el alumnado logre crear y ejecutar un programa Java simple sin errores de compilación.

  • Instalación de JDK 17 o superior.
  • Creación de un proyecto Java y escritura de un programa "Hola, mundo".
• Actividad 2: Primer programa orientado a objetos

  Crear una clase simple que modela una entidad genérica (por ejemplo, ObjetoMinecraft) con atributos y métodos básicos. Objetivo: practicar encapsulación y uso de métodos.

  • Definir variables privadas, constructores y getters/setters.
  • Ejecutar un método de prueba que muestre valores por consola.
• Actividad 3: Discusión guiada sobre OO y Minecraft

  Analizar ejemplos de entidades de Minecraft (jugador, bloque, evento) y discutir cómo se modelarían como clases en Java. Objetivo: activar el pensamiento de diseño orientado a objetos aplicado al dominio del juego.

  • Identificar atributos y comportamientos relevantes de cada entidad.
  • Propuesta de relaciones entre clases (asociaciones, agregaciones).

Evaluación formativa basada en la participación y en la entrega de las actividades de la unidad:

• Comprensión de conceptos básicos de Java y OO (40%).
• Capacidad para justificar la relevancia de Java en el desarrollo de plugins (30%).
• Calidad de las actividades prácticas de configuración y diseño OO (30%).

2 semanas

1. Tema 1: Variables y tipos de datos

   Primitivos (int, long, double, boolean, char) y objetos básicos, conversiones y valores por defecto.

2. Tema 2: Operadores y expresiones

   Aritméticos, lógicos y relacionales; construcción de expresiones y asignaciones combinadas.

3. Tema 3: Estructuras de control

   if/else, switch, bucles for/while; prácticas con ejemplos simples.

4. Tema 4: Clases y objetos simples

   Definición de clases,constructores, atributos y métodos; jerarquía de acceso y encapsulación básica.

• Actividad 1: Proyecto Java básico

  Crear una pequeña clase que represente una entidad de Minecraft (p. ej., BloqueMini) con atributos simples y un método que imprima su estado. Objetivo: practicar declaración de variables, métodos y encapsulación.

  • Definir al menos dos atributos y un método público.
  • Compilar y ejecutar desde la consola.
• Actividad 2: Control de flujo aplicado

  Escribir un programa que tome una entrada simulada y use estructuras de control para decidir una acción (p. ej., si un jugador tiene suficiente "energía" para activar un bloque).

  • Implementar condiciones y bucles básicos.
  • Verificar la salida ante diferentes entradas.
• Actividad 3: Diseño de clase orientada a objetos

  Definir una clase JugadorMini que modele atributos como nombre y nivel, con métodos para aumentar nivel y mostrar información.

  • Aplicar encapsulación y métodos de acceso.
  • Preparar el código para futuras extensiones del plugin.

La evaluación considera: comprensión de fundamentos de Java, capacidad de escribir código básico y diseño de una clase representativa de entidades Minecraft.

• Calidad del código Java básico (25%).
• Correcta utilización de estructuras de control (25%).
• Diseño de al menos una clase representativa (50%).

2 semanas

1. Tema 1: Clases, objetos y encapsulación

   Patrones de diseño básicos para representar entidades del juego con privaciones de acceso y métodos.

2. Tema 2: Relaciones entre clases

   Asociaciones, agregaciones y composición; cuándo usar cada una en el diseño de un plugin.

3. Tema 3: Modelado de entidades: Jugador, Bloque, Evento

   Definición de atributos clave y comportamientos para cada entidad y sus interacciones.

4. Tema 4: Estructura de clases en Java para plugins

   Convenciones de nombres, organización de paquetes y documentación mínima.

• Actividad 1: Boceto de clases

  Diseñar diagramas simples (en papel o digital) para Jugador, Bloque y Evento, indicando atributos y métodos principales.

  • Identificar relaciones entre las clases.
  • Justificar elecciones de encapsulación.
• Actividad 2: Skeleton de clases en Java

  Crear tres clases Java con atributos y métodos basados en el diseño anterior, con constructores y getters/setters.

  • Compilar y mostrar información mediante un método toString().
• Actividad 3: Interacciones básicas

  Implementar métodos que simulen interacción entre Jugador y Bloque (p. ej., jugador interactúa con un bloque para obtener un beneficio).

  • Verificar cohesión entre clases y facilidad de extensión.

Evaluación centrada en la calidad del diseño OO y la cohesión de las entidades modeladas.

• Claridad y coherencia del modelo OO (40%).
• Encapsulación y responsabilidades de cada clase (25%).
• Capacidad de extender el modelo para incluir nuevas entidades (35%).

3 semanas

1. Tema 1: Estructura de un plugin Spigot: clase principal y plugin.yml

   Cómo organizar el código y la configuración necesaria para que el servidor cargue el plugin.

2. Tema 2: Listeners y registro de eventos

   Cómo suscribirse a eventos de Minecraft y ejecutar lógica cuando ocurren.

3. Tema 3: Respuestas a eventos: mensajes y acciones

   Cómo interactuar con el mundo y los jugadores en respuesta a eventos usando la API.

• Actividad 1: Esqueleto del plugin

  Crear la clase principal que extienda JavaPlugin y un plugin.yml mínimo. Objetivo: entender el ciclo de vida del plugin.

  • Definir nombre, versión y punto de entrada.
• Actividad 2: Registrar BlockBreakEvent

  Implementar un Listener que detecte la rotura de bloques y envíe un mensaje al jugador que participó en la acción.

  • Utilizar el método onBlockBreak y enviar un título o chat message al jugador.
• Actividad 3: Prueba en servidor local

  Empaquetar el plugin, copiar el JAR al servidor de pruebas y verificar que al romper un bloque el jugador reciba el mensaje correspondiente.

  • Revisar logs y confirmar que no hay errores de carga.

Evaluación del diseño, implementación y prueba del plugin básico.

• Funcionamiento correcto del evento (35%).
• Calidad del código y claridad del flujo de ejecución (25%).
• Capacidad de prueba en servidor local y manejo de errores (20%).
• Documentación mínima en el código (20%).

2 semanas

1. Tema 1: Eventos avanzados y filtros

   Detección de eventos relevantes y uso de filtros para reducir el procesamiento innecesario.

2. Tema 2: Comandos personalizados

   Declaración, registro y manejo de argumentos básicos de comandos.

3. Tema 3: Permisos y seguridad

   Conceptos de permisos, integración con sistemas de permisos ya existentes y buenas prácticas.

4. Tema 4: Organización de código y documentación

   Convenciones de nombres, modularización y comentarios para facilitar mantenimiento.

• Actividad 1: Registro de eventos adicionales

  Ampliar el plugin para escuchar PlayerJoinEvent y enviar un saludo. Incluye manejo de condiciones simples y comentarios explicativos.

  • Mostrar mensaje de bienvenida al jugador que se une.
• Actividad 2: Comando sencillo

  Crear un comando /saludo que devuelva un mensaje personalizado al usuario y registre argumentos simples.

  • Parseo básico de argumentos, validaciones y respuestas.
• Actividad 3: Permisos y control de acceso

  Definir un permiso para activar una función del plugin (p. ej., acceso al comando) y aplicar verificación antes de ejecutar la acción.

  • Asociar permisos en plugin.yml y comprobar en la ejecución.

Evaluación del uso adecuado de la API, la implementación de comandos y permisos, y la organización del código.

• Correcto manejo de al menos dos eventos y un comando (40%).
• Operaciones de permisos y validación de acceso (25%).
• Calidad del código y comentarios/documentación (25%).
• Buenas prácticas de código y pruebas (10%).

2 semanas

1. Tema 1: Introducción a la configuración en Spigot

   Archivos de configuración, formato YAML y su uso típico en plugins.

2. Tema 2: Lectura y escritura de YAML/JSON

   Uso de bibliotecas y APIs para cargar y guardar datos estructurados.

3. Tema 3: Manejo de errores y validaciones

   Buenas prácticas para validar datos y manejar fallos de I/O de manera segura.

• Actividad 1: Configuración YAML

  Crear un archivo de configuración YAML con valores simples (p. ej., mensaje de bienvenida, contador de eventos) y cargarlo en la inicialización del plugin.

  • Validar la presencia de claves esperadas y aplicar valores predeterminados si faltan.
• Actividad 2: Lectura/escritura de puntuaciones

  Implementar un sistema de puntuaciones que se guarda en un archivo JSON y se actualiza al cumplir acciones específicas.

  • Manejo de errores de E/S y cierre correcto de recursos.
• Actividad 3: Pruebas de persistencia

  Probar lectura/escritura con valores distintos y simular fallos para asegurar robustez (faltante de archivo, permisos).

  • Registro de errores en logs para diagnóstico.

Evaluación de la capacidad de leer y escribir configuraciones y datos de puntuación, y de manejo de errores.

• Correcta persistencia de datos (40%).
• Manejo de errores y robustez (30%).
• Documentación mínima del flujo de lectura/escritura (30%).

2 semanas

1. Tema 1: Pruebas y verificación manual

   Procedimientos para validar comportamiento del plugin en un servidor local y registrar resultados.

2. Tema 2: Depuración y análisis de logs

   Lectura de logs, trazas de pila y técnicas para aislar fallos.

3. Tema 3: Manejo de errores comunes (NPE, null checks)

   Estrategias para evitar errores de nulo y mejorar la robustez del código.

• Actividad 1: Pruebas de regresión manual

  Ejecutar escenarios de uso del plugin y registrar resultados, comparando con expectativas.

  • Crear una matriz de pruebas y criterios de éxito.
• Actividad 2: Análisis de logs

  Analizar archivos de log para localizar fallos y proponer soluciones.

  • Práctica de lectura de trazas y utilidades de filtrado.
• Actividad 3: Corrección de errores comunes

  Aplicar mejoras como comprobaciones de null y manejo de excepciones para mejorar la estabilidad.

  • Refactorización mínima para evitar NPE.

Evaluación de la capacidad para subir la calidad, estabilidad y fiabilidad del plugin a través de pruebas y depuración.

• Estabilidad y ausencia de errores graves (40%).
• Capacidad de diagnóstico y solución de problemas (30%).
• Documentación de pruebas y resultados (30%).

2 semanas

1. Tema 1: Git y flujo de trabajo

   Conceptos básicos de Git, clonación, commits, ramas y resolución de conflictos con prácticas recomendadas.

2. Tema 2: Documentación y README

   Cómo estructurar un README útil: descripción, instalación, pruebas y guía de uso.

3. Tema 3: Pruebas de instalación y distribución

   Pasos para empaquetar el plugin y verificar su instalación en un servidor local.

• Actividad 1: Configurar repositorio Git

  Iniciar un repositorio, crear ramas para características y realizar commits con mensajes claros. Objetivo: practicar control de versiones y documentación de cambios.

  • Ignorar archivos innecesarios con .gitignore adecuado.
• Actividad 2: README y guía de instalación

  Redactar un README que describa el plugin, su objetivo, requisitos y pasos de instalación y pruebas.

  • Incluir ejemplos de ejecución y pruebas mínimas.
• Actividad 3: Empaquetado y prueba de distribución

  Generar el JAR del plugin, moverlo a un servidor local y verificar que se carga correctamente con el plugin.yml.

  • Verificar compatibilidad de versión de Spigot/Bukkit y JRE.

Evaluación del control de versiones, la calidad de la documentación y la capacidad de distribuir el plugin.

• Uso correcto de Git y claridad de commits (30%).
• Calidad de la documentación (30%).
• Completitud de la guía de instalación y pruebas (40%).

2 semanas