class="kw">package com.hypixel.hytale.server.core.modules.entitystats;

class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
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.RemoveReason;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemGroup;
class="kw">import com.hypixel.hytale.component.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.dependency.SystemTypeDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.ISystem;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.protocol.ComponentUpdateType;
class="kw">import com.hypixel.hytale.protocol.EntityStatUpdate;
class="kw">import com.hypixel.hytale.protocol.EntityStatsUpdate;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionChain;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionManager;
class="kw">import com.hypixel.hytale.server.core.entity.LivingEntity;
class="kw">import com.hypixel.hytale.server.core.inventory.InventoryComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
class="kw">import com.hypixel.hytale.server.core.modules.entity.AllLegacyLivingEntityTypesQuery;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Invulnerable;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.DefaultEntityStatTypes;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.floats.FloatList;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import java.time.Instant;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

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

   class="kw">public class="kw">static class Changes class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> componentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
         new SystemDependency<>(Order.BEFORE, EntityStatsSystems.EntityTrackerUpdate.class),
         new SystemTypeDependency<EntityStore, EntityStatsSystems.StatModifyingSystem>(Order.AFTER, EntityStatsModule.get().getStatModifyingSystemType())
      );

      class="kw">public Changes(ComponentType<EntityStore, EntityStatMap> var1) {
         this.componentType = var1;
         this.query = Query.and(var1, InteractionModule.get().getInteractionManagerComponent(), AllLegacyLivingEntityTypesQuery.INSTANCE);
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return false;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         Ref var6 = var3.getReferenceTo(var2);
         EntityStatMap var7 = var3.getComponent(var2, this.componentType);
         assert var7 != null;
         InteractionManager var8 = var3.getComponent(var2, InteractionModule.get().getInteractionManagerComponent());
         assert var8 != null;
         boolean var9 = var3.getArchetype().contains(DeathComponent.getComponentType());
         Int2ObjectMap var10 = var7.getSelfUpdates();
         Int2ObjectMap var11 = var7.getSelfStatValues();

         for (int var12 = 0; var12 < var7.size(); var12++) {
            List var13 = (List<EntityStatUpdate>)var10.get(var12);
            if (var13 != null && !var13.isEmpty()) {
               FloatList var14 = (FloatList)var11.get(var12);
               EntityStatValue var15 = var7.get(var12);
               if (var15 != null) {
                  EntityStatType var16 = EntityStatType.getAssetMap().getAsset(var12);

                  for (int var17 = 0; var17 < var13.size(); var17++) {
                     EntityStatUpdate var18 = var13.get(var17);
                     float var19 = var14.getFloat(var17 * 2);
                     float var20 = var14.getFloat(var17 * 2 + 1);
                     if (testMaxValue(var20, var19, var15, var16.getMaxValueEffects())) {
                        runInteractions(var6, var8, var16.getMaxValueEffects(), var5);
                     }

                     if (testMinValue(var20, var19, var15, var16.getMinValueEffects())) {
                        runInteractions(var6, var8, var16.getMinValueEffects(), var5);
                     }

                     if (!var9 && var12 == DefaultEntityStatTypes.getHealth() && !(var18.value > 0.0F) && var20 <= var15.getMin()) {
                        DeathComponent.tryAddComponent(var5, var3.getReferenceTo(var2), new Damage(Damage.NULL_SOURCE, DamageCause.COMMAND, 0.0F));
                        var9 = true;
                     }
                  }
               }
            }
         }
      }

      class="kw">private class="kw">static boolean testMaxValue(float var0, float var1, @Nonnull EntityStatValue var2, @Nullable EntityStatType.EntityStatEffects var3) {
         if (var3 == null) {
            class="kw">return false;
         } else {
            class="kw">return var3.triggerAtZero() && var2.getMax() > 0.0F ? var1 < 0.0F && var0 >= 0.0F : var1 != var2.getMax() && var0 == var2.getMax();
         }
      }

      class="kw">private class="kw">static boolean testMinValue(float var0, float var1, @Nonnull EntityStatValue var2, @Nullable EntityStatType.EntityStatEffects var3) {
         if (var3 == null) {
            class="kw">return false;
         } else {
            class="kw">return var3.triggerAtZero() && var2.getMin() < 0.0F ? var1 > 0.0F && var0 < 0.0F : var1 != var2.getMin() && var0 == var2.getMin();
         }
      }

      class="kw">private class="kw">static void runInteractions(
         @Nonnull Ref<EntityStore> var0,
         @Nonnull InteractionManager var1,
         @Nullable EntityStatType.EntityStatEffects var2,
         @Nonnull ComponentAccessor<EntityStore> var3
      ) {
         if (var2 != null) {
            String var4 = var2.getInteractions();
            if (var4 != null) {
               InteractionContext var5 = InteractionContext.forInteraction(var1, var0, InteractionType.EntityStatEffect, var3);
               InteractionChain var6 = var1.initChain(InteractionType.EntityStatEffect, var5, RootInteraction.getRootInteractionOrUnknown(var4), true);
               var1.queueExecuteChain(var6);
            }
         }
      }
   }

   class="kw">public class="kw">static class ClearChanges class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> componentType;
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, EntityStatsSystems.EntityTrackerUpdate.class));

      class="kw">public ClearChanges(ComponentType<EntityStore, EntityStatMap> var1) {
         this.componentType = var1;
      }

      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.componentType;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityStatMap var6 = var3.getComponent(var2, this.componentType);
         var6.clearUpdates();
      }
   }

   class="kw">public class="kw">static class EntityTrackerRemove class="kw">extends RefChangeSystem<EntityStore, EntityStatMap> {
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> componentType;
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType = EntityTrackerSystems.Visible.getComponentType();
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public EntityTrackerRemove(ComponentType<EntityStore, EntityStatMap> var1) {
         this.componentType = var1;
         this.query = Query.and(this.visibleComponentType, var1);
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public ComponentType<EntityStore, EntityStatMap> componentType() {
         class="kw">return this.componentType;
      }

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull EntityStatMap var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1,
         EntityStatMap var2,
         @Nonnull EntityStatMap var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<EntityStore> var1, @Nonnull EntityStatMap var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         for (EntityTrackerSystems.EntityViewer var6 : var3.getComponent(var1, this.visibleComponentType).visibleTo.values()) {
            var6.queueRemove(var1, ComponentUpdateType.EntityStats);
         }
      }
   }

   class="kw">public class="kw">static class EntityTrackerUpdate class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> componentType;
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType = EntityTrackerSystems.Visible.getComponentType();
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(
         new SystemDependency<>(Order.BEFORE, EntityTrackerSystems.EffectControllerSystem.class),
         new SystemTypeDependency<EntityStore, EntityStatsSystems.StatModifyingSystem>(Order.AFTER, EntityStatsModule.get().getStatModifyingSystemType())
      );

      class="kw">public EntityTrackerUpdate(ComponentType<EntityStore, EntityStatMap> var1) {
         this.componentType = var1;
         this.query = Query.and(this.visibleComponentType, var1);
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityTrackerSystems.QUEUE_UPDATE_GROUP;
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         Ref var6 = var3.getReferenceTo(var2);
         EntityTrackerSystems.Visible var7 = var3.getComponent(var2, this.visibleComponentType);
         EntityStatMap var8 = var3.getComponent(var2, this.componentType);
         if (!var7.newlyVisibleTo.isEmpty()) {
            queueUpdatesForNewlyVisible(var6, var8, var7.newlyVisibleTo);
         }

         if (var8.consumeSelfNetworkOutdated()) {
            EntityTrackerSystems.EntityViewer var9 = var7.visibleTo.get(var6);
            if (var9 != null && !var7.newlyVisibleTo.containsKey(var6)) {
               EntityStatsUpdate var10 = new EntityStatsUpdate(var8.consumeSelfUpdates());
               var9.queueUpdate(var6, var10);
            }
         }

         if (var8.consumeNetworkOutdated()) {
            EntityStatsUpdate var13 = new EntityStatsUpdate(var8.consumeOtherUpdates());

            for (Entry var11 : var7.visibleTo.entrySet()) {
               Ref var12 = var11.getKey();
               if (!var7.newlyVisibleTo.containsKey(var12) && !var6.equals(var12)) {
                  var11.getValue().queueUpdate(var6, var13);
               }
            }
         }
      }

      class="kw">private class="kw">static void queueUpdatesForNewlyVisible(
         @Nonnull Ref<EntityStore> var0, @Nonnull EntityStatMap var1, @Nonnull Map<Ref<EntityStore>, EntityTrackerSystems.EntityViewer> var2
      ) {
         EntityStatsUpdate var3 = new EntityStatsUpdate(var1.createInitUpdate(false));

         for (Entry var5 : var2.entrySet()) {
            if (var0.equals(var5.getKey())) {
               queueUpdateForNewlyVisibleSelf(var0, var1, var5.getValue());
            } else {
               var5.getValue().queueUpdate(var0, var3);
            }
         }
      }

      class="kw">private class="kw">static void queueUpdateForNewlyVisibleSelf(Ref<EntityStore> var0, @Nonnull EntityStatMap var1, @Nonnull EntityTrackerSystems.EntityViewer var2) {
         EntityStatsUpdate var3 = new EntityStatsUpdate(var1.createInitUpdate(true));
         var2.queueUpdate(var0, var3);
      }
   }

   class="kw">public class="kw">static class Recalculate class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> entityStatMapComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public Recalculate(@Nonnull ComponentType<EntityStore, EntityStatMap> var1) {
         this.entityStatMapComponentType = var1;
         this.query = Query.and(AllLegacyLivingEntityTypesQuery.INSTANCE, var1);
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         EntityStatMap var6 = var3.getComponent(var2, this.entityStatMapComponentType);
         assert var6 != null;
         Ref var7 = var3.getReferenceTo(var2);
         var6.getStatModifiersManager().recalculateEntityStatModifiers(var7, var6, var5);
      }
   }

   class="kw">public class="kw">static class Regenerate<EntityType class="kw">extends LivingEntity> class="kw">extends EntityTickingSystem<EntityStore> class="kw">implements EntityStatsSystems.StatModifyingSystem {
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> componentType;
      class="kw">private class="kw">final ComponentType<EntityStore, EntityType> entityTypeComponent;
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public Regenerate(ComponentType<EntityStore, EntityStatMap> var1, ComponentType<EntityStore, EntityType> var2) {
         this.componentType = var1;
         this.entityTypeComponent = var2;
         this.query = Query.and(var1, var2);
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return false;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         Ref var6 = var3.getReferenceTo(var2);
         EntityStatMap var7 = var3.getComponent(var2, this.componentType);
         assert var7 != null;
         Instant var8 = var4.getResource(TimeResource.getResourceType()).getNow();
         int var9 = var7.size();
         if (var7.tempRegenerationValues.length < var9) {
            var7.tempRegenerationValues = new float[var9];
         }

         for (int var10 = 1; var10 < var9; var10++) {
            EntityStatValue var11 = var7.get(var10);
            if (var11 != null) {
               var7.tempRegenerationValues[var10] = 0.0F;
               RegeneratingValue[] var12 = var11.getRegeneratingValues();
               if (var12 != null) {
                  for (RegeneratingValue var16 : var12) {
                     if (var16.getRegenerating().getAmount() > 0.0F ? !(var11.get() >= var11.getMax()) : !(var11.get() <= var11.getMin())) {
                        var7.tempRegenerationValues[var10] = var7.tempRegenerationValues[var10]
                           + var16.regenerate(var5, var6, var8, var1, var11, var7.tempRegenerationValues[var10]);
                     }
                  }
               }
            }
         }

         InventoryComponent.Armor var21 = var5.getComponent(var6, InventoryComponent.Armor.getComponentType());
         if (var21 != null) {
            ItemContainer var22 = var21.getInventory();
            short var23 = var22.getCapacity();

            for (short var24 = 0; var24 < var23; var24++) {
               ItemStack var26 = var22.getItemStack(var24);
               if (!ItemStack.isEmpty(var26)) {
                  Item var28 = var26.getItem();
                  if (var28.getArmor() != null && var28.getArmor().getRegeneratingValues() != null && !var28.getArmor().getRegeneratingValues().isEmpty()) {
                     for (int var30 = 1; var30 < var9; var30++) {
                        EntityStatValue var17 = var7.get(var30);
                        if (var17 != null) {
                           List var18 = (List<RegeneratingValue>)var28.getArmor().getRegeneratingValues().get(var30);
                           if (var18 != null && !var18.isEmpty()) {
                              for (RegeneratingValue var20 : var18) {
                                 if (var20.getRegenerating().getAmount() > 0.0F ? !(var17.get() >= var17.getMax()) : !(var17.get() <= var17.getMin())) {
                                    var7.tempRegenerationValues[var30] = var7.tempRegenerationValues[var30]
                                       + var20.regenerate(var5, var6, var8, var1, var17, var7.tempRegenerationValues[var30]);
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }

            for (int var25 = 1; var25 < var9; var25++) {
               EntityStatValue var27 = var7.get(var25);
               if (var27 != null) {
                  float var29 = var7.tempRegenerationValues[var25];
                  boolean var31 = var5.getArchetype(var6).contains(Invulnerable.getComponentType());
                  if ((!(var29 < 0.0F) || var27.getIgnoreInvulnerability() || !var31) && var29 != 0.0F) {
                     var7.addStatValue(var25, var29);
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class Setup class="kw">extends HolderSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, EntityStatMap> componentType;

      class="kw">public Setup(ComponentType<EntityStore, EntityStatMap> var1) {
         this.componentType = var1;
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return AllLegacyLivingEntityTypesQuery.INSTANCE;
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         EntityStatMap var4 = var1.getComponent(this.componentType);
         if (var4 == null) {
            var4 = var1.ensureAndGetComponent(this.componentType);
            var4.update();
         }
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
      }
   }

   class="kw">public class="kw">interface StatModifyingSystem class="kw">extends ISystem<EntityStore> {
   }
}