other features

src/main/java/carpet/mixins/CarpetBlockMixin.java

@@ -0,0 +1,28 @@
+package carpet.mixins;
+
+import carpet.utils.WoolTool;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.CarpetBlock;
+import net.minecraft.item.ItemPlacementContext;
+import org.spongepowered.asm.mixin.Mixin;
+
+@Mixin(CarpetBlock.class)
+public abstract class CarpetBlockMixin extends Block
+{
+
+    public CarpetBlockMixin(Settings block$Settings_1)
+    {
+        super(block$Settings_1);
+    }
+
+    public BlockState getPlacementState(ItemPlacementContext context)
+    {
+        BlockState state = super.getPlacementState(context);
+        if (context.getPlayer() != null && !context.getWorld().isClient)
+        {
+            WoolTool.carpetPlacedAction(((CarpetBlock)(Object)this).getColor(), context.getPlayer(), context.getBlockPos(), context.getWorld());
+        }
+        return state;
+    }
+}

src/main/java/carpet/mixins/CoralBlockMixin.java

@@ -0,0 +1,81 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import carpet.fakes.CoralFeatureInterface;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.CoralBlock;
+import net.minecraft.block.CoralParentBlock;
+import net.minecraft.block.Fertilizable;
+import net.minecraft.block.MaterialColor;
+import net.minecraft.tag.BlockTags;
+import net.minecraft.tag.FluidTags;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.World;
+import net.minecraft.world.gen.feature.CoralClawFeature;
+import net.minecraft.world.gen.feature.CoralFeature;
+import net.minecraft.world.gen.feature.CoralMushroomFeature;
+import net.minecraft.world.gen.feature.CoralTreeFeature;
+import net.minecraft.world.gen.feature.DefaultFeatureConfig;
+import org.spongepowered.asm.mixin.Interface;
+import org.spongepowered.asm.mixin.Mixin;
+
+import java.util.Random;
+
+@Mixin(CoralBlock.class)
+@Interface(iface = Fertilizable.class, prefix = "fert$")
+public abstract class CoralBlockMixin implements Fertilizable
+{
+    public boolean isFertilizable(BlockView var1, BlockPos var2, BlockState var3, boolean var4)
+    {
+        return CarpetSettings.getBool("renewableCoral") && var3.get(CoralParentBlock.WATERLOGGED) && var1.getFluidState(var2.up()).matches(FluidTags.WATER);
+    }
+
+    public boolean canGrow(World var1, Random var2, BlockPos var3, BlockState var4)
+    {
+        return (double)var1.random.nextFloat() < 0.15D;
+    }
+
+    public void grow(World worldIn, Random random, BlockPos pos, BlockState blockUnder)
+    {
+
+        CoralFeature coral;
+        int variant = random.nextInt(3);
+        if (variant == 0)
+            coral = new CoralClawFeature(DefaultFeatureConfig::deserialize);
+        else if (variant == 1)
+            coral = new CoralTreeFeature(DefaultFeatureConfig::deserialize);
+        else
+            coral = new CoralMushroomFeature(DefaultFeatureConfig::deserialize);
+
+        MaterialColor color = blockUnder.getTopMaterialColor(worldIn, pos);
+        BlockState proper_block = blockUnder;
+        for (Block block: BlockTags.CORAL_BLOCKS.values())
+        {
+            proper_block = block.getDefaultState();
+            if (proper_block.getTopMaterialColor(worldIn,pos) == color)
+            {
+                break;
+            }
+        }
+        worldIn.setBlockState(pos, Blocks.WATER.getDefaultState(), 4);
+
+        if (!((CoralFeatureInterface)coral).growSpecific(worldIn, random, pos, proper_block))
+        {
+            worldIn.setBlockState(pos, blockUnder, 3);
+        }
+        else
+        {
+            if (worldIn.random.nextInt(10)==0)
+            {
+                BlockPos randomPos = pos.add(worldIn.random.nextInt(16)-8,worldIn.random.nextInt(8),worldIn.random.nextInt(16)-8  );
+                if (BlockTags.CORAL_BLOCKS.contains(worldIn.getBlockState(randomPos).getBlock()))
+                {
+                    worldIn.setBlockState(randomPos, Blocks.WET_SPONGE.getDefaultState(), 3);
+                }
+            }
+        }
+    }
+}

src/main/java/carpet/mixins/CoralFeatureMixin.java

@@ -0,0 +1,25 @@
+package carpet.mixins;
+
+import carpet.fakes.CoralFeatureInterface;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IWorld;
+import net.minecraft.world.World;
+import net.minecraft.world.gen.feature.CoralFeature;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+import java.util.Random;
+
+@Mixin(CoralFeature.class)
+public abstract class CoralFeatureMixin implements CoralFeatureInterface
+{
+
+    @Shadow protected abstract boolean spawnCoral(IWorld var1, Random var2, BlockPos var3, BlockState var4);
+
+    @Override
+    public boolean growSpecific(World worldIn, Random random, BlockPos pos, BlockState blockUnder)
+    {
+        return spawnCoral(worldIn, random, pos, blockUnder);
+    }
+}

src/main/java/carpet/mixins/KelpFeatureMixin.java

@@ -0,0 +1,24 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import net.minecraft.world.gen.feature.KelpFeature;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Random;
+
+@Mixin(KelpFeature.class)
+public class KelpFeatureMixin
+{
+    @Redirect(method = "method_13460", at = @At(value = "INVOKE", target = "Ljava/util/Random;nextInt(I)I"))
+    private int getRandom(Random random, int bound)
+    {
+        if (bound==10)
+            return random.nextInt(bound);
+        int limit = CarpetSettings.getInt("kelpGenerationGrowLimit");
+        if (limit == 0)
+            return random.nextInt(bound);
+        return 25-limit+random.nextInt(Math.min(23,limit+1));
+    }
+}

src/main/java/carpet/mixins/LivingEntity_maxCollisionsMixin.java

@@ -0,0 +1,64 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.damage.DamageSource;
+import net.minecraft.predicate.entity.EntityPredicates;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+
+@Mixin(LivingEntity.class)
+public abstract class LivingEntity_maxCollisionsMixin extends Entity
+{
+
+    public LivingEntity_maxCollisionsMixin(EntityType<?> entityType_1, World world_1)
+    {
+        super(entityType_1, world_1);
+    }
+
+    @Shadow protected abstract void pushAway(Entity entity_1);
+
+    @Inject(method = "tickPushing", cancellable = true, at = @At("HEAD"))
+    private void tickPushingReplacement(CallbackInfo ci)
+    {
+        List<Entity> list_1 = this.world.getEntities((Entity)this, this.getBoundingBox(), EntityPredicates.canBePushedBy(this));
+        if (!list_1.isEmpty()) {
+            int int_1 = this.world.getGameRules().getInteger("maxEntityCramming");
+            int int_2;
+            if (int_1 > 0 && list_1.size() > int_1 - 1 && this.random.nextInt(4) == 0) {
+                int_2 = 0;
+
+                for(int int_3 = 0; int_3 < list_1.size(); ++int_3) {
+                    if (!((Entity)list_1.get(int_3)).hasVehicle()) {
+                        ++int_2;
+                    }
+                }
+
+                if (int_2 > int_1 - 1) {
+                    this.damage(DamageSource.CRAMMING, 6.0F);
+                }
+            }
+
+            int limit = list_1.size();
+            if (CarpetSettings.n_maxEntityCollisions > 0)
+                limit = Math.min(limit, CarpetSettings.n_maxEntityCollisions);
+
+            for(int_2 = 0; int_2 < limit; ++int_2) {
+                Entity entity_1 = (Entity)list_1.get(int_2);
+                this.pushAway(entity_1);
+            }
+        }
+        ci.cancel();
+    }
+
+
+}

src/main/java/carpet/mixins/PistonHandler_pushLimitMixin.java

@@ -0,0 +1,18 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import net.minecraft.block.piston.PistonHandler;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Constant;
+import org.spongepowered.asm.mixin.injection.ModifyConstant;
+
+@Mixin(PistonHandler.class)
+public class PistonHandler_pushLimitMixin
+{
+    @ModifyConstant(method = "tryMove", constant = @Constant(intValue = 12), expect = 3)
+    private int pushLimit(int original)
+    {
+        return CarpetSettings.n_pushLimit;
+    }
+}

src/main/java/carpet/mixins/PoweredRailBlock_powerLimitMixin.java

@@ -0,0 +1,18 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import net.minecraft.block.PoweredRailBlock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.Constant;
+import org.spongepowered.asm.mixin.injection.ModifyConstant;
+
+@Mixin(PoweredRailBlock.class)
+public class PoweredRailBlock_powerLimitMixin
+{
+    @ModifyConstant(method = "isPoweredByOtherRails(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/BlockState;ZI)Z",
+            constant = @Constant(intValue = 8))
+    private int powerLimit(int original)
+    {
+        return CarpetSettings.railPowerLimitAdjusted;
+    }
+}

src/main/java/carpet/mixins/PrimedTntEntityMixin.java

@@ -5,6 +5,7 @@ import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityType;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.PrimedTntEntity;
+import net.minecraft.nbt.CompoundTag;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
@@ -24,6 +25,25 @@ public abstract class PrimedTntEntityMixin extends Entity
         super(entityType_1, world_1);
     }
 
+    @Inject(method = "<init>(Lnet/minecraft/entity/EntityType;Lnet/minecraft/world/World;)V", at = @At("RETURN"))
+    private void initTNTLoggerPrime(EntityType<? extends PrimedTntEntity> entityType_1, World world_1, CallbackInfo ci)
+    {
+        if (LoggerRegistry.__tnt && !world_1.isClient)
+        {
+            logHelper = new TNTLogHelper();
+        }
+    }
+
+    @Inject(method = "tick", at = @At("HEAD"))
+    private void initTracker(CallbackInfo ci)
+    {
+        if (LoggerRegistry.__tnt && logHelper != null && !logHelper.initialized)
+        {
+            logHelper.onPrimed(x, y, z, getVelocity());
+        }
+    }
+
+
     @Inject(method = "<init>(Lnet/minecraft/world/World;DDDLnet/minecraft/entity/LivingEntity;)V",
             at = @At(value = "RETURN"))
     private void initTNTLogger(World world_1, double double_1, double double_2, double double_3,
@@ -31,12 +51,6 @@ public abstract class PrimedTntEntityMixin extends Entity
     {
         if(CarpetSettings.getBool("tntPrimerMomentumRemoved"))
             this.setVelocity(new Vec3d(0.0, 0.20000000298023224D, 0.0));
-        if (LoggerRegistry.__tnt)
-        {
-            logHelper = new TNTLogHelper();
-
-            logHelper.onPrimed(double_1, double_2, double_3, getVelocity());
-        }
     }
 
     @Inject(method = "explode", at = @At(value = "HEAD"))

src/main/java/carpet/mixins/ProjectileEntityMixin.java

@@ -25,7 +25,7 @@ public abstract class ProjectileEntityMixin extends Entity
             logHelper = new TrajectoryLogHelper("projectiles");
     }
 
-    @Inject(method = "tick", at = @At("RETURN"))
+    @Inject(method = "tick", at = @At("HEAD"))
     private void tickCheck(CallbackInfo ci)
     {
         if (LoggerRegistry.__projectiles && logHelper != null)

src/main/java/carpet/mixins/ServerChunkManagerMixin.java

@@ -1,5 +1,6 @@
 package carpet.mixins;
 
+import carpet.fakes.WorldInterface;
 import carpet.utils.SpawnReporter;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import net.minecraft.entity.EntityCategory;
@@ -56,6 +57,7 @@ public abstract class ServerChunkManagerMixin
                              Object2IntMap object2IntMap_1)
     {
         DimensionType dim = this.world.dimension.getType();
+        ((WorldInterface)world).getPrecookedMobs().clear();
         SpawnReporter.mobCounts.put(dim, (Object2IntMap<EntityCategory>)object2IntMap_1);
         SpawnReporter.chunkCounts.put(dim, int_2);
 

src/main/java/carpet/mixins/ServerWorld_onePlayerSleepingMixin.java

@@ -0,0 +1,54 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+@Mixin(ServerWorld.class)
+public class ServerWorld_onePlayerSleepingMixin
+{
+    @Shadow @Final private List<ServerPlayerEntity> players;
+
+    @Shadow private boolean allPlayersSleeping;
+
+    @Inject(method = "updatePlayersSleeping", cancellable = true, at = @At("HEAD"))
+    private void updateOnePlayerSleeping(CallbackInfo ci)
+    {
+        if(CarpetSettings.getBool("onePlayerSleeping"))
+        {
+            allPlayersSleeping = false;
+            for (ServerPlayerEntity p : players)
+                if (!p.isSpectator() && p.isSleeping())
+                {
+                    allPlayersSleeping = true;
+                    ci.cancel();
+                    return;
+                }
+            ci.cancel();
+        }
+    }
+
+    @Redirect(method = "tick", at = @At(
+            value = "INVOKE",
+            target = "Ljava/util/stream/Stream;noneMatch(Ljava/util/function/Predicate;)Z"
+    ))
+    private boolean noneMatchSleep(Stream<ServerPlayerEntity> stream, Predicate<ServerPlayerEntity> predicate)
+    {
+        if (CarpetSettings.getBool("onePlayerSleeping"))
+            return stream.anyMatch((p) -> !p.isSpectator() && p.isSleepingLongEnough());
+        return stream.noneMatch(predicate);
+    }
+
+}

src/main/java/carpet/mixins/SpawnHelperMixin.java

@@ -1,24 +1,82 @@
 package carpet.mixins;
 
 import carpet.CarpetSettings;
+import carpet.fakes.WorldInterface;
 import carpet.utils.SpawnReporter;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
 import net.minecraft.entity.mob.MobEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BoundingBox;
+import net.minecraft.util.shape.VoxelShapes;
 import net.minecraft.world.SpawnHelper;
 import net.minecraft.world.World;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
 
+import java.util.Map;
+
 @Mixin(SpawnHelper.class)
-public abstract class SpawnHelperMixin
+public class SpawnHelperMixin
 {
+    // in World: private static Map<EntityType, Entity> precookedMobs= new HashMap<>();
+
+    @Redirect(method = "spawnEntitiesInChunk", at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/World;doesNotCollide(Lnet/minecraft/util/math/BoundingBox;)Z"
+    ))
+    private static boolean doesNotCollide(World world, BoundingBox bb)
+    {
+        //.doesNotCollide is VERY expensive. On the other side - most worlds are not made of trapdoors in
+        // various configurations, but solid and 'passable' blocks, like air, water grass, etc.
+        // checking if in the BB of the entity are only passable blocks is very cheap and covers most cases
+        // in case something more complex happens - we default to full block collision check
+        if (CarpetSettings.b_lagFreeSpawning)
+        {
+            BlockPos.Mutable blockpos = new BlockPos.Mutable();
+            for (int x = (int)bb.minX,  maxx = (int)Math.ceil(bb.maxX); x < maxx; x++)
+                for (int z = (int)bb.minZ, maxz = (int)Math.ceil(bb.maxZ); z < maxz; z++)
+                    for (int y = (int)bb.minY, maxy = (int)Math.ceil(bb.maxY); y < maxy; y++)
+                    {
+                        blockpos.set(x, y, z);
+                        if (world.getBlockState(blockpos).getCollisionShape(world, blockpos) != VoxelShapes.empty())
+                            return world.doesNotCollide(bb);
+                    }
+            return true;
+        }
+        return world.doesNotCollide(bb);
+    }
+
+    @Redirect(method = "spawnEntitiesInChunk", at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/entity/EntityType;create(Lnet/minecraft/world/World;)Lnet/minecraft/entity/Entity;"
+    ))
+    private static Entity create(EntityType<?> entityType, World world_1)
+    {
+        if (CarpetSettings.b_lagFreeSpawning)
+        {
+            Map<EntityType, Entity> precookedMobs = ((WorldInterface)world_1).getPrecookedMobs();
+            if (precookedMobs.containsKey(entityType))
+                //this mob has been <init>'s but not used yet
+                return precookedMobs.get(entityType);
+            Entity e = entityType.create(world_1);
+            precookedMobs.put(entityType, e);
+            return e;
+        }
+        return entityType.create(world_1);
+    }
+
     @Redirect(method = "spawnEntitiesInChunk", at = @At(
             value = "INVOKE",
             target = "Lnet/minecraft/world/World;spawnEntity(Lnet/minecraft/entity/Entity;)Z"
     ))
-    private static boolean catchEntitySpawn(World world, Entity entity_1)
+    private static boolean spawnEntity(World world, Entity entity_1)
     {
+        if (CarpetSettings.b_lagFreeSpawning)
+            // we used the mob - next time we will create a new one when needed
+            ((WorldInterface) world).getPrecookedMobs().remove(entity_1.getType());
+
         if (SpawnReporter.track_spawns > 0L && SpawnReporter.local_spawns != null)
         {
             SpawnReporter.registerSpawn(
@@ -31,6 +89,4 @@ public abstract class SpawnHelperMixin
             return world.spawnEntity(entity_1);
         return false;
     }
-
-
 }

src/main/java/carpet/mixins/SummonCommandMixin.java

@@ -0,0 +1,54 @@
+package carpet.mixins;
+
+import carpet.CarpetSettings;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LightningEntity;
+import net.minecraft.entity.mob.SkeletonHorseEntity;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.server.command.ServerCommandSource;
+import net.minecraft.server.command.SummonCommand;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.LocalDifficulty;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+@Mixin(SummonCommand.class)
+public class SummonCommandMixin
+{
+    @Inject(method = "execute", locals = LocalCapture.CAPTURE_FAILHARD, cancellable = true, at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/server/world/ServerWorld;addLightning(Lnet/minecraft/entity/LightningEntity;)V",
+            shift = At.Shift.BEFORE
+    ))
+    private static void addRiders(ServerCommandSource source, Identifier identifier_1, Vec3d vec3d_1, CompoundTag compoundTag_1, boolean arg4, CallbackInfoReturnable<Integer> cir, CompoundTag compoundTag_2, LightningEntity lightningEntity_1)
+    {
+        // [CM] SummonNaturalLightning - if statement around
+        if (CarpetSettings.getBool("summonNaturalLightning") && !source.getWorld().isClient)
+        {
+            ServerWorld world = source.getWorld();
+            BlockPos at = new BlockPos(vec3d_1);
+            LocalDifficulty localDifficulty_1 =  source.getWorld().getLocalDifficulty(at);
+            boolean boolean_2 = world.getGameRules().getBoolean("doMobSpawning") && world.random.nextDouble() < (double)localDifficulty_1.getLocalDifficulty() * 0.01D;
+            if (boolean_2) {
+                SkeletonHorseEntity skeletonHorseEntity_1 = (SkeletonHorseEntity) EntityType.SKELETON_HORSE.create(world);
+                skeletonHorseEntity_1.setTrapped(true);
+                skeletonHorseEntity_1.setBreedingAge(0);
+                skeletonHorseEntity_1.setPosition(vec3d_1.x, vec3d_1.y, vec3d_1.z);
+                world.spawnEntity(skeletonHorseEntity_1);
+            }
+            world.addLightning(lightningEntity_1);
+            source.sendFeedback(new TranslatableComponent("commands.summon.success", new Object[]{lightningEntity_1.getDisplayName()}), true);
+            cir.setReturnValue(1);
+            cir.cancel();
+
+        }
+    }
+
+}

src/main/java/carpet/mixins/World_tickMixin.java

@@ -1,9 +1,11 @@
 package carpet.mixins;
 
+import carpet.fakes.WorldInterface;
 import carpet.helpers.TickSpeed;
 import carpet.utils.CarpetProfiler;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.util.profiler.Profiler;
 import net.minecraft.world.World;
@@ -14,15 +16,24 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
+import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.function.Consumer;
 
 @Mixin(World.class)
-public abstract class World_tickMixin
+public abstract class World_tickMixin implements WorldInterface
 {
     CarpetProfiler.ProfilerToken currentSection;
     CarpetProfiler.ProfilerToken entitySection;
 
+    Map<EntityType, Entity> precookedMobs = new HashMap<>();
+
+    public Map<EntityType, Entity> getPrecookedMobs()
+    {
+        return precookedMobs;
+    }
+
     @Inject(method = "tickBlockEntities", at = @At("HEAD"))
     private void startBlockEntities(CallbackInfo ci) {
         currentSection = CarpetProfiler.start_section((World) (Object) this, "Tile Entities", CarpetProfiler.TYPE.GENERAL);