Entity.java

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

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.DirectDecodeCodec;
import com.hypixel.hytale.codec.ExtraInfo;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.component.Archetype;
import com.hypixel.hytale.component.Component;
import com.hypixel.hytale.component.ComponentAccessor;
import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.component.NonSerialized;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.RemoveReason;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.event.IEventDispatcher;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.protocol.MovementStates;
import com.hypixel.hytale.server.core.HytaleServer;
import com.hypixel.hytale.server.core.asset.type.model.config.Model;
import com.hypixel.hytale.server.core.entity.entities.Player;
import com.hypixel.hytale.server.core.event.events.entity.EntityRemoveEvent;
import com.hypixel.hytale.server.core.modules.entity.EntityModule;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
 com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 java.util.Arrays;
 java.util.UUID;
 java.util.concurrent.CompletableFuture;
 java.util.concurrent.TimeUnit;
 java.util.concurrent.atomic.AtomicBoolean;
 java.util.function.Function;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;
 org.bson.BsonDocument;
 org.bson.BsonString;
 org.bson.BsonValue;

     <EntityStore> {
   
         HytaleLogger.forEnclosingClass();
         ;
   
      KeyedCodec<Model.ModelReference> MODEL;
   
      KeyedCodec<String> DISPLAY_NAME;
   
      KeyedCodec<UUID> UUID;
   
      BuilderCodec<Entity> CODEC;
         -;
     networkId;
   
    UUID legacyUuid;
   
    World world;
   
    Ref<EntityStore> reference;
   
   
    TransformComponent transformComponent;
   
   
    String legacyDisplayName;
   
     AtomicBoolean wasRemoved;
   
    Throwable removedBy;

   
   
     {
      ();
      .networkId = world !=  ? world.getEntityStore().takeNextNetworkId() : -;
      .world = world;
   }

     {
      .networkId = -;
      .wasRemoved =  ();
   }

   
   
      {
       (.transformComponent != ) {
            .transformComponent.getChunk();
          (chunk != ) {
            chunk.getEntityChunk().markNeedsSaving();
         }

      }
   }

      {
      .legacyUuid = uuid;
   }

      {
      .world.debugAssertInTickingThread();
       (.wasRemoved.getAndSet()) {
          ;
      }  {
         .removedBy =  ();

          {
               .world !=  ? .world.getName() : ;
            IEventDispatcher<EntityRemoveEvent, EntityRemoveEvent> dispatcher = HytaleServer.get().getEventBus().dispatchFor(EntityRemoveEvent.class, key);
             (dispatcher.hasListener()) {
               dispatcher.dispatch( ());
            }

             (.reference.isValid()) {
               .world.getEntityStore().getStore().removeEntity(.reference, RemoveReason.REMOVE);
            }
         }  (Throwable var3) {
            .wasRemoved.set();
         }

          ;
      }
   }

      {
       (.world != ) {
           ( + String.valueOf());
      }  {
         .world = world;
          (.networkId == -) {
            .networkId = world.getEntityStore().takeNextNetworkId();
         }

      }
   }

      {
       (.world == ) {
           ( + String.valueOf());
      }  {
         .networkId = -;
         .world = ;
      }
   }

   
   
      {
       .networkId;
   }

   
   
    String  {
       .legacyDisplayName;
   }

   
   
   
    UUID  {
       .legacyUuid;
   }

   
   
      {
      .transformComponent = transform;
   }

   
   
    TransformComponent  {
       (.world !=  && .reference != ) {
          (!.world.isInThread()) {
            ((HytaleLogger.Api)((HytaleLogger.Api)LOGGER.at(Level.WARNING).atMostEvery(, TimeUnit.MINUTES)).withCause( ())).log();
             .transformComponent;
         }  {
            Store<EntityStore> store = .world.getEntityStore().getStore();
               (TransformComponent)store.getComponent(.reference, TransformComponent.getComponentType());

             transformComponent != ;

             transformComponent;
         }
      }  {
           ();
      }
   }

   
   
      {
         (TransformComponent)componentAccessor.getComponent(ref, TransformComponent.getComponentType());

       transformComponent != ;

      transformComponent.getPosition().assign(locX, locY, locZ);
   }

   
    World  {
       .world;
   }

      {
       .wasRemoved.get();
   }

      {
       ;
   }

      {
         .networkId;
      result =  * result + (.world !=  ? .world.hashCode() : );
       result;
   }

      {
       ( == o) {
          ;
      }   (o !=  && .getClass() == o.getClass()) {
            (Entity)o;
          (.networkId != entity.networkId) {
             ;
         }  {
             .world !=  ? .world.equals(entity.world) : entity.world == ;
         }
      }  {
          ;
      }
   }

   
    String  {
         .networkId;
        + var10000 +  + String.valueOf(.legacyUuid) +  + String.valueOf(.reference) +  + (.world !=  ? .world.getName() : ) +  + .legacyDisplayName +  + String.valueOf(.wasRemoved) +  + (.removedBy !=  ? String.valueOf(.removedBy) +  + Arrays.toString(.removedBy.getStackTrace()) : ) + ;
   }

      {
       ;
   }

      {
       (.reference !=  && .reference.isValid()) {
            String.valueOf(.reference);
           ( + var10002 +  + String.valueOf(reference));
      }  {
         .reference = reference;
      }
   }

   
    Ref<EntityStore>  {
       .reference;
   }

   
   
      {
      .reference = ;
   }

    Component<EntityStore>  {
      DirectDecodeCodec<Entity> codec = EntityModule.get().<Entity>getCodec(.getClass());
      Function<World, Entity> constructor = EntityModule.get().getConstructor(.getClass());
         codec.encode(, (ExtraInfo)ExtraInfo.THREAD_LOCAL.get()).asDocument();
      document.put((String), (BsonValue)( (EntityModule.get().getIdentifier(.getClass()))));
         (Entity)constructor.apply((Object));
      codec.decode(document, t, (ExtraInfo)ExtraInfo.THREAD_LOCAL.get());
       t;
   }

    Holder<EntityStore>  {
       (.reference !=  && .reference.isValid() && .world != ) {
          (!.world.isInThread()) {
             (Holder)CompletableFuture.supplyAsync(::toHolder, .world).join();
         }  {
            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
            Store<EntityStore> componentStore = .world.getEntityStore().getStore();
            Archetype<EntityStore> archetype = componentStore.getArchetype(.reference);

            (   archetype.getMinIndex(); i < archetype.length(); ++i) {
                  archetype.get(i);
                (componentType != ) {
                     componentStore.getComponent(.reference, componentType);

                   component != ;

                  holder.addComponent(componentType, component);
               }
            }

             holder;
         }
      }  {
         Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
          (  Player) {
            holder.addComponent(Player.getComponentType(), (Player));
         }  {
            ComponentType<EntityStore, ?  > componentType = EntityModule.get().getComponentType(.getClass());
            holder.addComponent(componentType, );
         }

         DirectDecodeCodec<?  > codec = EntityModule.get().<Entity>getCodec(.getClass());
          (codec == ) {
            holder.addComponent(EntityStore.REGISTRY.getNonSerializedComponentType(), NonSerialized.get());
         }

          holder;
      }
   }

    {
      MODEL =  <Model.ModelReference>(, Model.ModelReference.CODEC);
      DISPLAY_NAME =  <String>(, Codec.STRING);
      UUID =  <UUID>(, Codec.UUID_BINARY);
      CODEC = ((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)((BuilderCodec.Builder)BuilderCodec.abstractBuilder(Entity.class).legacyVersioned()).codecVersion()).append(DISPLAY_NAME, (entity, o) -> entity.legacyDisplayName = o, (entity) -> entity.legacyDisplayName).add()).append(UUID, (entity, o) -> entity.legacyUuid = o, (entity) -> entity.legacyUuid).add()).build();
   }

       {
      
            ;
      
            ;
      
            ;
      
            ;
      
            ;

        {
      }

      
        String[] getHurtAnimationIds( MovementStates movementStates,  DamageCause damageCause) {
            damageCause.getAnimationId();
          (movementStates.swimming) {
              []{animationId + , animationId, };
         }  {
             movementStates.flying ?  []{animationId + , animationId, } :  []{animationId, };
         }
      }

      
        String[] getDeathAnimationIds( MovementStates movementStates,  DamageCause damageCause) {
            damageCause.getDeathAnimationId();
          (movementStates.swimming) {
              []{animationId + , animationId, };
         }  {
             movementStates.flying ?  []{animationId + , animationId, } :  []{animationId, };
         }
      }
   }
}