_r10a_
📎 1 file 19,492 chars
📄
pasted-code-1791420360514.txt
txt 1167 lines
▶
Quiero que desarrolles desde cero un plugin de Minecraft llamado **LunarisTrabajos**, compatible con **Minecraft 1.20.1**.

El plugin está pensado principalmente para un servidor **Minecraft Roleplay**, por lo que debe ser profesional, modular, optimizado y fácil de integrar con otros plugins.

## OBJETIVO PRINCIPAL

LunarisTrabajos será un sistema completo de trabajos/empleos.

Un administrador podrá:

* Crear trabajos.
* Eliminar trabajos.
* Editar trabajos.
* Asignar un jefe a cada trabajo.
* Quitar el jefe.
* Gestionar empleados.
* Configurar permisos de cada trabajo.
* Configurar rangos dentro de los trabajos.
* Consultar información de los trabajos.

Cada trabajo debe funcionar de manera independiente.

Los jefes podrán gestionar su propio trabajo sin necesitar permisos administrativos, siempre respetando los permisos configurados.

El sistema debe estar diseñado para que posteriormente pueda crear un **panel GUI externo** utilizando otro plugin. Por esta razón, NO quiero que la lógica principal dependa de una GUI.

Todo debe poder manejarse mediante:

* Comandos.
* Subcomandos.
* Permisos.
* Placeholders/variables.
* Archivos YAML.
* API interna.

---

# 1. ESTRUCTURA DEL PLUGIN

El plugin debe llamarse:

**LunarisTrabajos**

Package recomendado:

`com.lunaris.trabajos`

Debe incluir:

* `plugin.yml`
* Configuración general.
* Sistema de trabajos.
* Sistema de empleados.
* Sistema de jefes.
* Sistema de rangos.
* Sistema de permisos.
* Sistema de placeholders.
* Sistema de archivos YAML individuales.
* API pública.
* Eventos Bukkit.
* Comandos.
* Sistema de mensajes configurable.
* Caché para evitar lecturas constantes de archivos.

---

# 2. SISTEMA DE TRABAJOS

Cada trabajo tendrá un identificador único.

Ejemplos:

```text
policia
medicos
juzgado
psicologos
```

Cuando un administrador cree un nuevo trabajo, el plugin debe crear automáticamente un archivo:

```text
plugins/LunarisTrabajos/jobs/nombre-del-trabajo.yml
```

Por ejemplo:

```text
plugins/LunarisTrabajos/jobs/policia.yml
plugins/LunarisTrabajos/jobs/medicos.yml
plugins/LunarisTrabajos/jobs/juzgado.yml
plugins/LunarisTrabajos/jobs/psicologos.yml
```

Si posteriormente el administrador ejecuta:

```text
/trabajos crear bomberos
```

debe generarse:

```text
plugins/LunarisTrabajos/jobs/bomberos.yml
```

No quiero tener que editar manualmente un archivo principal para crear trabajos.

---

# 3. ARCHIVO YAML DE CADA TRABAJO

Cada trabajo debe tener su propio YAML.

Ejemplo:

```yaml
id: policia

name: "Policía"

display-name: "&9&lPOLICÍA"

description:
  - "&7Departamento encargado"
  - "&7de mantener la seguridad."

enabled: true

boss:
  uuid: ""

settings:
  max-employees: -1
  require-boss: false

permissions:
  on-join:
    - "lunaris.trabajo.policia"
    - "lunaris.policia.radio"
    - "lunaris.policia.operativo"

  on-leave:
    - "lunaris.policia.radio"
    - "lunaris.policia.operativo"

ranks:
  cadete:
    display-name: "&7Cadete"
    permissions:
      - "lunaris.policia.cadete"

  oficial:
    display-name: "&fOficial"
    permissions:
      - "lunaris.policia.oficial"

  sargento:
    display-name: "&eSargento"
    permissions:
      - "lunaris.policia.sargento"

  comandante:
    display-name: "&6Comandante"
    permissions:
      - "lunaris.policia.comandante"
```

La estructura debe ser flexible y permitir agregar más configuraciones posteriormente.

---

# 4. PERMISOS CONFIGURABLES

Una característica MUY IMPORTANTE:

Quiero poder definir en el YAML de cada trabajo los permisos que recibirá un jugador cuando sea asignado a ese trabajo.

Por ejemplo:

```yaml
permissions:
  on-join:
    - "lunaris.trabajo.policia"
    - "lunaris.policia.radio"
    - "lunaris.policia.armas"

  on-leave:
    - "lunaris.trabajo.policia"
    - "lunaris.policia.radio"
```

El plugin debe encargarse de otorgar y retirar esos permisos.

IMPORTANTE:

El sistema debe ser compatible con sistemas de permisos externos cuando sea posible, especialmente:

**LuckPerms**

Si LuckPerms está instalado, utilizar su API en lugar de intentar modificar permisos manualmente.

Debe existir soporte para:

* Añadir permisos.
* Quitar permisos.
* Permisos por rango.
* Permisos al entrar al trabajo.
* Permisos al abandonar el trabajo.

---

# 5. RANGOS DE TRABAJO

Cada trabajo podrá tener diferentes rangos.

Ejemplo:

```yaml
ranks:

  cadete:
    display-name: "&7Cadete"
    permissions:
      - "lunaris.policia.cadete"

  oficial:
    display-name: "&fOficial"
    permissions:
      - "lunaris.policia.oficial"

  sargento:
    display-name: "&eSargento"
    permissions:
      - "lunaris.policia.sargento"

  comandante:
    display-name: "&6Comandante"
    permissions:
      - "lunaris.policia.comandante"
```

El jefe debe poder:

* Crear rangos.
* Eliminar rangos.
* Cambiar rangos.
* Asignar rangos.
* Quitar rangos.
* Promover empleados.
* Degradar empleados.

El rango de un jugador debe poder obtenerse mediante placeholders.

---

# 6. JEFE DEL TRABAJO

Cada trabajo puede tener un jefe.

El administrador podrá asignar a cualquier jugador como jefe.

Ejemplo:

```text
/trabajos jefe policia xDeividO
```

Al hacer esto:

```text
Trabajo: Policía
Jefe: xDeividO
```

El jefe podrá gestionar su trabajo.

El jefe podrá:

* Ver empleados.
* Contratar/asignar jugadores.
* Expulsar empleados.
* Promover.
* Degradar.
* Cambiar rangos.
* Consultar información del trabajo.
* Ver información de empleados.
* Gestionar configuraciones permitidas.

El jefe NO debe poder administrar otros trabajos.

---

# 7. EMPLEADOS

Cada jugador podrá tener un trabajo.

Por defecto quiero que un jugador solamente pueda tener un trabajo activo a la vez.

Debe ser posible configurar esto en:

```yaml
config.yml
```

Ejemplo:

```yaml
jobs:
  allow-multiple: false
```

Si está configurado en:

```yaml
allow-multiple: true
```

un jugador podrá pertenecer a varios trabajos.

---

# 8. CONTRATAR / ASIGNAR JUGADORES

El jefe podrá asignar jugadores a su trabajo.

Ejemplo:

```text
/trabajo contratar 
```

o:

```text
/trabajo contratar  
```

El sistema debe detectar automáticamente si quien ejecuta el comando es jefe de ese trabajo.

Al contratar:

1. Se registra al jugador.
2. Se asigna el trabajo.
3. Se asigna el rango inicial.
4. Se añaden los permisos configurados.
5. Se ejecuta un evento.
6. Se envía un mensaje configurable.
7. Se actualizan los placeholders.

---

# 9. DESPEDIR

El jefe podrá despedir empleados.

Ejemplo:

```text
/trabajo despedir 
```

Al despedir:

1. Se elimina la relación jugador → trabajo.
2. Se eliminan los permisos del trabajo.
3. Se eliminan los permisos del rango.
4. Se actualiza la información.
5. Se dispara un evento.
6. Se envía un mensaje configurable.

---

# 10. PROMOVER Y DEGRADAR

El jefe podrá modificar el rango de un empleado.

Ejemplo:

```text
/trabajo rango  
```

El sistema debe retirar los permisos del rango anterior y añadir los del nuevo rango.

Ejemplo:

```text
Cadete → Oficial
```

Debe quitar:

```text
lunaris.policia.cadete
```

y añadir:

```text
lunaris.policia.oficial
```

---

# 11. COMANDOS ADMINISTRATIVOS

Crear un comando principal:

```text
/trabajos
```

Debe tener subcomandos como:

```text
/trabajos crear 
/trabajos eliminar 
/trabajos recargar
/trabajos listar
/trabajos info 
/trabajos jefe  
/trabajos quitarjefe 
/trabajos contratar  
/trabajos despedir  
/trabajos rango   
/trabajos empleado 
```

Crear aliases razonables si son necesarios.

---

# 12. COMANDOS PARA JEFES

También quiero que existan comandos específicos para los jefes.

Por ejemplo:

```text
/trabajo
```

Comandos:

```text
/trabajo info
/trabajo empleados
/trabajo contratar 
/trabajo despedir 
/trabajo rango  
/trabajo promocionar 
/trabajo degradar 
```

El plugin debe comprobar automáticamente:

```text
¿El jugador es jefe?
```

Si no es jefe:

```text
No tienes permiso para gestionar este trabajo.
```

---

# 13. API

Crear una API pública para que otros plugins puedan interactuar con LunarisTrabajos.

Ejemplos de métodos:

```java
getJob(String jobId)

getPlayerJob(UUID player)

getPlayerJobs(UUID player)

isPlayerInJob(UUID player, String jobId)

isBoss(UUID player, String jobId)

getJobBoss(String jobId)

getEmployees(String jobId)

getPlayerRank(UUID player, String jobId)

setPlayerJob(UUID player, String jobId)

removePlayerJob(UUID player, String jobId)

setPlayerRank(UUID player, String jobId, String rank)

removePlayerFromJob(UUID player, String jobId)
```

La API debe estar documentada.

---

# 14. EVENTOS

Crear eventos Bukkit personalizados.

Por ejemplo:

```java
PlayerJoinJobEvent
PlayerLeaveJobEvent
PlayerPromoteJobEvent
PlayerDemoteJobEvent
JobCreatedEvent
JobDeletedEvent
BossAssignedEvent
BossRemovedEvent
```

Estos eventos permitirán que otros plugins reaccionen a las acciones.

---

# 15. PLACEHOLDERS

Esto es MUY IMPORTANTE porque voy a crear el panel del sistema con otro plugin.

Implementar soporte para **PlaceholderAPI**.

Crear placeholders como:

```text
%lunaristrabajos_job%
%lunaristrabajos_job_id%
%lunaristrabajos_job_name%
%lunaristrabajos_rank%
%lunaristrabajos_rank_name%
%lunaristrabajos_is_boss%
%lunaristrabajos_boss%
%lunaristrabajos_employee_count%
%lunaristrabajos_has_job%
```

También placeholders con parámetros:

```text
%lunaristrabajos_job_%
%lunaristrabajos_job__boss%
%lunaristrabajos_job__employees%
%lunaristrabajos_job__exists%
```

Si es técnicamente posible, implementar placeholders dinámicos de forma limpia.

Estos placeholders deben actualizarse correctamente.

---

# 16. VARIABLES PARA OTROS PLUGINS

Además de PlaceholderAPI, crear una API sencilla que permita que otros plugins consulten:

* Trabajo actual.
* ID del trabajo.
* Nombre del trabajo.
* Jefe.
* Rango.
* Lista de empleados.
* Cantidad de empleados.
* Si el jugador es jefe.
* Si pertenece a un trabajo.
* Lista de trabajos disponibles.

El objetivo es poder crear posteriormente un panel completamente externo.

---

# 17. TRABAJOS DE PRUEBA

El plugin debe incluir automáticamente 4 trabajos de ejemplo:

### Policía

ID:

```text
policia
```

Nombre:

```text
Policía
```

### Médicos

ID:

```text
medicos
```

Nombre:

```text
Médicos
```

### Juzgado

ID:

```text
juzgado
```

Nombre:

```text
Juzgado
```

### Psicólogos

ID:

```text
psicologos
```

Nombre:

```text
Psicólogos
```

Cada uno debe tener su propio YAML.

---

# 18. EJEMPLO DE POLICÍA

Crear:

```text
jobs/policia.yml
```

Con rangos de ejemplo:

```yaml
ranks:

  cadete:
    display-name: "&7Cadete"
    permissions:
      - "lunaris.policia.cadete"

  oficial:
    display-name: "&fOficial"
    permissions:
      - "lunaris.policia.oficial"

  sargento:
    display-name: "&eSargento"
    permissions:
      - "lunaris.policia.sargento"

  comandante:
    display-name: "&6Comandante"
    permissions:
      - "lunaris.policia.comandante"
```

---

# 19. EJEMPLO DE MÉDICOS

Crear:

```text
jobs/medicos.yml
```

Rangos:

```text
interno
doctor
cirujano
director
```

---

# 20. EJEMPLO DE JUZGADO

Crear:

```text
jobs/juzgado.yml
```

Rangos:

```text
asistente
abogado
juez
juez_supremo
```

---

# 21. EJEMPLO DE PSICÓLOGOS

Crear:

```text
jobs/psicologos.yml
```

Rangos:

```text
practicante
psicologo
especialista
director
```

---

# 22. CONFIGURACIÓN GLOBAL

Crear:

```text
config.yml
```

Con opciones como:

```yaml
settings:

  debug: false

  auto-save: true

  save-interval: 300

  allow-multiple-jobs: false

  require-boss-to-join: false

  default-rank: "default"

integrations:

  placeholderapi: true

  luckperms: true
```

---

# 23. DATOS DE LOS JUGADORES

No guardar toda la información de los jugadores dentro de los YAML de los trabajos.

Crear una carpeta:

```text
players/
```

Y guardar los datos de cada jugador de forma independiente.

Ejemplo:

```text
players/UUID.yml
```

Contenido:

```yaml
uuid: "UUID"

jobs:
  - id: policia
    rank: comandante
    joined: 2026-10-07
```

Esto debe permitir que el sistema sea escalable.

Si se utiliza una base de datos posteriormente, diseñar el código para poder reemplazar el sistema de almacenamiento sin reescribir todo el plugin.

---

# 24. ALMACENAMIENTO

Por defecto utilizar YAML.

Pero quiero que la arquitectura permita posteriormente añadir:

* SQLite.
* MySQL.
* MariaDB.

Crear una interfaz de almacenamiento, por ejemplo:

```java
JobStorage
```

con una implementación:

```java
YamlJobStorage
```

Esto permitirá añadir bases de datos en el futuro.

---

# 25. RECARGA

Crear:

```text
/trabajos recargar
```

Debe recargar:

* config.yml
* messages.yml
* todos los trabajos
* configuraciones
* placeholders

No debe ser necesario reiniciar el servidor para modificar un trabajo.

---

# 26. MENSAJES

Crear:

```text
messages.yml
```

Todo el texto que vea el jugador debe poder configurarse.

Ejemplo:

```yaml
prefix: "&8[&bLunarisTrabajos&8] "

no-permission: "&cNo tienes permiso."
job-created: "&aTrabajo creado correctamente."
job-deleted: "&cTrabajo eliminado."
boss-assigned: "&aJefe asignado correctamente."
employee-hired: "&aJugador contratado correctamente."
employee-fired: "&cJugador despedido."
rank-changed: "&aRango actualizado."
not-boss: "&cNo eres jefe de este trabajo."
job-not-found: "&cEse trabajo no existe."
```

Soportar:

* `&` colors.
* Hex colors si es compatible con 1.20.1.
* Placeholders dentro de los mensajes.

---

# 27. TAB COMPLETION

Todos los comandos deben tener autocompletado.

Ejemplo:

```text
/trabajos 
```

Mostrar:

```text
crear
eliminar
listar
info
jefe
quitarjefe
contratar
despedir
rango
recargar
```

Y:

```text
/trabajos info 
```

mostrar los trabajos existentes.

También autocompletar:

* Jugadores online.
* Rangos.
* IDs de trabajos.

---

# 28. SEGURIDAD

El plugin debe comprobar siempre permisos y propiedad.

Un jefe de:

```text
policia
```

NO puede ejecutar acciones administrativas sobre:

```text
medicos
```

Debe existir una separación clara entre:

### Administrador

Puede gestionar todos los trabajos.

### Jefe

Puede gestionar únicamente su trabajo.

### Empleado

No puede gestionar el trabajo.

### Jugador sin trabajo

No tiene permisos especiales.

---

# 29. PERMISOS DEL PLUGIN

Crear permisos como:

```text
lunaristrabajos.admin
lunaristrabajos.admin.create
lunaristrabajos.admin.delete
lunaristrabajos.admin.reload
lunaristrabajos.admin.assignboss
lunaristrabajos.admin.manage

lunaristrabajos.boss
lunaristrabajos.boss.manage

lunaristrabajos.employee
```

Pero NO limitar los permisos de los trabajos a permisos hardcodeados.

Los permisos específicos de cada trabajo deben venir del YAML.

---

# 30. COMPATIBILIDAD CON OFFLINE PLAYERS

El sistema debe trabajar correctamente con jugadores que no estén conectados.

Por ejemplo, un administrador debe poder asignar:

```text
/trabajos jefe policia NombreJugador
```

aunque ese jugador esté desconectado.

Usar UUID siempre que sea posible.

---

# 31. NO CREAR UNA GUI INTERNA OBLIGATORIA

No quiero que el plugin dependa de una GUI.

No es necesario crear:

* Menús.
* Inventarios.
* Interfaces gráficas.

La lógica debe estar disponible mediante comandos y API.

Posteriormente utilizaré otro plugin para crear el panel.

---

# 32. ARQUITECTURA

Utilizar una arquitectura limpia y modular.

Separar como mínimo:

```text
command/
job/
employee/
boss/
rank/
storage/
placeholder/
api/
event/
listener/
config/
util/
```

Evitar colocar toda la lógica en una sola clase.

Utilizar buenas prácticas de Java.

---

# 33. RENDIMIENTO

El plugin debe estar optimizado.

NO:

* Leer YAML constantemente.
* Escribir archivos en cada tick.
* Ejecutar operaciones pesadas en el hilo principal.
* Buscar jugadores recorriendo todos los jugadores constantemente.

Utilizar caché en memoria.

Guardar cambios de forma eficiente.

No generar lag aunque existan cientos o miles de empleados.

---

# 34. REGLAS IMPORTANTES

El código debe estar completamente funcional.

No quiero pseudocódigo.

No quiero:

```java
// TODO
```

para partes importantes.

No quiero métodos vacíos.

No quiero sistemas simulados.

Todo debe estar implementado.

Si necesitas utilizar una dependencia externa, indícala claramente y configura correctamente:

```text
plugin.yml
```

y el sistema de build.

Preferiblemente utilizar:

* Java 17.
* Spigot/Paper API compatible con Minecraft 1.20.1.
* Maven o Gradle.

---

# 35. RESULTADO FINAL

Quiero que entregues el proyecto completo de:

**LunarisTrabajos**

para:

**Minecraft 1.20.1**

Debe incluir:

```text
LunarisTrabajos/
├── src/
├── pom.xml
├── plugin.yml
└── README.md
```

Y al iniciar por primera vez:

```text
plugins/
└── LunarisTrabajos/
    ├── config.yml
    ├── messages.yml
    ├── jobs/
    │   ├── policia.yml
    │   ├── medicos.yml
    │   ├── juzgado.yml
    │   └── psicologos.yml
    └── players/
```

Los cuatro trabajos deben funcionar inmediatamente sin necesidad de configurarlos manualmente.

---

# 36. IMPORTANTE PARA EL DESARROLLO

Antes de terminar, revisa todo el proyecto y comprueba:

1. Que compile correctamente.
2. Que sea compatible con Minecraft 1.20.1.
3. Que los comandos funcionen.
4. Que los permisos funcionen.
5. Que LuckPerms funcione si está instalado.
6. Que PlaceholderAPI funcione si está instalado.
7. Que los YAML se generen correctamente.
8. Que los trabajos puedan crearse dinámicamente.
9. Que los jefes puedan administrar únicamente su trabajo.
10. Que los administradores puedan administrar todos los trabajos.
11. Que los jugadores puedan ser contratados/despedidos.
12. Que los rangos funcionen.
13. Que los permisos de los rangos funcionen.
14. Que los eventos funcionen.
15. Que la API esté disponible para otros plugins.
16. Que los datos sobrevivan a reinicios.
17. Que los jugadores offline sean compatibles.
18. Que `/trabajos recargar` funcione correctamente.
19. Que no existan errores de consola.
20. Que no haya operaciones innecesariamente pesadas en el servidor.

Finalmente, explica cómo instalar, configurar y utilizar el plugin, incluyendo todos los comandos, permisos, placeholders, estructura de los YAML y ejemplos de uso de la API.
Kodari AI
KodariOct 8 at 12:55 am 3
LunarisTrabajos
Un sistema completo de trabajos/empleos para servidores Minecraft Roleplay en 1.20.1. Permite crear, eliminar y editar trabajos dinámicamente con archivos YAML individuales. Incluye gestión de jefes, empleados y rangos con permisos configurables por trabajo. Soporta LuckPerms y PlaceholderAPI con placeholders dinámicos. Proporciona una API pública documentada, eventos Bukkit personalizados y almacenamiento en caché optimizado. Los jefes gestionan solo su trabajo mientras los administradores controlan todo. Compatible con jugadores offline y diseñado para futuras integraciones de bases de datos.
  1. Crearé la base Maven para Java 17/Spigot 1.20.1, con LuckPerms y PlaceholderAPI opcionales.

  2. Implementaré almacenamiento YAML cacheado, trabajos, empleados, rangos, permisos, API y eventos.

  3. Añadiré comandos con autocompletado, placeholders, configuraciones y cuatro trabajos de ejemplo.

  4. Documentaré instalación, configuración, comandos e integración con la API en README.md.

Creé LunarisTrabajos para Java 17 y Spigot/Paper 1.20.1. En el primer inicio genera los cuatro trabajos de ejemplo, config.yml, messages.yml y las carpetas jobs/ y players/.

Instalación: compila el proyecto con Compile en la barra superior, confirma Compile en la ventana y descarga el JAR cuando termine. LuckPerms y PlaceholderAPI son integraciones opcionales; el plugin también funciona sin ellas.

Comandos principales:

Plain Text
/trabajos crear <id>
/trabajos eliminar <id>
/trabajos editar <id> <nombre|display|habilitado|max-empleados> <valor>
/trabajos recargar
/trabajos listar
/trabajos info <id>
/trabajos jefe <trabajo> <jugador>
/trabajos quitarjefe <trabajo>
/trabajos contratar <trabajo> <jugador>
/trabajos despedir <trabajo> <jugador>
/trabajos rango <trabajo> <jugador> <rango>
/trabajos empleado <jugador>

/trabajo info
/trabajo empleados
/trabajo empleado <jugador>
/trabajo contratar <jugador>
/trabajo despedir <jugador>
/trabajo rango <jugador> <rango>
/trabajo promocionar <jugador>
/trabajo degradar <jugador>
/trabajo crear-rango <id> <nombre>
/trabajo eliminar-rango <id>

Si alguien es jefe de varios trabajos, debe indicar cuál en /trabajo, por ejemplo: /trabajo policia contratar jugador. La comprobación de UUID limita las acciones de jefes a sus propios trabajos.

Permisos: lunaristrabajos.admin concede acceso administrativo; también hay permisos granulares lunaristrabajos.admin.create, .delete, .reload, .assignboss y .manage. Los comandos de jefe usan lunaristrabajos.boss y .boss.manage. Los permisos específicos de cada empleo se configuran en su YAML.

PlaceholderAPI: están disponibles %lunaristrabajos_job%, %lunaristrabajos_job_id%, %lunaristrabajos_job_name%, %lunaristrabajos_rank%, %lunaristrabajos_rank_name%, %lunaristrabajos_is_boss%, %lunaristrabajos_boss%, %lunaristrabajos_employee_count% y %lunaristrabajos_has_job%, además de %lunaristrabajos_job_<id>%, %lunaristrabajos_job_<id>_boss%, %lunaristrabajos_job_<id>_employees% y %lunaristrabajos_job_<id>_exists%.

Los rangos y permisos se editan en jobs/<id>.yml; los datos de cada empleado se guardan por UUID en players/<UUID>.yml. La API pública está en LunarisTrabajos#getApi() e incluye consultas y operaciones de empleos, rangos, jefes y empleados. También se añadieron los siete eventos Bukkit solicitados. README.md contiene la guía de estructura YAML y ejemplos de integración con la API.

No ejecuté una prueba en un servidor; la compilación se puede iniciar desde Compile en Kodari.

_r10a_
📎 1 file 6,577 chars
📄
pasted-code-1791596890985.txt
txt 136 lines
▶
# PROMPT DEFINITIVO: ACTUALIZACIÓN DE PLUGIN A MINECRAFT 1.21.1

Quiero que analices y actualices mi plugin de Minecraft para que sea totalmente compatible con **Minecraft Java Edition 1.21.1**.

Tu objetivo es adaptar el código existente a esta versión, manteniendo todas las funcionalidades originales del plugin y mejorando su compatibilidad, estabilidad y rendimiento.

## 1. Análisis inicial del proyecto

Antes de modificar cualquier archivo:

- Analiza toda la estructura del proyecto.
- Revisa el código fuente completo y sus clases.
- Identifica la API de Minecraft utilizada actualmente.
- Comprueba la versión de Java, las dependencias y las librerías externas.
- Examina los archivos de configuración, comandos, permisos, eventos y sistemas de almacenamiento.
- Detecta métodos obsoletos, incompatibilidades y posibles errores que impidan ejecutar el plugin en Minecraft 1.21.1.

No comiences a realizar cambios sin comprender cómo funciona el plugin.

## 2. Compatibilidad con Minecraft 1.21.1

Adapta el plugin para que funcione correctamente en Minecraft 1.21.1.

- Actualiza las dependencias necesarias a versiones compatibles.
- Adapta las llamadas a la API de Bukkit, Spigot o Paper, según la plataforma utilizada por el proyecto.
- Corrige los métodos obsoletos o incompatibles.
- Actualiza los eventos, comandos, inventarios, materiales, entidades y demás componentes que lo necesiten.
- Verifica la compatibilidad con Java 21, que es la versión requerida por Minecraft 1.21.1.
- Ajusta el archivo `pom.xml` o `build.gradle`, según el sistema de compilación utilizado.
- Actualiza `plugin.yml` y cualquier otro descriptor necesario, sin eliminar configuraciones válidas.
- Comprueba la compatibilidad de las dependencias externas con la nueva versión.

No cambies de plataforma ni migres de Spigot a Paper, o viceversa, sin que sea técnicamente necesario. Si necesitas hacerlo, explica primero el motivo.

## 3. Conservación de las funciones originales

**Es obligatorio conservar todas las funcionalidades que ya tiene el plugin.**

No elimines, simplifiques ni reemplaces sistemas existentes simplemente porque resulte más fácil programarlos de nuevo.

Mantén, siempre que corresponda:

- Todos los comandos y subcomandos.
- Los permisos y sus condiciones de uso.
- Los eventos y sus comportamientos.
- Los archivos de configuración y sus opciones.
- Los mensajes y textos personalizados.
- Las integraciones con otros plugins.
- Los sistemas de datos, archivos YAML y bases de datos.
- Las interfaces gráficas, inventarios y menús.
- Los sistemas de economía, trabajos, empresas, NPC u otras mecánicas existentes.
- Las tareas programadas y los procesos automáticos.

Si alguna función necesita cambios importantes para funcionar en 1.21.1, adapta su implementación manteniendo su comportamiento original.

## 4. Protección de los datos y configuraciones

La actualización no debe provocar pérdida de información.

- Conserva las configuraciones existentes.
- No elimines opciones personalizadas del usuario.
- Mantén los datos de jugadores, permisos, estadísticas y demás información almacenada.
- Si necesitas modificar el formato de algún archivo, crea una migración segura y compatible con los datos anteriores.
- Genera valores predeterminados para las nuevas opciones sin sobrescribir la configuración personalizada.
- Evita reiniciar o borrar datos durante la actualización.

## 5. Calidad del código

Aprovecha la actualización para corregir problemas reales del código:

- Errores de compilación y excepciones.
- Problemas de rendimiento.
- Fugas de memoria.
- Tareas que no se cancelan correctamente.
- Accesos inseguros a la API desde hilos secundarios.
- Problemas con eventos duplicados.
- Errores al cargar o descargar el plugin.
- Problemas de compatibilidad con otras dependencias.

Respeta la arquitectura existente siempre que sea razonable. No reescribas todo el plugin innecesariamente.

## 6. Compilación y pruebas obligatorias

No consideres terminada la actualización simplemente porque hayas modificado el código.

Debes:

1. Compilar el proyecto utilizando su sistema de construcción.
2. Corregir todos los errores de compilación.
3. Resolver los problemas de dependencias.
4. Revisar los avisos importantes y las API obsoletas.
5. Ejecutar las pruebas disponibles.
6. Comprobar el registro de inicio y los errores de carga del plugin.
7. Verificar los comandos, permisos, eventos, configuraciones e integraciones principales.
8. Probar las funciones modificadas en un servidor de pruebas con Minecraft 1.21.1 cuando el entorno lo permita.

Si no puedes ejecutar un servidor real, indícalo claramente. No afirmes que has probado funciones que solamente has revisado en el código.

## 7. Entrega del proyecto actualizado

Al finalizar:

- Entrega el proyecto completo y actualizado.
- Incluye todos los archivos fuente necesarios.
- Incluye los archivos de construcción y configuración.
- Genera el archivo `.jar` final si dispones de un entorno de compilación funcional.
- Asegúrate de que el plugin conserve su nombre, identificador y funcionalidades originales.
- No entregues únicamente fragmentos de código ni ejemplos aislados.
- No elimines archivos del proyecto que sean necesarios para compilar o ejecutar el plugin.

## 8. Informe final

Cuando termines, proporciona un informe que incluya:

- Versión original detectada.
- Plataforma utilizada.
- Cambios realizados para Minecraft 1.21.1.
- Dependencias actualizadas.
- Archivos modificados.
- Errores corregidos.
- Funciones verificadas.
- Pruebas realizadas y sus resultados.
- Problemas pendientes, si existen.
- Ubicación del proyecto actualizado y del `.jar` generado.

## REGLAS IMPORTANTES

- Trabaja sobre el código real que te proporciono.
- No inventes clases, archivos ni resultados de pruebas.
- No elimines funcionalidades para solucionar errores.
- No sustituyas código funcional por implementaciones incompletas.
- No marques como completada una tarea que no hayas verificado.
- Si encuentras una incompatibilidad que requiere una decisión importante, explica las opciones antes de realizar cambios destructivos.
- Mantén el código organizado, legible y preparado para futuras actualizaciones.

**RESULTADO ESPERADO:** un plugin completamente adaptado a Minecraft 1.21.1, compilable, estable y funcional, conservando las características originales y entregado como un proyecto completo listo para probar en un servidor.
Kodari AI
KodariOct 10 at 1:51 am 1
  1. Alinear el build Maven con Spigot 1.21.1 y Java 21; conservar LuckPerms y PlaceholderAPI sin cambios.

  2. Actualizar api-version del descriptor y la documentación de instalación.

  3. Validar el resultado con la compilación automática disponible; no afirmar pruebas en servidor real.

Actualicé el proyecto para Spigot/Paper 1.21.1:

  • Versión detectada: Spigot API 1.20.1; Java 17.

  • Cambios: pom.xml ahora apunta a Spigot API 1.21.1 y Java 21; plugin.yml declara api-version: '1.21'; README actualizado.

  • Dependencias: LuckPerms, PlaceholderAPI y Lombok se conservaron; no encontré una incompatibilidad concreta que justificara cambiarlas.

  • Código y funciones: no modifiqué comandos, permisos, eventos ni almacenamiento. La revisión no identificó llamadas obsoletas incompatibles de forma evidente, pero eso no sustituye una compilación o una prueba en servidor.

  • Verificación: no ejecuté Maven ni probé el plugin en un servidor 1.21.1; por tanto, no puedo confirmar compilación ni carga, y no se generó un JAR.

Para compilar y descargar el JAR en Kodari, pulsa Compile en la barra superior (en móvil: ⋮ → Compile Project); cuando termine, selecciona Download.

Kodari can make mistakes. Review important code before using.
Files
src
pom.xml
README.md
Code
32 1,578
src/main/java/com/lunaris/trabajos/LunarisTrabajos.java
package com.lunaris.trabajos;

import com.lunaris.trabajos.api.LunarisTrabajosAPI;
import com.lunaris.trabajos.command.JobsCommand;
import com.lunaris.trabajos.config.MessageManager;
import com.lunaris.trabajos.job.JobManager;
import com.lunaris.trabajos.listener.PlayerListener;
import com.lunaris.trabajos.permission.PermissionService;
import com.lunaris.trabajos.placeholder.JobsExpansion;
import com.lunaris.trabajos.storage.YamlJobStorage;
import org.bukkit.Bukkit;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.util.List;

public class LunarisTrabajos extends JavaPlugin {
    private YamlJobStorage storage;
    private JobManager jobManager;
    private PermissionService permissionService;
    private MessageManager messageManager;
    private LunarisTrabajosAPI api;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        if (!new File(getDataFolder(), "messages.yml").exists()) saveResource("messages.yml", false);
        new File(getDataFolder(), "jobs").mkdirs();
        new File(getDataFolder(), "players").mkdirs();
        for (String id : List.of("policia", "medicos", "juzgado", "psicologos")) {
            String path = "jobs/" + id + ".yml";
            if (!new File(getDataFolder(), path).exists()) saveResource(path, false);
        }
        storage = new YamlJobStorage(this);
        storage.loadJobs();
        storage.loadPlayers();
        messageManager = new MessageManager(this);
        permissionService = new PermissionService(this);
        jobManager = new JobManager(this, storage, permissionService);
        api = new LunarisTrabajosAPI(jobManager);
        JobsCommand command = new JobsCommand(this, jobManager, messageManager);
        getCommand("trabajos").setExecutor(command);
        getCommand("trabajos").setTabCompleter(command);
        getCommand("trabajo").setExecutor(command);
        getCommand("trabajo").setTabCompleter(command);
        Bukkit.getPluginManager().registerEvents(new PlayerListener(jobManager, permissionService), this);
        if (getConfig().getBoolean("integrations.placeholderapi", true) && Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) new JobsExpansion(this, jobManager).register();
        getLogger().info("LunarisTrabajos habilitado con " + jobManager.getJobs().size() + " trabajos.");
    }

    public void reloadAll() {
        reloadConfig();
        messageManager.reload();
        jobManager.load();
        for (org.bukkit.entity.Player player : Bukkit.getOnlinePlayers()) jobManager.refreshPermissions(player.getUniqueId());
    }

    @Override
    public void onDisable() {
        if (permissionService != null) for (org.bukkit.entity.Player player : Bukkit.getOnlinePlayers()) permissionService.clear(player.getUniqueId());
    }

    public JobManager getJobManager() { return jobManager; }
    public LunarisTrabajosAPI getApi() { return api; }
    public MessageManager getMessageManager() { return messageManager; }
}