Minecraft刷怪笼顾名思义就是刷怪的笼子，遍布Minecraft各地，除了在水中、浮空和末地不存在外，一般来说刷怪笼都存在于低于地平线的位置，但是也有一些刷怪笼生成于高于地面的山中，有时会出现多个刷怪笼密集生成于一片区域的情况，比如蜘蛛刷怪笼。每种刷怪笼只会刷出一种怪，比如骷髅刷怪笼只会刷出骷髅弓箭手。当周围有刷怪笼时，可以听到独特的嘶嘶声，并且如果感觉某种怪物数量骤增，前赴后继地来攻击你，那周围很可能有刷怪笼存在。另外大部分刷怪笼都处于一个特制的房间中，其特点就是地板和墙壁是苔石铺成的，如果在挖掘时遇到苔石墙就得留意，后面很可能有刷怪笼存在。刷怪笼为了保护旁边箱子里的“宝物”(很可能只是几片面包)，在人靠近时会不断刷出怪，当然也存在旁边没有箱子的刷怪笼，比如蜘蛛刷怪笼。

图1. 刷怪笼示意图

还有一种刷怪车的东西，作用基本和刷怪笼一样。

图2. 刷怪车示意图

刷怪笼是作为一种TileEntity存在的

public class TileEntityMobSpawner extends TileEntity implements IUpdatePlayerListBox
{
    private final MobSpawnerBaseLogic spawnerLogic = new MobSpawnerBaseLogic()
    {
        public void setBlockEvent(int eventid)
        {
            TileEntityMobSpawner.this.worldObj.addBlockEvent(TileEntityMobSpawner.this.pos, Blocks.mob_spawner, eventid, 0);
        }
        public World getSpawnerWorld()
        {
            return TileEntityMobSpawner.this.worldObj;
        }
        public BlockPos getPos()
        {
            return TileEntityMobSpawner.this.pos;
        }
        public void setRandomEntity(MobSpawnerBaseLogic.WeightedRandomMinecart randomEntity)
        {
            super.setRandomEntity(randomEntity);

            if (this.getSpawnerWorld() != null)
            {
                this.getSpawnerWorld().markBlockForUpdate(TileEntityMobSpawner.this.pos);
            }
        }
    };

    public void readFromNBT(NBTTagCompound compound)
    {
        super.readFromNBT(compound);
        this.spawnerLogic.readFromNBT(compound);
    }

    public void writeToNBT(NBTTagCompound compound)
    {
        super.writeToNBT(compound);
        this.spawnerLogic.writeToNBT(compound);
    }

    /**
     * Updates the JList with a new model.
     */
    public void update()
    {
        this.spawnerLogic.updateSpawner();
    }

    /**
     * Allows for a specialized description packet to be created. This is often used to sync tile entity data from the
     * server to the client easily. For example this is used by signs to synchronise the text to be displayed.
     */
    public Packet getDescriptionPacket()
    {
        NBTTagCompound nbttagcompound = new NBTTagCompound();
        this.writeToNBT(nbttagcompound);
        nbttagcompound.removeTag("SpawnPotentials");
        return new S35PacketUpdateTileEntity(this.pos, 1, nbttagcompound);
    }

    public boolean receiveClientEvent(int id, int type)
    {
        return this.spawnerLogic.setDelayToMin(id) ? true : super.receiveClientEvent(id, type);
    }

    public MobSpawnerBaseLogic getSpawnerBaseLogic()
    {
        return this.spawnerLogic;
    }
}

TileEntityMobSpawner的Update其实就是由MobSpawnerBaseLogic来决定的。

Minecraft Wiki里面对刷怪箱的刷怪逻辑如下

玩家距离刷怪箱16个方块内时，刷怪箱才会工作。当刷怪箱工作时，会以刷怪箱方块为中心的8×3×8（8格长宽，3格高）的有效区域生成生物，这意味着生物可以在一个9×9的区域，或距离刷怪箱3.5格的位置生成。生物可以在此区域符合生物生成要求的任意一处生成，生物更有可能生成在靠近刷怪箱而不是远离刷怪箱的地方。

当生物生成的 X 和 Z 坐标（注：不一定与刷怪箱对齐）是小数时，它们会生成在 Y 坐标是整数的地方。生物可以生成在8×8平面区域内的任意一处，但生成的生物脚的高度会与刷怪箱方块在同一层，或者比它高一层或低一层。

对于一些在生成区域以外生成的生物来说，必须远离不透明方块以确保可以容纳生物的高度和宽度，或由其它规则支配它们的每个生成区域。对于一些需要2格高或以上的空间才能生成的生物（如僵尸、骷髅或在Y轴最上面生成的烈焰人）来说，上面的空间必须只包含空气。

刷怪箱方块会尝试在有效区域内随机选择的位置生成4个生物，每次生成后会等待200-799刻（10-39.95秒）。在等待时，刷怪箱方块里面的生物会越转越快。除了对地面的生成要求，生物的其它生成要求也必须要满足（例如不能生成在固体方块里、亮度范围要正确等），因此刷怪箱常常不能生成4个生物。当刷怪箱生成了生物时，它会发出嘶嘶声，刷怪箱内火焰升腾。如果刷怪箱在有效区域内找不到任何符合要求的位置生成生物，则每一刻都会尝试一次。如果在生成阶段刷怪箱周围17×9×17的空间存在至少6个生物，则刷怪箱内火焰会升腾（表示已经“生成”了新的生物），但实际上生成过程被跳过，进入下一个周期。

当在一个没有有效位置生成生物的刷怪箱附近进行开采时，有时候刷怪箱会在方块被开采后立即生成一只怪物。

这些逻辑都在MobSpawnerBaseLogic.Java中定义

public abstract class MobSpawnerBaseLogic
{
    /** The delay to spawn. */
    private int spawnDelay = 20;
    private String mobID = "Pig";
    /** List of minecart to spawn. */
    private final List minecartToSpawn = Lists.newArrayList();
    private MobSpawnerBaseLogic.WeightedRandomMinecart randomEntity;
    /** The rotation of the mob inside the mob spawner */
    private double mobRotation;
    /** the previous rotation of the mob inside the mob spawner */
    private double prevMobRotation;
    private int minSpawnDelay = 200;
    private int maxSpawnDelay = 800;
    private int spawnCount = 4;
    /** Cached instance of the entity to render inside the spawner. */
    private Entity cachedEntity;
    private int maxNearbyEntities = 6;
    /** The distance from which a player activates the spawner. */
    private int activatingRangeFromPlayer = 16;
    /** The range coefficient for spawning entities around. */
    private int spawnRange = 4;

    /**
     * Gets the entity name that should be spawned.
     */
    private String getEntityNameToSpawn()
    {
        if (this.getRandomEntity() == null)
        {
            if (this.mobID.equals("Minecart"))
            {
                this.mobID = "MinecartRideable";
            }

            return this.mobID;
        }
        else
        {
            return this.getRandomEntity().entityType;
        }
    }

    public void setEntityName(String entityName)
    {
        this.mobID = entityName;
    }

    /**
     * Returns true if there's a player close enough to this mob spawner to activate it.
     */
    private boolean isActivated()
    {
        BlockPos blockpos = this.getBlockPos();
        return this.getSpawnerWorld().hasPlayerInRange((double)blockpos.getX() + 0.5D, (double)blockpos.getY() + 0.5D, (double)blockpos.getZ() + 0.5D, (double)this.activatingRangeFromPlayer);
    }

    public void updateSpawner()
    {
        if (this.isActivated())
        {
            BlockPos blockpos = this.getBlockPos();
            double posX;

            if (this.getSpawnerWorld().isRemote)
            {
                double d0 = (double)((float)blockpos.getX() + this.getSpawnerWorld().rand.nextFloat());
                double d1 = (double)((float)blockpos.getY() + this.getSpawnerWorld().rand.nextFloat());
                posX = (double)((float)blockpos.getZ() + this.getSpawnerWorld().rand.nextFloat());
                this.getSpawnerWorld().spawnParticle(EnumParticleTypes.SMOKE_NORMAL, d0, d1, posX, 0.0D, 0.0D, 0.0D, new int[0]);
                this.getSpawnerWorld().spawnParticle(EnumParticleTypes.FLAME, d0, d1, posX, 0.0D, 0.0D, 0.0D, new int[0]);

                if (this.spawnDelay > 0)
                {
                    --this.spawnDelay;
                }

                this.prevMobRotation = this.mobRotation;
                this.mobRotation = (this.mobRotation + (double)(1000.0F / ((float)this.spawnDelay + 200.0F))) % 360.0D;
            }
            else
            {
                if (this.spawnDelay == -1)
                {
                    this.resetTimer();
                }

                if (this.spawnDelay > 0)
                {
                    --this.spawnDelay;
                    return;
                }

                boolean flag = false;

                for (int i = 0; i < this.spawnCount; ++i)
                {
                    Entity entity = EntityList.createEntityByName(this.getEntityNameToSpawn(), this.getSpawnerWorld());

                    if (entity == null)
                    {
                        return;
                    }

                    int j = this.getSpawnerWorld().getEntitiesWithinAABB(entity.getClass(), (new AxisAlignedBB((double)blockpos.getX(), (double)blockpos.getY(), (double)blockpos.getZ(), (double)(blockpos.getX() + 1), (double)(blockpos.getY() + 1), (double)(blockpos.getZ() + 1))).expand((double)this.spawnRange, (double)this.spawnRange, (double)this.spawnRange)).size();

                    if (j >= this.maxNearbyEntities)
                    {
                        this.resetTimer();
                        return;
                    }

                    posX = (double)blockpos.getX() + (this.getSpawnerWorld().rand.nextDouble() - this.getSpawnerWorld().rand.nextDouble()) * (double)this.spawnRange + 0.5D;
                    double posY = (double)(blockpos.getY() + this.getSpawnerWorld().rand.nextInt(3) - 1);
                    double posZ = (double)blockpos.getZ() + (this.getSpawnerWorld().rand.nextDouble() - this.getSpawnerWorld().rand.nextDouble()) * (double)this.spawnRange + 0.5D;
                    EntityLiving entityliving = entity instanceof EntityLiving ? (EntityLiving)entity : null;
                    entity.setLocationAndAngles(posX, posY, posZ, this.getSpawnerWorld().rand.nextFloat() * 360.0F, 0.0F);

                    if (entityliving == null || entityliving.getCanSpawnHere() && entityliving.handleLavaMovement())
                    {
                        this.InstantiateEntity(entity, true);
                        this.getSpawnerWorld().playAuxSFX(2004, blockpos, 0);

                        if (entityliving != null)
                        {
                            entityliving.spawnExplosionParticle();
                        }

                        flag = true;
                    }
                }

                if (flag)
                {
                    this.resetTimer();
                }
            }
        }
    }

    private Entity InstantiateEntity(Entity entity, boolean needSpawn)
    {
        if (this.getRandomEntity() != null)
        {
            NBTTagCompound nbttagcompound = new NBTTagCompound();
            entity.writeToNBTOptional(nbttagcompound);
            Iterator iterator = this.getRandomEntity().nbtCompund.getKeySet().iterator();

            while (iterator.hasNext())
            {
                String s = (String)iterator.next();
                NBTBase nbtbase = this.getRandomEntity().nbtCompund.getTag(s);
                nbttagcompound.setTag(s, nbtbase.copy());
            }

            entity.readFromNBT(nbttagcompound);

            if (entity.worldObj != null && needSpawn)
            {
                entity.worldObj.spawnEntityInWorld(entity);
            }

            NBTTagCompound nbttagcompounposX;

            for (Entity entity1 = entity; nbttagcompound.hasKey("Riding", 10); nbttagcompound = nbttagcompounposX)
            {
                nbttagcompounposX = nbttagcompound.getCompoundTag("Riding");
                Entity entity2 = EntityList.createEntityByName(nbttagcompounposX.getString("id"), entity.worldObj);

                if (entity2 != null)
                {
                    NBTTagCompound nbttagcompound1 = new NBTTagCompound();
                    entity2.writeToNBTOptional(nbttagcompound1);
                    Iterator iterator1 = nbttagcompounposX.getKeySet().iterator();

                    while (iterator1.hasNext())
                    {
                        String s1 = (String)iterator1.next();
                        NBTBase nbtbase1 = nbttagcompounposX.getTag(s1);
                        nbttagcompound1.setTag(s1, nbtbase1.copy());
                    }

                    entity2.readFromNBT(nbttagcompound1);
                    entity2.setLocationAndAngles(entity1.posX, entity1.posY, entity1.posZ, entity1.rotationYaw, entity1.rotationPitch);

                    if (entity.worldObj != null && needSpawn)
                    {
                        entity.worldObj.spawnEntityInWorld(entity2);
                    }

                    entity1.mountEntity(entity2);
                }

                entity1 = entity2;
            }
        }
        else if (entity instanceof EntityLivingBase && entity.worldObj != null && needSpawn)
        {
            ((EntityLiving)entity).func_180482_a(entity.worldObj.getDifficultyForLocation(new BlockPos(entity)), (IEntityLivingData)null);
            entity.worldObj.spawnEntityInWorld(entity);
        }

        return entity;
    }

    private void resetTimer()
    {
        if (this.maxSpawnDelay <= this.minSpawnDelay)
        {
            this.spawnDelay = this.minSpawnDelay;
        }
        else
        {
            int i = this.maxSpawnDelay - this.minSpawnDelay;
            this.spawnDelay = this.minSpawnDelay + this.getSpawnerWorld().rand.nextInt(i);
        }

        if (this.minecartToSpawn.size() > 0)
        {
            this.setRandomEntity((MobSpawnerBaseLogic.WeightedRandomMinecart)WeightedRandom.getRandomItem(this.getSpawnerWorld().rand, this.minecartToSpawn));
        }

        this.setBlockEvent(1);
    }

    public void readFromNBT(NBTTagCompound nbtCompound)
    {
        this.mobID = nbtCompound.getString("EntityId");
        this.spawnDelay = nbtCompound.getShort("Delay");
        this.minecartToSpawn.clear();

        if (nbtCompound.hasKey("SpawnPotentials", 9))
        {
            NBTTagList nbttaglist = nbtCompound.getTagList("SpawnPotentials", 10);

            for (int i = 0; i < nbttaglist.tagCount(); ++i)
            {
                this.minecartToSpawn.add(new MobSpawnerBaseLogic.WeightedRandomMinecart(nbttaglist.getCompoundTagAt(i)));
            }
        }

        if (nbtCompound.hasKey("SpawnData", 10))
        {
            this.setRandomEntity(new MobSpawnerBaseLogic.WeightedRandomMinecart(nbtCompound.getCompoundTag("SpawnData"), this.mobID));
        }
        else
        {
            this.setRandomEntity((MobSpawnerBaseLogic.WeightedRandomMinecart)null);
        }

        if (nbtCompound.hasKey("MinSpawnDelay", 99))
        {
            this.minSpawnDelay = nbtCompound.getShort("MinSpawnDelay");
            this.maxSpawnDelay = nbtCompound.getShort("MaxSpawnDelay");
            this.spawnCount = nbtCompound.getShort("SpawnCount");
        }

        if (nbtCompound.hasKey("MaxNearbyEntities", 99))
        {
            this.maxNearbyEntities = nbtCompound.getShort("MaxNearbyEntities");
            this.activatingRangeFromPlayer = nbtCompound.getShort("RequiredPlayerRange");
        }

        if (nbtCompound.hasKey("SpawnRange", 99))
        {
            this.spawnRange = nbtCompound.getShort("SpawnRange");
        }

        if (this.getSpawnerWorld() != null)
        {
            this.cachedEntity = null;
        }
    }

    public void writeToNBT(NBTTagCompound nbtCompound)
    {
        nbtCompound.setString("EntityId", this.getEntityNameToSpawn());
        nbtCompound.setShort("Delay", (short)this.spawnDelay);
        nbtCompound.setShort("MinSpawnDelay", (short)this.minSpawnDelay);
        nbtCompound.setShort("MaxSpawnDelay", (short)this.maxSpawnDelay);
        nbtCompound.setShort("SpawnCount", (short)this.spawnCount);
        nbtCompound.setShort("MaxNearbyEntities", (short)this.maxNearbyEntities);
        nbtCompound.setShort("RequiredPlayerRange", (short)this.activatingRangeFromPlayer);
        nbtCompound.setShort("SpawnRange", (short)this.spawnRange);

        if (this.getRandomEntity() != null)
        {
            nbtCompound.setTag("SpawnData", this.getRandomEntity().nbtCompund.copy());
        }

        if (this.getRandomEntity() != null || this.minecartToSpawn.size() > 0)
        {
            NBTTagList nbttaglist = new NBTTagList();

            if (this.minecartToSpawn.size() > 0)
            {
                Iterator iterator = this.minecartToSpawn.iterator();

                while (iterator.hasNext())
                {
                    MobSpawnerBaseLogic.WeightedRandomMinecart weightedrandomminecart = (MobSpawnerBaseLogic.WeightedRandomMinecart)iterator.next();
                    nbttaglist.appendTag(weightedrandomminecart.generateNBT());
                }
            }
            else
            {
                nbttaglist.appendTag(this.getRandomEntity().generateNBT());
            }

            nbtCompound.setTag("SpawnPotentials", nbttaglist);
        }
    }

    /**
     * Sets the delay to minDelay if parameter given is 1, else return false.
     */
    public boolean setDelayToMin(int delay)
    {
        if (delay == 1 && this.getSpawnerWorld().isRemote)
        {
            this.spawnDelay = this.minSpawnDelay;
            return true;
        }
        else
        {
            return false;
        }
    }

    @SideOnly(Side.CLIENT)
    public Entity cacheEntity(World worldIn)
    {
        if (this.cachedEntity == null)
        {
            Entity entity = EntityList.createEntityByName(this.getEntityNameToSpawn(), worldIn);

            if (entity != null)
            {
                entity = this.InstantiateEntity(entity, false);
                this.cachedEntity = entity;
            }
        }

        return this.cachedEntity;
    }

    private MobSpawnerBaseLogic.WeightedRandomMinecart getRandomEntity()
    {
        return this.randomEntity;
    }

    public void setRandomEntity(MobSpawnerBaseLogic.WeightedRandomMinecart _randomEntity)
    {
        this.randomEntity = _randomEntity;
    }

    public abstract void setBlockEvent(int eventId);

    public abstract World getSpawnerWorld();

    public abstract BlockPos getBlockPos();

    @SideOnly(Side.CLIENT)
    public double getMobRotation()
    {
        return this.mobRotation;
    }

    @SideOnly(Side.CLIENT)
    public double getPrevMobRotation()
    {
        return this.prevMobRotation;
    }

    public class WeightedRandomMinecart extends WeightedRandom.Item
    {
        private final NBTTagCompound nbtCompund;
        private final String entityType;

        public WeightedRandomMinecart(NBTTagCompound nbtCompound)
        {
            this(nbtCompound.getCompoundTag("Properties"), nbtCompound.getString("Type"), nbtCompound.getInteger("Weight"));
        }

        public WeightedRandomMinecart(NBTTagCompound nbtCompound, String entityType)
        {
            this(nbtCompound, entityType, 1);
        }

        private WeightedRandomMinecart(NBTTagCompound nbtCompound, String entityType, int weight)
        {
            super(weight);

            if (entityType.equals("Minecart"))
            {
                if (nbtCompound != null)
                {
                    entityType = EntityMinecart.EnumMinecartType.byNetworkID(nbtCompound.getInteger("Type")).getName();
                }
                else
                {
                    entityType = "MinecartRideable";
                }
            }

            this.nbtCompund = nbtCompound;
            this.entityType = entityType;
        }

        public NBTTagCompound generateNBT()
        {
            NBTTagCompound nbttagcompound = new NBTTagCompound();
            nbttagcompound.setTag("Properties", this.nbtCompund);
            nbttagcompound.setString("Type", this.entityType);
            nbttagcompound.setInteger("Weight", this.itemWeight);
            return nbttagcompound;
        }
    }
}

这里面实现了一个WeightedRandomMinecart，他是一个WeightRandom.Item，也就是带权值的随机Item，权值越大，概率也就越大。

public class WeightedRandom
{

    /**
     * Returns the total weight of all items in a collection.
     *  
     * @param collection Collection to get the total weight of
     */
    public static int getTotalWeight(Collection collection)
    {
        int i = 0;
        WeightedRandom.Item item;

        for (Iterator iterator = collection.iterator(); iterator.hasNext(); i += item.itemWeight)
        {
            item = (WeightedRandom.Item)iterator.next();
        }

        return i;
    }

    /**
     * Returns a random choice from the input items, with a total weight value.
     *  
     * @param collection Collection of the input items
     */
    public static WeightedRandom.Item getRandomItem(Random random, Collection collection, int seed)
    {
        if (seed <= 0)
        {
            throw new IllegalArgumentException();
        }
        else
        {
            int j = random.nextInt(seed);
            return getRandomItem(collection, j);
        }
    }

    public static WeightedRandom.Item getRandomItem(Collection collection, int totalWeight)
    {
        Iterator iterator = collection.iterator();
        WeightedRandom.Item item;

        do
        {
            if (!iterator.hasNext())
            {
                return null;
            }

            item = (WeightedRandom.Item)iterator.next();
            totalWeight -= item.itemWeight;
        }
        while (totalWeight >= 0);

        return item;
    }

    /**
     * Returns a random choice from the input items.
     *  
     * @param collection Collection to get the random item from
     */
    public static WeightedRandom.Item getRandomItem(Random random, Collection collection)
    {
        /**
         * Returns a random choice from the input items, with a total weight value.
         *  
         * @param collection Collection of the input items
         */
        return getRandomItem(random, collection, getTotalWeight(collection));
    }

    public static class Item
        {
            /** The Weight is how often the item is chosen(higher number is higher chance(lower is lower)) */
            public int itemWeight;

            public Item(int itemWeightIn)
            {
                this.itemWeight = itemWeightIn;
            }
        }
}

参考

Minecraft wiki

Minecraft Forge