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

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.Object2DoubleMapCodec;
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.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.protocol.InteractionState;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.CombatConfig;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.damage.DamageDataComponent;
class="kw">import com.hypixel.hytale.server.core.entity.effect.ActiveEntityEffect;
class="kw">import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
class="kw">import com.hypixel.hytale.server.core.io.NetworkSerializable;
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.DefaultEntityStatTypes;
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.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageEffects;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.floats.Float2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2DoubleMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2DoubleMaps;
class="kw">import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;
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.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
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.Object2DoubleMap.Entry;
class="kw">import java.util.Iterator;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class WieldingInteraction class="kw">extends ChargingInteraction {
   class="kw">public class="kw">static class="kw">final float WIELDING_INDEX = 0.0F;
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<WieldingInteraction> CODEC = BuilderCodec.builder(
         WieldingInteraction.class, WieldingInteraction::new, ChargingInteraction.ABSTRACT_CODEC
      )
      .documentation("Interaction that blocks while the key is held and applies various modifiers while active.")
      .<Object2DoubleMap<String>>appendInherited(
         new KeyedCodec<>("KnockbackModifiers", new Object2DoubleMapCodec<>(Codec.STRING, Object2DoubleOpenHashMap::new)),
         (var0, var1) -> var0.knockbackModifiersRaw = var1,
         var0 -> var0.knockbackModifiersRaw,
         (var0, var1) -> var0.knockbackModifiersRaw = var1.knockbackModifiersRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .<Object2FloatMap<String>>appendInherited(
         new KeyedCodec<>("DamageModifiers", new Object2FloatMapCodec<>(Codec.STRING, Object2FloatOpenHashMap::new)),
         (var0, var1) -> var0.damageModifiersRaw = var1,
         var0 -> var0.damageModifiersRaw,
         (var0, var1) -> var0.damageModifiersRaw = var1.damageModifiersRaw
      )
      .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
      .add()
      .appendInherited(
         new KeyedCodec<>("AngledWielding", WieldingInteraction.AngledWielding.CODEC),
         (var0, var1) -> var0.angledWielding = var1,
         var0 -> var0.angledWielding,
         (var0, var1) -> var0.angledWielding = var1.angledWielding
      )
      .add()
      .<String>appendInherited(new KeyedCodec<>("Next", Interaction.CHILD_ASSET_CODEC), (var0, var1) -> {
         var0.next = new Float2ObjectOpenHashMap();
         var0.next.put(0.0F, var1);
      }, var0 -> var0.next != null ? (String)var0.next.get(0.0F) : null, (var0, var1) -> var0.next = var1.next)
      .addValidatorLate(() -> VALIDATOR_CACHE.getValidator().late())
      .add()
      .<WieldingInteraction.StaminaCost>appendInherited(
         new KeyedCodec<>("StaminaCost", WieldingInteraction.StaminaCost.CODEC),
         (var0, var1) -> var0.staminaCost = var1,
         var0 -> var0.staminaCost,
         (var0, var1) -> var0.staminaCost = var1.staminaCost
      )
      .documentation("Configuration to define how stamina loss is computed.")
      .add()
      .appendInherited(
         new KeyedCodec<>("BlockedEffects", DamageEffects.CODEC),
         (var0, var1) -> var0.blockedEffects = var1,
         var0 -> var0.blockedEffects,
         (var0, var1) -> var0.blockedEffects = var1.blockedEffects
      )
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("BlockedInteractions", RootInteraction.CHILD_ASSET_CODEC),
         (var0, var1) -> var0.blockedInteractions = var1,
         var0 -> var0.blockedInteractions,
         (var0, var1) -> var0.blockedInteractions = var1.blockedInteractions
      )
      .addValidatorLate(() -> RootInteraction.VALIDATOR_CACHE.getValidator().late())
      .add()
      .afterDecode(var0 -> {
         var0.allowIndefiniteHold = true;
         if (var0.next != null && var0.runTime > 0.0F) {
            var0.next.put(var0.runTime, (String)var0.next.get(0.0F));
         }

         if (var0.knockbackModifiersRaw != null) {
            var0.knockbackModifiers = new Int2DoubleOpenHashMap();
            Iterator var1 = var0.knockbackModifiersRaw.object2DoubleEntrySet().iterator();

            while (var1.hasNext()) {
               Entry var2 = (Entry<String>)var1.next();
               int var3 = DamageCause.getAssetMap().getIndex((String)var2.getKey());
               var0.knockbackModifiers.put(var3, var2.getDoubleValue());
            }
         }

         if (var0.damageModifiersRaw != null) {
            var0.damageModifiers = new Int2FloatOpenHashMap();
            Iterator var4 = var0.damageModifiersRaw.object2FloatEntrySet().iterator();

            while (var4.hasNext()) {
               it.unimi.dsi.fastutil.objects.Object2FloatMap.Entry var5 = (it.unimi.dsi.fastutil.objects.Object2FloatMap.Entry<String>)var4.next();
               int var6 = DamageCause.getAssetMap().getIndex((String)var5.getKey());
               var0.damageModifiers.put(var6, var5.getFloatValue());
            }
         }
      })
      .build();
   @Nullable
   class="kw">protected Object2DoubleMap<String> knockbackModifiersRaw;
   @Nullable
   class="kw">protected Object2FloatMap<String> damageModifiersRaw;
   class="kw">protected WieldingInteraction.AngledWielding angledWielding;
   class="kw">protected WieldingInteraction.StaminaCost staminaCost;
   class="kw">protected DamageEffects blockedEffects;
   class="kw">protected String blockedInteractions;
   @Nonnull
   class="kw">protected class="kw">transient Int2DoubleMap knockbackModifiers = Int2DoubleMaps.EMPTY_MAP;
   @Nonnull
   class="kw">protected class="kw">transient Int2FloatMap damageModifiers = Int2FloatMaps.EMPTY_MAP;

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

   @Nonnull
   class="kw">public Int2DoubleMap getKnockbackModifiers() {
      class="kw">return this.knockbackModifiers;
   }

   @Nonnull
   class="kw">public Int2FloatMap getDamageModifiers() {
      class="kw">return this.damageModifiers;
   }

   class="kw">public WieldingInteraction.AngledWielding getAngledWielding() {
      class="kw">return this.angledWielding;
   }

   class="kw">public DamageEffects getBlockedEffects() {
      class="kw">return this.blockedEffects;
   }

   class="kw">public WieldingInteraction.StaminaCost getStaminaCost() {
      class="kw">return this.staminaCost;
   }

   class="kw">public String getBlockedInteractions() {
      class="kw">return this.blockedInteractions;
   }

   @Override
   class="kw">protected void tick0(boolean var1, float var2, @Nonnull InteractionType var3, @Nonnull InteractionContext var4, @Nonnull CooldownHandler var5) {
      CommandBuffer var6 = var4.getCommandBuffer();
      assert var6 != null;
      Ref var7 = var4.getEntity();
      World var8 = var6.getExternalData().getWorld();
      DamageDataComponent var9 = var6.getComponent(var7, DamageDataComponent.getComponentType());
      assert var9 != null;
      if (Interaction.failed(var4.getState().state)) {
         var9.setCurrentWielding(null);
      } else {
         CombatConfig var10 = var8.getGameplayConfig().getCombatConfig();
         EffectControllerComponent var11 = var6.getComponent(var7, EffectControllerComponent.getComponentType());
         if (var11 != null) {
            Int2ObjectMap var12 = var11.getActiveEffects();
            if (!var1 && var12.containsKey(var10.getStaminaBrokenEffectIndex())) {
               var9.setCurrentWielding(null);
               var4.getState().state = InteractionState.Failed;
               if (var4.hasLabels()) {
                  var4.jump(var4.getLabel(this.next != null ? this.next.size() : 0));
               }

               class="kw">return;
            }
         }

         super.tick0(var1, var2, var3, var4, var5);
         if (var1 && var4.getState().state == InteractionState.NotFinished) {
            var9.setCurrentWielding(this);
         } else {
            if (var4.getState().state == InteractionState.Finished) {
               var9.setCurrentWielding(null);
            }
         }
      }
   }

   @Override
   class="kw">protected void simulateTick0(boolean var1, float var2, @Nonnull InteractionType var3, @Nonnull InteractionContext var4, @Nonnull CooldownHandler var5) {
      CommandBuffer var6 = var4.getCommandBuffer();
      assert var6 != null;
      Ref var7 = var4.getEntity();
      World var8 = var6.getExternalData().getWorld();
      CombatConfig var9 = var8.getGameplayConfig().getCombatConfig();
      EffectControllerComponent var10 = var6.getComponent(var7, EffectControllerComponent.getComponentType());
      if (var10 != null) {
         Int2ObjectMap var11 = var10.getActiveEffects();
         if (!var1 && var11.containsKey(var9.getStaminaBrokenEffectIndex())) {
            var4.getState().state = InteractionState.Failed;
            if (var4.hasLabels()) {
               var4.jump(var4.getLabel(this.next != null ? this.next.size() : 0));
            }

            class="kw">return;
         }
      }

      super.simulateTick0(var1, var2, var3, var4, var5);
   }

   @Override
   class="kw">public void handle(@Nonnull Ref<EntityStore> var1, boolean var2, float var3, @Nonnull InteractionType var4, @Nonnull InteractionContext var5) {
      super.handle(var1, var2, var3, var4, var5);
      if (var5.getState().state != InteractionState.NotFinished) {
         CommandBuffer var6 = var5.getCommandBuffer();
         assert var6 != null;
         DamageDataComponent var7 = var6.getComponent(var1, DamageDataComponent.getComponentType());
         assert var7 != null;
         var7.setCurrentWielding(null);
      }
   }

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

   @Override
   class="kw">protected void configurePacket(com.hypixel.hytale.protocol.Interaction var1) {
      super.configurePacket(var1);
      com.hypixel.hytale.protocol.WieldingInteraction var2 = (com.hypixel.hytale.protocol.WieldingInteraction)var1;
      if (this.blockedEffects != null) {
         var2.blockedEffects = this.blockedEffects.toPacket();
      }

      if (this.angledWielding != null) {
         var2.angledWielding = this.angledWielding.toPacket();
      }

      var2.hasModifiers = this.damageModifiersRaw != null || this.knockbackModifiersRaw != null;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "WieldingInteraction{knockbackModifiers="
         + this.knockbackModifiersRaw
         + ", damageModifiers="
         + this.damageModifiersRaw
         + ", angledWielding="
         + this.angledWielding
         + ", failed='"
         + this.failed
         + "', staminaCost="
         + this.staminaCost
         + ", blockedEffects="
         + this.blockedEffects
         + "} "
         + super.toString();
   }

   class="kw">public class="kw">static class AngledWielding class="kw">implements NetworkSerializable<com.hypixel.hytale.protocol.AngledWielding> {
      class="kw">public class="kw">static class="kw">final BuilderCodec<WieldingInteraction.AngledWielding> CODEC = BuilderCodec.builder(
            WieldingInteraction.AngledWielding.class, WieldingInteraction.AngledWielding::new
         )
         .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()
         .<Object2DoubleMap<String>>appendInherited(
            new KeyedCodec<>("KnockbackModifiers", new Object2DoubleMapCodec<>(Codec.STRING, Object2DoubleOpenHashMap::new)),
            (var0, var1) -> var0.knockbackModifiersRaw = var1,
            var0 -> var0.knockbackModifiersRaw,
            (var0, var1) -> var0.knockbackModifiersRaw = var1.knockbackModifiersRaw
         )
         .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
         .add()
         .<Object2FloatMap<String>>appendInherited(
            new KeyedCodec<>("DamageModifiers", new Object2FloatMapCodec<>(Codec.STRING, Object2FloatOpenHashMap::new)),
            (var0, var1) -> var0.damageModifiersRaw = var1,
            var0 -> var0.damageModifiersRaw,
            (var0, var1) -> var0.damageModifiersRaw = var1.damageModifiersRaw
         )
         .addValidator(DamageCause.VALIDATOR_CACHE.getMapKeyValidator())
         .add()
         .afterDecode(var0 -> {
            if (var0.knockbackModifiersRaw != null) {
               var0.knockbackModifiers = new Int2DoubleOpenHashMap();
               Iterator var1 = var0.knockbackModifiersRaw.object2DoubleEntrySet().iterator();

               while (var1.hasNext()) {
                  Entry var2 = (Entry<String>)var1.next();
                  int var3 = DamageCause.getAssetMap().getIndex((String)var2.getKey());
                  var0.knockbackModifiers.put(var3, var2.getDoubleValue());
               }
            }

            if (var0.damageModifiersRaw != null) {
               var0.damageModifiers = new Int2FloatOpenHashMap();
               Iterator var4 = var0.damageModifiersRaw.object2FloatEntrySet().iterator();

               while (var4.hasNext()) {
                  it.unimi.dsi.fastutil.objects.Object2FloatMap.Entry var5 = (it.unimi.dsi.fastutil.objects.Object2FloatMap.Entry<String>)var4.next();
                  int var6 = DamageCause.getAssetMap().getIndex((String)var5.getKey());
                  var0.damageModifiers.put(var6, var5.getFloatValue());
               }
            }
         })
         .build();
      class="kw">protected float angleRad;
      class="kw">protected float angleDistanceRad;
      @Nullable
      class="kw">protected Object2DoubleMap<String> knockbackModifiersRaw;
      @Nullable
      class="kw">protected Object2FloatMap<String> damageModifiersRaw;
      @Nonnull
      class="kw">protected class="kw">transient Int2DoubleMap knockbackModifiers = Int2DoubleMaps.EMPTY_MAP;
      @Nonnull
      class="kw">protected class="kw">transient Int2FloatMap damageModifiers = Int2FloatMaps.EMPTY_MAP;

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

      class="kw">public double getAngleRad() {
         class="kw">return this.angleRad;
      }

      class="kw">public double getAngleDistanceRad() {
         class="kw">return this.angleDistanceRad;
      }

      @Nonnull
      class="kw">public Int2DoubleMap getKnockbackModifiers() {
         class="kw">return this.knockbackModifiers;
      }

      @Nonnull
      class="kw">public Int2FloatMap getDamageModifiers() {
         class="kw">return this.damageModifiers;
      }

      @Nonnull
      class="kw">public com.hypixel.hytale.protocol.AngledWielding toPacket() {
         com.hypixel.hytale.protocol.AngledWielding var1 = new com.hypixel.hytale.protocol.AngledWielding();
         var1.angleRad = this.angleRad;
         var1.angleDistanceRad = this.angleDistanceRad;
         var1.hasModifiers = this.damageModifiersRaw != null || this.knockbackModifiersRaw != null;
         class="kw">return var1;
      }
   }

   class="kw">public class="kw">static class StaminaCost {
      class="kw">public class="kw">static class="kw">final BuilderCodec<WieldingInteraction.StaminaCost> CODEC = BuilderCodec.builder(
            WieldingInteraction.StaminaCost.class, WieldingInteraction.StaminaCost::new
         )
         .append(
            new KeyedCodec<>("CostType", new EnumCodec<>(WieldingInteraction.StaminaCost.CostType.class)),
            (var0, var1) -> var0.costType = var1,
            var0 -> var0.costType
         )
         .documentation(
            "Define how the stamina loss is computed. Use MAX_HEALTH_PERCENTAGE to define how many % of the player's max health 1 stamina point is worth. Use DAMAGE define how much damage 1 stamina point is worth. Default value is MAX_HEALTH_PERCENTAGE."
         )
         .add()
         .<Float>append(new KeyedCodec<>("Value", Codec.FLOAT), (var0, var1) -> var0.value = var1, var0 -> var0.value)
         .addValidator(Validators.greaterThanOrEqual(0.0F))
         .documentation(
            "The value to define how much a stamina point is worth. When CostType.MAX_HEALTH_PERCENTAGE, a ratio is expected, so for 4% of max health, the value expected here is 0.04. Default value is 0.04f"
         )
         .add()
         .build();
      class="kw">private WieldingInteraction.StaminaCost.CostType costType = WieldingInteraction.StaminaCost.CostType.MAX_HEALTH_PERCENTAGE;
      class="kw">private float value = 0.04F;

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

      class="kw">public float computeStaminaAmountToConsume(float var1, @Nonnull EntityStatMap var2) {
         class="kw">return class="kw">switch (this.costType) {
            case MAX_HEALTH_PERCENTAGE -> var1 / (this.value * var2.get(DefaultEntityStatTypes.getHealth()).getMax());
            case DAMAGE -> var1 / this.value;
         };
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "StaminaCost{costType=" + this.costType + ", value=" + this.value + "}";
      }

      enum CostType {
         MAX_HEALTH_PERCENTAGE,
         DAMAGE;

         CostType() {
         }
      }
   }
}