From e7e8b0e0e5226983a2ec25b967416508a29eb044 Mon Sep 17 00:00:00 2001
From: Pasqual Koschmieder <git@derklaro.dev>
Date: Sat, 5 Aug 2023 23:30:19 +0200
Subject: [PATCH 1/2] fix: replace event lib with custom implementation

---
 .idea/codeStyles/Project.xml                  |   2 +-
 api/build.gradle.kts                          |   1 -
 .../npclib/api/event/CancellableNpcEvent.java |   5 +-
 .../event/manager/DefaultNpcEventManager.java | 132 ++++++++++--------
 .../manager/DefaultNpcEventSubscription.java  |  69 +++++++++
 .../event/manager/EventExceptionHandler.java  |  53 +++++++
 .../api/event/manager/NpcEventConsumer.java   |   5 +-
 .../api/event/manager/NpcEventManager.java    |   8 +-
 .../event/manager/NpcEventSubscription.java   |  39 ++++++
 gradle/libs.versions.toml                     |   2 -
 10 files changed, 250 insertions(+), 66 deletions(-)
 create mode 100644 api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventSubscription.java
 create mode 100644 api/src/main/java/com/github/juliarn/npclib/api/event/manager/EventExceptionHandler.java
 create mode 100644 api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventSubscription.java

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index d0f4383..b0cd35f 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -182,7 +182,7 @@
       <option name="FOR_BRACE_FORCE" value="3" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+        <option name="CONTINUATION_INDENT_SIZE" value="2" />
         <option name="TAB_SIZE" value="2" />
       </indentOptions>
     </codeStyleSettings>
diff --git a/api/build.gradle.kts b/api/build.gradle.kts
index 6acdd1c..d822d08 100644
--- a/api/build.gradle.kts
+++ b/api/build.gradle.kts
@@ -25,7 +25,6 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 
 dependencies {
-  api(libs.event)
   implementation(libs.gson)
 }
 
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/CancellableNpcEvent.java b/api/src/main/java/com/github/juliarn/npclib/api/event/CancellableNpcEvent.java
index 748e2e7..844e231 100644
--- a/api/src/main/java/com/github/juliarn/npclib/api/event/CancellableNpcEvent.java
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/CancellableNpcEvent.java
@@ -24,8 +24,9 @@
 
 package com.github.juliarn.npclib.api.event;
 
-import com.seiama.event.Cancellable;
+public interface CancellableNpcEvent extends NpcEvent {
 
-public interface CancellableNpcEvent extends Cancellable {
+  boolean cancelled();
 
+  void cancelled(boolean cancelled);
 }
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java
index 01ac01f..3cd9c63 100644
--- a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java
@@ -24,93 +24,113 @@
 
 package com.github.juliarn.npclib.api.event.manager;
 
+import com.github.juliarn.npclib.api.event.CancellableNpcEvent;
 import com.github.juliarn.npclib.api.event.NpcEvent;
 import com.github.juliarn.npclib.api.log.PlatformLogger;
-import com.seiama.event.EventConfig;
-import com.seiama.event.EventSubscription;
-import com.seiama.event.bus.EventBus;
-import com.seiama.event.bus.SimpleEventBus;
-import com.seiama.event.registry.EventRegistry;
-import com.seiama.event.registry.SimpleEventRegistry;
-import java.util.OptionalInt;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Predicate;
 import org.jetbrains.annotations.NotNull;
 
 final class DefaultNpcEventManager implements NpcEventManager {
 
-  private final EventBus<NpcEvent> eventBus;
-  private final EventRegistry<NpcEvent> eventRegistry;
+  private static final Comparator<NpcEventSubscription<? super NpcEvent>> SUBSCRIPTION_COMPARABLE =
+    Comparator.comparingInt(NpcEventSubscription::order);
+
+  private final boolean debugEnabled;
+  private final PlatformLogger platformLogger;
+
+  private final Map<Class<?>, List<NpcEventSubscription<? super NpcEvent>>> registeredSubscribers =
+    new ConcurrentHashMap<>(16, 0.9f, 1);
 
   public DefaultNpcEventManager(boolean debugEnabled, @NotNull PlatformLogger logger) {
-    this.eventRegistry = new SimpleEventRegistry<>(NpcEvent.class);
-    this.eventBus = new SimpleEventBus<>(this.eventRegistry, new LoggingEventExceptionHandler(debugEnabled, logger));
+    this.debugEnabled = debugEnabled;
+    this.platformLogger = logger;
+  }
+
+  private static boolean isEventCancelled(@NotNull NpcEvent event) {
+    return event instanceof CancellableNpcEvent && ((CancellableNpcEvent) event).cancelled();
   }
 
   @Override
   public <E extends NpcEvent> @NotNull E post(@NotNull E event) {
-    this.eventBus.post(event, OptionalInt.empty());
+    Objects.requireNonNull(event, "event");
+
+    List<NpcEventSubscription<? super NpcEvent>> subscriptions = this.registeredSubscribers.get(event.getClass());
+    if (!subscriptions.isEmpty()) {
+      for (NpcEventSubscription<? super E> subscription : subscriptions) {
+        // once the event was cancelled we don't want to post it to any further subscribers
+        boolean eventWasCancelled = isEventCancelled(event);
+        if (eventWasCancelled) {
+          break;
+        }
+
+        try {
+          subscription.eventConsumer().handle(event);
+        } catch (Throwable throwable) {
+          EventExceptionHandler.rethrowFatalException(throwable);
+          if (this.debugEnabled) {
+            // not a fatal exception but debug is enabled to we log it anyway
+            this.platformLogger.error(
+              String.format(
+                "Subscriber %s was unable to handle %s",
+                subscription.eventConsumer().getClass().getName(),
+                event.getClass().getSimpleName()),
+              throwable);
+          }
+        }
+      }
+    }
+
     return event;
   }
 
   @Override
-  public <E extends NpcEvent> @NotNull NpcEventManager registerEventHandler(
+  public <E extends NpcEvent> @NotNull NpcEventSubscription<? super E> registerEventHandler(
     @NotNull Class<E> eventType,
     @NotNull NpcEventConsumer<E> consumer
   ) {
-    return this.registerEventHandler(eventType, consumer, EventConfig.DEFAULT_ORDER);
+    return this.registerEventHandler(eventType, consumer, 0);
   }
 
   @Override
-  public <E extends NpcEvent> @NotNull NpcEventManager registerEventHandler(
+  @SuppressWarnings("unchecked")
+  public <E extends NpcEvent> @NotNull NpcEventSubscription<? super E> registerEventHandler(
     @NotNull Class<E> eventType,
     @NotNull NpcEventConsumer<E> consumer,
     int eventHandlerPriority
   ) {
-    EventConfig eventConfig = EventConfig.defaults().acceptsCancelled(false).order(eventHandlerPriority);
-    this.eventRegistry.subscribe(eventType, eventConfig, consumer::accept);
-    return this;
-  }
-
-  private static final class LoggingEventExceptionHandler implements EventBus.EventExceptionHandler {
+    NpcEventSubscription<? super E> subscription = new DefaultNpcEventSubscription<>(
+      eventHandlerPriority,
+      eventType,
+      consumer,
+      this);
 
-    private final boolean debugEnabled;
-    private final PlatformLogger logger;
+    List<NpcEventSubscription<? super NpcEvent>> eventSubscriptions = this.registeredSubscribers.computeIfAbsent(
+      eventType,
+      __ -> new CopyOnWriteArrayList<>());
+    eventSubscriptions.add((NpcEventSubscription<? super NpcEvent>) subscription);
 
-    public LoggingEventExceptionHandler(boolean debugEnabled, @NotNull PlatformLogger logger) {
-      this.debugEnabled = debugEnabled;
-      this.logger = logger;
-    }
-
-    private static boolean isFatal(@NotNull Throwable throwable) {
-      // this includes the most fatal errors that can occur on a thread which we should not silently ignore and rethrow
-      return throwable instanceof InterruptedException
-        || throwable instanceof LinkageError
-        || throwable instanceof ThreadDeath
-        || throwable instanceof VirtualMachineError;
-    }
+    eventSubscriptions.sort(SUBSCRIPTION_COMPARABLE);
+    return subscription;
+  }
 
-    @SuppressWarnings("unchecked")
-    private static <T extends Throwable> void throwUnchecked(@NotNull Throwable throwable) throws T {
-      throw (T) throwable;
+  @Override
+  public void unregisterEventHandlerIf(@NotNull Predicate<NpcEventSubscription<? super NpcEvent>> subscriptionFilter) {
+    for (List<NpcEventSubscription<? super NpcEvent>> subscriptions : this.registeredSubscribers.values()) {
+      subscriptions.removeIf(subscriptionFilter);
     }
+  }
 
-    @Override
-    public <E> void eventExceptionCaught(
-      @NotNull EventSubscription<? super E> subscription,
-      @NotNull E event,
-      @NotNull Throwable throwable
-    ) {
-      if (isFatal(throwable)) {
-        // rethrow fatal exceptions instantly
-        throwUnchecked(throwable);
-      } else if (this.debugEnabled) {
-        // just log that we received an exception from the event handler
-        this.logger.error(
-          String.format(
-            "Subscriber %s was unable to handle %s:",
-            subscription.subscriber().getClass().getName(),
-            event.getClass().getSimpleName()),
-          throwable);
-      }
+  void removeSubscription(@NotNull NpcEventSubscription<?> subscription) {
+    List<NpcEventSubscription<? super NpcEvent>> subscriptions = this.registeredSubscribers.get(
+      subscription.eventType());
+    if (subscriptions != null) {
+      subscriptions.remove(subscription);
     }
   }
 }
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventSubscription.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventSubscription.java
new file mode 100644
index 0000000..f72d79e
--- /dev/null
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventSubscription.java
@@ -0,0 +1,69 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.api.event.manager;
+
+import com.github.juliarn.npclib.api.event.NpcEvent;
+import org.jetbrains.annotations.NotNull;
+
+final class DefaultNpcEventSubscription<E extends NpcEvent> implements NpcEventSubscription<E> {
+
+  private final int order;
+  private final Class<E> eventType;
+  private final NpcEventConsumer<E> consumer;
+
+  private final DefaultNpcEventManager eventManager;
+
+  public DefaultNpcEventSubscription(
+    int order,
+    @NotNull Class<E> eventType,
+    @NotNull NpcEventConsumer<E> consumer,
+    @NotNull DefaultNpcEventManager eventManager
+  ) {
+    this.order = order;
+    this.eventType = eventType;
+    this.consumer = consumer;
+    this.eventManager = eventManager;
+  }
+
+  @Override
+  public int order() {
+    return this.order;
+  }
+
+  @Override
+  public @NotNull Class<E> eventType() {
+    return this.eventType;
+  }
+
+  @Override
+  public @NotNull NpcEventConsumer<E> eventConsumer() {
+    return this.consumer;
+  }
+
+  @Override
+  public void dispose() {
+    this.eventManager.removeSubscription(this);
+  }
+}
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/EventExceptionHandler.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/EventExceptionHandler.java
new file mode 100644
index 0000000..639d9df
--- /dev/null
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/EventExceptionHandler.java
@@ -0,0 +1,53 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.api.event.manager;
+
+import org.jetbrains.annotations.NotNull;
+
+final class EventExceptionHandler {
+
+  private EventExceptionHandler() {
+    throw new UnsupportedOperationException();
+  }
+
+  public static void rethrowFatalException(@NotNull Throwable throwable) {
+    if (isFatal(throwable)) {
+      throwUnchecked(throwable);
+    }
+  }
+
+  private static boolean isFatal(@NotNull Throwable throwable) {
+    // this includes the most fatal errors that can occur on a thread which we should not silently ignore and rethrow
+    return throwable instanceof InterruptedException
+      || throwable instanceof LinkageError
+      || throwable instanceof ThreadDeath
+      || throwable instanceof VirtualMachineError;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <T extends Throwable> void throwUnchecked(@NotNull Throwable throwable) throws T {
+    throw (T) throwable;
+  }
+}
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventConsumer.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventConsumer.java
index b8fbb4b..2bf1295 100644
--- a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventConsumer.java
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventConsumer.java
@@ -25,9 +25,10 @@
 package com.github.juliarn.npclib.api.event.manager;
 
 import com.github.juliarn.npclib.api.event.NpcEvent;
-import java.util.function.Consumer;
+import org.jetbrains.annotations.NotNull;
 
 @FunctionalInterface
-public interface NpcEventConsumer<E extends NpcEvent> extends Consumer<E> {
+public interface NpcEventConsumer<E extends NpcEvent> {
 
+  void handle(@NotNull E event) throws Exception;
 }
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventManager.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventManager.java
index ba1ea94..f3cfa3f 100644
--- a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventManager.java
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventManager.java
@@ -27,6 +27,7 @@
 import com.github.juliarn.npclib.api.event.NpcEvent;
 import com.github.juliarn.npclib.api.log.PlatformLogger;
 import java.util.Objects;
+import java.util.function.Predicate;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
@@ -38,14 +39,17 @@ public interface NpcEventManager {
     return new DefaultNpcEventManager(debugEnabled, logger);
   }
 
+  @Contract("_ -> param1")
   <E extends NpcEvent> @NotNull E post(@NotNull E event);
 
-  <E extends NpcEvent> @NotNull NpcEventManager registerEventHandler(
+  <E extends NpcEvent> @NotNull NpcEventSubscription<? super E> registerEventHandler(
     @NotNull Class<E> eventType,
     @NotNull NpcEventConsumer<E> consumer);
 
-  <E extends NpcEvent> @NotNull NpcEventManager registerEventHandler(
+  <E extends NpcEvent> @NotNull NpcEventSubscription<? super E> registerEventHandler(
     @NotNull Class<E> eventType,
     @NotNull NpcEventConsumer<E> consumer,
     int eventHandlerPriority);
+
+  void unregisterEventHandlerIf(@NotNull Predicate<NpcEventSubscription<? super NpcEvent>> subscriptionFilter);
 }
diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventSubscription.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventSubscription.java
new file mode 100644
index 0000000..7732c31
--- /dev/null
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/NpcEventSubscription.java
@@ -0,0 +1,39 @@
+/*
+ * This file is part of npc-lib, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) 2022-2023 Julian M., Pasqual K. and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.github.juliarn.npclib.api.event.manager;
+
+import com.github.juliarn.npclib.api.event.NpcEvent;
+import org.jetbrains.annotations.NotNull;
+
+public interface NpcEventSubscription<E extends NpcEvent> {
+
+  int order();
+
+  @NotNull Class<E> eventType();
+
+  @NotNull NpcEventConsumer<E> eventConsumer();
+
+  void dispose();
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 8f55141..3dc9ad5 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -10,7 +10,6 @@ checkstyleTools = "10.12.2"
 gson = "2.10.1"
 netty = "4.1.96.Final"
 annotations = "24.0.1"
-event = "1.0.0-SNAPSHOT"
 
 # platform api versions
 sponge = "10.0.0"
@@ -26,7 +25,6 @@ packetEvents = "800ffafb96"
 [libraries]
 
 # general
-event = { group = "com.seiama", name = "event-api", version.ref = "event" }
 netty = { group = "io.netty", name = "netty-buffer", version.ref = "netty" }
 gson = { group = "com.google.code.gson", name = "gson", version.ref = "gson" }
 annotations = { group = "org.jetbrains", name = "annotations", version.ref = "annotations" }

From e59ead1d1e50d2006e61f4982ef85ed928d6fab0 Mon Sep 17 00:00:00 2001
From: Pasqual Koschmieder <git@derklaro.dev>
Date: Sun, 6 Aug 2023 11:31:11 +0200
Subject: [PATCH 2/2] fix: correctly post events to subscribers

---
 .../event/manager/DefaultNpcEventManager.java | 44 ++++++++++---------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java
index 3cd9c63..89bae97 100644
--- a/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java
+++ b/api/src/main/java/com/github/juliarn/npclib/api/event/manager/DefaultNpcEventManager.java
@@ -60,27 +60,31 @@ private static boolean isEventCancelled(@NotNull NpcEvent event) {
   public <E extends NpcEvent> @NotNull E post(@NotNull E event) {
     Objects.requireNonNull(event, "event");
 
-    List<NpcEventSubscription<? super NpcEvent>> subscriptions = this.registeredSubscribers.get(event.getClass());
-    if (!subscriptions.isEmpty()) {
-      for (NpcEventSubscription<? super E> subscription : subscriptions) {
-        // once the event was cancelled we don't want to post it to any further subscribers
-        boolean eventWasCancelled = isEventCancelled(event);
-        if (eventWasCancelled) {
-          break;
-        }
+    for (Map.Entry<Class<?>, List<NpcEventSubscription<? super NpcEvent>>> entry : this.registeredSubscribers.entrySet()) {
+      Class<?> subscribedEventType = entry.getKey();
+      List<NpcEventSubscription<? super NpcEvent>> subscriptions = entry.getValue();
+
+      if (subscribedEventType.isInstance(event) && !subscriptions.isEmpty()) {
+        for (NpcEventSubscription<? super E> subscription : subscriptions) {
+          // once the event was cancelled we don't want to post it to any further subscribers
+          boolean eventWasCancelled = isEventCancelled(event);
+          if (eventWasCancelled) {
+            break;
+          }
 
-        try {
-          subscription.eventConsumer().handle(event);
-        } catch (Throwable throwable) {
-          EventExceptionHandler.rethrowFatalException(throwable);
-          if (this.debugEnabled) {
-            // not a fatal exception but debug is enabled to we log it anyway
-            this.platformLogger.error(
-              String.format(
-                "Subscriber %s was unable to handle %s",
-                subscription.eventConsumer().getClass().getName(),
-                event.getClass().getSimpleName()),
-              throwable);
+          try {
+            subscription.eventConsumer().handle(event);
+          } catch (Throwable throwable) {
+            EventExceptionHandler.rethrowFatalException(throwable);
+            if (this.debugEnabled) {
+              // not a fatal exception but debug is enabled to we log it anyway
+              this.platformLogger.error(
+                String.format(
+                  "Subscriber %s was unable to handle %s",
+                  subscription.eventConsumer().getClass().getName(),
+                  event.getClass().getSimpleName()),
+                throwable);
+            }
           }
         }
       }