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

class="kw">import com.hypixel.hytale.assetstore.AssetStore;
class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentRegistryProxy;
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.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.StateData;
class="kw">import com.hypixel.hytale.server.core.modules.LegacyModule;
class="kw">import com.hypixel.hytale.server.core.modules.blockanimation.commands.BlockAnimationSpeedCommand;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
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.ChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.util.FillerBlockUtil;
class="kw">import java.util.OptionalDouble;
class="kw">import java.util.Set;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BlockAnimationModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final float MAX_SPEED = 100.0F;
   @Nonnull
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(BlockAnimationModule.class).depends(LegacyModule.class).build();
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static BlockAnimationModule instance;
   class="kw">private ComponentType<ChunkStore, BlockAnimationSection> blockAnimationSectionComponentType;
   class="kw">private ResourceType<ChunkStore, BlockAnimationDirtySections> dirtySectionsResourceType;

   class="kw">public BlockAnimationModule(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Nonnull
   class="kw">public class="kw">static BlockAnimationModule get() {
      class="kw">return instance;
   }

   @Override
   class="kw">protected void setup() {
      ComponentRegistryProxy var1 = this.getChunkStoreRegistry();
      this.blockAnimationSectionComponentType = var1.registerComponent(BlockAnimationSection.class, "BlockAnimationSection", BlockAnimationSection.CODEC);
      this.dirtySectionsResourceType = var1.registerResource(BlockAnimationDirtySections.class, BlockAnimationDirtySections::new);
      var1.registerSystem(new BlockAnimationSystems.RemoveEmptySections(this.blockAnimationSectionComponentType));
      var1.registerSystem(new BlockAnimationSystems.LoadPacket(this.blockAnimationSectionComponentType));
      var1.registerSystem(new BlockAnimationSystems.ReplicateChanges(this.blockAnimationSectionComponentType, this.dirtySectionsResourceType));
      this.getCommandRegistry().registerCommand(new BlockAnimationSpeedCommand(this));
   }

   class="kw">public boolean setBlockAnimationSpeed(@Nonnull World var1, int var2, int var3, int var4, float var5) {
      if (!isValidSpeed(var5)) {
         class="kw">return false;
      }

      BlockAnimationModule.ResolvedSection var6 = this.resolveSection(var1, var2, var3, var4, true);
      if (var6 != null && var6.animationSection != null) {
         if (var6.animationSection.setSpeed(var6.index, var5)) {
            this.markDirty(var6);
         }

         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean setBlockAnimationSpeed(@Nonnull World var1, int var2, int var3, int var4, float var5, float var6) {
      if (isValidSpeed(var5) && Float.isFinite(var6)) {
         BlockAnimationModule.ResolvedSection var7 = this.resolveSection(var1, var2, var3, var4, true);
         if (var7 != null && var7.animationSection != null) {
            boolean var8 = var7.animationSection.setSpeed(var7.index, var5);
            boolean var9 = var7.animationSection.setPhase(var7.index, var6);
            if (var8 || var9) {
               this.markDirty(var7);
            }

            class="kw">return var9;
         } else {
            class="kw">return false;
         }
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean setBlockAnimationPhase(@Nonnull World var1, int var2, int var3, int var4, float var5) {
      if (!Float.isFinite(var5)) {
         class="kw">return false;
      }

      BlockAnimationModule.ResolvedSection var6 = this.resolveSection(var1, var2, var3, var4, false);
      if (var6 == null || var6.animationSection == null) {
         class="kw">return false;
      }

      if (!var6.animationSection.setPhase(var6.index, var5)) {
         class="kw">return false;
      }

      this.markDirty(var6);
      class="kw">return true;
   }

   class="kw">public boolean clearBlockAnimationSpeed(@Nonnull World var1, int var2, int var3, int var4) {
      BlockAnimationModule.ResolvedSection var5 = this.resolveSection(var1, var2, var3, var4, false);
      if (var5 != null && var5.animationSection != null) {
         boolean var6 = clearSpeed(var5.sectionRef.getStore(), var5.sectionRef, this.blockAnimationSectionComponentType, var5.animationSection, var5.index);
         if (!var6) {
            class="kw">return false;
         }

         this.markDirty(var5);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   @Nonnull
   class="kw">public OptionalDouble getBlockAnimationSpeedOverride(@Nonnull World var1, int var2, int var3, int var4) {
      BlockAnimationModule.ResolvedSection var5 = this.resolveSection(var1, var2, var3, var4, false);
      class="kw">return var5 == null ? OptionalDouble.empty() : getSpeedOverride(var5.animationSection, var5.index);
   }

   @Nonnull
   class="kw">public ComponentType<ChunkStore, BlockAnimationSection> getBlockAnimationSectionComponentType() {
      class="kw">return this.blockAnimationSectionComponentType;
   }

   @Nonnull
   class="kw">public ResourceType<ChunkStore, BlockAnimationDirtySections> getDirtySectionsResourceType() {
      class="kw">return this.dirtySectionsResourceType;
   }

   class="kw">public boolean canBlockAnimate(@Nonnull World var1, int var2, int var3, int var4) {
      BlockAnimationModule.ResolvedSection var5 = this.resolveSection(var1, var2, var3, var4, false);
      if (var5 == null) {
         class="kw">return false;
      }

      AssetStore var6 = BlockType.getAssetStore();
      if (var6 == null) {
         class="kw">return false;
      }

      BlockTypeAssetMap var7 = (BlockTypeAssetMap<String, BlockType>)var6.getAssetMap();
      if (var7 == null) {
         class="kw">return false;
      }

      BlockType var8 = var7.getAsset(var5.blockSection.get(var5.index));
      class="kw">return var8 != null && familyHasAnimation(var8, var7);
   }

   class="kw">static boolean familyHasAnimation(@Nonnull BlockType var0, @Nonnull BlockTypeAssetMap<String, BlockType> var1) {
      if (var0.getCustomModelAnimation() != null) {
         class="kw">return true;
      }

      StateData var2 = var0.getState();
      if (var2 == null) {
         class="kw">return false;
      }

      Set var3 = var2.getStateNames();
      if (var3 == null) {
         class="kw">return false;
      }

      for (String var5 : var3) {
         String var6 = var0.getBlockKeyForState(var5);
         if (var6 != null) {
            BlockType var7 = var1.getAsset(var6);
            if (var7 != null && var7.getCustomModelAnimation() != null) {
               class="kw">return true;
            }
         }
      }

      class="kw">return false;
   }

   class="kw">private BlockAnimationModule.ResolvedSection resolveSection(@Nonnull World var1, int var2, int var3, int var4, boolean var5) {
      ChunkStore var6 = var1.getChunkStore();
      Store var7 = var6.getStore();
      if (!var7.isInThread()) {
         LOGGER.at(Level.WARNING).log("Block animation overrides must be changed on the world thread.");
         class="kw">return null;
      }

      try {
         Ref var8 = var6.getChunkSectionReferenceAtBlock(var2, var3, var4);
         if (var8 != null && var8.isValid()) {
            BlockSection var9 = var7.getComponent(var8, BlockSection.getComponentType());
            if (var9 == null) {
               class="kw">return null;
            }

            ChunkSection var10 = var7.getComponent(var8, ChunkSection.getComponentType());
            if (var10 == null) {
               class="kw">return null;
            }

            int var11 = var9.getFiller(ChunkUtil.indexBlock(var2, var3, var4));
            if (var11 != 0) {
               int var12 = var2 - FillerBlockUtil.unpackX(var11);
               int var13 = var3 - FillerBlockUtil.unpackY(var11);
               int var14 = var4 - FillerBlockUtil.unpackZ(var11);
               if (var12 != var2 || var13 != var3 || var14 != var4) {
                  class="kw">return this.resolveSection(var1, var12, var13, var14, var5);
               }
            }

            BlockAnimationSection var16 = var7.getComponent(var8, this.blockAnimationSectionComponentType);
            if (var16 == null && var5) {
               if (var7.isProcessing()) {
                  LOGGER.at(Level.WARNING).log("A block animation component cannot be attached during store write processing.");
                  class="kw">return null;
               }

               var16 = new BlockAnimationSection();
               var7.putComponent(var8, this.blockAnimationSectionComponentType, var16);
            }

            int var17 = ChunkUtil.indexBlock(var2, var3, var4);
            class="kw">return new BlockAnimationModule.ResolvedSection(var8, var10, var9, var16, var17);
         } else {
            class="kw">return null;
         }
      } catch (RuntimeException var15) {
         ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var15)).log("Failed to access a block animation override at %d, %d, %d.", var2, var3, var4);
         class="kw">return null;
      }
   }

   class="kw">public class="kw">static void onBlockReplaced(@Nonnull ComponentAccessor<ChunkStore> var0, @Nonnull Ref<ChunkStore> var1, int var2, int var3, int var4) {
      BlockAnimationModule var5 = instance;
      if (var5 != null && var3 != var4) {
         try {
            BlockAnimationSection var6 = var0.getComponent(var1, var5.blockAnimationSectionComponentType);
            if (var6 == null || !var6.hasSpeed(var2)) {
               class="kw">return;
            }

            if (isSameBlockFamily(var3, var4)) {
               class="kw">return;
            }

            if (!clearSpeed(var0, var1, var5.blockAnimationSectionComponentType, var6, var2)) {
               class="kw">return;
            }

            ChunkSection var7 = var0.getComponent(var1, ChunkSection.getComponentType());
            if (var7 != null) {
               var7.markNeedsSaving();
            }

            var1.getStore().getResource(var5.dirtySectionsResourceType).add(var1);
         } catch (RuntimeException var8) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var8)).log("Failed to drop a block animation override at index %d.", var2);
         }
      }
   }

   class="kw">static boolean isSameBlockFamily(int var0, int var1) {
      AssetStore var2 = BlockType.getAssetStore();
      if (var2 == null) {
         class="kw">return false;
      }

      BlockTypeAssetMap var3 = (BlockTypeAssetMap<String, BlockType>)var2.getAssetMap();
      if (var3 == null) {
         class="kw">return false;
      }

      BlockType var4 = var3.getAsset(var0);
      BlockType var5 = var3.getAsset(var1);
      class="kw">return var4 != null && var5 != null ? var4.getStateForBlock(var5.getId()) != null : false;
   }

   class="kw">static boolean isValidSpeed(float var0) {
      class="kw">return Float.isFinite(var0) && var0 >= 0.0F && var0 < 100.0F;
   }

   class="kw">static boolean clearSpeed(
      @Nonnull ComponentAccessor<ChunkStore> var0,
      @Nonnull Ref<ChunkStore> var1,
      @Nonnull ComponentType<ChunkStore, BlockAnimationSection> var2,
      @Nonnull BlockAnimationSection var3,
      int var4
   ) {
      if (!var3.removeSpeed(var4)) {
         class="kw">return false;
      }

      removeSectionIfEmpty(var0, var1, var2, var3);
      class="kw">return true;
   }

   class="kw">static void removeSectionIfEmpty(
      @Nonnull ComponentAccessor<ChunkStore> var0,
      @Nonnull Ref<ChunkStore> var1,
      @Nonnull ComponentType<ChunkStore, BlockAnimationSection> var2,
      @Nonnull BlockAnimationSection var3
   ) {
      if (var3.isEmpty()) {
         var0.removeComponent(var1, var2);
      }
   }

   class="kw">private void markDirty(@Nonnull BlockAnimationModule.ResolvedSection var1) {
      var1.chunkSection.markNeedsSaving();
      var1.sectionRef.getStore().getResource(this.dirtySectionsResourceType).add(var1.sectionRef);
   }

   @Nonnull
   class="kw">static OptionalDouble getSpeedOverride(@Nullable BlockAnimationSection var0, int var1) {
      class="kw">return var0 != null && var0.hasSpeed(var1) ? OptionalDouble.of(var0.getSpeed(var1)) : OptionalDouble.empty();
   }

   class="kw">private record ResolvedSection(
      @Nonnull Ref<ChunkStore> sectionRef,
      @Nonnull ChunkSection chunkSection,
      @Nonnull BlockSection blockSection,
      @Nullable BlockAnimationSection animationSection,
      int index
   ) {
      class="kw">private ResolvedSection {
      }
   }
}