GamePacketHandler.java

package com.hypixel.hytale.server.core.io.handlers.game;

import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.math.util.ChunkUtil;
import com.hypixel.hytale.math.util.MathUtil;
import com.hypixel.hytale.math.vector.Transform;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.math.vector.Vector3f;
import com.hypixel.hytale.math.vector.Vector3i;
import com.hypixel.hytale.protocol.BlockRotation;
import com.hypixel.hytale.protocol.GameMode;
import com.hypixel.hytale.protocol.HostAddress;
import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.io.netty.ProtocolUtil;
import com.hypixel.hytale.protocol.packets.camera.RequestFlyCameraMode;
import com.hypixel.hytale.protocol.packets.camera.SetFlyCameraMode;
import com.hypixel.hytale.protocol.packets.connection.Disconnect;
import com.hypixel.hytale.protocol.packets.connection.Pong;
import com.hypixel.hytale.protocol.packets.entities.MountMovement;
import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
import com.hypixel.hytale.protocol.packets.interface_.ChatMessage;
import com.hypixel.hytale.protocol.packets.interface_.CustomPageEvent;
import com.hypixel.hytale.protocol.packets.interface_.Page;
 com.hypixel.hytale.protocol.packets.interface_.SetPage;
 com.hypixel.hytale.protocol.packets.interface_.UpdateLanguage;
 com.hypixel.hytale.protocol.packets.machinima.RequestMachinimaActorModel;
 com.hypixel.hytale.protocol.packets.machinima.SetMachinimaActorModel;
 com.hypixel.hytale.protocol.packets.machinima.UpdateMachinimaScene;
 com.hypixel.hytale.protocol.packets.player.ClientMovement;
 com.hypixel.hytale.protocol.packets.player.ClientPlaceBlock;
 com.hypixel.hytale.protocol.packets.player.ClientReady;
 com.hypixel.hytale.protocol.packets.player.MouseInteraction;
 com.hypixel.hytale.protocol.packets.player.RemoveMapMarker;
 com.hypixel.hytale.protocol.packets.player.SyncPlayerPreferences;
 com.hypixel.hytale.protocol.packets.serveraccess.SetServerAccess;
 com.hypixel.hytale.protocol.packets.serveraccess.UpdateServerAccess;
 com.hypixel.hytale.protocol.packets.setup.RequestAssets;
 com.hypixel.hytale.protocol.packets.setup.ViewRadius;
 com.hypixel.hytale.protocol.packets.window.ClientOpenWindow;
 com.hypixel.hytale.protocol.packets.window.CloseWindow;
 com.hypixel.hytale.protocol.packets.window.SendWindowAction;
 com.hypixel.hytale.protocol.packets.window.UpdateWindow;
 com.hypixel.hytale.protocol.packets.world.SetPaused;
 com.hypixel.hytale.protocol.packets.worldmap.MapMarker;
 com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapMarker;
 com.hypixel.hytale.protocol.packets.worldmap.TeleportToWorldMapPosition;
 com.hypixel.hytale.protocol.packets.worldmap.UpdateWorldMapVisible;
 com.hypixel.hytale.server.core.Constants;
 com.hypixel.hytale.server.core.HytaleServer;
 com.hypixel.hytale.server.core.HytaleServerConfig;
 com.hypixel.hytale.server.core.Message;
 com.hypixel.hytale.server.core.NameMatching;
 com.hypixel.hytale.server.core.asset.common.CommonAssetModule;
 com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
 com.hypixel.hytale.server.core.asset.type.model.config.Model;
 com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
 com.hypixel.hytale.server.core.auth.PlayerAuthentication;
 com.hypixel.hytale.server.core.command.system.CommandManager;
 com.hypixel.hytale.server.core.command.system.CommandSender;
 com.hypixel.hytale.server.core.console.ConsoleModule;
 com.hypixel.hytale.server.core.entity.entities.Player;
 com.hypixel.hytale.server.core.entity.entities.player.data.PlayerWorldData;
 com.hypixel.hytale.server.core.entity.entities.player.pages.PageManager;
 com.hypixel.hytale.server.core.entity.entities.player.windows.ValidatedWindow;
 com.hypixel.hytale.server.core.entity.entities.player.windows.Window;
 com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
 com.hypixel.hytale.server.core.event.events.player.PlayerChatEvent;
 com.hypixel.hytale.server.core.inventory.Inventory;
 com.hypixel.hytale.server.core.inventory.ItemStack;
 com.hypixel.hytale.server.core.io.ProtocolVersion;
 com.hypixel.hytale.server.core.io.ServerManager;
 com.hypixel.hytale.server.core.io.handlers.GenericPacketHandler;
 com.hypixel.hytale.server.core.io.handlers.IPacketHandler;
 com.hypixel.hytale.server.core.io.handlers.SubPacketHandler;
 com.hypixel.hytale.server.core.io.netty.NettyUtil;
 com.hypixel.hytale.server.core.modules.entity.EntityModule;
 com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
 com.hypixel.hytale.server.core.modules.entity.player.PlayerCreativeSettings;
 com.hypixel.hytale.server.core.modules.entity.player.PlayerInput;
 com.hypixel.hytale.server.core.modules.entity.player.PlayerSettings;
 com.hypixel.hytale.server.core.modules.entity.teleport.PendingTeleport;
 com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
 com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
 com.hypixel.hytale.server.core.modules.interaction.BlockPlaceUtils;
 com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
 com.hypixel.hytale.server.core.modules.singleplayer.SingleplayerModule;
 com.hypixel.hytale.server.core.universe.PlayerRef;
 com.hypixel.hytale.server.core.universe.Universe;
 com.hypixel.hytale.server.core.universe.world.World;
 com.hypixel.hytale.server.core.universe.world.WorldMapTracker;
 com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
 com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
 com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
 com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 com.hypixel.hytale.server.core.util.MessageUtil;
 com.hypixel.hytale.server.core.util.PositionUtil;
 com.hypixel.hytale.server.core.util.ValidateUtil;
 io.netty.channel.Channel;
 io.netty.channel.ChannelHandlerContext;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 java.net.InetSocketAddress;
 java.util.Collections;
 java.util.Deque;
 java.util.List;
 java.util.Objects;
 java.util.UUID;
 java.util.concurrent.CompletableFuture;
 java.util.concurrent.ConcurrentLinkedDeque;
 java.util.concurrent.CopyOnWriteArrayList;
 java.util.function.Supplier;
 java.util.logging.Level;
 javax.annotation.Nonnull;

       {
         ;
    PlayerRef playerRef;
   
   
    Player playerComponent;
   
     Deque<SyncInteractionChain> interactionPacketQueue =  ();

     {
      (channel, protocolVersion);
      .auth = auth;
      ServerManager.get().populateSubPacketHandlers();
      .registerHandlers();
   }

   
    Deque<SyncInteractionChain>  {
       .interactionPacketQueue;
   }

   
    PlayerRef  {
       .playerRef;
   }

      {
      .playerRef = playerRef;
      .playerComponent = playerComponent;
   }

   
    String  {
         NettyUtil.formatRemoteAddress(.channel);
        + var10000 +  + (.playerRef !=  ? String.valueOf(.playerRef.getUuid()) +  + .playerRef.getUsername() : ) + ;
   }

      {
      .registerHandler(, (p) -> .handle((Disconnect)p));
      .registerHandler(, (p) -> .handlePong((Pong)p));
      .registerHandler(, (p) -> .handle((ClientMovement)p));
      .registerHandler(, (p) -> .handle((ChatMessage)p));
      .registerHandler(, (p) -> .handle((RequestAssets)p));
      .registerHandler(, (p) -> .handle((CustomPageEvent)p));
      .registerHandler(, (p) -> .handle((ViewRadius)p));
      .registerHandler(, (p) -> .handle((UpdateLanguage)p));
      .registerHandler(, (p) -> .handle((MouseInteraction)p));
      .registerHandler(, (p) -> .handle((UpdateServerAccess)p));
      .registerHandler(, (p) -> .handle((SetServerAccess)p));
      .registerHandler(, (p) -> .handle((ClientOpenWindow)p));
      .registerHandler(, (p) -> .handle((SendWindowAction)p));
      .registerHandler(, (p) -> .handle((CloseWindow)p));
      .registerHandler(, (p) -> .handle((RequestMachinimaActorModel)p));
      .registerHandler(, (p) -> .handle((UpdateMachinimaScene)p));
      .registerHandler(, (p) -> .handle((ClientReady)p));
      .registerHandler(, (p) -> .handle((MountMovement)p));
      .registerHandler(, (p) -> .handle((SyncPlayerPreferences)p));
      .registerHandler(, (p) -> .handle((ClientPlaceBlock)p));
      .registerHandler(, (p) -> .handle((RemoveMapMarker)p));
      .registerHandler(, (p) -> .handle((UpdateWorldMapVisible)p));
      .registerHandler(, (p) -> .handle((TeleportToWorldMapMarker)p));
      .registerHandler(, (p) -> .handle((TeleportToWorldMapPosition)p));
      .registerHandler(, (p) -> .handle((SyncInteractionChains)p));
      .registerHandler(, (p) -> .handle((SetPaused)p));
      .registerHandler(, (p) -> .handle((RequestFlyCameraMode)p));
      .packetHandlers.forEach(SubPacketHandler::registerHandlers);
   }

      {
      .closed(ctx);
      Universe.get().removePlayer(.playerRef);
   }

      {
      .disconnectReason.setServerDisconnectReason(message);
       (.playerRef != ) {
         HytaleLogger.getLogger().at(Level.INFO).log(, .playerRef.getUsername(), NettyUtil.formatRemoteAddress(.channel), message);
         .disconnect0(message);
         Universe.get().removePlayer(.playerRef);
      }  {
         .disconnect(message);
      }

   }

      {
      .disconnectReason.setClientDisconnectType(packet.type);
      HytaleLogger.getLogger().at(Level.INFO).log(, .playerRef.getUuid(), .playerRef.getUsername(), NettyUtil.formatRemoteAddress(.channel), packet.type.name(), packet.reason);
      ProtocolUtil.closeApplicationConnection(.channel);
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

            InteractionModule.get().doMouseInteraction(ref, store, packet, playerComponent, .playerRef);
         });
      }
   }

      {
       (packet.absolutePosition !=  && !ValidateUtil.isSafePosition(packet.absolutePosition)) {
         .disconnect();
      }   ((packet.bodyOrientation ==  || ValidateUtil.isSafeDirection(packet.bodyOrientation)) && (packet.lookOrientation ==  || ValidateUtil.isSafeDirection(packet.lookOrientation))) {
         Ref<EntityStore> ref = .playerRef.getReference();
          (ref !=  && ref.isValid()) {
            Store<EntityStore> store = ref.getStore();
               ((EntityStore)store.getExternalData()).getWorld();
            world.execute(() -> {
                (ref.isValid()) {
                     (Player)store.getComponent(ref, Player.getComponentType());

                   playerComponent != ;

                   (!playerComponent.isWaitingForClientReady()) {
                        (PlayerInput)store.getComponent(ref, PlayerInput.getComponentType());
                      (playerInputComponent != ) {
                         (packet.movementStates != ) {
                           playerInputComponent.queue( .SetMovementStates(packet.movementStates));
                        }

                         (packet.velocity != ) {
                           playerInputComponent.queue( .SetClientVelocity(packet.velocity));
                        }

                           (PendingTeleport)store.getComponent(ref, PendingTeleport.getComponentType());
                         (pendingTeleport != ) {
                            (packet.teleportAck == ) {
                              ;
                           }

                            (pendingTeleport.validate(packet.teleportAck.teleportId, packet.absolutePosition)) {
                               OK:
                              :
                                  (!pendingTeleport.isEmpty()) {
                                    ;
                                 }

                                 store.removeComponent(ref, PendingTeleport.getComponentType());
                                 ;
                               INVALID_ID:
                                 .disconnect();
                                 ;
                               INVALID_POSITION:
                                 .disconnect();
                                 ;
                           }
                        }

                         (packet.mountedTo != ) {
                            (packet.mountedTo != playerInputComponent.getMountId()) {
                              ;
                           }

                            (packet.riderMovementStates != ) {
                              playerInputComponent.queue( .SetRiderMovementStates(packet.riderMovementStates));
                           }
                        }

                         (packet.bodyOrientation != ) {
                           playerInputComponent.queue( .SetBody(packet.bodyOrientation));
                        }

                         (packet.lookOrientation != ) {
                           playerInputComponent.queue( .SetHead(packet.lookOrientation));
                        }

                         (packet.wishMovement != ) {
                           playerInputComponent.queue( .WishMovement(packet.wishMovement.x, packet.wishMovement.y, packet.wishMovement.z));
                        }

                         (packet.absolutePosition != ) {
                           playerInputComponent.queue( .AbsoluteMovement(packet.absolutePosition.x, packet.absolutePosition.y, packet.absolutePosition.z));
                        }   (packet.relativePosition !=  && (packet.relativePosition.x !=  || packet.relativePosition.y !=  || packet.relativePosition.z !=  || packet.movementStates != )) {
                           playerInputComponent.queue( .RelativeMovement(()packet.relativePosition.x / , ()packet.relativePosition.y / , ()packet.relativePosition.z / ));
                        }

                     }
                  }
               }
            });
         }
      }  {
         .disconnect();
      }
   }

      {
       (packet.message !=  && !packet.message.isEmpty()) {
            packet.message;
            message.charAt();
          (firstChar == ) {
            CommandManager.get().handleCommand((CommandSender).playerComponent, message.substring());
         }   (firstChar == ) {
            .playerRef.sendMessage(Message.translation().param(, message));
         }  {
            Ref<EntityStore> ref = .playerRef.getReference();
             (ref ==  || !ref.isValid()) {
               ;
            }

               .playerRef.getUuid();
            List<PlayerRef> targetPlayerRefs =  <PlayerRef>(Universe.get().getPlayers());
            targetPlayerRefs.removeIf((targetPlayerRef) -> targetPlayerRef.getHiddenPlayersManager().isPlayerHidden(playerUUID));
            ((CompletableFuture)HytaleServer.get().getEventBus().dispatchForAsync(PlayerChatEvent.class).dispatch( (.playerRef, targetPlayerRefs, message))).whenComplete((playerChatEvent, throwable) -> {
                (throwable != ) {
                  ((HytaleLogger.Api)HytaleLogger.getLogger().at(Level.SEVERE).withCause(throwable)).log(, .playerRef.getUsername());
               }   (!playerChatEvent.isCancelled()) {
                     playerChatEvent.getFormatter().format(.playerRef, playerChatEvent.getContent());
                  HytaleLogger.getLogger().at(Level.INFO).log(MessageUtil.toAnsiString(sentMessage).toAnsi(ConsoleModule.get().getTerminal()));

                  (PlayerRef targetPlayerRef : playerChatEvent.getTargets()) {
                     targetPlayerRef.sendMessage(sentMessage);
                  }

               }
            });
         }

      }  {
         .disconnect();
      }
   }

      {
      CommonAssetModule.get().sendAssetsToPlayer(, packet.assets, );
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

               playerComponent.getPageManager();
            pageManager.handleEvent(ref, store, packet);
         });
      }  {
         .playerRef.getPacketHandler().writeNoCache( (Page.None, ));
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

            EntityTrackerSystems.   (EntityTrackerSystems.EntityViewer)store.getComponent(ref, EntityTrackerSystems.EntityViewer.getComponentType());

             entityViewerComponent != ;

               MathUtil.ceil(()(()packet.value / ));
            playerComponent.setClientViewRadius(viewRadiusChunks);
            entityViewerComponent.viewRadiusBlocks = playerComponent.getViewRadius() * ;
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         .playerRef.setLanguage(packet.language);
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Supplier<?  > supplier = (Supplier)Window.CLIENT_REQUESTABLE_WINDOW_TYPES.get(packet.type);
          (supplier == ) {
              ();
         }  {
            Store<EntityStore> store = ref.getStore();
               ((EntityStore)store.getExternalData()).getWorld();
            world.execute(() -> {
                  (Player)store.getComponent(ref, Player.getComponentType());

                playerComponent != ;

                  playerComponent.getWindowManager().clientOpenWindow((Window)supplier.get());
                (updateWindowPacket != ) {
                  .writeNoCache(updateWindowPacket);
               }

            });
         }
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

               playerComponent.getWindowManager().getWindow(packet.id);
             (window != ) {
                (window  ValidatedWindow && !((ValidatedWindow)window).validate()) {
                  window.close();
               }  {
                  window.handleAction(.playerRef.getReference(), store, packet.action);
               }
            }
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
            ComponentType<EntityStore, PlayerSettings> componentType = EntityModule.get().getPlayerSettingsComponentType();
            store.putComponent(ref, componentType,  (packet.showEntityMarkers, packet.armorItemsPreferredPickupLocation, packet.weaponAndToolItemsPreferredPickupLocation, packet.usableItemsItemsPreferredPickupLocation, packet.solidBlockItemsPreferredPickupLocation, packet.miscItemsPreferredPickupLocation,  (packet.allowNPCDetection, packet.respondToHit)));
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

               playerComponent.getInventory();
                (packet.position.x, packet.position.y, packet.position.z);
                (packet.rotation.rotationYaw, packet.rotation.rotationPitch, packet.rotation.rotationRoll);
               (TransformComponent)store.getComponent(ref, TransformComponent.getComponentType());
             (transformComponent !=  && playerComponent.getGameMode() != GameMode.Creative) {
                  transformComponent.getPosition();
                   (()targetBlock.x + , ()targetBlock.y + , ()targetBlock.z + );
                (position.distanceSquaredTo(blockCenter) > ) {
                  ;
               }
            }

            Store<ChunkStore> chunkStore = world.getChunkStore().getStore();
               ChunkUtil.indexChunkFromBlock(targetBlock.x, targetBlock.z);
            Ref<ChunkStore> chunkReference = ((ChunkStore)chunkStore.getExternalData()).getChunkReference(chunkIndex);
             (chunkReference != ) {
                  (BlockChunk)chunkStore.getComponent(chunkReference, BlockChunk.getComponentType());
                (blockChunk != ) {
                     blockChunk.getSectionAtBlockY(targetBlock.y);
                   (section != ) {
                        playerComponent.getInventory().getItemInHand();
                      (itemInHand == ) {
                        section.invalidateBlock(targetBlock.x, targetBlock.y, targetBlock.z);
                     }  {
                           itemInHand.getBlockKey();
                         (heldBlockKey == ) {
                           section.invalidateBlock(targetBlock.x, targetBlock.y, targetBlock.z);
                        }  {
                            (packet.placedBlockId != -) {
                                 ((BlockType)BlockType.getAssetMap().getAsset(packet.placedBlockId)).getId();
                                 (BlockType)BlockType.getAssetMap().getAsset(heldBlockKey);
                               (heldBlockType !=  && BlockPlaceUtils.canPlaceBlock(heldBlockType, clientPlacedBlockTypeKey)) {
                                 heldBlockKey = clientPlacedBlockTypeKey;
                              }
                           }

                           BlockPlaceUtils.placeBlock(ref, itemInHand, heldBlockKey, inventory.getHotbar(), Vector3i.ZERO, targetBlock, blockRotation, inventory, inventory.getActiveHotbarSlot(), playerComponent.getGameMode() != GameMode.Creative, chunkReference, chunkStore, store);
                        }
                     }
                  }
               }
            }
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

               playerComponent.getPlayerConfigData().getPerWorldData(world.getName());
            perWorldData.removeLastDeath(packet.markerId);
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

            playerComponent.getWindowManager().closeWindow(packet.id);
         });
      }
   }

      {
       (!Constants.SINGLEPLAYER) {
           ();
      }   (!SingleplayerModule.isOwner(.playerRef)) {
           ();
      }  {
         List<InetSocketAddress> publicAddresses =  ();

         (HostAddress host : packet.hosts) {
            publicAddresses.add(InetSocketAddress.createUnresolved(host.host, host.port & ));
         }

            SingleplayerModule.get();
         singleplayerModule.setPublicAddresses(publicAddresses);
         singleplayerModule.updateAccess(packet.access);
      }
   }

      {
       (!Constants.SINGLEPLAYER) {
           ();
      }   (!SingleplayerModule.isOwner(.playerRef)) {
           ();
      }  {
            HytaleServer.get().getConfig();
          (config != ) {
            config.setPassword(packet.password !=  ? packet.password : );
            HytaleServerConfig.save(config);
         }

         SingleplayerModule.get().requestServerAccess(packet.access);
      }
   }

      {
         (ModelAsset)ModelAsset.getAssetMap().getAsset(packet.modelId);
      .writeNoCache( (Model.createUnitScaleModel(modelAsset).toPacket(), packet.sceneName, packet.actorName));
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
                (.playerRef.getUsername(), packet.sceneName, packet.frame, packet.updateType, packet.scene);
             (.equals(packet.player)) {
               (PlayerRef otherPlayerRef : world.getPlayerRefs()) {
                   (!Objects.equals(otherPlayerRef, .playerRef)) {
                     otherPlayerRef.getPacketHandler().writeNoCache(updatePacket);
                  }
               }

               .playerRef.sendMessage(Message.translation());
            }  {
                  (PlayerRef)NameMatching.DEFAULT.find(Universe.get().getPlayers(), packet.player, PlayerRef::getUsername);
                (target !=  && ((EntityStore)target.getReference().getStore().getExternalData()).getWorld() == world) {
                  target.getPacketHandler().write((Packet)updatePacket);
                  .playerRef.sendMessage(Message.translation().param(, target.getUsername()));
               }  {
                  .playerRef.sendMessage(Message.translation().param(, packet.player));
               }
            }

         });
      }
   }

      {
      HytaleLogger.getLogger().at(Level.WARNING).log(, .getIdentifier(), packet);
      CompletableFuture<Void> future = .clientReadyForChunksFuture;
       (packet.readyForChunks && !packet.readyForGameplay && future != ) {
         .clientReadyForChunksFutureStack = ;
         .clientReadyForChunksFuture = ;
         future.completeAsync(() -> );
      }

       (packet.readyForGameplay) {
         Ref<EntityStore> ref = .playerRef.getReference();
          (ref ==  || !ref.isValid()) {
            ;
         }

         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

            playerComponent.handleClientReady();
         });
      }

   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

            playerComponent.getWorldMapTracker().setClientHasWorldMapVisible(packet.visible);
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

               playerComponent.getWorldMapTracker();
             (!worldMapTracker.isAllowTeleportToMarkers()) {
               .disconnect();
            }  {
                  (MapMarker)worldMapTracker.getSentMarkers().get(packet.id);
                (marker != ) {
                     PositionUtil.toTransform(marker.transform);
                     Teleport.createForPlayer(transform);
                  world.getEntityStore().getStore().addComponent(.playerRef.getReference(), Teleport.getComponentType(), teleportComponent);
               }

            }
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

               playerComponent.getWorldMapTracker();
             (!worldMapTracker.isAllowTeleportToCoordinates()) {
               .disconnect();
            }  {
               world.getChunkStore().getChunkReferenceAsync(ChunkUtil.indexChunkFromBlock(packet.x, packet.y)).thenAcceptAsync((chunkRef) -> {
                     (BlockChunk)world.getChunkStore().getStore().getComponent(chunkRef, BlockChunk.getComponentType());

                   blockChunkComponent != ;

                      (()packet.x, ()(blockChunkComponent.getHeight(packet.x, packet.y) + ), ()packet.y);
                     Teleport.createForPlayer((World), position,  (, , ));
                  world.getEntityStore().getStore().addComponent(.playerRef.getReference(), Teleport.getComponentType(), teleportComponent);
               }, world);
            }
         });
      }
   }

      {
      Collections.addAll(.interactionPacketQueue, packet.updates);
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

            Ref<EntityStore> entityReference = world.getEntityStore().getRefFromNetworkId(playerComponent.getMountEntityId());
             (entityReference !=  && entityReference.isValid()) {
                  (TransformComponent)store.getComponent(entityReference, TransformComponent.getComponentType());

                transformComponent != ;

               transformComponent.setPosition(PositionUtil.toVector3d(packet.absolutePosition));
               transformComponent.setRotation(PositionUtil.toRotation(packet.bodyOrientation));
                  (MovementStatesComponent)store.getComponent(entityReference, MovementStatesComponent.getComponentType());

                movementStatesComponent != ;

               movementStatesComponent.setMovementStates(packet.movementStates);
            }
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
             (world.getPlayerCount() ==  && Constants.SINGLEPLAYER) {
               world.setPaused(packet.paused);
            }
         });
      }
   }

      {
      Ref<EntityStore> ref = .playerRef.getReference();
       (ref !=  && ref.isValid()) {
         Store<EntityStore> store = ref.getStore();
            ((EntityStore)store.getExternalData()).getWorld();
         world.execute(() -> {
               (Player)store.getComponent(ref, Player.getComponentType());

             playerComponent != ;

             (playerComponent.hasPermission()) {
               .writeNoCache( (packet.entering));
                (packet.entering) {
                  .playerRef.sendMessage(Message.translation());
               }  {
                  .playerRef.sendMessage(Message.translation());
               }
            }  {
               .playerRef.sendMessage(Message.translation());
            }

         });
      }
   }
}