class="kw">package com.hypixel.hytale.builtin.adventure.farming;

class="kw">import com.hypixel.hytale.builtin.adventure.farming.component.CoopResidentComponent;
class="kw">import com.hypixel.hytale.builtin.adventure.farming.config.FarmingCoopAsset;
class="kw">import com.hypixel.hytale.builtin.adventure.farming.config.stages.BlockStateFarmingStageData;
class="kw">import com.hypixel.hytale.builtin.adventure.farming.config.stages.BlockTypeFarmingStageData;
class="kw">import com.hypixel.hytale.builtin.adventure.farming.states.CoopBlock;
class="kw">import com.hypixel.hytale.builtin.adventure.farming.states.FarmingBlock;
class="kw">import com.hypixel.hytale.builtin.adventure.farming.states.TilledSoilBlock;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
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.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import com.hypixel.hytale.protocol.Rangef;
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.blocktype.config.farming.FarmingData;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.farming.FarmingStageData;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.modules.block.BlockModule;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.TickSuppressionRegistry;
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.ChunkColumn;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkFlag;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockComponentSection;
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.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.TargetUtil;
class="kw">import java.time.Instant;
class="kw">import java.time.temporal.ChronoUnit;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.ThreadLocalRandom;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

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

   class="kw">private class="kw">static boolean hasCropAbove(@Nonnull BlockSection var0, int var1, int var2, int var3) {
      BlockType var4 = BlockType.getAssetMap().getAsset(var0.get(var1, var2 + 1, var3));
      if (var4 == null) {
         class="kw">return false;
      }

      FarmingData var5 = var4.getFarming();
      class="kw">return var5 != null && var5.getStages() != null;
   }

   @Nullable
   class="kw">private class="kw">static BlockSection blockSectionAbove(@Nonnull ComponentAccessor<ChunkStore> var0, @Nonnull ChunkSection var1) {
      Ref var2 = var0.getExternalData().getChunkSectionReference(var1.getX(), var1.getY() + 1, var1.getZ());
      class="kw">return var2 != null && var2.isValid() ? var0.getComponent(var2, BlockSection.getComponentType()) : null;
   }

   class="kw">private class="kw">static boolean updateSoilDecayTime(@Nonnull CommandBuffer<ChunkStore> var0, @Nonnull TilledSoilBlock var1, @Nullable BlockType var2) {
      if (var2 == null) {
         class="kw">return false;
      }

      FarmingData var3 = var2.getFarming();
      if (var3 != null && var3.getSoilConfig() != null) {
         FarmingData.SoilConfig var4 = var3.getSoilConfig();
         Rangef var5 = var4.getLifetime();
         if (var5 == null) {
            class="kw">return false;
         }

         double var6 = var5.min + (var5.max - var5.min) * ThreadLocalRandom.current().nextDouble();
         Instant var8 = var0.getExternalData().getWorld().getEntityStore().getStore().getResource(WorldTimeResource.getResourceType()).getGameTime();
         Instant var9 = var8.plus(Math.round(var6), ChronoUnit.SECONDS);
         var1.setDecayTime(var9);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public class="kw">static class CoopResidentEntitySystem class="kw">extends RefSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, CoopResidentComponent> coopResidentComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, UUIDComponent> uuidComponentType;

      class="kw">public CoopResidentEntitySystem(@Nonnull ComponentType<EntityStore, CoopResidentComponent> var1, @Nonnull ComponentType<EntityStore, UUIDComponent> var2) {
         this.coopResidentComponentType = var1;
         this.uuidComponentType = var2;
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.coopResidentComponentType;
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         if (var2 != RemoveReason.UNLOAD) {
            UUIDComponent var5 = var4.getComponent(var1, this.uuidComponentType);
            if (var5 != null) {
               UUID var6 = var5.getUuid();
               CoopResidentComponent var7 = var4.getComponent(var1, this.coopResidentComponentType);
               if (var7 != null) {
                  Vector3i var8 = var7.getCoopLocation();
                  World var9 = var4.getExternalData().getWorld();
                  long var10 = ChunkUtil.indexChunkFromBlock(var8.x, var8.z);
                  Ref var12 = var9.getChunkStore().getChunkReference(var10);
                  if (var12 != null && var12.isValid()) {
                     Store var13 = var9.getChunkStore().getStore();
                     WorldChunk var14 = var13.getComponent(var12, WorldChunk.getComponentType());
                     if (var14 != null && var14.is(ChunkFlag.TICKING)) {
                        ChunkColumn var15 = var13.getComponent(var12, ChunkColumn.getComponentType());
                        if (var15 != null) {
                           Ref var16 = var15.getSection(ChunkUtil.chunkCoordinate(var8.y));
                           if (var16 != null && var16.isValid()) {
                              Ref var17 = BlockModule.getBlockEntity(var13, var16, var8.x, var8.y, var8.z);
                              if (var17 != null) {
                                 CoopBlock var18 = var13.getComponent(var17, CoopBlock.getComponentType());
                                 if (var18 != null) {
                                    var18.handleResidentDespawn(var6);
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class CoopResidentTicking class="kw">extends EntityTickingSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, CoopResidentComponent> coopResidentComponentType;

      class="kw">public CoopResidentTicking(@Nonnull ComponentType<EntityStore, CoopResidentComponent> var1) {
         this.coopResidentComponentType = var1;
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.coopResidentComponentType;
      }

      @Override
      class="kw">public void tick(
         float var1, int var2, @Nonnull ArchetypeChunk<EntityStore> var3, @Nonnull Store<EntityStore> var4, @Nonnull CommandBuffer<EntityStore> var5
      ) {
         CoopResidentComponent var6 = var3.getComponent(var2, this.coopResidentComponentType);
         assert var6 != null;
         if (var6.getMarkedForDespawn()) {
            var5.removeEntity(var3.getReferenceTo(var2), RemoveReason.REMOVE);
         }
      }
   }

   class="kw">public class="kw">static class OnCoopAdded class="kw">extends RefSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockModule.BlockStateInfo> blockStateInfoComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, CoopBlock> coopBlockComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public OnCoopAdded(@Nonnull ComponentType<ChunkStore, BlockModule.BlockStateInfo> var1, @Nonnull ComponentType<ChunkStore, CoopBlock> var2) {
         this.blockStateInfoComponentType = var1;
         this.coopBlockComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         CoopBlock var5 = var4.getComponent(var1, this.coopBlockComponentType);
         assert var5 != null;
         BlockModule.BlockStateInfo var6 = var4.getComponent(var1, this.blockStateInfoComponentType);
         assert var6 != null;
         World var7 = var4.getExternalData().getWorld();
         Store var8 = var7.getEntityStore().getStore();
         WorldTimeResource var9 = var8.getResource(WorldTimeResource.getResourceType());
         int var10 = var6.getIndex();
         int var11 = ChunkUtil.xFromIndex(var10);
         int var12 = ChunkUtil.yFromIndex(var10);
         int var13 = ChunkUtil.zFromIndex(var10);
         Ref var14 = var6.getSectionRef();
         if (var14.isValid()) {
            BlockSection var15 = var4.getComponent(var14, BlockSection.getComponentType());
            if (var15 != null) {
               var15.scheduleTick(ChunkUtil.indexBlock(var11, var12, var13), var5.getNextScheduledTick(var9));
            }
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         if (var2 != RemoveReason.UNLOAD) {
            CoopBlock var5 = var4.getComponent(var1, this.coopBlockComponentType);
            assert var5 != null;
            BlockModule.BlockStateInfo var6 = var4.getComponent(var1, this.blockStateInfoComponentType);
            assert var6 != null;
            Ref var7 = var6.getSectionRef();
            if (var7.isValid()) {
               int var8 = var6.getIndex();
               int var9 = ChunkUtil.xFromIndex(var8);
               int var10 = ChunkUtil.yFromIndex(var8);
               int var11 = ChunkUtil.zFromIndex(var8);
               ChunkSection var12 = var4.getComponent(var7, ChunkSection.getComponentType());
               assert var12 != null;
               int var13 = ChunkUtil.worldCoordFromLocalCoord(var12.getX(), var9);
               int var14 = ChunkUtil.worldCoordFromLocalCoord(var12.getY(), var10);
               int var15 = ChunkUtil.worldCoordFromLocalCoord(var12.getZ(), var11);
               World var16 = var4.getExternalData().getWorld();
               Store var17 = var16.getEntityStore().getStore();
               WorldTimeResource var18 = var17.getResource(WorldTimeResource.getResourceType());
               var5.handleBlockBroken(var16, var18, var17, var13, var14, var15);
            }
         }
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }
   }

   class="kw">public class="kw">static class OnFarmBlockAdded class="kw">extends RefSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockModule.BlockStateInfo> blockStateInfoComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FarmingBlock> farmingBlockComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public OnFarmBlockAdded(@Nonnull ComponentType<ChunkStore, BlockModule.BlockStateInfo> var1, @Nonnull ComponentType<ChunkStore, FarmingBlock> var2) {
         this.blockStateInfoComponentType = var1;
         this.farmingBlockComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         FarmingBlock var5 = var4.getComponent(var1, this.farmingBlockComponentType);
         assert var5 != null;
         BlockModule.BlockStateInfo var6 = var4.getComponent(var1, this.blockStateInfoComponentType);
         assert var6 != null;
         Ref var7 = var6.getSectionRef();
         if (var7.isValid()) {
            BlockSection var8 = var4.getComponent(var7, BlockSection.getComponentType());
            assert var8 != null;
            World var9 = var3.getExternalData().getWorld();
            Store var10 = var9.getEntityStore().getStore();
            WorldTimeResource var11 = var10.getResource(WorldTimeResource.getResourceType());
            if (var5.getLastTickGameTime() == null) {
               int var12 = var6.getIndex();
               int var13 = var8.get(ChunkUtil.xFromIndex(var12), ChunkUtil.yFromIndex(var12), ChunkUtil.zFromIndex(var12));
               BlockType var14 = BlockType.getAssetMap().getAsset(var13);
               if (var14 == null) {
                  class="kw">return;
               }

               FarmingData var15 = var14.getFarming();
               if (var15 == null) {
                  class="kw">return;
               }

               String var16 = var15.getStartingStageSet();
               var5.setCurrentStageSet(var16);
               var5.setLastTickGameTime(var11.getGameTime());
               var6.markNeedsSaving();
               Map var17 = var15.getStages();
               if (var17 != null) {
                  FarmingStageData[] var18 = var17.get(var16);
                  if (var18 != null && var18.length > 0) {
                     boolean var19 = false;

                     for (int var20 = 0; var20 < var18.length; var20++) {
                        FarmingStageData var21 = var18[var20];
                        class="kw">switch (var21) {
                           case BlockTypeFarmingStageData var24:
                              if (var24.getBlock().equals(var14.getId())) {
                                 var5.setGrowthProgress(var20);
                                 var19 = true;
                              }
                              break;
                           case BlockStateFarmingStageData var25:
                              BlockType var26 = var14.getBlockForState(var25.getState());
                              if (var26 != null && var26.getId().equals(var14.getId())) {
                                 var5.setGrowthProgress(var20);
                                 var19 = true;
                              }
                              break;
                           class="kw">default:
                        }
                     }

                     if (!var19 && var7 != null && var7.isValid()) {
                        var18[0].apply(var4, var7, var1, ChunkUtil.xFromIndex(var12), ChunkUtil.yFromIndex(var12), ChunkUtil.zFromIndex(var12), null);
                     }
                  }
               }
            }

            if (var5.getLastTickGameTime() == null) {
               var5.setLastTickGameTime(var11.getGameTime());
               var6.markNeedsSaving();
            }

            int var27 = var6.getIndex();
            int var28 = ChunkUtil.xFromIndex(var27);
            int var29 = ChunkUtil.yFromIndex(var27);
            int var30 = ChunkUtil.zFromIndex(var27);
            BlockSection var31 = var4.getComponent(var7, BlockSection.getComponentType());
            assert var31 != null;
            FarmingUtil.tickFarming(var4, var6, var31, var7, var1, var5, var28, var29, var30, true);
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }
   }

   class="kw">public class="kw">static class OnSoilAdded class="kw">extends RefSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockModule.BlockStateInfo> blockStateInfoComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, TilledSoilBlock> tilledSoilBlockComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public OnSoilAdded(@Nonnull ComponentType<ChunkStore, BlockModule.BlockStateInfo> var1, @Nonnull ComponentType<ChunkStore, TilledSoilBlock> var2) {
         this.blockStateInfoComponentType = var1;
         this.tilledSoilBlockComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         TilledSoilBlock var5 = var4.getComponent(var1, this.tilledSoilBlockComponentType);
         assert var5 != null;
         BlockModule.BlockStateInfo var6 = var4.getComponent(var1, this.blockStateInfoComponentType);
         assert var6 != null;
         Ref var7 = var6.getSectionRef();
         if (var7.isValid()) {
            if (!var5.isPlanted()) {
               int var8 = var6.getIndex();
               int var9 = ChunkUtil.xFromIndex(var8);
               int var10 = ChunkUtil.yFromIndex(var8);
               int var11 = ChunkUtil.zFromIndex(var8);
               BlockSection var12 = var4.getComponent(var7, BlockSection.getComponentType());
               assert var12 != null;
               Instant var13 = var5.getDecayTime();
               if (var13 == null) {
                  int var14 = var12.get(var9, var10, var11);
                  BlockType var15 = BlockType.getAssetMap().getAsset(var14);
                  FarmingSystems.updateSoilDecayTime(var4, var5, var15);
                  var13 = var5.getDecayTime();
               }

               if (var13 == null) {
                  class="kw">return;
               }

               var12.scheduleTick(ChunkUtil.indexBlock(var9, var10, var11), var13);
            }
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }
   }

   class="kw">public class="kw">static class Ticking class="kw">extends EntityTickingSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockSection> blockSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSection> chunkSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FarmingBlock> farmingBlockComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, TilledSoilBlock> tilledSoilBlockComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, CoopBlock> coopBlockComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public Ticking(
         @Nonnull ComponentType<ChunkStore, BlockSection> var1,
         @Nonnull ComponentType<ChunkStore, ChunkSection> var2,
         @Nonnull ComponentType<ChunkStore, FarmingBlock> var3,
         @Nonnull ComponentType<ChunkStore, TilledSoilBlock> var4,
         @Nonnull ComponentType<ChunkStore, CoopBlock> var5
      ) {
         this.blockSectionComponentType = var1;
         this.chunkSectionComponentType = var2;
         this.farmingBlockComponentType = var3;
         this.tilledSoilBlockComponentType = var4;
         this.coopBlockComponentType = var5;
         this.query = Query.and(var1, var2);
      }

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull ArchetypeChunk<ChunkStore> var3, @Nonnull Store<ChunkStore> var4, @Nonnull CommandBuffer<ChunkStore> var5) {
         BlockSection var6 = var3.getComponent(var2, this.blockSectionComponentType);
         assert var6 != null;
         if (var6.getTickingBlocksCountCopy() != 0) {
            ChunkSection var7 = var3.getComponent(var2, this.chunkSectionComponentType);
            assert var7 != null;
            Ref var8 = var7.getChunkColumnReference();
            if (var8 != null && var8.isValid()) {
               BlockComponentSection var9 = var3.getComponent(var2, BlockComponentSection.getComponentType());
               assert var9 != null;
               Ref var10 = var3.getReferenceTo(var2);
               TickSuppressionRegistry var11 = var4.getExternalData().getWorld().getEntityStore().getStore().getResource(TickSuppressionRegistry.RESOURCE);
               TickSuppressionRegistry var12 = var11 != null && var11.hasKind(1) ? var11 : null;
               int var13 = var7.getX();
               int var14 = var7.getZ();
               var6.forEachTicking(
                  var9,
                  var5,
                  var7.getY(),
                  (var6x, var7x, var8x, var9x, var10x, var11x) -> {
                     Ref var12 = var6x.getBlockReference(ChunkUtil.indexBlock(var8x, var9x, var10x));
                     if (var12 == null) {
                        class="kw">return BlockTickStrategy.IGNORED;
                     } else {
                        BlockModule.BlockStateInfo var13 = var7x.getComponent(var12, BlockModule.BlockStateInfo.getComponentType());
                        FarmingBlock var14 = var7x.getComponent(var12, this.farmingBlockComponentType);
                        if (var14 != null) {
                           FarmingUtil.tickFarming(var7x, var13, var6, var10, var12, var14, var8x, ChunkUtil.localCoordinate(var9x), var10x, false);
                           class="kw">return BlockTickStrategy.SLEEP;
                        } else if (var12 != null
                           && var12.isBlockSuppressed(
                              ChunkUtil.worldCoordFromLocalCoord(var13, var8x), var9x, ChunkUtil.worldCoordFromLocalCoord(var14, var10x), 1
                           )) {
                           class="kw">return BlockTickStrategy.IGNORED;
                        } else {
                           TilledSoilBlock var15 = var7x.getComponent(var12, this.tilledSoilBlockComponentType);
                           if (var15 != null) {
                              class="kw">return tickSoil(var7x, var12, var15);
                           } else {
                              CoopBlock var16 = var7x.getComponent(var12, this.coopBlockComponentType);
                              if (var16 != null) {
                                 tickCoop(var7x, var12, var16);
                                 class="kw">return BlockTickStrategy.SLEEP;
                              } else {
                                 class="kw">return BlockTickStrategy.IGNORED;
                              }
                           }
                        }
                     }
                  }
               );
            }
         }
      }

      class="kw">private class="kw">static BlockTickStrategy tickSoil(@Nonnull CommandBuffer<ChunkStore> var0, @Nonnull Ref<ChunkStore> var1, @Nonnull TilledSoilBlock var2) {
         BlockModule.BlockStateInfo var3 = var0.getComponent(var1, BlockModule.BlockStateInfo.getComponentType());
         assert var3 != null;
         int var4 = var3.getIndex();
         int var5 = ChunkUtil.xFromIndex(var4);
         int var6 = ChunkUtil.yFromIndex(var4);
         int var7 = ChunkUtil.zFromIndex(var4);
         Ref var8 = var3.getSectionRef();
         if (!var8.isValid()) {
            class="kw">return BlockTickStrategy.SLEEP;
         }

         BlockSection var9 = var0.getComponent(var8, BlockSection.getComponentType());
         if (var9 == null) {
            class="kw">return BlockTickStrategy.SLEEP;
         }

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

         BlockSection var11 = var6 == 31 ? FarmingSystems.blockSectionAbove(var0, var10) : var9;
         if (var11 == null) {
            class="kw">return BlockTickStrategy.WAIT_FOR_ADJACENT_CHUNK_LOAD;
         }

         boolean var12 = FarmingSystems.hasCropAbove(var11, var5, var6, var7);
         int var13 = var9.get(var5, var6, var7);
         BlockType var14 = BlockType.getAssetMap().getAsset(var13);
         if (var14 == null) {
            class="kw">return BlockTickStrategy.SLEEP;
         }

         Instant var15 = var0.getExternalData().getWorld().getEntityStore().getStore().getResource(WorldTimeResource.getResourceType()).getGameTime();
         Instant var16 = var2.getDecayTime();
         if (var2.isPlanted() && !var12) {
            if (!FarmingSystems.updateSoilDecayTime(var0, var2, var14)) {
               class="kw">return BlockTickStrategy.SLEEP;
            }

            Instant var26 = var2.getDecayTime();
            if (var26 != null) {
               var9.scheduleTick(ChunkUtil.indexBlock(var5, var6, var7), var26);
            }
         } else if (!var2.isPlanted() && !var12) {
            if (var16 == null || !var16.isAfter(var15)) {
               if (var14.getFarming() != null && var14.getFarming().getSoilConfig() != null) {
                  FarmingData.SoilConfig var17 = var14.getFarming().getSoilConfig();
                  String var18 = var17.getTargetBlock();
                  if (var18 == null) {
                     class="kw">return BlockTickStrategy.SLEEP;
                  }

                  int var19 = BlockType.getAssetMap().getIndex(var18);
                  if (var19 == Integer.MIN_VALUE) {
                     class="kw">return BlockTickStrategy.SLEEP;
                  }

                  BlockType var20 = BlockType.getAssetMap().getAsset(var19);
                  int var21 = var9.getRotationIndex(var5, var6, var7);
                  int var22 = ChunkUtil.worldCoordFromLocalCoord(var10.getX(), var5);
                  int var23 = ChunkUtil.worldCoordFromLocalCoord(var10.getY(), var6);
                  int var24 = ChunkUtil.worldCoordFromLocalCoord(var10.getZ(), var7);
                  ChunkStore var25 = var0.getExternalData();
                  var0.run(var8x -> {
                     if (var8.isValid()) {
                        BlockOperations.setBlock(var25, var8, var22, var23, var24, var19, var20, var21, 0, 0);
                     }
                  });
                  class="kw">return BlockTickStrategy.SLEEP;
               } else {
                  class="kw">return BlockTickStrategy.SLEEP;
               }
            }
         } else if (var12) {
            var2.setDecayTime(null);
         }

         String var27 = var2.computeBlockType(var15, var14);
         if (var27 != null && !var27.equals(var14.getId())) {
            int var28 = var9.getRotationIndex(var5, var6, var7);
            int var29 = BlockType.getAssetMap().getIndex(var27);
            BlockType var30 = BlockType.getAssetMap().getAsset(var29);
            int var31 = ChunkUtil.worldCoordFromLocalCoord(var10.getX(), var5);
            int var32 = ChunkUtil.worldCoordFromLocalCoord(var10.getY(), var6);
            int var33 = ChunkUtil.worldCoordFromLocalCoord(var10.getZ(), var7);
            ChunkStore var34 = var0.getExternalData();
            var0.run(var8x -> {
               if (var8.isValid()) {
                  BlockOperations.setBlock(var34, var8, var31, var32, var33, var29, var30, var28, 0, 2);
               }
            });
         }

         var2.setPlanted(var12);
         class="kw">return BlockTickStrategy.SLEEP;
      }

      class="kw">private class="kw">static void tickCoop(@Nonnull CommandBuffer<ChunkStore> var0, @Nonnull Ref<ChunkStore> var1, @Nonnull CoopBlock var2) {
         BlockModule.BlockStateInfo var3 = var0.getComponent(var1, BlockModule.BlockStateInfo.getComponentType());
         assert var3 != null;
         Ref var4 = var3.getSectionRef();
         if (var4.isValid()) {
            World var5 = var0.getExternalData().getWorld();
            Store var6 = var5.getEntityStore().getStore();
            WorldTimeResource var7 = var6.getResource(WorldTimeResource.getResourceType());
            FarmingCoopAsset var8 = var2.getCoopAsset();
            if (var8 != null) {
               int var9 = var3.getIndex();
               int var10 = ChunkUtil.xFromIndex(var9);
               int var11 = ChunkUtil.yFromIndex(var9);
               int var12 = ChunkUtil.zFromIndex(var9);
               BlockSection var13 = var0.getComponent(var4, BlockSection.getComponentType());
               assert var13 != null;
               ChunkSection var14 = var0.getComponent(var4, ChunkSection.getComponentType());
               assert var14 != null;
               int var15 = ChunkUtil.worldCoordFromLocalCoord(var14.getX(), var10);
               int var16 = ChunkUtil.worldCoordFromLocalCoord(var14.getY(), var11);
               int var17 = ChunkUtil.worldCoordFromLocalCoord(var14.getZ(), var12);
               double var18 = var13.getRotation(var10, var11, var12).yaw().getRadians();
               Vector3d var20 = new Vector3d().set(var8.getResidentSpawnOffset()).rotateY((float)var18);
               Vector3i var21 = new Vector3i(var15, var16, var17);
               boolean var22 = var8.getCaptureWildNPCsInRange();
               float var23 = var8.getWildCaptureRadius();
               if (var22 && var23 >= 0.0F) {
                  var5.execute(() -> {
                     List var6 = TargetUtil.getAllEntitiesInSphere(Vector3iUtil.toVector3d(var21), var23, var6);
                     boolean var7 = false;

                     for (Ref var9 : var6) {
                        var7 |= var2.tryPutWildResidentFromWild(var6, var9, var7, var21);
                     }

                     if (var7) {
                        var3.markNeedsSaving();
                     }
                  });
               }

               if (var2.shouldResidentsBeInCoop(var7)) {
                  var5.execute(() -> {
                     if (var2.ensureNoResidentsInWorld(var6)) {
                        var3.markNeedsSaving();
                     }
                  });
               } else {
                  var5.execute(
                     () -> {
                        boolean var15 = var2.ensureSpawnResidentsInWorld(var5, var6, Vector3iUtil.toVector3d(var21), var20);
                        var15 |= var2.generateProduceToInventory(var7);
                        if (var15) {
                           var3.markNeedsSaving();
                        }

                        if (var4.isValid()) {
                           BlockType var16 = BlockType.getAssetMap().getAsset(var13.get(var10, var11, var12));
                           assert var16 != null;
                           BlockOperations.setBlockInteractionState(
                              var5.getChunkStore(), var4, var15, var16, var17, var16, var2.hasProduce() ? "Produce_Ready" : "class="kw">default", false
                           );
                        }
                     }
                  );
               }

               Instant var24 = var2.getNextScheduledTick(var7);
               if (var24 != null) {
                  var13.scheduleTick(ChunkUtil.indexBlock(var10, var11, var12), var24);
               }
            }
         }
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }
   }
}