class="kw">package com.hypixel.hytale.server.npc.corecomponents.combat.builders;

class="kw">import com.google.gson.JsonElement;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockset.config.BlockSet;
class="kw">import com.hypixel.hytale.server.core.modules.blockset.BlockSetModule;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderDescriptorState;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderSupport;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.Feature;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.AssetHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.BooleanHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.DoubleHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.IntHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.holder.NumberArrayHolder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.AssetValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleRangeValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.DoubleSequenceValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.IntRangeValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.RelationalOperator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.BlockSetExistsValidator;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.validators.asset.RootInteractionValidator;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.builders.BuilderBodyMotionBase;
class="kw">import com.hypixel.hytale.server.npc.corecomponents.combat.BodyMotionCharge;
class="kw">import com.hypixel.hytale.server.npc.instructions.BodyMotion;
class="kw">import com.hypixel.hytale.server.npc.util.expression.ExecutionContext;
class="kw">import com.hypixel.hytale.server.npc.util.expression.Scope;
class="kw">import com.hypixel.hytale.server.npc.validators.NPCLoadTimeValidationHelper;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import java.util.List;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BuilderBodyMotionCharge class="kw">extends BuilderBodyMotionBase {
   class="kw">public class="kw">static class="kw">final double[] DEFAULT_LOCKED_ON_DURATION_RANGE = new double[]{5.0, 5.0};
   class="kw">public class="kw">static class="kw">final double[] DEFAULT_WINDING_UP_DURATION_RANGE = new double[]{5.0, 5.0};
   class="kw">public class="kw">static class="kw">final double[] DEFAULT_POST_CHARGE_DURATION_RANGE = new double[]{2.0, 2.0};
   class="kw">protected class="kw">final DoubleHolder relativeTurnSpeed = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder windingUpRelativeTurnSpeed = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder chargeRelativeSpeed = new DoubleHolder();
   class="kw">protected class="kw">final NumberArrayHolder chargeDistanceRange = new NumberArrayHolder();
   class="kw">protected class="kw">final NumberArrayHolder lockedOnDurationRange = new NumberArrayHolder();
   class="kw">protected class="kw">final NumberArrayHolder windingUpDurationRange = new NumberArrayHolder();
   class="kw">protected class="kw">final NumberArrayHolder postChargeDurationRange = new NumberArrayHolder();
   class="kw">protected class="kw">final BooleanHolder windingUpUninterruptable = new BooleanHolder();
   class="kw">protected class="kw">final BooleanHolder clearOnceOnStateChange = new BooleanHolder();
   class="kw">protected class="kw">final DoubleHolder chargeAbsoluteSpeed = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder chargeAcceleration = new DoubleHolder();
   class="kw">protected class="kw">final BooleanHolder ignoredBlockSetTriggers = new BooleanHolder();
   class="kw">protected class="kw">final BooleanHolder entityStopsCharge = new BooleanHolder();
   class="kw">protected class="kw">final AssetHolder blockCollisionInteraction = new AssetHolder();
   class="kw">protected class="kw">final AssetHolder npcCollisionInteraction = new AssetHolder();
   class="kw">protected class="kw">final AssetHolder playerCollisionInteraction = new AssetHolder();
   class="kw">protected class="kw">final DoubleHolder repeatCollisionIgnoreDuration = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder climbSlope = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder dropSlope = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder horizontalSkipGapWidth = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder knockbackThreshold = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder probeChargeRecomputeDistance = new DoubleHolder();
   class="kw">protected class="kw">final IntHolder probeMinFrequency = new IntHolder();
   class="kw">protected class="kw">final IntHolder probeMaxFrequency = new IntHolder();
   class="kw">protected class="kw">final DoubleHolder probeMinDirectionChangeDegrees = new DoubleHolder();
   class="kw">protected class="kw">final DoubleHolder lockedOnToleranceAngleDegrees = new DoubleHolder();
   class="kw">protected class="kw">final AssetHolder ignoredBlockSet = new AssetHolder();
   class="kw">protected class="kw">final AssetHolder removedBlockSet = new AssetHolder();

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

   @Nonnull
   class="kw">public BodyMotion build(@Nonnull BuilderSupport var1) {
      class="kw">return new BodyMotionCharge(this, var1);
   }

   @Nonnull
   @Override
   class="kw">public String getShortDescription() {
      class="kw">return "Aim at a target and progress through locked-on, winding up, and charging motion states.";
   }

   @Nonnull
   @Override
   class="kw">public String getLongDescription() {
      class="kw">return this.getShortDescription();
   }

   @Nonnull
   @Override
   class="kw">public BuilderDescriptorState getBuilderDescriptorState() {
      class="kw">return BuilderDescriptorState.Stable;
   }

   @Nonnull
   class="kw">public BuilderBodyMotionCharge readConfig(@Nonnull JsonElement var1) {
      this.getDouble(
         var1,
         "RelativeTurnSpeed",
         this.relativeTurnSpeed,
         1.0,
         DoubleRangeValidator.between(0.0, 2.0),
         BuilderDescriptorState.Stable,
         "Relative turn speed while aiming and locked on",
         null
      );
      this.getDouble(
         var1,
         "LockedOnToleranceAngle",
         this.lockedOnToleranceAngleDegrees,
         15.0,
         DoubleRangeValidator.fromExclToIncl(0.0, 360.0),
         BuilderDescriptorState.Stable,
         "View cone angle where target is still considered locked on",
         null
      );
      this.getDoubleRange(
         var1,
         "LockedOnDurationRange",
         this.lockedOnDurationRange,
         DEFAULT_LOCKED_ON_DURATION_RANGE,
         DoubleSequenceValidator.betweenWeaklyMonotonic(0.0, Double.MAX_VALUE),
         BuilderDescriptorState.Stable,
         "Random interval range in seconds specifying minimum time target must be locked on before winding up",
         null
      );
      this.getDoubleRange(
         var1,
         "WindingUpDurationRange",
         this.windingUpDurationRange,
         DEFAULT_WINDING_UP_DURATION_RANGE,
         DoubleSequenceValidator.betweenWeaklyMonotonic(0.0, Double.MAX_VALUE),
         BuilderDescriptorState.Stable,
         "Random interval range in seconds specifying winding up time before charging",
         null
      );
      this.getDoubleRange(
         var1,
         "PostChargeDurationRange",
         this.postChargeDurationRange,
         DEFAULT_POST_CHARGE_DURATION_RANGE,
         DoubleSequenceValidator.betweenWeaklyMonotonic(0.0, Double.MAX_VALUE),
         BuilderDescriptorState.Stable,
         "Random interval range in seconds spent resting after an obstructed or finished charge",
         null
      );
      this.getBoolean(
         var1,
         "WindingUpUninterruptable",
         this.windingUpUninterruptable,
         true,
         BuilderDescriptorState.Stable,
         "When true, WindingUp is not interrupted by target loss or aim drift",
         null
      );
      this.getDouble(
         var1,
         "WindingUpRelativeTurnSpeed",
         this.windingUpRelativeTurnSpeed,
         1.0,
         DoubleRangeValidator.between(0.0, 2.0),
         BuilderDescriptorState.Stable,
         "Relative turn speed during WindingUp. Can be 0 to disable rotation in that phase",
         null
      );
      this.getDouble(
         var1,
         "ChargeRelativeSpeed",
         this.chargeRelativeSpeed,
         5.0,
         DoubleRangeValidator.between(0.0, 20.0),
         BuilderDescriptorState.Stable,
         "Relative forward movement speed toward the target during Charging",
         null
      );
      this.requireDoubleRange(
         var1,
         "ChargeDistanceRange",
         this.chargeDistanceRange,
         DoubleSequenceValidator.betweenWeaklyMonotonic(1.0, 50.0),
         BuilderDescriptorState.Stable,
         "Range used to pick a random maximum charge distance when a new aiming cycle starts",
         null
      );
      this.getAsset(
         var1,
         "IgnoredBlockSet",
         this.ignoredBlockSet,
         "",
         BlockSetExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Blocks in this set are ignored by the charge probe (treated as non-colliding)",
         null
      );
      this.getAsset(
         var1,
         "RemovedBlockSet",
         this.removedBlockSet,
         "",
         BlockSetExistsValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Subset of IgnoredBlockSet expected to be removed by charge block hit actions. These blocks are treated as absent for charge probe breathability checks",
         null
      );
      this.getBoolean(
         var1,
         "ClearOnceOnStateChange",
         this.clearOnceOnStateChange,
         true,
         BuilderDescriptorState.Stable,
         "When true, calls clearOnce() on the parent instruction whenever the charge state changes",
         null
      );
      this.getDouble(
         var1,
         "ChargeAbsoluteSpeed",
         this.chargeAbsoluteSpeed,
         0.0,
         DoubleRangeValidator.between(0.0, 100.0),
         BuilderDescriptorState.Stable,
         "Maximum charge speed in blocks/s. 0 disables the cap and ChargeRelativeSpeed is used",
         null
      );
      this.validateExactlyOneZero(this.chargeRelativeSpeed, this.chargeAbsoluteSpeed);
      this.getDouble(
         var1,
         "ChargeAcceleration",
         this.chargeAcceleration,
         1000.0,
         DoubleRangeValidator.between(0.0, 10000.0),
         BuilderDescriptorState.Stable,
         "Linear acceleration in blocks/s^2 applied each tick during charging. Very high values reproduce the pre-existing near-instant ramp-up",
         null
      );
      this.getBoolean(
         var1,
         "IgnoredBlockSetTriggers",
         this.ignoredBlockSetTriggers,
         false,
         BuilderDescriptorState.Stable,
         "When true, blocks in IgnoredBlockSet still fire trigger/damage interactions during the rail step",
         null
      );
      this.getBoolean(
         var1,
         "EntityStopsCharge",
         this.entityStopsCharge,
         false,
         BuilderDescriptorState.Stable,
         "When true, the first entity (player or NPC) hit during the rail step clamps the charge and transitions to Obstructed. When false, entity hits are reported without stopping the charge",
         null
      );
      this.getAsset(
         var1,
         "BlockCollisionInteraction",
         this.blockCollisionInteraction,
         "",
         RootInteractionValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Optional interaction to execute immediately for each block collision during charging",
         null
      );
      this.getAsset(
         var1,
         "NPCCollisionInteraction",
         this.npcCollisionInteraction,
         "",
         RootInteractionValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Optional interaction to execute immediately for each NPC collision during charging",
         null
      );
      this.getAsset(
         var1,
         "PlayerCollisionInteraction",
         this.playerCollisionInteraction,
         "",
         RootInteractionValidator.withConfig(AssetValidator.CanBeEmpty),
         BuilderDescriptorState.Stable,
         "Optional interaction to execute immediately for each player collision during charging",
         null
      );
      this.getDouble(
         var1,
         "RepeatCollisionIgnoreDuration",
         this.repeatCollisionIgnoreDuration,
         0.2,
         DoubleRangeValidator.between(0.0, Double.MAX_VALUE),
         BuilderDescriptorState.Stable,
         "Duration in seconds for which repeat collisions with the same entity are ignored by BodyMotionCharge collision interactions and sensors",
         null
      );
      this.getDouble(
         var1,
         "ClimbSlope",
         this.climbSlope,
         2.0,
         DoubleRangeValidator.between(0.0, 10.0),
         BuilderDescriptorState.Stable,
         "Horizontal blocks per vertical block when smoothing CLIMB segments along the charge path. 0 disables climb smoothing; otherwise the climb starts as far back from the edge as a slope of this value allows (e.g. 2 = 2 horizontal blocks per 1 vertical block). The actual slope can become steeper but never shallower than this value",
         null
      );
      this.getDouble(
         var1,
         "DropSlope",
         this.dropSlope,
         2.0,
         DoubleRangeValidator.between(0.0, 10.0),
         BuilderDescriptorState.Stable,
         "Horizontal blocks per vertical block when smoothing DROP segments along the charge path. 0 disables drop smoothing; otherwise the drop lands as far past the edge as a slope of this value allows. The actual slope can become steeper but never shallower than this value",
         null
      );
      this.getDouble(
         var1,
         "HorizontalSkipGapWidth",
         this.horizontalSkipGapWidth,
         1.2,
         DoubleRangeValidator.between(0.0, 8.0),
         BuilderDescriptorState.Stable,
         "Maximum horizontal width (in blocks) the NPC may stride over while sloping a climb/drop or when collapsing a drop+climb dip whose endpoints are at the same height. 0 disables both shortcuts",
         null
      );
      this.getDouble(
         var1,
         "KnockbackThreshold",
         this.knockbackThreshold,
         0.0,
         DoubleRangeValidator.between(0.0, Double.MAX_VALUE),
         BuilderDescriptorState.Stable,
         "Threshold for external knockback magnitude while Charging. If the combined external velocity is below this value the knockback is ignored and cleared; otherwise Charging transitions to Knockback",
         null
      );
      this.getDouble(
         var1,
         "ProbeChargeRecomputeDistance",
         this.probeChargeRecomputeDistance,
         0.0,
         DoubleRangeValidator.between(-Double.MAX_VALUE, Double.MAX_VALUE),
         BuilderDescriptorState.Stable,
         "Interval in blocks during Charging for re-validating the walk path against world changes (2D motion controllers only). Must be > 0; values <= 0 disable mid-charge re-validation",
         null
      );
      this.getInt(
         var1,
         "ProbeMinFrequency",
         this.probeMinFrequency,
         2,
         IntRangeValidator.between(0, 30),
         BuilderDescriptorState.Stable,
         "Minimum frequency for executing the reachability test during updates. 0 means maximum frequency (as often as possible)",
         null
      );
      this.getInt(
         var1,
         "ProbeMaxFrequency",
         this.probeMaxFrequency,
         10,
         IntRangeValidator.between(0, 30),
         BuilderDescriptorState.Stable,
         "Maximum frequency for executing the reachability test during updates. 0 means maximum frequency (as often as possible)",
         null
      );
      this.validateIntRelation(this.probeMinFrequency, RelationalOperator.LessEqual, this.probeMaxFrequency);
      this.getDouble(
         var1,
         "ProbeMinDirectionChange",
         this.probeMinDirectionChangeDegrees,
         5.0,
         DoubleRangeValidator.between(0.0, 180.0),
         BuilderDescriptorState.Stable,
         "Minimum angular change to target in degrees required before executing another reachability test",
         null
      );
      this.requireFeature(Feature.AnyPosition);
      this.providePreceding(BodyMotionCharge.class);
      class="kw">return this;
   }

   @Override
   class="kw">public boolean validate(String var1, @Nonnull NPCLoadTimeValidationHelper var2, ExecutionContext var3, Scope var4, @Nonnull List<String> var5) {
      class="kw">return super.validate(var1, var2, var3, var4, var5) & this.validateRemovedBlockSetSubset(var1, var3, var5);
   }

   class="kw">public double getRelativeTurnSpeed(@Nonnull BuilderSupport var1) {
      class="kw">return this.relativeTurnSpeed.get(var1.getExecutionContext());
   }

   class="kw">public double getLockedOnHalfAngleRadians(@Nonnull BuilderSupport var1) {
      class="kw">return this.lockedOnToleranceAngleDegrees.get(var1.getExecutionContext()) / 2.0 * (float) (Math.PI / 180.0);
   }

   @Nonnull
   class="kw">public double[] getLockedOnDurationRange(@Nonnull BuilderSupport var1) {
      class="kw">return this.lockedOnDurationRange.get(var1.getExecutionContext());
   }

   @Nonnull
   class="kw">public double[] getWindingUpDurationRange(@Nonnull BuilderSupport var1) {
      class="kw">return this.windingUpDurationRange.get(var1.getExecutionContext());
   }

   @Nonnull
   class="kw">public double[] getPostChargeDurationRange(@Nonnull BuilderSupport var1) {
      class="kw">return this.postChargeDurationRange.get(var1.getExecutionContext());
   }

   class="kw">public boolean isWindingUpUninterruptable(@Nonnull BuilderSupport var1) {
      class="kw">return this.windingUpUninterruptable.get(var1.getExecutionContext());
   }

   class="kw">public boolean isClearOnceOnStateChange(@Nonnull BuilderSupport var1) {
      class="kw">return this.clearOnceOnStateChange.get(var1.getExecutionContext());
   }

   class="kw">public double getWindingUpRelativeTurnSpeed(@Nonnull BuilderSupport var1) {
      class="kw">return this.windingUpRelativeTurnSpeed.get(var1.getExecutionContext());
   }

   class="kw">public double getChargeRelativeSpeed(@Nonnull BuilderSupport var1) {
      class="kw">return this.chargeRelativeSpeed.get(var1.getExecutionContext());
   }

   @Nonnull
   class="kw">public double[] getChargeDistanceRange(@Nonnull BuilderSupport var1) {
      class="kw">return this.chargeDistanceRange.get(var1.getExecutionContext());
   }

   class="kw">public int getIgnoredBlockSet(@Nonnull BuilderSupport var1) {
      String var2 = this.ignoredBlockSet.get(var1.getExecutionContext());
      if (var2 != null && !var2.isEmpty()) {
         int var3 = BlockSet.getAssetMap().getIndex(var2);
         if (var3 == Integer.MIN_VALUE) {
            throw new IllegalArgumentException("Unknown BlockSet: " + var2);
         } else {
            class="kw">return var3;
         }
      } else {
         class="kw">return Integer.MIN_VALUE;
      }
   }

   class="kw">public int getRemovedBlockSet(@Nonnull BuilderSupport var1) {
      String var2 = this.removedBlockSet.get(var1.getExecutionContext());
      if (var2 != null && !var2.isEmpty()) {
         int var3 = BlockSet.getAssetMap().getIndex(var2);
         if (var3 == Integer.MIN_VALUE) {
            throw new IllegalArgumentException("Unknown BlockSet: " + var2);
         } else {
            class="kw">return var3;
         }
      } else {
         class="kw">return Integer.MIN_VALUE;
      }
   }

   class="kw">public double getChargeAbsoluteSpeed(@Nonnull BuilderSupport var1) {
      class="kw">return this.chargeAbsoluteSpeed.get(var1.getExecutionContext());
   }

   class="kw">public double getChargeAcceleration(@Nonnull BuilderSupport var1) {
      class="kw">return this.chargeAcceleration.get(var1.getExecutionContext());
   }

   class="kw">public boolean isIgnoredBlockSetTriggers(@Nonnull BuilderSupport var1) {
      class="kw">return this.ignoredBlockSetTriggers.get(var1.getExecutionContext());
   }

   class="kw">public boolean isEntityStopsCharge(@Nonnull BuilderSupport var1) {
      class="kw">return this.entityStopsCharge.get(var1.getExecutionContext());
   }

   @Nullable
   class="kw">public String getBlockCollisionInteraction(@Nonnull BuilderSupport var1) {
      String var2 = this.blockCollisionInteraction.get(var1.getExecutionContext());
      class="kw">return var2 != null && !var2.isEmpty() ? var2 : null;
   }

   @Nullable
   class="kw">public String getNPCCollisionInteraction(@Nonnull BuilderSupport var1) {
      String var2 = this.npcCollisionInteraction.get(var1.getExecutionContext());
      class="kw">return var2 != null && !var2.isEmpty() ? var2 : null;
   }

   @Nullable
   class="kw">public String getPlayerCollisionInteraction(@Nonnull BuilderSupport var1) {
      String var2 = this.playerCollisionInteraction.get(var1.getExecutionContext());
      class="kw">return var2 != null && !var2.isEmpty() ? var2 : null;
   }

   class="kw">public double getClimbSlope(@Nonnull BuilderSupport var1) {
      class="kw">return this.climbSlope.get(var1.getExecutionContext());
   }

   class="kw">public double getDropSlope(@Nonnull BuilderSupport var1) {
      class="kw">return this.dropSlope.get(var1.getExecutionContext());
   }

   class="kw">public double getHorizontalSkipGapWidth(@Nonnull BuilderSupport var1) {
      class="kw">return this.horizontalSkipGapWidth.get(var1.getExecutionContext());
   }

   class="kw">public double getRepeatCollisionIgnoreDuration(@Nonnull BuilderSupport var1) {
      class="kw">return this.repeatCollisionIgnoreDuration.get(var1.getExecutionContext());
   }

   class="kw">public double getKnockbackThreshold(@Nonnull BuilderSupport var1) {
      class="kw">return this.knockbackThreshold.get(var1.getExecutionContext());
   }

   class="kw">public double getProbeChargeRecomputeDistance(@Nonnull BuilderSupport var1) {
      class="kw">return this.probeChargeRecomputeDistance.get(var1.getExecutionContext());
   }

   class="kw">public double getProbeMinInterval(@Nonnull BuilderSupport var1) {
      class="kw">return frequencyToDuration(this.probeMaxFrequency.get(var1.getExecutionContext()));
   }

   class="kw">public double getProbeMaxInterval(@Nonnull BuilderSupport var1) {
      class="kw">return frequencyToDuration(this.probeMinFrequency.get(var1.getExecutionContext()));
   }

   class="kw">public double getProbeMinDirectionChangeRadians(@Nonnull BuilderSupport var1) {
      class="kw">return this.probeMinDirectionChangeDegrees.get(var1.getExecutionContext()) * (float) (Math.PI / 180.0);
   }

   class="kw">private class="kw">static double frequencyToDuration(int var0) {
      if (var0 <= 0) {
         class="kw">return 0.0;
      }

      int var1 = Math.min(var0, 30);
      class="kw">return 1.0 / var1;
   }

   class="kw">private boolean validateRemovedBlockSetSubset(String var1, ExecutionContext var2, @Nonnull List<String> var3) {
      String var4;
      String var5;
      try {
         var4 = this.removedBlockSet.get(var2);
         var5 = this.ignoredBlockSet.get(var2);
      } catch (RuntimeException var14) {
         var3.add(String.format("%s: %s", var1, var14.getMessage()));
         class="kw">return false;
      }

      if (var4 == null || var4.isEmpty()) {
         class="kw">return true;
      }

      if (var5 != null && !var5.isEmpty()) {
         int var6 = BlockSet.getAssetMap().getIndex(var4);
         int var7 = BlockSet.getAssetMap().getIndex(var5);
         if (var6 != Integer.MIN_VALUE && var7 != Integer.MIN_VALUE) {
            BlockSetModule var8 = BlockSetModule.getInstance();
            if (var8 == null) {
               class="kw">return true;
            }

            Int2ObjectMap var9 = var8.getBlockSets();
            IntSet var10 = (IntSet)var9.get(var6);
            IntSet var11 = (IntSet)var9.get(var7);
            if (var10 != null && var11 != null) {
               IntIterator var12 = var10.iterator();

               while (var12.hasNext()) {
                  int var13 = var12.nextInt();
                  if (!var11.contains(var13)) {
                     var3.add(String.format("%s: RemovedBlockSet '%s' must be a subset of IgnoredBlockSet '%s'", var1, var4, var5));
                     class="kw">return false;
                  }
               }

               class="kw">return true;
            } else {
               class="kw">return true;
            }
         } else {
            class="kw">return true;
         }
      } else {
         var3.add(String.format("%s: RemovedBlockSet '%s' requires IgnoredBlockSet to be configured", var1, var4));
         class="kw">return false;
      }
   }
}