AxoProtectionBlock

AxoProtectionBlock API

Esta sección es para desarrolladores que quieren leer, validar o modificar protecciones desde otro plugin de Paper/Folia.

La API pública vive en org.axostudio.axoprotectionblock.api. Permite consultar regiones, leer snapshots inmutables, validar flags, crear o eliminar protecciones, administrar miembros, modificar chunks, abrir menús, mostrar bordes visuales, consultar combate y trabajar con backups.

Agregar AxoProtectionBlock como dependencia

Agrega JitPack como repositorio y compila contra AxoProtectionBlock. Para plugins Paper se recomienda compileOnly o provided para no empaquetar AxoProtectionBlock dentro de tu jar.

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenCentral()
        maven { url 'https://jitpack.io' }
    }
}

dependencies {
    compileOnly 'com.github.Axolotle154:AxoProtectionBlock:3.1.4'
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

dependencies {
    compileOnly("com.github.Axolotle154:AxoProtectionBlock:3.1.4")
}

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

<dependency>
    <groupId>com.github.Axolotle154</groupId>
    <artifactId>AxoProtectionBlock</artifactId>
    <version>3.1.4</version>
    <scope>provided</scope>
</dependency>

resolvers += "jitpack" at "https://jitpack.io"

libraryDependencies += "com.github.Axolotle154" % "AxoProtectionBlock" % "3.1.4" % "provided"

:repositories [["jitpack" "https://jitpack.io"]]

:dependencies [[com.github.Axolotle154/AxoProtectionBlock "3.1.4" :scope "provided"]]

Declarar AxoProtectionBlock en tu plugin

Si tu plugin necesita AxoProtectionBlock para funcionar, declaralo como dependencia requerida en paper-plugin.yml:

dependencies:
  server:
    AxoProtectionBlock:
      load: AFTER
      required: true
      join-classpath: true

Si tu plugin puede funcionar sin AxoProtectionBlock, dejalo opcional:

dependencies:
  server:
    AxoProtectionBlock:
      load: AFTER
      required: false
      join-classpath: true

Para un plugin.yml legacy:

depend: [AxoProtectionBlock]

o, si es opcional:

softdepend: [AxoProtectionBlock]

Obtener la API

La forma directa usa AxoProtectionBlockProvider:

import org.axostudio.axoprotectionblock.api.AxoProtectionBlockApi;
import org.axostudio.axoprotectionblock.api.AxoProtectionBlockProvider;
import org.bukkit.plugin.java.JavaPlugin;

public final class MyPlugin extends JavaPlugin {

    private AxoProtectionBlockApi protectionApi;

    @Override
    public void onEnable() {
        protectionApi = AxoProtectionBlockProvider.require();
    }
}

Si AxoProtectionBlock es opcional, usa get() y valida el resultado:

AxoProtectionBlockProvider.get().ifPresent(api -> {
    getLogger().info("Hook con AxoProtectionBlock listo. Version " + api.version());
});

Obtener la API con ServicesManager

También puedes resolverla desde el ServicesManager de Bukkit/Paper.

import org.axostudio.axoprotectionblock.api.AxoProtectionBlockApi;
import org.bukkit.plugin.RegisteredServiceProvider;

RegisteredServiceProvider<AxoProtectionBlockApi> registration =
        getServer().getServicesManager().getRegistration(AxoProtectionBlockApi.class);

AxoProtectionBlockApi protectionApi = registration == null ? null : registration.getProvider();

Consultas y checks

ProtectionCheckResult result = api.check(player, block.getLocation(), ProtectionFlag.BLOCK_BREAK);
if (result.denied()) {
    player.sendMessage("No puedes romper aquí: " + result.reason());
}

Creación y edición

ProtectionMutationResult created = api.createProtection(
    player,
    player.getLocation().getBlock(),
    ProtectionCreateRequest.blockType("beacon_64").withName("Base principal")
);

if (!created.success()) {
    player.sendMessage("No se pudo crear: " + created.code());
}

Miembros, flags y chunks

api.setFlag(regionId, ProtectionFlag.PVP, false, player);
api.addMember(regionId, target.getUniqueId(), target.getName(), player);

ProtectionChunkSnapshot chunk = ProtectionChunkSnapshot.fromLocation(player.getLocation());
api.addClaimedChunk(regionId, chunk, null, null, player);

Visuales, combate, items y backups

Apertura de menús por API

Los métodos de menú reutilizan los inventarios configurados del plugin. El plugin externo debe encargarse de validar permisos si quiere aplicar reglas propias antes de abrirlos.

api.openFlagsMenu(player, regionId, false, 0);

Eventos Bukkit

Los eventos de API se disparan antes de aplicar cambios cuando son cancelables. Las operaciones internas de combate disparan ProtectionCombatBorderEvent cuando se va a mostrar el borde por combate.

@EventHandler
public void onCombatBorder(ProtectionCombatBorderEvent event) {
    if (event.player().hasPermission("myplugin.hidecombatborder")) {
        event.setCancelled(true);
    }
}

Archivos y Carpetas

plugins/AxoProtectionBlock/
├─ blocks/
│  ├─ beacon_64.yml
│  └─ otros_bloques.yml
├─ menu/
│  ├─ main.yml
│  ├─ shop.yml
│  ├─ homes.yml
│  ├─ systems.yml
│  └─ otros_menus.yml
├─ recipes/
│  ├─ beacon_64.yml
│  └─ otras_recetas.yml
├─ lang/
│  ├─ es_ES.yml
│  ├─ en_US.yml
│  └─ ru_RU.yml
├─ protecciones/
│  ├─ region-uuid.yml
│  └─ region-otro-uuid.yml
├─ cleanup-previews/
├─ migration-backups/
├─ config.yml
├─ discord.yml
├─ rent-data.yml
├─ tax-data.yml
├─ player-languages.yml
└─ messages.yml

Bloque configurable - Ejemplo básico

type: BEACON
alias: "64"
description: "Protección de radio 64 bloques."

restrict-obtaining: true

worlds:
  list-type: blacklist
  list:
    - world_nether
    - world_the_end

region:
  x_radius: 64
  y_radius: -1
  z_radius: 64

  home-offset:
    x: 0.5
    y: 1.0
    z: 0.5
    yaw: 0.0
    pitch: 0.0

  flags:
    BLOCK_BREAK: false
    BLOCK_PLACE: false
    INTERACT: false
    CONTAINER_ACCESS: false
    PVP: false
    ENTITY_DAMAGE: false
    EXPLOSIONS: false
    LIQUID_FLOW: false
    PISTONS: false
    ENTRY: true
    INVINCIBLE: false
    MOB_DAMAGE: true

block-data:
  display-name: "&b&lProtección &d&l64x64"
  lore:
    - "&7Coloca este bloque para crear una protección."
    - "&bRadio: &f64 bloques"
    - "&7Dueño: &f%player%"
  enchanted-effect: true
  custom-model-data: -1
  price: 0.0

Bloque configurable - Opciones avanzadas

recipe:
  enabled: false
  amount: 1
  shape:
    - ["", "STONE", ""]
    - ["STONE", "BEACON", "STONE"]
    - ["", "STONE", ""]

craftengine:
  item-id: "craftengine:protection_item"
  block-id: "craftengine:protection_block"

shop:
  enabled: true
  price: 1000.0
  material: BEACON
  slot: auto
  priority: 1

behaviour:
  no-drop: false

player:
  permission: ""

event:
  enable: true
  on-region-create:
    - "global_message: &b%player% creó una protección."
    - "console_command: say Protección creada"
  on-region-destroy: []

Bloque con cabeza personalizada

type: PLAYER_HEAD
alias: "head_10"
description: "Protección de radio 10 con cabeza."

region:
  x_radius: 10
  y_radius: -1
  z_radius: 10

block-data:
  display-name: "&c&lProtección de Cabeza &7(Radio 10)"
  lore:
    - "&7Coloca esta cabeza para proteger una zona."
    - "&cRadio: &f10 bloques"

  head:
    enabled: true
    owner: "%player%"
    texture: ""

Configuración - config.yml (parte 1)

settings:
  default-radius: 16
  max-regions-per-player: 3
  region-shape: CUBE
  disabled-worlds:
    - world_nether
    - world_the_end

menus:
  size: 27
  rows: 3

shop:
  enabled: true
  command: "apb shop"
  menu-file: "shop.yml"

language:
  default: "es_ES"
  auto-detect-client: true
  fallback: "en_US"
  fallbacks: ["en_US"]

Configuración - config.yml (parte 2)

recipes:
  auto-register: true

homes:
  enabled: true
  default-home-at-protection-block: true
  allow-members-teleport: true
  safe-teleport: true
  teleport-delay: 3

combat:
  enabled: true
  tag-seconds: 15
  border:
    enabled: true
    duration-seconds: 4
    particle: FLAME

chunk-claims:
  enabled: true
  default-limit: 9
  block-break-action: REGENERATE
  interactive:
    enabled: true
    start-on-command: true
    start-on-block-place: true

cleanup:
  enabled: false
  inactive-days: 30
  automatic:
    enabled: true
  check-members-activity: true
  delete-if-owner-inactive-only: false

Configuración - config.yml (parte 3)

sql:
  enabled: false
  type: sqlite
  host: localhost
  port: 3306
  database: axoprotectionblock
  username: root
  password: ""
  pool:
    maximum-pool-size: 10
    minimum-idle: 2
    connection-timeout-ms: 30000
    idle-timeout-ms: 600000
    max-lifetime-ms: 1800000

tax-system:
  enabled: false
  interval-hours: 24
  grace-period-days: 7
  action-on-unpaid: DISABLE

rent-system:
  enabled: false
  min-price: 100.0
  max-price: 100000.0
  allow-auto-renew: true

menu-system:
  enabled: true

Base de Datos SQL

HikariCP incluido con relocation. Drivers JDBC descargados automáticamente por Paper.

• SQLite: Sin configuración de red, ideal para servidores pequeños.
• MySQL: Para servidores en red o múltiples instancias.
• El migrador automático lee YAML y regions.yml legacy.
• Crea respaldos en migration-backups/ antes de insertar.
• Normaliza datos en tablas para regiones, co-dueños, miembros, bloqueos, flags y homes.

Discord Webhooks

Se configura en discord.yml. Soporta eventos con content, embeds, colores y placeholders.

enabled: true
webhook-url: "https://discord.com/api/webhooks/..."
username: "AxoProtectionBlock"
avatar-url: ""

events:
  region-create:
    enabled: true
    title: "Nueva Protección"
    description:
      - "**%player%** creó una protección."
      - "Región: **%region%**"
    color: "#00ff00"
    fields:
      - name: "Dueño"
        value: "`%owner%`"
      - name: "Ubicación"
        value: "`%world%: %x% %y% %z%`"
    footer:
      text: "%server% • %time%"
    timestamp: true

Mensajes silenciables

Cualquier mensaje enviado desde archivos de idioma puede ocultarse poniendo la clave en none o false. Esto evita enviar una línea vacía al chat.

no-permission: none
shop-no-permission: false

Comandos - Generales

Comandos - Protecciones

Comandos - Protecciones por Chunks

Comandos - Miembros y Acceso

Comandos - Flags y Configuración

Comandos - Logs y Backups

Comandos - Homes

Comandos - Tienda y Recetas

Comandos - Impuestos

Comandos - Rentas

Comandos - Idiomas

Comandos - Administración

Comandos - Migradores

Comandos - Limpieza

Permisos - Generales

Permisos - Protecciones

Permisos - Miembros y Acceso

Permisos - Flags y Configuración

Permisos - Homes

Permisos - Menús

Permisos - Tienda y Recetas

Permisos - Impuestos

Permisos - Rentas

Permisos - Idiomas

Permisos - Administración avanzada

Límites por permisos

El plugin detecta automáticamente el permiso numérico más alto. Los permisos se leen dinámicamente desde Bukkit/Paper, por lo que funcionan con LuckPerms u otros plugins de permisos sin reiniciar.

axoprotectionblock.limit.1
axoprotectionblock.limit.3
axoprotectionblock.limit.5
axoprotectionblock.limit.10
axoprotectionblock.limit.50
axoprotectionblock.limit.unlimited

axoprotectionblock.chunks.limit.9
axoprotectionblock.chunks.limit.25
axoprotectionblock.chunks.limit.unlimited

• Si un jugador tiene axoprotectionblock.limit.5 y axoprotectionblock.limit.10, el límite usado será 10.
• Si tiene axoprotectionblock.limit.unlimited, no tendrá límite.
• Si no tiene ningún permiso limit.X, se usa settings.max-regions-per-player.
• Los límites de chunks usan axoprotectionblock.chunks.limit.X y, si no existen, se usa chunk-claims.default-limit.

settings:
  max-regions-per-player: 3