com/hypixel/hytale/server/core/event

com/hypixel/hytale/server/core/event/events/BootEvent.java

package com.hypixel.hytale.server.core.event.events;

import com.hypixel.hytale.event.IEvent;
import javax.annotation.Nonnull;

public class BootEvent implements IEvent<Void> {
   public BootEvent() {
   }

   @Nonnull
   public String toString() {
      return "BootEvent{}";
   }
}

com/hypixel/hytale/server/core/event/events/PrepareUniverseEvent.java

package com.hypixel.hytale.server.core.event.events;

import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.universe.world.WorldConfigProvider;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated
public class PrepareUniverseEvent implements IEvent<Void> {
   private WorldConfigProvider worldConfigProvider;

   public PrepareUniverseEvent(WorldConfigProvider worldConfigProvider) {
      this.worldConfigProvider = worldConfigProvider;
   }

   public WorldConfigProvider getWorldConfigProvider() {
      return this.worldConfigProvider;
   }

   public void setWorldConfigProvider(WorldConfigProvider worldConfigProvider) {
      this.worldConfigProvider = worldConfigProvider;
   }

   @Nonnull
   public String toString() {
      return "PrepareUniverseEvent{worldConfigProvider=" + String.valueOf(this.worldConfigProvider) + "}";
   }
}

com/hypixel/hytale/server/core/event/events/ShutdownEvent.java

package com.hypixel.hytale.server.core.event.events;

import com.hypixel.hytale.event.IEvent;
import javax.annotation.Nonnull;

public class ShutdownEvent implements IEvent<Void> {
   public static final short DISCONNECT_PLAYERS = -48;
   public static final short UNBIND_LISTENERS = -40;
   public static final short SHUTDOWN_WORLDS = -32;

   public ShutdownEvent() {
   }

   @Nonnull
   public String toString() {
      return "ShutdownEvent{}";
   }
}

com/hypixel/hytale/server/core/event/events/ecs/BreakBlockEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class BreakBlockEvent extends CancellableEcsEvent {
   @Nullable
   private final ItemStack itemInHand;
   @Nonnull
   private Vector3i targetBlock;
   @Nonnull
   private final BlockType blockType;

   public BreakBlockEvent(@Nullable ItemStack itemInHand, @Nonnull Vector3i targetBlock, @Nonnull BlockType blockType) {
      this.itemInHand = itemInHand;
      this.targetBlock = targetBlock;
      this.blockType = blockType;
   }

   @Nullable
   public ItemStack getItemInHand() {
      return this.itemInHand;
   }

   @Nonnull
   public Vector3i getTargetBlock() {
      return this.targetBlock;
   }

   @Nonnull
    BlockType  {
       .blockType;
   }

      {
      .targetBlock = targetBlock;
   }
}

com/hypixel/hytale/server/core/event/events/ecs/ChangeGameModeEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.protocol.GameMode;
import javax.annotation.Nonnull;

public class ChangeGameModeEvent extends CancellableEcsEvent {
   @Nonnull
   private GameMode gameMode;

   public ChangeGameModeEvent(@Nonnull GameMode gameMode) {
      this.gameMode = gameMode;
   }

   @Nonnull
   public GameMode getGameMode() {
      return this.gameMode;
   }

   public void setGameMode(@Nonnull GameMode gameMode) {
      this.gameMode = gameMode;
   }
}

com/hypixel/hytale/server/core/event/events/ecs/CraftRecipeEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.server.core.asset.type.item.config.CraftingRecipe;
import javax.annotation.Nonnull;

public abstract class CraftRecipeEvent extends CancellableEcsEvent {
   @Nonnull
   private final CraftingRecipe craftedRecipe;
   private final int quantity;

   public CraftRecipeEvent(@Nonnull CraftingRecipe craftedRecipe, int quantity) {
      this.craftedRecipe = craftedRecipe;
      this.quantity = quantity;
   }

   @Nonnull
   public CraftingRecipe getCraftedRecipe() {
      return this.craftedRecipe;
   }

   public int getQuantity() {
      return this.quantity;
   }

   public static final class Pre extends CraftRecipeEvent {
      public Pre(@Nonnull CraftingRecipe craftedRecipe,  quantity) {
         (craftedRecipe, quantity);
      }
   }

          {
        {
         (craftedRecipe, quantity);
      }
   }
}

com/hypixel/hytale/server/core/event/events/ecs/DamageBlockEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DamageBlockEvent extends CancellableEcsEvent {
   @Nullable
   private final ItemStack itemInHand;
   @Nonnull
   private Vector3i targetBlock;
   @Nonnull
   private final BlockType blockType;
   private final float currentDamage;
   private float damage;

   public DamageBlockEvent(@Nullable ItemStack itemInHand, @Nonnull Vector3i targetBlock, @Nonnull BlockType blockType, float currentDamage, float damage) {
      this.itemInHand = itemInHand;
      this.targetBlock = targetBlock;
      this.blockType = blockType;
      this.currentDamage = currentDamage;
      this.damage = damage;
   }

   @Nullable
   public ItemStack getItemInHand {
       .itemInHand;
   }

   
    Vector3i  {
       .targetBlock;
   }

      {
      .targetBlock = targetBlock;
   }

   
    BlockType  {
       .blockType;
   }

      {
       .currentDamage;
   }

      {
       .damage;
   }

      {
      .damage = damage;
   }
}

com/hypixel/hytale/server/core/event/events/ecs/DiscoverZoneEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.EcsEvent;
import com.hypixel.hytale.component.system.ICancellableEcsEvent;
import com.hypixel.hytale.server.core.universe.world.WorldMapTracker;
import javax.annotation.Nonnull;

public abstract class DiscoverZoneEvent extends EcsEvent {
   @Nonnull
   private final WorldMapTracker.ZoneDiscoveryInfo discoveryInfo;

   public DiscoverZoneEvent(@Nonnull WorldMapTracker.ZoneDiscoveryInfo discoveryInfo) {
      this.discoveryInfo = discoveryInfo;
   }

   @Nonnull
   public WorldMapTracker.ZoneDiscoveryInfo getDiscoveryInfo() {
      return this.discoveryInfo;
   }

   public static class Display extends DiscoverZoneEvent implements ICancellableEcsEvent {
      private boolean cancelled = false;

      public Display(@Nonnull WorldMapTracker.ZoneDiscoveryInfo discoveryInfo) {
         super(discoveryInfo);
      }

         {
          .cancelled;
      }

         {
         .cancelled = cancelled;
      }
   }
}

com/hypixel/hytale/server/core/event/events/ecs/DropItemEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import javax.annotation.Nonnull;

public class DropItemEvent extends CancellableEcsEvent {
   public DropItemEvent() {
   }

   public static final class PlayerRequest extends DropItemEvent {
      private final int inventorySectionId;
      private final short slotId;

      public PlayerRequest(int inventorySectionId, short slotId) {
         this.inventorySectionId = inventorySectionId;
         this.slotId = slotId;
      }

      public int getInventorySectionId() {
         return this.inventorySectionId;
      }

      public short getSlotId() {
         return this.slotId;
      }
   }

   public static      {
      
       ItemStack itemStack;
        throwSpeed;

        {
         .itemStack = itemStack;
         .throwSpeed = throwSpeed;
      }

         {
         .throwSpeed = throwSpeed;
      }

         {
          .throwSpeed;
      }

         {
         .itemStack = itemStack;
      }

      
       ItemStack  {
          .itemStack;
      }
   }
}

com/hypixel/hytale/server/core/event/events/ecs/InteractivelyPickupItemEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import javax.annotation.Nonnull;

public class InteractivelyPickupItemEvent extends CancellableEcsEvent {
   @Nonnull
   private ItemStack itemStack;

   public InteractivelyPickupItemEvent(@Nonnull ItemStack itemStack) {
      this.itemStack = itemStack;
   }

   @Nonnull
   public ItemStack getItemStack() {
      return this.itemStack;
   }

   public void setItemStack(@Nonnull ItemStack itemStack) {
      this.itemStack = itemStack;
   }
}

com/hypixel/hytale/server/core/event/events/ecs/PlaceBlockEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class PlaceBlockEvent extends CancellableEcsEvent {
   @Nullable
   private final ItemStack itemInHand;
   @Nonnull
   private Vector3i targetBlock;
   @Nonnull
   private RotationTuple rotation;

   public PlaceBlockEvent(@Nullable ItemStack itemInHand, @Nonnull Vector3i targetBlock, @Nonnull RotationTuple rotation) {
      this.itemInHand = itemInHand;
      this.targetBlock = targetBlock;
      this.rotation = rotation;
   }

   @Nullable
   public ItemStack getItemInHand() {
      return this.itemInHand;
   }

   @Nonnull
   public Vector3i getTargetBlock() {
      return this.targetBlock;
   }

      {
      Objects.requireNonNull(targetBlock, );
      .targetBlock = targetBlock;
   }

   
    RotationTuple  {
       .rotation;
   }

      {
      .rotation = rotation;
   }
}

com/hypixel/hytale/server/core/event/events/ecs/SwitchActiveSlotEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.CancellableEcsEvent;

public class SwitchActiveSlotEvent extends CancellableEcsEvent {
   private final int previousSlot;
   private final int inventorySectionId;
   private byte newSlot;
   private final boolean serverRequest;

   public SwitchActiveSlotEvent(int inventorySectionId, int previousSlot, byte newSlot, boolean serverRequest) {
      this.inventorySectionId = inventorySectionId;
      this.previousSlot = previousSlot;
      this.newSlot = newSlot;
      this.serverRequest = serverRequest;
   }

   public int getPreviousSlot() {
      return this.previousSlot;
   }

   public byte getNewSlot() {
      return this.newSlot;
   }

   public void setNewSlot(byte newSlot) {
      .newSlot = newSlot;
   }

      {
       .serverRequest;
   }

      {
       !.serverRequest;
   }

      {
       .inventorySectionId;
   }
}

com/hypixel/hytale/server/core/event/events/ecs/UseBlockEvent.java

package com.hypixel.hytale.server.core.event.events.ecs;

import com.hypixel.hytale.component.system.EcsEvent;
import com.hypixel.hytale.component.system.ICancellableEcsEvent;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.InteractionType;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
import com.hypixel.hytale.server.core.entity.InteractionContext;
import javax.annotation.Nonnull;

public abstract class UseBlockEvent extends EcsEvent {
   @Nonnull
   private final InteractionType interactionType;
   @Nonnull
   private final InteractionContext context;
   @Nonnull
   private final Vector3i targetBlock;
   @Nonnull
   private final BlockType blockType;

   public UseBlockEvent(@Nonnull InteractionType interactionType, @Nonnull InteractionContext context, @Nonnull Vector3i targetBlock, @Nonnull BlockType blockType) {
      this.interactionType = interactionType;
      this.context = context;
      this.targetBlock = targetBlock;
      this.blockType = blockType;
   }

   @Nonnull
   public InteractionType getInteractionType {
       .interactionType;
   }

   
    InteractionContext  {
       .context;
   }

   
    Vector3i  {
       .targetBlock;
   }

   
    BlockType  {
       .blockType;
   }

            {
          ;

        {
         (interactionType, context, targetBlock, blockType);
      }

         {
          .cancelled;
      }

         {
         .cancelled = cancelled;
      }
   }

          {
        {
         (interactionType, context, targetBlock, blockType);
      }
   }
}

com/hypixel/hytale/server/core/event/events/entity/EntityEvent.java

package com.hypixel.hytale.server.core.event.events.entity;

import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.entity.Entity;
import javax.annotation.Nonnull;

public abstract class EntityEvent<EntityType extends Entity, KeyType> implements IEvent<KeyType> {
   private final EntityType entity;

   public EntityEvent(EntityType entity) {
      this.entity = entity;
   }

   public EntityType getEntity() {
      return this.entity;
   }

   @Nonnull
   public String toString() {
      return "EntityEvent{entity=" + String.valueOf(this.entity) + "}";
   }
}

com/hypixel/hytale/server/core/event/events/entity/EntityRemoveEvent.java

package com.hypixel.hytale.server.core.event.events.entity;

import com.hypixel.hytale.server.core.entity.Entity;
import javax.annotation.Nonnull;

public class EntityRemoveEvent extends EntityEvent<Entity, String> {
   public EntityRemoveEvent(Entity entity) {
      super(entity);
   }

   @Nonnull
   public String toString() {
      return "EntityRemoveEvent{} " + super.toString();
   }
}

com/hypixel/hytale/server/core/event/events/entity/LivingEntityInventoryChangeEvent.java

package com.hypixel.hytale.server.core.event.events.entity;

import com.hypixel.hytale.server.core.entity.LivingEntity;
import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
import com.hypixel.hytale.server.core.inventory.transaction.Transaction;
import javax.annotation.Nonnull;

public class LivingEntityInventoryChangeEvent extends EntityEvent<LivingEntity, String> {
   private ItemContainer itemContainer;
   private Transaction transaction;

   public LivingEntityInventoryChangeEvent(LivingEntity entity, ItemContainer itemContainer, Transaction transaction) {
      super(entity);
      this.itemContainer = itemContainer;
      this.transaction = transaction;
   }

   public ItemContainer getItemContainer() {
      return this.itemContainer;
   }

   public Transaction getTransaction() {
      return this.transaction;
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(this.itemContainer);
      return "LivingEntityInventoryChangeEvent{itemContainer=" + var10000 + ", transaction=" + String.valueOf(this.transaction) +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/entity/LivingEntityUseBlockEvent.java

package com.hypixel.hytale.server.core.event.events.entity;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated(
   forRemoval = true
)
public class LivingEntityUseBlockEvent implements IEvent<String> {
   private Ref<EntityStore> ref;
   private String blockType;

   public LivingEntityUseBlockEvent(Ref<EntityStore> ref, String blockType) {
      this.ref = ref;
      this.blockType = blockType;
   }

   public String getBlockType() {
      return this.blockType;
   }

   public Ref<EntityStore> getRef() {
      return this.ref;
   }

   @Nonnull
   public String toString() {
      String var10000 = this.blockType;
      return "LivingEntityUseBlockEvent{blockType=" + var10000 + "} " + super.toString();
   }
}

com/hypixel/hytale/server/core/event/events/permissions/GroupPermissionChangeEvent.java

package com.hypixel.hytale.server.core.event.events.permissions;

import com.hypixel.hytale.event.IEvent;
import java.util.Collections;
import java.util.Set;
import javax.annotation.Nonnull;

public abstract class GroupPermissionChangeEvent implements IEvent<Void> {
   @Nonnull
   private final String groupName;

   protected GroupPermissionChangeEvent(@Nonnull String groupName) {
      this.groupName = groupName;
   }

   @Nonnull
   public String getGroupName() {
      return this.groupName;
   }

   public static class Added extends GroupPermissionChangeEvent {
      @Nonnull
      private final Set<String> addedPermissions;

      public Added(@Nonnull String groupName, @Nonnull Set<String> addedPermissions) {
         super(groupName);
         this.addedPermissions = addedPermissions;
      }

      @Nonnull
      public Set<String> getAddedPermissions {
          Collections.unmodifiableSet(.addedPermissions);
      }
   }

         {
      
        Set<String> removedPermissions;

        {
         (groupName);
         .removedPermissions = removedPermissions;
      }

      
       Set<String>  {
          Collections.unmodifiableSet(.removedPermissions);
      }
   }
}

com/hypixel/hytale/server/core/event/events/permissions/PlayerGroupEvent.java

package com.hypixel.hytale.server.core.event.events.permissions;

import java.util.UUID;
import javax.annotation.Nonnull;

public class PlayerGroupEvent extends PlayerPermissionChangeEvent {
   @Nonnull
   private final String groupName;

   public PlayerGroupEvent(@Nonnull UUID playerUuid, @Nonnull String groupName) {
      super(playerUuid);
      this.groupName = groupName;
   }

   @Nonnull
   public String getGroupName() {
      return this.groupName;
   }

   public static class Added extends PlayerGroupEvent {
      public Added(@Nonnull UUID playerUuid, @Nonnull String groupName) {
         super(playerUuid, groupName);
      }
   }

   public static class Removed extends PlayerGroupEvent {
      public Removed(@Nonnull UUID playerUuid,  String groupName) {
         (playerUuid, groupName);
      }
   }
}

com/hypixel/hytale/server/core/event/events/permissions/PlayerPermissionChangeEvent.java

package com.hypixel.hytale.server.core.event.events.permissions;

import com.hypixel.hytale.event.IEvent;
import java.util.Collections;
import java.util.Set;
import java.util.UUID;
import javax.annotation.Nonnull;

public abstract class PlayerPermissionChangeEvent implements IEvent<Void> {
   @Nonnull
   private final UUID playerUuid;

   protected PlayerPermissionChangeEvent(@Nonnull UUID playerUuid) {
      this.playerUuid = playerUuid;
   }

   @Nonnull
   public UUID getPlayerUuid() {
      return this.playerUuid;
   }

   public static class PermissionsAdded extends PlayerPermissionChangeEvent {
      @Nonnull
      private final Set<String> addedPermissions;

      public PermissionsAdded(@Nonnull UUID playerUuid, @Nonnull Set<String> addedPermissions) {
         super(playerUuid);
         this.addedPermissions = addedPermissions;
      }

      @Nonnull
      public Set<String>  {
          Collections.unmodifiableSet(.addedPermissions);
      }
   }

         {
      
        Set<String> removedPermissions;

        {
         (playerUuid);
         .removedPermissions = removedPermissions;
      }

      
       Set<String>  {
          Collections.unmodifiableSet(.removedPermissions);
      }
   }

         {
      
        String groupName;

        {
         (playerUuid);
         .groupName = groupName;
      }

      
       String  {
          .groupName;
      }
   }

         {
      
        String groupName;

        {
         (playerUuid);
         .groupName = groupName;
      }

      
       String  {
          .groupName;
      }
   }
}

com/hypixel/hytale/server/core/event/events/player/AddPlayerToWorldEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class AddPlayerToWorldEvent implements IEvent<String> {
   @Nonnull
   private final Holder<EntityStore> holder;
   @Nonnull
   private final World world;
   private boolean broadcastJoinMessage = true;

   public AddPlayerToWorldEvent(@Nonnull Holder<EntityStore> holder, @Nonnull World world) {
      this.holder = holder;
      this.world = world;
   }

   @Nonnull
   public Holder<EntityStore> getHolder() {
      return this.holder;
   }

   @Nonnull
   public World getWorld() {
      return this.world;
   }

   public boolean shouldBroadcastJoinMessage {
       .broadcastJoinMessage;
   }

      {
      .broadcastJoinMessage = broadcastJoinMessage;
   }

   
    String  {
         String.valueOf(.world);
        + var10000 +  + .broadcastJoinMessage +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/DrainPlayerFromWorldEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.math.vector.Transform;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class DrainPlayerFromWorldEvent implements IEvent<String> {
   private final Holder<EntityStore> holder;
   private World world;
   private Transform transform;

   public DrainPlayerFromWorldEvent(Holder<EntityStore> holder, World world, Transform transform) {
      this.holder = holder;
      this.world = world;
      this.transform = transform;
   }

   public Holder<EntityStore> getHolder() {
      return this.holder;
   }

   public World getWorld() {
      return this.world;
   }

   public void setWorld(World world) {
      this.world = world;
   }

   public Transform getTransform() {
      return .transform;
   }

      {
      .transform = transform;
   }

   
    String  {
         String.valueOf(.world);
        + var10000 +  + String.valueOf(.transform) +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerChatEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.event.IAsyncEvent;
import com.hypixel.hytale.event.ICancellable;
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import java.util.List;
import javax.annotation.Nonnull;

public class PlayerChatEvent implements IAsyncEvent<String>, ICancellable {
   @Nonnull
   public static final Formatter DEFAULT_FORMATTER = (playerRef, msg) -> Message.translation("server.chat.playerMessage").param("username", playerRef.getUsername()).param("message", msg);
   @Nonnull
   private PlayerRef sender;
   @Nonnull
   private List<PlayerRef> targets;
   @Nonnull
   private String content;
   private Formatter formatter;
   private boolean cancelled;

   public PlayerChatEvent(@Nonnull PlayerRef sender, @Nonnull List<PlayerRef> targets, @Nonnull String content) {
      this.sender = sender;
      this.targets = targets;
      this.content = content;
      this.formatter = DEFAULT_FORMATTER;
      .cancelled = ;
   }

   
    PlayerRef  {
       .sender;
   }

      {
      .sender = sender;
   }

   
    List<PlayerRef>  {
       .targets;
   }

      {
      .targets = targets;
   }

   
    String  {
       .content;
   }

      {
      .content = content;
   }

   
    Formatter  {
       .formatter;
   }

      {
      .formatter = formatter;
   }

      {
       .cancelled;
   }

      {
      .cancelled = cancelled;
   }

   
    String  {
         .content;
        + var10000 +  + String.valueOf(.targets) +  + String.valueOf(.formatter) +  + .cancelled +  + .toString();
   }

      {
      
      Message ;
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerConnectEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class PlayerConnectEvent implements IEvent<Void> {
   private final Holder<EntityStore> holder;
   private final PlayerRef playerRef;
   @Nullable
   private World world;

   public PlayerConnectEvent(@Nonnull Holder<EntityStore> holder, @Nonnull PlayerRef playerRef, @Nullable World world) {
      this.holder = holder;
      this.playerRef = playerRef;
      this.world = world;
   }

   public Holder<EntityStore> getHolder() {
      return this.holder;
   }

   public PlayerRef getPlayerRef() {
      return this.playerRef;
   }

   /** @deprecated */
   
   
    Player  {
       (Player).holder.getComponent(Player.getComponentType());
   }

   
    World  {
       .world;
   }

      {
      .world = world;
   }

   
    String  {
         String.valueOf(.world);
        + var10000 +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerCraftEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.asset.type.item.config.CraftingRecipe;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated(
   forRemoval = true
)
public class PlayerCraftEvent extends PlayerEvent<String> {
   private final CraftingRecipe craftedRecipe;
   private final int quantity;

   public PlayerCraftEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Player player, CraftingRecipe craftedRecipe, int quantity) {
      super(ref, player);
      this.craftedRecipe = craftedRecipe;
      this.quantity = quantity;
   }

   public CraftingRecipe getCraftedRecipe() {
      return this.craftedRecipe;
   }

   public int getQuantity() {
      return this.quantity;
   }

   @Nonnull
   public String toString {
         String.valueOf(.craftedRecipe);
        + var10000 +  + .quantity + ;
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerDisconnectEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.server.core.io.PacketHandler;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import javax.annotation.Nonnull;

public class PlayerDisconnectEvent extends PlayerRefEvent<Void> {
   public PlayerDisconnectEvent(@Nonnull PlayerRef playerRef) {
      super(playerRef);
   }

   @Nonnull
   public PacketHandler.DisconnectReason getDisconnectReason() {
      return this.playerRef.getPacketHandler().getDisconnectReason();
   }

   @Nonnull
   public String toString() {
      String var10000 = String.valueOf(this.playerRef);
      return "PlayerDisconnectEvent{playerRef=" + var10000 + "} " + super.toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public abstract class PlayerEvent<KeyType> implements IEvent<KeyType> {
   @Nonnull
   private final Ref<EntityStore> playerRef;
   @Nonnull
   private final Player player;

   public PlayerEvent(@Nonnull Ref<EntityStore> playerRef, @Nonnull Player player) {
      this.playerRef = playerRef;
      this.player = player;
   }

   @Nonnull
   public Ref<EntityStore> getPlayerRef() {
      return this.playerRef;
   }

   @Nonnull
   public Player getPlayer() {
      return this.player;
   }

   @Nonnull
   public String toString() {
      return "PlayerEvent{player=" + String.valueOf(this.player) + ;
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerInteractEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.event.ICancellable;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.InteractionType;
import com.hypixel.hytale.server.core.entity.Entity;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

/** @deprecated */
@Deprecated
public class PlayerInteractEvent extends PlayerEvent<String> implements ICancellable {
   private final InteractionType actionType;
   private final long clientUseTime;
   private final ItemStack itemInHand;
   private final Vector3i targetBlock;
   private final Ref<EntityStore> targetRef;
   private final Entity targetEntity;
   private boolean cancelled;

   public PlayerInteractEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Player player, long clientUseTime, InteractionType actionType, ItemStack itemInHand, Vector3i targetBlock, Ref<EntityStore> targetRef, Entity targetEntity) {
      (ref, player);
      .actionType = actionType;
      .clientUseTime = clientUseTime;
      .itemInHand = itemInHand;
      .targetBlock = targetBlock;
      .targetRef = targetRef;
      .targetEntity = targetEntity;
   }

      {
       .cancelled;
   }

      {
      .cancelled = cancelled;
   }

    InteractionType  {
       .actionType;
   }

      {
       .clientUseTime;
   }

    ItemStack  {
       .itemInHand;
   }

    Vector3i  {
       .targetBlock;
   }

    Entity  {
       .targetEntity;
   }

    Ref<EntityStore>  {
       .targetRef;
   }

   
    String  {
         String.valueOf(.actionType);
        + var10000 +  + .clientUseTime +  + String.valueOf(.itemInHand) +  + String.valueOf(.targetBlock) +  + String.valueOf(.targetEntity) +  + .cancelled +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerMouseButtonEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.event.ICancellable;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.MouseButtonEvent;
import com.hypixel.hytale.protocol.Vector2f;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.entity.Entity;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class PlayerMouseButtonEvent extends PlayerEvent<Void> implements ICancellable {
   @Nonnull
   private final PlayerRef playerRef;
   private final long clientUseTime;
   private final Item itemInHand;
   private final Vector3i targetBlock;
   private final Entity targetEntity;
   private final Vector2f screenPoint;
   private final MouseButtonEvent mouseButton;
   private boolean cancelled;

   public PlayerMouseButtonEvent( Ref<EntityStore> ref,  Player player,  PlayerRef playerRefComponent,  clientUseTime,  Item itemInHand,  Vector3i targetBlock,  Entity targetEntity,  Vector2f screenPoint,  MouseButtonEvent mouseButton) {
      (ref, player);
      .playerRef = playerRefComponent;
      .clientUseTime = clientUseTime;
      .itemInHand = itemInHand;
      .targetBlock = targetBlock;
      .targetEntity = targetEntity;
      .screenPoint = screenPoint;
      .mouseButton = mouseButton;
   }

   
    PlayerRef  {
       .playerRef;
   }

      {
       .cancelled;
   }

      {
      .cancelled = cancelled;
   }

      {
       .clientUseTime;
   }

    Item  {
       .itemInHand;
   }

    Vector3i  {
       .targetBlock;
   }

    Entity  {
       .targetEntity;
   }

    Vector2f  {
       .screenPoint;
   }

    MouseButtonEvent  {
       .mouseButton;
   }

   
    String  {
         .clientUseTime;
        + var10000 +  + String.valueOf(.itemInHand) +  + String.valueOf(.targetBlock) +  + String.valueOf(.targetEntity) +  + String.valueOf(.screenPoint) +  + String.valueOf(.mouseButton) +  + .cancelled +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerMouseMotionEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.event.ICancellable;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.MouseMotionEvent;
import com.hypixel.hytale.protocol.Vector2f;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.entity.Entity;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class PlayerMouseMotionEvent extends PlayerEvent<Void> implements ICancellable {
   private final long clientUseTime;
   private final Item itemInHand;
   private final Vector3i targetBlock;
   private final Entity targetEntity;
   private final Vector2f screenPoint;
   private final MouseMotionEvent mouseMotion;
   private boolean cancelled;

   public PlayerMouseMotionEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Player player, long clientUseTime, Item itemInHand, Vector3i targetBlock, Entity targetEntity, Vector2f screenPoint, MouseMotionEvent mouseMotion) {
      (ref, player);
      .clientUseTime = clientUseTime;
      .itemInHand = itemInHand;
      .targetBlock = targetBlock;
      .targetEntity = targetEntity;
      .screenPoint = screenPoint;
      .mouseMotion = mouseMotion;
   }

      {
       .cancelled;
   }

      {
      .cancelled = cancelled;
   }

      {
       .clientUseTime;
   }

    Item  {
       .itemInHand;
   }

    Vector3i  {
       .targetBlock;
   }

    Entity  {
       .targetEntity;
   }

    Vector2f  {
       .screenPoint;
   }

    MouseMotionEvent  {
       .mouseMotion;
   }

   
    String  {
         .clientUseTime;
        + var10000 +  + String.valueOf(.itemInHand) +  + String.valueOf(.targetBlock) +  + String.valueOf(.targetEntity) +  + String.valueOf(.screenPoint) +  + String.valueOf(.mouseMotion) +  + .cancelled +  + .toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerReadyEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import javax.annotation.Nonnull;

public class PlayerReadyEvent extends PlayerEvent<String> {
   private final int readyId;

   public PlayerReadyEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Player player, int readyId) {
      super(ref, player);
      this.readyId = readyId;
   }

   public int getReadyId() {
      return this.readyId;
   }

   @Nonnull
   public String toString() {
      int var10000 = this.readyId;
      return "PlayerReadyEvent{readyId=" + var10000 + "} " + super.toString();
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerRefEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import javax.annotation.Nonnull;

public abstract class PlayerRefEvent<KeyType> implements IEvent<KeyType> {
   @Nonnull
   final PlayerRef playerRef;

   public PlayerRefEvent(@Nonnull PlayerRef playerRef) {
      this.playerRef = playerRef;
   }

   @Nonnull
   public PlayerRef getPlayerRef() {
      return this.playerRef;
   }

   @Nonnull
   public String toString() {
      return "PlayerRefEvent{playerRef=" + String.valueOf(this.playerRef) + "}";
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerSetupConnectEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.event.ICancellable;
import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.HostAddress;
import com.hypixel.hytale.protocol.packets.auth.ClientReferral;
import com.hypixel.hytale.server.core.auth.PlayerAuthentication;
import com.hypixel.hytale.server.core.io.PacketHandler;
import java.util.Objects;
import java.util.UUID;
import java.util.logging.Level;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class PlayerSetupConnectEvent implements IEvent<Void>, ICancellable {
   public static final String DEFAULT_REASON = "You have been disconnected from the server!";
   private final PacketHandler packetHandler;
   private final String username;
   private final UUID uuid;
   private final PlayerAuthentication auth;
   private final byte[] referralData;
   private final HostAddress referralSource;
   private boolean cancelled;
   private String reason;
    ClientReferral clientReferral;

     {
      .packetHandler = packetHandler;
      .username = username;
      .uuid = uuid;
      .auth = auth;
      .referralData = referralData;
      .referralSource = referralSource;
      .reason = ;
      .cancelled = ;
   }

    PacketHandler  {
       .packetHandler;
   }

    UUID  {
       .uuid;
   }

    String  {
       .username;
   }

    PlayerAuthentication  {
       .auth;
   }

   
    [] getReferralData() {
       .referralData;
   }

      {
       .referralData !=  && .referralData.length > ;
   }

   
    HostAddress  {
       .referralSource;
   }

   
    ClientReferral  {
       .clientReferral;
   }

      {
      .referToServer(host, port, ([]));
   }

      {
         ;
      Objects.requireNonNull(host, );
       (port >  && port <= ) {
          (data !=  && data.length > ) {
              ( + data.length + );
         }  {
            HytaleLogger.getLogger().at(Level.INFO).log(, .username, .uuid, host, port, data !=  ? data.length : );
            .clientReferral =  ( (host, ()port), data);
         }
      }  {
           ();
      }
   }

    String  {
       .reason;
   }

      {
      Objects.requireNonNull(reason, );
      .reason = reason;
   }

      {
       .cancelled;
   }

      {
      .cancelled = cancelled;
   }

   
    String  {
         .username;
        + var10000 +  + String.valueOf(.uuid) +  + String.valueOf(.auth) +  + (.referralData !=  ? .referralData.length +  : ) +  + (.referralSource !=  ? .referralSource.host +  + .referralSource.port : ) +  + .cancelled +  + .reason + ;
   }
}

com/hypixel/hytale/server/core/event/events/player/PlayerSetupDisconnectEvent.java

package com.hypixel.hytale.server.core.event.events.player;

import com.hypixel.hytale.event.IEvent;
import com.hypixel.hytale.server.core.auth.PlayerAuthentication;
import com.hypixel.hytale.server.core.io.PacketHandler;
import java.util.UUID;
import javax.annotation.Nonnull;

public class PlayerSetupDisconnectEvent implements IEvent<Void> {
   private final String username;
   private final UUID uuid;
   private final PlayerAuthentication auth;
   private final PacketHandler.DisconnectReason disconnectReason;

   public PlayerSetupDisconnectEvent(String username, UUID uuid, PlayerAuthentication auth, PacketHandler.DisconnectReason disconnectReason) {
      this.username = username;
      this.uuid = uuid;
      this.auth = auth;
      this.disconnectReason = disconnectReason;
   }

   public String getUsername() {
      return this.username;
   }

   public UUID getUuid() {
      return this.uuid;
   }

   public PlayerAuthentication getAuth() {
      return this.auth;
   }

    PacketHandler.DisconnectReason  {
       .disconnectReason;
   }

   
    String  {
         .username;
        + var10000 +  + String.valueOf(.uuid) +  + String.valueOf(.auth) +  + String.valueOf(.disconnectReason) + ;
   }
}