class="kw">package com.hypixel.hytale.server.core.entity.entities;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.common.util.DebugFlags;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.event.IEventDispatcher;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import com.hypixel.hytale.metrics.MetricProvider;
class="kw">import com.hypixel.hytale.metrics.MetricResults;
class="kw">import com.hypixel.hytale.metrics.MetricsRegistry;
class="kw">import com.hypixel.hytale.protocol.FlyMode;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.protocol.MovementSettings;
class="kw">import com.hypixel.hytale.protocol.MovementStates;
class="kw">import com.hypixel.hytale.protocol.SavedMovementStates;
class="kw">import com.hypixel.hytale.protocol.SoundCategory;
class="kw">import com.hypixel.hytale.protocol.packets.player.SetBlockPlacementOverride;
class="kw">import com.hypixel.hytale.protocol.packets.player.SetGameMode;
class="kw">import com.hypixel.hytale.protocol.packets.player.SetMovementStates;
class="kw">import com.hypixel.hytale.protocol.packets.player.SetNoClip;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.type.gamemode.GameModeType;
class="kw">import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
class="kw">import com.hypixel.hytale.server.core.entity.Entity;
class="kw">import com.hypixel.hytale.server.core.entity.LivingEntity;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.CameraManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.HotbarManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.data.PlayerConfigData;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.data.PlayerRespawnPointData;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.hud.HudManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.pages.PageManager;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.windows.WindowManager;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.ChangeGameModeEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.PlayerReadyEvent;
class="kw">import com.hypixel.hytale.server.core.inventory.InventoryUtils;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.inventory.transaction.ItemStackTransaction;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionModule;
class="kw">import com.hypixel.hytale.server.core.modules.collision.CollisionResult;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.CollisionResultComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Invulnerable;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.RespondToHit;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.gamemode.GameModeTypeState;
class="kw">import com.hypixel.hytale.server.core.modules.entity.gamemode.GameModeTypes;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.ChunkTracker;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.CreativeEraserSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.Velocity;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.SoundUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.WorldMapTracker;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.ISpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.NotificationUtil;
class="kw">import com.hypixel.hytale.server.core.util.TempAssetIdUtil;
class="kw">import it.unimi.dsi.fastutil.longs.LongIterator;
class="kw">import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
class="kw">import java.util.Arrays;
class="kw">import java.util.List;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.ScheduledFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import java.util.concurrent.atomic.AtomicInteger;
class="kw">import java.util.concurrent.atomic.AtomicReference;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class Player class="kw">extends LivingEntity class="kw">implements MetricProvider {
   @Nonnull
   class="kw">public class="kw">static class="kw">final MetricsRegistry<Player> METRICS_REGISTRY = new MetricsRegistry<Player>()
      .register("Uuid", Entity::getUuid, Codec.UUID_STRING)
      .register("ClientViewRadius", Player::getClientViewRadius, Codec.INTEGER);
   @Nonnull
   class="kw">public class="kw">static class="kw">final KeyedCodec<PlayerConfigData> PLAYER_CONFIG_DATA = new KeyedCodec<>("PlayerData", PlayerConfigData.CODEC);
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<Player> CODEC = BuilderCodec.builder(Player.class, Player::new, LivingEntity.CODEC)
      .append(PLAYER_CONFIG_DATA, (var0, var1) -> var0.data = var1, var0 -> var0.data)
      .add()
      .append(
         new KeyedCodec<>("BlockPlacementOverride", Codec.BOOLEAN),
         (var0, var1) -> var0.overrideBlockPlacementRestrictions = var1,
         var0 -> var0.overrideBlockPlacementRestrictions
      )
      .add()
      .append(new KeyedCodec<>("HotbarManager", HotbarManager.CODEC), (var0, var1) -> var0.hotbarManager = var1, var0 -> var0.hotbarManager)
      .add()
      .<GameMode>appendInherited(
         new KeyedCodec<>("GameMode", ProtocolCodecs.GAMEMODE_LEGACY),
         (var0, var1) -> var0.gameMode = var1,
         var0 -> var0.gameMode,
         (var0, var1) -> var0.gameMode = var1.gameMode
      )
      .documentation("The last known game-mode of the entity.")
      .add()
      .build();
   class="kw">public class="kw">static class="kw">final int DEFAULT_VIEW_RADIUS_CHUNKS = 6;
   class="kw">public class="kw">static class="kw">final long RESPAWN_INVULNERABILITY_TIME_NANOS = TimeUnit.MILLISECONDS.toNanos(3000L);
   class="kw">public class="kw">static class="kw">final long MAX_TELEPORT_INVULNERABILITY_MILLIS = 10000L;
   @Deprecated(forRemoval = true)
   class="kw">private PlayerRef playerRef;
   @Nonnull
   class="kw">private PlayerConfigData data = new PlayerConfigData();
   @Nonnull
   class="kw">private class="kw">final WorldMapTracker worldMapTracker = new WorldMapTracker(this);
   @Nonnull
   class="kw">private class="kw">final WindowManager windowManager = new WindowManager();
   @Nonnull
   class="kw">private class="kw">final PageManager pageManager = new PageManager();
   @Nonnull
   class="kw">private class="kw">final HudManager hudManager = new HudManager();
   @Nonnull
   class="kw">private HotbarManager hotbarManager = new HotbarManager();
   class="kw">private GameMode gameMode;
   class="kw">private int clientViewRadius = 6;
   class="kw">protected long lastSpawnTimeNanos;
   class="kw">private class="kw">static class="kw">final int MAX_VELOCITY_SAMPLE_COUNT = 2;
   class="kw">private class="kw">static class="kw">final int VELOCITY_SAMPLE_LENGTH = 12;
   class="kw">private class="kw">static class="kw">final double[][] velocitySampleWeights = new double[][]{{1.0}, {0.9, 0.1}};
   class="kw">private class="kw">final double[] velocitySamples = new double[12];
   class="kw">private int velocitySampleCount;
   class="kw">private int velocitySampleIndex = 4;
   class="kw">private boolean overrideBlockPlacementRestrictions;
   class="kw">private boolean noClip;
   class="kw">private class="kw">final AtomicInteger readyId = new AtomicInteger();
   class="kw">private class="kw">final AtomicReference<ScheduledFuture<?>> waitingForClientReady = new AtomicReference<>();
   class="kw">public boolean executeTriggers;
   class="kw">public boolean executeBlockDamage;
   class="kw">private boolean firstSpawn;
   class="kw">private int mountEntityId;

   @Nonnull
   class="kw">public class="kw">static ComponentType<EntityStore, Player> getComponentType() {
      class="kw">return EntityModule.get().getPlayerComponentType();
   }

   class="kw">public Player() {
   }

   class="kw">public void copyFrom(@Nonnull Player var1) {
      this.init(this.legacyUuid, this.playerRef);
      this.worldMapTracker.copyFrom(var1.worldMapTracker);
      this.clientViewRadius = var1.clientViewRadius;
      this.readyId.set(var1.readyId.get());
   }

   class="kw">public void init(@Nonnull UUID var1, @Nonnull PlayerRef var2) {
      this.legacyUuid = var1;
      this.playerRef = var2;
      this.worldMapTracker.setPlayerUuid(var1);
      this.windowManager.init(var2);
      this.pageManager.init(var2, this.windowManager);
   }

   class="kw">public void setNetworkId(int var1) {
      this.networkId = var1;
   }

   @Override
   class="kw">public boolean remove() {
      if (this.wasRemoved.getAndSet(true)) {
         class="kw">return false;
      }

      this.worldMapTracker.unregisterEvents();
      this.removedBy = DebugFlags.CAPTURE_THROWABLES ? new Throwable() : null;
      if (this.world != null && this.world.isAlive()) {
         if (this.world.isInThread()) {
            Ref var1 = this.playerRef.getReference();
            if (var1 != null) {
               Store var2 = var1.getStore();
               ChunkTracker var3 = var2.getComponent(var1, ChunkTracker.getComponentType());
               if (var3 != null) {
                  var3.clear();
               }

               this.playerRef.removeFromStore();
            }
         } else {
            this.world.execute(() -> {
               Ref var1 = this.playerRef.getReference();
               if (var1 != null) {
                  Store var2 = var1.getStore();
                  ChunkTracker var3 = var2.getComponent(var1, ChunkTracker.getComponentType());
                  if (var3 != null) {
                     var3.clear();
                  }

                  this.playerRef.removeFromStore();
               }
            });
         }
      }

      if (this.playerRef.getPacketHandler().getChannel().isActive()) {
         PacketHandler.DisconnectReason var4 = this.playerRef.getPacketHandler().getDisconnectReason();
         if (var4.getServerDisconnectReason() == null && var4.getClientDisconnectType() == null) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(this.removedBy)).log("Player removed from world! %s", this);
         }

         this.playerRef.getPacketHandler().disconnect(Message.translation("server.general.disconnect.playerRemovedFromWorld"));
      }

      ScheduledFuture var5;
      if ((var5 = this.waitingForClientReady.getAndSet(null)) != null) {
         var5.cancel(false);
      }

      class="kw">return true;
   }

   @Override
   class="kw">public void moveTo(@Nonnull Ref<EntityStore> var1, double var2, double var4, double var6, @Nonnull ComponentAccessor<EntityStore> var8) {
      TransformComponent var9 = var8.getComponent(var1, TransformComponent.getComponentType());
      assert var9 != null;
      Vector3d var10 = var9.getPosition();
      addLocationChange(var1, var2 - var10.x(), var4 - var10.y(), var6 - var10.z(), var8);
      super.moveTo(var1, var2, var4, var6, var8);
      this.windowManager.validateWindows(var1, var8);
   }

   @Nonnull
   class="kw">public PlayerConfigData getPlayerConfigData() {
      class="kw">return this.data;
   }

   @Override
   class="kw">public void markNeedsSave() {
      this.data.markChanged();
   }

   class="kw">public class="kw">static void applyMovementStates(
      @Nonnull Ref<EntityStore> var0, @Nonnull SavedMovementStates var1, @Nonnull MovementStates var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      var2.flying = var1.flying;
      PlayerRef var4 = var3.getComponent(var0, PlayerRef.getComponentType());
      assert var4 != null;
      var4.getPacketHandler().writeNoCache(new SetMovementStates(new SavedMovementStates(var2.flying)));
   }

   class="kw">public void startClientReadyTimeout() {
      ScheduledFuture var1 = HytaleServer.SCHEDULED_EXECUTOR.schedule(() -> {
         World var1 = this.world;
         if (var1 == null) {
            this.waitingForClientReady.set(null);
         } else {
            var1.execute(() -> this.handleClientReady(true));
         }
      }, 10000L, TimeUnit.MILLISECONDS);
      ScheduledFuture var2 = this.waitingForClientReady.getAndSet(var1);
      if (var2 != null) {
         var2.cancel(false);
      }
   }

   class="kw">public void handleClientReady(boolean var1) {
      ScheduledFuture var2;
      if ((var2 = this.waitingForClientReady.getAndSet(null)) != null) {
         var2.cancel(false);
         if (this.world == null) {
            class="kw">return;
         }

         IEventDispatcher var3 = HytaleServer.get().getEventBus().dispatchFor(PlayerReadyEvent.class, this.world.getName());
         if (var3.hasListener()) {
            var3.dispatch(new PlayerReadyEvent(this.reference, this, this.readyId.getAndIncrement()));
         }
      }
   }

   @Nonnull
   class="kw">public CompletableFuture<Void> saveConfig(@Nonnull World var1, @Nonnull Holder<EntityStore> var2, boolean var3) {
      MovementStatesComponent var4 = var2.getComponent(MovementStatesComponent.getComponentType());
      assert var4 != null;
      UUIDComponent var5 = var2.getComponent(UUIDComponent.getComponentType());
      assert var5 != null;
      this.data.getPerWorldData(var1.getName()).setLastMovementStates(var4.getMovementStates(), false);
      class="kw">return Universe.get().getPlayerStorage().save(var5.getUuid(), var2, var3);
   }

   @Deprecated(forRemoval = true)
   class="kw">public PacketHandler getPlayerConnection() {
      class="kw">return this.playerRef.getPacketHandler();
   }

   @Nonnull
   class="kw">public WorldMapTracker getWorldMapTracker() {
      class="kw">return this.worldMapTracker;
   }

   @Nonnull
   class="kw">public WindowManager getWindowManager() {
      class="kw">return this.windowManager;
   }

   @Nonnull
   class="kw">public PageManager getPageManager() {
      class="kw">return this.pageManager;
   }

   @Nonnull
   class="kw">public HudManager getHudManager() {
      class="kw">return this.hudManager;
   }

   @Nonnull
   class="kw">public HotbarManager getHotbarManager() {
      class="kw">return this.hotbarManager;
   }

   class="kw">public boolean isFirstSpawn() {
      class="kw">return this.firstSpawn;
   }

   class="kw">public void setFirstSpawn(boolean var1) {
      this.firstSpawn = var1;
   }

   class="kw">public void resetManagers(@Nonnull Holder<EntityStore> var1) {
      PlayerRef var2 = this.playerRef;
      EntityTrackerSystems.clear(var1);
      this.worldMapTracker.clear();
      this.worldMapTracker.unregisterEvents();
      this.hudManager.resetUserInterface(this.playerRef);
      this.hudManager.resetHud(this.playerRef);
      CameraManager var3 = var2.getComponent(CameraManager.getComponentType());
      assert var3 != null;
      var3.resetCamera(var2);
      MovementManager var4 = var2.getComponent(MovementManager.getComponentType());
      assert var4 != null;
      var4.applyDefaultSettings();
      var4.update(var2.getPacketHandler());
   }

   class="kw">public class="kw">static void notifyPickupItem(
      @Nonnull Ref<EntityStore> var0, @Nonnull ItemStack var1, @Nullable Vector3d var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      World var4 = var3.getExternalData().getWorld();
      if (var4.getGameplayConfig().getShowItemPickupNotifications()) {
         PlayerRef var5 = var3.getComponent(var0, PlayerRef.getComponentType());
         assert var5 != null;
         NotificationUtil.sendNotification(
            var5.getPacketHandler(), Message.translation("server.general.pickedUpItem").param("item", var1.getDisplayName()), null, var1.toPacket()
         );
      }

      if (var2 != null) {
         SoundUtil.playSoundEvent3dToPlayer(var0, TempAssetIdUtil.getSoundEventIndex("SFX_Player_Pickup_Item"), SoundCategory.UI, var2, var3);
      } else {
         SoundUtil.playSoundEvent2d(var0, TempAssetIdUtil.getSoundEventIndex("SFX_Player_Pickup_Item"), SoundCategory.UI, var3);
      }
   }

   class="kw">public boolean isOverrideBlockPlacementRestrictions() {
      class="kw">return this.overrideBlockPlacementRestrictions;
   }

   class="kw">public void setOverrideBlockPlacementRestrictions(@Nonnull Ref<EntityStore> var1, boolean var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      this.overrideBlockPlacementRestrictions = var2;
      PlayerRef var4 = var3.getComponent(var1, PlayerRef.getComponentType());
      assert var4 != null;
      var4.getPacketHandler().writeNoCache(new SetBlockPlacementOverride(var2));
   }

   class="kw">public boolean isNoClip() {
      class="kw">return this.noClip;
   }

   class="kw">public void setNoClip(@Nonnull Ref<EntityStore> var1, boolean var2, boolean var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      this.noClip = var2;
      PlayerRef var5 = var4.getComponent(var1, PlayerRef.getComponentType());
      assert var5 != null;
      var5.getPacketHandler().writeNoCache(new SetNoClip(var2, var3));
   }

   class="kw">public boolean isFlying(@Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      MovementStatesComponent var3 = var2.getComponent(var1, MovementStatesComponent.getComponentType());
      assert var3 != null;
      class="kw">return var3.getMovementStates().flying;
   }

   class="kw">public void setFlying(@Nonnull Ref<EntityStore> var1, boolean var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      MovementStatesComponent var4 = var3.getComponent(var1, MovementStatesComponent.getComponentType());
      assert var4 != null;
      MovementManager var5 = var3.getComponent(var1, MovementManager.getComponentType());
      if (var5 != null) {
         MovementSettings var6 = var5.getDefaultSettings();
         MovementSettings var7 = var5.getSettings();
         if (var6 != null && var7 != null) {
            FlyMode var8;
            if (!var2) {
               var8 = var6.fly;
            } else if (var7.fly == FlyMode.Forced) {
               var8 = FlyMode.Forced;
            } else {
               var8 = FlyMode.Allowed;
            }

            if (var7.fly != var8) {
               var7.fly = var8;
               PlayerRef var9 = var3.getComponent(var1, PlayerRef.getComponentType());
               assert var9 != null;
               var5.update(var9.getPacketHandler());
            }
         }
      }

      applyMovementStates(var1, new SavedMovementStates(var2), var4.getMovementStates(), var3);
   }

   class="kw">public class="kw">static void addLocationChange(@Nonnull Ref<EntityStore> var0, double var1, double var3, double var5, @Nonnull ComponentAccessor<EntityStore> var7) {
      CollisionResultComponent var8 = var7.getComponent(var0, CollisionResultComponent.getComponentType());
      assert var8 != null;
      var8.getCollisionPositionOffset().add(var1, var3, var5);
      if (!var8.isPendingCollisionCheck()) {
         TransformComponent var9 = var7.getComponent(var0, TransformComponent.getComponentType());
         assert var9 != null;
         Vector3d var10 = var9.getPosition();
         var8.getCollisionStartPosition().set(var10);
         var8.markPendingCollisionCheck();
      }
   }

   class="kw">public void configTriggerBlockProcessing(boolean var1, boolean var2, @Nonnull CollisionResultComponent var3) {
      this.executeTriggers = var1;
      this.executeBlockDamage = var2;
      if (!var1 && !var2) {
         var3.getCollisionResult().disableTriggerBlocks();
      } else {
         var3.getCollisionResult().enableTriggerBlocks();
      }
   }

   class="kw">public void resetVelocity(@Nonnull Velocity var1) {
      Arrays.fill(this.velocitySamples, 0.0);
      this.velocitySampleIndex = 4;
      this.velocitySampleCount = 0;
      var1.setZero();
   }

   class="kw">public void processVelocitySample(double var1, @Nonnull Vector3d var3, @Nonnull Velocity var4) {
      double var5 = var3.x;
      double var7 = var3.y;
      double var9 = var3.z;
      if (var1 != 0.0) {
         this.velocitySamples[this.velocitySampleIndex] = var5;
         this.velocitySamples[this.velocitySampleIndex + 1] = var7;
         this.velocitySamples[this.velocitySampleIndex + 2] = var9;
         this.velocitySamples[this.velocitySampleIndex + 3] = var1;
         int var11 = this.velocitySampleIndex;
         this.velocitySampleIndex += 4;
         if (this.velocitySampleIndex >= 12) {
            this.velocitySampleIndex = 4;
         }

         if (this.velocitySampleCount < 2) {
            this.velocitySampleCount++;
         }

         if (this.velocitySampleCount < 2) {
            var4.setZero();
         } else {
            for (int var12 = 0; var12 < 4; var12++) {
               this.velocitySamples[var12] = 0.0;
            }

            double[] var17 = velocitySampleWeights[this.velocitySampleCount - 2];

            for (int var14 = 0; var14 < this.velocitySampleCount - 1; var14++) {
               int var13 = var11 - 4;
               if (var13 < 4) {
                  var13 = 8;
               }

               double var15 = var17[var14] / this.velocitySamples[var11 + 3];
               this.velocitySamples[0] = this.velocitySamples[0] + var15 * (this.velocitySamples[var11] - this.velocitySamples[var13]);
               this.velocitySamples[1] = this.velocitySamples[1] + var15 * (this.velocitySamples[var11 + 1] - this.velocitySamples[var13 + 1]);
               this.velocitySamples[2] = this.velocitySamples[2] + var15 * (this.velocitySamples[var11 + 2] - this.velocitySamples[var13 + 2]);
               var11 = var13;
            }

            var4.set(this.velocitySamples[0], this.velocitySamples[1], this.velocitySamples[2]);
         }
      }
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<Transform> getRespawnPosition(
      @Nonnull Ref<EntityStore> var0, @Nonnull String var1, @Nonnull ComponentAccessor<EntityStore> var2
   ) {
      Player var3 = var2.getComponent(var0, getComponentType());
      assert var3 != null;
      World var4 = var2.getExternalData().getWorld();
      PlayerConfigData var5 = var3.data;
      PlayerRespawnPointData[] var6 = var5.getPerWorldData(var1).getRespawnPoints();
      if (var6 != null && var6.length != 0) {
         TransformComponent var12 = var2.getComponent(var0, TransformComponent.getComponentType());
         assert var12 != null;
         Vector3d var13 = var12.getPosition();
         List var9 = Arrays.stream(var6).sorted((var1x, var2x) -> {
            Vector3d var3 = var1x.getRespawnPosition();
            Vector3d var4 = var2x.getRespawnPosition();
            double var5 = var13.distanceSquared(var3.x, var13.y, var3.z);
            double var7 = var13.distanceSquared(var4.x, var13.y, var4.z);
            class="kw">return Double.compare(var5, var7);
         }).toList();
         BoundingBox var10 = var2.getComponent(var0, BoundingBox.getComponentType());
         if (var10 == null) {
            class="kw">return CompletableFuture.completedFuture(new Transform(var9.getFirst().getRespawnPosition()));
         }

         PlayerRef var11 = var2.getComponent(var0, PlayerRef.getComponentType());
         assert var11 != null;
         class="kw">return tryUseSpawnPoint(var4, var9, 0, var0, var11, var10.getBoundingBox());
      } else {
         ISpawnProvider var7 = var4.getWorldConfig().getSpawnProvider();
         if (var7 == null) {
            class="kw">return CompletableFuture.completedFuture(new Transform());
         }

         Transform var8 = var7.getSpawnPoint(var0, var2);
         class="kw">return CompletableFuture.completedFuture(var8);
      }
   }

   @Nonnull
   class="kw">private class="kw">static CompletableFuture<Transform> tryUseSpawnPoint(
      @Nonnull World var0, @Nullable List<PlayerRespawnPointData> var1, int var2, @Nonnull Ref<EntityStore> var3, @Nonnull PlayerRef var4, @Nonnull Box var5
   ) {
      if (var1 != null && var2 < var1.size()) {
         PlayerRespawnPointData var6 = var1.get(var2);
         LongOpenHashSet var7 = new LongOpenHashSet();
         if (var6.getRespawnPosition() != null) {
            var5.forEachBlock(var6.getRespawnPosition(), 2.0, var7, (var0x, var1x, var2x, var3x) -> {
               var3x.add(ChunkUtil.indexChunkFromBlock(var0x, var2x));
               class="kw">return true;
            });
         }

         if (var6.getBlockPosition() != null) {
            var5.forEachBlock(Vector3iUtil.toVector3d(var6.getBlockPosition()), 2.0, var7, (var0x, var1x, var2x, var3x) -> {
               var3x.add(ChunkUtil.indexChunkFromBlock(var0x, var2x));
               class="kw">return true;
            });
         }

         CompletableFuture[] var8 = new CompletableFuture[var7.size()];
         int var9 = 0;
         LongIterator var10 = var7.iterator();

         while (var10.hasNext()) {
            long var11 = var10.nextLong();
            var8[var9++] = var0.getChunkStore().getChunkReferenceAsync(var11).thenApplyAsync(var0x -> {
               if (var0x != null && var0x.isValid()) {
                  WorldChunk var1 = var0x.getStore().getComponent((Ref<ChunkStore>)var0x, WorldChunk.getComponentType());
                  assert var1 != null;
                  var1.addKeepLoaded();
                  class="kw">return var1;
               } else {
                  class="kw">return null;
               }
            }, var0);
         }

         class="kw">return CompletableFuture.allOf(var8).thenApplyAsync(var4x -> {
            Vector3d var5 = ensureNoCollisionAtRespawnPosition(var6, var5, var0);
            if (var5 != null) {
               class="kw">return new Transform(var5, new Rotation3f(Rotation3f.IDENTITY));
            }

            var4.sendMessage(Message.translation("server.general.respawnPointObstructed").param("respawnPointName", var6.getName()));
            class="kw">return null;
         }, var0).whenComplete((var1x, var2x) -> {
            for (CompletableFuture var6 : var8) {
               var6.thenAccept(WorldChunk::removeKeepLoaded);
            }
         }).thenCompose(var6x -> var6x != null ? CompletableFuture.completedFuture(var6x) : tryUseSpawnPoint(var0, var1, var2 + 1, var3, var4, var5));
      } else {
         var4.sendMessage(Message.translation("server.general.allRespawnPointsObstructed"));
         class="kw">return CompletableFuture.supplyAsync(() -> {
            if (!var3.isValid()) {
               class="kw">return new Transform();
            }

            ISpawnProvider var2 = var0.getWorldConfig().getSpawnProvider();
            if (var2 == null) {
               class="kw">return new Transform();
            }

            Transform var3 = var2.getSpawnPoint(var3, var3.getStore());
            var3.setRotation(Rotation3f.IDENTITY);
            class="kw">return var3;
         }, var0);
      }
   }

   @Nullable
   class="kw">private class="kw">static Vector3d ensureNoCollisionAtRespawnPosition(@Nonnull PlayerRespawnPointData var0, @Nonnull Box var1, @Nonnull World var2) {
      Vector3d var3 = new Vector3d(var0.getRespawnPosition());
      if (CollisionModule.get().validatePosition(var2, var1, var3, new CollisionResult()) != -1) {
         class="kw">return var3;
      }

      Vector3i var4 = var0.getBlockPosition();
      var3.x = var4.x + 0.5F;
      var3.y = var4.y;
      var3.z = var4.z + 0.5F;

      for (int var5 = 1; var5 <= 2; var5++) {
         for (int var6 = -var5; var6 <= var5; var6++) {
            Vector3d var7 = new Vector3d(var3.x + var6, var3.y, var3.z - var5);
            if (CollisionModule.get().validatePosition(var2, var1, var7, new CollisionResult()) != -1) {
               class="kw">return var7;
            }

            var7 = new Vector3d(var3.x + var6, var3.y, var3.z + var5);
            if (CollisionModule.get().validatePosition(var2, var1, var7, new CollisionResult()) != -1) {
               class="kw">return var7;
            }
         }

         for (int var8 = -var5 + 1; var8 < var5; var8++) {
            Vector3d var10 = new Vector3d(var3.x - var5, var3.y, var3.z + var8);
            if (CollisionModule.get().validatePosition(var2, var1, var10, new CollisionResult()) != -1) {
               class="kw">return var10;
            }

            var10 = new Vector3d(var3.x + var5, var3.y, var3.z + var8);
            if (CollisionModule.get().validatePosition(var2, var1, var10, new CollisionResult()) != -1) {
               class="kw">return var10;
            }
         }
      }

      class="kw">return null;
   }

   class="kw">public boolean hasSpawnProtection() {
      class="kw">return System.nanoTime() - this.lastSpawnTimeNanos <= RESPAWN_INVULNERABILITY_TIME_NANOS || this.waitingForClientReady.get() != null;
   }

   class="kw">public boolean isWaitingForClientReady() {
      class="kw">return this.waitingForClientReady.get() != null;
   }

   @Override
   class="kw">public boolean isHiddenFromLivingEntity(@Nonnull Ref<EntityStore> var1, @Nonnull Ref<EntityStore> var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      UUIDComponent var4 = var3.getComponent(var1, UUIDComponent.getComponentType());
      assert var4 != null;
      PlayerRef var5 = var3.getComponent(var2, PlayerRef.getComponentType());
      class="kw">return var5 != null && var5.getHiddenPlayersManager().isPlayerHidden(var4.getUuid());
   }

   class="kw">public void setClientViewRadius(int var1) {
      this.clientViewRadius = Math.max(0, var1);
   }

   class="kw">public int getClientViewRadius() {
      class="kw">return this.clientViewRadius;
   }

   class="kw">public int getViewRadius() {
      class="kw">return Math.clamp(this.clientViewRadius, 0, HytaleServer.get().getConfig().getMaxViewRadius());
   }

   @Nonnull
   @Override
   class="kw">public MetricResults toMetricResults() {
      class="kw">return METRICS_REGISTRY.toMetricResults(this);
   }

   class="kw">public void setLastSpawnTimeNanos(long var1) {
      this.lastSpawnTimeNanos = var1;
   }

   class="kw">public long getSinceLastSpawnNanos() {
      class="kw">return System.nanoTime() - this.lastSpawnTimeNanos;
   }

   @Deprecated(forRemoval = true)
   class="kw">public PlayerRef getPlayerRef() {
      class="kw">return this.playerRef;
   }

   class="kw">public int getMountEntityId() {
      class="kw">return this.mountEntityId;
   }

   class="kw">public void setMountEntityId(int var1) {
      this.mountEntityId = var1;
   }

   class="kw">public GameMode getGameMode() {
      class="kw">return this.gameMode;
   }

   class="kw">public class="kw">static void setGameMode(@Nonnull Ref<EntityStore> var0, @Nonnull GameMode var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      MovementManager var3 = var2.getComponent(var0, MovementManager.getComponentType());
      assert var3 != null;
      Player var4 = var2.getComponent(var0, getComponentType());
      assert var4 != null;
      GameMode var5 = var4.gameMode;
      if (var5 != var1) {
         ChangeGameModeEvent var6 = new ChangeGameModeEvent(var1);
         var2.invoke(var0, var6);
         if (var6.isCancelled()) {
            class="kw">return;
         }

         setGameModeInternal(var0, var6.getGameMode(), var3, var2);
         if (GameModeTypes.getCurrentTypeId(var0, var2) == null) {
            runOnSwitchToGameMode(var0, var1);
         }
      }
   }

   class="kw">public class="kw">static void initGameMode(@Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1) {
      MovementManager var2 = var1.getComponent(var0, MovementManager.getComponentType());
      assert var2 != null;
      Player var3 = var1.getComponent(var0, getComponentType());
      assert var3 != null;
      GameMode var4 = var3.gameMode;
      if (var4 == null) {
         World var5 = var1.getExternalData().getWorld();
         var4 = var5.getWorldConfig().getGameMode();
         LOGGER.at(Level.INFO).log("Assigning class="kw">default gamemode %s to player!", var4);
      }

      setGameModeInternal(var0, var4, var2, var1);
   }

   class="kw">private class="kw">static void setGameModeInternal(
      @Nonnull Ref<EntityStore> var0, @Nonnull GameMode var1, @Nonnull MovementManager var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      Player var4 = var3.getComponent(var0, getComponentType());
      assert var4 != null;
      PlayerRef var5 = var3.getComponent(var0, PlayerRef.getComponentType());
      assert var5 != null;
      var4.gameMode = var1;
      var5.getPacketHandler().writeNoCache(new SetGameMode(var1));
      if (var2.getDefaultSettings() != null) {
         var2.resetFly(var1);
         var2.update(var5.getPacketHandler());
      }

      if (var1 == GameMode.Creative) {
         var3.putComponent(var0, Invulnerable.getComponentType(), Invulnerable.INSTANCE);
      } else {
         var3.tryRemoveComponent(var0, Invulnerable.getComponentType());
      }

      if (var1 == GameMode.Creative) {
         PlayerSettings var6 = var3.getComponent(var0, PlayerSettings.getComponentType());
         if (var6 == null) {
            var6 = PlayerSettings.defaults();
         }

         if (var6.creativeSettings().respondToHit()) {
            var3.putComponent(var0, RespondToHit.getComponentType(), RespondToHit.INSTANCE);
         } else {
            var3.tryRemoveComponent(var0, RespondToHit.getComponentType());
         }
      } else {
         var3.tryRemoveComponent(var0, RespondToHit.getComponentType());
      }

      CreativeEraserSystems.refresh(var0, var3);
      GameModeTypeState.reassert(var0, var4, var3);
      World var7 = var3.getExternalData().getWorld();
      var4.worldMapTracker.sendSettings(var7);
   }

   class="kw">private class="kw">static void runOnSwitchToGameMode(@Nonnull Ref<EntityStore> var0, @Nonnull GameMode var1) {
      GameModeTypeState.runInteractionsOnEnter(var0, GameModeType.fromGameMode(var1).getInteractionsOnEnter(), var0.getStore());
   }

   @Nonnull
   class="kw">public class="kw">static ItemStackTransaction giveItem(@Nonnull ItemStack var0, @Nonnull Ref<EntityStore> var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      PlayerSettings var3 = var2.getComponent(var1, PlayerSettings.getComponentType());
      if (var3 == null) {
         var3 = PlayerSettings.defaults();
      }

      class="kw">return InventoryUtils.getContainerForItemPickup(var1, var0.getItem(), var3, var2).addItemStack(var0);
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = super.hashCode();
      class="kw">return 31 * var1 + (this.getUuid() != null ? this.getUuid().hashCode() : 0);
   }

   @Override
   class="kw">public boolean equals(@Nullable Object var1) {
      if (this == var1) {
         class="kw">return true;
      }

      if (var1 == null || this.getClass() != var1.getClass()) {
         class="kw">return false;
      }

      if (!super.equals(var1)) {
         class="kw">return false;
      }

      Player var2 = (Player)var1;
      class="kw">return this.getUuid() != null ? this.getUuid().equals(var2.getUuid()) : var2.getUuid() == null;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "Player{uuid=" + this.getUuid() + ", clientViewRadius=" + this.clientViewRadius + ", " + super.toString() + "}";
   }
}