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

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.EnumCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.Object2FloatMapCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import it.unimi.dsi.fastutil.ints.Int2FloatMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2FloatMaps;
class="kw">import it.unimi.dsi.fastutil.ints.Int2FloatOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.Object2FloatMap.Entry;
class="kw">import java.util.Iterator;
class="kw">import java.util.Objects;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class DamageCalculator {
   class="kw">public class="kw">static class="kw">final BuilderCodec<DamageCalculator> CODEC = BuilderCodec.builder(DamageCalculator.class, DamageCalculator::new)
      .appendInherited(
         new KeyedCodec<>("Type", DamageCalculator.Type.CODEC), (var0, var1) -> var0.type = var1, var0 -> var0.type, (var0, var1) -> var0.type = var1.type
      )
      .add()
      .<DamageClass>appendInherited(
         new KeyedCodec<>("Class", DamageClass.CODEC),
         (var0, var1) -> var0.damageClass = var1,
         var0 -> var0.damageClass,
         (var0, var1) -> var0.damageClass = var1.damageClass
      )
      .documentation("The class of the damage being created, used by the damage system to apply modifiers based on equipment of the source.")
      .addValidator(Validators.nonNull())
      .add()
      .<Object2FloatMap<String>>appendInherited(
         new KeyedCodec<>("BaseDamage", new Object2FloatMapCodec<>(Codec.STRING, Object2FloatOpenHashMap::new)),
         (var0, var1) -> var0.baseDamageRaw = var1,
         var0 -> var0.baseDamageRaw,
         (var0, var1) -> var0.baseDamageRaw = var1.baseDamageRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .appendInherited(
         new KeyedCodec<>("SequentialModifierStep", Codec.FLOAT),
         (var0, var1) -> var0.sequentialModifierStep = var1,
         var0 -> var0.sequentialModifierStep,
         (var0, var1) -> var0.sequentialModifierStep = var1.sequentialModifierStep
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("SequentialModifierMinimum", Codec.FLOAT),
         (var0, var1) -> var0.sequentialModifierMinimum = var1,
         var0 -> var0.sequentialModifierMinimum,
         (var0, var1) -> var0.sequentialModifierMinimum = var1.sequentialModifierMinimum
      )
      .add()
      .<Float>appendInherited(
         new KeyedCodec<>("RandomPercentageModifier", Codec.FLOAT),
         (var0, var1) -> var0.randomPercentageModifier = var1,
         var0 -> var0.randomPercentageModifier,
         (var0, var1) -> var0.randomPercentageModifier = var1.randomPercentageModifier
      )
      .addValidator(Validators.greaterThanOrEqual(0.0F))
      .add()
      .afterDecode(var0 -> {
         if (var0.baseDamageRaw != null) {
            var0.baseDamage = new Int2FloatOpenHashMap();
            Iterator var1 = var0.baseDamageRaw.object2FloatEntrySet().iterator();

            while (var1.hasNext()) {
               Entry var2 = (Entry<String>)var1.next();
               int var3 = DamageCause.getAssetMap().getIndex((String)var2.getKey());
               var0.baseDamage.put(var3, var2.getFloatValue());
            }
         }
      })
      .build();
   class="kw">protected DamageCalculator.Type type = DamageCalculator.Type.ABSOLUTE;
   @Nonnull
   class="kw">protected DamageClass damageClass = DamageClass.UNKNOWN;
   class="kw">protected Object2FloatMap<String> baseDamageRaw;
   class="kw">protected float sequentialModifierStep;
   class="kw">protected float sequentialModifierMinimum;
   class="kw">protected float randomPercentageModifier;
   @Nonnull
   class="kw">protected class="kw">transient Int2FloatMap baseDamage = Int2FloatMaps.EMPTY_MAP;

   class="kw">protected DamageCalculator() {
   }

   @Nullable
   class="kw">public Object2FloatMap<DamageCause> calculateDamage(double var1) {
      if (this.baseDamageRaw != null && !this.baseDamageRaw.isEmpty()) {
         Object2FloatMap var3 = new Object2FloatOpenHashMap(this.baseDamage.size());
         float var4 = MathUtil.randomFloat(-this.randomPercentageModifier, this.randomPercentageModifier);
         ObjectIterator var5 = this.baseDamage.int2FloatEntrySet().iterator();

         while (var5.hasNext()) {
            it.unimi.dsi.fastutil.ints.Int2FloatMap.Entry var6 = (it.unimi.dsi.fastutil.ints.Int2FloatMap.Entry)var5.next();
            DamageCause var7 = DamageCause.getAssetMap().getAsset(var6.getIntKey());
            float var8 = var6.getFloatValue();
            float var9 = this.scaleDamage(var1, var8);
            var9 += var9 * var4;
            var3.put(var7, var9);
         }

         class="kw">return var3;
      } else {
         class="kw">return null;
      }
   }

   class="kw">private float scaleDamage(double var1, float var3) {
      class="kw">return class="kw">switch (this.type) {
         case DPS -> (float)var1 * var3;
         case ABSOLUTE -> var3;
      };
   }

   class="kw">public void computeDamageRange(double var1, @Nonnull float[] var3) {
      if (this.baseDamage.isEmpty()) {
         var3[0] = 0.0F;
         var3[1] = 0.0F;
      } else {
         float var4 = 0.0F;
         ObjectIterator var5 = this.baseDamage.int2FloatEntrySet().iterator();

         while (var5.hasNext()) {
            it.unimi.dsi.fastutil.ints.Int2FloatMap.Entry var6 = (it.unimi.dsi.fastutil.ints.Int2FloatMap.Entry)var5.next();
            var4 += this.scaleDamage(var1, var6.getFloatValue());
         }

         var3[0] = var4 * (1.0F - this.randomPercentageModifier);
         var3[1] = var4 * (1.0F + this.randomPercentageModifier);
      }
   }

   class="kw">public DamageCalculator.Type getType() {
      class="kw">return this.type;
   }

   @Nonnull
   class="kw">public DamageClass getDamageClass() {
      class="kw">return this.damageClass;
   }

   class="kw">public float getSequentialModifierStep() {
      class="kw">return this.sequentialModifierStep;
   }

   class="kw">public float getSequentialModifierMinimum() {
      class="kw">return this.sequentialModifierMinimum;
   }

   @Override
   class="kw">public boolean equals(Object var1) {
      if (this == var1) {
         class="kw">return true;
      }

      if (var1 class="kw">instanceof DamageCalculator var2) {
         if (Double.compare(var2.sequentialModifierStep, this.sequentialModifierStep) != 0) {
            class="kw">return false;
         } else if (Double.compare(var2.sequentialModifierMinimum, this.sequentialModifierMinimum) != 0) {
            class="kw">return false;
         } else if (Double.compare(var2.randomPercentageModifier, this.randomPercentageModifier) != 0) {
            class="kw">return false;
         } else {
            class="kw">return this.type != var2.type ? false : Objects.equals(this.baseDamageRaw, var2.baseDamageRaw);
         }
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">public int hashCode() {
      int var1 = this.type != null ? this.type.hashCode() : 0;
      var1 = 31 * var1 + (this.baseDamageRaw != null ? this.baseDamageRaw.hashCode() : 0);
      long var2 = Double.doubleToLongBits(this.sequentialModifierStep);
      var1 = 31 * var1 + (int)(var2 ^ var2 >>> 32);
      var2 = Double.doubleToLongBits(this.sequentialModifierMinimum);
      var1 = 31 * var1 + (int)(var2 ^ var2 >>> 32);
      var2 = Double.doubleToLongBits(this.randomPercentageModifier);
      class="kw">return 31 * var1 + (int)(var2 ^ var2 >>> 32);
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "DamageCalculator{type="
         + this.type
         + ", baseDamage="
         + this.baseDamageRaw
         + ", sequentialModifierStep="
         + this.sequentialModifierStep
         + ", sequentialModifierMinimum="
         + this.sequentialModifierMinimum
         + ", randomPercentageModifier="
         + this.randomPercentageModifier
         + "}";
   }

   class="kw">public enum Type {
      DPS,
      ABSOLUTE;

      class="kw">public class="kw">static class="kw">final EnumCodec<DamageCalculator.Type> CODEC = new EnumCodec<>(DamageCalculator.Type.class);

      Type() {
      }
   }
}