添加一些基础条件和函数

还需要对vanilla-loots系统进行重构
2025-12-21 07:59:19 +00:00 · 2025-05-14 21:44:56 +08:00
parent f7016bacdf
commit c047e5a83c
32 changed files with 608 additions and 74 deletions
--- a/bukkit/loader/src/main/resources/translations/en.yml
+++ b/bukkit/loader/src/main/resources/translations/en.yml
@@ -90,7 +90,10 @@ warning.config.condition.match_block_property.missing_properties: "<yellow>Issue
 warning.config.condition.match_item.missing_id: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'id' argument for 'match_item' condition.</yellow>"
 warning.config.condition.table_bonus.missing_enchantment: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'enchantment' argument for 'table_bonus' condition.</yellow>"
 warning.config.condition.table_bonus.missing_chances: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'chances' argument for 'table_bonus' condition.</yellow>"
-warning.config.condition.click_type.missing_click_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'click-type' argument for 'click_type' condition.</yellow>"
+warning.config.condition.permission.missing_permission: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'permission' argument for 'permission' condition.</yellow>"
+warning.config.condition.equals.missing_value1: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'value1' argument for 'equals' condition.</yellow>"
+warning.config.condition.equals.missing_value2: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'value2' argument for 'equals' condition.</yellow>"
+warning.config.condition.expression.missing_expression: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'expression' argument for 'expression' condition.</yellow>"
 warning.config.structure.not_section: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is expected to be a config section while it's actually a(n) '<arg:2>'.</yellow>"
 warning.config.image.duplicate: "<yellow>Issue found in file <arg:0> - Duplicated image '<arg:1>'. Please check if there is the same configuration in other files.</yellow>"
 warning.config.image.missing_height: "<yellow>Issue found in file <arg:0> - The image '<arg:1>' is missing the required 'height' argument.</yellow>"
@@ -302,4 +305,9 @@ warning.config.event.condition.missing_type: "<yellow>Issue found in file <arg:0
 warning.config.event.condition.invalid_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is using an invalid 'type' argument '<arg:2>' for event condition.</yellow>"
 warning.config.function.missing_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'type' argument for function.</yellow>"
 warning.config.function.invalid_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is using an invalid function type '<arg:2>'.</yellow>"
-warning.config.function.command.missing_command: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'command' argument for 'command' function.</yellow>"
+warning.config.function.command.missing_command: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'command' argument for 'command' function.</yellow>"
+warning.config.function.actionbar.missing_actionbar: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'actionbar' argument for 'actionbar' function.</yellow>"
+warning.config.function.message.missing_message: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'message' argument for 'message' function.</yellow>"
+warning.config.selector.missing_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'type' argument for selector.</yellow>"
+warning.config.selector.invalid_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is using an invalid selector type '<arg:2>'.</yellow>"
+warning.config.selector.invalid_target: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is using an invalid selector target '<arg:2>'.</yellow>"
--- a/bukkit/loader/src/main/resources/translations/zh_cn.yml
+++ b/bukkit/loader/src/main/resources/translations/zh_cn.yml
@@ -90,7 +90,8 @@ warning.config.condition.match_block_property.missing_properties: "<yellow>在
 warning.config.condition.match_item.missing_id: "<yellow>在文件 <arg:0> 发现问题 - 配置项 '<arg:1>' 缺少 'match_item' 条件所需的 'id' 参数</yellow>"
 warning.config.condition.table_bonus.missing_enchantment: "<yellow>在文件 <arg:0> 发现问题 - 配置项 '<arg:1>' 缺少 'table_bonus' 条件所需的 'enchantment' 参数</yellow>"
 warning.config.condition.table_bonus.missing_chances: "<yellow>在文件 <arg:0> 发现问题 - 配置项 '<arg:1>' 缺少 'table_bonus' 条件所需的 'chances' 参数</yellow>"
-warning.config.condition.click_type.missing_click_type: "<yellow>Issue found in file <arg:0> - The config '<arg:1>' is missing the required 'click-type' argument for 'click_type' condition.</yellow>"
+
+
 warning.config.structure.not_section: "<yellow>在文件 <arg:0> 发现问题 - 配置项 '<arg:1>' 应为配置段落 但实际类型为 '<arg:2>'</yellow>"
 warning.config.image.duplicate: "<yellow>在文件 <arg:0> 发现问题 - 重复的图片配置 '<arg:1>' 请检查其他文件中是否存在相同配置</yellow>"
 warning.config.image.missing_height: "<yellow>在文件 <arg:0> 发现问题 - 图片 '<arg:1>' 缺少必需的 'height' 参数</yellow>"
--- a/bukkit/src/main/java/net/momirealms/craftengine/bukkit/block/BlockEventListener.java
+++ b/bukkit/src/main/java/net/momirealms/craftengine/bukkit/block/BlockEventListener.java
@@ -11,6 +11,7 @@ import net.momirealms.craftengine.bukkit.world.BukkitWorld;
 import net.momirealms.craftengine.core.block.ImmutableBlockState;
 import net.momirealms.craftengine.core.block.properties.Property;
 import net.momirealms.craftengine.core.entity.player.InteractionHand;
+import net.momirealms.craftengine.core.item.CustomItem;
 import net.momirealms.craftengine.core.item.Item;
 import net.momirealms.craftengine.core.loot.LootTable;
 import net.momirealms.craftengine.core.plugin.config.Config;
@@ -42,6 +43,7 @@ import org.bukkit.event.world.GenericGameEvent;
 import org.bukkit.inventory.ItemStack;

 import java.util.List;
+import java.util.Optional;

 public class BlockEventListener implements Listener {
    private final BukkitCraftEngine plugin;
@@ -121,11 +123,35 @@ public class BlockEventListener implements Listener {
        Object blockState = BlockStateUtils.blockDataToBlockState(block.getBlockData());
        int stateId = BlockStateUtils.blockStateToId(blockState);
        Player player = event.getPlayer();
+        Location location = block.getLocation();
+        BukkitServerPlayer serverPlayer = this.plugin.adapt(player);
+        net.momirealms.craftengine.core.world.World world = new BukkitWorld(player.getWorld());
+        WorldPosition position = new WorldPosition(world, location.getBlockX() + 0.5, location.getBlockY() + 0.5, location.getBlockZ() + 0.5);
+        Item<ItemStack> itemInHand = serverPlayer.getItemInHand(InteractionHand.MAIN_HAND);
+
+        if (itemInHand != null) {
+            Optional<CustomItem<ItemStack>> optionalCustomItem = itemInHand.getCustomItem();
+            if (optionalCustomItem.isPresent()) {
+                Cancellable dummy = Cancellable.dummy();
+                optionalCustomItem.get().execute(
+                        PlayerOptionalContext.of(serverPlayer, ContextHolder.builder()
+                            .withParameter(DirectContextParameters.BLOCK, new BukkitBlockInWorld(block))
+                            .withParameter(DirectContextParameters.POSITION, position)
+                            .withParameter(DirectContextParameters.PLAYER, serverPlayer)
+                            .withParameter(DirectContextParameters.EVENT, dummy)
+                            .withOptionalParameter(DirectContextParameters.ITEM_IN_HAND, itemInHand)
+                        ), EventTrigger.BREAK
+                );
+                if (dummy.isCancelled()) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
+
        if (!BlockStateUtils.isVanillaBlock(stateId)) {
            ImmutableBlockState state = manager.getImmutableBlockStateUnsafe(stateId);
            if (!state.isEmpty()) {
-                Location location = block.getLocation();
-                BukkitServerPlayer serverPlayer = this.plugin.adapt(player);
                // double check adventure mode to prevent dupe
                if (!FastNMS.INSTANCE.mayBuild(serverPlayer.serverPlayer()) && !serverPlayer.canBreak(LocationUtils.toBlockPos(location), null)) {
                    return;
@@ -139,10 +165,6 @@ public class BlockEventListener implements Listener {
                    return;
                }

-                Item<ItemStack> itemInHand = serverPlayer.getItemInHand(InteractionHand.MAIN_HAND);
-                net.momirealms.craftengine.core.world.World world = new BukkitWorld(location.getWorld());
-                WorldPosition position = new WorldPosition(world, location.getBlockX() + 0.5, location.getBlockY() + 0.5, location.getBlockZ() + 0.5);
-
                // execute functions
                Cancellable cancellable = Cancellable.dummy();
                PlayerOptionalContext context = PlayerOptionalContext.of(serverPlayer, ContextHolder.builder()
@@ -180,12 +202,12 @@ public class BlockEventListener implements Listener {
                }

                // drop items
-                ContextHolder.Builder builder = ContextHolder.builder()
+                ContextHolder.Builder lootContext = ContextHolder.builder()
                        .withParameter(DirectContextParameters.POSITION, position)
                        .withParameter(DirectContextParameters.PLAYER, serverPlayer)
                        .withParameter(DirectContextParameters.BLOCK, new BukkitBlockInWorld(block))
                        .withOptionalParameter(DirectContextParameters.ITEM_IN_HAND, itemInHand);
-                for (Item<Object> item : state.getDrops(builder, world, serverPlayer)) {
+                for (Item<Object> item : state.getDrops(lootContext, world, serverPlayer)) {
                    world.dropItemNaturally(position, item);
                }
            }
@@ -197,23 +219,19 @@ public class BlockEventListener implements Listener {
                        event.setDropItems(false);
                        event.setExpToDrop(0);
                    }
-                    Location location = block.getLocation();
-                    BukkitServerPlayer serverPlayer = this.plugin.adapt(player);
-                    net.momirealms.craftengine.core.world.World world = new BukkitWorld(player.getWorld());
-                    WorldPosition position = new WorldPosition(world, location.getBlockX() + 0.5, location.getBlockY() + 0.5, location.getBlockZ() + 0.5);
-                    ContextHolder.Builder builder = ContextHolder.builder()
+                    ContextHolder lootContext = ContextHolder.builder()
                            .withParameter(DirectContextParameters.BLOCK, new BukkitBlockInWorld(block))
                            .withParameter(DirectContextParameters.POSITION, position)
                            .withParameter(DirectContextParameters.PLAYER, serverPlayer)
-                            .withOptionalParameter(DirectContextParameters.ITEM_IN_HAND, serverPlayer.getItemInHand(InteractionHand.MAIN_HAND));
-                    ContextHolder contextHolder = builder.build();
+                            .withOptionalParameter(DirectContextParameters.ITEM_IN_HAND, itemInHand).build();
                    for (LootTable<?> lootTable : it.lootTables()) {
-                        for (Item<?> item : lootTable.getRandomItems(contextHolder, world, serverPlayer)) {
+                        for (Item<?> item : lootTable.getRandomItems(lootContext, world, serverPlayer)) {
                            world.dropItemNaturally(position, item);
                        }
                    }
                });
            }
+
            // sound system
            if (Config.enableSoundSystem()) {
                Object ownerBlock = BlockStateUtils.getBlockOwner(blockState);
--- a/bukkit/src/main/java/net/momirealms/craftengine/bukkit/entity/BukkitEntity.java
+++ b/bukkit/src/main/java/net/momirealms/craftengine/bukkit/entity/BukkitEntity.java
@@ -8,6 +8,7 @@ import net.momirealms.craftengine.core.util.Key;
 import net.momirealms.craftengine.core.world.World;

 import java.lang.ref.WeakReference;
+import java.util.UUID;

 public class BukkitEntity extends AbstractEntity {
    private final WeakReference<org.bukkit.entity.Entity> entity;
@@ -69,4 +70,14 @@ public class BukkitEntity extends AbstractEntity {
    public Key type() {
        return KeyUtils.namespacedKey2Key(literalObject().getType().getKey());
    }
+
+    @Override
+    public String name() {
+        return literalObject().getName();
+    }
+
+    @Override
+    public UUID uuid() {
+        return literalObject().getUniqueId();
+    }
 }
--- a/bukkit/src/main/java/net/momirealms/craftengine/bukkit/plugin/user/BukkitServerPlayer.java
+++ b/bukkit/src/main/java/net/momirealms/craftengine/bukkit/plugin/user/BukkitServerPlayer.java
@@ -13,6 +13,7 @@ import net.momirealms.craftengine.bukkit.world.BukkitWorld;
 import net.momirealms.craftengine.core.block.BlockSettings;
 import net.momirealms.craftengine.core.block.ImmutableBlockState;
 import net.momirealms.craftengine.core.block.PackedBlockState;
+import net.momirealms.craftengine.core.entity.player.GameMode;
 import net.momirealms.craftengine.core.entity.player.InteractionHand;
 import net.momirealms.craftengine.core.entity.player.Player;
 import net.momirealms.craftengine.core.item.Item;
@@ -27,7 +28,10 @@ import net.momirealms.craftengine.core.util.VersionHelper;
 import net.momirealms.craftengine.core.world.BlockPos;
 import net.momirealms.craftengine.core.world.World;
 import net.momirealms.craftengine.core.world.WorldEvents;
-import org.bukkit.*;
+import org.bukkit.FluidCollisionMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.SoundCategory;
 import org.bukkit.attribute.Attribute;
 import org.bukkit.attribute.AttributeInstance;
 import org.bukkit.block.Block;
@@ -145,18 +149,18 @@ public class BukkitServerPlayer extends Player {
    }

    @Override
-    public boolean isCreativeMode() {
-        return platformPlayer().getGameMode() == GameMode.CREATIVE;
+    public GameMode gameMode() {
+        return switch (platformPlayer().getGameMode()) {
+            case CREATIVE -> GameMode.CREATIVE;
+            case SPECTATOR -> GameMode.SPECTATOR;
+            case ADVENTURE -> GameMode.ADVENTURE;
+            case SURVIVAL -> GameMode.SURVIVAL;
+        };
    }

    @Override
-    public boolean isSpectatorMode() {
-        return platformPlayer().getGameMode() == GameMode.SPECTATOR;
-    }
-
-    @Override
-    public boolean isAdventureMode() {
-        return platformPlayer().getGameMode() == GameMode.ADVENTURE;
+    public void setGameMode(GameMode gameMode) {
+        platformPlayer().setGameMode(Objects.requireNonNull(org.bukkit.GameMode.getByValue(gameMode.id())));
    }

    @Override
@@ -175,6 +179,14 @@ public class BukkitServerPlayer extends Player {
        sendPacket(packet, false);
    }

+    @Override
+    public void sendTitle(Component title, Component subtitle, int fadeIn, int stay, int fadeOut) {
+        Object titlePacket = FastNMS.INSTANCE.constructor$ClientboundSetTitleTextPacket(ComponentUtils.adventureToMinecraft(title));
+        Object subtitlePacket = FastNMS.INSTANCE.constructor$ClientboundSetSubtitleTextPacket(ComponentUtils.adventureToMinecraft(subtitle));
+        Object timePacket = FastNMS.INSTANCE.constructor$ClientboundSetTitlesAnimationPacket(fadeIn, stay, fadeOut);
+        sendPackets(List.of(titlePacket, subtitlePacket, timePacket), false);
+    }
+
    @Override
    public void sendMessage(Component text, boolean overlay) {
        Object packet = FastNMS.INSTANCE.constructor$ClientboundSystemChatPacket(ComponentUtils.adventureToMinecraft(text), overlay);
@@ -816,4 +828,9 @@ public class BukkitServerPlayer extends Player {
            return LegacyAttributeUtils.getLuck(platformPlayer());
        }
    }
+
+    @Override
+    public boolean isFlying() {
+        return platformPlayer().isFlying();
+    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/entity/Entity.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/entity/Entity.java
@@ -5,6 +5,8 @@ import net.momirealms.craftengine.core.util.Key;
 import net.momirealms.craftengine.core.world.World;
 import net.momirealms.craftengine.core.world.WorldPosition;

+import java.util.UUID;
+
 public interface Entity {
    Key type();

@@ -29,4 +31,8 @@ public interface Entity {
    Direction getDirection();

    Object literalObject();
+
+    String name();
+
+    UUID uuid();
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/entity/player/GameMode.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/entity/player/GameMode.java
@@ -0,0 +1,18 @@
+package net.momirealms.craftengine.core.entity.player;
+
+public enum GameMode {
+    SURVIVAL(0),
+    CREATIVE(1),
+    ADVENTURE(2),
+    SPECTATOR(3);
+
+    private final int id;
+
+    GameMode(int id) {
+        this.id = id;
+    }
+
+    public int id() {
+        return id;
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/entity/player/Player.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/entity/player/Player.java
@@ -46,11 +46,9 @@ public abstract class Player extends AbstractEntity implements NetWorkUser {

    public abstract boolean isSneaking();

-    public abstract boolean isCreativeMode();
+    public abstract GameMode gameMode();

-    public abstract boolean isSpectatorMode();
-
-    public abstract boolean isAdventureMode();
+    public abstract void setGameMode(GameMode gameMode);

    public abstract boolean canBreak(BlockPos pos, Object state);

@@ -60,6 +58,8 @@ public abstract class Player extends AbstractEntity implements NetWorkUser {

    public abstract void sendMessage(Component text, boolean overlay);

+    public abstract void sendTitle(Component title, Component subtitle, int fadeIn, int stay, int fadeOut);
+
    public abstract boolean updateLastSuccessfulInteractionTick(int tick);

    public abstract int lastSuccessfulInteractionTick();
@@ -75,7 +75,7 @@ public abstract class Player extends AbstractEntity implements NetWorkUser {
    public abstract String name();

    public void playSound(Key sound) {
-        playSound(sound, 1, 1);
+        playSound(sound, 1f, 1f);
    }

    public abstract void playSound(Key sound, float volume, float pitch);
@@ -92,8 +92,26 @@ public abstract class Player extends AbstractEntity implements NetWorkUser {

    public abstract double luck();

+    public abstract boolean isFlying();
+
    @Override
    public Key type() {
        return TYPE;
    }
+
+    public boolean isCreativeMode() {
+        return gameMode() == GameMode.CREATIVE;
+    }
+
+    public boolean isSpectatorMode() {
+        return gameMode() == GameMode.SPECTATOR;
+    }
+
+    public boolean isSurvivalMode() {
+        return gameMode() == GameMode.SURVIVAL;
+    }
+
+    public boolean isAdventureMode() {
+        return gameMode() == GameMode.ADVENTURE;
+    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/loot/LootConditions.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/loot/LootConditions.java
@@ -30,6 +30,9 @@ public class LootConditions {
        register(CommonConditions.FALLING_BLOCK, new FallingBlockCondition.FactoryImpl<>());
        register(CommonConditions.RANDOM, new RandomCondition.FactoryImpl<>());
        register(CommonConditions.DISTANCE, new DistanceCondition.FactoryImpl<>());
+        register(CommonConditions.PERMISSION, new PermissionCondition.FactoryImpl<>());
+        register(CommonConditions.EQUALS, new EqualsCondition.FactoryImpl<>());
+        register(CommonConditions.EXPRESSION, new ExpressionCondition.FactoryImpl<>());
    }

    public static void register(Key key, ConditionFactory<LootContext> factory) {
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/AbstractChainParameterContext.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/AbstractChainParameterContext.java
@@ -14,6 +14,8 @@ public abstract class AbstractChainParameterContext extends AbstractCommonContex
        CHAIN_PARAMETERS.put(DirectContextParameters.WORLD, new WorldParameterProvider());
        CHAIN_PARAMETERS.put(DirectContextParameters.BLOCK, new BlockParameterProvider());
        CHAIN_PARAMETERS.put(DirectContextParameters.POSITION, new PositionParameterProvider());
+        CHAIN_PARAMETERS.put(DirectContextParameters.FURNITURE, new FurnitureParameterProvider());
+        CHAIN_PARAMETERS.put(DirectContextParameters.ENTITY, new EntityParameterProvider());
        ItemParameterProvider itemProvider = new ItemParameterProvider();
        CHAIN_PARAMETERS.put(DirectContextParameters.MAIN_HAND_ITEM, itemProvider);
        CHAIN_PARAMETERS.put(DirectContextParameters.OFF_HAND_ITEM, itemProvider);
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/CommonConditions.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/CommonConditions.java
@@ -10,7 +10,6 @@ public final class CommonConditions {
    public static final Key ANY_OF = Key.of("craftengine:any_of");
    public static final Key INVERTED = Key.of("craftengine:inverted");
    public static final Key MATCH_ITEM = Key.of("craftengine:match_item");
-    public static final Key CLICK_TYPE = Key.of("craftengine:click_type");
    public static final Key MATCH_BLOCK_PROPERTY = Key.from("craftengine:match_block_property");
    public static final Key TABLE_BONUS = Key.from("craftengine:table_bonus");
    public static final Key SURVIVES_EXPLOSION = Key.from("craftengine:survives_explosion");
@@ -19,4 +18,6 @@ public final class CommonConditions {
    public static final Key FALLING_BLOCK = Key.from("craftengine:falling_block");
    public static final Key DISTANCE = Key.from("craftengine:distance");
    public static final Key PERMISSION = Key.from("craftengine:permission");
+    public static final Key EQUALS = Key.from("craftengine:equals");
+    public static final Key EXPRESSION = Key.from("craftengine:expression");
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/EqualsCondition.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/EqualsCondition.java
@@ -0,0 +1,40 @@
+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.plugin.context.text.TextProvider;
+import net.momirealms.craftengine.core.plugin.context.text.TextProviders;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+
+import java.util.Map;
+
+public class EqualsCondition<CTX extends Context> implements Condition<CTX> {
+    private final TextProvider value1;
+    private final TextProvider value2;
+
+    public EqualsCondition(TextProvider value1, TextProvider value2) {
+        this.value1 = value1;
+        this.value2 = value2;
+    }
+
+    @Override
+    public Key type() {
+        return CommonConditions.EQUALS;
+    }
+
+    @Override
+    public boolean test(CTX ctx) {
+        return this.value1.get(ctx).equals(this.value2.get(ctx));
+    }
+
+    public static class FactoryImpl<CTX extends Context> implements ConditionFactory<CTX> {
+
+        @Override
+        public Condition<CTX> create(Map<String, Object> arguments) {
+            String value1 = ResourceConfigUtils.requireNonEmptyStringOrThrow(arguments.get("value1"), "warning.config.condition.equals.missing_value1");
+            String value2 = ResourceConfigUtils.requireNonEmptyStringOrThrow(arguments.get("value1"), "warning.config.condition.equals.missing_value2");
+            return new EqualsCondition<>(TextProviders.fromString(value1), TextProviders.fromString(value2));
+        }
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/ExpressionCondition.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/ExpressionCondition.java
@@ -0,0 +1,48 @@
+package net.momirealms.craftengine.core.plugin.context.condition;
+
+import com.ezylang.evalex.EvaluationException;
+import com.ezylang.evalex.Expression;
+import com.ezylang.evalex.parser.ParseException;
+import net.momirealms.craftengine.core.plugin.CraftEngine;
+import net.momirealms.craftengine.core.plugin.context.Condition;
+import net.momirealms.craftengine.core.plugin.context.Context;
+import net.momirealms.craftengine.core.plugin.context.text.TextProvider;
+import net.momirealms.craftengine.core.plugin.context.text.TextProviders;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+
+import java.util.Map;
+
+public class ExpressionCondition<CTX extends Context> implements Condition<CTX> {
+    private final TextProvider expression;
+
+    public ExpressionCondition(TextProvider expression) {
+        this.expression = expression;
+    }
+
+    @Override
+    public Key type() {
+        return CommonConditions.EXPRESSION;
+    }
+
+    @Override
+    public boolean test(CTX ctx) {
+        String exp = expression.get(ctx);
+        Expression expr = new Expression(exp);
+        try {
+            return expr.evaluate().getBooleanValue();
+        } catch (ParseException | EvaluationException e) {
+            CraftEngine.instance().logger().warn("Invalid expression " + exp, e);
+            return false;
+        }
+    }
+
+    public static class FactoryImpl<CTX extends Context> implements ConditionFactory<CTX> {
+
+        @Override
+        public Condition<CTX> create(Map<String, Object> arguments) {
+            String value = ResourceConfigUtils.requireNonEmptyStringOrThrow(arguments.get("expression"), "warning.config.condition.expression.missing_expression");
+            return new ExpressionCondition<>(TextProviders.fromString(value));
+        }
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/PermissionCondition.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/condition/PermissionCondition.java
@@ -0,0 +1,39 @@
+package net.momirealms.craftengine.core.plugin.context.condition;
+
+import net.momirealms.craftengine.core.entity.player.Player;
+import net.momirealms.craftengine.core.plugin.context.Condition;
+import net.momirealms.craftengine.core.plugin.context.Context;
+import net.momirealms.craftengine.core.plugin.context.parameter.DirectContextParameters;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+
+import java.util.Map;
+import java.util.Optional;
+
+public class PermissionCondition<CTX extends Context> implements Condition<CTX> {
+    private final String permission;
+
+    public PermissionCondition(String permission) {
+        this.permission = permission;
+    }
+
+    @Override
+    public Key type() {
+        return CommonConditions.PERMISSION;
+    }
+
+    @Override
+    public boolean test(CTX ctx) {
+        Optional<Player> player = ctx.getOptionalParameter(DirectContextParameters.PLAYER);
+        return player.map(value -> value.hasPermission(this.permission)).orElse(false);
+    }
+
+    public static class FactoryImpl<CTX extends Context> implements ConditionFactory<CTX> {
+
+        @Override
+        public Condition<CTX> create(Map<String, Object> arguments) {
+            String permission = ResourceConfigUtils.requireNonEmptyStringOrThrow(arguments.get("permission"), "warning.config.condition.permission.missing_permission");
+            return new PermissionCondition<>(permission);
+        }
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/ActionBarFunction.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/ActionBarFunction.java
@@ -0,0 +1,61 @@
+package net.momirealms.craftengine.core.plugin.context.function;
+
+import net.momirealms.craftengine.core.entity.player.Player;
+import net.momirealms.craftengine.core.plugin.context.*;
+import net.momirealms.craftengine.core.plugin.context.parameter.DirectContextParameters;
+import net.momirealms.craftengine.core.plugin.context.selector.PlayerSelector;
+import net.momirealms.craftengine.core.plugin.context.selector.PlayerSelectors;
+import net.momirealms.craftengine.core.plugin.context.text.TextProvider;
+import net.momirealms.craftengine.core.plugin.context.text.TextProviders;
+import net.momirealms.craftengine.core.util.AdventureHelper;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class ActionBarFunction<CTX extends Context> extends AbstractConditionalFunction<CTX> {
+    private final TextProvider message;
+    private final PlayerSelector<CTX> selector;
+
+    public ActionBarFunction(List<Condition<CTX>> predicates, @Nullable PlayerSelector<CTX> selector, TextProvider messages) {
+        super(predicates);
+        this.message = messages;
+        this.selector = selector;
+    }
+
+    @Override
+    public void runInternal(CTX ctx) {
+        Optional<Player> owner = ctx.getOptionalParameter(DirectContextParameters.PLAYER);
+        if (this.selector == null) {
+            owner.ifPresent(it -> {
+                it.sendActionBar(AdventureHelper.miniMessage().deserialize(this.message.get(ctx), ctx.tagResolvers()));
+            });
+        } else {
+            for (Player viewer : this.selector.get(ctx)) {
+                RelationalContext relationalContext = ViewerContext.of(ctx, PlayerOptionalContext.of(viewer, ContextHolder.EMPTY));
+                viewer.sendActionBar(AdventureHelper.miniMessage().deserialize(this.message.get(relationalContext), relationalContext.tagResolvers()));
+            }
+        }
+    }
+
+    @Override
+    public Key type() {
+        return CommonFunctions.ACTIONBAR;
+    }
+
+    public static class FactoryImpl<CTX extends Context> extends AbstractFactory<CTX> {
+
+        public FactoryImpl(java.util.function.Function<Map<String, Object>, Condition<CTX>> factory) {
+            super(factory);
+        }
+
+        @Override
+        public Function<CTX> create(Map<String, Object> arguments) {
+            String message = ResourceConfigUtils.requireNonEmptyStringOrThrow(ResourceConfigUtils.get(arguments, "actionbar", "message"), "warning.config.function.actionbar.missing_actionbar");
+            return new ActionBarFunction<>(getPredicates(arguments), PlayerSelectors.fromObject(arguments.get("target"), conditionFactory()), TextProviders.fromString(message));
+        }
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/CancelEventFunction.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/CancelEventFunction.java
@@ -0,0 +1,41 @@
+package net.momirealms.craftengine.core.plugin.context.function;
+
+import net.momirealms.craftengine.core.plugin.context.Condition;
+import net.momirealms.craftengine.core.plugin.context.Context;
+import net.momirealms.craftengine.core.plugin.context.parameter.DirectContextParameters;
+import net.momirealms.craftengine.core.util.Cancellable;
+import net.momirealms.craftengine.core.util.Key;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class CancelEventFunction<CTX extends Context> extends AbstractConditionalFunction<CTX> {
+
+    public CancelEventFunction(List<Condition<CTX>> predicates) {
+        super(predicates);
+    }
+
+    @Override
+    public void runInternal(CTX ctx) {
+        Optional<Cancellable> cancellable = ctx.getOptionalParameter(DirectContextParameters.EVENT);
+        cancellable.ifPresent(value -> value.setCancelled(true));
+    }
+
+    @Override
+    public Key type() {
+        return CommonFunctions.CANCEL_EVENT;
+    }
+
+    public static class FactoryImpl<CTX extends Context> extends AbstractFactory<CTX> {
+
+        public FactoryImpl(java.util.function.Function<Map<String, Object>, Condition<CTX>> factory) {
+            super(factory);
+        }
+
+        @Override
+        public Function<CTX> create(Map<String, Object> arguments) {
+            return new CancelEventFunction<>(getPredicates(arguments));
+        }
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/CommandFunction.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/CommandFunction.java
@@ -23,7 +23,7 @@ public class CommandFunction<CTX extends Context> extends AbstractConditionalFun
    private final boolean asPlayer;
    private final PlayerSelector<CTX> selector;

-    public CommandFunction(List<Condition<CTX>> predicates, List<TextProvider> command, boolean asPlayer, @Nullable PlayerSelector<CTX> selector) {
+    public CommandFunction(List<Condition<CTX>> predicates, @Nullable PlayerSelector<CTX> selector, List<TextProvider> command, boolean asPlayer) {
        super(predicates);
        this.asPlayer = asPlayer;
        this.command = command;
@@ -72,7 +72,7 @@ public class CommandFunction<CTX extends Context> extends AbstractConditionalFun
            Object command = ResourceConfigUtils.requireNonNullOrThrow(ResourceConfigUtils.get(arguments, "command", "commands"), "warning.config.function.command.missing_command");
            List<TextProvider> commands = MiscUtils.getAsStringList(command).stream().map(TextProviders::fromString).toList();
            boolean asPlayer = (boolean) arguments.getOrDefault("as-player", false);
-            return new CommandFunction<>(getPredicates(arguments), commands, asPlayer, PlayerSelectors.fromObject(arguments.get("target"), conditionFactory()));
+            return new CommandFunction<>(getPredicates(arguments), PlayerSelectors.fromObject(arguments.get("target"), conditionFactory()), commands, asPlayer);
        }
    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/MessageFunction.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/MessageFunction.java
@@ -22,7 +22,7 @@ public class MessageFunction<CTX extends Context> extends AbstractConditionalFun
    private final PlayerSelector<CTX> selector;
    private final boolean overlay;

-    public MessageFunction(List<Condition<CTX>> predicates, List<TextProvider> messages, @Nullable PlayerSelector<CTX> selector, boolean overlay) {
+    public MessageFunction(List<Condition<CTX>> predicates, @Nullable PlayerSelector<CTX> selector, List<TextProvider> messages, boolean overlay) {
        super(predicates);
        this.messages = messages;
        this.selector = selector;
@@ -64,7 +64,7 @@ public class MessageFunction<CTX extends Context> extends AbstractConditionalFun
            Object message = ResourceConfigUtils.requireNonNullOrThrow(ResourceConfigUtils.get(arguments, "messages", "message"), "warning.config.function.command.missing_message");
            List<TextProvider> messages = MiscUtils.getAsStringList(message).stream().map(TextProviders::fromString).toList();
            boolean overlay = (boolean) arguments.getOrDefault("overlay", false);
-            return new MessageFunction<>(getPredicates(arguments), messages, PlayerSelectors.fromObject(arguments.get("target"), conditionFactory()), overlay);
+            return new MessageFunction<>(getPredicates(arguments), PlayerSelectors.fromObject(arguments.get("target"), conditionFactory()), messages, overlay);
        }
    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/TitleFunction.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/function/TitleFunction.java
@@ -0,0 +1,82 @@
+package net.momirealms.craftengine.core.plugin.context.function;
+
+import net.momirealms.craftengine.core.entity.player.Player;
+import net.momirealms.craftengine.core.plugin.context.*;
+import net.momirealms.craftengine.core.plugin.context.number.NumberProvider;
+import net.momirealms.craftengine.core.plugin.context.number.NumberProviders;
+import net.momirealms.craftengine.core.plugin.context.parameter.DirectContextParameters;
+import net.momirealms.craftengine.core.plugin.context.selector.PlayerSelector;
+import net.momirealms.craftengine.core.plugin.context.selector.PlayerSelectors;
+import net.momirealms.craftengine.core.plugin.context.text.TextProvider;
+import net.momirealms.craftengine.core.plugin.context.text.TextProviders;
+import net.momirealms.craftengine.core.util.AdventureHelper;
+import net.momirealms.craftengine.core.util.Key;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class TitleFunction<CTX extends Context> extends AbstractConditionalFunction<CTX> {
+    private final PlayerSelector<CTX> selector;
+    private final TextProvider main;
+    private final TextProvider sub;
+    private final NumberProvider fadeIn;
+    private final NumberProvider stay;
+    private final NumberProvider fadeOut;
+
+    public TitleFunction(List<Condition<CTX>> predicates, @Nullable PlayerSelector<CTX> selector,
+                         TextProvider main, TextProvider sub, NumberProvider fadeIn, NumberProvider stay, NumberProvider fadeOut) {
+        super(predicates);
+        this.selector = selector;
+        this.main = main;
+        this.sub = sub;
+        this.fadeIn = fadeIn;
+        this.stay = stay;
+        this.fadeOut = fadeOut;
+    }
+
+    @Override
+    public void runInternal(CTX ctx) {
+        Optional<Player> owner = ctx.getOptionalParameter(DirectContextParameters.PLAYER);
+        if (this.selector == null) {
+            owner.ifPresent(it -> it.sendTitle(
+                    AdventureHelper.miniMessage().deserialize(this.main.get(ctx), ctx.tagResolvers()),
+                    AdventureHelper.miniMessage().deserialize(this.sub.get(ctx), ctx.tagResolvers()),
+                    this.fadeIn.getInt(ctx), this.stay.getInt(ctx), this.fadeOut.getInt(ctx)
+            ));
+        } else {
+            for (Player viewer : this.selector.get(ctx)) {
+                RelationalContext relationalContext = ViewerContext.of(ctx, PlayerOptionalContext.of(viewer, ContextHolder.EMPTY));
+                viewer.sendTitle(
+                        AdventureHelper.miniMessage().deserialize(this.main.get(relationalContext), relationalContext.tagResolvers()),
+                        AdventureHelper.miniMessage().deserialize(this.sub.get(relationalContext), relationalContext.tagResolvers()),
+                        this.fadeIn.getInt(relationalContext), this.stay.getInt(relationalContext), this.fadeOut.getInt(relationalContext)
+                );
+            }
+        }
+    }
+
+    @Override
+    public Key type() {
+        return CommonFunctions.TITLE;
+    }
+
+    public static class FactoryImpl<CTX extends Context> extends AbstractFactory<CTX> {
+
+        public FactoryImpl(java.util.function.Function<Map<String, Object>, Condition<CTX>> factory) {
+            super(factory);
+        }
+
+        @Override
+        public Function<CTX> create(Map<String, Object> arguments) {
+            String title = arguments.getOrDefault("title", "").toString();
+            String subtitle = arguments.getOrDefault("subtitle", "").toString();
+            NumberProvider fadeIn = NumberProviders.fromObject(arguments.getOrDefault("fade-in", 10));
+            NumberProvider stay = NumberProviders.fromObject(arguments.getOrDefault("stay", 20));
+            NumberProvider fadeOut = NumberProviders.fromObject(arguments.getOrDefault("fade-out", 5));
+            return new TitleFunction<>(getPredicates(arguments), PlayerSelectors.fromObject(arguments.get("target"), conditionFactory()),
+                    TextProviders.fromString(title), TextProviders.fromString(subtitle), fadeIn, stay, fadeOut);
+        }
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/DirectContextParameters.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/DirectContextParameters.java
@@ -2,8 +2,10 @@ package net.momirealms.craftengine.core.plugin.context.parameter;

 import net.momirealms.craftengine.core.block.CustomBlock;
 import net.momirealms.craftengine.core.block.ImmutableBlockState;
+import net.momirealms.craftengine.core.entity.Entity;
 import net.momirealms.craftengine.core.entity.furniture.AnchorType;
 import net.momirealms.craftengine.core.entity.furniture.Furniture;
+import net.momirealms.craftengine.core.entity.player.GameMode;
 import net.momirealms.craftengine.core.entity.player.InteractionHand;
 import net.momirealms.craftengine.core.entity.player.Player;
 import net.momirealms.craftengine.core.item.Item;
@@ -29,6 +31,7 @@ public final class DirectContextParameters {
    public static final ContextKey<Boolean> FALLING_BLOCK = ContextKey.direct("falling_block");
    public static final ContextKey<Float> EXPLOSION_RADIUS = ContextKey.direct("explosion_radius");
    public static final ContextKey<Player> PLAYER = ContextKey.direct("player");
+    public static final ContextKey<Entity> ENTITY = ContextKey.direct("entity");
    public static final ContextKey<ImmutableBlockState> BLOCK_STATE = ContextKey.direct("custom_block_state");
    public static final ContextKey<Position> COORDINATE = ContextKey.direct("coordinate");
    public static final ContextKey<WorldPosition> POSITION = ContextKey.direct("position");
@@ -51,4 +54,8 @@ public final class DirectContextParameters {
    public static final ContextKey<AnchorType> ANCHOR_TYPE = ContextKey.direct("anchor_type");
    public static final ContextKey<InteractionHand> HAND = ContextKey.direct("hand");
    public static final ContextKey<Cancellable> EVENT = ContextKey.direct("event");
+    public static final ContextKey<Boolean> IS_FLYING = ContextKey.direct("is_flying");
+    public static final ContextKey<Boolean> IS_SNEAKING = ContextKey.direct("is_sneaking");
+    public static final ContextKey<Boolean> IS_CUSTOM = ContextKey.direct("is_custom");
+    public static final ContextKey<GameMode> GAMEMODE = ContextKey.direct("gamemode");
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/EntityParameterProvider.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/EntityParameterProvider.java
@@ -0,0 +1,33 @@
+package net.momirealms.craftengine.core.plugin.context.parameter;
+
+import net.momirealms.craftengine.core.entity.Entity;
+import net.momirealms.craftengine.core.plugin.context.ChainParameterProvider;
+import net.momirealms.craftengine.core.plugin.context.ContextKey;
+import net.momirealms.craftengine.core.util.MCUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class EntityParameterProvider implements ChainParameterProvider<Entity> {
+    private static final Map<ContextKey<?>, Function<Entity, Object>> CONTEXT_FUNCTIONS = new HashMap<>();
+    static {
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.X, Entity::x);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.Y, Entity::y);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.Z, Entity::z);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.POSITION, Entity::position);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.BLOCK_X, p -> MCUtils.fastFloor(p.x()));
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.BLOCK_Y, p -> MCUtils.fastFloor(p.y()));
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.BLOCK_Z, p -> MCUtils.fastFloor(p.z()));
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.NAME, Entity::name);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.UUID, Entity::uuid);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.WORLD, Entity::world);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> Optional<T> getOptionalParameter(ContextKey<T> parameter, Entity entity) {
+        return (Optional<T>) Optional.ofNullable(CONTEXT_FUNCTIONS.get(parameter)).map(f -> f.apply(entity));
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/FurnitureParameterProvider.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/FurnitureParameterProvider.java
@@ -0,0 +1,25 @@
+package net.momirealms.craftengine.core.plugin.context.parameter;
+
+import net.momirealms.craftengine.core.entity.furniture.Furniture;
+import net.momirealms.craftengine.core.plugin.context.ChainParameterProvider;
+import net.momirealms.craftengine.core.plugin.context.ContextKey;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class FurnitureParameterProvider implements ChainParameterProvider<Furniture> {
+    private static final Map<ContextKey<?>, Function<Furniture, Object>> CONTEXT_FUNCTIONS = new HashMap<>();
+    static {
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.ID, Furniture::id);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.UUID, Furniture::uuid);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.ANCHOR_TYPE, Furniture::anchorType);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> Optional<T> getOptionalParameter(ContextKey<T> parameter, Furniture world) {
+        return (Optional<T>) Optional.ofNullable(CONTEXT_FUNCTIONS.get(parameter)).map(f -> f.apply(world));
+    }
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/ItemParameterProvider.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/ItemParameterProvider.java
@@ -14,6 +14,7 @@ public class ItemParameterProvider implements ChainParameterProvider<Item<?>> {
    static {
        CONTEXT_FUNCTIONS.put(DirectContextParameters.ID, Item::id);
        CONTEXT_FUNCTIONS.put(DirectContextParameters.CUSTOM_MODEL_DATA, i -> i.customModelData().orElse(null));
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.IS_CUSTOM, Item::isCustomItem);
    }

    @SuppressWarnings("unchecked")
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/PlayerParameterProvider.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/parameter/PlayerParameterProvider.java
@@ -26,6 +26,9 @@ public class PlayerParameterProvider implements ChainParameterProvider<Player> {
        CONTEXT_FUNCTIONS.put(DirectContextParameters.NAME, Player::name);
        CONTEXT_FUNCTIONS.put(DirectContextParameters.UUID, Player::uuid);
        CONTEXT_FUNCTIONS.put(DirectContextParameters.WORLD, Entity::world);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.IS_FLYING, Player::isFlying);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.IS_SNEAKING, Player::isSneaking);
+        CONTEXT_FUNCTIONS.put(DirectContextParameters.GAMEMODE, Player::gameMode);
        CONTEXT_FUNCTIONS.put(DirectContextParameters.MAIN_HAND_ITEM, p -> p.getItemInHand(InteractionHand.MAIN_HAND));
        CONTEXT_FUNCTIONS.put(DirectContextParameters.OFF_HAND_ITEM, p -> p.getItemInHand(InteractionHand.OFF_HAND));
    }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/AllPlayerSelector.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/AllPlayerSelector.java
@@ -13,6 +13,8 @@ import net.momirealms.craftengine.core.util.MCUtils;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 import java.util.function.Predicate;

 public class AllPlayerSelector<CTX extends Context> implements PlayerSelector<CTX> {
@@ -50,4 +52,14 @@ public class AllPlayerSelector<CTX extends Context> implements PlayerSelector<CT
    public Key type() {
        return PlayerSelectors.ALL;
    }
+
+    public static class FactoryImpl<CTX extends Context> implements PlayerSelectorFactory<CTX> {
+
+        @Override
+        public PlayerSelector<CTX> create(Map<String, Object> args, Function<Map<String, Object>, Condition<CTX>> conditionFactory) {
+
+
+            return null;
+        }
+    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/PlayerSelectorFactory.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/PlayerSelectorFactory.java
@@ -0,0 +1,12 @@
+package net.momirealms.craftengine.core.plugin.context.selector;
+
+import net.momirealms.craftengine.core.plugin.context.Condition;
+import net.momirealms.craftengine.core.plugin.context.Context;
+
+import java.util.Map;
+import java.util.function.Function;
+
+public interface PlayerSelectorFactory<CTX extends Context> {
+
+    PlayerSelector<CTX> create(Map<String, Object> args, Function<Map<String, Object>, Condition<CTX>> conditionFactory);
+}
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/PlayerSelectors.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/PlayerSelectors.java
@@ -2,12 +2,17 @@ package net.momirealms.craftengine.core.plugin.context.selector;

 import net.momirealms.craftengine.core.plugin.context.Condition;
 import net.momirealms.craftengine.core.plugin.context.Context;
+import net.momirealms.craftengine.core.plugin.locale.LocalizedResourceConfigException;
+import net.momirealms.craftengine.core.registry.BuiltInRegistries;
+import net.momirealms.craftengine.core.registry.Holder;
+import net.momirealms.craftengine.core.registry.Registries;
+import net.momirealms.craftengine.core.registry.WritableRegistry;
 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.util.ResourceKey;
+import org.jetbrains.annotations.Nullable;

-import java.util.ArrayList;
-import java.util.List;
 import java.util.Map;
 import java.util.function.Function;

@@ -15,37 +20,41 @@ public class PlayerSelectors {
    public static final Key ALL = Key.of("craftengine:all");
    public static final Key SELF = Key.of("craftengine:self");

+    static {
+        register(ALL, new AllPlayerSelector.FactoryImpl<>());
+        register(SELF, new SelfPlayerSelector.FactoryImpl<>());
+    }
+
+    public static void register(Key key, PlayerSelectorFactory<?> factory) {
+        Holder.Reference<PlayerSelectorFactory<?>> holder = ((WritableRegistry<PlayerSelectorFactory<?>>) BuiltInRegistries.PLAYER_SELECTOR_FACTORY)
+                .registerForHolder(new ResourceKey<>(Registries.PLAYER_SELECTOR_FACTORY.location(), key));
+        holder.bindValue(factory);
+    }
+
+    @Nullable
    public static <CTX extends Context> PlayerSelector<CTX> fromObject(Object object, Function<Map<String, Object>, Condition<CTX>> conditionFactory) {
        if (object == null) return null;
-        if (object instanceof String string) {
-            if (string.equals("self") || string.equals("@self") || string.equals("@s")) {
-                return new SelfPlayerSelector<>();
-            } else if (string.equals("all") || string.equals("@all") || string.equals("@a")) {
-                return new AllPlayerSelector<>();
-            }
-        } else if (object instanceof Map<?,?> map) {
+        if (object instanceof Map<?,?> map) {
            Map<String, Object> selectorMap = MiscUtils.castToMap(map, false);
-            Object typeObj = selectorMap.get("type");
-            Object conditionObj = ResourceConfigUtils.get(selectorMap, "conditions");
-            if (!(typeObj instanceof String typeString)) {
-                throw new UnsupportedOperationException("Not supported yet.");
-            }
-            if (typeString.equals("all") || typeString.equals("@all") || typeString.equals("@a")) {
-                List<Condition<CTX>> conditions = new ArrayList<>();
-                if (conditionObj instanceof List<?> list) {
-                    @SuppressWarnings("unchecked")
-                    List<Map<String, Object>> conditionList = (List<Map<String, Object>>) list;
-                    for (Map<String, Object> condition : conditionList) {
-                        conditions.add(conditionFactory.apply(condition));
-                    }
-                } else if (conditionObj instanceof Map<?,?>) {
-                    conditions.add(conditionFactory.apply(MiscUtils.castToMap(conditionObj, false)));
-                } else {
-                    return new AllPlayerSelector<>();
-                }
-                return new AllPlayerSelector<>(conditions);
+            return fromMap(selectorMap, conditionFactory);
+        } else if (object instanceof String target) {
+            if (target.equals("all") || target.equals("@a")) {
+                return new AllPlayerSelector<>();
+            } else if (target.equals("self") || target.equals("@s")) {
+                return new SelfPlayerSelector<>();
            }
        }
-        throw new UnsupportedOperationException("Not supported yet.");
+        throw new LocalizedResourceConfigException("warning.config.selector.invalid_target", object.toString());
+    }
+
+    public static <CTX extends Context> PlayerSelector<CTX> fromMap(Map<String, Object> map, Function<Map<String, Object>, Condition<CTX>> conditionFactory) {
+        String type = ResourceConfigUtils.requireNonEmptyStringOrThrow(map.get("type"), "warning.config.selector.missing_type");
+        Key key = Key.withDefaultNamespace(type, Key.DEFAULT_NAMESPACE);
+        @SuppressWarnings("unchecked")
+        PlayerSelectorFactory<CTX> factory = (PlayerSelectorFactory<CTX>) BuiltInRegistries.PLAYER_SELECTOR_FACTORY.getValue(key);
+        if (factory == null) {
+            throw new LocalizedResourceConfigException("warning.config.selector.invalid_type", type);
+        }
+        return factory.create(map, conditionFactory);
    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/SelfPlayerSelector.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/context/selector/SelfPlayerSelector.java
@@ -1,11 +1,14 @@
 package net.momirealms.craftengine.core.plugin.context.selector;

 import net.momirealms.craftengine.core.entity.player.Player;
+import net.momirealms.craftengine.core.plugin.context.Condition;
 import net.momirealms.craftengine.core.plugin.context.Context;
 import net.momirealms.craftengine.core.plugin.context.parameter.DirectContextParameters;
 import net.momirealms.craftengine.core.util.Key;

 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;

 public class SelfPlayerSelector<CTX extends Context> implements PlayerSelector<CTX> {

@@ -18,4 +21,11 @@ public class SelfPlayerSelector<CTX extends Context> implements PlayerSelector<C
    public Key type() {
        return PlayerSelectors.SELF;
    }
+
+    public static class FactoryImpl<CTX extends Context> implements PlayerSelectorFactory<CTX> {
+        @Override
+        public PlayerSelector<CTX> create(Map<String, Object> args, Function<Map<String, Object>, Condition<CTX>> conditionFactory) {
+            return new SelfPlayerSelector<>();
+        }
+    }
 }
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/event/EventConditions.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/event/EventConditions.java
@@ -28,6 +28,9 @@ public class EventConditions {
        register(CommonConditions.FALLING_BLOCK, new FallingBlockCondition.FactoryImpl<>());
        register(CommonConditions.RANDOM, new RandomCondition.FactoryImpl<>());
        register(CommonConditions.DISTANCE, new DistanceCondition.FactoryImpl<>());
+        register(CommonConditions.PERMISSION, new PermissionCondition.FactoryImpl<>());
+        register(CommonConditions.EQUALS, new EqualsCondition.FactoryImpl<>());
+        register(CommonConditions.EXPRESSION, new ExpressionCondition.FactoryImpl<>());
    }

    public static void register(Key key, ConditionFactory<PlayerOptionalContext> factory) {
--- a/core/src/main/java/net/momirealms/craftengine/core/plugin/event/EventFunctions.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/plugin/event/EventFunctions.java
@@ -1,10 +1,7 @@
 package net.momirealms.craftengine.core.plugin.event;

 import net.momirealms.craftengine.core.plugin.context.PlayerOptionalContext;
-import net.momirealms.craftengine.core.plugin.context.function.CommandFunction;
-import net.momirealms.craftengine.core.plugin.context.function.CommonFunctions;
-import net.momirealms.craftengine.core.plugin.context.function.Function;
-import net.momirealms.craftengine.core.plugin.context.function.FunctionFactory;
+import net.momirealms.craftengine.core.plugin.context.function.*;
 import net.momirealms.craftengine.core.plugin.locale.LocalizedResourceConfigException;
 import net.momirealms.craftengine.core.registry.BuiltInRegistries;
 import net.momirealms.craftengine.core.registry.Holder;
@@ -24,6 +21,10 @@ public class EventFunctions {

    static {
        register(CommonFunctions.COMMAND, new CommandFunction.FactoryImpl<>(EventConditions::fromMap));
+        register(CommonFunctions.MESSAGE, new MessageFunction.FactoryImpl<>(EventConditions::fromMap));
+        register(CommonFunctions.ACTIONBAR, new ActionBarFunction.FactoryImpl<>(EventConditions::fromMap));
+        register(CommonFunctions.TITLE, new TitleFunction.FactoryImpl<>(EventConditions::fromMap));
+        register(CommonFunctions.CANCEL_EVENT, new CancelEventFunction.FactoryImpl<>(EventConditions::fromMap));
    }

    public static void register(Key key, FunctionFactory<PlayerOptionalContext> factory) {
--- a/core/src/main/java/net/momirealms/craftengine/core/registry/BuiltInRegistries.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/registry/BuiltInRegistries.java
@@ -25,6 +25,7 @@ import net.momirealms.craftengine.core.plugin.context.PlayerOptionalContext;
 import net.momirealms.craftengine.core.plugin.context.condition.ConditionFactory;
 import net.momirealms.craftengine.core.plugin.context.function.FunctionFactory;
 import net.momirealms.craftengine.core.plugin.context.number.NumberProviderFactory;
+import net.momirealms.craftengine.core.plugin.context.selector.PlayerSelectorFactory;
 import net.momirealms.craftengine.core.util.Key;
 import net.momirealms.craftengine.core.util.ResourceKey;

@@ -54,6 +55,7 @@ public class BuiltInRegistries {
    public static final Registry<ResourcePackHostFactory> RESOURCE_PACK_HOST_FACTORY = createRegistry(Registries.RESOURCE_PACK_HOST_FACTORY);
    public static final Registry<FunctionFactory<PlayerOptionalContext>> EVENT_FUNCTION_FACTORY = createRegistry(Registries.EVENT_FUNCTION_FACTORY);
    public static final Registry<ConditionFactory<PlayerOptionalContext>> EVENT_CONDITION_FACTORY = createRegistry(Registries.EVENT_CONDITION_FACTORY);
+    public static final Registry<PlayerSelectorFactory<?>> PLAYER_SELECTOR_FACTORY = createRegistry(Registries.PLAYER_SELECTOR_FACTORY);

    private static <T> Registry<T> createRegistry(ResourceKey<? extends Registry<T>> key) {
        return new MappedRegistry<>(key);
--- a/core/src/main/java/net/momirealms/craftengine/core/registry/Registries.java
+++ b/core/src/main/java/net/momirealms/craftengine/core/registry/Registries.java
@@ -25,6 +25,7 @@ import net.momirealms.craftengine.core.plugin.context.PlayerOptionalContext;
 import net.momirealms.craftengine.core.plugin.context.condition.ConditionFactory;
 import net.momirealms.craftengine.core.plugin.context.function.FunctionFactory;
 import net.momirealms.craftengine.core.plugin.context.number.NumberProviderFactory;
+import net.momirealms.craftengine.core.plugin.context.selector.PlayerSelectorFactory;
 import net.momirealms.craftengine.core.util.Key;
 import net.momirealms.craftengine.core.util.ResourceKey;

@@ -53,6 +54,7 @@ public class Registries {
    public static final ResourceKey<Registry<CustomSmithingTransformRecipe.ItemDataProcessor.ProcessorFactory>> SMITHING_RESULT_PROCESSOR_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("smithing_result_processor_factory"));
    public static final ResourceKey<Registry<HitBoxFactory>> HITBOX_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("hitbox_factory"));
    public static final ResourceKey<Registry<ResourcePackHostFactory>> RESOURCE_PACK_HOST_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("resource_pack_host_factory"));
-    public static final ResourceKey<Registry<FunctionFactory<PlayerOptionalContext>>> EVENT_FUNCTION_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("player_block_function_factory"));
-    public static final ResourceKey<Registry<ConditionFactory<PlayerOptionalContext>>> EVENT_CONDITION_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("player_block_condition_factory"));
+    public static final ResourceKey<Registry<FunctionFactory<PlayerOptionalContext>>> EVENT_FUNCTION_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("event_function_factory"));
+    public static final ResourceKey<Registry<ConditionFactory<PlayerOptionalContext>>> EVENT_CONDITION_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("event_condition_factory"));
+    public static final ResourceKey<Registry<PlayerSelectorFactory<?>>> PLAYER_SELECTOR_FACTORY = new ResourceKey<>(ROOT_REGISTRY, Key.withDefaultNamespace("player_selector"));
 }