EntityChunk.java

package com.hypixel.hytale.server.core.universe.world.chunk;

import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
import com.hypixel.hytale.codec.store.StoredCodec;
import com.hypixel.hytale.component.AddReason;
import com.hypixel.hytale.component.Archetype;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Component;
import com.hypixel.hytale.component.ComponentRegistry;
import com.hypixel.hytale.component.ComponentType;
import com.hypixel.hytale.component.Holder;
import com.hypixel.hytale.component.NonTicking;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.RemoveReason;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.component.query.Query;
import com.hypixel.hytale.component.system.RefChangeSystem;
import com.hypixel.hytale.logger.HytaleLogger;
import com.hypixel.hytale.server.core.entity.Entity;
import com.hypixel.hytale.server.core.entity.EntityUtils;
import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
import com.hypixel.hytale.server.core.modules.LegacyModule;
import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
 com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
 it.unimi.dsi.fastutil.objects.ObjectArrayList;
 java.util.Arrays;
 java.util.Collections;
 java.util.HashSet;
 java.util.Iterator;
 java.util.List;
 java.util.Objects;
 java.util.Set;
 java.util.logging.Level;
 javax.annotation.Nonnull;
 javax.annotation.Nullable;

    <ChunkStore> {
   
      BuilderCodec<EntityChunk> CODEC;
   
     List<Holder<EntityStore>> entityHolders;
   
     Set<Ref<EntityStore>> entityReferences;
   
     List<Holder<EntityStore>> entityHoldersUnmodifiable;
   
     Set<Ref<EntityStore>> entityReferencesUnmodifiable;
     needsSaving;

   
     ComponentType<ChunkStore, EntityChunk>  {
       LegacyModule.get().getEntityChunkComponentType();
   }

     {
      .entityHolders =  <Holder<EntityStore>>();
      .entityReferences =  ();
      .entityHoldersUnmodifiable = Collections.unmodifiableList(.entityHolders);
      .entityReferencesUnmodifiable = Collections.unmodifiableSet(.entityReferences);
   }

     {
      .entityHolders = entityHolders;
      .entityReferences = entityReferences;
      .entityHoldersUnmodifiable = Collections.unmodifiableList(entityHolders);
      .entityReferencesUnmodifiable = Collections.unmodifiableSet(entityReferences);
   }

   
    Component<ChunkStore>  {
      ObjectArrayList<Holder<EntityStore>> entityHoldersClone =  <Holder<EntityStore>>(.entityHolders.size() + .entityReferences.size());

      (Holder<EntityStore> entityHolder : .entityHolders) {
         entityHoldersClone.add(entityHolder.clone());
      }

      (Ref<EntityStore> reference : .entityReferences) {
         entityHoldersClone.add(reference.getStore().copyEntity(reference));
      }

        (entityHoldersClone,  ());
   }

   
    Component<ChunkStore>  {
      ComponentRegistry.Data<EntityStore> data = EntityStore.REGISTRY.getData();
      ObjectArrayList<Holder<EntityStore>> entityHoldersClone =  <Holder<EntityStore>>(.entityHolders.size() + .entityReferences.size());

      (Holder<EntityStore> entityHolder : .entityHolders) {
          (entityHolder.getArchetype().hasSerializableComponents(data)) {
            entityHoldersClone.add(entityHolder.cloneSerializable(data));
         }
      }

      (Ref<EntityStore> reference : .entityReferences) {
         Store<EntityStore> store = reference.getStore();
          (store.getArchetype(reference).hasSerializableComponents(data)) {
            entityHoldersClone.add(store.copySerializableEntity(reference));
         }
      }

        (entityHoldersClone,  ());
   }

   
    List<Holder<EntityStore>>  {
       .entityHoldersUnmodifiable;
   }

      {
      .entityHolders.add((Holder)Objects.requireNonNull(holder));
      .markNeedsSaving();
   }

      {
      .entityHolders.add((Holder)Objects.requireNonNull(holder));
   }

   
    Set<Ref<EntityStore>>  {
       .entityReferencesUnmodifiable;
   }

      {
      .entityReferences.add((Ref)Objects.requireNonNull(reference));
      .markNeedsSaving();
   }

      {
      .entityReferences.add((Ref)Objects.requireNonNull(reference));
   }

      {
      .entityReferences.remove(Objects.requireNonNull(reference));
      .markNeedsSaving();
   }

      {
      .entityReferences.remove(Objects.requireNonNull(reference));
   }

   
    Holder<EntityStore>[] takeEntityHolders() {
       (.entityHolders.isEmpty()) {
          ;
      }  {
         Holder<EntityStore>[] holders = (Holder[]).entityHolders.toArray((x$) ->  [x$]);
         .entityHolders.clear();
          holders;
      }
   }

   
    Ref<EntityStore>[] takeEntityReferences() {
       (.entityReferences.isEmpty()) {
          ;
      }  {
         Ref<EntityStore>[] holders = (Ref[]).entityReferences.toArray((x$) ->  [x$]);
         .entityReferences.clear();
          holders;
      }
   }

      {
       .needsSaving;
   }

      {
      .needsSaving = ;
   }

      {
         .needsSaving;
      .needsSaving = ;
       out;
   }

   
   
   
    Iterable<Entity>  {
       (.entityReferences.isEmpty()) {
          Collections.emptyList();
      }  {
         Ref<EntityStore>[] references = (Ref[]).entityReferences.toArray((x$) ->  [x$]);
          () ->  <Entity>() {
                  references.length;

                  {
                   (.index <= ) {
                      ;
                  }  {
                     (Ref<EntityStore> reference = references[.index - ]; !reference.isValid() || EntityUtils.getEntity(reference, reference.getStore()) == ; reference = references[.index - ]) {
                        --.index;
                         (.index <= ) {
                            ;
                        }
                     }

                      ;
                  }
               }

                Entity  {
                  Ref<EntityStore> reference = references[--.index];
                   EntityUtils.getEntity(reference, reference.getStore());
               }
            };
      }
   }

    {
      CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(EntityChunk.class, EntityChunk::).addField( (,  ( (EntityStore.HOLDER_CODEC_KEY), (x$) ->  [x$])), (entityChunk, array) -> {
         entityChunk.entityHolders.clear();
         Collections.addAll(entityChunk.entityHolders, array);
      }, (entityChunk) -> {
          (entityChunk.entityReferences.isEmpty()) {
             (Holder[])entityChunk.entityHolders.toArray( [entityChunk.entityHolders.size()]);
         }  {
            Holder<EntityStore>[] array =  [entityChunk.entityHolders.size() + entityChunk.entityReferences.size()];
            array = (Holder[])entityChunk.entityHolders.toArray(array);
               entityChunk.entityHolders.size();

            (Ref<EntityStore> reference : entityChunk.entityReferences) {
               Store<EntityStore> store = reference.getStore();
                (store.getArchetype(reference).hasSerializableComponents(store.getRegistry().getData())) {
                  array[index++] = store.copyEntity(reference);
               }
            }

             index == array.length ? array : (Holder[])Arrays.copyOfRange(array, , index);
         }
      })).build();
   }

        <ChunkStore, NonTicking<ChunkStore>> {
      
            HytaleLogger.forEnclosingClass();
      
        Archetype<ChunkStore> archetype = Archetype.of(WorldChunk.getComponentType(), EntityChunk.getComponentType());

        {
      }

       Query<ChunkStore>  {
          .archetype;
      }

      
       ComponentType<ChunkStore, NonTicking<ChunkStore>>  {
          ChunkStore.REGISTRY.getNonTickingComponentType();
      }

         {
            ((ChunkStore)store.getExternalData()).getWorld();
            (EntityChunk)store.getComponent(ref, EntityChunk.getComponentType());

          entityChunkComponent != ;

         Ref<EntityStore>[] references = entityChunkComponent.takeEntityReferences();
          (references != ) {
            Store<EntityStore> entityStore = world.getEntityStore().getStore();
            Holder<EntityStore>[] holders = entityStore.removeEntities(references, RemoveReason.UNLOAD);
            ComponentRegistry.Data<EntityStore> data = EntityStore.REGISTRY.getData();

            (   ; i < holders.length; ++i) {
               Holder<EntityStore> holder = holders[i];
                (holder.hasSerializableComponents(data)) {
                  entityChunkComponent.storeEntityHolder(holder);
               }
            }

         }
      }

         {
      }

         {
            ((ChunkStore)store.getExternalData()).getWorld();
            (WorldChunk)store.getComponent(ref, WorldChunk.getComponentType());

          worldChunkComponent != ;

            (EntityChunk)store.getComponent(ref, EntityChunk.getComponentType());

          entityChunkComponent != ;

         Store<EntityStore> entityStore = world.getEntityStore().getStore();
         Holder<EntityStore>[] holders = entityChunkComponent.takeEntityHolders();
          (holders != ) {
               holders.length;

            (   holderCount - ; i >= ; --i) {
               Holder<EntityStore> holder = holders[i];
               Archetype<EntityStore> archetype = holder.getArchetype();

                archetype != ;

                (archetype.isEmpty()) {
                  LOGGER.at(Level.SEVERE).log(, holder, i);
                  --holderCount;
                  holders[i] = holders[holderCount];
                  holders[holderCount] = holder;
                  worldChunkComponent.markNeedsSaving();
               }   (archetype.count() ==  && archetype.contains(Nameplate.getComponentType())) {
                  LOGGER.at(Level.SEVERE).log(, holder, i);
                  --holderCount;
                  holders[i] = holders[holderCount];
                  holders[holderCount] = holder;
                  worldChunkComponent.markNeedsSaving();
               }  {
                     (TransformComponent)holder.getComponent(TransformComponent.getComponentType());

                   transformComponent != ;

                  transformComponent.setChunkLocation(ref, worldChunkComponent);
               }
            }

            Ref<EntityStore>[] refs = entityStore.addEntities(holders, , holderCount, AddReason.LOAD);

            (   ; i < refs.length; ++i) {
               Ref<EntityStore> entityRef = refs[i];
                (!entityRef.isValid()) {
                  ;
               }

               entityChunkComponent.loadEntityReference(entityRef);
            }

         }
      }
   }
}