diff --git a/src/main/java/org/violetmoon/zeta/event/bus/FabricZetaEventBus.java b/src/main/java/org/violetmoon/zeta/event/bus/FabricZetaEventBus.java
index 69dcf72..8f34886 100644
--- a/src/main/java/org/violetmoon/zeta/event/bus/FabricZetaEventBus.java
+++ b/src/main/java/org/violetmoon/zeta/event/bus/FabricZetaEventBus.java
@@ -36,12 +36,12 @@ public FabricZetaEventBus(Class<? extends Annotation> subscriberAnnotation, Clas
 	}
 
 	@Override
-	protected void subscribeMethod(Method m, Object receiver, Class owningClazz) {
+	protected void subscribeMethod(Method m, Object receiver, Class<?> owningClazz) {
 		getListenersFor(m).subscribe(receiver, owningClazz, m);
 	}
 
 	@Override
-	protected void unsubscribeMethod(Method m, Object receiver, Class owningClazz) {
+	protected void unsubscribeMethod(Method m, Object receiver, Class<?> owningClazz) {
 		getListenersFor(m).unsubscribe(receiver, owningClazz, m);
 	}
 
diff --git a/src/main/java/org/violetmoon/zeta/event/bus/ForgeZetaEventBus.java b/src/main/java/org/violetmoon/zeta/event/bus/ForgeZetaEventBus.java
index cccbf8c..4b72bec 100644
--- a/src/main/java/org/violetmoon/zeta/event/bus/ForgeZetaEventBus.java
+++ b/src/main/java/org/violetmoon/zeta/event/bus/ForgeZetaEventBus.java
@@ -5,7 +5,6 @@
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.violetmoon.zeta.Zeta;
 
 import java.lang.annotation.Annotation;
 import java.lang.invoke.MethodHandle;
@@ -37,6 +36,7 @@ public ForgeZetaEventBus(Class<? extends Annotation> subscriberAnnotation, Class
         this.forgeBus = forgeBus;
     }
 
+
     @Override
     protected void subscribeMethod(Method method, Object receiver, Class<?> owningClazz) {
         if (method.getParameterCount() != 1)
@@ -89,33 +89,43 @@ public <T extends E> T fire(@NotNull T event, Class<? super T> firedAs) {
     // reflection hacks below. be warned
 
     private <T extends E> Event remapEvent(@NotNull T event, Class<?> firedAs) {
-        Function<? extends E, ? extends Event> zetaToForgeFunc = zetaToForgeMap.computeIfAbsent((Class<? extends E>) firedAs, this::findWrappedEvent);
+        Function<? extends E, ? extends Event> zetaToForgeFunc = zetaToForgeMap.get((Class<? extends E>) firedAs);
+        if (zetaToForgeFunc == null) {
+            throw new RuntimeException("No wrapped forge Event found for Zeta event class. You must register its subclass using registerSubclass. " + firedAs);
+        }
         return createForgeEvent(event, zetaToForgeFunc);
     }
 
     // takes a method that takes a zeta event and turns into one that takes a forge event
     private Consumer<? extends Event> remapMethod(MethodHandle zetaEventConsumer, Class<? extends E> zetaEventClass) {
-        Function<? extends Event, ? extends E> forgeToZetaFunc = forgeToZetaMap.computeIfAbsent(zetaEventClass,this::findWrappingConstructor);
+        Function<? extends Event, ? extends E> forgeToZetaFunc = forgeToZetaMap.get(zetaEventClass);
+        if (forgeToZetaFunc == null) {
+            throw new RuntimeException("No forge-Event-wrapping constructor found for Zeta event class. You must register its subclass using registerSubclass. " + zetaEventClass);
+        }
         return createForgeConsumer(zetaEventConsumer, forgeToZetaFunc);
     }
 
+    private <T extends E> Event createForgeEvent(@NotNull E event, Function<T, ? extends Event> function) {
+        return function.apply((T) event);
+    }
 
-    private Function<? extends E, ? extends Event> findWrappedEvent(Class<? extends E> zetaEventClass) {
-        for (Field field : zetaEventClass.getDeclaredFields()) {
-            if (Event.class.isAssignableFrom(field.getType())) {
-                return instance -> {
-                    try {
-                        return (Event) field.get(instance);
-                    } catch (IllegalAccessException illegalAccessException) {
-                        throw new RuntimeException(illegalAccessException);
-                    }
-                };
+    private <Z extends E, F extends Event> Consumer<F> createForgeConsumer(MethodHandle zetaEventConsumer, Function<F, Z> forgeToZetaFunc) {
+        return event -> {
+            try {
+                zetaEventConsumer.invoke(forgeToZetaFunc.apply(event));
+            } catch (Throwable e) {
+                throw new RuntimeException(e);
             }
-        }
-        throw new RuntimeException("No wrapped forge Event found for Zeta event class " + zetaEventClass);
+        };
     }
 
-    private Function<? extends Event,? extends E> findWrappingConstructor(Class<? extends E> zetaEventClass) {
+
+    public <S extends C, C extends E> void registerSubClass(Class<C> eventClass, Class<S> zetaEventClass) {
+        forgeToZetaMap.put(eventClass, findWrappingConstructor(zetaEventClass));
+        zetaToForgeMap.put(eventClass, findWrappedEvent(zetaEventClass));
+    }
+
+    private Function<? extends Event, ? extends E> findWrappingConstructor(Class<? extends E> zetaEventClass) {
         // Find the constructor that takes a single parameter of type A
         for (Constructor<?> constructor : zetaEventClass.getConstructors()) {
             Class<?>[] parameterTypes = constructor.getParameterTypes();
@@ -132,18 +142,20 @@ private Function<? extends Event,? extends E> findWrappingConstructor(Class<? ex
         throw new RuntimeException("No forge-Event-wrapping constructor found for Zeta event class " + zetaEventClass);
     }
 
-    private <T extends E> Event createForgeEvent(@NotNull E event, Function<T, ? extends Event> function) {
-        return function.apply((T) event);
-    }
 
-    private <Z extends E, F extends Event> Consumer<F> createForgeConsumer(MethodHandle zetaEventConsumer, Function<F, Z> forgeToZetaFunc) {
-        return event -> {
-            try {
-                zetaEventConsumer.invoke(forgeToZetaFunc.apply(event));
-            } catch (Throwable e) {
-                throw new RuntimeException(e);
+    private Function<? extends E, ? extends Event> findWrappedEvent(Class<? extends E> zetaEventClass) {
+        for (Field field : zetaEventClass.getDeclaredFields()) {
+            if (Event.class.isAssignableFrom(field.getType())) {
+                return instance -> {
+                    try {
+                        return (Event) field.get(instance);
+                    } catch (IllegalAccessException illegalAccessException) {
+                        throw new RuntimeException(illegalAccessException);
+                    }
+                };
             }
-        };
+        }
+        throw new RuntimeException("No wrapped forge Event found for Zeta event class " + zetaEventClass);
     }
 
 }
diff --git a/src/main/java/org/violetmoon/zetaimplforge/ForgeZeta.java b/src/main/java/org/violetmoon/zetaimplforge/ForgeZeta.java
index f0193c2..868a85d 100644
--- a/src/main/java/org/violetmoon/zetaimplforge/ForgeZeta.java
+++ b/src/main/java/org/violetmoon/zetaimplforge/ForgeZeta.java
@@ -88,6 +88,62 @@ public ForgeZeta(String modid, Logger log) {
                         MinecraftForge.EVENT_BUS)
         );
 
+        uglyPopulateForgePlayBus();
+        uglyPopulateForgeLoadBus();
+    }
+
+    private void uglyPopulateForgeLoadBus(){
+        var bus = (ForgeZetaEventBus<IZetaLoadEvent>) loadBus;
+        bus.registerSubClass(ZCommonSetup.class, ForgeZCommonSetup.class);
+        bus.registerSubClass(ZAddReloadListener.class, ForgeZAddReloadListener.class);
+        bus.registerSubClass(ZEntityAttributeCreation.class, ForgeZEntityAttributeCreation.class);
+    }
+
+    private void uglyPopulateForgePlayBus() {
+        var bus = (ForgeZetaEventBus<IZetaPlayEvent>) playBus;
+        bus.registerSubClass(ZAnvilRepair.class, ForgeZAnvilRepair.class);
+        bus.registerSubClass(ZBabyEntitySpawn.class, ForgeZBabyEntitySpawn.class);
+        bus.registerSubClass(ZBlock.Break.class, ForgeZBlock.Break.class);
+        bus.registerSubClass(ZBlock.EntityPlace.class, ForgeZBlock.EntityPlace.class);
+        bus.registerSubClass(ZBlock.BlockToolModification.class, ForgeZBlock.BlockToolModification.class);
+        bus.registerSubClass(ZBonemeal.class, ForgeZBonemeal.class);
+        bus.registerSubClass(ZEntityConstruct.class, ForgeZEntityConstruct.class);
+        bus.registerSubClass(ZEntityInteract.class, ForgeZEntityInteract.class);
+        bus.registerSubClass(ZEntityItemPickup.class, ForgeZEntityItemPickup.class);
+        bus.registerSubClass(ZEntityJoinLevel.class, ForgeZEntityJoinLevel.class);
+        bus.registerSubClass(ZEntityMobGriefing.class, ForgeZEntityMobGriefing.class);
+        bus.registerSubClass(ZEntityTeleport.class, ForgeZEntityTeleport.class);
+        bus.registerSubClass(ZItemTooltip.class, ForgeZItemTooltip.class);
+        bus.registerSubClass(ZLivingChangeTarget.class, ForgeZLivingChangeTarget.class);
+        bus.registerSubClass(ZLivingConversion.class, ForgeZLivingConversion.class);
+        bus.registerSubClass(ZLivingConversion.Pre.class, ForgeZLivingConversion.Pre.class);
+        bus.registerSubClass(ZLivingConversion.Post.class, ForgeZLivingConversion.Post.class);
+        bus.registerSubClass(ZLivingDeath.class, ForgeZLivingDeath.class);
+        bus.registerSubClass(ZLivingDeath.Lowest.class, ForgeZLivingDeath.Lowest.class);
+        bus.registerSubClass(ZLivingDrops.class, ForgeZLivingDrops.class);
+        bus.registerSubClass(ZLivingDrops.Lowest.class, ForgeZLivingDrops.Lowest.class);
+        bus.registerSubClass(ZLivingFall.class, ForgeZLivingFall.class);
+        bus.registerSubClass(ZLivingTick.class, ForgeZLivingTick.class);
+        bus.registerSubClass(ZMobSpawnEvent.class, ForgeZMobSpawnEvent.class);
+        bus.registerSubClass(ZMobSpawnEvent.CheckSpawn.class, ForgeZMobSpawnEvent.FinalizeSpawn.class);
+        bus.registerSubClass(ZMobSpawnEvent.CheckSpawn.Lowest.class, ForgeZMobSpawnEvent.FinalizeSpawn.Lowest.class);
+        bus.registerSubClass(ZPlayNoteBlock.class, ForgeZPlayNoteBlock.class);
+        bus.registerSubClass(ZPlayer.class, ForgeZPlayer.class);
+        bus.registerSubClass(ZPlayer.BreakSpeed.class, ForgeZPlayer.BreakSpeed.class);
+        bus.registerSubClass(ZPlayer.Clone.class, ForgeZPlayer.Clone.class);
+        bus.registerSubClass(ZPlayerDestroyItem.class, ForgeZPlayerDestroyItem.class);
+        bus.registerSubClass(ZPlayer.LoggedIn.class, ForgeZPlayer.LoggedIn.class);
+        bus.registerSubClass(ZPlayer.LoggedOut.class, ForgeZPlayer.LoggedOut.class);
+        bus.registerSubClass(ZPlayerTick.Start.class, ForgeZPlayerTick.Start.class);
+        bus.registerSubClass(ZPlayerTick.End.class, ForgeZPlayerTick.End.class);
+        bus.registerSubClass(ZPlayerInteract.class, ForgeZPlayerInteract.class);
+        bus.registerSubClass(ZPlayerInteract.EntityInteractSpecific.class, ForgeZPlayerInteract.EntityInteractSpecific.class);
+        bus.registerSubClass(ZPlayerInteract.EntityInteract.class, ForgeZPlayerInteract.EntityInteract.class);
+        bus.registerSubClass(ZPlayerInteract.RightClickBlock.class, ForgeZPlayerInteract.RightClickBlock.class);
+        bus.registerSubClass(ZPlayerInteract.RightClickItem.class, ForgeZPlayerInteract.RightClickItem.class);
+        bus.registerSubClass(ZRightClickBlock.class, ForgeZRightClickBlock.class);
+        bus.registerSubClass(ZRightClickBlock.Low.class, ForgeZRightClickBlock.Low.class);
+        bus.registerSubClass(ZRightClickItem.class, ForgeZRightClickItem.class);
     }
 
     @Override