Separate api and impl.

src/main/java/me/melontini/commander/api/command/Command.java

@@ -0,0 +1,25 @@
+package me.melontini.commander.api.command;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.DataResult;
+import me.melontini.commander.api.event.EventContext;
+import me.melontini.commander.api.event.EventType;
+import me.melontini.commander.impl.command.ConditionedCommand;
+
+
+public interface Command {
+
+    Codec<Conditioned> CODEC = (Codec<Conditioned>) ConditionedCommand.CODEC;
+
+    boolean execute(EventContext context);
+    CommandType type();
+
+    default DataResult<Void> validate(EventType type) {
+        return DataResult.success(null);
+    }
+
+    interface Conditioned {
+        boolean execute(EventContext context);
+        DataResult<Void> validate(EventType type);
+    }
+}

src/main/java/me/melontini/commander/command/CommandType.java → src/main/java/me/melontini/commander/api/command/CommandType.java

@@ -1,7 +1,7 @@
-package me.melontini.commander.command;
+package me.melontini.commander.api.command;
 
 import com.mojang.serialization.Codec;
-import me.melontini.commander.data.types.CommandTypes;
+import me.melontini.commander.impl.event.data.types.CommandTypes;
 import net.minecraft.util.Identifier;
 
 public interface CommandType {

src/main/java/me/melontini/commander/command/selector/MacroBuilder.java → src/main/java/me/melontini/commander/api/command/selector/MacroBuilder.java

@@ -1,9 +1,9 @@
-package me.melontini.commander.command.selector;
+package me.melontini.commander.api.command.selector;
 
 import com.google.common.collect.ImmutableMap;
-import me.melontini.commander.util.functions.ToDoubleBiFunction;
-import me.melontini.commander.util.functions.ToDoubleFunction;
-import me.melontini.commander.util.macro.MacroContainer;
+import me.melontini.commander.api.util.functions.ToDoubleBiFunction;
+import me.melontini.commander.api.util.functions.ToDoubleFunction;
+import me.melontini.commander.impl.util.macro.MacroContainer;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.registry.Registries;
@@ -27,6 +27,7 @@ public class MacroBuilder {
     public static Consumer<MacroBuilder> forEntity() {
         return builder -> builder
                 .string("uuid", source -> entity(source).getUuidAsString())
+                .string("key", source -> Registries.ENTITY_TYPE.getId(entity(source).getType()).toString())
                 .arithmetic("vel/x", source -> entity(source).getVelocity().x)
                 .arithmetic("vel/y", source -> entity(source).getVelocity().y)
                 .arithmetic("vel/z", source -> entity(source).getVelocity().z)

src/main/java/me/melontini/commander/command/selector/Selector.java → src/main/java/me/melontini/commander/api/command/selector/Selector.java

@@ -1,15 +1,21 @@
-package me.melontini.commander.command.selector;
+package me.melontini.commander.api.command.selector;
 
-import me.melontini.commander.data.types.SelectorTypes;
+import com.mojang.serialization.Codec;
+import me.melontini.commander.api.event.EventContext;
+import me.melontini.commander.impl.command.ConditionedSelector;
+import me.melontini.commander.impl.event.data.types.SelectorTypes;
 import net.minecraft.loot.context.LootContext;
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.util.Identifier;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Optional;
 import java.util.function.Consumer;
 
 public interface Selector {
 
+    Codec<Conditioned> CODEC = (Codec<Conditioned>) ConditionedSelector.CODEC;
+
     static Selector register(Identifier identifier, Selector selector) {
         return SelectorTypes.register(identifier, selector, null);
     }
@@ -19,4 +25,8 @@ static Selector register(Identifier identifier, Selector selector, Consumer<Macr
     }
 
     @Nullable ServerCommandSource select(LootContext context);
+
+    interface Conditioned {
+        Optional<ServerCommandSource> select(EventContext context);
+    }
 }

src/main/java/me/melontini/commander/api/event/EventContext.java

@@ -0,0 +1,27 @@
+package me.melontini.commander.api.event;
+
+import me.melontini.commander.impl.event.EventContextImpl;
+import net.minecraft.loot.context.LootContext;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+public interface EventContext {
+
+    static EventContext.Builder builder(EventType type) {
+        return new EventContextImpl.Builder(type);
+    }
+
+    <T> @NotNull T getParameter(EventKey<T> key);
+    @NotNull LootContext lootContext();
+
+    void setReturnValue(Object value);
+    <T> T getReturnValue(T def);
+
+    EventContext with(Map<EventKey<?>, Object> parameters);
+
+    interface Builder {
+        <T> Builder addParameter(EventKey<T> key, T value);
+        EventContext build();
+    }
+}

src/main/java/me/melontini/commander/api/event/EventKey.java

@@ -0,0 +1,26 @@
+package me.melontini.commander.api.event;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.Accessors;
+import me.melontini.commander.impl.Commander;
+import net.minecraft.loot.context.LootContext;
+import net.minecraft.util.Identifier;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+@Getter
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+@Accessors(fluent = true)
+public final class EventKey<T> {
+
+    public static final EventKey<LootContext> LOOT_CONTEXT = create(Commander.id("loot_context"));
+    public static final EventKey<AtomicReference<Object>> RETURN_VALUE = create(Commander.id("return_value"));
+
+    private final Identifier id;
+
+    public static <T> EventKey<T> create(Identifier id) {
+        return new EventKey<>(id);
+    }
+}

src/main/java/me/melontini/commander/api/event/EventType.java

@@ -0,0 +1,30 @@
+package me.melontini.commander.api.event;
+
+import com.mojang.serialization.Codec;
+import me.melontini.commander.impl.event.EventTypeImpl;
+import me.melontini.dark_matter.api.base.util.Context;
+import net.minecraft.util.Identifier;
+
+import java.util.List;
+import java.util.function.Function;
+
+import static me.melontini.commander.impl.Commander.id;
+
+public interface EventType extends Context {
+
+    EventType NULL = EventType.builder().extension(null, subscriptions -> null).build(id("none"));
+
+    Context.Key<Codec<?>> EXTENSION = Context.key("extension");
+    Context.Key<Function<List<Subscription<?>>, ?>> FINALIZER = Context.key("finalizer");
+    Context.Key<Codec<?>> CANCEL_TERM = Context.key("cancel_term");
+
+    static EventType.Builder builder() {
+        return new EventTypeImpl.Builder();
+    }
+
+    interface Builder {
+        <T, C> Builder extension(Codec<T> extension, Function<List<Subscription<T>>, C> finalizer);
+        <R> Builder cancelTerm(Codec<R> returnCodec);
+        EventType build(Identifier identifier);
+    }
+}

src/main/java/me/melontini/commander/api/event/Subscription.java

@@ -0,0 +1,18 @@
+package me.melontini.commander.api.event;
+
+import me.melontini.commander.api.command.Command;
+import me.melontini.commander.impl.event.data.DynamicEventManager;
+import net.minecraft.server.MinecraftServer;
+
+import java.util.List;
+
+public interface Subscription<E> {
+
+    static <T> T getData(MinecraftServer server, EventType type) {
+        return DynamicEventManager.getData(server, type);
+    }
+
+    EventType type();
+    E parameters();
+    List<Command.Conditioned> list();
+}

src/main/java/me/melontini/commander/util/math/Arithmetica.java → src/main/java/me/melontini/commander/api/util/Arithmetica.java

@@ -1,15 +1,15 @@
-package me.melontini.commander.util.math;
+package me.melontini.commander.api.util;
 
 import com.mojang.datafixers.util.Either;
 import com.mojang.serialization.Codec;
-import me.melontini.commander.util.functions.ToDoubleFunction;
-import me.melontini.commander.util.macro.PatternParser;
+import me.melontini.commander.api.util.functions.ToDoubleFunction;
+import me.melontini.commander.impl.util.ExpressionParser;
 import me.melontini.dark_matter.api.data.codecs.ExtraCodecs;
 import net.minecraft.loot.context.LootContext;
 
 public interface Arithmetica extends ToDoubleFunction<LootContext> {
 
-    Codec<Arithmetica> CODEC = ExtraCodecs.either(Codec.DOUBLE, Codec.STRING).comapFlatMap(PatternParser::parseArithmetica, Arithmetica::toSource);
+    Codec<Arithmetica> CODEC = ExtraCodecs.either(Codec.DOUBLE, Codec.STRING).comapFlatMap(ExpressionParser::parseArithmetica, Arithmetica::toSource);
 
     default long asLong(LootContext context) {
         return (long) this.apply(context);

src/main/java/me/melontini/commander/util/EventExecutors.java → src/main/java/me/melontini/commander/api/util/EventExecutors.java

@@ -1,44 +1,45 @@
-package me.melontini.commander.util;
+package me.melontini.commander.api.util;
 
 import lombok.experimental.UtilityClass;
-import me.melontini.commander.command.ConditionedCommand;
-import me.melontini.commander.data.DynamicEventManager;
-import me.melontini.commander.event.EventContext;
-import me.melontini.commander.event.EventKey;
-import me.melontini.commander.event.EventType;
+import me.melontini.commander.api.command.Command;
+import me.melontini.commander.api.event.EventContext;
+import me.melontini.commander.api.event.EventKey;
+import me.melontini.commander.api.event.EventType;
+import me.melontini.commander.api.event.Subscription;
 import me.melontini.dark_matter.api.base.util.MakeSure;
 import net.minecraft.loot.context.LootContext;
 import net.minecraft.util.ActionResult;
 import net.minecraft.world.World;
 
+import java.util.List;
 import java.util.function.Supplier;
 
 @UtilityClass
 public class EventExecutors {
     public static void runVoid(EventType type, World world, Supplier<LootContext> supplier) {
         if (world.isClient()) return;
 
-        var subscribers = DynamicEventManager.getData(MakeSure.notNull(world.getServer()), type, DynamicEventManager.DEFAULT);
+        List<Command.Conditioned> subscribers = Subscription.getData(MakeSure.notNull(world.getServer()), type);
         if (subscribers.isEmpty()) return;
 
         EventContext context = EventContext.builder(type)
                 .addParameter(EventKey.LOOT_CONTEXT, supplier.get())
                 .build();
-        for (ConditionedCommand subscriber : subscribers) subscriber.execute(context);
+        for (Command.Conditioned subscriber : subscribers) subscriber.execute(context);
     }
 
     public static boolean runBoolean(EventType type, boolean def, World world, Supplier<LootContext> supplier) {
         if (world.isClient()) return def;
 
-        var subscribers = DynamicEventManager.getData(MakeSure.notNull(world.getServer()), type, DynamicEventManager.DEFAULT);
+        List<Command.Conditioned> subscribers = Subscription.getData(MakeSure.notNull(world.getServer()), type);
         if (subscribers.isEmpty()) return def;
 
         EventContext context = EventContext.builder(type)
                 .addParameter(EventKey.LOOT_CONTEXT, supplier.get())
                 .build();
-        for (ConditionedCommand subscriber : subscribers) {
+        for (Command.Conditioned subscriber : subscribers) {
             subscriber.execute(context);
-            boolean val = context.getReturnValue(null, def);
+            boolean val = context.getReturnValue(def);
             if (val != def) return val;
         }
         return def;
@@ -51,15 +52,15 @@ public static boolean runBoolean(EventType type, World world, Supplier<LootConte
     public static <T extends Enum<T>> T runEnum(EventType type, T def, World world, Supplier<LootContext> supplier) {
         if (world.isClient()) return def;
 
-        var subscribers = DynamicEventManager.getData(MakeSure.notNull(world.getServer()), type, DynamicEventManager.DEFAULT);
+        List<Command.Conditioned> subscribers = Subscription.getData(MakeSure.notNull(world.getServer()), type);
         if (subscribers.isEmpty()) return def;
 
         var context = EventContext.builder(type)
                 .addParameter(EventKey.LOOT_CONTEXT, supplier.get())
                 .build();
-        for (ConditionedCommand subscriber : subscribers) {
+        for (Command.Conditioned subscriber : subscribers) {
             subscriber.execute(context);
-            T r = context.getReturnValue(null, def);
+            T r = context.getReturnValue(def);
             if (r != def) return r;
         }
         return def;

src/main/java/me/melontini/commander/util/functions/ToDoubleBiFunction.java → src/main/java/me/melontini/commander/api/util/functions/ToDoubleBiFunction.java

@@ -1,4 +1,4 @@
-package me.melontini.commander.util.functions;
+package me.melontini.commander.api.util.functions;
 
 public interface ToDoubleBiFunction<T, U> {
     double apply(T t, U u);

src/main/java/me/melontini/commander/util/functions/ToDoubleFunction.java → src/main/java/me/melontini/commander/api/util/functions/ToDoubleFunction.java

@@ -1,4 +1,4 @@
-package me.melontini.commander.util.functions;
+package me.melontini.commander.api.util.functions;
 
 public interface ToDoubleFunction<T> {
     double apply(T t);