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

class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.MapCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.util.TrigMathUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Rotation3fc;
class="kw">import com.hypixel.hytale.protocol.InteractionState;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.protocol.WaitForDataFrom;
class="kw">import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.entity.EntitySnapshot;
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.ItemUtils;
class="kw">import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
class="kw">import com.hypixel.hytale.server.core.entity.knockback.KnockbackComponent;
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.io.NetworkSerializable;
class="kw">import com.hypixel.hytale.server.core.meta.DynamicMetaStore;
class="kw">import com.hypixel.hytale.server.core.meta.MetaKey;
class="kw">import com.hypixel.hytale.server.core.modules.debug.DebugUtils;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCalculatorSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.EntityStatType;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.modifier.StaticModifier;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.CooldownHandler;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.data.Collector;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.data.CollectorTag;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.data.StringTag;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.none.SelectInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageCalculator;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageClass;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageEffects;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.Knockback;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.TargetEntityEffect;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.operation.Label;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.operation.OperationsBuilder;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.util.InteractionValidation;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.HashMap;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.stream.IntStream;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3f;
class="kw">import org.joml.Vector4d;

class="kw">public class DamageEntityInteraction class="kw">extends Interaction {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<DamageEntityInteraction> CODEC = BuilderCodec.builder(
         DamageEntityInteraction.class, DamageEntityInteraction::new, Interaction.ABSTRACT_CODEC
      )
      .documentation("Damages the target entity.")
      .appendInherited(
         new KeyedCodec<>("DamageCalculator", DamageCalculator.CODEC),
         (var0, var1) -> var0.damageCalculator = var1,
         var0 -> var0.damageCalculator,
         (var0, var1) -> var0.damageCalculator = var1.damageCalculator
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("DamageEffects", DamageEffects.CODEC),
         (var0, var1) -> var0.damageEffects = var1,
         var0 -> var0.damageEffects,
         (var0, var1) -> var0.damageEffects = var1.damageEffects
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("AngledDamage", new ArrayCodec<>(DamageEntityInteraction.AngledDamage.CODEC, DamageEntityInteraction.AngledDamage[]::new)),
         (var0, var1) -> var0.angledDamage = var1,
         var0 -> var0.angledDamage,
         (var0, var1) -> var0.angledDamage = var1.angledDamage
      )
      .add()
      .<Map>appendInherited(
         new KeyedCodec<>("TargetedDamage", new MapCodec<>(DamageEntityInteraction.TargetedDamage.CODEC, HashMap::new)),
         (var0, var1) -> var0.targetedDamage = var1,
         var0 -> var0.targetedDamage,
         (var0, var1) -> var0.targetedDamage = var1.targetedDamage
      )
      .addValidator(Validators.nonNull())
      .add()
      .<DamageEntityInteraction.EntityStatOnHit[]>appendInherited(
         new KeyedCodec<>("EntityStatsOnHit", new ArrayCodec<>(DamageEntityInteraction.EntityStatOnHit.CODEC, DamageEntityInteraction.EntityStatOnHit[]::new)),
         (var0, var1) -> var0.entityStatsOnHit = var1,
         var0 -> var0.entityStatsOnHit,
         (var0, var1) -> var0.entityStatsOnHit = var1.entityStatsOnHit
      )
      .documentation("EntityStats to apply based on the hits resulting from this interaction.")
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("Next", Interaction.CHILD_ASSET_CODEC), (var0, var1) -> var0.next = var1, var0 -> var0.next, (var0, var1) -> var0.next = var1.next
      )
      .documentation("The interactions to run when this interaction succeeds.")
      .addValidatorLate(() -> VALIDATOR_CACHE.getValidator().late())
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("Failed", Interaction.CHILD_ASSET_CODEC),
         (var0, var1) -> var0.failed = var1,
         var0 -> var0.failed,
         (var0, var1) -> var0.failed = var1.failed
      )
      .documentation("The interactions to run when this interaction fails.")
      .addValidatorLate(() -> VALIDATOR_CACHE.getValidator().late())
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("Blocked", Interaction.CHILD_ASSET_CODEC),
         (var0, var1) -> var0.blocked = var1,
         var0 -> var0.blocked,
         (var0, var1) -> var0.blocked = var1.blocked
      )
      .documentation("The interactions to run when this interaction fails.")
      .addValidatorLate(() -> VALIDATOR_CACHE.getValidator().late())
      .add()
      .afterDecode(var0 -> {
         String[] var1 = var0.sortedTargetDamageKeys = var0.targetedDamage.keySet().toArray(String[]::new);
         Arrays.sort(var1);
         int var2 = 0;

         while (var2 < var1.length) {
            String var3 = var1[var2];
            var0.targetedDamage.get(var3).index = var2++;
         }
      })
      .build();
   class="kw">private class="kw">static class="kw">final int FAILED_LABEL_INDEX = 0;
   class="kw">private class="kw">static class="kw">final int SUCCESS_LABEL_INDEX = 1;
   class="kw">private class="kw">static class="kw">final int BLOCKED_LABEL_INDEX = 2;
   class="kw">private class="kw">static class="kw">final int ANGLED_LABEL_OFFSET = 3;
   class="kw">public class="kw">static class="kw">final int ARMOR_RESISTANCE_FLAT_MODIFIER = 0;
   class="kw">public class="kw">static class="kw">final int ARMOR_RESISTANCE_MULTIPLIER_MODIFIER = 1;
   class="kw">private class="kw">static class="kw">final StringTag TAG_NEXT = StringTag.of("Next");
   class="kw">private class="kw">static class="kw">final StringTag TAG_FAILED = StringTag.of("Failed");
   class="kw">private class="kw">static class="kw">final StringTag TAG_BLOCKED = StringTag.of("Blocked");
   class="kw">private class="kw">static class="kw">final MetaKey<DamageCalculatorSystems.Sequence> SEQUENTIAL_HITS = META_REGISTRY.registerMetaObject(
      var0 -> new DamageCalculatorSystems.Sequence()
   );
   class="kw">private class="kw">static class="kw">final MetaKey<Integer> NEXT_INDEX = META_REGISTRY.registerMetaObject();
   class="kw">private class="kw">static class="kw">final MetaKey<Damage[]> QUEUED_DAMAGE = META_REGISTRY.registerMetaObject();
   class="kw">protected DamageCalculator damageCalculator;
   @Nullable
   class="kw">protected DamageEffects damageEffects;
   class="kw">protected DamageEntityInteraction.AngledDamage[] angledDamage;
   class="kw">protected DamageEntityInteraction.EntityStatOnHit[] entityStatsOnHit;
   class="kw">protected Map<String, DamageEntityInteraction.TargetedDamage> targetedDamage = Collections.emptyMap();
   class="kw">protected String[] sortedTargetDamageKeys;
   @Nullable
   class="kw">protected String next;
   @Nullable
   class="kw">protected String blocked;
   @Nullable
   class="kw">protected String failed;

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

   @Override
   class="kw">protected void tick0(boolean var1, float var2, @Nonnull InteractionType var3, @Nonnull InteractionContext var4, @Nonnull CooldownHandler var5) {
      Ref var6 = var4.getTargetEntity();
      if (var6 != null && var6.isValid() && var4.getEntity().isValid()) {
         CommandBuffer var7 = var4.getCommandBuffer();
         assert var7 != null;
         if (!InteractionValidation.canPlayerInteractWithEntity(var4.getEntity(), var7, var4.getHeldItem(), var6)) {
            var4.jump(var4.getLabel(0));
            var4.getState().nextLabel = 0;
            var4.getState().state = InteractionState.Failed;
         } else if (!this.processDamage(var4, var4.getInstanceStore().getIfPresentMetaObject(QUEUED_DAMAGE))) {
            Ref var8 = var4.getOwningEntity();
            Vector4d var9 = var4.getMetaStore().getMetaObject(Interaction.HIT_LOCATION);
            Damage.EntitySource var10 = new Damage.EntitySource(var8);
            this.attemptEntityDamage0(var10, var4, var4.getEntity(), var6, var9);
            if (SelectInteraction.SHOW_VISUAL_DEBUG && var9 != null) {
               DebugUtils.addSphere(var7.getExternalData().getWorld(), new Vector3d(var9.x, var9.y, var9.z), new Vector3f(1.0F, 0.0F, 0.0F), 0.2F, 5.0F);
            }
         }
      } else {
         var4.jump(var4.getLabel(0));
         var4.getState().nextLabel = 0;
         var4.getState().state = InteractionState.Failed;
      }
   }

   @Override
   class="kw">protected void simulateTick0(boolean var1, float var2, @Nonnull InteractionType var3, @Nonnull InteractionContext var4, @Nonnull CooldownHandler var5) {
      this.tick0(var1, var2, var3, var4, var5);
   }

   class="kw">private boolean processDamage(@Nonnull InteractionContext var1, @Nullable Damage[] var2) {
      if (var2 == null) {
         class="kw">return false;
      }

      boolean var3 = true;
      boolean var4 = false;

      for (Damage var8 : var2) {
         if (!var8.isCancelled()) {
            var3 = false;
         }

         if (var8.getMetaObject(Damage.BLOCKED)) {
            var4 = true;
         }
      }

      if (var3) {
         var1.jump(var1.getLabel(0));
         var1.getState().nextLabel = 0;
         var1.getState().state = InteractionState.Failed;
      } else if (var4) {
         var1.jump(var1.getLabel(2));
         var1.getState().nextLabel = 2;
         var1.getState().state = InteractionState.Finished;
      } else {
         int var9 = var1.getInstanceStore().getMetaObject(NEXT_INDEX);
         var1.getState().nextLabel = var9;
         var1.jump(var1.getLabel(var9));
         var1.getState().state = InteractionState.Finished;
      }

      class="kw">return true;
   }

   @Override
   class="kw">public void compile(@Nonnull OperationsBuilder var1) {
      Label[] var2 = new Label[3 + (this.angledDamage != null ? this.angledDamage.length : 0) + this.targetedDamage.size()];
      var1.addOperation(this, var2);
      Label var3 = var1.createUnresolvedLabel();
      var2[0] = var1.createLabel();
      if (this.failed != null) {
         Interaction.getInteractionOrUnknown(this.failed).compile(var1);
      }

      var1.jump(var3);
      var2[1] = var1.createLabel();
      if (this.next != null) {
         Interaction.getInteractionOrUnknown(this.next).compile(var1);
      }

      var1.jump(var3);
      var2[2] = var1.createLabel();
      if (this.blocked != null) {
         Interaction.getInteractionOrUnknown(this.blocked).compile(var1);
      }

      var1.jump(var3);
      int var4 = 3;
      if (this.angledDamage != null) {
         for (DamageEntityInteraction.AngledDamage var8 : this.angledDamage) {
            var2[var4++] = var1.createLabel();
            String var9 = var8.next;
            if (var9 == null) {
               var9 = this.next;
            }

            if (var9 != null) {
               Interaction.getInteractionOrUnknown(var9).compile(var1);
            }

            var1.jump(var3);
         }
      }

      if (!this.targetedDamage.isEmpty()) {
         for (String var14 : this.sortedTargetDamageKeys) {
            DamageEntityInteraction.TargetedDamage var15 = this.targetedDamage.get(var14);
            var2[var4++] = var1.createLabel();
            String var10 = var15.next;
            if (var10 == null) {
               var10 = this.next;
            }

            if (var10 != null) {
               Interaction.getInteractionOrUnknown(var10).compile(var1);
            }

            var1.jump(var3);
         }
      }

      var1.resolveLabel(var3);
   }

   @Nullable
   class="kw">public DamageCalculator getDamageCalculator() {
      class="kw">return this.damageCalculator;
   }

   @Nullable
   class="kw">public DamageEntityInteraction.AngledDamage[] getAngledDamage() {
      class="kw">return this.angledDamage;
   }

   @Nonnull
   class="kw">public Map<String, DamageEntityInteraction.TargetedDamage> getTargetedDamage() {
      class="kw">return this.targetedDamage;
   }

   @Override
   class="kw">public boolean walk(@Nonnull Collector var1, @Nonnull InteractionContext var2) {
      if (this.next != null && InteractionManager.walkInteraction(var1, var2, TAG_NEXT, this.next)) {
         class="kw">return true;
      }

      if (this.failed != null && InteractionManager.walkInteraction(var1, var2, TAG_FAILED, this.failed)) {
         class="kw">return true;
      }

      if (this.blocked != null && InteractionManager.walkInteraction(var1, var2, TAG_BLOCKED, this.blocked)) {
         class="kw">return true;
      }

      if (this.angledDamage != null) {
         for (int var3 = 0; var3 < this.angledDamage.length; var3++) {
            DamageEntityInteraction.AngledDamage var4 = this.angledDamage[var3];
            String var5 = var4.next != null ? var4.next : this.next;
            if (var5 != null && InteractionManager.walkInteraction(var1, var2, DamageEntityInteraction.AngledDamageTag.of(var3), var5)) {
               class="kw">return true;
            }
         }
      }

      if (!this.targetedDamage.isEmpty()) {
         for (Entry var8 : this.targetedDamage.entrySet()) {
            DamageEntityInteraction.TargetedDamage var9 = var8.getValue();
            String var6 = var9.next != null ? var9.next : this.next;
            if (var6 != null && InteractionManager.walkInteraction(var1, var2, DamageEntityInteraction.TargetedDamageTag.of(var8.getKey()), var6)) {
               class="kw">return true;
            }
         }
      }

      class="kw">return false;
   }

   @Nonnull
   @Override
   class="kw">protected com.hypixel.hytale.protocol.Interaction generatePacket() {
      class="kw">return new com.hypixel.hytale.protocol.DamageEntityInteraction();
   }

   @Override
   class="kw">protected void configurePacket(com.hypixel.hytale.protocol.Interaction var1) {
      super.configurePacket(var1);
      com.hypixel.hytale.protocol.DamageEntityInteraction var2 = (com.hypixel.hytale.protocol.DamageEntityInteraction)var1;
      var2.damageEffects = this.damageEffects != null ? this.damageEffects.toPacket() : null;
      var2.next = Interaction.getInteractionIdOrUnknown(this.next);
      var2.failed = Interaction.getInteractionIdOrUnknown(this.failed);
      var2.blocked = Interaction.getInteractionIdOrUnknown(this.blocked);
      if (this.angledDamage != null) {
         var2.angledDamage = new com.hypixel.hytale.protocol.AngledDamage[this.angledDamage.length];

         for (int var3 = 0; var3 < this.angledDamage.length; var3++) {
            var2.angledDamage[var3] = this.angledDamage[var3].toAngledDamagePacket();
         }
      }

      if (this.entityStatsOnHit != null) {
         var2.entityStatsOnHit = new com.hypixel.hytale.protocol.EntityStatOnHit[this.entityStatsOnHit.length];

         for (int var5 = 0; var5 < this.entityStatsOnHit.length; var5++) {
            var2.entityStatsOnHit[var5] = this.entityStatsOnHit[var5].toPacket();
         }
      }

      var2.targetedDamage = new Object2ObjectOpenHashMap();

      for (Entry var4 : this.targetedDamage.entrySet()) {
         var2.targetedDamage.put(var4.getKey(), var4.getValue().toTargetedDamagePacket());
      }
   }

   @Override
   class="kw">public boolean needsRemoteSync() {
      class="kw">return true;
   }

   @Nonnull
   @Override
   class="kw">public WaitForDataFrom getWaitForDataFrom() {
      class="kw">return WaitForDataFrom.None;
   }

   class="kw">private void attemptEntityDamage0(
      @Nonnull Damage.Source var1, @Nonnull InteractionContext var2, @Nonnull Ref<EntityStore> var3, @Nonnull Ref<EntityStore> var4, @Nullable Vector4d var5
   ) {
      CommandBuffer var6 = var2.getCommandBuffer();
      assert var6 != null;
      if (isTargetInvulnerable(var6, var3, var4)) {
         var2.jump(var2.getLabel(0));
         var2.getState().nextLabel = 0;
         var2.getState().state = InteractionState.Failed;
      } else {
         DamageCalculator var7 = this.damageCalculator;
         DamageEffects var8 = this.damageEffects;
         EntitySnapshot var9 = var2.getSnapshot(var4, var6);
         EntitySnapshot var10 = var2.getSnapshot(var3, var6);
         Vector3d var11 = var9.getPosition();
         Vector3d var12 = var10.getPosition();
         float var13 = TrigMathUtil.atan2(var12.x - var11.x, var12.z - var11.z);
         int var14 = 1;
         if (this.angledDamage != null) {
            float var15 = MathUtil.wrapAngle(var13 + (float) Math.PI - var9.getBodyRotation().yaw());

            for (int var16 = 0; var16 < this.angledDamage.length; var16++) {
               DamageEntityInteraction.AngledDamage var17 = this.angledDamage[var16];
               if (Math.abs(MathUtil.compareAngle(var15, var17.angleRad)) < var17.angleDistanceRad) {
                  var7 = var17.damageCalculator == null ? var7 : var17.damageCalculator;
                  var8 = var17.damageEffects == null ? var8 : var17.damageEffects;
                  var14 = 3 + var16;
                  break;
               }
            }
         }

         String var35 = var2.getMetaStore().getIfPresentMetaObject(HIT_DETAIL);
         if (var35 != null) {
            DamageEntityInteraction.TargetedDamage var36 = this.targetedDamage.get(var35);
            if (var36 != null) {
               var7 = var36.damageCalculator == null ? var7 : var36.damageCalculator;
               var8 = var36.damageEffects == null ? var8 : var36.damageEffects;
               var14 = var36.index;
            }
         }

         var2.getInstanceStore().putMetaObject(NEXT_INDEX, var14);
         if (var7 != null) {
            DynamicMetaStore var37 = var2.getMetaStore().getMetaObject(SelectInteraction.SELECT_META_STORE);
            DamageCalculatorSystems.Sequence var38 = var37 == null ? new DamageCalculatorSystems.Sequence() : var37.getMetaObject(SEQUENTIAL_HITS);
            Object2FloatMap var18 = var7.calculateDamage(this.getRunTime());
            HeadRotation var20 = var6.getComponent(var3, HeadRotation.getComponentType());
            Rotation3fc var19;
            if (var20 != null) {
               var19 = var20.getRotation();
            } else {
               var19 = Rotation3f.IDENTITY;
            }

            if (var18 != null && !var18.isEmpty()) {
               double[] var21 = new double[]{1.0};
               float[] var22 = new float[]{0.0F, 1.0F};
               calculateKnockbackAndArmorModifiers(var7.getDamageClass(), var18, var4, var3, var22, var21, var6);
               KnockbackComponent var23 = null;
               if (var8 != null && var8.getKnockback() != null) {
                  var23 = var6.getComponent(var4, KnockbackComponent.getComponentType());
                  if (var23 == null) {
                     var23 = new KnockbackComponent();
                     var6.putComponent(var4, KnockbackComponent.getComponentType(), var23);
                  }

                  Knockback var24 = var8.getKnockback();
                  var23.setVelocity(var24.calculateVector(var12, var19.yaw(), var11).mul(var21[0]));
                  var23.setVelocityType(var24.getVelocityType());
                  var23.setVelocityConfig(var24.getVelocityConfig());
                  var23.setDuration(var24.getDuration());
               }

               ItemStack var39 = ItemUtils.canApplyItemStackPenalties(var3, var6) ? var2.getHeldItem() : null;
               Damage[] var25 = DamageCalculatorSystems.queueDamageCalculator(
                  var6.getExternalData().getWorld(), var18, var4, var2.getCommandBuffer(), var1, var39
               );
               if (var25.length > 0) {
                  Damage var26 = var25[0];
                  DamageCalculatorSystems.DamageSequence var27 = new DamageCalculatorSystems.DamageSequence(var38, var7);
                  var27.setEntityStatOnHit(this.entityStatsOnHit);
                  var26.putMetaObject(DamageCalculatorSystems.DAMAGE_SEQUENCE, var27);
                  if (var8 != null) {
                     var8.addToDamage(var26);
                  }

                  for (Damage var31 : var25) {
                     if (var23 != null) {
                        var31.putMetaObject(Damage.KNOCKBACK_COMPONENT, var23);
                     }

                     float var32 = var31.getAmount();
                     var32 += var22[0];
                     var31.setAmount(var32 * Math.max(0.0F, var22[1]));
                     if (var5 != null) {
                        var31.putMetaObject(Damage.HIT_LOCATION, var5);
                        float var33 = TrigMathUtil.atan2(var12.x - var5.x, var12.z - var5.z);
                        var33 = MathUtil.wrapAngle(var33 - var19.yaw());
                        float var34 = var33 * (180.0F / (float)Math.PI);
                        var31.putMetaObject(Damage.HIT_ANGLE, var34);
                     }

                     var6.invoke(var4, var31);
                  }

                  this.processDamage(var2, var25);
               }

               var2.getInstanceStore().putMetaObject(QUEUED_DAMAGE, var25);
            }
         }
      }
   }

   class="kw">private class="kw">static void calculateKnockbackAndArmorModifiers(
      @Nonnull DamageClass var0,
      @Nonnull Object2FloatMap<DamageCause> var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull Ref<EntityStore> var3,
      float[] var4,
      double[] var5,
      @Nonnull ComponentAccessor<EntityStore> var6
   ) {
      EffectControllerComponent var7 = var6.getComponent(var2, EffectControllerComponent.getComponentType());
      if (var7 != null) {
         var5[0] = IntStream.of(var7.getActiveEffectIndexes())
            .mapToObj(var0x -> (EntityEffect)((IndexedLookupTableAssetMap)EntityEffect.getAssetStore().getAssetMap()).getAsset(var0x))
            .filter(var0x -> var0x != null && var0x.getApplicationEffects() != null)
            .mapToDouble(var0x -> var0x.getApplicationEffects().getKnockbackMultiplier())
            .reduce(1.0, (var0x, var2x) -> var0x * var2x);
      }

      InventoryComponent.Armor var8 = var6.getComponent(var3, InventoryComponent.Armor.getComponentType());
      if (var8 != null) {
         ItemContainer var9 = var8.getInventory();
         float var10 = 1.0F;

         for (short var11 = 0; var11 < var9.getCapacity(); var11++) {
            ItemStack var12 = var9.getItemStack(var11);
            if (var12 != null && !var12.isEmpty()) {
               Item var13 = var12.getItem();
               if (var13.getArmor() != null) {
                  Map var14 = var13.getArmor().getDamageEnhancementValues();
                  ObjectIterator var15 = var1.keySet().iterator();

                  while (var15.hasNext()) {
                     DamageCause var16 = (DamageCause)var15.next();
                     if (var14 != null) {
                        StaticModifier[] var17 = var14.get(var16);
                        if (var17 != null) {
                           for (StaticModifier var21 : var17) {
                              if (var21.getCalculationType() == StaticModifier.CalculationType.ADDITIVE) {
                                 var4[0] += var21.getAmount();
                              } else {
                                 var4[1] += var21.getAmount();
                              }
                           }
                        }
                     }

                     Map var24 = var13.getArmor().getKnockbackEnhancements();
                     if (var24 != null && var24.containsKey(var16)) {
                        var10 += var24.get(var16);
                     }
                  }

                  StaticModifier[] var22 = var13.getArmor().getDamageClassEnhancement().get(var0);
                  if (var22 != null) {
                     for (StaticModifier var27 : var22) {
                        if (var27.getCalculationType() == StaticModifier.CalculationType.ADDITIVE) {
                           var4[0] += var27.getAmount();
                        } else {
                           var4[1] += var27.getAmount();
                        }
                     }
                  }
               }
            }
         }

         var5[0] *= var10;
      }
   }

   class="kw">public class="kw">static class AngledDamage class="kw">extends DamageEntityInteraction.TargetedDamage {
      class="kw">public class="kw">static class="kw">final BuilderCodec<DamageEntityInteraction.AngledDamage> CODEC = BuilderCodec.builder(
            DamageEntityInteraction.AngledDamage.class, DamageEntityInteraction.AngledDamage::new, DamageEntityInteraction.TargetedDamage.CODEC
         )
         .appendInherited(
            new KeyedCodec<>("Angle", Codec.FLOAT),
            (var0, var1) -> var0.angleRad = var1 * (float) (Math.PI / 180.0),
            var0 -> var0.angleRad * (180.0F / (float)Math.PI),
            (var0, var1) -> var0.angleRad = var1.angleRad
         )
         .add()
         .appendInherited(
            new KeyedCodec<>("AngleDistance", Codec.FLOAT),
            (var0, var1) -> var0.angleDistanceRad = var1 * (float) (Math.PI / 180.0),
            var0 -> var0.angleDistanceRad * (180.0F / (float)Math.PI),
            (var0, var1) -> var0.angleDistanceRad = var1.angleDistanceRad
         )
         .add()
         .build();
      class="kw">protected float angleRad;
      class="kw">protected float angleDistanceRad;

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

      @Nonnull
      class="kw">public com.hypixel.hytale.protocol.AngledDamage toAngledDamagePacket() {
         com.hypixel.hytale.protocol.DamageEffects var1 = this.damageEffects == null ? null : this.damageEffects.toPacket();
         class="kw">return new com.hypixel.hytale.protocol.AngledDamage(this.angleRad, this.angleDistanceRad, var1, Interaction.getInteractionIdOrUnknown(this.next));
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "AngledDamage{angleRad=" + this.angleRad + ", angleDistanceRad=" + this.angleDistanceRad + "} " + super.toString();
      }
   }

   class="kw">public class="kw">static class="kw">final class AngledDamageTag class="kw">implements CollectorTag {
      class="kw">private class="kw">final int index;

      class="kw">private AngledDamageTag(int var1) {
         this.index = var1;
      }

      class="kw">public int getIndex() {
         class="kw">return this.index;
      }

      @Override
      class="kw">public boolean equals(@Nullable Object var1) {
         if (this == var1) {
            class="kw">return true;
         } else {
            class="kw">return var1 != null && this.getClass() == var1.getClass() ? this.index == ((DamageEntityInteraction.AngledDamageTag)var1).index : false;
         }
      }

      @Override
      class="kw">public int hashCode() {
         class="kw">return this.index;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "AngledDamageTag{index=" + this.index + "}";
      }

      @Nonnull
      class="kw">public class="kw">static DamageEntityInteraction.AngledDamageTag of(int var0) {
         class="kw">return new DamageEntityInteraction.AngledDamageTag(var0);
      }
   }

   class="kw">public class="kw">static class EntityStatOnHit class="kw">implements NetworkSerializable<com.hypixel.hytale.protocol.EntityStatOnHit> {
      class="kw">public class="kw">static class="kw">final BuilderCodec<DamageEntityInteraction.EntityStatOnHit> CODEC = BuilderCodec.builder(
            DamageEntityInteraction.EntityStatOnHit.class, DamageEntityInteraction.EntityStatOnHit::new
         )
         .appendInherited(
            new KeyedCodec<>("EntityStatId", Codec.STRING),
            (var0, var1) -> var0.entityStatId = var1,
            var0 -> var0.entityStatId,
            (var0, var1) -> var0.entityStatId = var1.entityStatId
         )
         .documentation("The id of the EntityStat that will be affected by the interaction.")
         .addValidator(Validators.nonNull())
         .addValidator(EntityStatType.VALIDATOR_CACHE.getValidator())
         .add()
         .<Float>appendInherited(
            new KeyedCodec<>("Amount", Codec.FLOAT), (var0, var1) -> var0.amount = var1, var0 -> var0.amount, (var0, var1) -> var0.amount = var1.amount
         )
         .documentation("The base amount for a single entity hit.")
         .add()
         .<float[]>appendInherited(
            new KeyedCodec<>("MultipliersPerEntitiesHit", Codec.FLOAT_ARRAY),
            (var0, var1) -> var0.multipliersPerEntitiesHit = var1,
            var0 -> var0.multipliersPerEntitiesHit,
            (var0, var1) -> var0.multipliersPerEntitiesHit = var1.multipliersPerEntitiesHit
         )
         .documentation("An array of multipliers corresponding to how much the amount should be multiplied by for each entity hit.")
         .addValidator(Validators.nonEmptyFloatArray())
         .add()
         .<Float>appendInherited(
            new KeyedCodec<>("MultiplierPerExtraEntityHit", Codec.FLOAT),
            (var0, var1) -> var0.multiplierPerExtraEntityHit = var1,
            var0 -> var0.multiplierPerExtraEntityHit,
            (var0, var1) -> var0.multiplierPerExtraEntityHit = var1.multiplierPerExtraEntityHit
         )
         .documentation(
            "When the number of entity hit is higher than the number of multipliers defined, the amount will be multiplied by this multiplier for each extra entity hit."
         )
         .add()
         .afterDecode(var0 -> {
            if (var0.entityStatId != null) {
               var0.entityStatIndex = EntityStatType.getAssetMap().getIndex(var0.entityStatId);
            }
         })
         .build();
      class="kw">public class="kw">static class="kw">final float[] DEFAULT_MULTIPLIERS_PER_ENTITIES_HIT = new float[]{1.0F, 0.6F, 0.4F, 0.2F, 0.1F};
      class="kw">public class="kw">static class="kw">final float DEFAULT_MULTIPLIER_PER_EXTRA_ENTITY_HIT = 0.05F;
      class="kw">protected String entityStatId;
      class="kw">protected float amount;
      class="kw">protected float[] multipliersPerEntitiesHit = DEFAULT_MULTIPLIERS_PER_ENTITIES_HIT;
      class="kw">protected float multiplierPerExtraEntityHit = 0.05F;
      class="kw">private int entityStatIndex;

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

      class="kw">public void processEntityStatsOnHit(int var1, @Nonnull EntityStatMap var2) {
         if (var1 != 0) {
            float var3;
            if (var1 <= this.multipliersPerEntitiesHit.length) {
               var3 = this.multipliersPerEntitiesHit[var1 - 1];
            } else {
               var3 = this.multiplierPerExtraEntityHit;
            }

            var2.addStatValue(EntityStatMap.Predictable.SELF, this.entityStatIndex, var3 * this.amount);
         }
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "EntityStatOnHit{entityStatId='"
            + this.entityStatId
            + "', amount="
            + this.amount
            + ", multipliersPerEntitiesHit="
            + Arrays.toString(this.multipliersPerEntitiesHit)
            + ", multiplierPerExtraEntityHit="
            + this.multiplierPerExtraEntityHit
            + ", entityStatIndex="
            + this.entityStatIndex
            + "}";
      }

      @Nonnull
      class="kw">public com.hypixel.hytale.protocol.EntityStatOnHit toPacket() {
         class="kw">return new com.hypixel.hytale.protocol.EntityStatOnHit(
            this.entityStatIndex, this.amount, this.multipliersPerEntitiesHit, this.multiplierPerExtraEntityHit
         );
      }
   }

   class="kw">public class="kw">static class TargetedDamage {
      class="kw">public class="kw">static class="kw">final BuilderCodec<DamageEntityInteraction.TargetedDamage> CODEC = BuilderCodec.builder(
            DamageEntityInteraction.TargetedDamage.class, DamageEntityInteraction.TargetedDamage::new
         )
         .appendInherited(
            new KeyedCodec<>("DamageCalculator", DamageCalculator.CODEC),
            (var0, var1) -> var0.damageCalculator = var1,
            var0 -> var0.damageCalculator,
            (var0, var1) -> var0.damageCalculator = var1.damageCalculator
         )
         .add()
         .appendInherited(
            new KeyedCodec<>("TargetEntityEffects", new MapCodec<>(TargetEntityEffect.CODEC, HashMap::new)),
            (var0, var1) -> var0.targetEntityEffects = var1,
            var0 -> var0.targetEntityEffects,
            (var0, var1) -> var0.targetEntityEffects = var1.targetEntityEffects
         )
         .add()
         .appendInherited(
            new KeyedCodec<>("DamageEffects", DamageEffects.CODEC),
            (var0, var1) -> var0.damageEffects = var1,
            var0 -> var0.damageEffects,
            (var0, var1) -> var0.damageEffects = var1.damageEffects
         )
         .add()
         .<String>appendInherited(
            new KeyedCodec<>("Next", Interaction.CHILD_ASSET_CODEC), (var0, var1) -> var0.next = var1, var0 -> var0.next, (var0, var1) -> var0.next = var1.next
         )
         .documentation("The interactions to run when this interaction succeeds.")
         .addValidatorLate(() -> Interaction.VALIDATOR_CACHE.getValidator().late())
         .add()
         .build();
      class="kw">protected int index;
      class="kw">protected DamageCalculator damageCalculator;
      class="kw">protected Map<String, TargetEntityEffect> targetEntityEffects;
      class="kw">protected DamageEffects damageEffects;
      @Nullable
      class="kw">protected String next;

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

      @Nullable
      class="kw">public DamageCalculator getDamageCalculator() {
         class="kw">return this.damageCalculator;
      }

      @Nonnull
      class="kw">public com.hypixel.hytale.protocol.TargetedDamage toTargetedDamagePacket() {
         com.hypixel.hytale.protocol.DamageEffects var1 = this.damageEffects == null ? null : this.damageEffects.toPacket();
         class="kw">return new com.hypixel.hytale.protocol.TargetedDamage(this.index, var1, Interaction.getInteractionIdOrUnknown(this.next));
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "TargetedDamage{damageCalculator="
            + this.damageCalculator
            + ", targetEntityEffects="
            + this.targetEntityEffects
            + ", damageEffects="
            + this.damageEffects
            + ", next='"
            + this.next
            + "'}";
      }
   }

   class="kw">public class="kw">static class="kw">final class TargetedDamageTag class="kw">implements CollectorTag {
      class="kw">private class="kw">final String key;

      class="kw">private TargetedDamageTag(@Nonnull String var1) {
         this.key = var1;
      }

      @Nonnull
      class="kw">public String getKey() {
         class="kw">return this.key;
      }

      @Override
      class="kw">public boolean equals(@Nullable Object var1) {
         if (this == var1) {
            class="kw">return true;
         } else {
            class="kw">return var1 != null && this.getClass() == var1.getClass() ? this.key.equals(((DamageEntityInteraction.TargetedDamageTag)var1).key) : false;
         }
      }

      @Override
      class="kw">public int hashCode() {
         class="kw">return this.key.hashCode();
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "TargetedDamageTag{key='" + this.key + "'}";
      }

      @Nonnull
      class="kw">public class="kw">static DamageEntityInteraction.TargetedDamageTag of(@Nonnull String var0) {
         class="kw">return new DamageEntityInteraction.TargetedDamageTag(var0);
      }
   }
}