DamageCalculatorSystems.java

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

import com.hypixel.hytale.codec.Codec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.component.Archetype;
import com.hypixel.hytale.component.ArchetypeChunk;
import com.hypixel.hytale.component.CommandBuffer;
import com.hypixel.hytale.component.Ref;
import com.hypixel.hytale.component.Store;
import com.hypixel.hytale.component.dependency.Dependency;
import com.hypixel.hytale.component.dependency.Order;
import com.hypixel.hytale.component.dependency.SystemDependency;
import com.hypixel.hytale.component.dependency.SystemGroupDependency;
import com.hypixel.hytale.component.query.Query;
import com.hypixel.hytale.server.core.asset.type.gameplay.BrokenPenalties;
import com.hypixel.hytale.server.core.inventory.ItemStack;
import com.hypixel.hytale.server.core.meta.MetaKey;
import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.DamageEntityInteraction;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageCalculator;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
import it.unimi.dsi.fastutil.objects.Object2FloatMap;
import java.util.Set;
import javax.annotation.Nonnull;
 javax.annotation.Nullable;

   {
   
     MetaKey<DamageSequence> DAMAGE_SEQUENCE;

     {
   }

   
     Damage[] queueDamageCalculator( World world,  Object2FloatMap<DamageCause> relativeDamage,  Ref<EntityStore> ref,  CommandBuffer<EntityStore> commandBuffer,  Damage.Source source,  ItemStack itemInHand) {
      Damage[] results =  [relativeDamage.size()];
         ;

      (DamageCause damageCause : relativeDamage.keySet()) {
            relativeDamage.getFloat(damageCause);
          (damageCause == DamageCause.PHYSICAL && itemInHand !=  && itemInHand.isBroken()) {
               world.getGameplayConfig().getItemDurabilityConfig().getBrokenPenalties();
            damageAmount *= ()( - brokenPenalties.getWeapon());
         }

             (source, damageCause, damageAmount);
         damage.getMetaStore().putMetaObject(Damage.CAN_BE_PREDICTED, Boolean.TRUE);
         results[offset++] = damage;
      }

       results;
   }

    {
      DAMAGE_SEQUENCE = Damage.META_REGISTRY.registerMetaObject();
   }

         {
      
        Set<Dependency<EntityStore>> dependencies;

        {
         .dependencies = Set.of( (Order.AFTER, DamageModule.get().getGatherDamageGroup()),  (Order.AFTER, DamageModule.get().getFilterDamageGroup()),  (Order.BEFORE, DamageSystems.ApplyDamage.class));
      }

      
       Set<Dependency<EntityStore>>  {
          .dependencies;
      }

      
       Query<EntityStore>  {
          Archetype.<EntityStore>empty();
      }

         {
          (!(damage.getAmount() <= )) {
               (DamageSequence)damage.getIfPresentMetaObject(DamageCalculatorSystems.DAMAGE_SEQUENCE);
             (damageSequence != ) {
                  damageSequence.getDamageCalculator();
                (damageSequence.getSequentialHits() > ) {
                     Math.max( - damageCalculator.getSequentialModifierStep() * ()damageSequence.getSequentialHits(), damageCalculator.getSequentialModifierMinimum());
                  damage.setAmount(damage.getAmount() * sequentialModifier);
               }

               damageSequence.addSequentialHit();
               DamageEntityInteraction.EntityStatOnHit[] entityStatsOnHit = damageSequence.getEntityStatOnHit();
                (entityStatsOnHit != ) {
                  Damage.   damage.getSource();
                   (var10  Damage.EntitySource) {
                     Damage.   (Damage.EntitySource)var10;
                     Ref<EntityStore> attackerRef = entitySource.getRef();
                        (EntityStatMap)commandBuffer.getComponent(attackerRef, EntityStatMap.getComponentType());
                      (entityStatMapComponent == ) {
                        ;
                     }

                     (DamageEntityInteraction.EntityStatOnHit statOnHit : entityStatsOnHit) {
                        statOnHit.processEntityStatsOnHit(damageSequence.getSequentialHits(), entityStatMapComponent);
                     }
                  }
               }

            }
         }
      }
   }

       {
      
        Sequence sequence;
      
        DamageCalculator damageCalculator;
      
       DamageEntityInteraction.EntityStatOnHit[] entityStatOnHit;

        {
         .sequence = sequence;
         .damageCalculator = damageCalculator;
      }

         {
          .sequence.hits;
      }

         {
         ++.sequence.hits;
      }

      
       DamageCalculator  {
          .damageCalculator;
      }

      
       DamageEntityInteraction.EntityStatOnHit[] getEntityStatOnHit() {
          .entityStatOnHit;
      }

         {
         .entityStatOnHit = entityStatOnHit;
      }
   }

       {
      
         BuilderCodec<Sequence> CODEC;
        hits;

        {
      }

        {
         .hits = hits;
      }

         {
          .hits;
      }

      
       String  {
           + .hits + ;
      }

       {
         CODEC = ((BuilderCodec.Builder)BuilderCodec.builder(Sequence.class, Sequence::).append( (, Codec.INTEGER), (entityEffect, x) -> entityEffect.hits = x, (entityEffect) -> entityEffect.hits).add()).build();
      }
   }
}