Instalación y creación de un proyecto con la Spigot API (gradle)

Vamos a instalar las extensiones necesarias para IntellIj, y luego crear nuestro primer proyecto de Spigot.

Instalar la extension Minecraft Development

Primero de todo abriremos IntellIj Idea (tutorial aquí). Iremos a configuración, y a Plugins.

Pantalla de Plugins de IntellIj

Pantalla de Plugins de IntellIj con el Plugin Minecraft Development

Creación de un proyecto de Spigot y Paper

Cuando vuelva a iniciarse, crearemos un nuevo proyecto utilizando el plugin de Minecraft Development. Hay que configurar:

• Nombre del proyecto
• Seleccionar Plugin
• Seleccionar Bukkit
• Seleccionar Paper
• Seleccionar la versión de Minecraft que queramos.
• Poner el Package que tendrá nuestro proyecto.
• Seleccionar el JDK correcto.

Pantalla de creación de un Proyecto de IntellIj relacionado con Minecraft

Añadiendo utilidades con Gradle

Vamos a añadir un par de plugins que nos ayudarán con el desarrollo de plugins de Minecraft.

Usando paperweight en Gradle

Paper ofrece un plugin oficial llamado paperweight, el cual nos ayuda con el desarrollo de plugins. Nosotros usaremos el paperweight.userdev, que hará que nuestro código al interactuar con Minecraft sea más legible.

Para ello, en el build.gradle, añadiremos el plugin:

plugins {  
    id 'java'  
 
	// Plugin añadido
    id("io.papermc.paperweight.userdev") version "1.5.11"  
}

Luego, en el bloque de configuración dependencies, hemos de añadir una cosita:

dependencies {  
	paperweight.paperDevBundle "1.20.4-R0.1-SNAPSHOT"
    compileOnly "io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT"  
}

Usando run-paper en Gradle

Para no tener que compilar, copiar el archivo y reiniciar el servidor cada vez que cambiamos algo, usaremos el plugin run-paper que se encargará de todo eso, y encima podremos debugar en el IDE directamente.

Para instalar el plugin, en el build.gradle añadiremos:

plugins {
	id 'java'  
    id("io.papermc.paperweight.userdev") version "1.5.11"  
 
	// Plugin añadido
	id("xyz.jpenilla.run-paper") version "2.2.3"
}

Luego hemos de configurar la tarea runServer que añade el plugin con la versión de Minecraft que usaremos:

tasks {
  runServer {
    minecraftVersion("1.20.4")
  }
}

Ahora que tenemos todo, hará falta sincronizar el proyecto de Gradle. Para ello en IntelliJ le damos al icono que hay de recargar, y dejamos que descargue todas las librerías necesarias. Con Gradle hay que tener mucha paciencia, así que puedes ir a desayunar, o tomarte un café, que tardará un rato.

Analizando el proyecto

Cuando hayamos creado nuestro proyecto, nos encontraremos código ya hecho, y un archivo nuevo llamado plugin.yml

El archivo plugin.yml

Este archivo es esencial. Es el archivo que contendrá toda la información de nuestro plugin. Podríamos decir que es como el Manifest de Java. Aquí especificaremos tres atributos obligatorios: name, version, main, api-version.

name: CursoSpigot  
version: '${version}'  
main: me.polvallverdu.cursospigot.CursoSpigot  

En este archivo podemos especificar más cosas:

description: "Descripción del plugin"
api-version: '1.20'
authors: 
  - Pol Vallverdu
website: "polv.dev"

Luego podemos añadir dependencias. Hay dos tipos:

• softdepend: dependencias que no hace falta que existan.
• depend: dependencias necesarias. Si no están, el plugin no iniciará.

En el plugin.yml también especificaremos los comandos:

commands:
  nombrecomando:
    description: Descripción del comando
    aliases: [otrocomando]
    permission: cursospigot.nombrepermiso

El archivo principal CursoSpigot.java

Nos encontraremos un archivo con algo de código. Si nos fijamos, este extiende la clase JavaPlugin. Todos los plugins de Spigot (y demás) empiezan por una clase que extiende JavaPlugin. Nos añade una gran variedad de métodos (los puedes ver aquí), y dos funciones esenciales:

@Override  
public void onEnable() {  
	// Cuando el plugin se habilita
}  
  
@Override  
public void onDisable() {  
    // Cuando el plugin se deshabilita  
}

Probando que todo funciona correctamente

Ya conocemos nuestro proyecto, conocemos como funciona más o menos, vamos a probar que el plugin inicia correctamente.

Lo que haremos será algo simple, imprimir algo en pantalla cuando se habilite y deshabilite el plugin:

@Override  
public void onEnable() {  
	System.out.println("¡El plugin ha sido cargado correctamente!");
}  
  
@Override  
public void onDisable() {  
    System.out.println("El plugin se ha deshabilitado :(");
}

Con esto será suficiente. Ahora toca ejecutarlo en un servidor. Podríamos compilarlo y ponerlo en un servidor propio, pero gracias a Gradle no nos hace falta. Si ejecutamos la tarea :runServer de Gradle, iniciará un servidor con el plugin ya dentro. Este servidor se encuentra en el directorio run/

Si es la primera vez que se inicia, hemos de aceptar el EULA en el eula.txt. La segunda vez que lo iniciemos, si nos fijamos ahí estará el mensaje 😄.

Información Adicional

En todo nuestro proyecto tenemos acceso a métodos estáticos en la clase Bukkit. Podremos realizar muchas cosas con esa clase, pero lo veremos más adelante.