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

class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.component.Archetype;
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.Ref;
class="kw">import com.hypixel.hytale.component.ResourceType;
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.SystemGroupDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.spatial.SpatialStructure;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.component.system.tick.DelayedEntitySystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.math.random.RandomExtra;
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.protocol.AnimationSlot;
class="kw">import com.hypixel.hytale.protocol.CombatTextUpdate;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.protocol.MovementStates;
class="kw">import com.hypixel.hytale.protocol.SoundCategory;
class="kw">import com.hypixel.hytale.protocol.packets.entities.SpawnModelParticles;
class="kw">import com.hypixel.hytale.protocol.packets.player.DamageInfo;
class="kw">import com.hypixel.hytale.protocol.packets.player.ReticleEvent;
class="kw">import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.BrokenPenalties;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.PlayerConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.ItemArmor;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.Model;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.ModelParticle;
class="kw">import com.hypixel.hytale.server.core.asset.type.particle.config.WorldParticle;
class="kw">import com.hypixel.hytale.server.core.entity.AnimationUtils;
class="kw">import com.hypixel.hytale.server.core.entity.Entity;
class="kw">import com.hypixel.hytale.server.core.entity.EntityUtils;
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.ItemUtils;
class="kw">import com.hypixel.hytale.server.core.entity.LivingEntity;
class="kw">import com.hypixel.hytale.server.core.entity.damage.DamageDataComponent;
class="kw">import com.hypixel.hytale.server.core.entity.effect.EffectControllerComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.movement.MovementConfig;
class="kw">import com.hypixel.hytale.server.core.entity.knockback.KnockbackComponent;
class="kw">import com.hypixel.hytale.server.core.entity.movement.MovementStatesComponent;
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.EmptyItemContainer;
class="kw">import com.hypixel.hytale.server.core.inventory.container.ItemContainer;
class="kw">import com.hypixel.hytale.server.core.meta.DynamicMetaStore;
class="kw">import com.hypixel.hytale.server.core.modules.entity.AllLegacyLivingEntityTypesQuery;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BreathingComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.CachedStatsComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Intangible;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Invulnerable;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerInput;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.EntityTrackerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatValue;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.EntityStatsSystems;
class="kw">import com.hypixel.hytale.server.core.modules.entitystats.asset.DefaultEntityStatTypes;
class="kw">import com.hypixel.hytale.server.core.modules.entityui.EntityUIModule;
class="kw">import com.hypixel.hytale.server.core.modules.entityui.UIComponentList;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.InteractionModule;
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.client.WieldingInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.DamageEffects;
class="kw">import com.hypixel.hytale.server.core.modules.physics.component.Velocity;
class="kw">import com.hypixel.hytale.server.core.modules.splitvelocity.SplitVelocity;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.ParticleUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.SoundUtil;
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.ints.Int2DoubleMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2FloatMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortArrayList;
class="kw">import java.time.Instant;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector4d;

class="kw">public class DamageSystems {
   class="kw">public class="kw">static class="kw">final float DEFAULT_DAMAGE_DELAY = 1.0F;
   class="kw">private class="kw">static class="kw">final Query<EntityStore> NPCS_QUERY = Query.and(
      AllLegacyLivingEntityTypesQuery.INSTANCE,
      EntityStatMap.getComponentType(),
      MovementStatesComponent.getComponentType(),
      Query.not(EntityModule.get().getPlayerComponentType())
   );

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

   class="kw">public class="kw">static void executeDamage(@Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1, @Nonnull Damage var2) {
      var1.invoke(var0, var2);
   }

   class="kw">public class="kw">static void executeDamage(int var0, @Nonnull ArchetypeChunk<EntityStore> var1, @Nonnull CommandBuffer<EntityStore> var2, @Nonnull Damage var3) {
      var2.invoke(var1.getReferenceTo(var0), var3);
   }

   class="kw">public class="kw">static void executeDamage(@Nonnull Ref<EntityStore> var0, @Nonnull CommandBuffer<EntityStore> var1, @Nonnull Damage var2) {
      var1.invoke(var0, var2);
   }

   class="kw">public class="kw">static class ApplyDamage class="kw">extends DamageEventSystem class="kw">implements EntityStatsSystems.StatModifyingSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = EntityStatMap.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(
         new SystemGroupDependency<>(Order.AFTER, DamageModule.get().getGatherDamageGroup()),
         new SystemGroupDependency<>(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
         new SystemGroupDependency<>(Order.BEFORE, DamageModule.get().getInspectDamageGroup())
      );

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         EntityStatMap var6 = var2.getComponent(var1, EntityStatMap.getComponentType());
         assert var6 != null;
         int var7 = DefaultEntityStatTypes.getHealth();
         EntityStatValue var8 = var6.get(var7);
         Objects.requireNonNull(var8);
         boolean var9 = var2.getArchetype().contains(DeathComponent.getComponentType());
         if (var9) {
            var5.setCancelled(true);
         } else {
            var5.setAmount(Math.round(var5.getAmount()));
            float var10 = var6.subtractStatValue(var7, var5.getAmount());
            if (var10 <= var8.getMin()) {
               DeathComponent.tryAddComponent(var4, var2.getReferenceTo(var1), var5);
            }
         }
      }
   }

   class="kw">public class="kw">static class ApplyParticles class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> PLAYER_SPATIAL_RESOURCE_TYPE = EntityModule.get()
         .getPlayerSpatialResourceType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, NetworkId> NETWORK_ID_COMPONENT_TYPE = NetworkId.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(TRANSFORM_COMPONENT_TYPE, NETWORK_ID_COMPONENT_TYPE);

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         Damage.Particles var6 = var5.getIfPresentMetaObject(Damage.IMPACT_PARTICLES);
         if (var6 != null) {
            if (var5.getSource() class="kw">instanceof Damage.EntitySource var7) {
               Ref var27 = var7.getRef();
               if (var27.isValid()) {
                  TransformComponent var9 = var2.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
                  assert var9 != null;
                  Vector4d var10 = var5.getIfPresentMetaObject(Damage.HIT_LOCATION);
                  Vector3d var11 = var10 == null ? var9.getPosition() : new Vector3d(var10.x, var10.y, var10.z);
                  boolean var12 = var5.getMetaStore().getMetaObject(Damage.CAN_BE_PREDICTED);
                  double var13 = var6.getViewDistance();
                  WorldParticle[] var15 = var6.getWorldParticles();
                  if (var15 != null && var15.length > 0) {
                     TransformComponent var16 = var4.getComponent(var27, TransformComponent.getComponentType());
                     if (var16 != null) {
                        float var17 = TrigMathUtil.atan2(var16.getPosition().x - var11.x, var16.getPosition().z - var11.z);
                        SpatialResource var18 = var4.getResource(EntityModule.get().getPlayerSpatialResourceType());
                        List var19 = SpatialResource.getThreadLocalReferenceList();
                        var18.getSpatialStructure().collect(var11, var13, var19);
                        Ref var20 = var12 ? var27 : null;

                        for (WorldParticle var24 : var15) {
                           ParticleUtil.spawnParticleEffect(var24, var11, var17, 0.0F, 0.0F, var20, var19, var4);
                        }
                     }
                  }

                  ModelParticle[] var28 = var6.getModelParticles();
                  if (var28 != null && var28.length > 0) {
                     com.hypixel.hytale.protocol.ModelParticle[] var29 = new com.hypixel.hytale.protocol.ModelParticle[var28.length];

                     for (int var30 = 0; var30 < var28.length; var30++) {
                        var29[var30] = var28[var30].toPacket();
                     }

                     NetworkId var31 = var2.getComponent(var1, NETWORK_ID_COMPONENT_TYPE);
                     assert var31 != null;
                     int var32 = var31.getId();
                     SpawnModelParticles var33 = new SpawnModelParticles(var32, var29);
                     SpatialResource var34 = var3.getResource(PLAYER_SPATIAL_RESOURCE_TYPE);
                     SpatialStructure var35 = var34.getSpatialStructure();
                     List var36 = SpatialResource.getThreadLocalReferenceList();
                     var35.ordered(var11, var13, var36);

                     for (Ref var25 : var36) {
                        if (!var12 || !var25.equals(var27)) {
                           PlayerRef var26 = var4.getComponent(var25, PlayerRef.getComponentType());
                           if (var26 != null) {
                              var26.getPacketHandler().write(var33);
                           }
                        }
                     }
                  }
               }
            }
         }
      }

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

   class="kw">public class="kw">static class ApplySoundEffects class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, Player> PLAYER_COMPONENT_TYPE = Player.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = TRANSFORM_COMPONENT_TYPE;

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
      }

      class="kw">public void handleInternal(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         TransformComponent var6 = var2.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
         assert var6 != null;
         Player var7 = var2.getComponent(var1, PLAYER_COMPONENT_TYPE);
         Ref var8 = var2.getReferenceTo(var1);
         Damage.SoundEffect var9 = var5.getIfPresentMetaObject(Damage.IMPACT_SOUND_EFFECT);
         Damage.SoundEffect var10 = var5.getIfPresentMetaObject(Damage.PLAYER_IMPACT_SOUND_EFFECT);
         if (var9 != null || var10 != null) {
            Ref var11;
            if (var5.getSource() class="kw">instanceof Damage.EntitySource var12) {
               var11 = var12.getRef().isValid() ? var12.getRef() : null;
            } else {
               var11 = null;
            }

            Vector4d var17 = var5.getIfPresentMetaObject(Damage.HIT_LOCATION);
            Vector3d var18 = var17 == null ? var6.getPosition() : new Vector3d(var17.x, var17.y, var17.z);
            boolean var14 = var7 != null && var10 != null && var10.getSoundEventIndex() != 0;
            if (var9 != null && var9.getSoundEventIndex() != 0) {
               Predicate var15 = var3x -> var11 != null && var3x.equals(var11) ? false : !var14 || !var3x.equals(var8);
               SoundUtil.playSoundEvent3d(var9.getSoundEventIndex(), var18.x, var18.y, var18.z, var15, var4);
            }

            if (var14) {
               PlayerRef var19 = var4.getComponent(var8, PlayerRef.getComponentType());
               if (var19 != null) {
                  int var16 = var9 != null ? var9.getSoundEventIndex() : 0;
                  SoundUtil.playLocalPlayerSoundEvent(var19, var10.getSoundEventIndex(), var16, SoundCategory.SFX);
               }
            }
         }
      }

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

   @Deprecated
   class="kw">public class="kw">static class ArmorDamageReduction class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = AllLegacyLivingEntityTypesQuery.INSTANCE;

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         World var6 = var4.getExternalData().getWorld();
         Ref var7 = var2.getReferenceTo(var1);
         InventoryComponent.Armor var8 = var4.getComponent(var7, InventoryComponent.Armor.getComponentType());
         ItemContainer var9 = var8 != null ? var8.getInventory() : EmptyItemContainer.INSTANCE;
         EffectControllerComponent var10 = var2.getComponent(var1, EffectControllerComponent.getComponentType());
         Map var11 = getResistanceModifiers(var6, var9, ItemUtils.canApplyItemStackPenalties(var7, var4), var10);
         if (!var5.getCause().doesBypassResistances() && !var11.isEmpty()) {
            DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers var12 = var11.get(var5.getCause());
            if (var12 == null) {
               class="kw">return;
            }

            float var13 = Math.max(0.0F, var5.getAmount() - var12.flatModifier);
            var13 *= Math.max(0.0F, 1.0F - var12.multiplierModifier);

            while (var12.inheritedParentId != null) {
               var12 = var11.get(var12.inheritedParentId);
               if (var12 == null) {
                  break;
               }

               var13 = Math.max(0.0F, var13 - var12.flatModifier);
               var13 *= Math.max(0.0F, 1.0F - var12.multiplierModifier);
            }

            var5.setAmount(var13);
         }
      }

      @Nonnull
      class="kw">public class="kw">static Map<DamageCause, DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers> getResistanceModifiers(
         @Nonnull World var0, @Nonnull ItemContainer var1, boolean var2, @Nullable EffectControllerComponent var3
      ) {
         Map var4 = new Object2ObjectOpenHashMap();

         for (short var5 = 0; var5 < var1.getCapacity(); var5++) {
            ItemStack var6 = var1.getItemStack(var5);
            if (var6 != null && !var6.isEmpty()) {
               Item var7 = var6.getItem();
               ItemArmor var8 = var7.getArmor();
               if (var8 != null) {
                  Map var9 = var8.getDamageResistanceValues();
                  double var10 = var8.getBaseDamageResistance();
                  if (var9 != null) {
                     for (Entry var13 : var9.entrySet()) {
                        if (var13.getValue() != null) {
                           calculateResistanceEntryModifications(var13, var0, var4, var2, var6.isBroken(), var10);
                        }
                     }
                  }
               }
            }
         }

         addResistanceModifiersFromEntityEffects(var4, var3);
         class="kw">return var4;
      }

      class="kw">private class="kw">static void calculateResistanceEntryModifications(
         @Nonnull Entry<DamageCause, ResistanceModifier[]> var0,
         @Nonnull World var1,
         @Nonnull Map<DamageCause, DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers> var2,
         boolean var3,
         boolean var4,
         double var5
      ) {
         DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers var7 = var2.computeIfAbsent(
            var0.getKey(), var0x -> new DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers()
         );
         ResistanceModifier[] var8 = var0.getValue();

         for (int var9 = 0; var9 < var8.length; var9++) {
            ResistanceModifier var10 = var8[var9];
            if (var10.getCalculationType() == ResistanceModifier.ResistanceCalculationType.FLAT) {
               var7.flatModifier = var7.flatModifier + var10.getAmount();
            } else {
               var7.multiplierModifier = var7.multiplierModifier + var10.getAmount();
            }
         }

         var7.flatModifier += (float)var5;
         DamageCause var13 = var0.getKey();
         if (var13 != null && var13.getInherits() != null) {
            var7.inheritedParentId = DamageCause.getAssetMap().getAsset(var13.getInherits());
         }

         if (var3 && var4) {
            BrokenPenalties var14 = var1.getGameplayConfig().getItemDurabilityConfig().getBrokenPenalties();
            double var11 = var14.getWeapon(0.0);
            var7.flatModifier *= (float)(1.0 - var11);
            var7.multiplierModifier *= (float)(1.0 - var11);
         }
      }

      class="kw">private class="kw">static void addResistanceModifiersFromEntityEffects(
         Map<DamageCause, DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers> var0, EffectControllerComponent var1
      ) {
         if (var1 != null) {
            IntIterator var2 = var1.getActiveEffects().keySet().iterator();

            while (var2.hasNext()) {
               int var3 = (Integer)var2.next();
               EntityEffect var4 = EntityEffect.getAssetMap().getAsset(var3);
               if (var4 != null) {
                  Map var5 = var4.getDamageResistanceValues();
                  if (var5 != null && !var5.isEmpty()) {
                     for (Entry var7 : var5.entrySet()) {
                        DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers var8 = var0.computeIfAbsent(
                           var7.getKey(), var0x -> new DamageSystems.ArmorDamageReduction.ArmorResistanceModifiers()
                        );

                        for (ResistanceModifier var12 : var7.getValue()) {
                           if (var12.getCalculationType() == ResistanceModifier.ResistanceCalculationType.FLAT) {
                              var8.flatModifier = var8.flatModifier + var12.getAmount();
                           } else if (var12.getCalculationType() == ResistanceModifier.ResistanceCalculationType.PERCENT) {
                              var8.multiplierModifier = var8.multiplierModifier + var12.getAmount();
                           }
                        }
                     }
                  }
               }
            }
         }
      }

      class="kw">public class="kw">static class ArmorResistanceModifiers {
         class="kw">public float flatModifier;
         class="kw">public float multiplierModifier;
         @Nullable
         class="kw">public DamageCause inheritedParentId;

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

   @Deprecated
   class="kw">public class="kw">static class ArmorKnockbackReduction class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         AllLegacyLivingEntityTypesQuery.INSTANCE,
         InventoryComponent.Armor.getComponentType(),
         DamageDataComponent.getComponentType(),
         TRANSFORM_COMPONENT_TYPE
      );

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
      }

      class="kw">public void handleInternal(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         InventoryComponent.Armor var6 = var2.getComponent(var1, InventoryComponent.Armor.getComponentType());
         assert var6 != null;
         ItemContainer var7 = var6.getInventory();
         if (var7 != null) {
            KnockbackComponent var8 = var5.getIfPresentMetaObject(Damage.KNOCKBACK_COMPONENT);
            if (var8 != null) {
               float var9 = 0.0F;

               for (short var10 = 0; var10 < var7.getCapacity(); var10++) {
                  ItemStack var11 = var7.getItemStack(var10);
                  if (var11 != null && !var11.isEmpty()) {
                     Item var12 = var11.getItem();
                     ItemArmor var13 = var12.getArmor();
                     if (var13 != null) {
                        Map var14 = var13.getKnockbackResistances();
                        if (var14 != null) {
                           DamageCause var15 = var5.getCause();
                           var9 += var14.get(var15);
                        }
                     }
                  }
               }

               var8.addModifier(Math.max(1.0F - var9, 0.0F));
            }
         }
      }
   }

   class="kw">public class="kw">static class BreathingSystem class="kw">extends DelayedEntitySystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         BreathingComponent.getComponentType(), TransformComponent.getComponentType(), ModelComponent.getComponentType()
      );

      class="kw">public BreathingSystem() {
         super(1.0F);
      }

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

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

      @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);
         BreathingComponent var7 = var3.getComponent(var2, BreathingComponent.getComponentType());
         assert var7 != null;
         CachedStatsComponent var8 = var3.getComponent(var2, CachedStatsComponent.getComponentType());
         boolean var9 = var3.getArchetype().contains(Invulnerable.getComponentType());
         EntityUtils.processEntityBreathing(var6, var7, var8, var9, false, var5);
      }

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

   class="kw">public class="kw">static class CanBreathe class="kw">extends DelayedEntitySystem<EntityStore> {
      class="kw">private class="kw">static class="kw">final float DAMAGE_AMOUNT_DROWNING = 10.0F;
      class="kw">private class="kw">static class="kw">final float DAMAGE_AMOUNT_SUFFOCATION = 20.0F;
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(BreathingComponent.getComponentType(), EntityStatMap.getComponentType());

      class="kw">public CanBreathe() {
         super(1.0F);
      }

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

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

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return Set.of(new SystemDependency<>(Order.AFTER, DamageSystems.BreathingSystem.class));
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         BreathingComponent var6 = var3.getComponent(var2, BreathingComponent.getComponentType());
         assert var6 != null;
         if (var6.isSuffocating()) {
            EntityStatMap var7 = var3.getComponent(var2, EntityStatMap.getComponentType());
            assert var7 != null;
            EntityStatValue var8 = var7.get(DefaultEntityStatTypes.getOxygen());
            if (var8 != null && !(var8.get() > var8.getMin())) {
               Damage var9;
               if (var6.getLastFluidId() != 0) {
                  assert DamageCause.DROWNING != null;
                  var9 = new Damage(Damage.NULL_SOURCE, DamageCause.DROWNING, 10.0F);
               } else {
                  assert DamageCause.SUFFOCATION != null;
                  var9 = new Damage(Damage.NULL_SOURCE, DamageCause.SUFFOCATION, 20.0F);
               }

               DamageSystems.executeDamage(var2, var3, var5, var9);
            }
         }
      }

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

   class="kw">public class="kw">static class DamageArmor class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = AllLegacyLivingEntityTypesQuery.INSTANCE;

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         Ref var6 = var2.getReferenceTo(var1);
         DamageCause var7 = var5.getCause();
         if (var7.isDurabilityLoss()) {
            InventoryComponent.Armor var8 = var4.getComponent(var6, InventoryComponent.Armor.getComponentType());
            if (var8 != null) {
               ItemContainer var9 = var8.getInventory();
               ShortArrayList var10 = new ShortArrayList();
               var9.forEachWithMeta((var0, var1x, var2x) -> {
                  if (!var1x.isBroken()) {
                     var2x.add(var0);
                  }
               }, var10);
               if (!var10.isEmpty()) {
                  short var11 = var10.getShort(RandomExtra.randomRange(var10.size()));
                  ItemUtils.decreaseItemStackDurability(var6, var9.getItemStack(var11), -3, var11, var4);
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class DamageAttackerTool class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(AllLegacyLivingEntityTypesQuery.INSTANCE, InventoryComponent.Hotbar.getComponentType());

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         if (var5.getCause().isDurabilityLoss() && var5.getSource() class="kw">instanceof Damage.EntitySource var6) {
            Ref var11 = var6.getRef();
            if (var11.isValid()) {
               InventoryComponent.Hotbar var8 = var4.getComponent(var11, InventoryComponent.Hotbar.getComponentType());
               if (var8 != null) {
                  byte var9 = var8.getActiveSlot();
                  if (var9 != -1) {
                     ItemStack var10 = InventoryComponent.getItemInHand(var4, var11);
                     ItemUtils.decreaseItemStackDurability(var11, var10, -1, var9, var4);
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class DamageStamina class="kw">extends DamageEventSystem class="kw">implements EntityStatsSystems.StatModifyingSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(DamageDataComponent.getComponentType(), EntityStatMap.getComponentType());

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
      }

      class="kw">public void handleInternal(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         EntityStatMap var6 = var2.getComponent(var1, EntityStatMap.getComponentType());
         assert var6 != null;
         DamageDataComponent var7 = var2.getComponent(var1, DamageDataComponent.getComponentType());
         assert var7 != null;
         if (var7.getCurrentWielding() != null) {
            WieldingInteraction.StaminaCost var8 = var7.getCurrentWielding().getStaminaCost();
            if (var8 != null) {
               Boolean var9 = var5.getMetaStore().getIfPresentMetaObject(Damage.BLOCKED);
               if (var9 != null && var9) {
                  float var10 = var8.computeStaminaAmountToConsume(var5.getInitialAmount(), var6);
                  Float var11 = var5.getIfPresentMetaObject(Damage.STAMINA_DRAIN_MULTIPLIER);
                  if (var11 != null) {
                     var10 *= var11;
                  }

                  var6.subtractStatValue(DefaultEntityStatTypes.getStamina(), var10);
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class EntityUIEvents class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, EntityTrackerSystems.Visible> visibleComponentType = EntityModule.get().getVisibleComponentType();
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, UIComponentList> uiComponentListComponentType = EntityUIModule.get().getUIComponentListType();
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(this.visibleComponentType, this.uiComponentListComponentType);

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         if (!(var5.getAmount() <= 0.0F)) {
            if (var5.getSource() class="kw">instanceof Damage.EntitySource var6) {
               Ref var11 = var6.getRef();
               if (var11.isValid()) {
                  PlayerRef var8 = var4.getComponent(var11, PlayerRef.getComponentType());
                  if (var8 != null && var8.isValid()) {
                     EntityTrackerSystems.EntityViewer var9 = var4.getComponent(var11, EntityTrackerSystems.EntityViewer.getComponentType());
                     if (var9 != null) {
                        Float var10 = var5.getIfPresentMetaObject(Damage.HIT_ANGLE);
                        queueUpdateFor(var2.getReferenceTo(var1), var5.getAmount(), var10, var9);
                     }
                  }
               }
            }
         }
      }

      class="kw">private class="kw">static void queueUpdateFor(@Nonnull Ref<EntityStore> var0, float var1, @Nullable Float var2, @Nonnull EntityTrackerSystems.EntityViewer var3) {
         CombatTextUpdate var4 = new CombatTextUpdate(var2 == null ? 0.0F : var2, Integer.toString((int)Math.floor(var1)));
         var3.queueUpdate(var0, var4);
      }
   }

   class="kw">public class="kw">static class FallDamageNPCs class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">static class="kw">final float CURVE_MODIFIER = 0.58F;
      class="kw">static class="kw">final float CURVE_MULTIPLIER = 2.0F;
      class="kw">public class="kw">static class="kw">final double MIN_DAMAGE = 10.0;

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

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

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

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull Store<EntityStore> var3) {
         World var4 = var3.getExternalData().getWorld();
         if (var4.getWorldConfig().isFallDamageEnabled()) {
            super.tick(var1, var2, var3);
         }
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         LivingEntity var6 = (LivingEntity)EntityUtils.getEntity(var2, var3);
         assert var6 != null;
         MovementStatesComponent var7 = var3.getComponent(var2, MovementStatesComponent.getComponentType());
         assert var7 != null;
         MovementStates var8 = var7.getMovementStates();
         if (var8.onGround && var6.getCurrentFallDistance() > 0.0) {
            Velocity var9 = var3.getComponent(var2, Velocity.getComponentType());
            assert var9 != null;
            double var10 = Math.abs(var9.getVelocity().y());
            World var12 = var5.getExternalData().getWorld();
            int var13 = var12.getGameplayConfig().getPlayerConfig().getMovementConfigIndex();
            MovementConfig var14 = MovementConfig.getAssetMap().getAsset(var13);
            float var15 = var14.getMinFallSpeedToEngageRoll();
            if (var10 > var15 && !var8.inFluid) {
               EntityStatMap var16 = var3.getComponent(var2, EntityStatMap.getComponentType());
               assert var16 != null;
               double var17 = Math.pow(0.58F * (var10 - var15), 2.0) + 10.0;
               EntityStatValue var19 = var16.get(DefaultEntityStatTypes.getHealth());
               assert var19 != null;
               float var20 = var19.getMax();
               double var21 = var20 / 100.0;
               int var23 = (int)Math.floor(var21 * var17);
               if (var8.rolling) {
                  if (var10 <= var14.getMaxFallSpeedRollFullMitigation()) {
                     var23 = 0;
                  } else if (var10 <= var14.getMaxFallSpeedToEngageRoll()) {
                     var23 = (int)(var23 * (1.0 - var14.getFallDamagePartialMitigationPercent() / 100.0));
                  }
               }

               if (var23 > 0) {
                  assert DamageCause.FALL != null;
                  Damage var24 = new Damage(Damage.NULL_SOURCE, DamageCause.FALL, var23);
                  DamageSystems.executeDamage(var2, var3, var5, var24);
               }
            }

            var6.setCurrentFallDistance(0.0);
         }
      }

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

   class="kw">public class="kw">static class FallDamagePlayers class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">static class="kw">final float CURVE_MODIFIER = 0.58F;
      class="kw">static class="kw">final float CURVE_MULTIPLIER = 2.0F;
      class="kw">public class="kw">static class="kw">final double MIN_DAMAGE = 10.0;
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         EntityStatMap.getComponentType(),
         MovementStatesComponent.getComponentType(),
         EntityModule.get().getPlayerComponentType(),
         PlayerInput.getComponentType()
      );
      @Nonnull
      class="kw">private class="kw">static class="kw">final Set<Dependency<EntityStore>> DEPENDENCIES = Set.of(new SystemDependency<>(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class));

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

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

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

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

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull Store<EntityStore> var3) {
         World var4 = var3.getExternalData().getWorld();
         if (var4.getWorldConfig().isFallDamageEnabled()) {
            super.tick(var1, var2, var3);
         }
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         PlayerInput var6 = var3.getComponent(var2, PlayerInput.getComponentType());
         assert var6 != null;
         Velocity var7 = var3.getComponent(var2, Velocity.getComponentType());
         assert var7 != null;
         double var8 = Math.abs(var7.getClientVelocity().y());
         World var10 = var5.getExternalData().getWorld();
         PlayerConfig var11 = var10.getGameplayConfig().getPlayerConfig();
         List var12 = var6.getMovementUpdateQueue();

         for (int var13 = 0; var13 < var12.size(); var13++) {
            PlayerInput.InputUpdate var14 = var12.get(var13);
            class="kw">switch (var14) {
               case PlayerInput.SetClientVelocity var17:
                  var8 = Math.abs(var17.getVelocity().y);
                  break;
               case PlayerInput.SetMovementStates var18:
                  Player var19 = var3.getComponent(var2, Player.getComponentType());
                  assert var19 != null;
                  if (var18.movementStates().onGround && var19.getCurrentFallDistance() > 0.0) {
                     int var20 = var11.getMovementConfigIndex();
                     MovementConfig var21 = MovementConfig.getAssetMap().getAsset(var20);
                     float var22 = var21.getMinFallSpeedToEngageRoll();
                     if (var8 > var22 && !var18.movementStates().inFluid) {
                        EntityStatMap var23 = var3.getComponent(var2, EntityStatMap.getComponentType());
                        assert var23 != null;
                        double var24 = Math.pow(0.58F * (var8 - var22), 2.0) + 10.0;
                        EntityStatValue var26 = var23.get(DefaultEntityStatTypes.getHealth());
                        assert var26 != null;
                        float var27 = var26.getMax();
                        double var28 = var27 / 100.0;
                        int var30 = (int)Math.floor(var28 * var24);
                        if (var18.movementStates().rolling) {
                           if (var8 <= var21.getMaxFallSpeedRollFullMitigation()) {
                              var30 = 0;
                           } else if (var8 <= var21.getMaxFallSpeedToEngageRoll()) {
                              var30 = (int)(var30 * (1.0 - var21.getFallDamagePartialMitigationPercent() / 100.0));
                           }
                        }

                        if (var30 > 0) {
                           assert DamageCause.FALL != null;
                           Damage var31 = new Damage(Damage.NULL_SOURCE, DamageCause.FALL, var30);
                           DamageSystems.executeDamage(var2, var3, var5, var31);
                        }
                     }

                     var19.setCurrentFallDistance(0.0);
                  }
                  break;
               class="kw">default:
            }
         }
      }

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

   class="kw">public class="kw">static class FilterNPCWorldConfig class="kw">extends DamageEventSystem {
      class="kw">public FilterNPCWorldConfig() {
      }

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

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return DamageSystems.NPCS_QUERY;
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         World var6 = var3.getExternalData().getWorld();
         GameplayConfig var7 = var6.getGameplayConfig();
         if (var7.getCombatConfig().isNpcIncomingDamageDisabled()) {
            var5.setCancelled(true);
            Ref var8 = var2.getReferenceTo(var1);
            var4.tryRemoveComponent(var8, KnockbackComponent.getComponentType());
         }
      }
   }

   class="kw">public class="kw">static class FilterPlayerWorldConfig class="kw">extends DamageEventSystem {
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(AllLegacyLivingEntityTypesQuery.INSTANCE, Player.getComponentType());

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

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

      @Nullable
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return QUERY;
      }

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         World var6 = var3.getExternalData().getWorld();
         GameplayConfig var7 = var6.getGameplayConfig();
         if (var7.getCombatConfig().isPlayerIncomingDamageDisabled()) {
            var5.setCancelled(true);
            Ref var8 = var2.getReferenceTo(var1);
            var4.tryRemoveComponent(var8, KnockbackComponent.getComponentType());
         }
      }
   }

   class="kw">public class="kw">static class FilterUnkillable class="kw">extends DamageEventSystem {
      class="kw">public class="kw">static boolean CAUSE_DESYNC;
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = AllLegacyLivingEntityTypesQuery.INSTANCE;

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         EffectControllerComponent var6 = var2.getComponent(var1, EffectControllerComponent.getComponentType());
         if (var6 != null && var6.isInvulnerable()) {
            var5.setCancelled(true);
         }

         Archetype var7 = var2.getArchetype();
         boolean var8 = var7.contains(DeathComponent.getComponentType());
         boolean var9 = var7.contains(Invulnerable.getComponentType());
         boolean var10 = var7.contains(Intangible.getComponentType());
         if (var8 || var9 || var10 || CAUSE_DESYNC) {
            var5.setCancelled(true);
         }
      }
   }

   @Deprecated
   class="kw">public class="kw">static class HackKnockbackValues class="kw">extends EntityTickingSystem<EntityStore> {
      class="kw">public class="kw">static float PLAYER_KNOCKBACK_SCALE = 25.0F;
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(AllLegacyLivingEntityTypesQuery.INSTANCE, KnockbackComponent.getComponentType());

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

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

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

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         KnockbackComponent var6 = var3.getComponent(var2, KnockbackComponent.getComponentType());
         assert var6 != null;
         if (var6.getVelocityConfig() == null || SplitVelocity.SHOULD_MODIFY_VELOCITY) {
            Vector3d var7 = var6.getVelocity();
            var7.x = var7.x * PLAYER_KNOCKBACK_SCALE;
            var7.z = var7.z * PLAYER_KNOCKBACK_SCALE;
            var6.setVelocity(var7);
         }
      }

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

   class="kw">public class="kw">static class HitAnimation class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(Query.not(DeathComponent.getComponentType()), MovementStatesComponent.getComponentType());

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         ModelComponent var6 = var2.getComponent(var1, ModelComponent.getComponentType());
         Model var7 = var6 != null ? var6.getModel() : null;
         MovementStatesComponent var8 = var2.getComponent(var1, MovementStatesComponent.getComponentType());
         assert var8 != null;
         MovementStates var9 = var8.getMovementStates();
         if (!(var5.getAmount() <= 0.0F)) {
            String[] var10 = Entity.DefaultAnimations.getHurtAnimationIds(var9, var5.getCause());
            if (var7 != null) {
               String var11 = var7.getFirstBoundAnimationId(var10);
               if (var11 != null) {
                  AnimationUtils.playAnimation(var2.getReferenceTo(var1), AnimationSlot.Status, var11, true, var4);
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class InvulnerableBreathing class="kw">extends RefChangeSystem<EntityStore, Invulnerable> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, Invulnerable> invulnerableComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, BreathingComponent> breathingComponentType;

      class="kw">public InvulnerableBreathing(@Nonnull ComponentType<EntityStore, Invulnerable> var1, @Nonnull ComponentType<EntityStore, BreathingComponent> var2) {
         this.invulnerableComponentType = var1;
         this.breathingComponentType = var2;
      }

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

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

      class="kw">public void onComponentAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull Invulnerable var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         BreathingComponent var5 = var4.getComponent(var1, BreathingComponent.getComponentType());
         assert var5 != null;
         CachedStatsComponent var6 = var4.getComponent(var1, CachedStatsComponent.getComponentType());
         EntityUtils.processEntityBreathing(var1, var5, var6, true, true, var4);
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<EntityStore> var1,
         Invulnerable var2,
         @Nonnull Invulnerable var3,
         @Nonnull Store<EntityStore> var4,
         @Nonnull CommandBuffer<EntityStore> var5
      ) {
         BreathingComponent var6 = var5.getComponent(var1, BreathingComponent.getComponentType());
         assert var6 != null;
         CachedStatsComponent var7 = var5.getComponent(var1, CachedStatsComponent.getComponentType());
         EntityUtils.processEntityBreathing(var1, var6, var7, true, true, var5);
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<EntityStore> var1, @Nonnull Invulnerable var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         BreathingComponent var5 = var4.getComponent(var1, BreathingComponent.getComponentType());
         assert var5 != null;
         CachedStatsComponent var6 = var4.getComponent(var1, CachedStatsComponent.getComponentType());
         EntityUtils.processEntityBreathing(var1, var5, var6, false, true, var4);
      }
   }

   class="kw">public class="kw">static class OutOfWorldDamage class="kw">extends DelayedEntitySystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();

      class="kw">public OutOfWorldDamage() {
         super(1.0F);
      }

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

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

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         TransformComponent var6 = var3.getComponent(var2, TRANSFORM_COMPONENT_TYPE);
         assert var6 != null;
         double var7 = var6.getPosition().y();
         if (!(var7 >= 0.0)) {
            boolean var9 = var7 < -32.0;
            Damage var10 = new Damage(Damage.NULL_SOURCE, DamageCause.OUT_OF_WORLD, var9 ? 2.1474836E9F : 50.0F);
            if (var9) {
               DeathComponent.tryAddComponent(var5, var3.getReferenceTo(var2), var10);
            } else {
               DamageSystems.executeDamage(var2, var3, var5, var10);
            }
         }
      }

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

   class="kw">public class="kw">static class PlayerDamageFilterSystem class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Player.getComponentType();

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         World var6 = var3.getExternalData().getWorld();
         Player var7 = var2.getComponent(var1, Player.getComponentType());
         assert var7 != null;
         if (var7.hasSpawnProtection()) {
            var5.setCancelled(true);
         } else {
            if (!var6.getWorldConfig().isPvpEnabled() && var5.getSource() class="kw">instanceof Damage.EntitySource var8) {
               Ref var10 = var8.getRef();
               if (var10.isValid() && var4.getComponent(var10, Player.getComponentType()) != null) {
                  var5.setCancelled(true);
                  class="kw">return;
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class PlayerHitIndicators class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = PlayerRef.getComponentType();

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         PlayerRef var6 = var2.getComponent(var1, PlayerRef.getComponentType());
         assert var6 != null;
         if (var5.getSource() class="kw">instanceof Damage.EntitySource var7) {
            Ref var12 = var7.getRef();
            if (var12.isValid()) {
               DamageCause var9 = var5.getCause();
               if (var9 != null) {
                  TransformComponent var10 = var4.getComponent(var12, TRANSFORM_COMPONENT_TYPE);
                  if (var10 != null) {
                     Vector3d var11 = var10.getPosition();
                     var6.getPacketHandler()
                        .writeNoCache(
                           new DamageInfo(new com.hypixel.hytale.protocol.Vector3d(var11.x(), var11.y(), var11.z()), var5.getAmount(), var9.toPacket())
                        );
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class RecordLastCombat class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, DamageDataComponent> DAMAGE_DATA_COMPONENT_TYPE = DamageDataComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final ResourceType<EntityStore, TimeResource> TIME_RESOURCE_TYPE = TimeResource.getResourceType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = DAMAGE_DATA_COMPONENT_TYPE;

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         DamageDataComponent var6 = var2.getComponent(var1, DAMAGE_DATA_COMPONENT_TYPE);
         assert var6 != null;
         Instant var7 = var3.getResource(TIME_RESOURCE_TYPE).getNow();
         var6.setLastCombatAction(var7);
         if (var5.getSource() class="kw">instanceof Damage.EntitySource var8) {
            Ref var11 = var8.getRef();
            if (!var11.isValid()) {
               class="kw">return;
            }

            DamageDataComponent var10 = var3.getComponent(var11, DAMAGE_DATA_COMPONENT_TYPE);
            if (var10 != null) {
               var10.setLastCombatAction(var7);
            }
         }
      }

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

   class="kw">public class="kw">static class ReticleEvents class="kw">extends DamageEventSystem {
      class="kw">private class="kw">static class="kw">final int EVENT_ON_HIT_TAG_INDEX = AssetRegistry.getOrCreateTagIndex("OnHit");
      class="kw">private class="kw">static class="kw">final int EVENT_ON_KILL_TAG_INDEX = AssetRegistry.getOrCreateTagIndex("OnKill");
      class="kw">private class="kw">static class="kw">final ReticleEvent ON_HIT = new ReticleEvent(EVENT_ON_HIT_TAG_INDEX);
      class="kw">private class="kw">static class="kw">final ReticleEvent ON_KILL = new ReticleEvent(EVENT_ON_KILL_TAG_INDEX);

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         boolean var6 = var2.getArchetype().contains(DeathComponent.getComponentType());
         if (!(var5.getAmount() <= 0.0F)) {
            if (var5.getSource() class="kw">instanceof Damage.EntitySource var7) {
               Ref var10 = var7.getRef();
               if (var10.isValid()) {
                  PlayerRef var9 = var4.getComponent(var10, PlayerRef.getComponentType());
                  if (var9 != null && var9.isValid()) {
                     var9.getPacketHandler().writeNoCache(var6 ? ON_KILL : ON_HIT);
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class TrackLastDamage class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, DamageDataComponent> DAMAGE_DATA_COMPONENT_TYPE = DamageDataComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(AllLegacyLivingEntityTypesQuery.INSTANCE, DAMAGE_DATA_COMPONENT_TYPE);

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         TimeResource var6 = var4.getResource(TimeResource.getResourceType());
         DamageDataComponent var7 = var2.getComponent(var1, DAMAGE_DATA_COMPONENT_TYPE);
         assert var7 != null;
         var7.setLastDamageTime(var6.getNow());
      }
   }

   @Deprecated
   class="kw">public class="kw">static class WieldingDamageReduction class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         AllLegacyLivingEntityTypesQuery.INSTANCE,
         DamageDataComponent.getComponentType(),
         InteractionModule.get().getInteractionManagerComponent(),
         TRANSFORM_COMPONENT_TYPE
      );

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         DamageDataComponent var6 = var2.getComponent(var1, DamageDataComponent.getComponentType());
         assert var6 != null;
         InteractionManager var7 = var2.getComponent(var1, InteractionModule.get().getInteractionManagerComponent());
         assert var7 != null;
         WieldingInteraction var8 = var6.getCurrentWielding();
         if (var8 != null) {
            WieldingInteraction.AngledWielding var9 = var8.getAngledWielding();
            Ref var10 = var2.getReferenceTo(var1);
            TransformComponent var11 = var2.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
            assert var11 != null;
            Vector3d var12 = var11.getPosition();
            Rotation3f var13 = var11.getRotation();
            if (var5.getSource() class="kw">instanceof Damage.EntitySource var14) {
               Ref var27 = var14.getRef();
               if (var27.isValid()) {
                  TransformComponent var16 = var4.getComponent(var27, TRANSFORM_COMPONENT_TYPE);
                  if (var16 != null) {
                     int var17 = var5.getDamageCauseIndex();
                     float var18 = 1.0F;
                     float var19 = 1.0F;
                     String var20 = null;
                     Int2FloatMap var21 = var8.getDamageModifiers();
                     if (!var21.isEmpty()) {
                        var18 = var21.getOrDefault(var17, 1.0F);
                        DamageEffects var22 = var8.getBlockedEffects();
                        if (var22 != null) {
                           var22.addToDamage(var5);
                        }

                        String var23 = var8.getBlockedInteractions();
                        if (var23 != null) {
                           var20 = var23;
                        }

                        var5.putMetaObject(Damage.BLOCKED, Boolean.TRUE);
                     }

                     if (var9 != null) {
                        Int2FloatMap var28 = var9.getDamageModifiers();
                        if (var28.containsKey(var17)) {
                           Vector3d var30 = var16.getPosition();
                           float var24 = TrigMathUtil.atan2(var30.x - var12.x, var30.z - var12.z);
                           var24 = MathUtil.wrapAngle(var24 + (float) Math.PI - var13.yaw());
                           if (Math.abs(MathUtil.compareAngle(var24, var9.getAngleRad())) < var9.getAngleDistanceRad()) {
                              var19 = var28.getOrDefault(var17, 1.0F);
                              DamageEffects var25 = var8.getBlockedEffects();
                              if (var25 != null) {
                                 var25.addToDamage(var5);
                              }

                              String var26 = var8.getBlockedInteractions();
                              if (var26 != null) {
                                 var20 = var26;
                              }

                              var5.putMetaObject(Damage.BLOCKED, Boolean.TRUE);
                           }
                        }
                     }

                     var5.setAmount(var5.getAmount() * var18 * var19);
                     if (var20 != null) {
                        NetworkId var29 = var4.getComponent(var27, NetworkId.getComponentType());
                        if (var29 != null) {
                           InteractionContext var31 = InteractionContext.forInteraction(var7, var10, InteractionType.Wielding, var4);
                           DynamicMetaStore var33 = var31.getMetaStore();
                           var33.putMetaObject(Interaction.TARGET_ENTITY, var27);
                           var33.putMetaObject(Interaction.DAMAGE, var5);
                           int var34 = var29.getId();
                           InteractionChain var35 = var7.initChain(
                              InteractionType.Wielding, var31, RootInteraction.getRootInteractionOrUnknown(var20), var34, null, false
                           );
                           var7.queueExecuteChain(var35);
                        }
                     }
                  }
               }
            }
         }
      }
   }

   @Deprecated
   class="kw">public class="kw">static class WieldingKnockbackReduction class="kw">extends DamageEventSystem {
      @Nonnull
      class="kw">private class="kw">static class="kw">final ComponentType<EntityStore, TransformComponent> TRANSFORM_COMPONENT_TYPE = TransformComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">static class="kw">final Query<EntityStore> QUERY = Query.and(
         AllLegacyLivingEntityTypesQuery.INSTANCE, DamageDataComponent.getComponentType(), TRANSFORM_COMPONENT_TYPE
      );

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

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

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

      class="kw">public void handle(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
      }

      class="kw">public void handleInternal(
         int var1, @Nonnull ArchetypeChunk<EntityStore> var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4, @Nonnull Damage var5
      ) {
         DamageDataComponent var6 = var2.getComponent(var1, DamageDataComponent.getComponentType());
         assert var6 != null;
         TransformComponent var7 = var2.getComponent(var1, TRANSFORM_COMPONENT_TYPE);
         assert var7 != null;
         WieldingInteraction var8 = var6.getCurrentWielding();
         if (var8 != null) {
            Int2DoubleMap var9 = var8.getKnockbackModifiers();
            WieldingInteraction.AngledWielding var10 = var8.getAngledWielding();
            KnockbackComponent var11 = var5.getIfPresentMetaObject(Damage.KNOCKBACK_COMPONENT);
            if (var11 != null) {
               if (var5.getSource() class="kw">instanceof Damage.EntitySource var12) {
                  Ref var24 = var12.getRef();
                  if (var24.isValid()) {
                     TransformComponent var14 = var4.getComponent(var24, TRANSFORM_COMPONENT_TYPE);
                     if (var14 != null) {
                        int var15 = var5.getDamageCauseIndex();
                        double var16 = 1.0;
                        double var18 = var9.getOrDefault(var15, 1.0);
                        if (var10 != null) {
                           Int2DoubleMap var20 = var10.getKnockbackModifiers();
                           if (var20.containsKey(var15)) {
                              Vector3d var21 = var7.getPosition();
                              Vector3d var22 = var14.getPosition();
                              float var23 = TrigMathUtil.atan2(var22.x - var21.x, var22.z - var21.z);
                              var23 = MathUtil.wrapAngle(var23 + (float) Math.PI - var7.getRotation().yaw());
                              if (Math.abs(MathUtil.compareAngle(var23, var10.getAngleRad())) < var10.getAngleDistanceRad()) {
                                 var16 = var20.getOrDefault(var15, 1.0);
                              }
                           }
                        }

                        var11.addModifier(var18);
                        var11.addModifier(var16);
                     }
                  }
               }
            }
         }
      }
   }
}