class="kw">package com.hypixel.hytale.server.core.asset.type.fluid;

class="kw">import com.hypixel.hytale.assetstore.AssetExtraInfo;
class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
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.array.ArrayCodec;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.protocol.SoundCategory;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
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.asset.type.tagpattern.config.TagPattern;
class="kw">import com.hypixel.hytale.server.core.event.events.ecs.EnvironmentBreakBlockEvent;
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.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Collections;
class="kw">import java.util.Comparator;
class="kw">import java.util.List;
class="kw">import java.util.concurrent.ThreadLocalRandom;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class FireFluidTicker class="kw">extends FluidTicker {
   class="kw">public class="kw">static class="kw">final FireFluidTicker.FlammabilityConfig[] FLAMMABILITY_CONFIGS = new FireFluidTicker.FlammabilityConfig[0];
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<FireFluidTicker> CODEC = BuilderCodec.builder(FireFluidTicker.class, FireFluidTicker::new, BASE_CODEC)
      .appendInherited(
         new KeyedCodec<>("SpreadFluid", Codec.STRING),
         (var0, var1) -> var0.spreadFluid = var1,
         var0 -> var0.spreadFluid,
         (var0, var1) -> var0.spreadFluid = var1.spreadFluid
      )
      .addValidator(Fluid.VALIDATOR_CACHE.getValidator().late())
      .add()
      .<FireFluidTicker.FlammabilityConfig[]>appendInherited(
         new KeyedCodec<>("Flammability", new ArrayCodec<>(FireFluidTicker.FlammabilityConfig.CODEC, FireFluidTicker.FlammabilityConfig[]::new)),
         (var0, var1) -> {
            List var2 = new ArrayList<>();
            if (var0.rawFlammabilityConfigs != null) {
               Collections.addAll(var2, var0.rawFlammabilityConfigs);
            }

            Collections.addAll(var2, var1);
            var0.rawFlammabilityConfigs = var2.toArray(FLAMMABILITY_CONFIGS);
         },
         var0 -> var0.rawFlammabilityConfigs,
         (var0, var1) -> var0.rawFlammabilityConfigs = var1.rawFlammabilityConfigs
      )
      .documentation("Defines flammability configs per tag pattern")
      .add()
      .build();
   @Nonnull
   class="kw">public class="kw">static class="kw">final FireFluidTicker INSTANCE = new FireFluidTicker();
   class="kw">private class="kw">static class="kw">final Vector3i[] OFFSETS = new Vector3i[]{
      new Vector3i(0, -1, 0), new Vector3i(0, 1, 0), new Vector3i(0, 0, -1), new Vector3i(0, 0, 1), new Vector3i(-1, 0, 0), new Vector3i(1, 0, 0)
   };
   class="kw">private String spreadFluid;
   class="kw">private int spreadFluidId;
   class="kw">private FireFluidTicker.FlammabilityConfig[] rawFlammabilityConfigs = FLAMMABILITY_CONFIGS;
   @Nullable
   class="kw">private class="kw">transient List<FireFluidTicker.FlammabilityConfig> sortedFlammabilityConfigs;

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

   @Nonnull
   @Override
   class="kw">protected FluidTicker.AliveStatus isAlive(
      @Nonnull FluidTicker.Accessor var1, @Nonnull FluidSection var2, @Nonnull BlockSection var3, Fluid var4, int var5, byte var6, int var7, int var8, int var9
   ) {
      class="kw">return FluidTicker.AliveStatus.ALIVE;
   }

   @Nonnull
   @Override
   class="kw">protected BlockTickStrategy spread(
      @Nonnull World var1,
      long var2,
      @Nonnull FluidTicker.Accessor var4,
      @Nonnull FluidSection var5,
      BlockSection var6,
      @Nonnull Fluid var7,
      int var8,
      byte var9,
      int var10,
      int var11,
      int var12
   ) {
      BlockTypeAssetMap var13 = BlockType.getAssetMap();
      int var14 = this.getSpreadFluidId(var8);
      BlockType var15 = var13.getAsset(var6.get(var10, var11, var12));
      int var16 = var7.getMaxFluidLevel();
      if (var9 < var16) {
         var5.setFluid(var10, var11, var12, var8, ++var9);
      }

      for (Vector3i var20 : OFFSETS) {
         int var21 = var20.x;
         int var22 = var20.y;
         int var23 = var20.z;
         int var24 = var10 + var21;
         int var25 = var11 + var22;
         int var26 = var12 + var23;
         boolean var27 = !ChunkUtil.isSameChunkSection(var10, var11, var12, var24, var25, var26);
         FluidSection var28 = var27 ? var4.getFluidSectionByBlock(var24, var25, var26) : var5;
         BlockSection var29 = var27 ? var4.getBlockSectionByBlock(var24, var25, var26) : var6;
         if (var28 != null && var29 != null) {
            int var30 = var29.get(var24, var25, var26);
            BlockType var31 = var13.getAsset(var30);
            int var32 = var28.getFluidId(var24, var25, var26);
            if (var32 == 0) {
               boolean var33 = this.getFlammabilityForBlock(var31) != null;
               if (var33) {
                  var28.setFluid(var24, var25, var26, var14, (byte)1);
                  var29.setTicking(var24, var25, var26, true);
               }
            }
         } else if (var20.y == 0 || var1.getChunkStore().supportsCubicSections()) {
            class="kw">return BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
         }
      }

      FireFluidTicker.FlammabilityConfig var34 = this.getFlammabilityForBlock(var15);
      if (var34 == null) {
         var5.setFluid(var10, var11, var12, 0, (byte)0);
         class="kw">return BlockTickStrategy.SLEEP;
      } else {
         ThreadLocalRandom var35 = ThreadLocalRandom.current();
         if (var9 >= var34.getBurnLevel() && var35.nextFloat() < var34.getBurnChance()) {
            tryBurn(var1, var4, var5, var6, var34, var10, var11, var12);
            class="kw">return BlockTickStrategy.SLEEP;
         } else {
            class="kw">return BlockTickStrategy.CONTINUE;
         }
      }
   }

   @Nullable
   class="kw">private FireFluidTicker.FlammabilityConfig getFlammabilityForBlock(@Nonnull BlockType var1) {
      List var2 = this.getSortedFlammabilityConfigs();
      AssetExtraInfo.Data var3 = var1.getData();
      if (var3 == null) {
         class="kw">return null;
      }

      Int2ObjectMap var4 = var3.getTags();

      for (FireFluidTicker.FlammabilityConfig var6 : var2) {
         TagPattern var7 = var6.getTagPattern();
         if (var7 != null && var7.test(var4)) {
            class="kw">return var6;
         }
      }

      class="kw">return null;
   }

   @Override
   class="kw">public boolean canOccupySolidBlocks() {
      class="kw">return true;
   }

   class="kw">private class="kw">static boolean tryBurn(
      @Nonnull World var0,
      @Nonnull FluidTicker.Accessor var1,
      @Nonnull FluidSection var2,
      BlockSection var3,
      @Nonnull FireFluidTicker.FlammabilityConfig var4,
      int var5,
      int var6,
      int var7
   ) {
      int var8 = var4.getResultingBlockIndex();
      String var9 = var4.getResultingState();
      if (var8 != Integer.MIN_VALUE || var9 != null) {
         var0.execute(() -> applyBurnResult(var0, var3, var5, var6, var7, var8, var9));
         setTickingSurrounding(var1, var3, var5, var6, var7);
      }

      int var10 = var4.getSoundEventIndex();
      if (var10 != Integer.MIN_VALUE) {
         var0.execute(() -> SoundUtil.playSoundEvent3d(var10, SoundCategory.SFX, var5, var6, var7, var0.getEntityStore().getStore()));
      }

      var2.setFluid(var5, var6, var7, 0, (byte)0);
      class="kw">return true;
   }

   class="kw">private class="kw">static void applyBurnResult(@Nonnull World var0, @Nonnull BlockSection var1, int var2, int var3, int var4, int var5, @Nullable String var6) {
      ChunkStore var7 = var0.getChunkStore();
      Ref var8 = var7.getChunkSectionReferenceAtBlock(var2, var3, var4);
      if (var8 != null && var8.isValid()) {
         int var9 = var1.getRotationIndex(var2, var3, var4);
         int var10 = var1.getFiller(var2, var3, var4);
         BlockType var11 = BlockType.getAssetMap().getAsset(var1.get(var2, var3, var4));
         if (var11 != null) {
            if (var5 != Integer.MIN_VALUE && (var6 == null || var5 != 0)) {
               BlockType var12 = BlockType.getAssetMap().getAsset(var5);
               BlockOperations.setBlock(var7, var8, var2, var3, var4, var5, var12, var9, var10, 0);
               if (var11 != BlockType.EMPTY && var11 != var12) {
                  var0.getEntityStore().getStore().invoke(new EnvironmentBreakBlockEvent(new Vector3i(var2, var3, var4), var11));
               }
            }

            if (var6 != null) {
               BlockType var14 = var11.getBlockForState(var6);
               if (var14 == null) {
                  class="kw">return;
               }

               int var13 = BlockType.getAssetMap().getIndex(var14.getId());
               BlockOperations.setBlock(var7, var8, var2, var3, var4, var13, var14, var9, var10, 0);
            }
         }
      }
   }

   @Override
   class="kw">public boolean isSelfFluid(int var1, int var2) {
      class="kw">return super.isSelfFluid(var1, var2) || var2 == this.getSpreadFluidId(var1);
   }

   class="kw">private int getSpreadFluidId(int var1) {
      if (this.spreadFluidId == 0) {
         if (this.spreadFluid != null) {
            this.spreadFluidId = Fluid.getAssetMap().getIndex(this.spreadFluid);
         } else {
            this.spreadFluidId = Integer.MIN_VALUE;
         }
      }

      class="kw">return this.spreadFluidId == Integer.MIN_VALUE ? var1 : this.spreadFluidId;
   }

   @Nonnull
   class="kw">public List<FireFluidTicker.FlammabilityConfig> getSortedFlammabilityConfigs() {
      if (this.sortedFlammabilityConfigs == null) {
         List var1 = new ArrayList<>();
         if (this.rawFlammabilityConfigs != null) {
            Collections.addAll(var1, this.rawFlammabilityConfigs);
         }

         var1.sort(Comparator.comparingInt(FireFluidTicker.FlammabilityConfig::getPriority).reversed());
         this.sortedFlammabilityConfigs = var1;
      }

      class="kw">return this.sortedFlammabilityConfigs;
   }

   class="kw">public class="kw">static class FlammabilityConfig {
      @Nonnull
      class="kw">public class="kw">static class="kw">final BuilderCodec<FireFluidTicker.FlammabilityConfig> CODEC = BuilderCodec.builder(
            FireFluidTicker.FlammabilityConfig.class, FireFluidTicker.FlammabilityConfig::new
         )
         .appendInherited(
            new KeyedCodec<>("TagPattern", TagPattern.CHILD_ASSET_CODEC),
            (var0, var1) -> var0.tagPatternId = var1,
            var0 -> var0.tagPatternId,
            (var0, var1) -> var0.tagPatternId = var1.tagPatternId
         )
         .addValidator(TagPattern.VALIDATOR_CACHE.getValidator())
         .documentation("TagPattern to match blocks that this config applies to")
         .add()
         .<Integer>appendInherited(
            new KeyedCodec<>("Priority", Codec.INTEGER),
            (var0, var1) -> var0.priority = var1,
            var0 -> var0.priority,
            (var0, var1) -> var0.priority = var1.priority
         )
         .documentation("Priority for pattern matching - higher values are checked first")
         .add()
         .<Byte>appendInherited(
            new KeyedCodec<>("BurnLevel", Codec.BYTE),
            (var0, var1) -> var0.burnLevel = var1,
            var0 -> var0.burnLevel,
            (var0, var1) -> var0.burnLevel = var1.burnLevel
         )
         .documentation("The fluid level the fluid has to be greater than or equal to to burn this block")
         .add()
         .<Float>appendInherited(
            new KeyedCodec<>("BurnChance", Codec.FLOAT),
            (var0, var1) -> var0.burnChance = var1,
            var0 -> var0.burnChance,
            (var0, var1) -> var0.burnChance = var1.burnChance
         )
         .documentation("Probability (0.0 to 1.0) that the block will burn each tick when above the burn level")
         .add()
         .<String>appendInherited(
            new KeyedCodec<>("ResultingBlock", Codec.STRING),
            (var0, var1) -> var0.resultingBlock = var1,
            var0 -> var0.resultingBlock,
            (var0, var1) -> var0.resultingBlock = var1.resultingBlock
         )
         .documentation("The block to place after burning, if any")
         .add()
         .<String>appendInherited(
            new KeyedCodec<>("ResultingState", Codec.STRING),
            (var0, var1) -> var0.resultingState = var1,
            var0 -> var0.resultingState,
            (var0, var1) -> var0.resultingState = var1.resultingState
         )
         .documentation("The block state to attempt to change to after burning, if any")
         .add()
         .<String>appendInherited(
            new KeyedCodec<>("SoundEvent", Codec.STRING),
            (var0, var1) -> var0.soundEvent = var1,
            var0 -> var0.soundEvent,
            (var0, var1) -> var0.soundEvent = var1.soundEvent
         )
         .addValidator(SoundEvent.VALIDATOR_CACHE.getValidator())
         .add()
         .build();
      class="kw">private String tagPatternId;
      @Nullable
      class="kw">private class="kw">transient TagPattern tagPattern;
      class="kw">private int priority;
      class="kw">private byte burnLevel = 1;
      class="kw">private float burnChance = 0.1F;
      class="kw">private String resultingBlock = "Empty";
      @Nullable
      class="kw">private String resultingState;
      class="kw">private int resultingBlockIndex = Integer.MIN_VALUE;
      class="kw">private String soundEvent;
      class="kw">private int soundEventIndex = Integer.MIN_VALUE;

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

      @Nullable
      class="kw">public TagPattern getTagPattern() {
         if (this.tagPattern == null && this.tagPatternId != null) {
            this.tagPattern = TagPattern.getAssetMap().getAsset(this.tagPatternId);
         }

         class="kw">return this.tagPattern;
      }

      class="kw">public int getPriority() {
         class="kw">return this.priority;
      }

      class="kw">public byte getBurnLevel() {
         class="kw">return this.burnLevel;
      }

      class="kw">public float getBurnChance() {
         class="kw">return this.burnChance;
      }

      class="kw">public int getResultingBlockIndex() {
         if (this.resultingBlockIndex == Integer.MIN_VALUE && this.resultingBlock != null) {
            this.resultingBlockIndex = BlockType.getBlockIdOrUnknown(this.resultingBlock, "Unknown block type %s", this.resultingBlock);
         }

         class="kw">return this.resultingBlockIndex;
      }

      @Nullable
      class="kw">public String getResultingState() {
         class="kw">return this.resultingState;
      }

      class="kw">public int getSoundEventIndex() {
         if (this.soundEventIndex == Integer.MIN_VALUE && this.soundEvent != null) {
            this.soundEventIndex = SoundEvent.getAssetMap().getIndex(this.soundEvent);
         }

         class="kw">return this.soundEventIndex;
      }
   }
}