添加wg区域条件

bukkit/compatibility/build.gradle.kts

@@ -70,6 +70,8 @@ dependencies {
     compileOnly("com.github.Archy-X:AureliumSkills:Beta1.3.21")
     // Zaphkiel
     compileOnly("ink.ptms:ZaphkielAPI:2.1.0")
+    // WorldGuard
+    compileOnly(files("${rootProject.rootDir}/libs/worldguard-bukkit-7.0.14-dist.jar"))
 }
 
 java {

bukkit/compatibility/src/main/java/net/momirealms/craftengine/bukkit/compatibility/BukkitCompatibilityManager.java

@@ -11,6 +11,7 @@ import net.momirealms.craftengine.bukkit.compatibility.mythicmobs.MythicItemDrop
 import net.momirealms.craftengine.bukkit.compatibility.mythicmobs.MythicSkillHelper;
 import net.momirealms.craftengine.bukkit.compatibility.papi.PlaceholderAPIUtils;
 import net.momirealms.craftengine.bukkit.compatibility.permission.LuckPermsEventListeners;
+import net.momirealms.craftengine.bukkit.compatibility.region.WorldGuardRegionCondition;
 import net.momirealms.craftengine.bukkit.compatibility.skript.SkriptHook;
 import net.momirealms.craftengine.bukkit.compatibility.slimeworld.SlimeFormatStorageAdaptor;
 import net.momirealms.craftengine.bukkit.compatibility.viaversion.ViaVersionUtils;
@@ -20,9 +21,13 @@ import net.momirealms.craftengine.bukkit.item.BukkitItemManager;
 import net.momirealms.craftengine.bukkit.plugin.BukkitCraftEngine;
 import net.momirealms.craftengine.core.entity.furniture.ExternalModel;
 import net.momirealms.craftengine.core.entity.player.Player;
+import net.momirealms.craftengine.core.loot.LootConditions;
 import net.momirealms.craftengine.core.plugin.compatibility.CompatibilityManager;
 import net.momirealms.craftengine.core.plugin.compatibility.LevelerProvider;
 import net.momirealms.craftengine.core.plugin.compatibility.ModelProvider;
+import net.momirealms.craftengine.core.plugin.context.condition.AlwaysFalseCondition;
+import net.momirealms.craftengine.core.plugin.context.condition.AlwaysTrueCondition;
+import net.momirealms.craftengine.core.plugin.context.event.EventConditions;
 import net.momirealms.craftengine.core.util.Key;
 import net.momirealms.craftengine.core.util.VersionHelper;
 import net.momirealms.craftengine.core.world.WorldManager;
@@ -117,6 +122,15 @@ public class BukkitCompatibilityManager implements CompatibilityManager {
             new MythicItemDropListener(this.plugin);
             logHook("MythicMobs");
         }
+        Key worldGuardRegion = Key.of("worldguard:region");
+        if (this.isPluginEnabled("WorldGuard")) {
+            EventConditions.register(worldGuardRegion, new WorldGuardRegionCondition.FactoryImpl<>());
+            LootConditions.register(worldGuardRegion, new WorldGuardRegionCondition.FactoryImpl<>());
+            logHook("WorldGuard");
+        } else {
+            EventConditions.register(worldGuardRegion, new AlwaysFalseCondition.FactoryImpl<>());
+            LootConditions.register(worldGuardRegion, new AlwaysFalseCondition.FactoryImpl<>());
+        }
     }
 
     @Override

bukkit/compatibility/src/main/java/net/momirealms/craftengine/bukkit/compatibility/region/WorldGuardRegionCondition.java

@@ -0,0 +1,95 @@
+package net.momirealms.craftengine.bukkit.compatibility.region;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.managers.RegionManager;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import net.momirealms.craftengine.core.plugin.context.Condition;
+import net.momirealms.craftengine.core.plugin.context.Context;
+import net.momirealms.craftengine.core.plugin.context.condition.ConditionFactory;
+import net.momirealms.craftengine.core.plugin.context.parameter.DirectContextParameters;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.MiscUtils;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+import net.momirealms.craftengine.core.world.WorldPosition;
+import org.bukkit.World;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.function.Predicate;
+
+public class WorldGuardRegionCondition<CTX extends Context> implements Condition<CTX> {
+    private static final Key TYPE = Key.of("worldguard:region");
+    private final MatchMode mode;
+    private final List<String> regions;
+
+    public WorldGuardRegionCondition(MatchMode mode, List<String> regions) {
+        this.mode = mode;
+        this.regions = regions;
+    }
+
+    @Override
+    public boolean test(CTX ctx) {
+        if (this.regions.isEmpty()) return false;
+        Optional<WorldPosition> optionalPos = ctx.getOptionalParameter(DirectContextParameters.POSITION);
+        if (optionalPos.isEmpty()) {
+            return false;
+        }
+        WorldPosition position = optionalPos.get();
+        RegionManager regionManager = WorldGuard.getInstance().getPlatform().getRegionContainer().get(BukkitAdapter.adapt((World) position.world().platformWorld()));
+        if (regionManager != null) {
+            ApplicableRegionSet set = regionManager.getApplicableRegions(BlockVector3.at(position.x(), position.y(), position.z()));
+            List<String> regionsAtThisPos = new ArrayList<>(set.size());
+            for (ProtectedRegion region : set) {
+                String id = region.getId();
+                regionsAtThisPos.add(id);
+            }
+            Predicate<String> predicate = regionsAtThisPos::contains;
+            return this.mode.matcher.apply(predicate, this.regions);
+        }
+        return false;
+    }
+
+    @Override
+    public Key type() {
+        return TYPE;
+    }
+
+    public enum MatchMode {
+        ANY((p, regions) -> {
+            for (String region : regions) {
+                if (p.test(region)) {
+                    return true;
+                }
+            }
+            return false;
+        }),
+        ALL((p, regions) -> {
+            for (String region : regions) {
+                if (!p.test(region)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+
+        private final BiFunction<Predicate<String>, List<String>, Boolean> matcher;
+
+        MatchMode(BiFunction<Predicate<String>, List<String>, Boolean> matcher) {
+            this.matcher = matcher;
+        }
+    }
+
+    public static class FactoryImpl<CTX extends Context> implements ConditionFactory<CTX> {
+
+        @Override
+        public Condition<CTX> create(Map<String, Object> arguments) {
+            int mode = ResourceConfigUtils.getAsInt(arguments.getOrDefault("mode", 1), "mode") - 1;
+            MatchMode matchMode = MatchMode.values()[mode];
+            List<String> regions = MiscUtils.getAsStringList(arguments.get("regions"));
+            return new WorldGuardRegionCondition<>(matchMode, regions);
+        }
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/AlwaysFalseCondition.java

@@ -0,0 +1,23 @@
+package net.momirealms.craftengine.core.plugin.context.condition;
+
+import net.momirealms.craftengine.core.plugin.context.Condition;
+import net.momirealms.craftengine.core.plugin.context.Context;
+import net.momirealms.craftengine.core.util.Key;
+
+import java.util.Map;
+
+public class AlwaysFalseCondition<CTX extends Context> implements Condition<CTX> {
+
+    @Override
+    public Key type() {
+        return CommonConditions.ALWAYS_FALSE;
+    }
+
+    public static class FactoryImpl<CTX extends Context> implements ConditionFactory<CTX> {
+
+        @Override
+        public Condition<CTX> create(Map<String, Object> arguments) {
+            return new AlwaysFalseCondition<>();
+        }
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/AlwaysTrueCondition.java

@@ -6,11 +6,11 @@ import net.momirealms.craftengine.core.util.Key;
 
 import java.util.Map;
 
-public class EmptyCondition<CTX extends Context> implements Condition<CTX> {
+public class AlwaysTrueCondition<CTX extends Context> implements Condition<CTX> {
 
     @Override
     public Key type() {
-        return CommonConditions.EMPTY;
+        return CommonConditions.ALWAYS_TRUE;
     }
 
     @Override
@@ -22,7 +22,7 @@ public class EmptyCondition<CTX extends Context> implements Condition<CTX> {
 
         @Override
         public Condition<CTX> create(Map<String, Object> arguments) {
-            return new EmptyCondition<>();
+            return new AlwaysTrueCondition<>();
         }
     }
 }

core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/CommonConditions.java

@@ -5,7 +5,8 @@ import net.momirealms.craftengine.core.util.Key;
 public final class CommonConditions {
     private CommonConditions() {}
 
-    public static final Key EMPTY = Key.of("craftengine:empty");
+    public static final Key ALWAYS_TRUE = Key.of("craftengine:always_true");
+    public static final Key ALWAYS_FALSE = Key.of("craftengine:always_false");
     public static final Key ALL_OF = Key.of("craftengine:all_of");
     public static final Key ANY_OF = Key.of("craftengine:any_of");
     public static final Key INVERTED = Key.of("craftengine:inverted");

core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/ExpressionCondition.java

@@ -27,7 +27,7 @@ public class ExpressionCondition<CTX extends Context> implements Condition<CTX>
 
     @Override
     public boolean test(CTX ctx) {
-        String exp = expression.get(ctx);
+        String exp = this.expression.get(ctx);
         Expression expr = new Expression(exp);
         try {
             return expr.evaluate().getBooleanValue();

core/src/main/java/net/momirealms/craftengine/core/world/chunk/CEChunk.java

@@ -60,7 +60,10 @@ public class CEChunk {
     }
 
     public void removeBlockEntity(BlockPos blockPos) {
-
+        BlockEntity removedBlockEntity = this.blockEntities.remove(blockPos);
+        if (removedBlockEntity != null) {
+            removedBlockEntity.setValid(false);
+        }
     }
 
     public void setBlockEntity(BlockEntity blockEntity) {
@@ -84,11 +87,27 @@ public class CEChunk {
     public BlockEntity getBlockEntity(BlockPos pos) {
         BlockEntity blockEntity = this.blockEntities.get(pos);
         if (blockEntity == null) {
-
+            blockEntity = createBlockEntity(pos);
+            if (blockEntity != null) {
+                this.addBlockEntity(blockEntity);
+            }
+        } else {
+            if (!blockEntity.isValid()) {
+                this.blockEntities.remove(pos);
+                return null;
+            }
         }
         return blockEntity;
     }
 
+    private BlockEntity createBlockEntity(BlockPos pos) {
+        ImmutableBlockState blockState = this.getBlockState(pos);
+        if (!blockState.hasBlockEntity()) {
+            return null;
+        }
+        return blockState.blockEntityType().factory().create(pos, blockState);
+    }
+
     public Map<BlockPos, BlockEntity> blockEntities() {
         return Collections.unmodifiableMap(this.blockEntities);
     }

core/src/main/java/net/momirealms/craftengine/core/world/chunk/serialization/DefaultBlockEntitySerializer.java

@@ -16,7 +16,10 @@ public final class DefaultBlockEntitySerializer {
     public static ListTag serialize(Map<BlockPos, BlockEntity> tiles) {
         ListTag result = new ListTag();
         for (Map.Entry<BlockPos, BlockEntity> entry : tiles.entrySet()) {
-            result.add(entry.getValue().saveAsTag());
+            BlockEntity entity = entry.getValue();
+            if (entity.isValid()) {
+                result.add(entity.saveAsTag());
+            }
         }
         return result;
     }

gradle.properties

@@ -2,7 +2,7 @@ org.gradle.jvmargs=-Xmx1G
 
 # Project settings
 # Rule: [major update].[feature update].[bug fix]
-project_version=0.0.62.6
+project_version=0.0.62.8
 config_version=45
 lang_version=25
 project_group=net.momirealms