com/hypixel/hytale/event

com/hypixel/hytale/event/AsyncEventBusRegistry.java

package com.hypixel.hytale.event;

import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.sneakythrow.SneakyThrow;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AsyncEventBusRegistry<KeyType, EventType extends IAsyncEvent<KeyType>> extends EventBusRegistry<KeyType, EventType, AsyncEventConsumerMap<EventType>> {
   @Nonnull
   public static final IEventDispatcher NO_OP = new IEventDispatcher<IAsyncEvent, CompletableFuture<IAsyncEvent>>() {
      public boolean hasListener() {
         return false;
      }

      @Nonnull
      public CompletableFuture<IAsyncEvent> dispatch(IAsyncEvent event) {
         return CompletableFuture.completedFuture(event);
      }
   };
   @Nonnull
   private final IEventDispatcher<EventType, CompletableFuture<EventType>> globalDispatcher = (event) -> {
      CompletableFuture<EventType> future = CompletableFuture.completedFuture(event);
      CompletableFuture<EventType> before = future;
      future = this.dispatchGlobal(future);
      if (before == future) {
         future = this.dispatchUnhandled(future);
      }

      return future;
   };

   public AsyncEventBusRegistry(@Nonnull HytaleLogger logger, @Nonnull Class<EventType> eventClass) {
      super(logger, eventClass, new AsyncEventConsumerMap((AsyncEventBusRegistry)null), new AsyncEventConsumerMap((AsyncEventBusRegistry)null));
      (this.global).registry = (this.unhandled).registry = this;
   }

   @Nonnull
   public EventRegistration<KeyType, EventType> registerAsync(short priority, @Nonnull KeyType key, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
      return this.registerAsync0(priority, key, function, function.toString());
   }

   @Nonnull
   private EventRegistration<KeyType, EventType> registerAsync0(short priority, @Nullable KeyType key, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function, @Nonnull String consumerString) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else {
         KeyType k = (KeyType)(key != null ? key : NULL);
         AsyncEventConsumerMap<EventType> eventMap = (AsyncEventConsumerMap)this.map.computeIfAbsent(k, (o) -> new AsyncEventConsumerMap(this));
         AsyncEventConsumer<EventType> eventConsumer = new AsyncEventConsumer<EventType>(priority, consumerString, function);
         eventMap.add(eventConsumer);
         return new EventRegistration<KeyType, EventType>(this.eventClass, this::isAlive, () -> this.unregister(key, eventConsumer));
      }
   }

   private void unregister(@Nullable KeyType key, @Nonnull AsyncEventConsumer<EventType> consumer) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else {
         KeyType k = (KeyType)(key != null ? key : NULL);
         AsyncEventConsumerMap<EventType> eventMap = (AsyncEventConsumerMap)this.map.get(k);
         if (eventMap != null && !eventMap.remove(consumer)) {
            throw new IllegalArgumentException(String.valueOf(consumer));
         }
      }
   }

   @Nonnull
   public EventRegistration<KeyType, EventType> registerAsyncGlobal(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
      return this.registerAsyncGlobal0(priority, function, function.toString());
   }

   @Nonnull
   private EventRegistration<KeyType, EventType> registerAsyncGlobal0(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function, @Nonnull String consumerString) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else {
         AsyncEventConsumer<EventType> eventConsumer = new AsyncEventConsumer<EventType>(priority, consumerString, function);
         ((AsyncEventConsumerMap)this.global).add(eventConsumer);
         return new EventRegistration<KeyType, EventType>(this.eventClass, this::isAlive, () -> this.unregisterGlobal(eventConsumer));
      }
   }

   private void unregisterGlobal(@Nonnull AsyncEventConsumer<EventType> consumer) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else if (!((AsyncEventConsumerMap)this.global).remove(consumer)) {
         throw new IllegalArgumentException(String.valueOf(consumer));
      }
   }

   @Nonnull
   public EventRegistration<KeyType, EventType> registerAsyncUnhandled(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
      return this.registerAsyncUnhandled0(priority, function, function.toString());
   }

   @Nonnull
   private EventRegistration<KeyType, EventType> registerAsyncUnhandled0(short priority, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function, @Nonnull String consumerString) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else {
         AsyncEventConsumer<EventType> eventConsumer = new AsyncEventConsumer<EventType>(priority, consumerString, function);
         ((AsyncEventConsumerMap)this.unhandled).add(eventConsumer);
         return new EventRegistration<KeyType, EventType>(this.eventClass, this::isAlive, () -> this.unregisterUnhandled(eventConsumer));
      }
   }

   private void unregisterUnhandled(@Nonnull AsyncEventConsumer<EventType> consumer) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else if (!((AsyncEventConsumerMap)this.unhandled).remove(consumer)) {
         throw new IllegalArgumentException(String.valueOf(consumer));
      }
   }

   private CompletableFuture<EventType> dispatchGlobal(@Nonnull CompletableFuture<EventType> future) {
      return this.dispatchEventMap(future, this.global, "Failed to dispatch event (global)");
   }

   private CompletableFuture<EventType> dispatchUnhandled(@Nonnull CompletableFuture<EventType> future) {
      return this.dispatchEventMap(future, this.unhandled, "Failed to dispatch event (unhandled)");
   }

   private CompletableFuture<EventType> dispatchEventMap(@Nonnull CompletableFuture<EventType> future, @Nonnull AsyncEventConsumerMap<EventType> eventMap, @Nonnull String s) {
      for(short priority : eventMap.getPriorities()) {
         List<AsyncEventConsumer<EventType>> consumers = eventMap.get(priority);
         if (consumers != null) {
            for(AsyncEventConsumer<EventType> consumer : consumers) {
               try {
                  Function<CompletableFuture<EventType>, CompletableFuture<EventType>> theConsumer = this.timeEvents ? consumer.getTimedFunction() : consumer.getFunction();
                  future = ((CompletableFuture)theConsumer.apply(future)).whenComplete((event, throwable) -> {
                     if (event instanceof IProcessedEvent processedEvent) {
                        processedEvent.processEvent(consumer.getConsumerString());
                     }

                     if (throwable != null) {
                        ((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(throwable)).log("%s %s to %s", s, event, consumer);
                     }

                  });
               } catch (Throwable t) {
                  ((HytaleLogger.Api)this.logger.at(Level.SEVERE).withCause(t)).log("%s %s to %s", s, future, consumer);
               }
            }
         }
      }

      return future;
   }

   @Nonnull
   public EventRegistration<KeyType, EventType> register(short priority, KeyType key, @Nonnull Consumer<EventType> consumer) {
      return this.registerAsync0(priority, key, (f) -> f.thenApply((e) -> {
            consumer.accept(e);
            return e;
         }), consumer.toString());
   }

   @Nonnull
   public EventRegistration<KeyType, EventType> registerGlobal(short priority, @Nonnull Consumer<EventType> consumer) {
      return this.registerAsyncGlobal0(priority, (f) -> f.thenApply((e) -> {
            consumer.accept(e);
            return e;
         }), consumer.toString());
   }

   @Nonnull
   public EventRegistration<KeyType, EventType> registerUnhandled(short priority, @Nonnull Consumer<EventType> consumer) {
      return this.registerAsyncUnhandled0(priority, (f) -> f.thenApply((e) -> {
            consumer.accept(e);
            return e;
         }), consumer.toString());
   }

   @Nonnull
   public IEventDispatcher<EventType, CompletableFuture<EventType>> dispatchFor(@Nullable KeyType key) {
      if (this.shutdown) {
         throw new IllegalArgumentException("EventRegistry is shutdown!");
      } else {
         KeyType k = (KeyType)(key != null ? key : NULL);
         AsyncEventConsumerMap<EventType> eventMap = (AsyncEventConsumerMap)this.map.get(k);
         if (eventMap != null && !eventMap.isEmpty()) {
            return eventMap;
         } else {
            return ((AsyncEventConsumerMap)this.global).isEmpty() && ((AsyncEventConsumerMap)this.unhandled).isEmpty() ? NO_OP : this.globalDispatcher;
         }
      }
   }

   protected static class AsyncEventConsumer<EventType extends IAsyncEvent> extends EventBusRegistry.EventConsumer {
      @Nonnull
      private final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function;
      @Nonnull
      private final Function<CompletableFuture<EventType>, CompletableFuture<EventType>> timedFunction;

      public AsyncEventConsumer(short priority, @Nonnull String consumerString, @Nonnull Function<CompletableFuture<EventType>, CompletableFuture<EventType>> function) {
         super(priority, consumerString);
         this.function = function;
         this.timedFunction = (f) -> {
            long before = System.nanoTime();
            return ((CompletableFuture)function.apply(f)).whenComplete((eventType, throwable) -> {
               long after = System.nanoTime();
               this.timer.add(after - before);
               if (throwable != null) {
                  throw SneakyThrow.sneakyThrow(throwable);
               }
            });
         };
      }

      @Nonnull
      public Function<CompletableFuture<EventType>, CompletableFuture<EventType>> getFunction() {
         return this.function;
      }

      @Nonnull
      public Function<CompletableFuture<EventType>, CompletableFuture<EventType>> getTimedFunction() {
         return this.timedFunction;
      }

      @Nonnull
      public String toString() {
         String var10000 = String.valueOf(this.function);
         return "AsyncEventConsumer{function=" + var10000 + ", timedFunction=" + String.valueOf(this.timedFunction) + "} " + super.toString();
      }
   }

   protected static class AsyncEventConsumerMap<EventType extends IAsyncEvent> extends EventBusRegistry.EventConsumerMap<EventType, AsyncEventConsumer<EventType>, CompletableFuture<EventType>> {
      protected AsyncEventBusRegistry registry;

      public AsyncEventConsumerMap(AsyncEventBusRegistry registry) {
         this.registry = registry;
      }

      @Nonnull
      public CompletableFuture<EventType> dispatch(EventType event) {
         return CompletableFuture.completedFuture(event).thenComposeAsync(this::dispatch0);
      }

      private CompletableFuture<EventType> dispatch0(EventType event) {
         CompletableFuture<EventType> future = CompletableFuture.completedFuture(event);
         CompletableFuture<EventType> before = future;
         future = this.registry.dispatchEventMap(future, this, "Failed to dispatch event");
         CompletableFuture<EventType> beforeGlobal = future;
         future = this.registry.dispatchGlobal(future);
         if (beforeGlobal == future && before == beforeGlobal) {
            future = this.registry.dispatchUnhandled(future);
         }

         return future;
      }
   }
}

com/hypixel/hytale/event/EventBus.java

package com.hypixel.hytale.event;

import com.hypixel.hytale.logger.HytaleLogger;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class EventBus implements IEventBus {
   @Nonnull
   private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   private final Map<Class<? extends IBaseEvent<?>>, EventBusRegistry<?, ?, ?>> registryMap = new ConcurrentHashMap();
   private final boolean timeEvents;

   public EventBus(boolean timeEvents) {
      this.timeEvents = timeEvents;
   }

   public void shutdown() {
      this.registryMap.values().forEach(EventBusRegistry::shutdown);
   }

   @Nonnull
    Set<Class<?  <?>>> getRegisteredEventClasses() {
        (.registryMap.keySet());
   }

   
    Set<String>  {
      Set<String> classNames =  ();

      (Class<?> aClass : .registryMap.keySet()) {
         classNames.add(aClass.getSimpleName());
      }

       classNames;
   }

   
    EventBusRegistry<?, ?, ?> getRegistry( String eventName) {
      Class<?  > eventClass = ;

      (Class<?  <?>> aClass : .registryMap.keySet()) {
          (aClass.getSimpleName().equalsIgnoreCase(eventName) || aClass.getName().equalsIgnoreCase(eventName)) {
            eventClass = aClass;
         }
      }

       eventClass ==  ?  : .getRegistry(eventClass);
   }

   
    <KeyType, EventType  <KeyType>> EventBusRegistry<KeyType, EventType, ?> getRegistry( Class<?  EventType> eventClass) {
       (EventBusRegistry<KeyType, EventType, ?>)(IAsyncEvent.class.isAssignableFrom(eventClass) ? .getAsyncRegistry(eventClass) : .getSyncRegistry(eventClass));
   }

   
    <KeyType, EventType  <KeyType>> EventBusRegistry<KeyType, EventType, ?> getSyncRegistry( Class<?  EventType> eventClass) {
      EventBusRegistry<?, ?  <?>, ?  .EventConsumerMap<?  <?>, ?, ?>> registry = (EventBusRegistry).registryMap.computeIfAbsent(eventClass, (aClass) ->  (LOGGER, aClass));
       (.timeEvents) {
         registry.setTimeEvents();
      }

       registry;
   }

   
    <KeyType, EventType  <KeyType>> AsyncEventBusRegistry<KeyType, EventType>  {
      EventBusRegistry<?, ?  <?>, ?  .EventConsumerMap<?  <?>, ?, ?>> registry = (EventBusRegistry).registryMap.computeIfAbsent(eventClass, (aClass) ->  (LOGGER, aClass));
       (.timeEvents) {
         registry.setTimeEvents();
      }

       (AsyncEventBusRegistry)registry;
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
       .<Void, EventType>register((), eventClass, (Object), consumer);
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
       .<Void, EventType>register(priority.getValue(), eventClass, (Object), consumer);
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
       .<Void, EventType>register(priority, eventClass, (Object), consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>register((), eventClass, key, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>register(priority.getValue(), eventClass, key, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .getRegistry(eventClass).register(priority, key, consumer);
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
       .<Void, EventType>registerAsync((), eventClass, (Object), function);
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
       .<Void, EventType>registerAsync(priority.getValue(), eventClass, (Object), function);
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
       .<Void, EventType>registerAsync(priority, eventClass, (Object), function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerAsync((), eventClass, key, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerAsync(priority.getValue(), eventClass, key, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>getAsyncRegistry(eventClass).registerAsync(priority, key, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerGlobal((), eventClass, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerGlobal(priority.getValue(), eventClass, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .getRegistry(eventClass).registerGlobal(priority, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerAsyncGlobal((), eventClass, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerAsyncGlobal(priority.getValue(), eventClass, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>getAsyncRegistry(eventClass).registerAsyncGlobal(priority, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerUnhandled((), eventClass, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerUnhandled(priority.getValue(), eventClass, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .getRegistry(eventClass).registerUnhandled(priority, consumer);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerAsyncUnhandled((), eventClass, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>registerAsyncUnhandled(priority.getValue(), eventClass, function);
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
       .<KeyType, EventType>getAsyncRegistry(eventClass).registerAsyncUnhandled(priority, function);
   }

   
    <KeyType, EventType  <KeyType>> IEventDispatcher<EventType, EventType>  {
      SyncEventBusRegistry<KeyType, EventType> registry = (SyncEventBusRegistry).registryMap.get(eventClass);
       registry ==  ? SyncEventBusRegistry.NO_OP : registry.dispatchFor(key);
   }

   
    <KeyType, EventType  <KeyType>> IEventDispatcher<EventType, CompletableFuture<EventType>>  {
      AsyncEventBusRegistry<KeyType, EventType> registry = (AsyncEventBusRegistry).registryMap.get(eventClass);
       registry ==  ? AsyncEventBusRegistry.NO_OP : registry.dispatchFor(key);
   }
}

com/hypixel/hytale/event/EventBusRegistry.java

package com.hypixel.hytale.event;

import com.hypixel.fastutil.shorts.Short2ObjectConcurrentHashMap;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.metrics.metric.Metric;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public abstract class EventBusRegistry<KeyType, EventType extends IBaseEvent<KeyType>, ConsumerMapType extends EventBusRegistry.EventConsumerMap<EventType, ?, ?>> {
   @Nonnull
   protected static final Object NULL = new Object();
   @Nonnull
   protected final HytaleLogger logger;
   @Nonnull
   protected final Class<EventType> eventClass;
   @Nonnull
   protected final Map<KeyType, ConsumerMapType> map = new ConcurrentHashMap();
   
     ConsumerMapType global;
   
     ConsumerMapType unhandled;
     timeEvents;
     shutdown;

     {
      .logger = logger;
      .eventClass = eventClass;
      .global = global;
      .unhandled = unhandled;
   }

   
    Class<EventType>  {
       .eventClass;
   }

      {
       .timeEvents;
   }

      {
      .timeEvents = timeEvents;
   }

      {
      .shutdown = ;
      .map.clear();
   }

      {
       !.shutdown;
   }

     EventRegistration<KeyType, EventType> ;

     EventRegistration<KeyType, EventType> ;

     EventRegistration<KeyType, EventType> ;

     IEventDispatcher<EventType, ?> dispatchFor(KeyType var1);

        {
      
             ();
         index;
         priority;
      
        String consumerString;
      
            ();

        {
         .priority = priority;
         .consumerString = consumerString;
         .index = consumerIndex.getAndIncrement();
      }

         {
          .index;
      }

         {
          .priority;
      }

      
       String  {
          .consumerString;
      }

      
       Metric  {
          .timer;
      }

      
       String  {
            .index;
           + var10000 +  + .priority +  + .consumerString +  + String.valueOf(.timer) + ;
      }
   }

       <EventType  , ConsumerType  , ReturnType>  <EventType, ReturnType> {
         [] EMPTY_SHORT_ARRAY =  [];
        AtomicReference<[]> prioritiesRef;
      
        Short2ObjectConcurrentHashMap<List<ConsumerType>> map;

        {
         .prioritiesRef =  (EMPTY_SHORT_ARRAY);
         .map =  <List<ConsumerType>>(, ()-);
      }

         {
          .map.isEmpty();
      }

         {
            eventConsumer.getPriority();
         [] wasPriorityAdded =  []{};
         ((List).map.computeIfAbsent(priority, (s) -> {
            wasPriorityAdded[] = ;
              ();
         })).add(eventConsumer);
          (wasPriorityAdded[]) {
            .addPriority(priority);
         }

      }

         {
            consumer.getPriority();
         [] wasRemoved =  []{, };
         .map.computeIfPresent(priority, (key, obj) -> {
            wasRemoved[] = obj.remove(consumer);
             (!obj.isEmpty()) {
                obj;
            }  {
               wasRemoved[] = ;
                ;
            }
         });
          (wasRemoved[]) {
            .removePriority(priority);
         }

          wasRemoved[];
      }

       [] getPriorities() {
          ([]).prioritiesRef.get();
      }

      
       List<ConsumerType>  {
          .map.get(priority);
      }

         {
         (.map.containsKey(priority)) {
            [] currentPriorities = ([]).prioritiesRef.get();
               Arrays.binarySearch(currentPriorities, priority);
             (index >= ) {
               ;
            }

               -(index + );
               currentPriorities.length + ;
            [] newPriorities =  [newLength];
            System.arraycopy(currentPriorities, , newPriorities, , insertionPoint);
            newPriorities[insertionPoint] = priority;
            System.arraycopy(currentPriorities, insertionPoint, newPriorities, insertionPoint + , currentPriorities.length - insertionPoint);
             (.prioritiesRef.compareAndSet(currentPriorities, newPriorities)) {
               ;
            }
         }

      }

         {
         (!.map.containsKey(priority)) {
            [] currentPriorities = ([]).prioritiesRef.get();
               Arrays.binarySearch(currentPriorities, priority);
             (index < ) {
               ;
            }

               currentPriorities.length - ;
            [] newPriorities =  [newLength];
            System.arraycopy(currentPriorities, , newPriorities, , index);
            System.arraycopy(currentPriorities, index + , newPriorities, index, newLength - index);
             (.prioritiesRef.compareAndSet(currentPriorities, newPriorities)) {
               ;
            }
         }

      }
   }
}

com/hypixel/hytale/event/EventPriority.java

package com.hypixel.hytale.event;

public enum EventPriority {
   FIRST((short)-21844),
   EARLY((short)-10922),
   NORMAL((short)0),
   LATE((short)10922),
   LAST((short)21844);

   private final short value;

   private EventPriority(final short value) {
      this.value = value;
   }

   public short getValue() {
      return this.value;
   }
}

com/hypixel/hytale/event/EventRegistration.java

package com.hypixel.hytale.event;

import com.hypixel.hytale.registry.Registration;
import java.util.function.BooleanSupplier;
import javax.annotation.Nonnull;

public class EventRegistration<KeyType, EventType extends IBaseEvent<KeyType>> extends Registration {
   @Nonnull
   protected final Class<EventType> eventClass;

   public EventRegistration(@Nonnull Class<EventType> eventClass, @Nonnull BooleanSupplier isEnabled, @Nonnull Runnable unregister) {
      super(isEnabled, unregister);
      this.eventClass = eventClass;
   }

   public EventRegistration(@Nonnull EventRegistration<KeyType, EventType> registration, @Nonnull BooleanSupplier isEnabled, @Nonnull Runnable unregister) {
      super(isEnabled, unregister);
      this.eventClass = registration.eventClass;
   }

   @Nonnull
   public Class<EventType> getEventClass() {
      return this.eventClass;
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(.eventClass);
        + var10000 +  + .toString() + ;
   }

   
   
     <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
        <KeyType, EventType>(thisRegistration.eventClass, () -> {
          (!thisRegistration.isEnabled.getAsBoolean()) {
             ;
         }  {
            (EventRegistration<KeyType, EventType> containerRegistration : containerRegistrations) {
                (!containerRegistration.isEnabled.getAsBoolean()) {
                   ;
               }
            }

             ;
         }
      }, () -> {
         thisRegistration.unregister();

         (EventRegistration<KeyType, EventType> containerRegistration : containerRegistrations) {
            containerRegistration.unregister();
         }

      });
   }
}

com/hypixel/hytale/event/EventRegistry.java

package com.hypixel.hytale.event;

import com.hypixel.hytale.function.consumer.BooleanConsumer;
import com.hypixel.hytale.registry.Registry;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;

public class EventRegistry extends Registry<EventRegistration<?, ?>> implements IEventRegistry {
   @Nonnull
   private final IEventRegistry parent;

   public EventRegistry(@Nonnull List<BooleanConsumer> registrations, @Nonnull BooleanSupplier precondition, String preconditionMessage, @Nonnull IEventRegistry parent) {
      super(registrations, precondition, preconditionMessage, EventRegistration::new);
      this.parent = parent;
   }

   @Nonnull
   private IEventRegistry getParent() {
      return this.parent;
   }

   public <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull EventRegistration<KeyType, EventType> evt) {
       (EventRegistration).register(evt);
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
      .checkPrecondition();
       .<Void, EventType>register(.getParent().register(eventClass, consumer));
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
      .checkPrecondition();
       .<Void, EventType>register(.getParent().register(priority, eventClass, consumer));
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
      .checkPrecondition();
       .<Void, EventType>register(.getParent().register(priority, eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().register(eventClass, key, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().register(priority, eventClass, key, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().register(priority, eventClass, key, consumer));
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
      .checkPrecondition();
       .<Void, EventType>register(.getParent().registerAsync(eventClass, function));
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
      .checkPrecondition();
       .<Void, EventType>register(.getParent().registerAsync(priority, eventClass, function));
   }

    <EventType  <Void>> EventRegistration<Void, EventType>  {
      .checkPrecondition();
       .<Void, EventType>register(.getParent().registerAsync(priority, eventClass, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsync(eventClass, key, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsync(priority, eventClass, key, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsync(priority, eventClass, key, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerGlobal(eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerGlobal(priority, eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerGlobal(priority, eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsyncGlobal(eventClass, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsyncGlobal(priority, eventClass, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsyncGlobal(priority, eventClass, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerUnhandled(eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerUnhandled(priority, eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerUnhandled(priority, eventClass, consumer));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsyncUnhandled(eventClass, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsyncUnhandled(priority, eventClass, function));
   }

    <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType>  {
      .checkPrecondition();
       .<KeyType, EventType>register(.getParent().registerAsyncUnhandled(priority, eventClass, function));
   }
}

com/hypixel/hytale/event/IAsyncEvent.java

package com.hypixel.hytale.event;

public interface IAsyncEvent<KeyType> extends IBaseEvent<KeyType> {
}

com/hypixel/hytale/event/IBaseEvent.java

package com.hypixel.hytale.event;

public interface IBaseEvent<KeyType> {
}

com/hypixel/hytale/event/ICancellable.java

package com.hypixel.hytale.event;

public interface ICancellable {
   boolean isCancelled();

   void setCancelled(boolean var1);
}

com/hypixel/hytale/event/IEvent.java

package com.hypixel.hytale.event;

public interface IEvent<KeyType> extends IBaseEvent<KeyType> {
}

com/hypixel/hytale/event/IEventBus.java

package com.hypixel.hytale.event;

import java.util.concurrent.CompletableFuture;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public interface IEventBus extends IEventRegistry {
   default <KeyType, EventType extends IEvent<KeyType>> EventType dispatch(@Nonnull Class<EventType> eventClass) {
      return (EventType)(this.dispatchFor(eventClass, (Object)null).dispatch((IBaseEvent)null));
   }

   default <EventType extends IAsyncEvent<Void>> CompletableFuture<EventType> dispatchAsync(@Nonnull Class<EventType> eventClass) {
      return (CompletableFuture)this.dispatchForAsync(eventClass).dispatch((IBaseEvent)null);
   }

   default <KeyType, EventType extends IEvent<KeyType>> IEventDispatcher<EventType, EventType> dispatchFor(@Nonnull Class<? super EventType> eventClass) {
      return this.dispatchFor(eventClass, (Object)null);
   }

   <KeyType, EventType extends IEvent<KeyType>> IEventDispatcher<EventType, EventType> dispatchFor( Class<?  EventType> var1,  KeyType var2);

    <KeyType, EventType  <KeyType>> IEventDispatcher<EventType, CompletableFuture<EventType>>  {
       .dispatchForAsync(eventClass, (Object));
   }

   <KeyType, EventType  <KeyType>> IEventDispatcher<EventType, CompletableFuture<EventType>> ;
}

com/hypixel/hytale/event/IEventDispatcher.java

package com.hypixel.hytale.event;

import javax.annotation.Nullable;

public interface IEventDispatcher<EventType extends IBaseEvent, ReturnType> {
   default boolean hasListener() {
      return true;
   }

   ReturnType dispatch(@Nullable EventType var1);
}

com/hypixel/hytale/event/IEventRegistry.java

package com.hypixel.hytale.event;

import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public interface IEventRegistry {
   @Nullable
   <EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(@Nonnull Class<? super EventType> var1, @Nonnull Consumer<EventType> var2);

   @Nullable
   <EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(@Nonnull EventPriority var1, @Nonnull Class<? super EventType> var2, @Nonnull Consumer<EventType> var3);

   @Nullable
   <EventType extends IBaseEvent<Void>> EventRegistration<Void, EventType> register(short var1, @Nonnull Class<? super EventType> var2, @Nonnull Consumer<EventType> var3);

   @Nullable
   <KeyType, EventType extends IBaseEvent<KeyType>> EventRegistration<KeyType, EventType> register(@Nonnull Class<? super EventType> var1, @Nonnull KeyType var2,  Consumer<EventType> var3);

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <EventType  <Void>> EventRegistration<Void, EventType> ;

   
   <EventType  <Void>> EventRegistration<Void, EventType> ;

   
   <EventType  <Void>> EventRegistration<Void, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;

   
   <KeyType, EventType  <KeyType>> EventRegistration<KeyType, EventType> ;
}

com/hypixel/hytale/event/IProcessedEvent.java

package com.hypixel.hytale.event;

import javax.annotation.Nonnull;

public interface IProcessedEvent {
   void processEvent(@Nonnull String var1);
}

com/hypixel/hytale/event/SyncEventBusRegistry.java

package com.hypixel.hytale.event;

import com.hypixel.hytale.logger.HytaleLogger;
import java.util.List;
import java.util.function.Consumer;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class SyncEventBusRegistry<KeyType, EventType extends IEvent<KeyType>> extends EventBusRegistry<KeyType, EventType, SyncEventConsumerMap<EventType>> {
   public static final IEventDispatcher NO_OP = new IEventDispatcher<IBaseEvent, IBaseEvent>() {
      public boolean hasListener() {
         return false;
      }

      public IBaseEvent dispatch(IBaseEvent event) {
         return event;
      }
   };
   private final IEventDispatcher<EventType, EventType> globalDispatcher = (event) -> {
      if (!this.dispatchGlobal(event)) {
         this.dispatchUnhandled(event);
      }

      return event;
   };

   public SyncEventBusRegistry(HytaleLogger logger, Class<EventType> eventClass) {
      super(logger, eventClass,  ((SyncEventBusRegistry)),  ((SyncEventBusRegistry)));
      (.global).registry = (.unhandled).registry = ;
   }

   
    EventRegistration<KeyType, EventType>  {
       (.shutdown) {
           ();
      }  {
            (KeyType)(key !=  ? key : NULL);
         SyncEventConsumerMap<EventType> eventMap = (SyncEventConsumerMap).map.computeIfAbsent(k, (o) ->  ());
         SyncEventConsumer<EventType> eventConsumer =  <EventType>(priority, consumer);
         eventMap.add(eventConsumer);
           <KeyType, EventType>(.eventClass, ::isAlive, () -> .unregister(key, eventConsumer));
      }
   }

      {
       (.shutdown) {
           ();
      }  {
            (KeyType)(key !=  ? key : NULL);
         SyncEventConsumerMap<EventType> eventMap = (SyncEventConsumerMap).map.get(k);
          (eventMap !=  && !eventMap.remove(consumer)) {
              (String.valueOf(consumer));
         }
      }
   }

   
    EventRegistration<KeyType, EventType>  {
       (.shutdown) {
           ();
      }  {
         SyncEventConsumer<EventType> eventConsumer =  <EventType>(priority, consumer);
         ((SyncEventConsumerMap).global).add(eventConsumer);
           <KeyType, EventType>(.eventClass, ::isAlive, () -> .unregisterGlobal(eventConsumer));
      }
   }

      {
       (.shutdown) {
           ();
      }   (!((SyncEventConsumerMap).global).remove(consumer)) {
           (String.valueOf(consumer));
      }
   }

   
    EventRegistration<KeyType, EventType>  {
       (.shutdown) {
           ();
      }  {
         SyncEventConsumer<EventType> eventConsumer =  <EventType>(priority, consumer);
         ((SyncEventConsumerMap).unhandled).add(eventConsumer);
           <KeyType, EventType>(.eventClass, ::isAlive, () -> .unregisterUnhandled(eventConsumer));
      }
   }

      {
       (.shutdown) {
           ();
      }   (!((SyncEventConsumerMap).unhandled).remove(consumer)) {
           (String.valueOf(consumer));
      }
   }

   
    IEventDispatcher<EventType, EventType>  {
       (.shutdown) {
           ();
      }  {
            (KeyType)(key !=  ? key : NULL);
         SyncEventConsumerMap<EventType> eventMap = (SyncEventConsumerMap).map.get(k);
          (eventMap !=  && !eventMap.isEmpty()) {
             eventMap;
         }  {
             ((SyncEventConsumerMap).global).isEmpty() && ((SyncEventConsumerMap).unhandled).isEmpty() ? NO_OP : .globalDispatcher;
         }
      }
   }

      {
       .dispatchEventMap(event, .global, );
   }

      {
       .dispatchEventMap(event, .unhandled, );
   }

      {
         ;

      ( priority : eventMap.getPriorities()) {
         List<SyncEventConsumer<EventType>> consumers = eventMap.get(priority);
          (consumers != ) {
            (SyncEventConsumer<EventType> consumer : consumers) {
                {
                  Consumer<EventType> theConsumer = .timeEvents ? consumer.getTimedConsumer() : consumer.getConsumer();
                  theConsumer.accept(event);
                   (event  IProcessedEvent) {
                        (IProcessedEvent)event;
                     processedEvent.processEvent(consumer.getConsumerString());
                  }

                  handled = ;
               }  (Throwable t) {
                  ((HytaleLogger.Api).logger.at(Level.SEVERE).withCause(t)).log(, s, event, consumer);
               }
            }
         }
      }

       handled;
   }

      <EventType  >  .EventConsumer {
      
        Consumer<EventType> consumer;
      
        Consumer<EventType> timedConsumer;

        {
         (priority, consumer.toString());
         .consumer = consumer;
         .timedConsumer = (t) -> {
               System.nanoTime();
            consumer.accept(t);
               System.nanoTime();
            .timer.add(after - before);
         };
      }

      
       Consumer<EventType>  {
          .consumer;
      }

      
       Consumer<EventType>  {
          .timedConsumer;
      }

      
       String  {
            String.valueOf(.consumer);
           + var10000 +  + String.valueOf(.timedConsumer) +  + .toString();
      }
   }

      <EventType  >  .EventConsumerMap<EventType, SyncEventConsumer<EventType>, EventType> {
       SyncEventBusRegistry registry;

        {
         .registry = registry;
      }

       EventType  {
            .registry.dispatchEventMap(event, , );
          (!.registry.dispatchGlobal(event) && !handled) {
            .registry.dispatchUnhandled(event);
         }

          event;
      }
   }
}