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

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
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.common.util.MapUtil;
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.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.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import java.util.Collections;
class="kw">import java.util.HashMap;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector2i;

class="kw">public class DefaultFluidTicker class="kw">extends FluidTicker {
   class="kw">public class="kw">static class="kw">final BuilderCodec<DefaultFluidTicker> CODEC = BuilderCodec.builder(DefaultFluidTicker.class, DefaultFluidTicker::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()
      .<Map>appendInherited(
         new KeyedCodec<>("Collisions", new MapCodec<>(DefaultFluidTicker.FluidCollisionConfig.CODEC, HashMap::new)),
         (var0, var1) -> var0.rawCollisionMap = MapUtil.combineUnmodifiable(var0.rawCollisionMap, var1),
         var0 -> var0.rawCollisionMap,
         (var0, var1) -> var0.rawCollisionMap = var1.rawCollisionMap
      )
      .documentation("Defines what happens when this fluid tries to spread into another fluid")
      .add()
      .build();
   class="kw">private class="kw">static class="kw">final int MAX_DROP_DISTANCE = 5;
   class="kw">public class="kw">static class="kw">final DefaultFluidTicker INSTANCE = new DefaultFluidTicker();
   class="kw">private String spreadFluid;
   class="kw">private int spreadFluidId;
   class="kw">private Map<String, DefaultFluidTicker.FluidCollisionConfig> rawCollisionMap = Collections.emptyMap();
   @Nullable
   class="kw">private class="kw">transient Int2ObjectMap<DefaultFluidTicker.FluidCollisionConfig> collisionMap = null;

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

   @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();
      IndexedLookupTableAssetMap var14 = Fluid.getAssetMap();
      boolean var15 = var5.getY() != ChunkUtil.chunkCoordinate(var11 - 1);
      FluidSection var16 = var15 ? var4.getFluidSectionByBlock(var10, var11 - 1, var12) : var5;
      BlockSection var17 = var15 ? var4.getBlockSectionByBlock(var10, var11 - 1, var12) : var6;
      if (var16 != null && var17 != null) {
         int var18 = var16.getFluidId(var10, var11 - 1, var12);
         Fluid var19 = var14.getAsset(var18);
         byte var20 = var16.getFluidLevel(var10, var11 - 1, var12);
         int var21 = this.getSpreadFluidId(var8);
         int var22 = var17.get(var10, var11 - 1, var12);
         BlockType var23 = var13.getAsset(var22);
         if (isSolid(var23) || var18 != 0 && var18 != var21 && var18 == var8) {
            if (var18 == 0 || var18 != var21) {
               if (var9 == 1 && var7.getMaxFluidLevel() != 1) {
                  class="kw">return BlockTickStrategy.SLEEP;
               }

               int var43 = this.getSpreadOffsets(var13, var4, var5, var6, var10, var11, var12, ORTO_OFFSETS, var8, 5);
               if (var43 == 2147483646) {
                  class="kw">return BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
               }

               int var44 = var9 - 1;
               if (var21 != var8) {
                  var44 = Fluid.getAssetMap().getAsset(var21).getMaxFluidLevel() - 1;
               }

               BlockType var45 = var13.getAsset(var6.get(var10, var11, var12));
               int var46 = var6.getRotationIndex(var10, var11, var12);
               int var28 = var6.getFiller(var10, var11, var12);

               for (int var29 = 0; var29 < ORTO_OFFSETS.length; var29++) {
                  if (var43 == 0 || (var43 & 1 << var29) != 0) {
                     Vector2i var30 = ORTO_OFFSETS[var29];
                     int var31 = var30.x;
                     int var32 = var30.y;
                     int var33 = var10 + var31;
                     int var34 = var12 + var32;
                     if (!this.blocksFluidFrom(var45, var46, -var31, -var32, var28)) {
                        boolean var35 = !ChunkUtil.isSameChunkSection(var10, var11, var12, var33, var11, var34);
                        FluidSection var36 = var35 ? var4.getFluidSectionByBlock(var33, var11, var34) : var5;
                        BlockSection var37 = var35 ? var4.getBlockSectionByBlock(var33, var11, var34) : var6;
                        if (var36 == null || var37 == null) {
                           class="kw">return BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
                        }

                        BlockType var38 = var13.getAsset(var37.get(var33, var11, var34));
                        int var39 = var37.getRotationIndex(var33, var11, var34);
                        int var40 = var37.getFiller(var33, var11, var34);
                        if (!this.blocksFluidFrom(var38, var39, var31, var32, var40)) {
                           int var41 = var36.getFluidId(var33, var11, var34);
                           if (var41 != 0 && var41 != var21) {
                              DefaultFluidTicker.FluidCollisionConfig var42 = (DefaultFluidTicker.FluidCollisionConfig)this.getCollisionMap().get(var41);
                              if (var42 == null || executeCollision(var1, var4, var36, var37, var42, var33, var11, var34)) {
                                 class="kw">continue;
                              }
                           }

                           byte var47 = var36.getFluidLevel(var33, var11, var34);
                           if (var41 != var21 || var47 < var44) {
                              if (var44 == 0) {
                                 var36.setFluid(var33, var11, var34, 0, (byte)0);
                              } else {
                                 var36.setFluid(var33, var11, var34, var21, (byte)var44);
                                 var37.setTicking(var33, var11, var34, true);
                              }
                           }
                        }
                     }
                  }
               }
            }

            class="kw">return BlockTickStrategy.SLEEP;
         } else {
            DefaultFluidTicker.FluidCollisionConfig var24 = (DefaultFluidTicker.FluidCollisionConfig)this.getCollisionMap().get(var18);
            if (var24 != null && !executeCollision(var1, var4, var16, var17, var24, var10, var11 - 1, var12)) {
               class="kw">return BlockTickStrategy.CONTINUE;
            }

            if (var18 == 0 && !isSolid(var23) || var18 == var21 && var20 < var19.getMaxFluidLevel()) {
               int var25 = this.getSpreadFluidId(var8);
               Fluid var26 = var14.getAsset(var25);
               boolean var27 = var16.setFluid(var10, var11 - 1, var12, var25, (byte)var26.getMaxFluidLevel());
               if (var27) {
                  var17.setTicking(var10, var11 - 1, var12, true);
               }
            }

            class="kw">return BlockTickStrategy.SLEEP;
         }
      } else {
         class="kw">return BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
      }
   }

   class="kw">private class="kw">static boolean executeCollision(
      @Nonnull World var0,
      @Nonnull FluidTicker.Accessor var1,
      @Nonnull FluidSection var2,
      BlockSection var3,
      @Nonnull DefaultFluidTicker.FluidCollisionConfig var4,
      int var5,
      int var6,
      int var7
   ) {
      int var8 = var4.getBlockToPlaceIndex();
      if (var8 != Integer.MIN_VALUE && isReplaceableByFluidCollision(var3, var5, var6, var7)) {
         var1.setBlock(var5, var6, var7, var8);
         setTickingSurrounding(var1, var3, var5, var6, var7);
         var2.setFluid(var5, var6, var7, 0, (byte)0);
      }

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

      class="kw">return !var4.placeFluid;
   }

   class="kw">private class="kw">static boolean isReplaceableByFluidCollision(@Nonnull BlockSection var0, int var1, int var2, int var3) {
      int var4 = var0.get(var1, var2, var3);
      if (var4 == 0) {
         class="kw">return true;
      }

      BlockType var5 = BlockType.getAssetMap().getAsset(var4);
      class="kw">return var5 != null && var5.getGathering() != null && var5.getGathering().isSoft();
   }

   @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 Int2ObjectMap<DefaultFluidTicker.FluidCollisionConfig> getCollisionMap() {
      if (this.collisionMap == null) {
         Int2ObjectOpenHashMap var1 = new Int2ObjectOpenHashMap(this.rawCollisionMap.size());

         for (Entry var3 : this.rawCollisionMap.entrySet()) {
            int var4 = Fluid.getAssetMap().getIndex(var3.getKey());
            if (var4 != Integer.MIN_VALUE) {
               var1.put(var4, var3.getValue());
            }
         }

         this.collisionMap = var1;
      }

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

   class="kw">public class="kw">static class FluidCollisionConfig {
      class="kw">public class="kw">static class="kw">final BuilderCodec<DefaultFluidTicker.FluidCollisionConfig> CODEC = BuilderCodec.builder(
            DefaultFluidTicker.FluidCollisionConfig.class, DefaultFluidTicker.FluidCollisionConfig::new
         )
         .appendInherited(
            new KeyedCodec<>("BlockToPlace", Codec.STRING),
            (var0, var1) -> var0.blockToPlace = var1,
            var0 -> var0.blockToPlace,
            (var0, var1) -> var0.blockToPlace = var1.blockToPlace
         )
         .documentation("The block to place when a collision occurs")
         .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()
         .<Boolean>appendInherited(
            new KeyedCodec<>("PlaceFluid", Codec.BOOLEAN),
            (var0, var1) -> var0.placeFluid = var1,
            var0 -> var0.placeFluid,
            (var0, var1) -> var0.placeFluid = var1.placeFluid
         )
         .documentation("Whether to still place the fluid on collision")
         .add()
         .build();
      class="kw">private String blockToPlace;
      class="kw">private int blockToPlaceIndex = Integer.MIN_VALUE;
      class="kw">public boolean placeFluid = false;
      class="kw">private String soundEvent;
      class="kw">private int soundEventIndex = Integer.MIN_VALUE;

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

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

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

      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;
      }
   }
}