尝试通过多模块引入多版本支持(编译脚本有问题)

build.gradle.kts

@@ -15,6 +15,10 @@ tasks.withType<JavaCompile> {
     options.encoding = "UTF-8"
 }
 
+subprojects {
+    apply(plugin = "java")
+    apply(plugin = "com.github.johnrengelman.shadow")
+
     repositories {
         mavenCentral()
         mavenLocal()
@@ -26,8 +30,6 @@ repositories {
     }
 
     dependencies {
-    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
-
         compileOnly("com.github.BlueMap-Minecraft:BlueMapAPI:v2.6.2")
         compileOnly("us.dynmap:DynmapCoreAPI:3.4")
 
@@ -35,8 +37,8 @@ dependencies {
         implementation("org.yaml:snakeyaml:2.0")
     }
 
-tasks {
+
-    processResources {
+    tasks.withType<ProcessResources> {
         // replace @version@ in plugin.yml with project version
         filesMatching("**/plugin.yml") {
             filter {
@@ -45,9 +47,9 @@ tasks {
         }
     }
 
-    shadowJar {
+    tasks.withType<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar> {
         archiveClassifier.set("")
         archiveVersion.set(project.version.toString())
-        dependsOn(processResources)
+        dependsOn(tasks.withType<ProcessResources>())
     }
 }

core/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+    id("java")
+}
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+}
+
+// utf-8
+tasks.withType<JavaCompile> {
+    options.encoding = "UTF-8"
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+    maven("https://oss.sonatype.org/content/groups/public")
+    maven("https://repo.papermc.io/repository/maven-public/")
+    maven("https://jitpack.io")
+    maven("https://repo.mikeprimm.com/")
+    maven("https://ssl.lunadeer.cn:14454/repository/maven-snapshots/")
+}
+
+dependencies {
+    compileOnly("io.papermc.paper:paper-api:1.20.1-R0.1-SNAPSHOT")
+}

core/src/main/java/cn/lunadeer/dominion/Dominion.java

@@ -1,8 +1,6 @@
 package cn.lunadeer.dominion;
 
-import cn.lunadeer.dominion.events.EnvironmentEvents;
+import cn.lunadeer.dominion.events.RegisterEvents;
-import cn.lunadeer.dominion.events.PlayerEvents;
-import cn.lunadeer.dominion.events.SelectPointEvents;
 import cn.lunadeer.dominion.managers.ConfigManager;
 import cn.lunadeer.dominion.managers.DatabaseTables;
 import cn.lunadeer.dominion.utils.DynmapConnect;
@@ -41,9 +39,7 @@ public final class Dominion extends JavaPlugin {
         AutoClean.run();
         Cache.instance = new Cache();
 
-        Bukkit.getPluginManager().registerEvents(new PlayerEvents(), this);
+        new RegisterEvents(this);
-        Bukkit.getPluginManager().registerEvents(new EnvironmentEvents(), this);
-        Bukkit.getPluginManager().registerEvents(new SelectPointEvents(), this);
         Objects.requireNonNull(Bukkit.getPluginCommand("dominion")).setExecutor(new Commands());
 
         bStatsMetrics metrics = new bStatsMetrics(this, 21445);

core/src/main/java/cn/lunadeer/dominion/events/RegisterEvents.java

@@ -0,0 +1,62 @@
+package cn.lunadeer.dominion.events;
+
+import cn.lunadeer.minecraftpluginutils.XLogger;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class RegisterEvents {
+
+    private JavaPlugin plugin;
+
+    public RegisterEvents(JavaPlugin plugin) {
+        APIVersion version = GetAPIVersion(plugin);
+        this.plugin = plugin;
+        if (version == null) {
+            return;
+        }
+        try {
+            switch (version) {
+                case v1_21:
+                    registerEvents("cn.lunadeer.dominion.events_v1_21.PlayerEvents");
+                    registerEvents("cn.lunadeer.dominion.events_v1_21.EnvironmentEvents");
+                    registerEvents("cn.lunadeer.dominion.events_v1_21.SelectPointEvents");
+                    break;
+                case v1_20_1:
+                    registerEvents("cn.lunadeer.dominion.events_v1_20_1.PlayerEvents");
+                    registerEvents("cn.lunadeer.dominion.events_v1_20_1.EnvironmentEvents");
+                    registerEvents("cn.lunadeer.dominion.events_v1_20_1.SelectPointEvents");
+                    break;
+            }
+        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
+            XLogger.err("Failed to register events: %s", e.getMessage());
+            plugin.getServer().getPluginManager().disablePlugin(plugin);
+        }
+    }
+
+    enum APIVersion {
+        v1_21,
+        v1_20_1
+    }
+
+    private static APIVersion GetAPIVersion(JavaPlugin plugin) {
+        String version = plugin.getServer().getBukkitVersion();
+        if (version.contains("1.21")) {
+            return APIVersion.v1_21;
+        } else if (version.contains("1.20.1")
+                || version.contains("1.20.4")
+                || version.contains("1.20.6")) {
+            return APIVersion.v1_20_1;
+        }
+        XLogger.err("Unsupported API version: %s", version);
+        plugin.getServer().getPluginManager().disablePlugin(plugin);
+        return null;
+    }
+
+    private void registerEvents(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+        Class<?> clazz = Class.forName(className);
+        Listener listener = (Listener) clazz.newInstance();
+        Bukkit.getPluginManager().registerEvents(listener, plugin);
+    }
+
+}

settings.gradle.kts

@@ -1 +1,7 @@
 rootProject.name = "Dominion"
+
+include(
+    "core",
+    "v1_20_1",
+    "v1_21"
+)

v1_20_1/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    id("java")
+}
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+}
+
+// utf-8
+tasks.withType<JavaCompile> {
+    options.encoding = "UTF-8"
+}
+
+repositories {
+    maven("https://repo.papermc.io/repository/maven-public/")
+}
+
+dependencies {
+    compileOnly(project(":core"))
+    compileOnly("io.papermc.paper:paper-api:1.20.1-R0.1-SNAPSHOT")
+}

v1_20_1/src/main/java/cn/lunadeer/dominion/events_v1_20_1/EnvironmentEvents.java

@@ -0,0 +1,294 @@
+package cn.lunadeer.dominion.events_v1_20_1;
+
+import cn.lunadeer.dominion.Cache;
+import cn.lunadeer.dominion.dtos.DominionDTO;
+import cn.lunadeer.dominion.dtos.Flag;
+import cn.lunadeer.minecraftpluginutils.XLogger;
+import org.bukkit.Location;
+import org.bukkit.Tag;
+import org.bukkit.block.Block;
+import org.bukkit.entity.*;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.entity.*;
+import org.bukkit.event.hanging.HangingBreakByEntityEvent;
+import org.bukkit.event.hanging.HangingBreakEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+import java.util.Objects;
+
+import static cn.lunadeer.dominion.events.Apis.checkFlag;
+import static org.bukkit.Material.FARMLAND;
+
+public class EnvironmentEvents implements Listener {
+    @EventHandler(priority = EventPriority.HIGHEST) // creeper_explode
+    public void onEntityExplode(EntityExplodeEvent event) {
+        Entity entity = event.getEntity();
+        XLogger.debug("EntityExplodeEvent: " + entity.getType());
+        if (isNotExplodeEntity(entity)) {
+            return;
+        }
+        XLogger.debug("blockList" + event.blockList().size());
+        event.blockList().removeIf(block -> {
+            DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+            return !checkFlag(dom, Flag.CREEPER_EXPLODE, null);
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // creeper_explode - item frame
+    public void onItemFrameExploded(HangingBreakByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (event.getCause() != HangingBreakEvent.RemoveCause.EXPLOSION) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.CREEPER_EXPLODE, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // creeper_explode - armor stand
+    public void onArmorStandExploded(EntityDamageByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.ARMOR_STAND) {
+            return;
+        }
+        if (isNotExplodeEntity(event.getDamager())) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.CREEPER_EXPLODE, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // item_frame_proj_damage
+    public void removeSomeOnItemFrameByArrow(HangingBreakByEntityEvent event) {
+        if (event.getCause() != HangingBreakEvent.RemoveCause.ENTITY) {
+            return;
+        }
+        Entity remover = event.getRemover();
+        if (!(remover instanceof Projectile projectile)) {
+            return;
+        }
+        if (!(projectile.getShooter() instanceof Player)) {
+            // 玩家破坏由 玩家 break 权限控制
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getEntity().getLocation());
+        checkFlag(dom, Flag.ITEM_FRAME_PROJ_DAMAGE, event);
+    }
+
+    private static boolean isNotExplodeEntity(Entity damager) {
+        return damager.getType() != EntityType.CREEPER
+                && damager.getType() != EntityType.WITHER_SKULL
+                && damager.getType() != EntityType.FIREBALL
+                && damager.getType() != EntityType.ENDER_CRYSTAL
+                && damager.getType() != EntityType.SMALL_FIREBALL
+                && damager.getType() != EntityType.DRAGON_FIREBALL;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // dragon_break_block
+    public void onDragonBreakBlock(EntityExplodeEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.ENDER_DRAGON) {
+            return;
+        }
+        event.blockList().removeIf(block -> {
+            DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+            return !checkFlag(dom, Flag.DRAGON_BREAK_BLOCK, null);
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // fire_spread
+    public void onFireSpread(BlockIgniteEvent event) {
+        Player player = event.getPlayer();
+        if (player != null) {
+            // 如果点燃事件没有玩家触发，那么就是火焰蔓延
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getBlock().getLocation());
+        checkFlag(dom, Flag.FIRE_SPREAD, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // flow_in_protection
+    public void onLiquidFlowIn(BlockFromToEvent event) {
+        Location from = event.getBlock().getLocation();
+        Location to = event.getToBlock().getLocation();
+        DominionDTO dom_to = Cache.instance.getDominionByLoc(to);
+        if (dom_to == null) {
+            return;
+        }
+        DominionDTO dom_from = Cache.instance.getDominionByLoc(from);
+        if (dom_from != null) {
+            if (Objects.equals(dom_from.getId(), dom_to.getId())) {
+                return;
+            }
+        }
+        checkFlag(dom_to, Flag.FLOW_IN_PROTECTION, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // mob_drop_item
+    public void onMobDropItem(EntityDeathEvent event) {
+        Entity entity = event.getEntity();
+        if (entity instanceof Player) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        if (dom == null) {
+            return;
+        }
+        if (!Flag.MOB_DROP_ITEM.getEnable()) {
+            return;
+        }
+        if (dom.getFlagValue(Flag.MOB_DROP_ITEM)) {
+            return;
+        }
+        event.getDrops().clear();
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // tnt_explode
+    public void onTntExplode(EntityExplodeEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.MINECART_TNT && entity.getType() != EntityType.PRIMED_TNT) {
+            return;
+        }
+        event.blockList().removeIf(block -> {
+            DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+            return !checkFlag(dom, Flag.TNT_EXPLODE, null);
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // tnt_explode - armor stand
+    public void onArmorStandExplodedByTnt(EntityDamageByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.ARMOR_STAND) {
+            return;
+        }
+        if (entity.getType() != EntityType.MINECART_TNT && entity.getType() != EntityType.PRIMED_TNT) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.TNT_EXPLODE, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // trample
+    public void onFarmlandTrample(PlayerInteractEvent event) {
+        if (event.getAction() != Action.PHYSICAL) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        if (block.getType() != FARMLAND) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.TRAMPLE, event);
+    }
+
+    /*
+    TRIG_PRESSURE_PROJ("trig_pressure_proj", "投掷物触发压力板", "投掷物（箭/风弹/雪球）是否可以触发压力板", false, true, true),
+    TRIG_PRESSURE_MOB("trig_pressure_mob", "生物触发压力板", "生物（不包含玩家）是否可以触发压力板", false, true, true),
+    TRIG_PRESSURE_DROP("trig_pressure_drop", "掉落物触发压力板", "掉落物是否可以触发压力板", false, true, true),
+     */
+    @EventHandler(priority = EventPriority.HIGHEST) // trig_pressure_proj
+    public void onPressurePlateTriggeredByProjectile(EntityInteractEvent event) {
+        if (!(event.getEntity() instanceof Projectile)) {
+            return;
+        }
+        Block block = event.getBlock();
+        if (!Tag.PRESSURE_PLATES.isTagged(block.getType())) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.TRIG_PRESSURE_PROJ, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // trig_pressure_mob
+    public void onPressurePlateTriggeredByMob(EntityInteractEvent event) {
+        if (!(event.getEntity() instanceof Mob)) {
+            return;
+        }
+        Block block = event.getBlock();
+        if (!Tag.PRESSURE_PLATES.isTagged(block.getType())) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.TRIG_PRESSURE_MOB, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // trig_pressure_drop
+    public void onPressurePlateTriggeredByDrop(EntityInteractEvent event) {
+        if (!(event.getEntity() instanceof Item)) {
+            return;
+        }
+        Block block = event.getBlock();
+        if (!Tag.PRESSURE_PLATES.isTagged(block.getType())) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.TRIG_PRESSURE_DROP, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // wither_spawn
+    public void onWitherSpawn(CreatureSpawnEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.WITHER) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.WITHER_SPAWN, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // ender_man spawn
+    public void onEnderManSpawn(CreatureSpawnEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.ENDERMAN) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.ENDER_MAN, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // ender_man escape
+    public void onEnderManEscape(EntityTeleportEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.ENDERMAN) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.ENDER_MAN, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // monster_spawn
+    public void onMonsterSpawn(CreatureSpawnEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof Monster)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.MONSTER_SPAWN, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // animal_spawn
+    public void onAnimalSpawn(CreatureSpawnEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof Animals)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.ANIMAL_SPAWN, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // villager_spawn
+    public void onVillagerSpawn(CreatureSpawnEvent event) {
+        Entity entity = event.getEntity();
+        if (entity.getType() != EntityType.VILLAGER) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.VILLAGER_SPAWN, event);
+    }
+}

v1_20_1/src/main/java/cn/lunadeer/dominion/events_v1_20_1/PlayerEvents.java

@@ -0,0 +1,796 @@
+package cn.lunadeer.dominion.events_v1_20_1;
+
+import cn.lunadeer.dominion.Cache;
+import cn.lunadeer.dominion.dtos.DominionDTO;
+import cn.lunadeer.dominion.dtos.Flag;
+import cn.lunadeer.dominion.dtos.PlayerDTO;
+import cn.lunadeer.minecraftpluginutils.Common;
+import cn.lunadeer.minecraftpluginutils.Notification;
+import cn.lunadeer.minecraftpluginutils.Teleport;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Tag;
+import org.bukkit.block.Block;
+import org.bukkit.entity.*;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.*;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityPlaceEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.event.hanging.HangingBreakByEntityEvent;
+import org.bukkit.event.hanging.HangingBreakEvent;
+import org.bukkit.event.hanging.HangingPlaceEvent;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.event.player.*;
+import org.bukkit.event.vehicle.VehicleDestroyEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.material.Colorable;
+import org.spigotmc.event.entity.EntityMountEvent;
+
+import static cn.lunadeer.dominion.events.Apis.checkFlag;
+import static cn.lunadeer.dominion.events.Apis.getInvDominion;
+
+public class PlayerEvents implements Listener {
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player bukkitPlayer = event.getPlayer();
+        PlayerDTO player = PlayerDTO.get(bukkitPlayer);
+        player.onJoin(bukkitPlayer.getName()); // update name
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Player bukkitPlayer = event.getPlayer();
+        Cache.instance.onPlayerQuit(bukkitPlayer);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // anchor
+    public void onRespawnAnchor(PlayerRespawnEvent event) {
+        Player bukkitPlayer = event.getPlayer();
+        if (!event.isAnchorSpawn()) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(bukkitPlayer);
+        if (!checkFlag(dom, Flag.ANCHOR, bukkitPlayer, null)) {
+            if (bukkitPlayer.getBedSpawnLocation() != null) {
+                event.setRespawnLocation(bukkitPlayer.getBedSpawnLocation());
+            } else {
+                event.setRespawnLocation(bukkitPlayer.getWorld().getSpawnLocation());
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // animal_killing
+    public void onAnimalKilling(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        // 如果不是动物 则不处理
+        if (!(event.getEntity() instanceof Animals)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getEntity().getLocation());
+        checkFlag(dom, Flag.ANIMAL_KILLING, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // anvil
+    public void onAnvilUse(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.ANVIL) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(bukkitPlayer);
+        checkFlag(dom, Flag.ANVIL, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // beacon
+    public void onBeaconUse(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.BEACON) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(bukkitPlayer);
+        checkFlag(dom, Flag.BEACON, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // bed
+    public void onBedUse(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Player bukkitPlayer = event.getPlayer();
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        if (!(Tag.BEDS.isTagged(block.getType()))) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.BED, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // brew
+    public void onBrewUse(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.BREWING) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(bukkitPlayer);
+        checkFlag(dom, Flag.BREW, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // break
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        if (onBreak(player, event.getBlock().getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // break - item frame
+    public void onItemFrameBreak(HangingBreakByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (event.getCause() != HangingBreakEvent.RemoveCause.ENTITY) {
+            return;
+        }
+        if (entity instanceof ItemFrame) {
+            if (((ItemFrame) entity).getItem().getType() != Material.AIR) {
+                if (!hasContainerPermission((Player) event.getRemover(), entity.getLocation())) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
+        if (onBreak((Player) event.getRemover(), entity.getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // break - armor stand
+    public void onArmorStandBreak(EntityDamageByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof ArmorStand)) {
+            return;
+        }
+        if (!(event.getDamager() instanceof Player)) {
+            return;
+        }
+        if (onBreak((Player) event.getDamager(), entity.getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    public static boolean onBreak(Player player, Location location) {
+        DominionDTO dom = Cache.instance.getDominionByLoc(location);
+        return checkFlag(dom, Flag.BREAK_BLOCK, player, null);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // button
+    public void onButton(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Player player = event.getPlayer();
+        if (event.getClickedBlock() == null) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (!Tag.BUTTONS.isTagged(block.getType())) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.BUTTON, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // cake
+    public void eatCake(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        Material clicked = block.getType();
+        if (clicked != Material.CAKE) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.CAKE, player, event);
+    }
+
+    // 检查是否有容器权限
+    private static boolean hasContainerPermission(Player player, Location loc) {
+        DominionDTO dom;
+        if (loc == null) {
+            dom = null;
+        } else {
+            dom = Cache.instance.getDominionByLoc(loc);
+        }
+        return checkFlag(dom, Flag.CONTAINER, player, null);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // container
+    public void openContainer(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.CHEST &&
+                event.getInventory().getType() != InventoryType.BARREL &&
+                event.getInventory().getType() != InventoryType.SHULKER_BOX) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        if (hasContainerPermission(bukkitPlayer, event.getInventory().getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // container (armor stand)
+    public void manipulateArmorStand(PlayerArmorStandManipulateEvent event) {
+        Player bukkitPlayer = event.getPlayer();
+        if (hasContainerPermission(bukkitPlayer, event.getRightClicked().getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // container （item frame put）
+    public void putSomeOnItemFrame(PlayerInteractEntityEvent event) {
+        Entity entity = event.getRightClicked();
+        if (!(entity instanceof ItemFrame itemFrame)) {
+            return;
+        }
+        if (itemFrame.getItem().getType() != Material.AIR) {
+            return;
+        }
+        Player bukkitPlayer = event.getPlayer();
+        if (hasContainerPermission(bukkitPlayer, entity.getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // container （item frame get）
+    public void removeSomeOnItemFrame(EntityDamageByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof ItemFrame itemFrame)) {
+            return;
+        }
+        if (itemFrame.getItem().getType() == Material.AIR) {
+            return;
+        }
+        if (!(event.getDamager() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        if (hasContainerPermission(bukkitPlayer, entity.getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // container （item frame get）
+    public void removeSomeOnItemFrameByArrow(EntityDamageByEntityEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof ItemFrame itemFrame)) {
+            return;
+        }
+        if (itemFrame.getItem().getType() == Material.AIR) {
+            return;
+        }
+        if (!(event.getDamager() instanceof Arrow arrow)) {
+            return;
+        }
+        if (!(arrow.getShooter() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        if (hasContainerPermission(bukkitPlayer, itemFrame.getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // craft
+    public void onCraft(InventoryOpenEvent event) {
+        Inventory inv = event.getInventory();
+        if (inv.getType() != InventoryType.WORKBENCH) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = getInvDominion(bukkitPlayer, inv);
+        checkFlag(dom, Flag.CRAFT, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // crafter
+    public void onCrafterOpen(InventoryOpenEvent event) {
+        Inventory inv = event.getInventory();
+        // InventoryType.CRAFTER;
+        if (!inv.getType().name().contains("CRAFTER")) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = getInvDominion(bukkitPlayer, inv);
+        checkFlag(dom, Flag.CRAFTER, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // comparer
+    public void comparerChange(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        Material clicked = event.getClickedBlock().getType();
+        if (clicked != Material.COMPARATOR) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getClickedBlock().getLocation());
+        checkFlag(dom, Flag.COMPARER, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // door
+    public void doorUse(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        if (!Tag.DOORS.isTagged(block.getType())) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getClickedBlock().getLocation());
+        checkFlag(dom, Flag.DOOR, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // dragon_egg
+    public void touchDragonEdd(PlayerInteractEvent event) {
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        if (block.getType() != Material.DRAGON_EGG) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.DRAGON_EGG, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // dye
+    public void dyeEvent(PlayerInteractEntityEvent event) {
+        Player player = event.getPlayer();
+        Entity entity = event.getRightClicked();
+        if (!(entity instanceof Colorable)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.DYE, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // edit sign
+    public void onSignOpen(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Player player = event.getPlayer();
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        if (!(Tag.SIGNS.isTagged(block.getType()))) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.EDIT_SIGN, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // edit sign
+    public void onSignEdit(SignChangeEvent event) {
+        Player player = event.getPlayer();
+        Block block = event.getBlock();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.EDIT_SIGN, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // egg
+    public void onThrowingEgg(ProjectileLaunchEvent event) {
+        if (!(event.getEntity().getShooter() instanceof Player player)) {
+            return;
+        }
+        if (event.getEntity().getType() != EntityType.EGG) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(player);
+        checkFlag(dom, Flag.EGG, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // enchant
+    public void onEnchant(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.ENCHANTING) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = getInvDominion(bukkitPlayer, event.getInventory());
+        checkFlag(dom, Flag.ENCHANT, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // ender_pearl
+    public void onThrowingEndPearl(ProjectileLaunchEvent event) {
+        if (!(event.getEntity().getShooter() instanceof Player player)) {
+            return;
+        }
+        if (event.getEntity().getType() != EntityType.ENDER_PEARL) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(player);
+        checkFlag(dom, Flag.ENDER_PEARL, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // feed
+    public void onFeedAnimal(PlayerInteractEntityEvent event) {
+        if (!(event.getRightClicked() instanceof Animals)) {
+            return;
+        }
+        // if shearing sheep instead
+        if (event.getPlayer().getInventory().getItem(event.getHand()).getType() == Material.SHEARS) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getRightClicked().getLocation());
+        checkFlag(dom, Flag.FEED, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // harvest
+    public void onHarvest(BlockBreakEvent event) {
+        Block block = event.getBlock();
+        if (block.getType() != Material.COCOA &&
+                block.getType() != Material.WHEAT &&
+                block.getType() != Material.CARROTS &&
+                block.getType() != Material.POTATOES &&
+                block.getType() != Material.BEETROOTS &&
+                block.getType() != Material.NETHER_WART &&
+                block.getType() != Material.SWEET_BERRY_BUSH &&
+                block.getType() != Material.MELON &&
+                block.getType() != Material.PUMPKIN &&
+                block.getType() != Material.SUGAR_CANE &&
+                block.getType() != Material.BAMBOO &&
+                block.getType() != Material.CACTUS &&
+                block.getType() != Material.CHORUS_PLANT &&
+                block.getType() != Material.CHORUS_FLOWER &&
+                block.getType() != Material.KELP &&
+                block.getType() != Material.KELP_PLANT) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.HARVEST, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // honey
+    public void honeyInteractive(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        Material clicked = block.getType();
+        if (clicked != Material.BEEHIVE && clicked != Material.BEE_NEST) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.HONEY, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // hook
+    public void onHook(PlayerFishEvent event) {
+        Entity caught = event.getCaught();
+        if (caught == null) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(caught.getLocation());
+        checkFlag(dom, Flag.HOOK, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // hopper
+    public void openHopper(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.HOPPER &&
+                event.getInventory().getType() != InventoryType.DROPPER &&
+                event.getInventory().getType() != InventoryType.DISPENSER &&
+                event.getInventory().getType() != InventoryType.FURNACE &&
+                event.getInventory().getType() != InventoryType.BLAST_FURNACE &&
+                event.getInventory().getType() != InventoryType.SMOKER
+        ) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = getInvDominion(bukkitPlayer, event.getInventory());
+        checkFlag(dom, Flag.HOPPER, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // ignite
+    public void onPlayerIgnite(BlockIgniteEvent event) {
+        Player player = event.getPlayer();
+        if (player == null) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getBlock().getLocation());
+        checkFlag(dom, Flag.IGNITE, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // item_frame_interactive
+    public void onItemFrameInteractive(PlayerInteractEntityEvent event) {
+        Entity entity = event.getRightClicked();
+        if (!(entity instanceof ItemFrame itemFrame)) {
+            return;
+        }
+        if (itemFrame.getItem().getType() == Material.AIR) {
+            // 为空则当作容器处理见 putSomeOnItemFrame
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.ITEM_FRAME_INTERACTIVE, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // lever
+    public void onLever(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        Material clicked = block.getType();
+        if (clicked != Material.LEVER) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.LEVER, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // monster_killing
+    public void onMonsterKilling(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        // 如果不是怪物 则不处理
+        Entity entity = event.getEntity();
+        if (!(entity instanceof Monster)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.MONSTER_KILLING, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // move
+    public void onPlayerMove(PlayerMoveEvent event) {
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(player);
+        if (!checkFlag(dom, Flag.MOVE, player, null)) {
+            Location to = player.getLocation();
+            int x1 = Math.abs(to.getBlockX() - dom.getX1());
+            int x2 = Math.abs(to.getBlockX() - dom.getX2());
+            int z1 = Math.abs(to.getBlockZ() - dom.getZ1());
+            int z2 = Math.abs(to.getBlockZ() - dom.getZ2());
+            // find min distance
+            int min = Math.min(Math.min(x1, x2), Math.min(z1, z2));
+            if (min == x1) {
+                to.setX(dom.getX1() - 2);
+            } else if (min == x2) {
+                to.setX(dom.getX2() + 2);
+            } else if (min == z1) {
+                to.setZ(dom.getZ1() - 2);
+            } else {
+                to.setZ(dom.getZ2() + 2);
+            }
+            Teleport.doTeleportSafely(player, to).thenAccept((success) -> {
+                if (!success) {
+                    Notification.warn(player, "传送失败，你将被传送到复活点");
+                    Location bed = player.getBedSpawnLocation();
+                    if (bed == null) {
+                        bed = player.getWorld().getSpawnLocation();
+                    }
+                    if (Common.isPaper()) {
+                        player.teleportAsync(bed, PlayerTeleportEvent.TeleportCause.PLUGIN);
+                    } else {
+                        player.teleport(bed, PlayerTeleportEvent.TeleportCause.PLUGIN);
+                    }
+
+                }
+            });
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // note_block
+    public void onNoteBlockClicked(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        Material clicked = block.getType();
+        if (clicked != Material.NOTE_BLOCK) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.NOTE_BLOCK, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // place
+    public void onPlaceBlock(BlockPlaceEvent event) {
+        Player player = event.getPlayer();
+        if (onPlace(player, event.getBlock().getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // place - lava or water
+    public void onPlaceLavaOrWater(PlayerBucketEmptyEvent event) {
+        Player player = event.getPlayer();
+        if (onPlace(player, event.getBlock().getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // place - item frame
+    public void placeItemFrame(HangingPlaceEvent event) {
+        Entity entity = event.getEntity();
+        Player player = event.getPlayer();
+        if (player == null) {
+            return;
+        }
+        if (onPlace(player, entity.getLocation())) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    public static boolean onPlace(Player player, Location location) {
+        DominionDTO dom = Cache.instance.getDominionByLoc(location);
+        return checkFlag(dom, Flag.PLACE, player, null);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // pressure
+    public void onPressure(PlayerInteractEvent event) {
+        if (event.getAction() != Action.PHYSICAL) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        if (block == null) {
+            return;
+        }
+        if (!Tag.PRESSURE_PLATES.isTagged(block.getType())) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.PRESSURE, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // riding
+    public void onRiding(EntityMountEvent event) {
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getMount().getLocation());
+        checkFlag(dom, Flag.RIDING, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // repeater
+    public void onRepeaterChange(PlayerInteractEvent event) {
+        if (event.getClickedBlock() == null) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        Material clicked = block.getType();
+        if (clicked != Material.REPEATER) {
+            return;
+        }
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(block.getLocation());
+        checkFlag(dom, Flag.REPEATER, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // shear
+    public void onShear(PlayerShearEntityEvent event) {
+        Player player = event.getPlayer();
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getEntity().getLocation());
+        checkFlag(dom, Flag.SHEAR, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // shoot
+    public void onShootArrowSnowball(ProjectileHitEvent event) {
+        if (!(event.getEntity().getShooter() instanceof Player player)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getPlayerCurrentDominion(player);
+        checkFlag(dom, Flag.SHOOT, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // trade
+    public void onTrade(InventoryOpenEvent event) {
+        if (event.getInventory().getType() != InventoryType.MERCHANT) {
+            return;
+        }
+        if (!(event.getPlayer() instanceof Player bukkitPlayer)) {
+            return;
+        }
+        DominionDTO dom = getInvDominion(bukkitPlayer, event.getInventory());
+        checkFlag(dom, Flag.TRADE, bukkitPlayer, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // vehicle_destroy
+    public void onVehicleDestroy(VehicleDestroyEvent event) {
+        if (!(event.getAttacker() instanceof Player player)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getVehicle().getLocation());
+        checkFlag(dom, Flag.VEHICLE_DESTROY, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) // vehicle_spawn
+    public void onVehicleSpawn(EntityPlaceEvent event) {
+        Player player = event.getPlayer();
+        if (player == null) {
+            return;
+        }
+        Entity entity = event.getEntity();
+        if (!(entity instanceof Vehicle)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());
+        checkFlag(dom, Flag.VEHICLE_SPAWN, player, event);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)  // villager_killing
+    public void onVillagerKilling(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Player player)) {
+            return;
+        }
+        if (!(event.getEntity() instanceof Villager)) {
+            return;
+        }
+        DominionDTO dom = Cache.instance.getDominionByLoc(event.getEntity().getLocation());
+        checkFlag(dom, Flag.VILLAGER_KILLING, player, event);
+    }
+}

v1_20_1/src/main/java/cn/lunadeer/dominion/events_v1_20_1/SelectPointEvents.java

@@ -0,0 +1,104 @@
+package cn.lunadeer.dominion.events_v1_20_1;
+
+import cn.lunadeer.dominion.Dominion;
+import cn.lunadeer.dominion.dtos.DominionDTO;
+import cn.lunadeer.dominion.utils.Particle;
+import cn.lunadeer.minecraftpluginutils.Notification;
+import cn.lunadeer.minecraftpluginutils.VaultConnect.VaultConnect;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SelectPointEvents implements Listener {
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void selectPoint(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = player.getInventory().getItemInMainHand();
+
+        if (item.getType() != Dominion.config.getTool()) {
+            return;
+        }
+        Block block = event.getClickedBlock();
+        Action action = event.getAction();
+        if (block == null) {
+            return;
+        }
+
+        Map<Integer, Location> points = Dominion.pointsSelect.get(player.getUniqueId());
+        if (points == null) {
+            points = new HashMap<>();
+        }
+
+        if (action == Action.LEFT_CLICK_BLOCK) {
+            event.setCancelled(true);
+            Notification.info(player, "已选择第一个点: %d %d %d", block.getX(), block.getY(), block.getZ());
+            Location loc = block.getLocation();
+            if (Dominion.config.getLimitVert()) {
+                loc.setY(Dominion.config.getLimitMinY());
+            }
+            points.put(0, loc);
+        } else if (action == Action.RIGHT_CLICK_BLOCK) {
+            event.setCancelled(true);
+            Notification.info(player, "已选择第二个点: %d %d %d", block.getX(), block.getY(), block.getZ());
+            Location loc = block.getLocation();
+            if (Dominion.config.getLimitVert()) {
+                loc.setY(Dominion.config.getLimitMaxY() - 1);
+            }
+            points.put(1, loc);
+        } else {
+            return;
+        }
+        Dominion.pointsSelect.put(player.getUniqueId(), points);
+
+        if (points.size() == 2) {
+            World world = points.get(0).getWorld();
+            if (world == null) {
+                return;
+            }
+            if (!points.get(0).getWorld().equals(points.get(1).getWorld())) {
+                Notification.warn(player, "两个点不在同一个世界");
+                return;
+            }
+            Notification.info(player, "已选择两个点，可以使用 /dominion create <领地名称> 创建领地");
+            Location loc1 = points.get(0);
+            Location loc2 = points.get(1);
+            int minX = Math.min(loc1.getBlockX(), loc2.getBlockX());
+            int minY = Math.min(loc1.getBlockY(), loc2.getBlockY());
+            int minZ = Math.min(loc1.getBlockZ(), loc2.getBlockZ());
+            int maxX = Math.max(loc1.getBlockX(), loc2.getBlockX()) + 1;
+            int maxY = Math.max(loc1.getBlockY(), loc2.getBlockY()) + 1;
+            int maxZ = Math.max(loc1.getBlockZ(), loc2.getBlockZ()) + 1;
+            DominionDTO dominion = new DominionDTO(player.getUniqueId(), "", loc1.getWorld().getName(),
+                    minX, minY, minZ, maxX, maxY, maxZ);
+            if (Dominion.config.getEconomyEnable()) {
+                if (!VaultConnect.instance.economyAvailable()) {
+                    Notification.error(player, "计算价格失败，没有可用的经济插件系统，请联系服主。");
+                    return;
+                }
+                int count;
+                if (Dominion.config.getEconomyOnlyXZ()) {
+                    count = dominion.getSquare();
+                } else {
+                    count = dominion.getVolume();
+                }
+                float price = count * Dominion.config.getEconomyPrice();
+                Notification.info(player, "预计领地创建价格为 %.2f %s", price, VaultConnect.instance.currencyNamePlural());
+            }
+            Particle.showBorder(player, dominion);
+            Notification.info(player, "尺寸： %d x %d x %d", dominion.getWidthX(), dominion.getHeight(), dominion.getWidthZ());
+            Notification.info(player, "面积： %d", dominion.getSquare());
+            Notification.info(player, "高度： %d", dominion.getHeight());
+            Notification.info(player, "体积： %d", dominion.getVolume());
+        }
+    }
+}

v1_21/build.gradle.kts

@@ -0,0 +1,21 @@
+plugins {
+    id("java")
+}
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+}
+
+// utf-8
+tasks.withType<JavaCompile> {
+    options.encoding = "UTF-8"
+}
+
+repositories {
+    maven("https://repo.papermc.io/repository/maven-public/")
+}
+
+dependencies {
+    compileOnly(project(":core"))
+    compileOnly("io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT")
+}

v1_21/src/main/java/cn/lunadeer/dominion/events_v1_21/EnvironmentEvents.java

@@ -1,4 +1,4 @@
-package cn.lunadeer.dominion.events;
+package cn.lunadeer.dominion.events_v1_21;
 
 import cn.lunadeer.dominion.Cache;
 import cn.lunadeer.dominion.dtos.DominionDTO;
@@ -80,11 +80,12 @@ public class EnvironmentEvents implements Listener {
     }
 
     private static boolean isNotExplodeEntity(Entity damager) {
-        String materialName = damager.getType().name();
+        return damager.getType() != EntityType.CREEPER
-        return !materialName.contains("CREEPER")
+                && damager.getType() != EntityType.WITHER_SKULL
-                && !materialName.contains("WITHER_SKULL")
+                && damager.getType() != EntityType.FIREBALL
-                && !materialName.contains("FIREBALL")
+                && damager.getType() != EntityType.END_CRYSTAL
-                && !materialName.contains("CRYSTAL");
+                && damager.getType() != EntityType.SMALL_FIREBALL
+                && damager.getType() != EntityType.DRAGON_FIREBALL;
     }
 
     @EventHandler(priority = EventPriority.HIGHEST) // dragon_break_block
@@ -149,8 +150,7 @@ public class EnvironmentEvents implements Listener {
     @EventHandler(priority = EventPriority.HIGHEST) // tnt_explode
     public void onTntExplode(EntityExplodeEvent event) {
         Entity entity = event.getEntity();
-        XLogger.debug("EntityExplodeEvent#name(): " + entity.getType().name());
+        if (entity.getType() != EntityType.TNT_MINECART && entity.getType() != EntityType.TNT) {
-        if (!entity.getType().name().contains("TNT")) {
             return;
         }
         event.blockList().removeIf(block -> {
@@ -165,7 +165,7 @@ public class EnvironmentEvents implements Listener {
         if (entity.getType() != EntityType.ARMOR_STAND) {
             return;
         }
-        if (!event.getDamager().getType().name().contains("TNT")) {
+        if (entity.getType() != EntityType.TNT_MINECART && entity.getType() != EntityType.TNT) {
             return;
         }
         DominionDTO dom = Cache.instance.getDominionByLoc(entity.getLocation());

v1_21/src/main/java/cn/lunadeer/dominion/events_v1_21/PlayerEvents.java

@@ -1,4 +1,4 @@
-package cn.lunadeer.dominion.events;
+package cn.lunadeer.dominion.events_v1_21;
 
 import cn.lunadeer.dominion.Cache;
 import cn.lunadeer.dominion.dtos.DominionDTO;

v1_21/src/main/java/cn/lunadeer/dominion/events_v1_21/SelectPointEvents.java

@@ -1,4 +1,4 @@
-package cn.lunadeer.dominion.events;
+package cn.lunadeer.dominion.events_v1_21;
 
 import cn.lunadeer.dominion.Dominion;
 import cn.lunadeer.dominion.dtos.DominionDTO;