class="kw">package com.hypixel.hytale.builtin.deployables.config;

class="kw">import com.hypixel.hytale.builtin.deployables.DeployablesUtils;
class="kw">import com.hypixel.hytale.builtin.deployables.component.DeployableComponent;
class="kw">import com.hypixel.hytale.builtin.deployables.component.DeployableProjectileComponent;
class="kw">import com.hypixel.hytale.builtin.deployables.component.DeployableProjectileShooterComponent;
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.map.MapCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Rotation3fc;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.BlockMaterial;
class="kw">import com.hypixel.hytale.protocol.Opacity;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.group.EntityGroup;
class="kw">import com.hypixel.hytale.server.core.entity.knockback.KnockbackComponent;
class="kw">import com.hypixel.hytale.server.core.modules.debug.DebugUtils;
class="kw">import com.hypixel.hytale.server.core.modules.entity.DespawnComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.combat.Knockback;
class="kw">import com.hypixel.hytale.server.core.modules.projectile.config.ProjectileConfig;
class="kw">import com.hypixel.hytale.server.core.modules.projectile.config.StandardPhysicsProvider;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
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 com.hypixel.hytale.server.core.util.TargetUtil;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.time.Instant;
class="kw">import java.time.temporal.ChronoUnit;
class="kw">import java.util.Collections;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.atomic.AtomicReference;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3dc;
class="kw">import org.joml.Vector3f;
class="kw">import org.joml.Vector3i;

class="kw">public class DeployableTurretConfig class="kw">extends DeployableConfig {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<DeployableTurretConfig> CODEC = BuilderCodec.builder(
         DeployableTurretConfig.class, DeployableTurretConfig::new, DeployableConfig.BASE_CODEC
      )
      .appendInherited(
         new KeyedCodec<>("TrackableRadius", Codec.FLOAT),
         (var0, var1) -> var0.trackableRadius = var1,
         var0 -> var0.trackableRadius,
         (var0, var1) -> var0.trackableRadius = var1.trackableRadius
      )
      .documentation("The radius in which a targeted entity can be tracked")
      .add()
      .<Float>appendInherited(
         new KeyedCodec<>("DetectionRadius", Codec.FLOAT),
         (var0, var1) -> var0.detectionRadius = var1,
         var0 -> var0.detectionRadius,
         (var0, var1) -> var0.detectionRadius = var1.detectionRadius
      )
      .documentation("The radius in which an entity can be targeted")
      .add()
      .<Float>appendInherited(
         new KeyedCodec<>("RotationSpeed", Codec.FLOAT),
         (var0, var1) -> var0.rotationSpeed = var1,
         var0 -> var0.rotationSpeed,
         (var0, var1) -> var0.rotationSpeed = var1.rotationSpeed
      )
      .documentation("The speed at which the turret can rotate to hit it's target")
      .add()
      .<Boolean>appendInherited(
         new KeyedCodec<>("PreferOwnerTarget", Codec.BOOLEAN),
         (var0, var1) -> var0.preferOwnerTarget = var1,
         var0 -> var0.preferOwnerTarget,
         (var0, var1) -> var0.preferOwnerTarget = var1.preferOwnerTarget
      )
      .documentation("If true, will prefer targeting entities that the owner is attacking")
      .add()
      .<Integer>appendInherited(
         new KeyedCodec<>("Ammo", Codec.INTEGER), (var0, var1) -> var0.ammo = var1, var0 -> var0.ammo, (var0, var1) -> var0.ammo = var1.ammo
      )
      .documentation("The total ammo the turret has, each projectile will consume one")
      .add()
      .<Float>appendInherited(
         new KeyedCodec<>("DeployDelay", Codec.FLOAT),
         (var0, var1) -> var0.deployDelay = var1,
         var0 -> var0.deployDelay,
         (var0, var1) -> var0.deployDelay = var1.deployDelay
      )
      .documentation("The delay in seconds until the deployable is ready to begin targeting logic")
      .add()
      .<ProjectileConfig>appendInherited(
         new KeyedCodec<>("ProjectileConfig", ProjectileConfig.CODEC),
         (var0, var1) -> var0.projectileConfig = var1,
         var0 -> var0.projectileConfig,
         (var0, var1) -> var0.projectileConfig = var1.projectileConfig
      )
      .addValidator(Validators.nonNull())
      .add()
      .appendInherited(
         new KeyedCodec<>("ShotInterval", Codec.FLOAT),
         (var0, var1) -> var0.shotInterval = var1,
         var0 -> var0.shotInterval,
         (var0, var1) -> var0.shotInterval = var1.shotInterval
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("BurstCount", Codec.INTEGER),
         (var0, var1) -> var0.burstCount = var1,
         var0 -> var0.burstCount,
         (var0, var1) -> var0.burstCount = var1.burstCount
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("BurstCooldown", Codec.FLOAT),
         (var0, var1) -> var0.burstCooldown = var1,
         var0 -> var0.burstCooldown,
         (var0, var1) -> var0.burstCooldown = var1.burstCooldown
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("ProjectileDamage", Codec.FLOAT),
         (var0, var1) -> var0.projectileDamage = var1,
         var0 -> var0.projectileDamage,
         (var0, var1) -> var0.projectileDamage = var1.projectileDamage
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("CanShootOwner", Codec.BOOLEAN),
         (var0, var1) -> var0.canShootOwner = var1,
         var0 -> var0.canShootOwner,
         (var0, var1) -> var0.canShootOwner = var1.canShootOwner
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("Knockback", Knockback.CODEC),
         (var0, var1) -> var0.projectileKnockback = var1,
         var0 -> var0.projectileKnockback,
         (var0, var1) -> var0.projectileKnockback = var1.projectileKnockback
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("TargetOffset", Vector3dUtil.CODEC),
         (var0, var1) -> var0.targetOffset = var1,
         var0 -> var0.targetOffset,
         (var0, var1) -> var0.targetOffset = var1.targetOffset
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("DoLineOfSightTest", Codec.BOOLEAN),
         (var0, var1) -> var0.doLineOfSightTest = var1,
         var0 -> var0.doLineOfSightTest,
         (var0, var1) -> var0.doLineOfSightTest = var1.doLineOfSightTest
      )
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("ProjectileHitWorldSoundEventId", Codec.STRING),
         (var0, var1) -> var0.projectileHitWorldSoundEventId = var1,
         var0 -> var0.projectileHitWorldSoundEventId,
         (var0, var1) -> var0.projectileHitWorldSoundEventId = var1.projectileHitWorldSoundEventId
      )
      .documentation("The positioned sound event played to surrounding players when the projectile hits a player")
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("ProjectileHitLocalSoundEventId", Codec.STRING),
         (var0, var1) -> var0.projectileHitLocalSoundEventId = var1,
         var0 -> var0.projectileHitLocalSoundEventId,
         (var0, var1) -> var0.projectileHitLocalSoundEventId = var1.projectileHitLocalSoundEventId
      )
      .documentation("The positioned sound event played to a player hit by the projectile")
      .add()
      .appendInherited(
         new KeyedCodec<>("RespectTeams", Codec.BOOLEAN),
         (var0, var1) -> var0.respectTeams = var1,
         var0 -> var0.respectTeams,
         (var0, var1) -> var0.respectTeams = var1.respectTeams
      )
      .add()
      .appendInherited(
         new KeyedCodec<>("ProjectileSpawnOffsets", new MapCodec<>(Vector3dUtil.CODEC, Object2ObjectOpenHashMap::new, true)),
         (var0, var1) -> var0.projectileSpawnOffsets = var1,
         var0 -> var0.projectileSpawnOffsets,
         (var0, var1) -> var0.projectileSpawnOffsets = var1.projectileSpawnOffsets
      )
      .add()
      .afterDecode(DeployableTurretConfig::processConfig)
      .build();
   class="kw">protected float trackableRadius;
   class="kw">protected float detectionRadius;
   class="kw">protected float rotationSpeed;
   class="kw">protected float projectileDamage;
   class="kw">protected boolean preferOwnerTarget;
   class="kw">protected int ammo;
   class="kw">protected ProjectileConfig projectileConfig;
   class="kw">protected float deployDelay;
   class="kw">protected float shotInterval;
   class="kw">protected int burstCount;
   class="kw">protected float burstCooldown;
   class="kw">protected boolean canShootOwner;
   class="kw">protected Knockback projectileKnockback;
   class="kw">protected Vector3d targetOffset = new Vector3d(0.0, 0.0, 0.0);
   class="kw">protected boolean doLineOfSightTest = true;
   class="kw">protected String projectileHitWorldSoundEventId;
   class="kw">protected String projectileHitLocalSoundEventId;
   class="kw">protected int projectileHitLocalSoundEventIndex = 0;
   class="kw">protected int projectileHitWorldSoundEventIndex = 0;
   class="kw">protected boolean respectTeams = true;
   class="kw">protected Map<String, Vector3d> projectileSpawnOffsets = new Object2ObjectOpenHashMap();

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

   class="kw">protected void processConfig() {
      if (this.projectileHitWorldSoundEventId != null) {
         this.projectileHitWorldSoundEventIndex = SoundEvent.getAssetMap().getIndex(this.projectileHitWorldSoundEventId);
      }

      if (this.projectileHitLocalSoundEventId != null) {
         this.projectileHitLocalSoundEventIndex = SoundEvent.getAssetMap().getIndex(this.projectileHitLocalSoundEventId);
      }
   }

   @Override
   class="kw">public void tick(
      @Nonnull DeployableComponent var1,
      float var2,
      int var3,
      @Nonnull ArchetypeChunk<EntityStore> var4,
      @Nonnull Store<EntityStore> var5,
      @Nonnull CommandBuffer<EntityStore> var6
   ) {
      Ref var7 = var4.getReferenceTo(var3);
      class="kw">switch (var1.getFlag(DeployableComponent.DeployableFlag.STATE)) {
         case 0:
            this.tickInitState(var7, var1, var5, var6);
            break;
         case 1:
            this.tickStartDeployState(var7, var1, var5);
            break;
         case 2:
            this.tickAwaitDeployState(var7, var1, var5);
            break;
         case 3:
            this.tickAttackState(var7, var1, var2, var5, var6);
      }
   }

   class="kw">private void tickInitState(
      @Nonnull Ref<EntityStore> var1, @Nonnull DeployableComponent var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
   ) {
      var2.setFlag(DeployableComponent.DeployableFlag.STATE, 1);
      var4.addComponent(var1, DeployableProjectileShooterComponent.getComponentType());
      playAnimation(var3, var1, this, "Deploy");
   }

   class="kw">private void tickStartDeployState(@Nonnull Ref<EntityStore> var1, @Nonnull DeployableComponent var2, @Nonnull Store<EntityStore> var3) {
      var2.setFlag(DeployableComponent.DeployableFlag.STATE, 2);
      playAnimation(var3, var1, this, "Deploy");
   }

   class="kw">private void tickAwaitDeployState(@Nonnull Ref<EntityStore> var1, @Nonnull DeployableComponent var2, @Nonnull Store<EntityStore> var3) {
      Instant var4 = var3.getResource(TimeResource.getResourceType()).getNow();
      Instant var5 = var2.getSpawnInstant().plus((long)this.deployDelay, ChronoUnit.SECONDS);
      if (var4.isAfter(var5)) {
         var2.setFlag(DeployableComponent.DeployableFlag.STATE, 3);
         playAnimation(var3, var1, this, "Loop");
      }
   }

   class="kw">private void tickAttackState(
      @Nonnull Ref<EntityStore> var1, @Nonnull DeployableComponent var2, float var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
   ) {
      var2.setTimeSinceLastAttack(var2.getTimeSinceLastAttack() + var3);
      World var6 = var5.getExternalData().getWorld();
      DeployableProjectileShooterComponent var7 = var4.getComponent(var1, DeployableProjectileShooterComponent.getComponentType());
      Vector3d var8 = new Vector3d(Vector3dUtil.ZERO);
      if (this.projectileSpawnOffsets != null) {
         Vector3d var9 = this.projectileSpawnOffsets.get(var2.getSpawnFace());
         if (var9 != null) {
            var8.add(var9);
         }
      }

      if (var7 == null) {
         var6.execute(() -> {
            if (var1.isValid()) {
               DespawnComponent var3 = var4.ensureAndGetComponent(var1, DespawnComponent.getComponentType());
               WorldTimeResource var4 = var5.getResource(WorldTimeResource.getResourceType());
               var3.setDespawn(var4.getGameTime());
            }
         });
      } else {
         TransformComponent var23 = var4.getComponent(var1, TransformComponent.getComponentType());
         assert var23 != null;
         HeadRotation var10 = var4.getComponent(var1, HeadRotation.getComponentType());
         assert var10 != null;
         Vector3d var11 = new Vector3d(var8).add(var23.getPosition());
         this.updateProjectiles(var1, var4, var5, var7);
         boolean var12 = false;
         Ref var13 = var7.getActiveTarget();
         if (var13 != null && var13.isValid()) {
            TransformComponent var14 = var4.getComponent(var13, TransformComponent.getComponentType());
            assert var14 != null;
            Vector3d var15 = this.calculatedTargetPosition(var14.getPosition());
            Vector3d var16 = Vector3dUtil.directionTo(var11, var15);
            if (var15.distance(var11) <= this.trackableRadius && this.testLineOfSight(var11, var15, var16, var5)) {
               var12 = true;
            }
         }

         if (!var12) {
            var7.setActiveTarget(null);
            Ref var24 = null;
            Vector3d var27 = new Vector3d(Vector3dUtil.MAX);

            for (Ref var18 : TargetUtil.getAllEntitiesInSphere(var11, this.detectionRadius, var5)) {
               if (var18 != null && var18.isValid()) {
                  TransformComponent var19 = var4.getComponent(var18, TransformComponent.getComponentType());
                  assert var19 != null;
                  Vector3d var20 = this.calculatedTargetPosition(var19.getPosition());
                  Vector3d var21 = Vector3dUtil.directionTo(var11, var20);
                  if (this.testLineOfSight(var11, var20, var21, var5) && this.isValidTarget(var1, var4, var18) && var11.distance(var20) < var11.distance(var27)
                     )
                   {
                     var27.set(var20);
                     var24 = var18;
                  }
               }
            }

            if (var24 != null) {
               var7.setActiveTarget(var24);
               var13 = var24;
               var12 = true;
            }
         }

         Vector3dc var25 = Vector3dUtil.ZERO;
         Rotation3fc var28 = Rotation3f.IDENTITY;
         Rotation3fc var31 = Rotation3f.IDENTITY;
         if (var12) {
            TransformComponent var32 = var4.getComponent(var13, TransformComponent.getComponentType());
            assert var32 != null;
            Vector3d var26 = this.calculatedTargetPosition(new Vector3d(var32.getPosition()));
            Vector3d var34 = var11.sub(var26, new Vector3d());
            var28 = Rotation3f.lookAt(var34.negate());
            var31 = Rotation3f.lerpAngle(var10.getRotation(), var28, this.rotationSpeed * var3);
         }

         var10.setRotation(var31);
         int var33 = var2.getFlag(DeployableComponent.DeployableFlag.BURST_SHOTS);
         float var35 = var2.getTimeSinceLastAttack();
         boolean var36 = false;
         if (var33 < this.burstCount && var35 >= this.shotInterval) {
            var2.setFlag(DeployableComponent.DeployableFlag.BURST_SHOTS, var33 + 1);
            var36 = true;
         } else if (var33 >= this.burstCount && var35 >= this.burstCooldown) {
            var2.setFlag(DeployableComponent.DeployableFlag.BURST_SHOTS, 1);
            var36 = true;
         }

         if (var36 && var12) {
            Vector3d var37 = Vector3dUtil.setYawPitch(var31.yaw(), var31.pitch(), new Vector3d());
            Vector3d var38 = var23.getPosition();
            Vector3d var22 = new Vector3d(Vector3dUtil.ZERO);
            if (this.projectileSpawnOffsets != null) {
               var22 = new Vector3d((Vector3dc)this.projectileSpawnOffsets.getOrDefault(var2.getSpawnFace(), new Vector3d()));
            }

            var22.add(new Vector3d(var37).normalize());
            var22.add(var38);
            var7.spawnProjectile(var1, var5, this.projectileConfig, var22, new Vector3d(var37));
            playAnimation(var4, var1, this, "Shoot");
            var2.setTimeSinceLastAttack(0.0F);
         }
      }
   }

   @Nonnull
   class="kw">private Vector3d calculatedTargetPosition(@Nonnull Vector3d var1) {
      class="kw">return new Vector3d(var1).add(this.targetOffset);
   }

   class="kw">private boolean isValidTarget(@Nonnull Ref<EntityStore> var1, @Nonnull Store<EntityStore> var2, @Nonnull Ref<EntityStore> var3) {
      if (var3 == var1) {
         class="kw">return false;
      }

      DeployableComponent var4 = var2.getComponent(var1, DeployableComponent.getComponentType());
      if (var4 != null) {
         if (!this.canShootOwner) {
            UUID var5 = var4.getOwnerUUID();
            if (var5 != null) {
               UUIDComponent var6 = var2.getComponent(var3, UUIDComponent.getComponentType());
               if (var6 != null && var5.equals(var6.getUuid())) {
                  class="kw">return false;
               }
            }
         }

         if (this.respectTeams) {
            Ref var7 = var4.getOwner();
            if (var7 != null && var7.isValid()) {
               EntityGroup var8 = var2.getComponent(var7, EntityGroup.getComponentType());
               class="kw">return var8 == null || !var8.isMember(var3);
            }
         }
      }

      class="kw">return true;
   }

   class="kw">private boolean testLineOfSight(@Nonnull Vector3d var1, @Nonnull Vector3d var2, @Nonnull Vector3d var3, @Nonnull CommandBuffer<EntityStore> var4) {
      if (!this.doLineOfSightTest) {
         class="kw">return true;
      }

      Vector3f var5 = this.projectileConfig.getSpawnOffset();
      Vector3d var6 = new Vector3d(var1).add(var5.x, var5.y + this.generatedModel.getEyeHeight(), var5.z);
      double var7 = var6.distance(var2);
      World var9 = var4.getExternalData().getWorld();
      Vector3f var10 = new Vector3f(1.0F, 1.0F, 1.0F);
      if (this.getDebugVisuals()) {
         Vector3d var11 = var3.mul(var7);

         for (int var12 = 0; var12 < 10; var12++) {
            Vector3d var13 = new Vector3d(var6);
            var13.fma(var12 / 10.0F, var11);
            DebugUtils.addSphere(var9, var13, var10, 0.1F, 0.5F);
         }
      }

      Vector3i var16 = TargetUtil.getTargetBlock(var9, (var0, var1x) -> {
         if (var0 == 0) {
            class="kw">return false;
         }

         BlockType var2 = BlockType.getAssetMap().getAsset(var0);
         if (var2 == null) {
            class="kw">return false;
         }

         BlockMaterial var3 = var2.getMaterial();
         class="kw">return var3 != null && var3 != BlockMaterial.Empty ? var2.getOpacity() != Opacity.Transparent : false;
      }, var1.x, var1.y, var1.z, var3.x, var3.y, var3.z, var7);
      if (var16 == null) {
         class="kw">return true;
      }

      double var17 = var1.distanceSquared(var2);
      double var14 = var1.distanceSquared(var16.x + 0.5, var16.y + 0.5, var16.z + 0.5);
      class="kw">return var17 < var14;
   }

   class="kw">private void updateProjectiles(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Store<EntityStore> var2,
      @Nonnull CommandBuffer<EntityStore> var3,
      @Nonnull DeployableProjectileShooterComponent var4
   ) {
      List var5 = var4.getProjectiles();
      List var6 = var4.getProjectilesForRemoval();
      var5.removeAll(Collections.singleton(null));

      for (Ref var8 : var5) {
         this.updateProjectile(var1, var8, var4, var2, var3);
      }

      for (Ref var10 : var6) {
         if (var10.isValid()) {
            var3.removeEntity(var10, RemoveReason.REMOVE);
         }

         var5.remove(var10);
      }

      var6.clear();
   }

   class="kw">private void updateProjectile(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull DeployableProjectileShooterComponent var3,
      @Nonnull Store<EntityStore> var4,
      @Nonnull CommandBuffer<EntityStore> var5
   ) {
      if (!var2.isValid()) {
         var3.getProjectilesForRemoval().add(var2);
      } else {
         TransformComponent var6 = var4.getComponent(var2, TransformComponent.getComponentType());
         if (var6 == null) {
            var3.getProjectilesForRemoval().add(var2);
         } else {
            Vector3d var7 = var6.getPosition();
            DeployableProjectileComponent var8 = var4.getComponent(var2, DeployableProjectileComponent.getComponentType());
            if (var8 == null) {
               var3.getProjectilesForRemoval().add(var2);
            } else {
               Ref var9 = var8.takeHitEntityRef();
               if (var9 != null && var9.isValid() && this.isValidTarget(var1, var4, var9)) {
                  this.projectileHit(var1, var9, var2, var3, var4, var5);
               } else {
                  AtomicReference var10 = new AtomicReference<>(Boolean.FALSE);
                  Vector3d var11 = var8.getPreviousTickPosition();
                  Vector3d var12 = new Vector3d((var7.x - var11.x) * 0.1F, (var7.y - var11.y) * 0.1F, (var7.z - var11.z) * 0.1F);

                  for (int var13 = 0; var13 < 10; var13++) {
                     if (!var10.get()) {
                        Vector3d var14 = new Vector3d(var8.getPreviousTickPosition());
                        var14.x = var14.x + var12.x * var13;
                        var14.y = var14.y + var12.y * var13;
                        var14.z = var14.z + var12.z * var13;
                        if (this.getDebugVisuals()) {
                           DebugUtils.addSphere(var4.getExternalData().getWorld(), var14, new Vector3f(1.0F, 1.0F, 1.0F), 0.1F, 5.0F);
                        }

                        for (Ref var17 : TargetUtil.getAllEntitiesInSphere(var14, 0.1, var4)) {
                           if (var10.get()) {
                              class="kw">return;
                           }

                           boolean var18 = var17 == var2;
                           if (!var18 && this.isValidTarget(var1, var4, var17)) {
                              this.projectileHit(var1, var17, var2, var3, var4, var5);
                              var10.set(Boolean.TRUE);
                           }
                        }
                     }
                  }

                  var8.setPreviousTickPosition(var7);
                  if (!var10.get()) {
                     StandardPhysicsProvider var19 = var4.getComponent(var2, StandardPhysicsProvider.getComponentType());
                     if (var19 != null && var19.getState() != StandardPhysicsProvider.STATE.ACTIVE) {
                        var3.getProjectilesForRemoval().add(var2);
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">private void projectileHit(
      @Nonnull Ref<EntityStore> var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull DeployableProjectileShooterComponent var4,
      @Nonnull Store<EntityStore> var5,
      @Nonnull CommandBuffer<EntityStore> var6
   ) {
      Damage var7 = new Damage(new Damage.EntitySource(var1), DamageCause.PHYSICAL, this.projectileDamage);
      DamageSystems.executeDamage(var2, var6, var7);
      TransformComponent var8 = var5.getComponent(var3, TransformComponent.getComponentType());
      assert var8 != null;
      Vector3d var9 = new Vector3d(var8.getPosition());
      if (this.projectileKnockback != null) {
         float var10 = var8.getRotation().yaw();
         var5.getExternalData().getWorld().execute(() -> {
            if (var2.isValid()) {
               this.applyKnockback(var2, var9, var10, var5);
            }
         });
      }

      DeployablesUtils.playSoundEventsAtEntity(var2, var6, this.projectileHitLocalSoundEventIndex, this.projectileHitWorldSoundEventIndex, var9);
      var4.getProjectilesForRemoval().add(var3);
   }

   class="kw">private void applyKnockback(@Nonnull Ref<EntityStore> var1, @Nonnull Vector3d var2, float var3, @Nonnull Store<EntityStore> var4) {
      KnockbackComponent var5 = var4.ensureAndGetComponent(var1, KnockbackComponent.getComponentType());
      TransformComponent var6 = var4.getComponent(var1, TransformComponent.getComponentType());
      assert var6 != null;
      var5.setVelocity(this.projectileKnockback.calculateVector(var2, var3, var6.getPosition()));
      var5.setVelocityType(this.projectileKnockback.getVelocityType());
      var5.setVelocityConfig(this.projectileKnockback.getVelocityConfig());
      var5.setDuration(this.projectileKnockback.getDuration());
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "DeployableTurretConfig{}" + super.toString();
   }
}