Initial commit (Forge 1291).

src/main/java/org/apache/logging/log4j/core/appender/ConsoleAppender.java

@@ -0,0 +1,245 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.core.appender;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.Serializable;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Constructor;
+import java.nio.charset.Charset;
+
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.Layout;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
+import org.apache.logging.log4j.core.config.plugins.PluginElement;
+import org.apache.logging.log4j.core.config.plugins.PluginFactory;
+import org.apache.logging.log4j.core.helpers.Booleans;
+import org.apache.logging.log4j.core.helpers.Loader;
+import org.apache.logging.log4j.core.layout.PatternLayout;
+import org.apache.logging.log4j.util.PropertiesUtil;
+
+/**
+ * ConsoleAppender appends log events to <code>System.out</code> or
+ * <code>System.err</code> using a layout specified by the user. The
+ * default target is <code>System.out</code>.
+ * @doubt accessing System.out or .err as a byte stream instead of a writer
+ *    bypasses the JVM's knowledge of the proper encoding. (RG) Encoding
+ * is handled within the Layout. Typically, a Layout will generate a String
+ * and then call getBytes which may use a configured encoding or the system
+ * default. OTOH, a Writer cannot print byte streams.
+ */
+@Plugin(name = "Console", category = "Core", elementType = "appender", printObject = true)
+public final class ConsoleAppender extends AbstractOutputStreamAppender {
+
+    private static final String JANSI_CLASS = "org.fusesource.jansi.WindowsAnsiOutputStream";
+    private static ConsoleManagerFactory factory = new ConsoleManagerFactory();
+
+    /**
+     * Enumeration of console destinations.
+     */
+    public enum Target {
+        /** Standard output. */
+        SYSTEM_OUT,
+        /** Standard error output. */
+        SYSTEM_ERR
+    }
+
+    private ConsoleAppender(final String name, final Layout<? extends Serializable> layout, final Filter filter,
+                            final OutputStreamManager manager,
+                            final boolean ignoreExceptions) {
+        super(name, layout, filter, ignoreExceptions, true, manager);
+    }
+
+    /**
+     * Create a Console Appender.
+     * @param layout The layout to use (required).
+     * @param filter The Filter or null.
+     * @param t The target ("SYSTEM_OUT" or "SYSTEM_ERR"). The default is "SYSTEM_OUT".
+     * @param follow If true will follow changes to the underlying output stream.
+     * @param name The name of the Appender (required).
+     * @param ignore If {@code "true"} (default) exceptions encountered when appending events are logged; otherwise
+     *               they are propagated to the caller.
+     * @return The ConsoleAppender.
+     */
+    @PluginFactory
+    public static ConsoleAppender createAppender(
+            @PluginElement("Layout") Layout<? extends Serializable> layout,
+            @PluginElement("Filters") final Filter filter,
+            @PluginAttribute("target") final String t,
+            @PluginAttribute("name") final String name,
+            @PluginAttribute("follow") final String follow,
+            @PluginAttribute("ignoreExceptions") final String ignore) {
+        if (name == null) {
+            LOGGER.error("No name provided for ConsoleAppender");
+            return null;
+        }
+        if (layout == null) {
+            layout = PatternLayout.createLayout(null, null, null, null, null);
+        }
+        final boolean isFollow = Boolean.parseBoolean(follow);
+        final boolean ignoreExceptions = Booleans.parseBoolean(ignore, true);
+        final Target target = t == null ? Target.SYSTEM_OUT : Target.valueOf(t);
+        return new ConsoleAppender(name, layout, filter, getManager(isFollow, target, layout), ignoreExceptions);
+    }
+
+    private static OutputStreamManager getManager(final boolean follow, final Target target, final Layout<? extends Serializable> layout) {
+        final String type = target.name();
+        final OutputStream os = getOutputStream(follow, target);
+        return OutputStreamManager.getManager(target.name() + "." + follow, new FactoryData(os, type, layout), factory);
+    }
+
+    private static OutputStream getOutputStream(final boolean follow, final Target target) {
+        final String enc = Charset.defaultCharset().name();
+        PrintStream printStream = null;
+        try {
+            printStream = target == Target.SYSTEM_OUT ?
+                    follow ? new PrintStream(new SystemOutStream(), true, enc) : System.out :
+                    follow ? new PrintStream(new SystemErrStream(), true, enc) : System.err;
+        } catch (final UnsupportedEncodingException ex) { // should never happen
+            throw new IllegalStateException("Unsupported default encoding " + enc, ex);
+        }
+        final PropertiesUtil propsUtil = PropertiesUtil.getProperties();
+        if (!propsUtil.getStringProperty("os.name").startsWith("Windows") ||
+                propsUtil.getBooleanProperty("log4j.skipJansi")) {
+            return printStream;
+        }
+        try {
+            final ClassLoader loader = Loader.getClassLoader();
+            // We type the parameter as a wildcard to avoid a hard reference to Jansi.
+            final Class<?> clazz = loader.loadClass(JANSI_CLASS);
+            final Constructor<?> constructor = clazz.getConstructor(OutputStream.class);
+            return (OutputStream) constructor.newInstance(printStream);
+        } catch (final ClassNotFoundException cnfe) {
+            LOGGER.debug("Jansi is not installed, cannot find {}", JANSI_CLASS);
+        } catch (final NoSuchMethodException nsme) {
+            LOGGER.warn("{} is missing the proper constructor", JANSI_CLASS);
+        } catch (final Throwable ex) { // CraftBukkit - Exception -> Throwable
+            LOGGER.warn("Unable to instantiate {}", JANSI_CLASS);
+        }
+        return printStream;
+    }
+
+    /**
+     * An implementation of OutputStream that redirects to the current System.err.
+     */
+    private static class SystemErrStream extends OutputStream {
+        public SystemErrStream() {
+        }
+
+        @Override
+        public void close() {
+            // do not close sys err!
+        }
+
+        @Override
+        public void flush() {
+            System.err.flush();
+        }
+
+        @Override
+        public void write(final byte[] b) throws IOException {
+            System.err.write(b);
+        }
+
+        @Override
+        public void write(final byte[] b, final int off, final int len)
+                throws IOException {
+            System.err.write(b, off, len);
+        }
+
+        @Override
+        public void write(final int b) {
+            System.err.write(b);
+        }
+    }
+
+    /**
+     * An implementation of OutputStream that redirects to the current System.out.
+     */
+    private static class SystemOutStream extends OutputStream {
+        public SystemOutStream() {
+        }
+
+        @Override
+        public void close() {
+            // do not close sys out!
+        }
+
+        @Override
+        public void flush() {
+            System.out.flush();
+        }
+
+        @Override
+        public void write(final byte[] b) throws IOException {
+            System.out.write(b);
+        }
+
+        @Override
+        public void write(final byte[] b, final int off, final int len)
+                throws IOException {
+            System.out.write(b, off, len);
+        }
+
+        @Override
+        public void write(final int b) throws IOException {
+            System.out.write(b);
+        }
+    }
+
+    /**
+     * Data to pass to factory method.
+     */
+    private static class FactoryData {
+        private final OutputStream os;
+        private final String type;
+        private final Layout<? extends Serializable> layout;
+
+        /**
+         * Constructor.
+         * @param os The OutputStream.
+         * @param type The name of the target.
+         * @param layout A Serializable layout
+         */
+        public FactoryData(final OutputStream os, final String type, final Layout<? extends Serializable> layout) {
+            this.os = os;
+            this.type = type;
+            this.layout = layout;
+        }
+    }
+
+    /**
+     * Factory to create the Appender.
+     */
+    private static class ConsoleManagerFactory implements ManagerFactory<OutputStreamManager, FactoryData> {
+
+        /**
+         * Create an OutputStreamManager.
+         * @param name The name of the entity to manage.
+         * @param data The data required to create the entity.
+         * @return The OutputStreamManager
+         */
+        @Override
+        public OutputStreamManager createManager(final String name, final FactoryData data) {
+            return new OutputStreamManager(data.os, data.type, data.layout);
+        }
+    }
+
+}

src/main/java/org/bukkit/craftbukkit/CraftArt.java

@@ -0,0 +1,73 @@
+package org.bukkit.craftbukkit;
+
+import org.bukkit.Art;
+
+// Safety class, will break if either side changes
+public class CraftArt {
+
+    public static Art NotchToBukkit(net.minecraft.entity.item.EntityPainting.EnumArt art) {
+        switch (art) {
+            case Kebab: return Art.KEBAB;
+            case Aztec: return Art.AZTEC;
+            case Alban: return Art.ALBAN;
+            case Aztec2: return Art.AZTEC2;
+            case Bomb: return Art.BOMB;
+            case Plant: return Art.PLANT;
+            case Wasteland: return Art.WASTELAND;
+            case Pool: return Art.POOL;
+            case Courbet: return Art.COURBET;
+            case Sea: return Art.SEA;
+            case Sunset: return Art.SUNSET;
+            case Creebet: return Art.CREEBET;
+            case Wanderer: return Art.WANDERER;
+            case Graham: return Art.GRAHAM;
+            case Match: return Art.MATCH;
+            case Bust: return Art.BUST;
+            case Stage: return Art.STAGE;
+            case Void: return Art.VOID;
+            case SkullAndRoses: return Art.SKULL_AND_ROSES;
+            case Fighters: return Art.FIGHTERS;
+            case Pointer: return Art.POINTER;
+            case Pigscene: return Art.PIGSCENE;
+            case BurningSkull: return Art.BURNINGSKULL;
+            case Skeleton: return Art.SKELETON;
+            case DonkeyKong: return Art.DONKEYKONG;
+            case Wither: return Art.WITHER;
+            default:
+                throw new AssertionError(art);
+        }
+    }
+
+    public static net.minecraft.entity.item.EntityPainting.EnumArt BukkitToNotch(Art art) {
+        switch (art) {
+            case KEBAB: return net.minecraft.entity.item.EntityPainting.EnumArt.Kebab;
+            case AZTEC: return net.minecraft.entity.item.EntityPainting.EnumArt.Aztec;
+            case ALBAN: return net.minecraft.entity.item.EntityPainting.EnumArt.Alban;
+            case AZTEC2: return net.minecraft.entity.item.EntityPainting.EnumArt.Aztec2;
+            case BOMB: return net.minecraft.entity.item.EntityPainting.EnumArt.Bomb;
+            case PLANT: return net.minecraft.entity.item.EntityPainting.EnumArt.Plant;
+            case WASTELAND: return net.minecraft.entity.item.EntityPainting.EnumArt.Wasteland;
+            case POOL: return net.minecraft.entity.item.EntityPainting.EnumArt.Pool;
+            case COURBET: return net.minecraft.entity.item.EntityPainting.EnumArt.Courbet;
+            case SEA: return net.minecraft.entity.item.EntityPainting.EnumArt.Sea;
+            case SUNSET: return net.minecraft.entity.item.EntityPainting.EnumArt.Sunset;
+            case CREEBET: return net.minecraft.entity.item.EntityPainting.EnumArt.Creebet;
+            case WANDERER: return net.minecraft.entity.item.EntityPainting.EnumArt.Wanderer;
+            case GRAHAM: return net.minecraft.entity.item.EntityPainting.EnumArt.Graham;
+            case MATCH: return net.minecraft.entity.item.EntityPainting.EnumArt.Match;
+            case BUST: return net.minecraft.entity.item.EntityPainting.EnumArt.Bust;
+            case STAGE: return net.minecraft.entity.item.EntityPainting.EnumArt.Stage;
+            case VOID: return net.minecraft.entity.item.EntityPainting.EnumArt.Void;
+            case SKULL_AND_ROSES: return net.minecraft.entity.item.EntityPainting.EnumArt.SkullAndRoses;
+            case FIGHTERS: return net.minecraft.entity.item.EntityPainting.EnumArt.Fighters;
+            case POINTER: return net.minecraft.entity.item.EntityPainting.EnumArt.Pointer;
+            case PIGSCENE: return net.minecraft.entity.item.EntityPainting.EnumArt.Pigscene;
+            case BURNINGSKULL: return net.minecraft.entity.item.EntityPainting.EnumArt.BurningSkull;
+            case SKELETON: return net.minecraft.entity.item.EntityPainting.EnumArt.Skeleton;
+            case DONKEYKONG: return net.minecraft.entity.item.EntityPainting.EnumArt.DonkeyKong;
+            case WITHER: return net.minecraft.entity.item.EntityPainting.EnumArt.Wither;
+            default:
+                throw new AssertionError(art);
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftChunk.java

@@ -0,0 +1,346 @@
+package org.bukkit.craftbukkit;
+
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+
+
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.craftbukkit.block.CraftBlock;
+import org.bukkit.entity.Entity;
+import org.bukkit.ChunkSnapshot;
+
+public class CraftChunk implements Chunk {
+    private WeakReference<net.minecraft.world.chunk.Chunk> weakChunk;
+    private final net.minecraft.world.WorldServer worldServer;
+    private final int x;
+    private final int z;
+    private static final byte[] emptyData = new byte[2048];
+    private static final short[] emptyBlockIDs = new short[4096];
+    private static final byte[] emptySkyLight = new byte[2048];
+
+    public CraftChunk(net.minecraft.world.chunk.Chunk chunk) {
+        if (!(chunk instanceof net.minecraft.world.chunk.EmptyChunk)) {
+            this.weakChunk = new WeakReference<net.minecraft.world.chunk.Chunk>(chunk);
+        }
+
+        worldServer = (net.minecraft.world.WorldServer) getHandle().worldObj;
+        x = getHandle().xPosition;
+        z = getHandle().zPosition;
+    }
+
+    public World getWorld() {
+        return worldServer.getWorld();
+    }
+
+    public CraftWorld getCraftWorld() {
+        return (CraftWorld) getWorld();
+    }
+
+    public net.minecraft.world.chunk.Chunk getHandle() {
+        net.minecraft.world.chunk.Chunk c = weakChunk.get();
+
+        if (c == null) {
+            c = worldServer.getChunkFromChunkCoords(x, z);
+
+            if (!(c instanceof net.minecraft.world.chunk.EmptyChunk)) {
+                weakChunk = new WeakReference<net.minecraft.world.chunk.Chunk>(c);
+            }
+        }
+
+        return c;
+    }
+
+    void breakLink() {
+        weakChunk.clear();
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getZ() {
+        return z;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftChunk{" + "x=" + getX() + "z=" + getZ() + '}';
+    }
+
+    public Block getBlock(int x, int y, int z) {
+        return new CraftBlock(this, (getX() << 4) | (x & 0xF), y & 0xFF, (getZ() << 4) | (z & 0xF));
+    }
+
+    public Entity[] getEntities() {
+        int count = 0, index = 0;
+        net.minecraft.world.chunk.Chunk chunk = getHandle();
+
+        for (int i = 0; i < 16; i++) {
+            count += chunk.entityLists[i].size();
+        }
+
+        Entity[] entities = new Entity[count];
+
+        for (int i = 0; i < 16; i++) {
+            for (Object obj : chunk.entityLists[i].toArray()) {
+                if (!(obj instanceof net.minecraft.entity.Entity)) {
+                    continue;
+                }
+
+                entities[index++] = ((net.minecraft.entity.Entity) obj).getBukkitEntity();
+            }
+        }
+
+        return entities;
+    }
+
+    public BlockState[] getTileEntities() {
+        int index = 0;
+        net.minecraft.world.chunk.Chunk chunk = getHandle();
+        BlockState[] entities = new BlockState[chunk.chunkTileEntityMap.size()];
+
+        for (Object obj : chunk.chunkTileEntityMap.keySet().toArray()) {
+            if (!(obj instanceof net.minecraft.world.ChunkPosition)) {
+                continue;
+            }
+
+            net.minecraft.world.ChunkPosition position = (net.minecraft.world.ChunkPosition) obj;
+            entities[index++] = worldServer.getWorld().getBlockAt(position.chunkPosX + (chunk.xPosition << 4), position.chunkPosY, position.chunkPosZ + (chunk.zPosition << 4)).getState();
+        }
+        return entities;
+    }
+
+    public boolean isLoaded() {
+        return getWorld().isChunkLoaded(this);
+    }
+
+    public boolean load() {
+        return getWorld().loadChunk(getX(), getZ(), true);
+    }
+
+    public boolean load(boolean generate) {
+        return getWorld().loadChunk(getX(), getZ(), generate);
+    }
+
+    public boolean unload() {
+        return getWorld().unloadChunk(getX(), getZ());
+    }
+
+    public boolean unload(boolean save) {
+        return getWorld().unloadChunk(getX(), getZ(), save);
+    }
+
+    public boolean unload(boolean save, boolean safe) {
+        return getWorld().unloadChunk(getX(), getZ(), save, safe);
+    }
+
+    public ChunkSnapshot getChunkSnapshot() {
+        return getChunkSnapshot(true, false, false);
+    }
+
+    public ChunkSnapshot getChunkSnapshot(boolean includeMaxBlockY, boolean includeBiome, boolean includeBiomeTempRain) {
+        net.minecraft.world.chunk.Chunk chunk = getHandle();
+
+        net.minecraft.world.chunk.storage.ExtendedBlockStorage[] cs = chunk.getBlockStorageArray(); /* Get sections */
+        short[][] sectionBlockIDs = new short[cs.length][];
+        byte[][] sectionBlockData = new byte[cs.length][];
+        byte[][] sectionSkyLights = new byte[cs.length][];
+        byte[][] sectionEmitLights = new byte[cs.length][];
+        boolean[] sectionEmpty = new boolean[cs.length];
+
+        for (int i = 0; i < cs.length; i++) {
+            if (cs[i] == null) { /* Section is empty? */
+                sectionBlockIDs[i] = emptyBlockIDs;
+                sectionBlockData[i] = emptyData;
+                sectionSkyLights[i] = emptySkyLight;
+                sectionEmitLights[i] = emptyData;
+                sectionEmpty[i] = true;
+            } else { /* Not empty */
+                short[] blockids = new short[4096];
+                byte[] baseids = cs[i].getBlockLSBArray();
+
+                /* Copy base IDs */
+                for (int j = 0; j < 4096; j++) {
+                    blockids[j] = (short) (baseids[j] & 0xFF);
+                }
+
+                if (cs[i].getBlockMSBArray() != null) { /* If we've got extended IDs */
+                    // Spigot start
+                    if (cs[i].getBlockMSBArray().isTrivialArray()) {
+                        int tval = cs[i].getBlockMSBArray().getTrivialArrayValue();
+                        if (tval != 0) {
+                            tval = tval << 8;
+                            for (int j = 0; j < 4096; j++) {
+                                blockids[j] |= tval;
+                            }
+                        }
+                  } else {
+                    byte[] extids = cs[i].getBlockMSBArray().getValueArray();
+                    // Spigot end
+
+                    for (int j = 0; j < 2048; j++) {
+                        short b = (short) (extids[j] & 0xFF);
+
+                        if (b == 0) {
+                            continue;
+                        }
+
+                        blockids[j<<1] |= (b & 0x0F) << 8;
+                        blockids[(j<<1)+1] |= (b & 0xF0) << 4;
+                    }
+                    } // Spigot
+                }
+
+                sectionBlockIDs[i] = blockids;
+
+                /* Get block data nibbles */
+                // Spigot start
+                if (cs[i].getMetadataArray().isTrivialArray() && (cs[i].getMetadataArray().getTrivialArrayValue() == 0)) {
+                    sectionBlockData[i] = emptyData;
+                } else {
+                    sectionBlockData[i] = new byte[2048];
+                    cs[i].getMetadataArray().copyToByteArray(sectionBlockData[i], 0);
+                }
+                if (cs[i].getSkylightArray() == null) {
+                    sectionSkyLights[i] = emptyData;
+                }
+                else if (cs[i].getSkylightArray().isTrivialArray()) {
+                    if (cs[i].getSkylightArray().getTrivialArrayValue() == 0) {
+                        sectionSkyLights[i] = emptyData;
+                    } else if (cs[i].getSkylightArray().getTrivialArrayValue() == 15) {
+                        sectionSkyLights[i] = emptySkyLight;
+                    } else {
+                        sectionSkyLights[i] = new byte[2048];
+                        cs[i].getSkylightArray().copyToByteArray(sectionSkyLights[i], 0);
+                    }
+                } else {
+                    sectionSkyLights[i] = new byte[2048];
+                    cs[i].getSkylightArray().copyToByteArray(sectionSkyLights[i], 0);
+                }
+                if (cs[i].getBlocklightArray().isTrivialArray() && (cs[i].getBlocklightArray().getTrivialArrayValue() == 0)) {
+                    sectionEmitLights[i] = emptyData;
+                } else {
+                    sectionEmitLights[i] = new byte[2048];
+                    cs[i].getBlocklightArray().copyToByteArray(sectionEmitLights[i], 0);
+                }
+                // Spigot end
+            }
+        }
+
+        int[] hmap = null;
+
+        if (includeMaxBlockY) {
+            hmap = new int[256]; // Get copy of height map
+            System.arraycopy(chunk.heightMap, 0, hmap, 0, 256);
+        }
+
+        net.minecraft.world.biome.BiomeGenBase[] biome = null;
+        double[] biomeTemp = null;
+        double[] biomeRain = null;
+
+        if (includeBiome || includeBiomeTempRain) {
+            net.minecraft.world.biome.WorldChunkManager wcm = chunk.worldObj.getWorldChunkManager();
+
+            if (includeBiome) {
+                biome = new net.minecraft.world.biome.BiomeGenBase[256];
+                for (int i = 0; i < 256; i++) {
+                    biome[i] = chunk.getBiomeGenForWorldCoords(i & 0xF, i >> 4, wcm);
+                }
+            }
+
+            if (includeBiomeTempRain) {
+                biomeTemp = new double[256];
+                biomeRain = new double[256];
+                float[] dat = getTemperatures(wcm, getX() << 4, getZ() << 4);
+
+                for (int i = 0; i < 256; i++) {
+                    biomeTemp[i] = dat[i];
+                }
+
+                dat = wcm.getRainfall(null, getX() << 4, getZ() << 4, 16, 16);
+
+                for (int i = 0; i < 256; i++) {
+                    biomeRain[i] = dat[i];
+                }
+            }
+        }
+
+        World world = getWorld();
+        return new CraftChunkSnapshot(getX(), getZ(), world.getName(), world.getFullTime(), sectionBlockIDs, sectionBlockData, sectionSkyLights, sectionEmitLights, sectionEmpty, hmap, biome, biomeTemp, biomeRain);
+    }
+
+    public static ChunkSnapshot getEmptyChunkSnapshot(int x, int z, CraftWorld world, boolean includeBiome, boolean includeBiomeTempRain) {
+        net.minecraft.world.biome.BiomeGenBase[] biome = null;
+        double[] biomeTemp = null;
+        double[] biomeRain = null;
+
+        if (includeBiome || includeBiomeTempRain) {
+            net.minecraft.world.biome.WorldChunkManager wcm = world.getHandle().getWorldChunkManager();
+
+            if (includeBiome) {
+                biome = new net.minecraft.world.biome.BiomeGenBase[256];
+                for (int i = 0; i < 256; i++) {
+                    biome[i] = world.getHandle().getBiomeGenForCoords((x << 4) + (i & 0xF), (z << 4) + (i >> 4));
+                }
+            }
+
+            if (includeBiomeTempRain) {
+                biomeTemp = new double[256];
+                biomeRain = new double[256];
+                float[] dat = getTemperatures(wcm, x << 4, z << 4);
+
+                for (int i = 0; i < 256; i++) {
+                    biomeTemp[i] = dat[i];
+                }
+
+                dat = wcm.getRainfall(null, x << 4, z << 4, 16, 16);
+
+                for (int i = 0; i < 256; i++) {
+                    biomeRain[i] = dat[i];
+                }
+            }
+        }
+
+        /* Fill with empty data */
+        int hSection = world.getMaxHeight() >> 4;
+        short[][] blockIDs = new short[hSection][];
+        byte[][] skyLight = new byte[hSection][];
+        byte[][] emitLight = new byte[hSection][];
+        byte[][] blockData = new byte[hSection][];
+        boolean[] empty = new boolean[hSection];
+
+        for (int i = 0; i < hSection; i++) {
+            blockIDs[i] = emptyBlockIDs;
+            skyLight[i] = emptySkyLight;
+            emitLight[i] = emptyData;
+            blockData[i] = emptyData;
+            empty[i] = true;
+        }
+
+        return new CraftChunkSnapshot(x, z, world.getName(), world.getFullTime(), blockIDs, blockData, skyLight, emitLight, empty, new int[256], biome, biomeTemp, biomeRain);
+    }
+
+    private static float[] getTemperatures(net.minecraft.world.biome.WorldChunkManager chunkmanager, int chunkX, int chunkZ) {
+        net.minecraft.world.biome.BiomeGenBase[] biomes = chunkmanager.getBiomesForGeneration(null, chunkX, chunkZ, 16, 16);
+        float[] temps = new float[biomes.length];
+
+        for (int i = 0; i < biomes.length; i++) {
+            float temp = biomes[i].temperature; // Vanilla of olde: ((int) biomes[i].temperature * 65536.0F) / 65536.0F
+
+            if (temp > 1F) {
+                temp = 1F;
+            }
+
+            temps[i] = temp;
+        }
+
+        return temps;
+    }
+
+    static {
+        Arrays.fill(emptySkyLight, (byte) 0xFF);
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java

@@ -0,0 +1,96 @@
+package org.bukkit.craftbukkit;
+
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.block.Biome;
+import org.bukkit.craftbukkit.block.CraftBlock;
+
+
+/**
+ * Represents a static, thread-safe snapshot of chunk of blocks
+ * Purpose is to allow clean, efficient copy of a chunk data to be made, and then handed off for processing in another thread (e.g. map rendering)
+ */
+public class CraftChunkSnapshot implements ChunkSnapshot {
+    private final int x, z;
+    private final String worldname;
+    private final short[][] blockids; /* Block IDs, by section */
+    private final byte[][] blockdata;
+    private final byte[][] skylight;
+    private final byte[][] emitlight;
+    private final boolean[] empty;
+    private final int[] hmap; // Height map
+    private final long captureFulltime;
+    private final net.minecraft.world.biome.BiomeGenBase[] biome;
+    private final double[] biomeTemp;
+    private final double[] biomeRain;
+
+    CraftChunkSnapshot(int x, int z, String wname, long wtime, short[][] sectionBlockIDs, byte[][] sectionBlockData, byte[][] sectionSkyLights, byte[][] sectionEmitLights, boolean[] sectionEmpty, int[] hmap, net.minecraft.world.biome.BiomeGenBase[] biome, double[] biomeTemp, double[] biomeRain) {
+        this.x = x;
+        this.z = z;
+        this.worldname = wname;
+        this.captureFulltime = wtime;
+        this.blockids = sectionBlockIDs;
+        this.blockdata = sectionBlockData;
+        this.skylight = sectionSkyLights;
+        this.emitlight = sectionEmitLights;
+        this.empty = sectionEmpty;
+        this.hmap = hmap;
+        this.biome = biome;
+        this.biomeTemp = biomeTemp;
+        this.biomeRain = biomeRain;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getZ() {
+        return z;
+    }
+
+    public String getWorldName() {
+        return worldname;
+    }
+
+    public final int getBlockTypeId(int x, int y, int z) {
+        return blockids[y >> 4][((y & 0xF) << 8) | (z << 4) | x];
+    }
+
+    public final int getBlockData(int x, int y, int z) {
+        int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
+        return (blockdata[y >> 4][off] >> ((x & 1) << 2)) & 0xF;
+    }
+
+    public final int getBlockSkyLight(int x, int y, int z) {
+        int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
+        return (skylight[y >> 4][off] >> ((x & 1) << 2)) & 0xF;
+    }
+
+    public final int getBlockEmittedLight(int x, int y, int z) {
+        int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
+        return (emitlight[y >> 4][off] >> ((x & 1) << 2)) & 0xF;
+    }
+
+    public final int getHighestBlockYAt(int x, int z) {
+        return hmap[z << 4 | x];
+    }
+
+    public final Biome getBiome(int x, int z) {
+        return CraftBlock.biomeBaseToBiome(biome[z << 4 | x]);
+    }
+
+    public final double getRawBiomeTemperature(int x, int z) {
+        return biomeTemp[z << 4 | x];
+    }
+
+    public final double getRawBiomeRainfall(int x, int z) {
+        return biomeRain[z << 4 | x];
+    }
+
+    public final long getCaptureFullTime() {
+        return captureFulltime;
+    }
+
+    public final boolean isSectionEmpty(int sy) {
+        return empty[sy];
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftCrashReport.java

@@ -0,0 +1,40 @@
+package org.bukkit.craftbukkit;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.Callable;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginDescriptionFile;
+
+
+public class CraftCrashReport implements Callable<Object> {
+
+    public Object call() throws Exception {
+        StringWriter value = new StringWriter();
+        try {
+            value.append("\n   Running: ").append(Bukkit.getName()).append(" version ").append(Bukkit.getVersion()).append(" (Implementing API version ").append(Bukkit.getBukkitVersion()).append(") ").append(String.valueOf(net.minecraft.server.MinecraftServer.getServer().isServerInOnlineMode()));
+            value.append("\n   Plugins: {");
+            for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+                PluginDescriptionFile description = plugin.getDescription();
+                value.append(' ').append(description.getFullName()).append(' ').append(description.getMain()).append(' ').append(Arrays.toString(description.getAuthors().toArray())).append(',');
+            }
+            value.append("}\n   Warnings: ").append(Bukkit.getWarningState().name());
+            value.append("\n   Threads: {");
+            for (Map.Entry<Thread, ? extends Object[]> entry : Thread.getAllStackTraces().entrySet()) {
+                value.append(' ').append(entry.getKey().getState().name()).append(' ').append(entry.getKey().getName()).append(": ").append(Arrays.toString(entry.getValue())).append(',');
+            }
+            value.append("}\n   ").append(Bukkit.getScheduler().toString());
+        } catch (Throwable t) {
+            value.append("\n   Failed to handle CraftCrashReport:\n");
+            PrintWriter writer = new PrintWriter(value);
+            t.printStackTrace(writer);
+            writer.flush();
+        }
+        return value.toString();
+    }
+
+}

src/main/java/org/bukkit/craftbukkit/CraftEffect.java

@@ -0,0 +1,63 @@
+package org.bukkit.craftbukkit;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.potion.Potion;
+
+public class CraftEffect {
+    public static <T> int getDataValue(Effect effect, T data) {
+        int datavalue;
+        switch(effect) {
+        case POTION_BREAK:
+            datavalue = ((Potion) data).toDamageValue() & 0x3F;
+            break;
+        case RECORD_PLAY:
+            Validate.isTrue(((Material) data).isRecord(), "Invalid record type!");
+            datavalue = ((Material) data).getId();
+            break;
+        case SMOKE:
+            switch((BlockFace) data) { // TODO: Verify (Where did these values come from...?)
+            case SOUTH_EAST:
+                datavalue = 0;
+                break;
+            case SOUTH:
+                datavalue = 1;
+                break;
+            case SOUTH_WEST:
+                datavalue = 2;
+                break;
+            case EAST:
+                datavalue = 3;
+                break;
+            case UP:
+            case SELF:
+                datavalue = 4;
+                break;
+            case WEST:
+                datavalue = 5;
+                break;
+            case NORTH_EAST:
+                datavalue = 6;
+                break;
+            case NORTH:
+                datavalue = 7;
+                break;
+            case NORTH_WEST:
+                datavalue = 8;
+                break;
+            default:
+                throw new IllegalArgumentException("Bad smoke direction!");
+            }
+            break;
+        case STEP_SOUND:
+            Validate.isTrue(((Material) data).isBlock(), "Material is not a block!");
+            datavalue = ((Material) data).getId();
+            break;
+        default:
+            datavalue = 0;
+        }
+        return datavalue;
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftIpBanEntry.java

@@ -0,0 +1,86 @@
+package org.bukkit.craftbukkit;
+
+import net.minecraft.server.management.IPBanEntry;
+import net.minecraft.server.management.BanList;
+import net.minecraft.server.MinecraftServer;
+
+import java.io.IOException;
+import java.util.Date;
+
+public final class CraftIpBanEntry implements org.bukkit.BanEntry {
+    private final BanList list;
+    private final String target;
+    private Date created;
+    private String source;
+    private Date expiration;
+    private String reason;
+
+    public CraftIpBanEntry(String target, IPBanEntry entry, BanList list) {
+        this.list = list;
+        this.target = target;
+        this.created = entry.getCreated() != null ? new Date(entry.getCreated().getTime()) : null;
+        this.source = entry.getSource();
+        this.expiration = entry.getBanEndDate() != null ? new Date(entry.getBanEndDate().getTime()) : null;
+        this.reason = entry.getBanReason();
+    }
+
+    @Override
+    public String getTarget() {
+        return this.target;
+    }
+
+    @Override
+    public Date getCreated() {
+        return this.created == null ? null : (Date) this.created.clone();
+    }
+
+    @Override
+    public void setCreated(Date created) {
+        this.created = created;
+    }
+
+    @Override
+    public String getSource() {
+        return this.source;
+    }
+
+    @Override
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    @Override
+    public Date getExpiration() {
+        return this.expiration == null ? null : (Date) this.expiration.clone();
+    }
+
+    @Override
+    public void setExpiration(Date expiration) {
+        if (expiration != null && expiration.getTime() == new Date(0, 0, 0, 0, 0, 0).getTime()) {
+            expiration = null; // Forces "forever"
+        }
+
+        this.expiration = expiration;
+    }
+
+    @Override
+    public String getReason() {
+        return this.reason;
+    }
+
+    @Override
+    public void setReason(String reason) {
+        this.reason = reason;
+    }
+
+    @Override
+    public void save() {
+        IPBanEntry entry = new IPBanEntry(target, this.created, this.source, this.expiration, this.reason);
+        this.list.func_152687_a(entry);
+        try {
+            this.list.func_152678_f();
+        } catch (IOException ex) {
+            MinecraftServer.getLogger().error("Failed to save banned-ips.json, " + ex.getMessage());
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftIpBanList.java

@@ -0,0 +1,77 @@
+package org.bukkit.craftbukkit;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.Date;
+import java.util.Set;
+
+import net.minecraft.server.management.IPBanEntry;
+import net.minecraft.server.management.BanList;
+import net.minecraft.server.MinecraftServer;
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.Validate;
+
+import com.google.common.collect.ImmutableSet;
+
+public class CraftIpBanList implements org.bukkit.BanList {
+    private final BanList list;
+
+    public CraftIpBanList(BanList list) {
+        this.list = list;
+    }
+
+    @Override
+    public org.bukkit.BanEntry getBanEntry(String target) {
+        Validate.notNull(target, "Target cannot be null");
+
+        IPBanEntry entry = (IPBanEntry) list.func_152683_b(target);
+        if (entry == null) {
+            return null;
+        }
+
+        return new CraftIpBanEntry(target, entry, list);
+    }
+
+    @Override
+    public org.bukkit.BanEntry addBan(String target, String reason, Date expires, String source) {
+        Validate.notNull(target, "Ban target cannot be null");
+
+        IPBanEntry entry = new IPBanEntry(target, new Date(),
+                StringUtils.isBlank(source) ? null : source, expires,
+                StringUtils.isBlank(reason) ? null : reason);
+
+        list.func_152687_a(entry);
+
+        try {
+            list.func_152678_f();
+        } catch (IOException ex) {
+            MinecraftServer.getLogger().error("Failed to save banned-ips.json, " + ex.getMessage());
+        }
+
+        return new CraftIpBanEntry(target, entry, list);
+    }
+
+    @Override
+    public Set<org.bukkit.BanEntry> getBanEntries() {
+        ImmutableSet.Builder<org.bukkit.BanEntry> builder = ImmutableSet.builder();
+        for (String target : list.func_152685_a()) {
+            builder.add(new CraftIpBanEntry(target, (IPBanEntry) list.func_152683_b(target), list));
+        }
+
+        return builder.build();
+    }
+
+    @Override
+    public boolean isBanned(String target) {
+        Validate.notNull(target, "Target cannot be null");
+
+        return list.func_152708_a(InetSocketAddress.createUnresolved(target, 0));
+    }
+
+    @Override
+    public void pardon(String target) {
+        Validate.notNull(target, "Target cannot be null");
+
+        list.func_152684_c(target);
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java

@@ -0,0 +1,268 @@
+package org.bukkit.craftbukkit;
+
+import java.io.File;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+
+import com.mojang.authlib.GameProfile;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.nbt.NBTTagCompound;
+
+import org.bukkit.BanList;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Server;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.SerializableAs;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+
+@SerializableAs("Player")
+public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializable {
+    private final GameProfile profile;
+    private final CraftServer server;
+    private final net.minecraft.world.storage.SaveHandler storage;
+
+    protected CraftOfflinePlayer(CraftServer server, GameProfile profile) {
+        this.server = server;
+        this.profile = profile;
+        this.storage = (net.minecraft.world.storage.SaveHandler) (server.console.worlds.get(0).getSaveHandler());
+    }
+
+    public GameProfile getProfile() {
+        return profile;
+    }
+
+    public boolean isOnline() {
+        return getPlayer() != null;
+    }
+
+    public String getName() {
+        Player player = getPlayer();
+        if (player != null) {
+            return player.getName();
+        }
+
+        // This might not match lastKnownName but if not it should be more correct
+        if (profile.getName() != null) {
+            return profile.getName();
+        }
+
+        NBTTagCompound data = getBukkitData();
+
+        if (data != null) {
+            if (data.hasKey("lastKnownName")) {
+                return data.getString("lastKnownName");
+            }
+        }
+
+        return null;
+    }
+
+    public UUID getUniqueId() {
+        return profile.getId();
+    }
+
+    public Server getServer() {
+        return server;
+    }
+
+    public boolean isOp() {
+        return server.getHandle().func_152596_g(profile);
+    }
+
+    public void setOp(boolean value) {
+        if (value == isOp()) {
+            return;
+        }
+
+        if (value) {
+            server.getHandle().func_152605_a(profile);
+        } else {
+            server.getHandle().func_152610_b(profile);
+        }
+    }
+
+    public boolean isBanned() {
+        if (getName() == null) {
+            return false;
+        }
+
+        return server.getBanList(BanList.Type.NAME).isBanned(getName());
+    }
+
+    public void setBanned(boolean value) {
+        if (getName() == null) {
+            return;
+        }
+
+        if (value) {
+            server.getBanList(BanList.Type.NAME).addBan(getName(), null, null, null);
+        } else {
+            server.getBanList(BanList.Type.NAME).pardon(getName());
+        }
+    }
+
+    public boolean isWhitelisted() {
+        return server.getHandle().func_152607_e(profile); // Cauldron
+    }
+
+    public void setWhitelisted(boolean value) {
+        if (value) {
+            server.getHandle().func_152601_d(profile);
+        } else {
+            server.getHandle().func_152597_c(profile);
+        }
+    }
+
+    public Map<String, Object> serialize() {
+        Map<String, Object> result = new LinkedHashMap<String, Object>();
+
+        result.put("UUID", profile.getId().toString());
+
+        return result;
+    }
+
+    public static OfflinePlayer deserialize(Map<String, Object> args) {
+        // Backwards comparability
+        if (args.get("name") != null) {
+        return Bukkit.getServer().getOfflinePlayer((String) args.get("name"));
+    }
+
+        return Bukkit.getServer().getOfflinePlayer(UUID.fromString((String) args.get("UUID")));
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "[UUID=" + profile.getId() + "]";
+    }
+
+    public Player getPlayer() {
+        for (Object obj : server.getHandle().playerEntityList) {
+            EntityPlayerMP player = (EntityPlayerMP) obj;
+            if (player.getUniqueID().equals(getUniqueId())) {
+                return (player.playerNetServerHandler != null) ? player.playerNetServerHandler.getPlayerB() : null; // Cauldron
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || !(obj instanceof OfflinePlayer)) {
+            return false;
+        }
+
+        OfflinePlayer other = (OfflinePlayer) obj;
+        if ((this.getUniqueId() == null) || (other.getUniqueId() == null)) {
+            return false;
+        }
+
+        return this.getUniqueId().equals(other.getUniqueId());
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 5;
+        hash = 97 * hash + (this.getUniqueId() != null ? this.getUniqueId().hashCode() : 0);
+        return hash;
+    }
+
+    private NBTTagCompound getData() {
+        return storage.getPlayerData(getUniqueId().toString());
+    }
+
+    private NBTTagCompound getBukkitData() {
+        NBTTagCompound result = getData();
+
+        if (result != null) {
+            if (!result.hasKey("bukkit")) {
+                result.setTag("bukkit", new net.minecraft.nbt.NBTTagCompound());
+            }
+            result = result.getCompoundTag("bukkit");
+        }
+
+        return result;
+    }
+
+    private File getDataFile() {
+        return new File(storage.getPlayerDir(), getUniqueId() + ".dat");
+    }
+
+    public long getFirstPlayed() {
+        Player player = getPlayer();
+        if (player != null) return player.getFirstPlayed();
+
+        net.minecraft.nbt.NBTTagCompound data = getBukkitData();
+
+        if (data != null) {
+            if (data.hasKey("firstPlayed")) {
+                return data.getLong("firstPlayed");
+            } else {
+                File file = getDataFile();
+                return file.lastModified();
+            }
+        } else {
+            return 0;
+        }
+    }
+
+    public long getLastPlayed() {
+        Player player = getPlayer();
+        if (player != null) return player.getLastPlayed();
+
+        net.minecraft.nbt.NBTTagCompound data = getBukkitData();
+
+        if (data != null) {
+            if (data.hasKey("lastPlayed")) {
+                return data.getLong("lastPlayed");
+            } else {
+                File file = getDataFile();
+                return file.lastModified();
+            }
+        } else {
+            return 0;
+        }
+    }
+
+    public boolean hasPlayedBefore() {
+        return getData() != null;
+    }
+
+    public Location getBedSpawnLocation() {
+        net.minecraft.nbt.NBTTagCompound data = getData();
+        if (data == null) return null;
+
+        if (data.hasKey("SpawnX") && data.hasKey("SpawnY") && data.hasKey("SpawnZ")) {
+            String spawnWorld = data.getString("SpawnWorld");
+            if (spawnWorld.equals("")) {
+                spawnWorld = server.getWorlds().get(0).getName();
+            }
+            return new Location(server.getWorld(spawnWorld), data.getInteger("SpawnX"), data.getInteger("SpawnY"), data.getInteger("SpawnZ"));
+        }
+        return null;
+    }
+
+    public void setMetadata(String metadataKey, MetadataValue metadataValue) {
+        server.getPlayerMetadata().setMetadata(this, metadataKey, metadataValue);
+    }
+
+    public List<MetadataValue> getMetadata(String metadataKey) {
+        return server.getPlayerMetadata().getMetadata(this, metadataKey);
+    }
+
+    public boolean hasMetadata(String metadataKey) {
+        return server.getPlayerMetadata().hasMetadata(this, metadataKey);
+    }
+
+    public void removeMetadata(String metadataKey, Plugin plugin) {
+        server.getPlayerMetadata().removeMetadata(this, metadataKey, plugin);
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftProfileBanEntry.java

@@ -0,0 +1,88 @@
+package org.bukkit.craftbukkit;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.management.UserListBans;
+import net.minecraft.server.management.UserListBansEntry;
+
+import com.mojang.authlib.GameProfile;
+
+import java.io.IOException;
+import java.util.Date;
+
+public final class CraftProfileBanEntry implements org.bukkit.BanEntry {
+    private final UserListBans list;
+    private final GameProfile profile;
+    private Date created;
+    private String source;
+    private Date expiration;
+    private String reason;
+
+    public CraftProfileBanEntry(GameProfile profile, UserListBansEntry entry, UserListBans list) {
+        this.list = list;
+        this.profile = profile;
+        this.created = entry.getCreated() != null ? new Date(entry.getCreated().getTime()) : null;
+        this.source = entry.getSource();
+        this.expiration = entry.getBanEndDate() != null ? new Date(entry.getBanEndDate().getTime()) : null;
+        this.reason = entry.getBanReason();
+    }
+
+    @Override
+    public String getTarget() {
+        return this.profile.getName();
+    }
+
+    @Override
+    public Date getCreated() {
+        return this.created == null ? null : (Date) this.created.clone();
+    }
+
+    @Override
+    public void setCreated(Date created) {
+        this.created = created;
+    }
+
+    @Override
+    public String getSource() {
+        return this.source;
+    }
+
+    @Override
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    @Override
+    public Date getExpiration() {
+        return this.expiration == null ? null : (Date) this.expiration.clone();
+    }
+
+    @Override
+    public void setExpiration(Date expiration) {
+        if (expiration != null && expiration.getTime() == new Date(0, 0, 0, 0, 0, 0).getTime()) {
+            expiration = null; // Forces "forever"
+        }
+
+        this.expiration = expiration;
+    }
+
+    @Override
+    public String getReason() {
+        return this.reason;
+    }
+
+    @Override
+    public void setReason(String reason) {
+        this.reason = reason;
+    }
+
+    @Override
+    public void save() {
+        UserListBansEntry entry = new UserListBansEntry(profile, this.created, this.source, this.expiration, this.reason);
+        this.list.func_152687_a(entry);
+        try {
+            this.list.func_152678_f();
+        } catch (IOException ex) {
+            MinecraftServer.getLogger().error("Failed to save banned-players.json, " + ex.getMessage());
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftProfileBanList.java

@@ -0,0 +1,97 @@
+package org.bukkit.craftbukkit;
+
+import java.io.IOException;
+import java.util.Date;
+import java.util.Set;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.management.UserListBans;
+import net.minecraft.server.management.UserListBansEntry;
+import net.minecraft.server.management.UserListEntry;
+
+import com.mojang.authlib.GameProfile;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.Validate;
+
+import com.google.common.collect.ImmutableSet;
+
+public class CraftProfileBanList implements org.bukkit.BanList {
+    private final UserListBans list;
+
+    public CraftProfileBanList(UserListBans list){
+        this.list = list;
+    }
+
+    @Override
+    public org.bukkit.BanEntry getBanEntry(String target) {
+        Validate.notNull(target, "Target cannot be null");
+
+        GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a(target);
+        if (profile == null) {
+            return null;
+        }
+
+        UserListBansEntry entry = (UserListBansEntry) list.func_152683_b(profile);
+        if (entry == null) {
+            return null;
+        }
+
+        return new CraftProfileBanEntry(profile, entry, list);
+    }
+
+    @Override
+    public org.bukkit.BanEntry addBan(String target, String reason, Date expires, String source) {
+        Validate.notNull(target, "Ban target cannot be null");
+
+        GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a(target);
+        if (profile == null) {
+            return null;
+        }
+
+        UserListBansEntry entry = new UserListBansEntry(profile, new Date(),
+                StringUtils.isBlank(source) ? null : source, expires,
+                StringUtils.isBlank(reason) ? null : reason);
+
+        list.func_152687_a(entry);
+
+        try {
+            list.func_152678_f();
+        } catch (IOException ex) {
+            MinecraftServer.getLogger().error("Failed to save banned-players.json, " + ex.getMessage());
+        }
+
+        return new CraftProfileBanEntry(profile, entry, list);
+    }
+
+    @Override
+    public Set<org.bukkit.BanEntry> getBanEntries() {
+        ImmutableSet.Builder<org.bukkit.BanEntry> builder = ImmutableSet.builder();
+        for (UserListEntry entry : list.getValues()) {
+            GameProfile profile = (GameProfile) entry.func_152640_f(); // Should be getKey
+            builder.add(new CraftProfileBanEntry(profile, (UserListBansEntry) entry, list));
+        }
+
+        return builder.build();
+    }
+
+    @Override
+    public boolean isBanned(String target) {
+        Validate.notNull(target, "Target cannot be null");
+
+        GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a(target);
+        if (profile == null) {
+            return false;
+        }
+
+        return list.func_152702_a(profile);
+    }
+
+    @Override
+    public void pardon(String target) {
+        Validate.notNull(target, "Target cannot be null");
+
+        GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a(target);
+        list.func_152684_c(profile);
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftSound.java

@@ -0,0 +1,231 @@
+package org.bukkit.craftbukkit;
+
+import static org.bukkit.Sound.*;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.Sound;
+
+public class CraftSound {
+    private static final String[] sounds = new String[Sound.values().length];
+
+    static {
+        // Ambient
+        set(AMBIENCE_CAVE, "ambient.cave.cave");
+        set(AMBIENCE_RAIN, "ambient.weather.rain");
+        set(AMBIENCE_THUNDER, "ambient.weather.thunder");
+        // Damage
+        set(HURT_FLESH, "game.neutral.hurt");
+        set(FALL_BIG, "game.neutral.hurt.fall.big");
+        set(FALL_SMALL, "game.neutral.hurt.fall.small");
+        // Dig Sounds
+        set(DIG_WOOL, "dig.cloth");
+        set(DIG_GRASS, "dig.grass");
+        set(DIG_GRAVEL, "dig.gravel");
+        set(DIG_SAND, "dig.sand");
+        set(DIG_SNOW, "dig.snow");
+        set(DIG_STONE, "dig.stone");
+        set(DIG_WOOD, "dig.wood");
+        // Fire
+        set(FIRE, "fire.fire");
+        set(FIRE_IGNITE, "fire.ignite");
+        // Fireworks
+        set(FIREWORK_BLAST, "fireworks.blast");
+        set(FIREWORK_BLAST2, "fireworks.blast_far");
+        set(FIREWORK_LARGE_BLAST, "fireworks.largeBlast");
+        set(FIREWORK_LARGE_BLAST2, "fireworks.largeBlast_far");
+        set(FIREWORK_TWINKLE, "fireworks.twinkle");
+        set(FIREWORK_TWINKLE2, "fireworks.twinkle_far");
+        set(FIREWORK_LAUNCH, "fireworks.launch");
+        // Liquid
+        set(SPLASH2, "game.neutral.swim.splash");
+        set(SWIM, "game.neutral.swim");
+        set(WATER, "liquid.water");
+        set(LAVA, "liquid.lava");
+        set(LAVA_POP, "liquid.lavapop");
+        // Minecart
+        set(MINECART_BASE, "minecart.base");
+        set(MINECART_INSIDE, "minecart.inside");
+        // Mob
+        set(BAT_DEATH, "mob.bat.death");
+        set(BAT_HURT, "mob.bat.hurt");
+        set(BAT_IDLE, "mob.bat.idle");
+        set(BAT_LOOP, "mob.bat.loop");
+        set(BAT_TAKEOFF, "mob.bat.takeoff");
+        set(BLAZE_BREATH, "mob.blaze.breathe");
+        set(BLAZE_DEATH, "mob.blaze.death");
+        set(BLAZE_HIT, "mob.blaze.hit");
+        set(CAT_HISS, "mob.cat.hiss");
+        set(CAT_HIT, "mob.cat.hitt");
+        set(CAT_MEOW, "mob.cat.meow");
+        set(CAT_PURR, "mob.cat.purr");
+        set(CAT_PURREOW, "mob.cat.purreow");
+        set(CHICKEN_IDLE, "mob.chicken.say");
+        set(CHICKEN_HURT, "mob.chicken.hurt");
+        set(CHICKEN_EGG_POP, "mob.chicken.plop");
+        set(CHICKEN_WALK, "mob.chicken.step");
+        set(COW_HURT, "mob.cow.hurt");
+        set(COW_IDLE, "mob.cow.say");
+        set(COW_WALK, "mob.cow.step");
+        set(CREEPER_DEATH, "mob.creeper.death");
+        set(CREEPER_HISS, "mob.creeper.say");
+        set(ENDERDRAGON_DEATH, "mob.enderdragon.end");
+        set(ENDERDRAGON_GROWL, "mob.enderdragon.growl");
+        set(ENDERDRAGON_HIT, "mob.enderdragon.hit");
+        set(ENDERDRAGON_WINGS, "mob.enderdragon.wings");
+        set(ENDERMAN_DEATH, "mob.endermen.death");
+        set(ENDERMAN_HIT, "mob.endermen.hit");
+        set(ENDERMAN_IDLE, "mob.endermen.idle");
+        set(ENDERMAN_TELEPORT, "mob.endermen.portal");
+        set(ENDERMAN_SCREAM, "mob.endermen.scream");
+        set(ENDERMAN_STARE, "mob.endermen.stare");
+        set(GHAST_SCREAM2, "mob.ghast.affectionate_scream");
+        set(GHAST_CHARGE, "mob.ghast.charge");
+        set(GHAST_DEATH, "mob.ghast.death");
+        set(GHAST_FIREBALL, "mob.ghast.fireball");
+        set(GHAST_MOAN, "mob.ghast.moan");
+        set(GHAST_SCREAM, "mob.ghast.scream");
+        set(HORSE_ANGRY, "mob.horse.angry");
+        set(HORSE_ARMOR, "mob.horse.armor");
+        set(HORSE_BREATHE, "mob.horse.breathe");
+        set(HORSE_DEATH, "mob.horse.death");
+        set(HORSE_GALLOP, "mob.horse.gallop");
+        set(HORSE_HIT, "mob.horse.hit");
+        set(HORSE_IDLE, "mob.horse.idle");
+        set(HORSE_JUMP, "mob.horse.jump");
+        set(HORSE_LAND, "mob.horse.land");
+        set(HORSE_SADDLE, "mob.horse.leather");
+        set(HORSE_SOFT, "mob.horse.soft");
+        set(HORSE_WOOD, "mob.horse.wood");
+        set(DONKEY_ANGRY, "mob.horse.donkey.angry");
+        set(DONKEY_DEATH, "mob.horse.donkey.death");
+        set(DONKEY_HIT, "mob.horse.donkey.hit");
+        set(DONKEY_IDLE, "mob.horse.donkey.idle");
+        set(HORSE_SKELETON_DEATH, "mob.horse.skeleton.death");
+        set(HORSE_SKELETON_HIT, "mob.horse.skeleton.hit");
+        set(HORSE_SKELETON_IDLE, "mob.horse.skeleton.idle");
+        set(HORSE_ZOMBIE_DEATH, "mob.horse.zombie.death");
+        set(HORSE_ZOMBIE_HIT, "mob.horse.zombie.hit");
+        set(HORSE_ZOMBIE_IDLE, "mob.horse.zombie.idle");
+        set(IRONGOLEM_DEATH, "mob.irongolem.death");
+        set(IRONGOLEM_HIT, "mob.irongolem.hit");
+        set(IRONGOLEM_THROW, "mob.irongolem.throw");
+        set(IRONGOLEM_WALK, "mob.irongolem.walk");
+        set(MAGMACUBE_WALK, "mob.magmacube.small");
+        set(MAGMACUBE_WALK2, "mob.magmacube.big");
+        set(MAGMACUBE_JUMP, "mob.magmacube.jump");
+        set(PIG_IDLE, "mob.pig.say");
+        set(PIG_DEATH, "mob.pig.death");
+        set(PIG_WALK, "mob.pig.step");
+        set(SHEEP_IDLE, "mob.sheep.say");
+        set(SHEEP_SHEAR, "mob.sheep.shear");
+        set(SHEEP_WALK, "mob.sheep.step");
+        set(SILVERFISH_HIT, "mob.silverfish.hit");
+        set(SILVERFISH_KILL, "mob.silverfish.kill");
+        set(SILVERFISH_IDLE, "mob.silverfish.say");
+        set(SILVERFISH_WALK, "mob.silverfish.step");
+        set(SKELETON_IDLE, "mob.skeleton.say");
+        set(SKELETON_DEATH, "mob.skeleton.death");
+        set(SKELETON_HURT, "mob.skeleton.hurt");
+        set(SKELETON_WALK, "mob.skeleton.step");
+        set(SLIME_ATTACK, "mob.slime.attack");
+        set(SLIME_WALK, "mob.slime.small");
+        set(SLIME_WALK2, "mob.slime.big");
+        set(SPIDER_IDLE, "mob.spider.say");
+        set(SPIDER_DEATH, "mob.spider.death");
+        set(SPIDER_WALK, "mob.spider.step");
+        set(VILLAGER_DEATH, "mob.villager.death");
+        set(VILLAGER_HAGGLE, "mob.villager.haggle");
+        set(VILLAGER_HIT, "mob.villager.hit");
+        set(VILLAGER_IDLE, "mob.villager.idle");
+        set(VILLAGER_NO, "mob.villager.no");
+        set(VILLAGER_YES, "mob.villager.yes");
+        set(WITHER_DEATH, "mob.wither.death");
+        set(WITHER_HURT, "mob.wither.hurt");
+        set(WITHER_IDLE, "mob.wither.idle");
+        set(WITHER_SHOOT, "mob.wither.shoot");
+        set(WITHER_SPAWN, "mob.wither.spawn");
+        set(WOLF_BARK, "mob.wolf.bark");
+        set(WOLF_DEATH, "mob.wolf.death");
+        set(WOLF_GROWL, "mob.wolf.growl");
+        set(WOLF_HOWL, "mob.wolf.howl");
+        set(WOLF_HURT, "mob.wolf.hurt");
+        set(WOLF_PANT, "mob.wolf.panting");
+        set(WOLF_SHAKE, "mob.wolf.shake");
+        set(WOLF_WALK, "mob.wolf.step");
+        set(WOLF_WHINE, "mob.wolf.whine");
+        set(ZOMBIE_METAL, "mob.zombie.metal");
+        set(ZOMBIE_WOOD, "mob.zombie.wood");
+        set(ZOMBIE_WOODBREAK, "mob.zombie.woodbreak");
+        set(ZOMBIE_IDLE, "mob.zombie.say");
+        set(ZOMBIE_DEATH, "mob.zombie.death");
+        set(ZOMBIE_HURT, "mob.zombie.hurt");
+        set(ZOMBIE_INFECT, "mob.zombie.infect");
+        set(ZOMBIE_UNFECT, "mob.zombie.unfect");
+        set(ZOMBIE_REMEDY, "mob.zombie.remedy");
+        set(ZOMBIE_WALK, "mob.zombie.step");
+        set(ZOMBIE_PIG_IDLE, "mob.zombiepig.zpig");
+        set(ZOMBIE_PIG_ANGRY, "mob.zombiepig.zpigangry");
+        set(ZOMBIE_PIG_DEATH, "mob.zombiepig.zpigdeath");
+        set(ZOMBIE_PIG_HURT, "mob.zombiepig.zpighurt");
+        // Note (blocks)
+        set(NOTE_BASS_GUITAR, "note.bassattack");
+        set(NOTE_SNARE_DRUM, "note.snare");
+        set(NOTE_PLING, "note.pling");
+        set(NOTE_BASS, "note.bass");
+        set(NOTE_PIANO, "note.harp");
+        set(NOTE_BASS_DRUM, "note.bd");
+        set(NOTE_STICKS, "note.hat");
+        // Portal
+        set(PORTAL, "portal.portal");
+        set(PORTAL_TRAVEL, "portal.travel");
+        set(PORTAL_TRIGGER, "portal.trigger");
+        // Random
+        set(ANVIL_BREAK, "random.anvil_break");
+        set(ANVIL_LAND, "random.anvil_land");
+        set(ANVIL_USE, "random.anvil_use");
+        set(SHOOT_ARROW, "random.bow");
+        set(ARROW_HIT, "random.bowhit");
+        set(ITEM_BREAK, "random.break");
+        set(BURP, "random.burp");
+        set(CHEST_CLOSE, "random.chestclosed");
+        set(CHEST_OPEN, "random.chestopen");
+        set(CLICK, "random.click");
+        set(DOOR_CLOSE, "random.door_close");
+        set(DOOR_OPEN, "random.door_open");
+        set(DRINK, "random.drink");
+        set(EAT, "random.eat");
+        set(EXPLODE, "random.explode");
+        set(FIZZ, "random.fizz");
+        set(FUSE, "creeper.primed");
+        set(GLASS, "dig.glass");
+        set(LEVEL_UP, "random.levelup");
+        set(ORB_PICKUP, "random.orb");
+        set(ITEM_PICKUP, "random.pop");
+        set(SPLASH, "random.splash");
+        set(SUCCESSFUL_HIT, "random.successful_hit");
+        set(WOOD_CLICK, "random.wood_click");
+        // Step
+        set(STEP_WOOL, "step.cloth");
+        set(STEP_GRASS, "step.grass");
+        set(STEP_GRAVEL, "step.gravel");
+        set(STEP_LADDER, "step.ladder");
+        set(STEP_SAND, "step.sand");
+        set(STEP_SNOW, "step.snow");
+        set(STEP_STONE, "step.stone");
+        set(STEP_WOOD, "step.wood");
+        // Tile
+        set(PISTON_EXTEND, "tile.piston.out");
+        set(PISTON_RETRACT, "tile.piston.in");
+    }
+
+    private static void set(Sound sound, String key) {
+        sounds[sound.ordinal()] = key;
+    }
+
+    public static String getSound(final Sound sound) {
+        Validate.notNull(sound, "Sound cannot be null");
+        return sounds[sound.ordinal()];
+    }
+
+    private CraftSound() {}
+}

src/main/java/org/bukkit/craftbukkit/CraftStatistic.java

@@ -0,0 +1,142 @@
+package org.bukkit.craftbukkit;
+
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityList.EntityEggInfo;
+import net.minecraft.stats.StatList;
+
+import org.bukkit.Achievement;
+import org.bukkit.Statistic;
+import org.bukkit.Material;
+import org.bukkit.entity.EntityType;
+
+import com.google.common.base.CaseFormat;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableMap;
+
+public class CraftStatistic {
+    private static final BiMap<String, org.bukkit.Statistic> statistics;
+    private static final BiMap<String, org.bukkit.Achievement> achievements;
+
+    static {
+        ImmutableMap<String, org.bukkit.Achievement> specialCases = ImmutableMap.<String, org.bukkit.Achievement> builder()
+                .put("achievement.buildWorkBench", Achievement.BUILD_WORKBENCH)
+                .put("achievement.diamonds", Achievement.GET_DIAMONDS)
+                .put("achievement.portal", Achievement.NETHER_PORTAL)
+                .put("achievement.ghast", Achievement.GHAST_RETURN)
+                .put("achievement.theEnd", Achievement.END_PORTAL)
+                .put("achievement.theEnd2", Achievement.THE_END)
+                .put("achievement.blazeRod", Achievement.GET_BLAZE_ROD)
+                .put("achievement.potion", Achievement.BREW_POTION)
+                .build();
+        ImmutableBiMap.Builder<String, org.bukkit.Statistic> statisticBuilder = ImmutableBiMap.<String, org.bukkit.Statistic>builder();
+        ImmutableBiMap.Builder<String, org.bukkit.Achievement> achievementBuilder = ImmutableBiMap.<String, org.bukkit.Achievement>builder();
+        for (Statistic statistic : Statistic.values()) {
+            if (statistic == Statistic.PLAY_ONE_TICK) {
+                statisticBuilder.put("stat.playOneMinute", statistic);
+            } else {
+                statisticBuilder.put("stat." + CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, statistic.name()), statistic);
+            }
+        }
+        for (Achievement achievement : Achievement.values()) {
+            if (specialCases.values().contains(achievement)) {
+                continue;
+            }
+            achievementBuilder.put("achievement." + CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, achievement.name()), achievement);
+        }
+
+        achievementBuilder.putAll(specialCases);
+
+        statistics = statisticBuilder.build();
+        achievements = achievementBuilder.build();
+    }
+
+    private CraftStatistic() {}
+
+    public static org.bukkit.Achievement getBukkitAchievement(net.minecraft.stats.Achievement achievement) {
+        return getBukkitAchievementByName(achievement.statId);
+    }
+
+    public static org.bukkit.Achievement getBukkitAchievementByName(String name) {
+        return achievements.get(name);
+    }
+
+    public static org.bukkit.Statistic getBukkitStatistic(net.minecraft.stats.StatBase statistic) {
+        return getBukkitStatisticByName(statistic.statId);
+    }
+
+    public static org.bukkit.Statistic getBukkitStatisticByName(String name) {
+        if (name.startsWith("stat.killEntity")) {
+            name = "stat.killEntity";
+        }
+        if (name.startsWith("stat.entityKilledBy")) {
+            name = "stat.entityKilledBy";
+        }
+        if (name.startsWith("stat.breakItem")) {
+            name = "stat.breakItem";
+        }
+        if (name.startsWith("stat.useItem")) {
+            name = "stat.useItem";
+        }
+        if (name.startsWith("stat.mineBlock")) {
+            name = "stat.mineBlock";
+        }
+        if (name.startsWith("stat.craftItem")) {
+            name = "stat.craftItem";
+        }
+        return statistics.get(name);
+    }
+
+    public static net.minecraft.stats.StatBase getNMSStatistic(org.bukkit.Statistic statistic) {
+        return StatList.func_151177_a(statistics.inverse().get(statistic));
+    }
+
+    public static net.minecraft.stats.Achievement getNMSAchievement(org.bukkit.Achievement achievement) {
+        return (net.minecraft.stats.Achievement) StatList.func_151177_a(achievements.inverse().get(achievement));
+    }
+
+    public static net.minecraft.stats.StatBase getMaterialStatistic(org.bukkit.Statistic stat, Material material) {
+        try {
+            if (stat == Statistic.MINE_BLOCK) {
+                return StatList.mineBlockStatArray[material.getId()];
+            }
+            if (stat == Statistic.CRAFT_ITEM) {
+                return StatList.objectCraftStats[material.getId()];
+            }
+            if (stat == Statistic.USE_ITEM) {
+                return StatList.objectUseStats[material.getId()];
+            }
+            if (stat == Statistic.BREAK_ITEM) {
+                return StatList.objectBreakStats[material.getId()];
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            return null;
+        }
+        return null;
+    }
+
+    public static net.minecraft.stats.StatBase getEntityStatistic(org.bukkit.Statistic stat, EntityType entity) {
+        EntityEggInfo entityEggInfo = (EntityEggInfo) EntityList.entityEggs.get(Integer.valueOf(entity.getTypeId()));
+
+        if (entityEggInfo != null) {
+            return entityEggInfo.field_151512_d;
+        }
+        return null;
+    }
+
+    public static EntityType getEntityTypeFromStatistic(net.minecraft.stats.StatBase statistic) {
+        String statisticString = statistic.statId;
+        return EntityType.fromName(statisticString.substring(statisticString.lastIndexOf(".") + 1));
+    }
+
+    public static Material getMaterialFromStatistic(net.minecraft.stats.StatBase statistic) {
+        String statisticString = statistic.statId;
+        int id;
+        try {
+            id = Integer.valueOf(statisticString.substring(statisticString.lastIndexOf(".") + 1));
+        } catch (NumberFormatException e) {
+            return null;
+        }
+        return Material.getMaterial(id);
+    }
+}

src/main/java/org/bukkit/craftbukkit/CraftTravelAgent.java

@@ -0,0 +1,76 @@
+package org.bukkit.craftbukkit;
+
+
+import org.bukkit.Location;
+import org.bukkit.TravelAgent;
+
+public class CraftTravelAgent extends net.minecraft.world.Teleporter implements TravelAgent {
+
+    public static TravelAgent DEFAULT = null;
+
+    private int searchRadius = 128;
+    private int creationRadius = 16;
+    private boolean canCreatePortal = true;
+
+    public CraftTravelAgent(net.minecraft.world.WorldServer worldserver) {
+        super(worldserver);
+        if (DEFAULT == null && worldserver.provider.dimensionId == 0) { // Cauldron
+            DEFAULT = this;
+        }
+    }
+
+    public Location findOrCreate(Location target) {
+        net.minecraft.world.WorldServer worldServer = ((CraftWorld) target.getWorld()).getHandle();
+        boolean before = worldServer.theChunkProviderServer.loadChunkOnProvideRequest;
+        worldServer.theChunkProviderServer.loadChunkOnProvideRequest = true;
+
+        Location found = this.findPortal(target);
+        if (found == null) {
+            if (this.getCanCreatePortal() && this.createPortal(target)) {
+                found = this.findPortal(target);
+            } else {
+                found = target; // fallback to original if unable to find or create
+            }
+        }
+
+        worldServer.theChunkProviderServer.loadChunkOnProvideRequest = before;
+        return found;
+    }
+
+    public Location findPortal(Location location) {
+        net.minecraft.world.Teleporter pta = ((CraftWorld) location.getWorld()).getHandle().getDefaultTeleporter(); // Should be getTravelAgent
+        net.minecraft.util.ChunkCoordinates found = pta.findPortal(location.getX(), location.getY(), location.getZ(), this.getSearchRadius());
+        return found != null ? new Location(location.getWorld(), found.posX, found.posY, found.posZ, location.getYaw(), location.getPitch()) : null;
+    }
+
+    public boolean createPortal(Location location) {
+        net.minecraft.world.Teleporter pta = ((CraftWorld) location.getWorld()).getHandle().getDefaultTeleporter();
+        return pta.createPortal(location.getX(), location.getY(), location.getZ(), this.getCreationRadius());
+    }
+
+    public TravelAgent setSearchRadius(int radius) {
+        this.searchRadius = radius;
+        return this;
+    }
+
+    public int getSearchRadius() {
+        return this.searchRadius;
+    }
+
+    public TravelAgent setCreationRadius(int radius) {
+        this.creationRadius = radius < 2 ? 0 : radius;
+        return this;
+    }
+
+    public int getCreationRadius() {
+        return this.creationRadius;
+    }
+
+    public boolean getCanCreatePortal() {
+        return this.canCreatePortal;
+    }
+
+    public void setCanCreatePortal(boolean create) {
+        this.canCreatePortal = create;
+    }
+}

src/main/java/org/bukkit/craftbukkit/LoggerOutputStream.java

@@ -0,0 +1,31 @@
+package org.bukkit.craftbukkit;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.Logger;
+
+public class LoggerOutputStream extends ByteArrayOutputStream {
+    private final String separator = System.getProperty("line.separator");
+    private final Logger logger;
+    private final Level level;
+
+    public LoggerOutputStream(Logger logger, Level level) {
+        super();
+        this.logger = logger;
+        this.level = level;
+    }
+
+    @Override
+    public void flush() throws IOException {
+        synchronized (this) {
+            super.flush();
+            String record = this.toString();
+            super.reset();
+
+            if ((record.length() > 0) && (!record.equals(separator))) {
+                logger.log(level, record);
+            }
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/Overridden.java

@@ -0,0 +1,14 @@
+package org.bukkit.craftbukkit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates a method needs to be overridden in sub classes
+ */
+@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Overridden {
+}

src/main/java/org/bukkit/craftbukkit/SpigotTimings.java

@@ -0,0 +1,178 @@
+package org.bukkit.craftbukkit;
+
+import com.google.common.collect.Maps;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.server.*;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.World;
+
+import org.bukkit.plugin.java.JavaPluginLoader;
+import org.spigotmc.CustomTimingsHandler;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.craftbukkit.scheduler.CraftTask;
+
+public class SpigotTimings {
+
+    public static final CustomTimingsHandler serverTickTimer = new CustomTimingsHandler("** Full Server Tick");
+    public static final CustomTimingsHandler playerListTimer = new CustomTimingsHandler("Player List");
+    public static final CustomTimingsHandler connectionTimer = new CustomTimingsHandler("Connection Handler");
+    public static final CustomTimingsHandler tickablesTimer = new CustomTimingsHandler("Tickables");
+    public static final CustomTimingsHandler schedulerTimer = new CustomTimingsHandler("Scheduler");
+    public static final CustomTimingsHandler chunkIOTickTimer = new CustomTimingsHandler("ChunkIOTick");
+    public static final CustomTimingsHandler timeUpdateTimer = new CustomTimingsHandler("Time Update");
+    public static final CustomTimingsHandler serverCommandTimer = new CustomTimingsHandler("Server Command");
+    public static final CustomTimingsHandler worldSaveTimer = new CustomTimingsHandler("World Save");
+
+    public static final CustomTimingsHandler entityMoveTimer = new CustomTimingsHandler("** entityMove");
+    public static final CustomTimingsHandler tickEntityTimer = new CustomTimingsHandler("** tickEntity");
+    public static final CustomTimingsHandler activatedEntityTimer = new CustomTimingsHandler("** activatedTickEntity");
+    public static final CustomTimingsHandler tickTileEntityTimer = new CustomTimingsHandler("** tickTileEntity");
+
+    public static final CustomTimingsHandler timerEntityBaseTick = new CustomTimingsHandler("** livingEntityBaseTick");
+    public static final CustomTimingsHandler timerEntityAI = new CustomTimingsHandler("** livingEntityAI");
+    public static final CustomTimingsHandler timerEntityAICollision = new CustomTimingsHandler("** livingEntityAICollision");
+    public static final CustomTimingsHandler timerEntityAIMove = new CustomTimingsHandler("** livingEntityAIMove");
+    public static final CustomTimingsHandler timerEntityTickRest = new CustomTimingsHandler("** livingEntityTickRest");
+
+    public static final CustomTimingsHandler processQueueTimer = new CustomTimingsHandler("processQueue");
+    public static final CustomTimingsHandler schedulerSyncTimer = new CustomTimingsHandler("** Scheduler - Sync Tasks", JavaPluginLoader.pluginParentTimer);
+
+    public static final CustomTimingsHandler playerCommandTimer = new CustomTimingsHandler("** playerCommand");
+
+    public static final CustomTimingsHandler entityActivationCheckTimer = new CustomTimingsHandler("entityActivationCheck");
+    public static final CustomTimingsHandler checkIfActiveTimer = new CustomTimingsHandler("** checkIfActive");
+
+    public static final HashMap<String, CustomTimingsHandler> entityTypeTimingMap = new HashMap<String, CustomTimingsHandler>();
+    public static final HashMap<String, CustomTimingsHandler> tileEntityTypeTimingMap = new HashMap<String, CustomTimingsHandler>();
+    public static final HashMap<String, CustomTimingsHandler> pluginTaskTimingMap = new HashMap<String, CustomTimingsHandler>();
+
+    /**
+     * Gets a timer associated with a plugins tasks.
+     * @param task
+     * @param period
+     * @return
+     */
+    public static CustomTimingsHandler getPluginTaskTimings(BukkitTask task, long period) {
+        if (!task.isSync()) {
+            return null;
+        }
+        String plugin;
+        final CraftTask ctask = (CraftTask) task;
+
+        if (task.getOwner() != null) {
+            plugin = task.getOwner().getDescription().getFullName();
+        } else if (ctask.timingName != null) {
+            plugin = "CraftScheduler";
+        } else {
+            plugin = "Unknown";
+        }
+        String taskname = ctask.getTaskName();
+
+        String name = "Task: " + plugin + " Runnable: " + taskname;
+        if (period > 0) {
+            name += "(interval:" + period +")";
+        } else {
+            name += "(Single)";
+        }
+        CustomTimingsHandler result = pluginTaskTimingMap.get(name);
+        if (result == null) {
+            result = new CustomTimingsHandler(name, SpigotTimings.schedulerSyncTimer);
+            pluginTaskTimingMap.put(name, result);
+        }
+        return result;
+    }
+
+    /**
+     * Get a named timer for the specified entity type to track type specific timings.
+     * @param entity
+     * @return
+     */
+    public static CustomTimingsHandler getEntityTimings(Entity entity) {
+        String entityType = entity.getClass().getSimpleName();
+        CustomTimingsHandler result = entityTypeTimingMap.get(entityType);
+        if (result == null) {
+            result = new CustomTimingsHandler("** tickEntity - " + entityType, activatedEntityTimer);
+            entityTypeTimingMap.put(entityType, result);
+        }
+        return result;
+    }
+
+    /**
+     * Get a named timer for the specified tile entity type to track type specific timings.
+     * @param entity
+     * @return
+     */
+    public static CustomTimingsHandler getTileEntityTimings(TileEntity entity) {
+        String entityType = entity.getClass().getSimpleName();
+        CustomTimingsHandler result = tileEntityTypeTimingMap.get(entityType);
+        if (result == null) {
+            result = new CustomTimingsHandler("** tickTileEntity - " + entityType, tickTileEntityTimer);
+            tileEntityTypeTimingMap.put(entityType, result);
+        }
+        return result;
+    }
+
+    /**
+     * Set of timers per world, to track world specific timings.
+     */
+    public static class WorldTimingsHandler {
+        public final CustomTimingsHandler mobSpawn;
+        public final CustomTimingsHandler doChunkUnload;
+        public final CustomTimingsHandler doPortalForcer;
+        public final CustomTimingsHandler doTickPending;
+        public final CustomTimingsHandler doTickTiles;
+        public final CustomTimingsHandler doVillages;
+        public final CustomTimingsHandler doChunkMap;
+        public final CustomTimingsHandler doChunkGC;
+        public final CustomTimingsHandler doSounds;
+        public final CustomTimingsHandler entityTick;
+        public final CustomTimingsHandler tileEntityTick;
+        public final CustomTimingsHandler tileEntityPending;
+        public final CustomTimingsHandler tracker;
+        public final CustomTimingsHandler doTick;
+        public final CustomTimingsHandler tickEntities;
+
+        public final CustomTimingsHandler syncChunkLoadTimer;
+        public final CustomTimingsHandler syncChunkLoadDataTimer;
+        public final CustomTimingsHandler syncChunkLoadStructuresTimer;
+        public final CustomTimingsHandler syncChunkLoadEntitiesTimer;
+        public final CustomTimingsHandler syncChunkLoadTileEntitiesTimer;
+        public final CustomTimingsHandler syncChunkLoadTileTicksTimer;
+        public final CustomTimingsHandler syncChunkLoadPostTimer;
+
+        public WorldTimingsHandler(World server) {
+            String name = server.worldInfo.getWorldName() +" - ";
+
+            mobSpawn = new CustomTimingsHandler("** " + name + "mobSpawn");
+            doChunkUnload = new CustomTimingsHandler("** " + name + "doChunkUnload");
+            doTickPending = new CustomTimingsHandler("** " + name + "doTickPending");
+            doTickTiles = new CustomTimingsHandler("** " + name + "doTickTiles");
+            doVillages = new CustomTimingsHandler("** " + name + "doVillages");
+            doChunkMap = new CustomTimingsHandler("** " + name + "doChunkMap");
+            doSounds = new CustomTimingsHandler("** " + name + "doSounds");
+            doChunkGC = new CustomTimingsHandler("** " + name + "doChunkGC");
+            doPortalForcer = new CustomTimingsHandler("** " + name + "doPortalForcer");
+            entityTick = new CustomTimingsHandler("** " + name + "entityTick");
+            tileEntityTick = new CustomTimingsHandler("** " + name + "tileEntityTick");
+            tileEntityPending = new CustomTimingsHandler("** " + name + "tileEntityPending");
+
+            syncChunkLoadTimer = new CustomTimingsHandler("** " + name + "syncChunkLoad");
+            syncChunkLoadDataTimer = new CustomTimingsHandler("** " + name + "syncChunkLoad - Data");
+            syncChunkLoadStructuresTimer = new CustomTimingsHandler("** " + name + "chunkLoad - Structures");
+            syncChunkLoadEntitiesTimer = new CustomTimingsHandler("** " + name + "chunkLoad - Entities");
+            syncChunkLoadTileEntitiesTimer = new CustomTimingsHandler("** " + name + "chunkLoad - TileEntities");
+            syncChunkLoadTileTicksTimer = new CustomTimingsHandler("** " + name + "chunkLoad - TileTicks");
+            syncChunkLoadPostTimer = new CustomTimingsHandler("** " + name + "chunkLoad - Post");
+
+
+            tracker = new CustomTimingsHandler(name + "tracker");
+            doTick = new CustomTimingsHandler(name + "doTick");
+            tickEntities = new CustomTimingsHandler(name + "tickEntities");
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/TrigMath.java

@@ -0,0 +1,47 @@
+package org.bukkit.craftbukkit;
+
+/**
+ * Credits for this class goes to user aioobe on stackoverflow.com
+ * Source: http://stackoverflow.com/questions/4454630/j2me-calculate-the-the-distance-between-2-latitude-and-longitude
+ */
+public class TrigMath {
+
+    static final double sq2p1 = 2.414213562373095048802e0;
+    static final double sq2m1 = .414213562373095048802e0;
+    static final double p4 = .161536412982230228262e2;
+    static final double p3 = .26842548195503973794141e3;
+    static final double p2 = .11530293515404850115428136e4;
+    static final double p1 = .178040631643319697105464587e4;
+    static final double p0 = .89678597403663861959987488e3;
+    static final double q4 = .5895697050844462222791e2;
+    static final double q3 = .536265374031215315104235e3;
+    static final double q2 = .16667838148816337184521798e4;
+    static final double q1 = .207933497444540981287275926e4;
+    static final double q0 = .89678597403663861962481162e3;
+    static final double PIO2 = 1.5707963267948966135E0;
+
+    private static double mxatan(double arg) {
+        double argsq = arg * arg, value;
+
+        value = ((((p4 * argsq + p3) * argsq + p2) * argsq + p1) * argsq + p0);
+        value = value / (((((argsq + q4) * argsq + q3) * argsq + q2) * argsq + q1) * argsq + q0);
+        return value * arg;
+    }
+
+    private static double msatan(double arg) {
+        return arg < sq2m1 ? mxatan(arg)
+             : arg > sq2p1 ? PIO2 - mxatan(1 / arg)
+             : PIO2 / 2 + mxatan((arg - 1) / (arg + 1));
+    }
+
+    public static double atan(double arg) {
+        return arg > 0 ? msatan(arg) : -msatan(-arg);
+    }
+
+    public static double atan2(double arg1, double arg2) {
+        if (arg1 + arg2 == arg1)
+            return arg1 >= 0 ? PIO2 : -PIO2;
+        arg1 = atan(arg1 / arg2);
+        return arg2 < 0 ? arg1 <= 0 ? arg1 + Math.PI : arg1 - Math.PI : arg1;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftBeacon.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityBeacon;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.Beacon;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventoryBeacon;
+import org.bukkit.inventory.Inventory;
+
+public class CraftBeacon extends CraftBlockState implements Beacon {
+    private final CraftWorld world;
+    private final TileEntityBeacon beacon;
+
+    public CraftBeacon(final Block block) {
+        super(block);
+
+        world = (CraftWorld) block.getWorld();
+        beacon = (TileEntityBeacon) world.getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public Inventory getInventory() {
+        return new CraftInventoryBeacon(beacon);
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            beacon.markDirty();
+        }
+
+        return result;
+    }
+}
+

src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java

@@ -0,0 +1,621 @@
+package org.bukkit.craftbukkit.block;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import net.minecraft.world.EnumSkyBlock;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraft.block.BlockCocoa;
+import net.minecraft.block.BlockRedstoneWire;
+import net.minecraft.init.Blocks;
+
+import net.minecraft.item.Item;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.tileentity.TileEntitySkull;
+
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.PistonMoveReaction;
+import org.bukkit.craftbukkit.CraftChunk;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.util.BlockVector;
+// Cauldron start
+import cpw.mods.fml.common.FMLLog;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.inventory.IInventory;
+import net.minecraftforge.cauldron.block.CraftCustomContainer;
+// Cauldron end
+
+import org.bukkit.craftbukkit.CraftWorld;
+
+public class CraftBlock implements Block {
+    private final CraftChunk chunk;
+    private final int x;
+    private final int y;
+    private final int z;
+    // Cauldron start - add support for custom biomes
+    private static final Biome[] BIOME_MAPPING = new Biome[BiomeGenBase.getBiomeGenArray().length];
+    private static final BiomeGenBase[] BIOMEBASE_MAPPING = new BiomeGenBase[BiomeGenBase.getBiomeGenArray().length];
+    // Cauldron end
+    
+    public CraftBlock(CraftChunk chunk, int x, int y, int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.chunk = chunk;
+    }
+
+    private net.minecraft.block.Block getNMSBlock() {
+        return CraftMagicNumbers.getBlock(this); // TODO: UPDATE THIS
+    }
+
+    private static net.minecraft.block.Block getNMSBlock(int type) {
+        return CraftMagicNumbers.getBlock(type);
+    }
+
+    public World getWorld() {
+        return chunk.getWorld();
+    }
+
+    public Location getLocation() {
+        return new Location(getWorld(), x, y, z);
+    }
+
+    public Location getLocation(Location loc) {
+        if (loc != null) {
+            loc.setWorld(getWorld());
+            loc.setX(x);
+            loc.setY(y);
+            loc.setZ(z);
+            loc.setYaw(0);
+            loc.setPitch(0);
+        }
+
+        return loc;
+    }
+
+    public BlockVector getVector() {
+        return new BlockVector(x, y, z);
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public int getZ() {
+        return z;
+    }
+
+    public Chunk getChunk() {
+        return chunk;
+    }
+
+    public void setData(final byte data) {
+        chunk.getHandle().worldObj.setBlockMetadataWithNotify(x, y, z, data, 3);
+    }
+
+    public void setData(final byte data, boolean applyPhysics) {
+        if (applyPhysics) {
+            chunk.getHandle().worldObj.setBlockMetadataWithNotify(x, y, z, data, 3);
+        } else {
+            chunk.getHandle().worldObj.setBlockMetadataWithNotify(x, y, z, data, 2);
+        }
+    }
+
+    public byte getData() {
+        return (byte) chunk.getHandle().getBlockMetadata(this.x & 0xF, this.y & 0xFF, this.z & 0xF);
+    }
+
+    public void setType(final Material type) {
+        setTypeId(type.getId());
+    }
+
+    public boolean setTypeId(final int type) {
+        return setTypeId(type, true);
+    }
+
+    public boolean setTypeId(final int type, final boolean applyPhysics) {
+        return setTypeIdAndData(type, getData(), applyPhysics);
+    }
+
+    public boolean setTypeIdAndData(final int type, final byte data, final boolean applyPhysics) {
+        if (applyPhysics) {
+            return chunk.getHandle().worldObj.setBlock(x, y, z, getNMSBlock(type), data, 3);
+        } else {
+            boolean success = chunk.getHandle().worldObj.setBlock(x, y, z, getNMSBlock(type), data, 2);
+            if (success) {
+                chunk.getHandle().worldObj.markBlockForUpdate(x, y, z);
+            }
+            return success;
+        }
+    }
+
+    public Material getType() {
+        return Material.getMaterial(getTypeId());
+    }
+
+    @Deprecated
+    @Override
+    public int getTypeId() {
+        return CraftMagicNumbers.getId(chunk.getHandle().getBlock(this.x & 0xF, this.y & 0xFF, this.z & 0xF));
+    }
+
+    public byte getLightLevel() {
+        return (byte) chunk.getHandle().worldObj.getBlockLightValue(this.x, this.y, this.z);
+    }
+
+    public byte getLightFromSky() {
+        return (byte) chunk.getHandle().getSavedLightValue(EnumSkyBlock.Sky, this.x & 0xF, this.y & 0xFF, this.z & 0xF);
+    }
+
+    public byte getLightFromBlocks() {
+        return (byte) chunk.getHandle().getSavedLightValue(EnumSkyBlock.Block, this.x & 0xF, this.y & 0xFF, this.z & 0xF);
+    }
+
+
+    public Block getFace(final BlockFace face) {
+        return getRelative(face, 1);
+    }
+
+    public Block getFace(final BlockFace face, final int distance) {
+        return getRelative(face, distance);
+    }
+
+    public Block getRelative(final int modX, final int modY, final int modZ) {
+        return getWorld().getBlockAt(getX() + modX, getY() + modY, getZ() + modZ);
+    }
+
+    public Block getRelative(BlockFace face) {
+        return getRelative(face, 1);
+    }
+
+    public Block getRelative(BlockFace face, int distance) {
+        return getRelative(face.getModX() * distance, face.getModY() * distance, face.getModZ() * distance);
+    }
+
+    public BlockFace getFace(final Block block) {
+        BlockFace[] values = BlockFace.values();
+
+        for (BlockFace face : values) {
+            if ((this.getX() + face.getModX() == block.getX()) &&
+                (this.getY() + face.getModY() == block.getY()) &&
+                (this.getZ() + face.getModZ() == block.getZ())
+            ) {
+                return face;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftBlock{" + "chunk=" + chunk + ",x=" + x + ",y=" + y + ",z=" + z + ",type=" + getType() + ",data=" + getData() + '}';
+    }
+
+    /**
+     * Notch uses a 0-5 to mean DOWN, UP, NORTH, SOUTH, WEST, EAST
+     * in that order all over. This method is convenience to convert for us.
+     *
+     * @return BlockFace the BlockFace represented by this number
+     */
+    public static BlockFace notchToBlockFace(int notch) {
+        switch (notch) {
+        case 0:
+            return BlockFace.DOWN;
+        case 1:
+            return BlockFace.UP;
+        case 2:
+            return BlockFace.NORTH;
+        case 3:
+            return BlockFace.SOUTH;
+        case 4:
+            return BlockFace.WEST;
+        case 5:
+            return BlockFace.EAST;
+        default:
+            return BlockFace.SELF;
+        }
+    }
+
+    public static int blockFaceToNotch(BlockFace face) {
+        switch (face) {
+        case DOWN:
+            return 0;
+        case UP:
+            return 1;
+        case NORTH:
+            return 2;
+        case SOUTH:
+            return 3;
+        case WEST:
+            return 4;
+        case EAST:
+            return 5;
+        default:
+            return 7; // Good as anything here, but technically invalid
+        }
+    }
+
+    public BlockState getState() {
+        Material material = getType();
+        // Cauldron start - if null, check for TE that implements IInventory
+        if (material == null)
+        {
+            TileEntity te = ((CraftWorld)this.getWorld()).getHandle().getTileEntity(this.getX(), this.getY(), this.getZ());
+            if (te != null && te instanceof IInventory)
+            {
+                // In order to allow plugins to properly grab the container location, we must pass a class that extends CraftBlockState and implements InventoryHolder.
+                // Note: This will be returned when TileEntity.getOwner() is called
+                return new CraftCustomContainer(this);
+            }
+            // pass default state
+            return new CraftBlockState(this);
+        }
+        // Cauldron end
+        switch (material) {
+        case SIGN:
+        case SIGN_POST:
+        case WALL_SIGN:
+            return new CraftSign(this);
+        case CHEST:
+        case TRAPPED_CHEST:
+            return new CraftChest(this);
+        case BURNING_FURNACE:
+        case FURNACE:
+            return new CraftFurnace(this);
+        case DISPENSER:
+            return new CraftDispenser(this);
+        case DROPPER:
+            return new CraftDropper(this);
+        case HOPPER:
+            return new CraftHopper(this);
+        case MOB_SPAWNER:
+            return new CraftCreatureSpawner(this);
+        case NOTE_BLOCK:
+            return new CraftNoteBlock(this);
+        case JUKEBOX:
+            return new CraftJukebox(this);
+        case BREWING_STAND:
+            return new CraftBrewingStand(this);
+        case SKULL:
+            return new CraftSkull(this);
+        case COMMAND:
+            return new CraftCommandBlock(this);
+        case BEACON:
+            return new CraftBeacon(this);
+        default:
+            // Cauldron start
+            TileEntity te = ((CraftWorld)this.getWorld()).getHandle().getTileEntity(this.getX(), this.getY(), this.getZ());
+            if (te != null && te instanceof IInventory)
+            {
+                // In order to allow plugins to properly grab the container location, we must pass a class that extends CraftBlockState and implements InventoryHolder.
+                // Note: This will be returned when TileEntity.getOwner() is called
+                return new CraftCustomContainer(this);
+            }
+            // pass default state
+            // Cauldron end
+            return new CraftBlockState(this);
+        }
+    }
+
+    public Biome getBiome() {
+        return getWorld().getBiome(x, z);
+    }
+
+    public void setBiome(Biome bio) {
+        getWorld().setBiome(x, z, bio);
+    }
+
+    public static Biome biomeBaseToBiome(BiomeGenBase base) {
+        if (base == null) {
+            return null;
+        }
+
+        return BIOME_MAPPING[base.biomeID];
+    }
+
+    public static BiomeGenBase biomeToBiomeBase(Biome bio) {
+        if (bio == null) {
+            return null;
+        }
+        return BIOMEBASE_MAPPING[bio.ordinal()];
+    }
+
+    public double getTemperature() {
+        return getWorld().getTemperature(x, z);
+    }
+
+    public double getHumidity() {
+        return getWorld().getHumidity(x, z);
+    }
+
+    public boolean isBlockPowered() {
+        return chunk.getHandle().worldObj.getBlockPowerInput(x, y, z) > 0;
+    }
+
+    public boolean isBlockIndirectlyPowered() {
+        return chunk.getHandle().worldObj.isBlockIndirectlyGettingPowered(x, y, z);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof CraftBlock)) return false;
+        CraftBlock other = (CraftBlock) o;
+
+        return this.x == other.x && this.y == other.y && this.z == other.z && this.getWorld().equals(other.getWorld());
+    }
+
+    @Override
+    public int hashCode() {
+        return this.y << 24 ^ this.x ^ this.z ^ this.getWorld().hashCode();
+    }
+
+    public boolean isBlockFacePowered(BlockFace face) {
+        return chunk.getHandle().worldObj.getIndirectPowerOutput(x, y, z, blockFaceToNotch(face));
+    }
+
+    public boolean isBlockFaceIndirectlyPowered(BlockFace face) {
+        int power = chunk.getHandle().worldObj.getIndirectPowerLevelTo(x, y, z, blockFaceToNotch(face));
+
+        Block relative = getRelative(face);
+        if (relative.getType() == Material.REDSTONE_WIRE) {
+            return Math.max(power, relative.getData()) > 0;
+        }
+
+        return power > 0;
+    }
+
+    public int getBlockPower(BlockFace face) {
+        int power = 0;
+        BlockRedstoneWire wire = Blocks.redstone_wire;
+        net.minecraft.world.World world = chunk.getHandle().worldObj;
+        if ((face == BlockFace.DOWN || face == BlockFace.SELF) && world.getIndirectPowerOutput(x, y - 1, z, 0)) power = wire.func_150178_a(world, x, y - 1, z, power);
+        if ((face == BlockFace.UP || face == BlockFace.SELF) && world.getIndirectPowerOutput(x, y + 1, z, 1)) power = wire.func_150178_a(world, x, y + 1, z, power);
+        if ((face == BlockFace.EAST || face == BlockFace.SELF) && world.getIndirectPowerOutput(x + 1, y, z, 2)) power = wire.func_150178_a(world, x + 1, y, z, power);
+        if ((face == BlockFace.WEST || face == BlockFace.SELF) && world.getIndirectPowerOutput(x - 1, y, z, 3)) power = wire.func_150178_a(world, x - 1, y, z, power);
+        if ((face == BlockFace.NORTH || face == BlockFace.SELF) && world.getIndirectPowerOutput(x, y, z - 1, 4)) power = wire.func_150178_a(world, x, y, z - 1, power);
+        if ((face == BlockFace.SOUTH || face == BlockFace.SELF) && world.getIndirectPowerOutput(x, y, z + 1, 5)) power = wire.func_150178_a(world, x, y, z - 1, power);
+        return power > 0 ? power : (face == BlockFace.SELF ? isBlockIndirectlyPowered() : isBlockFaceIndirectlyPowered(face)) ? 15 : 0;
+    }
+
+    public int getBlockPower() {
+        return getBlockPower(BlockFace.SELF);
+    }
+
+    public boolean isEmpty() {
+        // Cauldron start - support custom air blocks (Railcraft player aura tracking block)
+        //return getType() == Material.AIR;
+        if (getType() == Material.AIR) return true;
+        if (!(getWorld() instanceof CraftWorld)) return false;
+        return ((CraftWorld) getWorld()).getHandle().isAirBlock(getX(), getY(), getZ());
+        // Cauldron end
+    }
+
+    public boolean isLiquid() {
+        return (getType() == Material.WATER) || (getType() == Material.STATIONARY_WATER) || (getType() == Material.LAVA) || (getType() == Material.STATIONARY_LAVA);
+    }
+
+    public PistonMoveReaction getPistonMoveReaction() {
+        return PistonMoveReaction.getById(getNMSBlock().getMaterial().getMaterialMobility());
+    }
+
+    private boolean itemCausesDrops(ItemStack item) {
+        net.minecraft.block.Block block = this.getNMSBlock();
+        net.minecraft.item.Item itemType = item != null ? net.minecraft.item.Item.getItemById(item.getTypeId()) : null;
+        return block != null && (block.getMaterial().isToolNotRequired() || (itemType != null && itemType.func_150897_b(block)));
+    }
+
+    public boolean breakNaturally() {
+        // Order matters here, need to drop before setting to air so skulls can get their data
+        net.minecraft.block.Block block = this.getNMSBlock();
+        byte data = getData();
+        boolean result = false;
+
+        if (block != null && block != Blocks.air) {
+            block.dropBlockAsItemWithChance(chunk.getHandle().worldObj, x, y, z, data, 1.0F, 0);
+            result = true;
+        }
+
+        setTypeId(Material.AIR.getId());
+        return result;
+    }
+
+    public boolean breakNaturally(ItemStack item) {
+        if (itemCausesDrops(item)) {
+            return breakNaturally();
+        } else {
+            return setTypeId(Material.AIR.getId());
+        }
+    }
+
+    public Collection<ItemStack> getDrops() {
+        List<ItemStack> drops = new ArrayList<ItemStack>();
+
+        net.minecraft.block.Block block = this.getNMSBlock();
+        if (block != Blocks.air) {
+            byte data = getData();
+            // based on nms.Block.dropNaturally
+            int count = block.quantityDroppedWithBonus(0, chunk.getHandle().worldObj.rand);
+            for (int i = 0; i < count; ++i) {
+                Item item = block.getItemDropped(data, chunk.getHandle().worldObj.rand, 0);
+                if (item != null) {
+                    // Skulls are special, their data is based on the tile entity
+                    if (Blocks.skull == block) {
+                        net.minecraft.item.ItemStack nmsStack = new net.minecraft.item.ItemStack(item, 1, block.getDamageValue(chunk.getHandle().worldObj, x, y, z));
+                        TileEntitySkull tileentityskull = (TileEntitySkull) chunk.getHandle().worldObj.getTileEntity(x, y, z);
+
+                        if (tileentityskull.func_145904_a() == 3 && tileentityskull.func_152108_a() != null) {
+                            nmsStack.setTagCompound(new NBTTagCompound());
+                            NBTTagCompound nbttagcompound = new NBTTagCompound();
+
+                            NBTUtil.func_152460_a(nbttagcompound, tileentityskull.func_152108_a());
+                            nmsStack.getTagCompound().setTag("SkullOwner", nbttagcompound);
+                        }
+
+                        drops.add(CraftItemStack.asBukkitCopy(nmsStack));
+                        // We don't want to drop cocoa blocks, we want to drop cocoa beans.
+                    } else if (Blocks.cocoa == block) {
+                        int dropAmount = (BlockCocoa.func_149987_c(data) >= 2 ? 3 : 1);
+                        for (int j = 0; j < dropAmount; ++j) {
+                            drops.add(new ItemStack(Material.INK_SACK, 1, (short) 3));
+                        }
+                    } else {
+                        drops.add(new ItemStack(org.bukkit.craftbukkit.util.CraftMagicNumbers.getMaterial(item), 1, (short) block.damageDropped(data)));
+                    }
+                }
+            }
+        }
+        return drops;
+    }
+
+    public Collection<ItemStack> getDrops(ItemStack item) {
+        if (itemCausesDrops(item)) {
+            return getDrops();
+        } else {
+            return Collections.emptyList();
+        }
+    }
+
+    /* Build biome index based lookup table for BiomeBase to Biome mapping */
+    public static void initMappings() { // Cauldron - initializer to initMappings() method; called in CraftServer
+        //BIOME_MAPPING = new Biome[BiomeGenBase.biomeList.length]; // Cauldron - move up
+        //BIOMEBASE_MAPPING = new BiomeGenBase[Biome.values().length]; // Cauldron - move up
+        BIOME_MAPPING[BiomeGenBase.swampland.biomeID] = Biome.SWAMPLAND;
+        BIOME_MAPPING[BiomeGenBase.forest.biomeID] = Biome.FOREST;
+        BIOME_MAPPING[BiomeGenBase.taiga.biomeID] = Biome.TAIGA;
+        BIOME_MAPPING[BiomeGenBase.desert.biomeID] = Biome.DESERT;
+        BIOME_MAPPING[BiomeGenBase.plains.biomeID] = Biome.PLAINS;
+        BIOME_MAPPING[BiomeGenBase.hell.biomeID] = Biome.HELL;
+        BIOME_MAPPING[BiomeGenBase.sky.biomeID] = Biome.SKY;
+        BIOME_MAPPING[BiomeGenBase.river.biomeID] = Biome.RIVER;
+        BIOME_MAPPING[BiomeGenBase.extremeHills.biomeID] = Biome.EXTREME_HILLS;
+        BIOME_MAPPING[BiomeGenBase.ocean.biomeID] = Biome.OCEAN;
+        BIOME_MAPPING[BiomeGenBase.frozenOcean.biomeID] = Biome.FROZEN_OCEAN;
+        BIOME_MAPPING[BiomeGenBase.frozenRiver.biomeID] = Biome.FROZEN_RIVER;
+        BIOME_MAPPING[BiomeGenBase.icePlains.biomeID] = Biome.ICE_PLAINS;
+        BIOME_MAPPING[BiomeGenBase.iceMountains.biomeID] = Biome.ICE_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.mushroomIsland.biomeID] = Biome.MUSHROOM_ISLAND;
+        BIOME_MAPPING[BiomeGenBase.mushroomIslandShore.biomeID] = Biome.MUSHROOM_SHORE;
+        BIOME_MAPPING[BiomeGenBase.beach.biomeID] = Biome.BEACH;
+        BIOME_MAPPING[BiomeGenBase.desertHills.biomeID] = Biome.DESERT_HILLS;
+        BIOME_MAPPING[BiomeGenBase.forestHills.biomeID] = Biome.FOREST_HILLS;
+        BIOME_MAPPING[BiomeGenBase.taigaHills.biomeID] = Biome.TAIGA_HILLS;
+        BIOME_MAPPING[BiomeGenBase.extremeHillsEdge.biomeID] = Biome.SMALL_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.jungle.biomeID] = Biome.JUNGLE;
+        BIOME_MAPPING[BiomeGenBase.jungleHills.biomeID] = Biome.JUNGLE_HILLS;
+        BIOME_MAPPING[BiomeGenBase.jungleEdge.biomeID] = Biome.JUNGLE_EDGE;
+        BIOME_MAPPING[BiomeGenBase.deepOcean.biomeID] = Biome.DEEP_OCEAN;
+        BIOME_MAPPING[BiomeGenBase.stoneBeach.biomeID] = Biome.STONE_BEACH;
+        BIOME_MAPPING[BiomeGenBase.coldBeach.biomeID] = Biome.COLD_BEACH;
+        BIOME_MAPPING[BiomeGenBase.birchForest.biomeID] = Biome.BIRCH_FOREST;
+        BIOME_MAPPING[BiomeGenBase.birchForestHills.biomeID] = Biome.BIRCH_FOREST_HILLS;
+        BIOME_MAPPING[BiomeGenBase.roofedForest.biomeID] = Biome.ROOFED_FOREST;
+        BIOME_MAPPING[BiomeGenBase.coldTaiga.biomeID] = Biome.COLD_TAIGA;
+        BIOME_MAPPING[BiomeGenBase.coldTaigaHills.biomeID] = Biome.COLD_TAIGA_HILLS;
+        BIOME_MAPPING[BiomeGenBase.megaTaiga.biomeID] = Biome.MEGA_TAIGA;
+        BIOME_MAPPING[BiomeGenBase.megaTaigaHills.biomeID] = Biome.MEGA_TAIGA_HILLS;
+        BIOME_MAPPING[BiomeGenBase.extremeHillsPlus.biomeID] = Biome.EXTREME_HILLS_PLUS;
+        BIOME_MAPPING[BiomeGenBase.savanna.biomeID] = Biome.SAVANNA;
+        BIOME_MAPPING[BiomeGenBase.savannaPlateau.biomeID] = Biome.SAVANNA_PLATEAU;
+        BIOME_MAPPING[BiomeGenBase.mesa.biomeID] = Biome.MESA;
+        BIOME_MAPPING[BiomeGenBase.mesaPlateau_F.biomeID] = Biome.MESA_PLATEAU_FOREST;
+        BIOME_MAPPING[BiomeGenBase.mesaPlateau.biomeID] = Biome.MESA_PLATEAU;
+
+        // Extended Biomes
+        BIOME_MAPPING[BiomeGenBase.plains.biomeID + 128] = Biome.SUNFLOWER_PLAINS;
+        BIOME_MAPPING[BiomeGenBase.desert.biomeID + 128] = Biome.DESERT_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.forest.biomeID + 128] = Biome.FLOWER_FOREST;
+        BIOME_MAPPING[BiomeGenBase.taiga.biomeID + 128] = Biome.TAIGA_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.swampland.biomeID + 128] = Biome.SWAMPLAND_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.icePlains.biomeID + 128] = Biome.ICE_PLAINS_SPIKES;
+        BIOME_MAPPING[BiomeGenBase.jungle.biomeID + 128] = Biome.JUNGLE_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.jungleEdge.biomeID + 128] = Biome.JUNGLE_EDGE_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.coldTaiga.biomeID + 128] = Biome.COLD_TAIGA_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.savanna.biomeID + 128] = Biome.SAVANNA_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.savannaPlateau.biomeID + 128] = Biome.SAVANNA_PLATEAU_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.mesa.biomeID + 128] = Biome.MESA_BRYCE;
+        BIOME_MAPPING[BiomeGenBase.mesaPlateau_F.biomeID + 128] = Biome.MESA_PLATEAU_FOREST_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.mesaPlateau.biomeID + 128] = Biome.MESA_PLATEAU_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.birchForest.biomeID + 128] = Biome.BIRCH_FOREST_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.birchForestHills.biomeID + 128] = Biome.BIRCH_FOREST_HILLS_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.roofedForest.biomeID + 128] = Biome.ROOFED_FOREST_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.megaTaiga.biomeID + 128] = Biome.MEGA_SPRUCE_TAIGA;
+        BIOME_MAPPING[BiomeGenBase.extremeHills.biomeID + 128] = Biome.EXTREME_HILLS_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.extremeHillsPlus.biomeID + 128] = Biome.EXTREME_HILLS_PLUS_MOUNTAINS;
+        BIOME_MAPPING[BiomeGenBase.megaTaigaHills.biomeID + 128] = Biome.MEGA_SPRUCE_TAIGA_HILLS;
+
+        /* Sanity check - we should have a record for each record in the BiomeBase.a table */
+        /* Helps avoid missed biomes when we upgrade bukkit to new code with new biomes */
+        for (int i = 0; i < BIOME_MAPPING.length; i++) {
+            if ((BiomeGenBase.getBiome(i) != null) && (BIOME_MAPPING[i] == null)) {
+                // Cauldron start - add support for mod biomes
+                //throw new IllegalArgumentException("Missing Biome mapping for BiomeBase[" + i + "]");
+                String name = BiomeGenBase.getBiome(i).biomeName;
+                int id = BiomeGenBase.getBiome(i).biomeID;
+
+                System.out.println("Adding biome mapping " + BiomeGenBase.getBiome(i).biomeID + " " + name + " at BiomeBase[" + i + "]");
+                net.minecraftforge.common.util.EnumHelper.addBukkitBiome(name); // Forge
+                BIOME_MAPPING[BiomeGenBase.getBiome(i).biomeID] = ((Biome) Enum.valueOf(Biome.class, name));
+                // Cauldron end           
+            }
+            if (BIOME_MAPPING[i] != null) {  /* Build reverse mapping for setBiome */
+                BIOMEBASE_MAPPING[BIOME_MAPPING[i].ordinal()] = BiomeGenBase.getBiome(i);
+            }
+        }
+    }
+
+    // Cauldron start - if cauldron.dump-materials is true, dump all materials with their corresponding id's
+    public static void dumpMaterials() {
+        if (MinecraftServer.getServer().cauldronConfig.dumpMaterials.getValue())
+        {
+            FMLLog.info("Cauldron Dump Materials is ENABLED. Starting dump...");
+            for (int i = 0; i < 32000; i++)
+            {
+                Material material = Material.getMaterial(i);
+                if (material != null)
+                {
+                    FMLLog.info("Found material " + material + " with ID " + i);
+                }
+            }
+            FMLLog.info("Cauldron Dump Materials complete.");
+            FMLLog.info("To disable these dumps, set cauldron.dump-materials to false in bukkit.yml.");
+        }
+    }
+    // Cauldron end
+
+    public void setMetadata(String metadataKey, MetadataValue newMetadataValue) {
+        chunk.getCraftWorld().getBlockMetadata().setMetadata(this, metadataKey, newMetadataValue);
+    }
+
+    public List<MetadataValue> getMetadata(String metadataKey) {
+        return chunk.getCraftWorld().getBlockMetadata().getMetadata(this, metadataKey);
+    }
+
+    public boolean hasMetadata(String metadataKey) {
+        return chunk.getCraftWorld().getBlockMetadata().hasMetadata(this, metadataKey);
+    }
+
+    public void removeMetadata(String metadataKey, Plugin owningPlugin) {
+        chunk.getCraftWorld().getBlockMetadata().removeMetadata(this, metadataKey, owningPlugin);
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftBlockState.java

@@ -0,0 +1,284 @@
+package org.bukkit.craftbukkit.block;
+
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.BlockState;
+import org.bukkit.craftbukkit.CraftChunk;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.material.MaterialData;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+
+import java.util.List;
+// Cauldron start
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+// Cauldron end
+
+public class CraftBlockState implements BlockState {
+    private final CraftWorld world;
+    private final CraftChunk chunk;
+    private final int x;
+    private final int y;
+    private final int z;
+    private final NBTTagCompound nbt; // Cauldron
+    protected int type;
+    protected MaterialData data;
+    protected int flag;
+    protected final byte light;
+
+    public CraftBlockState(final Block block) {
+        this.world = (CraftWorld) block.getWorld();
+        this.x = block.getX();
+        this.y = block.getY();
+        this.z = block.getZ();
+        this.type = block.getTypeId();
+        this.light = block.getLightLevel();
+        this.chunk = (CraftChunk) block.getChunk();
+        this.flag = 3;
+        // Cauldron start - save TE data
+        TileEntity te = world.getHandle().getTileEntity(x, y, z);
+        if (te != null)
+        {
+            nbt = new NBTTagCompound();
+            te.writeToNBT(nbt);
+        }
+        else nbt = null;
+        // Cauldron end
+
+        createData(block.getData());
+    }
+
+    public CraftBlockState(final Block block, int flag) {
+        this(block);
+        this.flag = flag;
+    }
+
+    public static CraftBlockState getBlockState(net.minecraft.world.World world, int x, int y, int z) {
+        return new CraftBlockState(world.getWorld().getBlockAt(x, y, z));
+    }
+
+    public static CraftBlockState getBlockState(net.minecraft.world.World world, int x, int y, int z, int flag) {
+        return new CraftBlockState(world.getWorld().getBlockAt(x, y, z), flag);
+    }
+
+    public World getWorld() {
+        return world;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public int getZ() {
+        return z;
+    }
+
+    public Chunk getChunk() {
+        return chunk;
+    }
+
+    public void setData(final MaterialData data) {
+        Material mat = getType();
+
+        if ((mat == null) || (mat.getData() == null)) {
+            this.data = data;
+        } else {
+            if ((data.getClass() == mat.getData()) || (data.getClass() == MaterialData.class)) {
+                this.data = data;
+            } else {
+                throw new IllegalArgumentException("Provided data is not of type "
+                        + mat.getData().getName() + ", found " + data.getClass().getName());
+            }
+        }
+    }
+
+    public MaterialData getData() {
+        return data;
+    }
+
+    public void setType(final Material type) {
+        setTypeId(type.getId());
+    }
+
+    public boolean setTypeId(final int type) {
+        if (this.type != type) {
+            this.type = type;
+
+            createData((byte) 0);
+        }
+        return true;
+    }
+
+    public Material getType() {
+        return Material.getMaterial(getTypeId());
+    }
+
+    public void setFlag(int flag) {
+        this.flag = flag;
+    }
+
+    public int getFlag() {
+        return flag;
+    }
+
+    public int getTypeId() {
+        return type;
+    }
+
+    public byte getLightLevel() {
+        return light;
+    }
+
+    public Block getBlock() {
+        return world.getBlockAt(x, y, z);
+    }
+
+    public boolean update() {
+        return update(false);
+    }
+
+    public boolean update(boolean force) {
+        return update(force, true);
+    }
+
+    public boolean update(boolean force, boolean applyPhysics) {
+        Block block = getBlock();
+
+        if (block.getType() != getType()) {
+            if (force) {
+                block.setTypeId(getTypeId(), applyPhysics);
+            } else {
+                return false;
+            }
+        }
+
+        block.setData(getRawData(), applyPhysics);
+        world.getHandle().markBlockForUpdate(x, y, z);
+        // Cauldron start - restore TE data from snapshot
+        if (nbt != null)
+        {
+            TileEntity te = world.getHandle().getTileEntity(x, y, z);
+            if (te != null)
+            {
+                te.readFromNBT(nbt);
+            }
+        }
+        // Cauldron end
+
+        return true;
+    }
+
+    private void createData(final byte data) {
+        Material mat = getType();
+        if (mat == null || mat.getData() == null) {
+            this.data = new MaterialData(type, data);
+        } else {
+            this.data = mat.getNewData(data);
+        }
+    }
+
+    public byte getRawData() {
+        return data.getData();
+    }
+
+    public Location getLocation() {
+        return new Location(world, x, y, z);
+    }
+
+    public Location getLocation(Location loc) {
+        if (loc != null) {
+            loc.setWorld(world);
+            loc.setX(x);
+            loc.setY(y);
+            loc.setZ(z);
+            loc.setYaw(0);
+            loc.setPitch(0);
+        }
+
+        return loc;
+    }
+
+    public void setRawData(byte data) {
+        this.data.setData(data);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final CraftBlockState other = (CraftBlockState) obj;
+        if (this.world != other.world && (this.world == null || !this.world.equals(other.world))) {
+            return false;
+        }
+        if (this.x != other.x) {
+            return false;
+        }
+        if (this.y != other.y) {
+            return false;
+        }
+        if (this.z != other.z) {
+            return false;
+        }
+        if (this.type != other.type) {
+            return false;
+        }
+        if (this.data != other.data && (this.data == null || !this.data.equals(other.data))) {
+            return false;
+        }
+        // Cauldron start
+        if (this.nbt != other.nbt && (this.nbt == null || !this.nbt.equals(other.nbt))) {
+            return false;
+        }
+        // Cauldron end
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 73 * hash + (this.world != null ? this.world.hashCode() : 0);
+        hash = 73 * hash + this.x;
+        hash = 73 * hash + this.y;
+        hash = 73 * hash + this.z;
+        hash = 73 * hash + this.type;
+        hash = 73 * hash + (this.data != null ? this.data.hashCode() : 0);
+        hash = 73 * hash + (this.nbt != null ? this.nbt.hashCode() : 0); // Cauldron
+        return hash;
+    }
+
+    public void setMetadata(String metadataKey, MetadataValue newMetadataValue) {
+        chunk.getCraftWorld().getBlockMetadata().setMetadata(getBlock(), metadataKey, newMetadataValue);
+    }
+
+    public List<MetadataValue> getMetadata(String metadataKey) {
+        return chunk.getCraftWorld().getBlockMetadata().getMetadata(getBlock(), metadataKey);
+    }
+
+    public boolean hasMetadata(String metadataKey) {
+        return chunk.getCraftWorld().getBlockMetadata().hasMetadata(getBlock(), metadataKey);
+    }
+
+    public void removeMetadata(String metadataKey, Plugin owningPlugin) {
+        chunk.getCraftWorld().getBlockMetadata().removeMetadata(getBlock(), metadataKey, owningPlugin);
+    }
+
+    // Cauldron start
+    public TileEntity getTileEntity() {
+        if (nbt != null)
+            return TileEntity.createAndLoadEntity(nbt);
+        else return null;
+    }
+    // Cauldron end
+}

src/main/java/org/bukkit/craftbukkit/block/CraftBrewingStand.java

@@ -0,0 +1,41 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityBrewingStand;
+import org.bukkit.block.Block;
+import org.bukkit.block.BrewingStand;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventoryBrewer;
+import org.bukkit.inventory.BrewerInventory;
+
+public class CraftBrewingStand extends CraftBlockState implements BrewingStand {
+    private final TileEntityBrewingStand brewingStand;
+
+    public CraftBrewingStand(Block block) {
+        super(block);
+
+        brewingStand = (TileEntityBrewingStand) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public BrewerInventory getInventory() {
+        return new CraftInventoryBrewer(brewingStand);
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            brewingStand.markDirty();
+        }
+
+        return result;
+    }
+
+    public int getBrewingTime() {
+        return brewingStand.brewTime;
+    }
+
+    public void setBrewingTime(int brewTime) {
+        brewingStand.brewTime = brewTime;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftChest.java

@@ -0,0 +1,72 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityChest;
+
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.Chest;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest;
+import org.bukkit.inventory.Inventory;
+
+public class CraftChest extends CraftBlockState implements Chest {
+    private final CraftWorld world;
+    private final TileEntityChest chest;
+
+    public CraftChest(final Block block) {
+        super(block);
+
+        world = (CraftWorld) block.getWorld();
+        chest = (TileEntityChest) world.getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public Inventory getBlockInventory() {
+        return new CraftInventory(chest);
+    }
+
+    public Inventory getInventory() {
+        int x = getX();
+        int y = getY();
+        int z = getZ();
+        // The logic here is basically identical to the logic in BlockChest.interact
+        CraftInventory inventory = new CraftInventory(chest);
+        int id;
+        if (world.getBlockTypeIdAt(x, y, z) == Material.CHEST.getId()) {
+            id = Material.CHEST.getId();
+        } else if (world.getBlockTypeIdAt(x, y, z) == Material.TRAPPED_CHEST.getId()) {
+            id = Material.TRAPPED_CHEST.getId();
+        } else {
+            throw new IllegalStateException("CraftChest is not a chest but is instead " + world.getBlockAt(x, y, z));
+        }
+
+        if (world.getBlockTypeIdAt(x - 1, y, z) == id) {
+            CraftInventory left = new CraftInventory((TileEntityChest)world.getHandle().getTileEntity(x - 1, y, z));
+            inventory = new CraftInventoryDoubleChest(left, inventory);
+        }
+        if (world.getBlockTypeIdAt(x + 1, y, z) == id) {
+            CraftInventory right = new CraftInventory((TileEntityChest) world.getHandle().getTileEntity(x + 1, y, z));
+            inventory = new CraftInventoryDoubleChest(inventory, right);
+        }
+        if (world.getBlockTypeIdAt(x, y, z - 1) == id) {
+            CraftInventory left = new CraftInventory((TileEntityChest) world.getHandle().getTileEntity(x, y, z - 1));
+            inventory = new CraftInventoryDoubleChest(left, inventory);
+        }
+        if (world.getBlockTypeIdAt(x, y, z + 1) == id) {
+            CraftInventory right = new CraftInventory((TileEntityChest) world.getHandle().getTileEntity(x, y, z + 1));
+            inventory = new CraftInventoryDoubleChest(inventory, right);
+        }
+        return inventory;
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            chest.markDirty();
+        }
+
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftCommandBlock.java

@@ -0,0 +1,49 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityCommandBlock;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.CommandBlock;
+import org.bukkit.craftbukkit.CraftWorld;
+
+public class CraftCommandBlock extends CraftBlockState implements CommandBlock {
+    private final TileEntityCommandBlock commandBlock;
+    private String command;
+    private String name;
+
+    public CraftCommandBlock(Block block) {
+        super(block);
+
+        CraftWorld world = (CraftWorld) block.getWorld();
+        commandBlock = (TileEntityCommandBlock) world.getTileEntityAt(getX(), getY(), getZ());
+        command = commandBlock.func_145993_a().field_145763_e;
+        name = commandBlock.func_145993_a().getCommandSenderName();
+    }
+
+    public String getCommand() {
+        return command;
+    }
+
+    public void setCommand(String command) {
+        this.command = command != null ? command : "";
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name != null ? name : "@";
+    }
+
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            commandBlock.func_145993_a().func_145752_a(command);
+            commandBlock.func_145993_a().func_145754_b(name);
+        }
+
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java

@@ -0,0 +1,73 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityMobSpawner;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.CreatureSpawner;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.entity.CreatureType;
+import org.bukkit.entity.EntityType;
+
+public class CraftCreatureSpawner extends CraftBlockState implements CreatureSpawner {
+    private final TileEntityMobSpawner spawner;
+
+    public CraftCreatureSpawner(final Block block) {
+        super(block);
+
+        spawner = (TileEntityMobSpawner) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    @Deprecated
+    public CreatureType getCreatureType() {
+        return CreatureType.fromName(spawner.func_145881_a().getEntityNameToSpawn());
+    }
+
+    public EntityType getSpawnedType() {
+        return EntityType.fromName(spawner.func_145881_a().getEntityNameToSpawn());
+    }
+
+    @Deprecated
+    public void setCreatureType(CreatureType creatureType) {
+        spawner.func_145881_a().setEntityName(creatureType.getName());
+    }
+
+    public void setSpawnedType(EntityType entityType) {
+        if (entityType == null || entityType.getName() == null) {
+            throw new IllegalArgumentException("Can't spawn EntityType " + entityType + " from mobspawners!");
+        }
+
+        spawner.func_145881_a().setEntityName(entityType.getName());
+    }
+
+    @Deprecated
+    public String getCreatureTypeId() {
+        return spawner.func_145881_a().getEntityNameToSpawn();
+    }
+
+    @Deprecated
+    public void setCreatureTypeId(String creatureName) {
+        setCreatureTypeByName(creatureName);
+    }
+
+    public String getCreatureTypeName() {
+        return spawner.func_145881_a().getEntityNameToSpawn();
+    }
+
+    public void setCreatureTypeByName(String creatureType) {
+        // Verify input
+        EntityType type = EntityType.fromName(creatureType);
+        if (type == null) {
+            return;
+        }
+        setSpawnedType(type);
+    }
+
+    public int getDelay() {
+        return spawner.func_145881_a().spawnDelay;
+    }
+
+    public void setDelay(int delay) {
+        spawner.func_145881_a().spawnDelay = delay;
+    }
+
+}

src/main/java/org/bukkit/craftbukkit/block/CraftDispenser.java

@@ -0,0 +1,64 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.block.BlockDispenser;
+import net.minecraft.init.Blocks;
+import net.minecraft.tileentity.TileEntityDispenser;
+
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.Dispenser;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.projectiles.BlockProjectileSource;
+
+public class CraftDispenser extends CraftBlockState implements Dispenser {
+    private final CraftWorld world;
+    private final TileEntityDispenser dispenser;
+
+    public CraftDispenser(final Block block) {
+        super(block);
+
+        world = (CraftWorld) block.getWorld();
+        dispenser = (TileEntityDispenser) world.getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public Inventory getInventory() {
+        return new CraftInventory(dispenser);
+    }
+
+    public BlockProjectileSource getBlockProjectileSource() {
+        Block block = getBlock();
+
+        if (block.getType() != Material.DISPENSER) {
+            return null;
+        }
+
+        return new CraftBlockProjectileSource(dispenser);
+    }
+
+    public boolean dispense() {
+        Block block = getBlock();
+
+        if (block.getType() == Material.DISPENSER) {
+            BlockDispenser dispense = (BlockDispenser) Blocks.dispenser;
+
+            dispense.func_149941_e(world.getHandle(), getX(), getY(), getZ());
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            dispenser.markDirty();
+        }
+
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftDropper.java

@@ -0,0 +1,49 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.block.BlockDropper;
+import net.minecraft.init.Blocks;
+import net.minecraft.tileentity.TileEntityDropper;
+
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.Dropper;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.inventory.Inventory;
+
+public class CraftDropper extends CraftBlockState implements Dropper {
+    private final CraftWorld world;
+    private final TileEntityDropper dropper;
+
+    public CraftDropper(final Block block) {
+        super(block);
+
+        world = (CraftWorld) block.getWorld();
+        dropper = (TileEntityDropper) world.getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public Inventory getInventory() {
+        return new CraftInventory(dropper);
+    }
+
+    public void drop() {
+        Block block = getBlock();
+
+        if (block.getType() == Material.DROPPER) {
+            BlockDropper drop = (BlockDropper) Blocks.dropper;
+
+            drop.func_149941_e(world.getHandle(), getX(), getY(), getZ());
+        }
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            dropper.markDirty();
+        }
+
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java

@@ -0,0 +1,49 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityFurnace;
+import org.bukkit.block.Block;
+import org.bukkit.block.Furnace;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventoryFurnace;
+import org.bukkit.inventory.FurnaceInventory;
+
+public class CraftFurnace extends CraftBlockState implements Furnace {
+    private final TileEntityFurnace furnace;
+
+    public CraftFurnace(final Block block) {
+        super(block);
+
+        furnace = (TileEntityFurnace) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public FurnaceInventory getInventory() {
+        return new CraftInventoryFurnace(furnace);
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            furnace.markDirty();
+        }
+
+        return result;
+    }
+
+    public short getBurnTime() {
+        return (short) furnace.furnaceBurnTime;
+    }
+
+    public void setBurnTime(short burnTime) {
+        furnace.furnaceBurnTime = burnTime;
+    }
+
+    public short getCookTime() {
+        return (short) furnace.furnaceCookTime;
+    }
+
+    public void setCookTime(short cookTime) {
+        furnace.furnaceCookTime = cookTime;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftHopper.java

@@ -0,0 +1,33 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityHopper;
+import org.bukkit.block.Block;
+import org.bukkit.block.Hopper;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.inventory.Inventory;
+
+public class CraftHopper extends CraftBlockState implements Hopper {
+    private final TileEntityHopper hopper;
+
+    public CraftHopper(final Block block) {
+        super(block);
+
+        hopper = (TileEntityHopper) ((CraftWorld) block.getWorld()).getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public Inventory getInventory() {
+        return new CraftInventory(hopper);
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            hopper.markDirty();
+        }
+
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftJukebox.java

@@ -0,0 +1,60 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.block.BlockJukebox;
+import net.minecraft.block.BlockJukebox.TileEntityJukebox;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.Jukebox;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+
+public class CraftJukebox extends CraftBlockState implements Jukebox {
+    private final CraftWorld world;
+    private final TileEntityJukebox jukebox;
+
+    public CraftJukebox(final Block block) {
+        super(block);
+
+        world = (CraftWorld) block.getWorld();
+        jukebox = (TileEntityJukebox) world.getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    @Override
+    public Material getPlaying() {
+        ItemStack record = jukebox.func_145856_a();
+        if (record == null) {
+            return Material.AIR;
+        }
+        return CraftMagicNumbers.getMaterial(record.getItem());
+    }
+
+    @Override
+    public void setPlaying(Material record) {
+        if (record == null || CraftMagicNumbers.getItem(record) == null) {
+            record = Material.AIR;
+            jukebox.func_145857_a(null);
+        } else {
+            jukebox.func_145857_a(new ItemStack(CraftMagicNumbers.getItem(record), 1));
+        }
+        jukebox.markDirty();
+        if (record == Material.AIR) {
+            world.getHandle().setBlockMetadataWithNotify(getX(), getY(), getZ(), 0, 3);
+        } else {
+            world.getHandle().setBlockMetadataWithNotify(getX(), getY(), getZ(), 1, 3);
+        }
+        world.playEffect(getLocation(), Effect.RECORD_PLAY, record.getId());
+    }
+
+    public boolean isPlaying() {
+        return getRawData() == 1;
+    }
+
+    public boolean eject() {
+        boolean result = isPlaying();
+        ((BlockJukebox) Blocks.jukebox).func_149925_e(world.getHandle(), getX(), getY(), getZ());
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftNoteBlock.java

@@ -0,0 +1,74 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntityNote;
+
+import org.bukkit.Instrument;
+import org.bukkit.Material;
+import org.bukkit.Note;
+import org.bukkit.block.Block;
+import org.bukkit.block.NoteBlock;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+
+public class CraftNoteBlock extends CraftBlockState implements NoteBlock {
+    private final CraftWorld world;
+    private final TileEntityNote note;
+
+    public CraftNoteBlock(final Block block) {
+        super(block);
+
+        world = (CraftWorld) block.getWorld();
+        note = (TileEntityNote) world.getTileEntityAt(getX(), getY(), getZ());
+    }
+
+    public Note getNote() {
+        return new Note(note.note);
+    }
+
+    public byte getRawNote() {
+        return note.note;
+    }
+
+    public void setNote(Note n) {
+        note.note = n.getId();
+    }
+
+    public void setRawNote(byte n) {
+        note.note = n;
+    }
+
+    public boolean play() {
+        Block block = getBlock();
+
+        if (block.getType() == Material.NOTE_BLOCK) {
+            note.triggerNote(world.getHandle(), getX(), getY(), getZ());
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean play(byte instrument, byte note) {
+        Block block = getBlock();
+
+        if (block.getType() == Material.NOTE_BLOCK) {
+            world.getHandle().addBlockEvent(getX(), getY(), getZ(), CraftMagicNumbers.getBlock(block), instrument, note);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean play(Instrument instrument, Note note) {
+        Block block = getBlock();
+
+        if (block.getType() == Material.NOTE_BLOCK) {
+            world.getHandle().addBlockEvent(getX(), getY(), getZ(), CraftMagicNumbers.getBlock(block), instrument.getType(), note.getId());
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftSign.java

@@ -0,0 +1,64 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.tileentity.TileEntitySign;
+import org.bukkit.block.Block;
+import org.bukkit.block.Sign;
+import org.bukkit.craftbukkit.CraftWorld;
+
+public class CraftSign extends CraftBlockState implements Sign {
+    private final TileEntitySign sign;
+    private final String[] lines;
+
+    public CraftSign(final Block block) {
+        super(block);
+
+        CraftWorld world = (CraftWorld) block.getWorld();
+        sign = (net.minecraft.tileentity.TileEntitySign) world.getTileEntityAt(getX(), getY(), getZ());
+        // Spigot start
+        if (sign == null) {
+            lines = new String[]{"", "", "", ""};
+            return;
+        }
+        // Spigot end
+        lines = new String[sign.signText.length];
+        System.arraycopy(sign.signText, 0, lines, 0, lines.length);
+    }
+
+    public String[] getLines() {
+        return lines;
+    }
+
+    public String getLine(int index) throws IndexOutOfBoundsException {
+        return lines[index];
+    }
+
+    public void setLine(int index, String line) throws IndexOutOfBoundsException {
+        lines[index] = line;
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            sign.signText = sanitizeLines(lines);
+            sign.markDirty();
+        }
+
+        return result;
+    }
+
+    public static String[] sanitizeLines(String[] lines) {
+        String[] astring = new String[4];
+
+            for(int i = 0; i < 4; i++) {
+            if (i < lines.length && lines[i] != null) {
+                astring[i] = lines[i];
+                } else {
+                astring[i] = "";
+            }
+        }
+
+        return TileEntitySign.sanitizeLines(astring);
+    }
+}

src/main/java/org/bukkit/craftbukkit/block/CraftSkull.java

@@ -0,0 +1,205 @@
+package org.bukkit.craftbukkit.block;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntitySkull;
+import com.mojang.authlib.GameProfile;
+
+import org.bukkit.SkullType;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.Skull;
+import org.bukkit.craftbukkit.CraftWorld;
+
+public class CraftSkull extends CraftBlockState implements Skull {
+    private static final int MAX_OWNER_LENGTH = 16;
+    private final TileEntitySkull skull;
+    private GameProfile profile;
+    private SkullType skullType;
+    private byte rotation;
+
+    public CraftSkull(final Block block) {
+        super(block);
+
+        CraftWorld world = (CraftWorld) block.getWorld();
+        skull = (TileEntitySkull) world.getTileEntityAt(getX(), getY(), getZ());
+        profile = skull.func_152108_a();
+        skullType = getSkullType(skull.func_145904_a());
+        rotation = (byte) skull.getRotation();
+    }
+
+    static SkullType getSkullType(int id) {
+        switch (id) {
+            case 0:
+                return SkullType.SKELETON;
+            case 1:
+                return SkullType.WITHER;
+            case 2:
+                return SkullType.ZOMBIE;
+            case 3:
+                return SkullType.PLAYER;
+            case 4:
+                return SkullType.CREEPER;
+            default:
+                throw new AssertionError(id);
+        }
+    }
+
+    static int getSkullType(SkullType type) {
+        switch(type) {
+            case SKELETON:
+                return 0;
+            case WITHER:
+                return 1;
+            case ZOMBIE:
+                return 2;
+            case PLAYER:
+                return 3;
+            case CREEPER:
+                return 4;
+            default:
+                throw new AssertionError(type);
+        }
+    }
+
+    static byte getBlockFace(BlockFace rotation) {
+        switch (rotation) {
+            case NORTH:
+                return 0;
+            case NORTH_NORTH_EAST:
+                return 1;
+            case NORTH_EAST:
+                return 2;
+            case EAST_NORTH_EAST:
+                return 3;
+            case EAST:
+                return 4;
+            case EAST_SOUTH_EAST:
+                return 5;
+            case SOUTH_EAST:
+                return 6;
+            case SOUTH_SOUTH_EAST:
+                return 7;
+            case SOUTH:
+                return 8;
+            case SOUTH_SOUTH_WEST:
+                return 9;
+            case SOUTH_WEST:
+                return 10;
+            case WEST_SOUTH_WEST:
+                return 11;
+            case WEST:
+                return 12;
+            case WEST_NORTH_WEST:
+                return 13;
+            case NORTH_WEST:
+                return 14;
+            case NORTH_NORTH_WEST:
+                return 15;
+            default:
+                throw new IllegalArgumentException("Invalid BlockFace rotation: " + rotation);
+        }
+    }
+
+    static BlockFace getBlockFace(byte rotation) {
+        switch (rotation) {
+            case 0:
+                return BlockFace.NORTH;
+            case 1:
+                return BlockFace.NORTH_NORTH_EAST;
+            case 2:
+                return BlockFace.NORTH_EAST;
+            case 3:
+                return BlockFace.EAST_NORTH_EAST;
+            case 4:
+                return BlockFace.EAST;
+            case 5:
+                return BlockFace.EAST_SOUTH_EAST;
+            case 6:
+                return BlockFace.SOUTH_EAST;
+            case 7:
+                return BlockFace.SOUTH_SOUTH_EAST;
+            case 8:
+                return BlockFace.SOUTH;
+            case 9:
+                return BlockFace.SOUTH_SOUTH_WEST;
+            case 10:
+                return BlockFace.SOUTH_WEST;
+            case 11:
+                return BlockFace.WEST_SOUTH_WEST;
+            case 12:
+                return BlockFace.WEST;
+            case 13:
+                return BlockFace.WEST_NORTH_WEST;
+            case 14:
+                return BlockFace.NORTH_WEST;
+            case 15:
+                return BlockFace.NORTH_NORTH_WEST;
+            default:
+                throw new AssertionError(rotation);
+        }
+    }
+
+    public boolean hasOwner() {
+        return profile != null;
+    }
+
+    public String getOwner() {
+        return hasOwner() ? profile.getName() : null;
+    }
+
+    public boolean setOwner(String name) {
+        if (name == null || name.length() > MAX_OWNER_LENGTH) {
+            return false;
+        }
+
+        GameProfile profile = MinecraftServer.getServer().func_152358_ax().func_152655_a (name);
+        if (profile == null) {
+            return false;
+        }
+
+        if (skullType != SkullType.PLAYER) {
+            skullType = SkullType.PLAYER;
+        }
+
+        this.profile = profile;
+        return true;
+    }
+
+    public BlockFace getRotation() {
+    	return getBlockFace(rotation);
+    }
+
+    public void setRotation(BlockFace rotation) {
+        this.rotation = getBlockFace(rotation);
+    }
+
+    public SkullType getSkullType() {
+        return skullType;
+    }
+
+    public void setSkullType(SkullType skullType) {
+        this.skullType = skullType;
+
+        if (skullType != SkullType.PLAYER) {
+            profile = null;
+        }
+    }
+
+    @Override
+    public boolean update(boolean force, boolean applyPhysics) {
+        boolean result = super.update(force, applyPhysics);
+
+        if (result) {
+            if (skullType == SkullType.PLAYER) {
+                skull.func_152106_a(profile);
+            } else {
+                skull.func_152107_a(getSkullType(skullType));
+            }
+
+            skull.func_145903_a(rotation);
+            skull.markDirty();
+        }
+
+        return result;
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java

@@ -0,0 +1,74 @@
+package org.bukkit.craftbukkit.command;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+import org.fusesource.jansi.Ansi;
+import org.fusesource.jansi.Ansi.Attribute;
+import jline.Terminal;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.craftbukkit.CraftServer;
+
+public class ColouredConsoleSender extends CraftConsoleCommandSender {
+    private final Terminal terminal;
+    private final Map<ChatColor, String> replacements = new EnumMap<ChatColor, String>(ChatColor.class);
+    private final ChatColor[] colors = ChatColor.values();
+
+    protected ColouredConsoleSender() {
+        super();
+        this.terminal = ((CraftServer) getServer()).getReader().getTerminal();
+
+        replacements.put(ChatColor.BLACK, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLACK).boldOff().toString());
+        replacements.put(ChatColor.DARK_BLUE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLUE).boldOff().toString());
+        replacements.put(ChatColor.DARK_GREEN, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.GREEN).boldOff().toString());
+        replacements.put(ChatColor.DARK_AQUA, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.CYAN).boldOff().toString());
+        replacements.put(ChatColor.DARK_RED, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.RED).boldOff().toString());
+        replacements.put(ChatColor.DARK_PURPLE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.MAGENTA).boldOff().toString());
+        replacements.put(ChatColor.GOLD, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.YELLOW).boldOff().toString());
+        replacements.put(ChatColor.GRAY, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.WHITE).boldOff().toString());
+        replacements.put(ChatColor.DARK_GRAY, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLACK).bold().toString());
+        replacements.put(ChatColor.BLUE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLUE).bold().toString());
+        replacements.put(ChatColor.GREEN, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.GREEN).bold().toString());
+        replacements.put(ChatColor.AQUA, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.CYAN).bold().toString());
+        replacements.put(ChatColor.RED, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.RED).bold().toString());
+        replacements.put(ChatColor.LIGHT_PURPLE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.MAGENTA).bold().toString());
+        replacements.put(ChatColor.YELLOW, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.YELLOW).bold().toString());
+        replacements.put(ChatColor.WHITE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.WHITE).bold().toString());
+        replacements.put(ChatColor.MAGIC, Ansi.ansi().a(Attribute.BLINK_SLOW).toString());
+        replacements.put(ChatColor.BOLD, Ansi.ansi().a(Attribute.UNDERLINE_DOUBLE).toString());
+        replacements.put(ChatColor.STRIKETHROUGH, Ansi.ansi().a(Attribute.STRIKETHROUGH_ON).toString());
+        replacements.put(ChatColor.UNDERLINE, Ansi.ansi().a(Attribute.UNDERLINE).toString());
+        replacements.put(ChatColor.ITALIC, Ansi.ansi().a(Attribute.ITALIC).toString());
+        replacements.put(ChatColor.RESET, Ansi.ansi().a(Attribute.RESET).toString());
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        if (terminal.isAnsiSupported()) {
+            if (!conversationTracker.isConversingModaly()) {
+                String result = message;
+                for (ChatColor color : colors) {
+                    if (replacements.containsKey(color)) {
+                        result = result.replaceAll("(?i)" + color.toString(), replacements.get(color));
+                    } else {
+                        result = result.replaceAll("(?i)" + color.toString(), "");
+                    }
+                }
+                System.out.println(result + Ansi.ansi().reset().toString());
+            }
+        } else {
+            super.sendMessage(message);
+        }
+    }
+
+    public static ConsoleCommandSender getInstance() {
+        if (Bukkit.getConsoleSender() != null) {
+            return Bukkit.getConsoleSender();
+        } else {
+            return new ColouredConsoleSender();
+        }
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java

@@ -0,0 +1,47 @@
+package org.bukkit.craftbukkit.command;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.util.Waitable;
+
+import jline.console.completer.Completer;
+
+public class ConsoleCommandCompleter implements Completer {
+    private final CraftServer server;
+
+    public ConsoleCommandCompleter(CraftServer server) {
+        this.server = server;
+    }
+
+    public int complete(final String buffer, final int cursor, final List<CharSequence> candidates) {
+        Waitable<List<String>> waitable = new Waitable<List<String>>() {
+            @Override
+            protected List<String> evaluate() {
+                return server.getCommandMap().tabComplete(server.getConsoleSender(), buffer);
+            }
+        };
+        this.server.getServer().processQueue.add(waitable);
+        try {
+            List<String> offers = waitable.get();
+            if (offers == null) {
+                return cursor;
+            }
+            candidates.addAll(offers);
+
+            final int lastSpace = buffer.lastIndexOf(' ');
+            if (lastSpace == -1) {
+                return cursor - buffer.length();
+            } else {
+                return cursor - (buffer.length() - lastSpace - 1);
+            }
+        } catch (ExecutionException e) {
+            this.server.getLogger().log(Level.WARNING, "Unhandled exception when tab completing", e);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+        return cursor;
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/CraftBlockCommandSender.java

@@ -0,0 +1,45 @@
+package org.bukkit.craftbukkit.command;
+
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.server.CommandBlockLogic;
+
+import org.bukkit.block.Block;
+import org.bukkit.command.BlockCommandSender;
+
+/**
+ * Represents input from a command block
+ */
+public class CraftBlockCommandSender extends ServerCommandSender implements BlockCommandSender {
+    private final CommandBlockLogic commandBlock;
+
+    public CraftBlockCommandSender(CommandBlockLogic commandBlockListenerAbstract) {
+        super();
+        this.commandBlock = commandBlockListenerAbstract;
+    }
+
+    public Block getBlock() {
+        return commandBlock.getEntityWorld().getWorld().getBlockAt(commandBlock.getPlayerCoordinates().posX, commandBlock.getPlayerCoordinates().posY, commandBlock.getPlayerCoordinates().posZ);
+    }
+
+    public void sendMessage(String message) {
+    }
+
+    public void sendMessage(String[] messages) {
+    }
+
+    public String getName() {
+        return commandBlock.getCommandSenderName();
+    }
+
+    public boolean isOp() {
+        return true;
+    }
+
+    public void setOp(boolean value) {
+        throw new UnsupportedOperationException("Cannot change operator status of a block");
+    }
+
+    public ICommandSender getTileEntity() {
+        return commandBlock;
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java

@@ -0,0 +1,66 @@
+package org.bukkit.craftbukkit.command;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.conversations.Conversation;
+import org.bukkit.conversations.ConversationAbandonedEvent;
+import org.bukkit.conversations.ManuallyAbandonedConversationCanceller;
+import org.bukkit.craftbukkit.conversations.ConversationTracker;
+
+/**
+ * Represents CLI input from a console
+ */
+public class CraftConsoleCommandSender extends ServerCommandSender implements ConsoleCommandSender {
+
+    protected final ConversationTracker conversationTracker = new ConversationTracker();
+
+    protected CraftConsoleCommandSender() {
+        super();
+    }
+
+    public void sendMessage(String message) {
+        sendRawMessage(message);
+    }
+
+    public void sendRawMessage(String message) {
+        System.out.println(ChatColor.stripColor(message));
+    }
+
+    public void sendMessage(String[] messages) {
+        for (String message : messages) {
+            sendMessage(message);
+        }
+    }
+
+    public String getName() {
+        return "CONSOLE";
+    }
+
+    public boolean isOp() {
+        return true;
+    }
+
+    public void setOp(boolean value) {
+        throw new UnsupportedOperationException("Cannot change operator status of server console");
+    }
+
+    public boolean beginConversation(Conversation conversation) {
+        return conversationTracker.beginConversation(conversation);
+    }
+
+    public void abandonConversation(Conversation conversation) {
+        conversationTracker.abandonConversation(conversation, new ConversationAbandonedEvent(conversation, new ManuallyAbandonedConversationCanceller()));
+    }
+
+    public void abandonConversation(Conversation conversation, ConversationAbandonedEvent details) {
+        conversationTracker.abandonConversation(conversation, details);
+    }
+
+    public void acceptConversationInput(String input) {
+        conversationTracker.acceptConversationInput(input);
+    }
+
+    public boolean isConversing() {
+        return conversationTracker.isConversing();
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.command;
+
+import net.minecraft.network.rcon.RConConsoleSource;
+import org.bukkit.command.RemoteConsoleCommandSender;
+
+public class CraftRemoteConsoleCommandSender extends ServerCommandSender implements RemoteConsoleCommandSender {
+    public CraftRemoteConsoleCommandSender() {
+        super();
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        RConConsoleSource.instance.sendMessage(message + "\n"); // Send a newline after each message, to preserve formatting.
+    }
+
+    @Override
+    public void sendMessage(String[] messages) {
+        for (String message : messages) {
+            sendMessage(message);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "Rcon";
+    }
+
+    @Override
+    public boolean isOp() {
+        return true;
+    }
+
+    @Override
+    public void setOp(boolean value) {
+        throw new UnsupportedOperationException("Cannot change operator status of remote controller.");
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/CraftSimpleCommandMap.java

@@ -0,0 +1,76 @@
+package org.bukkit.craftbukkit.command;
+
+import static org.bukkit.util.Java15Compat.Arrays_copyOfRange;
+
+import java.util.regex.Pattern;
+
+import net.minecraft.command.ICommandSender;
+
+import org.bukkit.Server;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandException;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+
+import cpw.mods.fml.common.FMLCommonHandler;
+
+public class CraftSimpleCommandMap extends SimpleCommandMap {
+
+    private static final Pattern PATTERN_ON_SPACE = Pattern.compile(" ", Pattern.LITERAL);
+    private ICommandSender vanillaConsoleSender; // Cauldron
+
+    public CraftSimpleCommandMap(Server server) {
+        super(server);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean dispatch(CommandSender sender, String commandLine) throws CommandException {
+        String[] args = PATTERN_ON_SPACE.split(commandLine);
+
+        if (args.length == 0) {
+            return false;
+        }
+
+        String sentCommandLabel = args[0].toLowerCase();
+        Command target = getCommand(sentCommandLabel);
+
+        if (target == null) {
+            return false;
+        }
+        try {
+            // Cauldron start - if command is a mod command, check permissions and route through vanilla
+            if (target instanceof ModCustomCommand)
+            {
+                if (!target.testPermission(sender)) return true;
+                if (sender instanceof ConsoleCommandSender)
+                {
+                    FMLCommonHandler.instance().getMinecraftServerInstance().getCommandManager().executeCommand(this.vanillaConsoleSender, commandLine);
+                }
+                else FMLCommonHandler.instance().getMinecraftServerInstance().getCommandManager().executeCommand(((CraftPlayer)sender).getHandle(), commandLine);
+            }
+            else {
+            // Cauldron end
+                // Note: we don't return the result of target.execute as thats success / failure, we return handled (true) or not handled (false)
+                target.execute(sender, sentCommandLabel, Arrays_copyOfRange(args, 1, args.length));
+            }
+        } catch (CommandException ex) {
+            throw ex;
+        } catch (Throwable ex) {
+            throw new CommandException("Unhandled exception executing '" + commandLine + "' in " + target, ex);
+        }
+
+        // return true as command was handled
+        return true;
+    }
+
+    // Cauldron start - sets the vanilla console sender
+    public void setVanillaConsoleSender(ICommandSender console)
+    {
+        this.vanillaConsoleSender = console;
+    }
+    // Cauldron end
+}

src/main/java/org/bukkit/craftbukkit/command/ModCustomCommand.java

@@ -0,0 +1,28 @@
+package org.bukkit.craftbukkit.command;
+
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+
+public class ModCustomCommand extends Command {
+
+    public ModCustomCommand(String name)
+    {
+        super(name);
+    }
+
+    public ModCustomCommand(String name, String description, String usageMessage, List<String> aliases)
+    {
+        super(name, description, usageMessage, aliases);
+    }
+
+    @Override
+    public boolean execute(CommandSender sender, String commandLabel, String[] args) {
+        // Dummy method
+        return false;
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/ServerCommandSender.java

@@ -0,0 +1,71 @@
+package org.bukkit.craftbukkit.command;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+import org.bukkit.command.CommandSender;
+import org.bukkit.permissions.PermissibleBase;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Set;
+
+public abstract class ServerCommandSender implements CommandSender {
+    private final PermissibleBase perm = new PermissibleBase(this);
+
+    public ServerCommandSender() {
+    }
+
+    public boolean isPermissionSet(String name) {
+        return perm.isPermissionSet(name);
+    }
+
+    public boolean isPermissionSet(Permission perm) {
+        return this.perm.isPermissionSet(perm);
+    }
+
+    public boolean hasPermission(String name) {
+        return perm.hasPermission(name);
+    }
+
+    public boolean hasPermission(Permission perm) {
+        return this.perm.hasPermission(perm);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value) {
+        return perm.addAttachment(plugin, name, value);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin) {
+        return perm.addAttachment(plugin);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value, int ticks) {
+        return perm.addAttachment(plugin, name, value, ticks);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin, int ticks) {
+        return perm.addAttachment(plugin, ticks);
+    }
+
+    public void removeAttachment(PermissionAttachment attachment) {
+        perm.removeAttachment(attachment);
+    }
+
+    public void recalculatePermissions() {
+        perm.recalculatePermissions();
+    }
+
+    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
+        return perm.getEffectivePermissions();
+    }
+
+    public boolean isPlayer() {
+        return false;
+    }
+
+    public Server getServer() {
+        return Bukkit.getServer();
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/TicksPerSecondCommand.java

@@ -0,0 +1,34 @@
+package org.bukkit.craftbukkit.command;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+
+public class TicksPerSecondCommand extends Command {
+
+    public TicksPerSecondCommand(String name) {
+        super(name);
+        this.description = "Gets the current ticks per second for the server";
+        this.usageMessage = "/tps";
+        this.setPermission("bukkit.command.tps");
+    }
+
+    @Override
+    public boolean execute(CommandSender sender, String currentAlias, String[] args) {
+        if (!testPermission(sender)) return true;
+
+        double tps = Math.min(20,  Math.round(net.minecraft.server.MinecraftServer.currentTps * 10) / 10.0);
+        ChatColor color;
+        if (tps > 19.2D) {
+            color = ChatColor.GREEN;
+        } else if (tps > 17.4D) {
+            color = ChatColor.YELLOW;
+        } else {
+            color = ChatColor.RED;
+        }
+
+        sender.sendMessage(ChatColor.GOLD + "[TPS] " + color + tps);
+
+        return true;
+    }
+}

src/main/java/org/bukkit/craftbukkit/command/VanillaCommandWrapper.java

@@ -0,0 +1,180 @@
+package org.bukkit.craftbukkit.command;
+
+import java.util.List;
+
+
+import net.minecraft.entity.EntityMinecartCommandBlockListener;
+import net.minecraft.tileentity.TileEntityCommandBlockListener;
+
+import org.apache.commons.lang.Validate;
+import org.apache.logging.log4j.Level;
+import org.bukkit.command.BlockCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
+import org.bukkit.command.defaults.*;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.entity.CraftMinecartCommand;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.minecart.CommandMinecart;
+
+public final class VanillaCommandWrapper extends VanillaCommand {
+    protected final net.minecraft.command.CommandBase vanillaCommand;
+
+    public VanillaCommandWrapper(net.minecraft.command.CommandBase vanillaCommand) {
+        super(vanillaCommand.getCommandName());
+        this.vanillaCommand = vanillaCommand;
+    }
+
+    public VanillaCommandWrapper(net.minecraft.command.CommandBase vanillaCommand, String usage) {
+        super(vanillaCommand.getCommandName());
+        this.vanillaCommand = vanillaCommand;
+        this.description = "A Mojang provided command.";
+        this.usageMessage = usage;
+        this.setPermission("minecraft.command." + vanillaCommand.getCommandName());
+    }
+
+    @Override
+    public boolean execute(CommandSender sender, String commandLabel, String[] args) {
+        if (!testPermission(sender)) return true;
+
+        net.minecraft.command.ICommandSender icommandlistener = getListener(sender);
+        // Some commands use the worldserver variable but we leave it full of null values,
+        // so we must temporarily populate it with the world of the commandsender
+        net.minecraft.world.WorldServer[] prev = net.minecraft.server.MinecraftServer.getServer().worldServers;
+        net.minecraft.server.MinecraftServer.getServer().worldServers = new net.minecraft.world.WorldServer[]{(net.minecraft.world.WorldServer) icommandlistener.getEntityWorld()};
+        try {
+            vanillaCommand.processCommand(icommandlistener, args);
+        } catch (net.minecraft.command.WrongUsageException exceptionusage) {
+            net.minecraft.util.ChatComponentTranslation chatmessage = new net.minecraft.util.ChatComponentTranslation("commands.generic.usage", new Object[] {new net.minecraft.util.ChatComponentTranslation(exceptionusage.getMessage(), exceptionusage.getErrorOjbects())});
+            chatmessage.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+            icommandlistener.addChatMessage(chatmessage);
+        } catch (net.minecraft.command.CommandException commandexception) {
+            net.minecraft.util.ChatComponentTranslation chatmessage = new net.minecraft.util.ChatComponentTranslation(commandexception.getMessage(), commandexception.getErrorOjbects());
+            chatmessage.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+            icommandlistener.addChatMessage(chatmessage);
+        } finally {
+            net.minecraft.server.MinecraftServer.getServer().worldServers = prev;
+        }
+        return true;
+    }
+
+    @Override
+    public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
+        Validate.notNull(sender, "Sender cannot be null");
+        Validate.notNull(args, "Arguments cannot be null");
+        Validate.notNull(alias, "Alias cannot be null");
+        return (List<String>) vanillaCommand.addTabCompletionOptions(getListener(sender), args);
+    }
+
+    public final int dispatchVanillaCommandBlock(net.minecraft.command.server.CommandBlockLogic icommandlistener, String s) {
+        // Copied from net.minecraft.server.CommandHandler
+        s = s.trim();
+        if (s.startsWith("/")) {
+            s = s.substring(1);
+        }
+        String as[] = s.split(" ");
+        as = dropFirstArgument(as);
+        int i = getPlayerListSize(as);
+        int j = 0;
+        // Some commands use the worldserver variable but we leave it full of null values,
+        // so we must temporarily populate it with the world of the commandsender
+        net.minecraft.world.WorldServer[] prev = net.minecraft.server.MinecraftServer.getServer().worldServers;
+        net.minecraft.server.MinecraftServer.getServer().worldServers = new net.minecraft.world.WorldServer[]{(net.minecraft.world.WorldServer) icommandlistener.getEntityWorld()};
+        try {
+            if (vanillaCommand.canCommandSenderUseCommand(icommandlistener)) {
+                if (i > -1) {
+                    net.minecraft.entity.player.EntityPlayerMP aentityplayer[] = net.minecraft.command.PlayerSelector.matchPlayers(icommandlistener, as[i]);
+                    String s2 = as[i];
+                    net.minecraft.entity.player.EntityPlayerMP aentityplayer1[] = aentityplayer;
+                    int k = aentityplayer1.length;
+                    for (int l = 0; l < k;) {
+                        net.minecraft.entity.player.EntityPlayerMP entityplayer = aentityplayer1[l];
+                        as[i] = entityplayer.getCommandSenderName();
+                        try {
+                            vanillaCommand.processCommand(icommandlistener, as);
+                            j++;
+                            continue;
+                        } catch (net.minecraft.command.CommandException commandexception1) {
+                            net.minecraft.util.ChatComponentTranslation chatmessage4 = new net.minecraft.util.ChatComponentTranslation(commandexception1.getMessage(), commandexception1.getErrorOjbects());
+                            chatmessage4.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+                            icommandlistener.addChatMessage(chatmessage4);
+                            l++;
+                        }
+                    }
+
+                    as[i] = s2;
+                } else {
+                    vanillaCommand.processCommand(icommandlistener, as);
+                    j++;
+                }
+            } else {
+                net.minecraft.util.ChatComponentTranslation chatmessage = new net.minecraft.util.ChatComponentTranslation("commands.generic.permission", new Object[0]);
+                chatmessage.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+                icommandlistener.addChatMessage(chatmessage);
+            }
+        } catch (net.minecraft.command.WrongUsageException exceptionusage) {
+            net.minecraft.util.ChatComponentTranslation chatmessage1 = new net.minecraft.util.ChatComponentTranslation("commands.generic.usage", new Object[] { new net.minecraft.util.ChatComponentTranslation(exceptionusage.getMessage(), exceptionusage.getErrorOjbects()) });
+            chatmessage1.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+            icommandlistener.addChatMessage(chatmessage1);
+        } catch (net.minecraft.command.CommandException commandexception) {
+            net.minecraft.util.ChatComponentTranslation chatmessage2 = new net.minecraft.util.ChatComponentTranslation(commandexception.getMessage(), commandexception.getErrorOjbects());
+            chatmessage2.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+            icommandlistener.addChatMessage(chatmessage2);
+        } catch (Throwable throwable) {
+            net.minecraft.util.ChatComponentTranslation chatmessage3 = new net.minecraft.util.ChatComponentTranslation("commands.generic.exception", new Object[0]);
+            chatmessage3.getChatStyle().setColor(net.minecraft.util.EnumChatFormatting.RED);
+            icommandlistener.addChatMessage(chatmessage3);
+            if(icommandlistener instanceof TileEntityCommandBlockListener) {
+                TileEntityCommandBlockListener listener = (TileEntityCommandBlockListener) icommandlistener;
+                net.minecraft.server.MinecraftServer.getLogger().log(Level.WARN, String.format("CommandBlock at (%d,%d,%d) failed to handle command", listener.getPlayerCoordinates().posX, listener.getPlayerCoordinates().posY, listener.getPlayerCoordinates().posZ), throwable);
+            } else if (icommandlistener instanceof EntityMinecartCommandBlockListener) {
+                EntityMinecartCommandBlockListener listener = (EntityMinecartCommandBlockListener) icommandlistener;
+                net.minecraft.server.MinecraftServer.getLogger().log(Level.WARN, String.format("MinecartCommandBlock at (%d,%d,%d) failed to handle command", listener.getPlayerCoordinates().posX, listener.getPlayerCoordinates().posY, listener.getPlayerCoordinates().posZ), throwable);
+            } else {
+                net.minecraft.server.MinecraftServer.getLogger().log(Level.WARN, String.format("Unknown CommandBlock failed to handle command"), throwable);
+            }
+        } finally {
+            net.minecraft.server.MinecraftServer.getServer().worldServers = prev;
+        }
+        return j;
+    }
+
+    private net.minecraft.command.ICommandSender getListener(CommandSender sender) {
+        if (sender instanceof Player) {
+            return ((CraftPlayer) sender).getHandle();
+        }
+        if (sender instanceof BlockCommandSender) {
+            return ((CraftBlockCommandSender) sender).getTileEntity();
+        }
+        if (sender instanceof CommandMinecart) {
+            return ((net.minecraft.entity.EntityMinecartCommandBlock) ((CraftMinecartCommand) sender).getHandle()).func_145822_e();
+        }
+        if (sender instanceof RemoteConsoleCommandSender) {
+            return net.minecraft.network.rcon.RConConsoleSource.instance;
+        }
+        if (sender instanceof ConsoleCommandSender) {
+            return ((CraftServer) sender.getServer()).getServer();
+        }
+        return null;
+    }
+
+    private int getPlayerListSize(String as[]) {
+        for (int i = 0; i < as.length; i++) {
+            if (vanillaCommand.isUsernameIndex(as, i) && net.minecraft.command.PlayerSelector.matchesMultiplePlayers(as[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private String[] dropFirstArgument(String as[]) {
+        String as1[] = new String[as.length - 1];
+        for (int i = 1; i < as.length; i++) {
+            as1[i - 1] = as[i];
+        }
+
+        return as1;
+    }
+}

src/main/java/org/bukkit/craftbukkit/conversations/ConversationTracker.java

@@ -0,0 +1,69 @@
+package org.bukkit.craftbukkit.conversations;
+
+import java.util.LinkedList;
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+import org.bukkit.conversations.Conversation;
+import org.bukkit.conversations.ConversationAbandonedEvent;
+import org.bukkit.conversations.ManuallyAbandonedConversationCanceller;
+
+/**
+ */
+public class ConversationTracker {
+
+    private LinkedList<Conversation> conversationQueue = new LinkedList<Conversation>();
+
+    public synchronized boolean beginConversation(Conversation conversation) {
+        if (!conversationQueue.contains(conversation)) {
+            conversationQueue.addLast(conversation);
+            if (conversationQueue.getFirst() == conversation) {
+                conversation.begin();
+                conversation.outputNextPrompt();
+                return true;
+            }
+        }
+        return true;
+    }
+
+    public synchronized void abandonConversation(Conversation conversation, ConversationAbandonedEvent details) {
+        if (!conversationQueue.isEmpty()) {
+            if (conversationQueue.getFirst() == conversation) {
+                conversation.abandon(details);
+            }
+            if (conversationQueue.contains(conversation)) {
+                conversationQueue.remove(conversation);
+            }
+            if (!conversationQueue.isEmpty()) {
+                conversationQueue.getFirst().outputNextPrompt();
+            }
+        }
+    }
+
+    public synchronized void abandonAllConversations() {
+
+        LinkedList<Conversation> oldQueue = conversationQueue;
+        conversationQueue = new LinkedList<Conversation>();
+        for(Conversation conversation : oldQueue) {
+            try {
+            conversation.abandon(new ConversationAbandonedEvent(conversation, new ManuallyAbandonedConversationCanceller()));
+            } catch (Throwable t) {
+                Bukkit.getLogger().log(Level.SEVERE, "Unexpected exception while abandoning a conversation", t);
+            }
+        }
+    }
+
+    public synchronized void acceptConversationInput(String input) {
+        if (isConversing()) {
+            conversationQueue.getFirst().acceptInput(input);
+        }
+    }
+
+    public synchronized boolean isConversing() {
+        return !conversationQueue.isEmpty();
+    }
+
+    public synchronized boolean isConversingModaly() {
+        return isConversing() && conversationQueue.getFirst().isModal();
+    }
+}

src/main/java/org/bukkit/craftbukkit/enchantments/CraftEnchantment.java

@@ -0,0 +1,188 @@
+package org.bukkit.craftbukkit.enchantments;
+
+import org.apache.commons.lang.StringUtils; // Cauldron
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.enchantments.EnchantmentTarget;
+import org.bukkit.enchantments.EnchantmentWrapper;
+import org.bukkit.inventory.ItemStack;
+
+public class CraftEnchantment extends Enchantment {
+    private final net.minecraft.enchantment.Enchantment target;
+
+    public CraftEnchantment(net.minecraft.enchantment.Enchantment target) {
+        super(target.effectId);
+        this.target = target;
+    }
+
+    @Override
+    public int getMaxLevel() {
+        return target.getMaxLevel();
+    }
+
+    @Override
+    public int getStartLevel() {
+        return target.getMinLevel();
+    }
+
+    @Override
+    public EnchantmentTarget getItemTarget() {
+        switch (target.type) {
+        case all:
+            return EnchantmentTarget.ALL;
+        case armor:
+            return EnchantmentTarget.ARMOR;
+        case armor_feet:
+            return EnchantmentTarget.ARMOR_FEET;
+        case armor_head:
+            return EnchantmentTarget.ARMOR_HEAD;
+        case armor_legs:
+            return EnchantmentTarget.ARMOR_LEGS;
+        case armor_torso:
+            return EnchantmentTarget.ARMOR_TORSO;
+        case digger:
+            return EnchantmentTarget.TOOL;
+        case weapon:
+            return EnchantmentTarget.WEAPON;
+        case bow:
+            return EnchantmentTarget.BOW;
+        case fishing_rod:
+            return EnchantmentTarget.FISHING_ROD;
+        default:
+            return null;
+        }
+    }
+
+    @Override
+    public boolean canEnchantItem(ItemStack item) {
+        return target.canApply(CraftItemStack.asNMSCopy(item));
+    }
+
+    private String generatedName;
+
+    @Override
+    public String getName() {
+        switch (target.effectId) {
+        case 0:
+            return "PROTECTION_ENVIRONMENTAL";
+        case 1:
+            return "PROTECTION_FIRE";
+        case 2:
+            return "PROTECTION_FALL";
+        case 3:
+            return "PROTECTION_EXPLOSIONS";
+        case 4:
+            return "PROTECTION_PROJECTILE";
+        case 5:
+            return "OXYGEN";
+        case 6:
+            return "WATER_WORKER";
+        case 7:
+            return "THORNS";
+        case 16:
+            return "DAMAGE_ALL";
+        case 17:
+            return "DAMAGE_UNDEAD";
+        case 18:
+            return "DAMAGE_ARTHROPODS";
+        case 19:
+            return "KNOCKBACK";
+        case 20:
+            return "FIRE_ASPECT";
+        case 21:
+            return "LOOT_BONUS_MOBS";
+        case 32:
+            return "DIG_SPEED";
+        case 33:
+            return "SILK_TOUCH";
+        case 34:
+            return "DURABILITY";
+        case 35:
+            return "LOOT_BONUS_BLOCKS";
+        case 48:
+            return "ARROW_DAMAGE";
+        case 49:
+            return "ARROW_KNOCKBACK";
+        case 50:
+            return "ARROW_FIRE";
+        case 51:
+            return "ARROW_INFINITE";
+        case 61:
+            return "LUCK";
+        case 62:
+            return "LURE";
+        default:
+            // Cauldron start - generate based on the class name
+            if (generatedName != null) {
+                return generatedName;
+            }
+
+            generatedName = generateName(target);
+            return generatedName;
+            // Cauldron end
+        }
+    }
+
+    // Cauldron start - generate based on the class name
+    private static String generateName(net.minecraft.enchantment.Enchantment target) {
+        String candidate;
+        Class<?> clz = target.getClass();
+        if (clz.getName().startsWith("net.minecraft")) {
+            // Keep pattern for vanilla
+            candidate = "UNKNOWN_ENCHANT_" + target.effectId;
+            return candidate;
+        }
+        candidate = clz.getSimpleName();
+        // Make a nice name when it starts with Enchantment (e.g. EnchantmentSlowFall)
+        if (StringUtils.containsIgnoreCase(candidate, "Enchantment")) {
+            candidate = candidate.replaceFirst("[E|e]nchantment", "");
+            // Add underscores at camelCase humps
+            candidate = candidate.replaceAll("([a-z])([A-Z])", "\1_\2").toUpperCase();
+            candidate = addSuffix(candidate.toUpperCase());
+            return candidate;
+        }
+        // fall back to the FQN if naming pattern is broken
+        candidate = clz.getName();
+        candidate = candidate.replaceAll("([a-z])([A-Z])", "\1_\2");
+        candidate = candidate.replaceAll("\\.", "_");
+        candidate = addSuffix(candidate.toUpperCase());
+        return candidate;
+    }
+
+    private static String addSuffix(String enchName) {
+        if (Enchantment.getByName(enchName) == null) {
+            return enchName;
+        }
+
+        int suffix = 2;
+        while (Enchantment.getByName(enchName + "_" + suffix) != null) {
+            suffix++;
+        }
+        return enchName + "_" + suffix;
+    }
+    // Cauldron end
+
+    public static net.minecraft.enchantment.Enchantment getRaw(Enchantment enchantment) {
+        if (enchantment instanceof EnchantmentWrapper) {
+            enchantment = ((EnchantmentWrapper) enchantment).getEnchantment();
+        }
+
+        if (enchantment instanceof CraftEnchantment) {
+            return ((CraftEnchantment) enchantment).target;
+        }
+
+        return null;
+    }
+
+    @Override
+    public boolean conflictsWith(Enchantment other) {
+        if (other instanceof EnchantmentWrapper) {
+            other = ((EnchantmentWrapper) other).getEnchantment();
+        }
+        if (!(other instanceof CraftEnchantment)) {
+            return false;
+        }
+        CraftEnchantment ench = (CraftEnchantment) other;
+        return !target.canApplyTogether(ench.target);
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/AbstractProjectile.java

@@ -0,0 +1,23 @@
+package org.bukkit.craftbukkit.entity;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Projectile;
+
+public abstract class AbstractProjectile extends CraftEntity implements Projectile {
+
+    private boolean doesBounce;
+
+    public AbstractProjectile(CraftServer server, net.minecraft.entity.Entity entity) {
+        super(server, entity);
+        doesBounce = false;
+    }
+
+    public boolean doesBounce() {
+        return doesBounce;
+    }
+
+    public void setBounce(boolean doesBounce) {
+        this.doesBounce = doesBounce;
+    }
+
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftAgeable.java

@@ -0,0 +1,67 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.EntityAgeable;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Ageable;
+
+public class CraftAgeable extends CraftCreature implements Ageable {
+    public CraftAgeable(CraftServer server, EntityAgeable entity) {
+        super(server, entity);
+    }
+
+    public int getAge() {
+        return getHandle().getGrowingAge();
+    }
+
+    public void setAge(int age) {
+        getHandle().setGrowingAge(age);
+    }
+
+    public void setAgeLock(boolean lock) {
+        getHandle().ageLocked = lock;
+    }
+
+    public boolean getAgeLock() {
+        return getHandle().ageLocked;
+    }
+
+    public void setBaby() {
+        if (isAdult()) {
+            setAge(-24000);
+        }
+    }
+
+    public void setAdult() {
+        if (!isAdult()) {
+            setAge(0);
+        }
+    }
+
+    public boolean isAdult() {
+        return getAge() >= 0;
+    }
+
+
+    public boolean canBreed() {
+        return getAge() == 0;
+    }
+
+    public void setBreed(boolean breed) {
+        if (breed) {
+            setAge(0);
+        } else if (isAdult()) {
+            setAge(6000);
+        }
+    }
+
+    @Override
+    public EntityAgeable getHandle() {
+        return (EntityAgeable) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftAgeable";
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftAmbient.java

@@ -0,0 +1,31 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.passive.EntityAmbientCreature;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Ambient;
+import org.bukkit.entity.EntityType;
+
+public class CraftAmbient extends CraftLivingEntity implements Ambient {
+    public CraftAmbient(CraftServer server, EntityAmbientCreature entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityAmbientCreature getHandle() {
+        return (EntityAmbientCreature) entity;
+    }
+
+    @Override
+    public String toString() {
+        return this.entityName; // Cauldron
+    }
+
+    public EntityType getType() {
+        // Cauldron start
+        EntityType type = EntityType.fromName(this.entityName);
+        if (type != null)
+            return type;
+        else return EntityType.UNKNOWN;
+        // Cauldron end
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftAnimals.java

@@ -0,0 +1,22 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.passive.EntityAnimal;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Animals;
+
+public class CraftAnimals extends CraftAgeable implements Animals {
+
+    public CraftAnimals(CraftServer server, EntityAnimal entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityAnimal getHandle() {
+        return (EntityAnimal) entity;
+    }
+
+    @Override
+    public String toString() {
+        return this.entityName; // Cauldron
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftArrow.java

@@ -0,0 +1,96 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.projectile.EntityArrow;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.projectiles.ProjectileSource;
+
+public class CraftArrow extends AbstractProjectile implements Arrow {
+
+    public CraftArrow(CraftServer server, EntityArrow entity) {
+        super(server, entity);
+    }
+
+    public void setKnockbackStrength(int knockbackStrength) {
+        Validate.isTrue(knockbackStrength >= 0, "Knockback cannot be negative");
+        getHandle().setKnockbackStrength(knockbackStrength);
+    }
+
+    public int getKnockbackStrength() {
+        return getHandle().knockbackStrength;
+    }
+
+    public boolean isCritical() {
+        return getHandle().getIsCritical();
+    }
+
+    public void setCritical(boolean critical) {
+        getHandle().setIsCritical(critical);
+    }
+
+    public ProjectileSource getShooter() {
+        return getHandle().projectileSource;
+    }
+
+    public void setShooter(ProjectileSource shooter) {
+        if (shooter instanceof LivingEntity) {
+            getHandle().shootingEntity = ((CraftLivingEntity) shooter).getHandle();
+        } else {
+            getHandle().shootingEntity = null;
+        }
+        getHandle().projectileSource = shooter;
+    }
+
+    @Override
+    public EntityArrow getHandle() {
+        return (EntityArrow) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftArrow";
+    }
+
+    public EntityType getType() {
+        return EntityType.ARROW;
+    }
+
+    @Deprecated
+    public LivingEntity _INVALID_getShooter() {
+        if (getHandle().shootingEntity == null) {
+            return null;
+        }
+        return (LivingEntity) getHandle().shootingEntity.getBukkitEntity();
+    }
+
+    @Deprecated
+    public void _INVALID_setShooter(LivingEntity shooter) {
+        getHandle().shootingEntity = ((CraftLivingEntity) shooter).getHandle();
+    }
+
+    // Spigot start
+    private final Arrow.Spigot spigot = new Arrow.Spigot()
+    {
+        @Override
+        public double getDamage()
+        {
+            return getHandle().getDamage();
+        }
+
+        @Override
+        public void setDamage(double damage)
+        {
+            getHandle().setDamage( damage );
+        }
+    };
+
+    public Arrow.Spigot spigot()
+    {
+        return spigot;
+    }
+    // Spigot end
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftBat.java

@@ -0,0 +1,36 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.passive.EntityBat;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Bat;
+import org.bukkit.entity.EntityType;
+
+public class CraftBat extends CraftAmbient implements Bat {
+    public CraftBat(CraftServer server, EntityBat entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityBat getHandle() {
+        return (EntityBat) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftBat";
+    }
+
+    public EntityType getType() {
+        return EntityType.BAT;
+    }
+
+    @Override
+    public boolean isAwake() {
+        return !getHandle().getIsBatHanging();
+    }
+
+    @Override
+    public void setAwake(boolean state) {
+        getHandle().setIsBatHanging(!state);
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftBlaze.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityBlaze;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Blaze;
+import org.bukkit.entity.EntityType;
+
+public class CraftBlaze extends CraftMonster implements Blaze {
+    public CraftBlaze(CraftServer server, EntityBlaze entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityBlaze getHandle() {
+        return (EntityBlaze) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftBlaze";
+    }
+
+    public EntityType getType() {
+        return EntityType.BLAZE;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java

@@ -0,0 +1,63 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityBoat;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Boat;
+import org.bukkit.entity.EntityType;
+
+public class CraftBoat extends CraftVehicle implements Boat {
+
+    public CraftBoat(CraftServer server, EntityBoat entity) {
+        super(server, entity);
+    }
+
+    public double getMaxSpeed() {
+        return getHandle().maxSpeed;
+    }
+
+    public void setMaxSpeed(double speed) {
+        if (speed >= 0D) {
+            getHandle().maxSpeed = speed;
+        }
+    }
+
+    public double getOccupiedDeceleration() {
+        return getHandle().occupiedDeceleration;
+    }
+
+    public void setOccupiedDeceleration(double speed) {
+        if (speed >= 0D) {
+            getHandle().occupiedDeceleration = speed;
+        }
+    }
+
+    public double getUnoccupiedDeceleration() {
+        return getHandle().unoccupiedDeceleration;
+    }
+
+    public void setUnoccupiedDeceleration(double speed) {
+        getHandle().unoccupiedDeceleration = speed;
+    }
+
+    public boolean getWorkOnLand() {
+        return getHandle().landBoats;
+    }
+
+    public void setWorkOnLand(boolean workOnLand) {
+        getHandle().landBoats = workOnLand;
+    }
+
+    @Override
+    public EntityBoat getHandle() {
+        return (EntityBoat) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftBoat";
+    }
+
+    public EntityType getType() {
+        return EntityType.BOAT;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftCaveSpider.java

@@ -0,0 +1,27 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityCaveSpider;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.CaveSpider;
+import org.bukkit.entity.EntityType;
+
+public class CraftCaveSpider extends CraftSpider implements CaveSpider {
+    public CraftCaveSpider(CraftServer server, EntityCaveSpider entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityCaveSpider getHandle() {
+        return (EntityCaveSpider) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftCaveSpider";
+    }
+
+    public EntityType getType() {
+        return EntityType.CAVE_SPIDER;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftChicken.java

@@ -0,0 +1,28 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.passive.EntityChicken;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Chicken;
+import org.bukkit.entity.EntityType;
+
+public class CraftChicken extends CraftAnimals implements Chicken {
+
+    public CraftChicken(CraftServer server, EntityChicken entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityChicken getHandle() {
+        return (EntityChicken) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftChicken";
+    }
+
+    public EntityType getType() {
+        return EntityType.CHICKEN;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftComplexLivingEntity.java

@@ -0,0 +1,22 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.EntityLivingBase;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.ComplexLivingEntity;
+
+public abstract class CraftComplexLivingEntity extends CraftLivingEntity implements ComplexLivingEntity {
+    public CraftComplexLivingEntity(CraftServer server, EntityLivingBase entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityLivingBase getHandle() {
+        return (EntityLivingBase) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftComplexLivingEntity";
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftComplexPart.java

@@ -0,0 +1,50 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.boss.EntityDragonPart;
+import net.minecraft.entity.boss.EntityDragon;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.ComplexEntityPart;
+import org.bukkit.entity.ComplexLivingEntity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.entity.EntityDamageEvent;
+
+public class CraftComplexPart extends CraftEntity implements ComplexEntityPart {
+    public CraftComplexPart(CraftServer server, EntityDragonPart entity) {
+        super(server, entity);
+    }
+
+    public ComplexLivingEntity getParent() {
+        // Cauldron start - Fix twilight Hydra crashes
+        org.bukkit.entity.Entity result = getParentEntity();
+        return (result instanceof ComplexLivingEntity) ? (ComplexLivingEntity)result : null;
+    }
+
+    private org.bukkit.entity.Entity getParentEntity() {
+        return ((net.minecraft.entity.Entity)getHandle().entityDragonObj).getBukkitEntity();
+    }
+
+    @Override
+    public void setLastDamageCause(EntityDamageEvent cause) {
+        getParentEntity().setLastDamageCause(cause);
+    }
+
+    @Override
+    public EntityDamageEvent getLastDamageCause() {
+        return getParentEntity().getLastDamageCause();
+        // Cauldron end
+    }
+
+    @Override
+    public EntityDragonPart getHandle() {
+        return (EntityDragonPart) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftComplexPart";
+    }
+
+    public EntityType getType() {
+        return EntityType.COMPLEX_PART;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftCow.java

@@ -0,0 +1,28 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.passive.EntityCow;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Cow;
+import org.bukkit.entity.EntityType;
+
+public class CraftCow extends CraftAnimals implements Cow {
+
+    public CraftCow(CraftServer server, EntityCow entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityCow getHandle() {
+        return (EntityCow) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftCow";
+    }
+
+    public EntityType getType() {
+        return EntityType.COW;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftCreature.java

@@ -0,0 +1,40 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.EntityCreature;
+import net.minecraft.entity.EntityLivingBase;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.LivingEntity;
+
+public class CraftCreature extends CraftLivingEntity implements Creature {
+    public CraftCreature(CraftServer server, EntityCreature entity) {
+        super(server, entity);
+    }
+
+    public void setTarget(LivingEntity target) {
+        EntityCreature entity = getHandle();
+        if (target == null) {
+            entity.entityToAttack = null;
+        } else if (target instanceof CraftLivingEntity) {
+            entity.entityToAttack = ((CraftLivingEntity) target).getHandle();
+            entity.pathToEntity = entity.worldObj.getPathEntityToEntity(entity, entity.entityToAttack, 16.0F, true, false, false, true);
+        }
+    }
+
+    public CraftLivingEntity getTarget() {
+        if (getHandle().entityToAttack == null) return null;
+        if (!(getHandle().entityToAttack instanceof EntityLivingBase)) return null;
+
+        return (CraftLivingEntity) getHandle().entityToAttack.getBukkitEntity();
+    }
+
+    @Override
+    public EntityCreature getHandle() {
+        return (EntityCreature) entity;
+    }
+
+    @Override
+    public String toString() {
+        return this.entityName; // Cauldron
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java

@@ -0,0 +1,54 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityCreeper;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.entity.CreeperPowerEvent;
+
+public class CraftCreeper extends CraftMonster implements Creeper {
+
+    public CraftCreeper(CraftServer server, EntityCreeper entity) {
+        super(server, entity);
+    }
+
+    public boolean isPowered() {
+        return getHandle().getPowered();
+    }
+
+    public void setPowered(boolean powered) {
+        CraftServer server = this.server;
+        Creeper entity = (Creeper) this.getHandle().getBukkitEntity();
+
+        if (powered) {
+            CreeperPowerEvent event = new CreeperPowerEvent(entity, CreeperPowerEvent.PowerCause.SET_ON);
+            server.getPluginManager().callEvent(event);
+
+            if (!event.isCancelled()) {
+                getHandle().setPowered(true);
+            }
+        } else {
+            CreeperPowerEvent event = new CreeperPowerEvent(entity, CreeperPowerEvent.PowerCause.SET_OFF);
+            server.getPluginManager().callEvent(event);
+
+            if (!event.isCancelled()) {
+                getHandle().setPowered(false);
+            }
+        }
+    }
+
+    @Override
+    public EntityCreeper getHandle() {
+        return (EntityCreeper) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftCreeper";
+    }
+
+    public EntityType getType() {
+        return EntityType.CREEPER;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEgg.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.projectile.EntityEgg;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Egg;
+import org.bukkit.entity.EntityType;
+
+public class CraftEgg extends CraftProjectile implements Egg {
+    public CraftEgg(CraftServer server, EntityEgg entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityEgg getHandle() {
+        return (EntityEgg) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEgg";
+    }
+
+    public EntityType getType() {
+        return EntityType.EGG;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEnderCrystal.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityEnderCrystal;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EnderCrystal;
+import org.bukkit.entity.EntityType;
+
+public class CraftEnderCrystal extends CraftEntity implements EnderCrystal {
+    public CraftEnderCrystal(CraftServer server, EntityEnderCrystal entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityEnderCrystal getHandle() {
+        return (EntityEnderCrystal) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEnderCrystal";
+    }
+
+    public EntityType getType() {
+        return EntityType.ENDER_CRYSTAL;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEnderDragon.java

@@ -0,0 +1,44 @@
+package org.bukkit.craftbukkit.entity;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+
+import java.util.Set;
+
+import net.minecraft.entity.boss.EntityDragonPart;
+import net.minecraft.entity.boss.EntityDragon;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.ComplexEntityPart;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.EntityType;
+
+public class CraftEnderDragon extends CraftComplexLivingEntity implements EnderDragon {
+    public CraftEnderDragon(CraftServer server, EntityDragon entity) {
+        super(server, entity);
+    }
+
+    public Set<ComplexEntityPart> getParts() {
+        Builder<ComplexEntityPart> builder = ImmutableSet.builder();
+
+        for (EntityDragonPart part : getHandle().dragonPartArray) {
+            builder.add((ComplexEntityPart) part.getBukkitEntity());
+        }
+
+        return builder.build();
+    }
+
+    @Override
+    public EntityDragon getHandle() {
+        return (EntityDragon) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEnderDragon";
+    }
+
+    public EntityType getType() {
+        return EntityType.ENDER_DRAGON;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEnderDragonPart.java

@@ -0,0 +1,87 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.boss.EntityDragonPart;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.EnderDragonPart;
+import org.bukkit.entity.Entity;
+import org.bukkit.util.NumberConversions;
+
+public class CraftEnderDragonPart extends CraftComplexPart implements EnderDragonPart {
+    public CraftEnderDragonPart(CraftServer server, EntityDragonPart entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EnderDragon getParent() {
+        return (EnderDragon) super.getParent();
+    }
+
+    @Override
+    public EntityDragonPart getHandle() {
+        return (EntityDragonPart) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEnderDragonPart";
+    }
+
+    public void damage(double amount) {
+        getParent().damage(amount);
+    }
+
+    public void damage(double amount, Entity source) {
+        getParent().damage(amount, source);
+    }
+
+    public double getHealth() {
+        return getParent().getHealth();
+    }
+
+    public void setHealth(double health) {
+        getParent().setHealth(health);
+    }
+
+    public double getMaxHealth() {
+        return getParent().getMaxHealth();
+    }
+
+    public void setMaxHealth(double health) {
+        getParent().setMaxHealth(health);
+    }
+
+    public void resetMaxHealth() {
+        getParent().resetMaxHealth();
+    }
+
+    @Deprecated
+    public void _INVALID_damage(int amount) {
+        damage(amount);
+    }
+
+    @Deprecated
+    public void _INVALID_damage(int amount, Entity source) {
+        damage(amount, source);
+    }
+
+    @Deprecated
+    public int _INVALID_getHealth() {
+        return NumberConversions.ceil(getHealth());
+    }
+
+    @Deprecated
+    public void _INVALID_setHealth(int health) {
+        setHealth(health);
+    }
+
+    @Deprecated
+    public int _INVALID_getMaxHealth() {
+        return NumberConversions.ceil(getMaxHealth());
+    }
+
+    @Deprecated
+    public void _INVALID_setMaxHealth(int health) {
+        setMaxHealth(health);
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEnderPearl.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityEnderPearl;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EnderPearl;
+import org.bukkit.entity.EntityType;
+
+public class CraftEnderPearl extends CraftProjectile implements EnderPearl {
+    public CraftEnderPearl(CraftServer server, EntityEnderPearl entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityEnderPearl getHandle() {
+        return (EntityEnderPearl) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEnderPearl";
+    }
+
+    public EntityType getType() {
+        return EntityType.ENDER_PEARL;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEnderSignal.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityEnderEye;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EnderSignal;
+import org.bukkit.entity.EntityType;
+
+public class CraftEnderSignal extends CraftEntity implements EnderSignal {
+    public CraftEnderSignal(CraftServer server, EntityEnderEye entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityEnderEye getHandle() {
+        return (EntityEnderEye) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEnderSignal";
+    }
+
+    public EntityType getType() {
+        return EntityType.ENDER_SIGNAL;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java

@@ -0,0 +1,38 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityEnderman;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.entity.Enderman;
+import org.bukkit.entity.EntityType;
+import org.bukkit.material.MaterialData;
+
+public class CraftEnderman extends CraftMonster implements Enderman {
+    public CraftEnderman(CraftServer server, EntityEnderman entity) {
+        super(server, entity);
+    }
+
+    public MaterialData getCarriedMaterial() {
+        return CraftMagicNumbers.getMaterial(getHandle().func_146080_bZ()).getNewData((byte) getHandle().getCarryingData());
+    }
+
+    public void setCarriedMaterial(MaterialData data) {
+        getHandle().func_146081_a(CraftMagicNumbers.getBlock(data.getItemTypeId()));
+        getHandle().setCarryingData(data.getData());
+    }
+
+    @Override
+    public EntityEnderman getHandle() {
+        return (EntityEnderman) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEnderman";
+    }
+
+    public EntityType getType() {
+        return EntityType.ENDERMAN;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java

@@ -0,0 +1,626 @@
+package org.bukkit.craftbukkit.entity;
+
+import java.util.List;
+import java.util.UUID;
+
+
+import org.bukkit.EntityEffect;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.util.Vector;
+
+// Cauldron start
+import java.util.Map;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.cauldron.entity.CraftCustomEntity;
+import net.minecraftforge.common.DimensionManager;
+import net.minecraftforge.common.util.EnumHelper;
+import net.minecraftforge.common.util.FakePlayerFactory;
+// Cauldron end
+
+public abstract class CraftEntity implements org.bukkit.entity.Entity {
+    protected final CraftServer server;
+    protected net.minecraft.entity.Entity entity;
+    private EntityDamageEvent lastDamageEvent;
+
+    public CraftEntity(final CraftServer server, final net.minecraft.entity.Entity entity) {
+        this.server = server;
+        this.entity = entity;
+    }
+
+    public static CraftEntity getEntity(CraftServer server, net.minecraft.entity.Entity entity) {
+        /**
+         * Order is *EXTREMELY* important -- keep it right! =D
+         */
+        if (entity instanceof net.minecraft.entity.EntityLivingBase) {
+            // Players
+            if (entity instanceof net.minecraft.entity.player.EntityPlayer) {
+                if (entity instanceof net.minecraft.entity.player.EntityPlayerMP) { return new CraftPlayer(server, (net.minecraft.entity.player.EntityPlayerMP) entity); }
+                // Cauldron start - support fake player classes from mods
+                // This case is never hit in vanilla
+                //else { return new CraftHumanEntity(server, (net.minecraft.entity.player.EntityPlayer) entity); }
+                else {
+                    return new CraftPlayer(server, FakePlayerFactory.get(DimensionManager.getWorld(entity.worldObj.provider.dimensionId), ((net.minecraft.entity.player.EntityPlayer) entity).getGameProfile()));
+                }
+                // Cauldron end
+            }
+            else if (entity instanceof net.minecraft.entity.EntityCreature) {
+                // Animals
+                if (entity instanceof net.minecraft.entity.passive.EntityAnimal) {
+                    if (entity instanceof net.minecraft.entity.passive.EntityChicken) { return new CraftChicken(server, (net.minecraft.entity.passive.EntityChicken) entity); }
+                    else if (entity instanceof net.minecraft.entity.passive.EntityCow) {
+                        if (entity instanceof net.minecraft.entity.passive.EntityMooshroom) { return new CraftMushroomCow(server, (net.minecraft.entity.passive.EntityMooshroom) entity); }
+                        else { return new CraftCow(server, (net.minecraft.entity.passive.EntityCow) entity); }
+                    }
+                    else if (entity instanceof net.minecraft.entity.passive.EntityPig) { return new CraftPig(server, (net.minecraft.entity.passive.EntityPig) entity); }
+                    else if (entity instanceof net.minecraft.entity.passive.EntityTameable) {
+                        if (entity instanceof net.minecraft.entity.passive.EntityWolf) { return new CraftWolf(server, (net.minecraft.entity.passive.EntityWolf) entity); }
+                        else if (entity instanceof net.minecraft.entity.passive.EntityOcelot) { return new CraftOcelot(server, (net.minecraft.entity.passive.EntityOcelot) entity); } // Cauldron
+                        else { return new CraftTameableAnimal(server, (net.minecraft.entity.passive.EntityTameable) entity); } // Cauldron
+                    }
+                    else if (entity instanceof net.minecraft.entity.passive.EntitySheep) { return new CraftSheep(server, (net.minecraft.entity.passive.EntitySheep) entity); }
+                    else if (entity instanceof net.minecraft.entity.passive.EntityHorse) { return new CraftHorse(server, (net.minecraft.entity.passive.EntityHorse) entity); }
+                    else { return new CraftAnimals(server, (net.minecraft.entity.passive.EntityAnimal) entity); }
+                }
+                // Monsters
+                else if (entity instanceof net.minecraft.entity.monster.EntityMob) {
+                    if (entity instanceof net.minecraft.entity.monster.EntityZombie) {
+                        if (entity instanceof net.minecraft.entity.monster.EntityPigZombie) { return new CraftPigZombie(server, (net.minecraft.entity.monster.EntityPigZombie) entity); }
+                        else { return new CraftZombie(server, (net.minecraft.entity.monster.EntityZombie) entity); }
+                    }
+                    else if (entity instanceof net.minecraft.entity.monster.EntityCreeper) { return new CraftCreeper(server, (net.minecraft.entity.monster.EntityCreeper) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntityEnderman) { return new CraftEnderman(server, (net.minecraft.entity.monster.EntityEnderman) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntitySilverfish) { return new CraftSilverfish(server, (net.minecraft.entity.monster.EntitySilverfish) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntityGiantZombie) { return new CraftGiant(server, (net.minecraft.entity.monster.EntityGiantZombie) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntitySkeleton) { return new CraftSkeleton(server, (net.minecraft.entity.monster.EntitySkeleton) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntityBlaze) { return new CraftBlaze(server, (net.minecraft.entity.monster.EntityBlaze) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntityWitch) { return new CraftWitch(server, (net.minecraft.entity.monster.EntityWitch) entity); }
+                    else if (entity instanceof net.minecraft.entity.boss.EntityWither) { return new CraftWither(server, (net.minecraft.entity.boss.EntityWither) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntitySpider) {
+                        if (entity instanceof net.minecraft.entity.monster.EntityCaveSpider) { return new CraftCaveSpider(server, (net.minecraft.entity.monster.EntityCaveSpider) entity); }
+                        else { return new CraftSpider(server, (net.minecraft.entity.monster.EntitySpider) entity); }
+                    }
+
+                    else  { return new CraftMonster(server, (net.minecraft.entity.monster.EntityMob) entity); }
+                }
+                // Water Animals
+                else if (entity instanceof net.minecraft.entity.passive.EntityWaterMob) {
+                    if (entity instanceof net.minecraft.entity.passive.EntitySquid) { return new CraftSquid(server, (net.minecraft.entity.passive.EntitySquid) entity); }
+                    else { return new CraftWaterMob(server, (net.minecraft.entity.passive.EntityWaterMob) entity); }
+                }
+                else if (entity instanceof net.minecraft.entity.monster.EntityGolem) {
+                    if (entity instanceof net.minecraft.entity.monster.EntitySnowman) { return new CraftSnowman(server, (net.minecraft.entity.monster.EntitySnowman) entity); }
+                    else if (entity instanceof net.minecraft.entity.monster.EntityIronGolem) { return new CraftIronGolem(server, (net.minecraft.entity.monster.EntityIronGolem) entity); }
+                    else { return new CraftLivingEntity(server, (net.minecraft.entity.EntityLivingBase) entity); } // Cauldron
+                }
+                else if (entity instanceof net.minecraft.entity.passive.EntityVillager) { return new CraftVillager(server, (net.minecraft.entity.passive.EntityVillager) entity); }
+                else { return new CraftCreature(server, (net.minecraft.entity.EntityCreature) entity); }
+            }
+            // Slimes are a special (and broken) case
+            else if (entity instanceof net.minecraft.entity.monster.EntitySlime) {
+                if (entity instanceof net.minecraft.entity.monster.EntityMagmaCube) { return new CraftMagmaCube(server, (net.minecraft.entity.monster.EntityMagmaCube) entity); }
+                else { return new CraftSlime(server, (net.minecraft.entity.monster.EntitySlime) entity); }
+            }
+            // Flying
+            else if (entity instanceof net.minecraft.entity.EntityFlying) {
+                if (entity instanceof net.minecraft.entity.monster.EntityGhast) { return new CraftGhast(server, (net.minecraft.entity.monster.EntityGhast) entity); }
+                else { return new CraftFlying(server, (net.minecraft.entity.EntityFlying) entity); }
+            }
+            else if (entity instanceof net.minecraft.entity.boss.EntityDragon) {
+                return new CraftEnderDragon(server, (net.minecraft.entity.boss.EntityDragon) entity);
+            }
+            // Ambient
+            else if (entity instanceof net.minecraft.entity.passive.EntityAmbientCreature) {
+                if (entity instanceof net.minecraft.entity.passive.EntityBat) { return new CraftBat(server, (net.minecraft.entity.passive.EntityBat) entity); }
+                else { return new CraftAmbient(server, (net.minecraft.entity.passive.EntityAmbientCreature) entity); }
+            }
+            else  { return new CraftLivingEntity(server, (net.minecraft.entity.EntityLivingBase) entity); }
+        }
+        else if (entity instanceof net.minecraft.entity.boss.EntityDragonPart) {
+            net.minecraft.entity.boss.EntityDragonPart part = (net.minecraft.entity.boss.EntityDragonPart) entity;
+            if (part.entityDragonObj instanceof net.minecraft.entity.boss.EntityDragon) { return new CraftEnderDragonPart(server, (net.minecraft.entity.boss.EntityDragonPart) entity); }
+            else { return new CraftComplexPart(server, (net.minecraft.entity.boss.EntityDragonPart) entity); }
+        }
+        else if (entity instanceof net.minecraft.entity.item.EntityXPOrb) { return new CraftExperienceOrb(server, (net.minecraft.entity.item.EntityXPOrb) entity); }
+        else if (entity instanceof net.minecraft.entity.projectile.EntityArrow) { return new CraftArrow(server, (net.minecraft.entity.projectile.EntityArrow) entity); }
+        else if (entity instanceof net.minecraft.entity.item.EntityBoat) { return new CraftBoat(server, (net.minecraft.entity.item.EntityBoat) entity); }
+        else if (entity instanceof net.minecraft.entity.projectile.EntityThrowable) {
+            if (entity instanceof net.minecraft.entity.projectile.EntityEgg) { return new CraftEgg(server, (net.minecraft.entity.projectile.EntityEgg) entity); }
+            else if (entity instanceof net.minecraft.entity.projectile.EntitySnowball) { return new CraftSnowball(server, (net.minecraft.entity.projectile.EntitySnowball) entity); }
+            else if (entity instanceof net.minecraft.entity.projectile.EntityPotion) { return new CraftThrownPotion(server, (net.minecraft.entity.projectile.EntityPotion) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityEnderPearl) { return new CraftEnderPearl(server, (net.minecraft.entity.item.EntityEnderPearl) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityExpBottle) { return new CraftThrownExpBottle(server, (net.minecraft.entity.item.EntityExpBottle) entity); }
+            else { return new CraftProjectile(server, (net.minecraft.entity.projectile.EntityThrowable) entity); } // Cauldron
+        }
+        else if (entity instanceof net.minecraft.entity.item.EntityFallingBlock) { return new CraftFallingSand(server, (net.minecraft.entity.item.EntityFallingBlock) entity); }
+        else if (entity instanceof net.minecraft.entity.projectile.EntityFireball) {
+            if (entity instanceof net.minecraft.entity.projectile.EntitySmallFireball) { return new CraftSmallFireball(server, (net.minecraft.entity.projectile.EntitySmallFireball) entity); }
+            else if (entity instanceof net.minecraft.entity.projectile.EntityLargeFireball) { return new CraftLargeFireball(server, (net.minecraft.entity.projectile.EntityLargeFireball) entity); }
+            else if (entity instanceof net.minecraft.entity.projectile.EntityWitherSkull) { return new CraftWitherSkull(server, (net.minecraft.entity.projectile.EntityWitherSkull) entity); }
+            else { return new CraftFireball(server, (net.minecraft.entity.projectile.EntityFireball) entity); }
+        }
+        else if (entity instanceof net.minecraft.entity.item.EntityEnderEye) { return new CraftEnderSignal(server, (net.minecraft.entity.item.EntityEnderEye) entity); }
+        else if (entity instanceof net.minecraft.entity.item.EntityEnderCrystal) { return new CraftEnderCrystal(server, (net.minecraft.entity.item.EntityEnderCrystal) entity); }
+        else if (entity instanceof net.minecraft.entity.projectile.EntityFishHook) { return new CraftFish(server, (net.minecraft.entity.projectile.EntityFishHook) entity); }
+        else if (entity instanceof net.minecraft.entity.item.EntityItem) { return new CraftItem(server, (net.minecraft.entity.item.EntityItem) entity); }
+        else if (entity instanceof net.minecraft.entity.effect.EntityWeatherEffect) {
+            if (entity instanceof net.minecraft.entity.effect.EntityLightningBolt) { return new CraftLightningStrike(server, (net.minecraft.entity.effect.EntityLightningBolt) entity); }
+            else { return new CraftWeather(server, (net.minecraft.entity.effect.EntityWeatherEffect) entity); }
+        }
+        else if (entity instanceof net.minecraft.entity.item.EntityMinecart) {
+            if (entity instanceof net.minecraft.entity.item.EntityMinecartFurnace) { return new CraftMinecartFurnace(server, (net.minecraft.entity.item.EntityMinecartFurnace) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityMinecartChest) { return new CraftMinecartChest(server, (net.minecraft.entity.item.EntityMinecartChest) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityMinecartTNT) { return new CraftMinecartTNT(server, (net.minecraft.entity.item.EntityMinecartTNT) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityMinecartHopper) { return new CraftMinecartHopper(server, (net.minecraft.entity.item.EntityMinecartHopper) entity); }
+            else if (entity instanceof net.minecraft.entity.ai.EntityMinecartMobSpawner) { return new CraftMinecartMobSpawner(server, (net.minecraft.entity.ai.EntityMinecartMobSpawner) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityMinecartEmpty) { return new CraftMinecartRideable(server, (net.minecraft.entity.item.EntityMinecartEmpty) entity); }
+            else if (entity instanceof net.minecraft.entity.EntityMinecartCommandBlock) { return new CraftMinecartCommand(server, (net.minecraft.entity.EntityMinecartCommandBlock) entity); }
+            else { return new CraftMinecart(server, (net.minecraft.entity.item.EntityMinecart) entity); } // Cauldron - other minecarts (Steve's Carts)
+        } else if (entity instanceof net.minecraft.entity.EntityHanging) {
+            if (entity instanceof net.minecraft.entity.item.EntityPainting) { return new CraftPainting(server, (net.minecraft.entity.item.EntityPainting) entity); }
+            else if (entity instanceof net.minecraft.entity.item.EntityItemFrame) { return new CraftItemFrame(server, (net.minecraft.entity.item.EntityItemFrame) entity); }
+            else if (entity instanceof net.minecraft.entity.EntityLeashKnot) { return new CraftLeash(server, (net.minecraft.entity.EntityLeashKnot) entity); }
+            else { return new CraftHanging(server, (net.minecraft.entity.EntityHanging) entity); }
+        }
+        else if (entity instanceof net.minecraft.entity.item.EntityTNTPrimed) { return new CraftTNTPrimed(server, (net.minecraft.entity.item.EntityTNTPrimed) entity); }
+        else if (entity instanceof net.minecraft.entity.item.EntityFireworkRocket) { return new CraftFirework(server, (net.minecraft.entity.item.EntityFireworkRocket) entity); }
+        // Cauldron - used for custom entities that extend Entity directly
+        else if (entity instanceof net.minecraft.entity.Entity) { return new CraftCustomEntity(server, (net.minecraft.entity.Entity) entity); }
+
+        throw new AssertionError("Unknown entity " + entity == null ? null : entity.getClass() + ": " + entity); // Cauldron - show the entity that caused exception
+    }
+
+    // Cauldron start - copy of getEntity() but operates on classes instead of instances, for EntityRegistry registerBukkitType
+    public static Class<? extends org.bukkit.entity.Entity> getEntityClass(Class<? extends net.minecraft.entity.Entity> nmsClass) {
+        /**
+         * Order is *EXTREMELY* important -- keep it right! =D
+         */
+        // pbpaste|perl -pe's/entity instanceof ([\w.]+)/$1.class.isAssignableFrom(nmsClass)/g'|perl -pe's/return new (\w+)([^;\n]+)/return $1.class/g'
+        if (net.minecraft.entity.EntityLivingBase.class.isAssignableFrom(nmsClass)) {
+            // Players
+            if (net.minecraft.entity.player.EntityPlayer.class.isAssignableFrom(nmsClass)) {
+                if (net.minecraft.entity.player.EntityPlayerMP.class.isAssignableFrom(nmsClass)) { return CraftPlayer.class; }
+                // support fake player classes from mods
+                // This case is never hit in vanilla
+                //else { return CraftHumanEntity.class; }
+                else {
+                    return CraftPlayer.class;
+                }
+            }
+            else if (net.minecraft.entity.EntityCreature.class.isAssignableFrom(nmsClass)) {
+                // Animals
+                if (net.minecraft.entity.passive.EntityAnimal.class.isAssignableFrom(nmsClass)) {
+                    if (net.minecraft.entity.passive.EntityChicken.class.isAssignableFrom(nmsClass)) { return CraftChicken.class; }
+                    else if (net.minecraft.entity.passive.EntityCow.class.isAssignableFrom(nmsClass)) {
+                        if (net.minecraft.entity.passive.EntityMooshroom.class.isAssignableFrom(nmsClass)) { return CraftMushroomCow.class; }
+                        else { return CraftCow.class; }
+                    }
+                    else if (net.minecraft.entity.passive.EntityPig.class.isAssignableFrom(nmsClass)) { return CraftPig.class; }
+                    else if (net.minecraft.entity.passive.EntityTameable.class.isAssignableFrom(nmsClass)) {
+                        if (net.minecraft.entity.passive.EntityWolf.class.isAssignableFrom(nmsClass)) { return CraftWolf.class; }
+                        else if (net.minecraft.entity.passive.EntityOcelot.class.isAssignableFrom(nmsClass)) { return CraftOcelot.class; } // Cauldron
+                        else { return CraftTameableAnimal.class; }
+                    }
+                    else if (net.minecraft.entity.passive.EntitySheep.class.isAssignableFrom(nmsClass)) { return CraftSheep.class; }
+                    else if (net.minecraft.entity.passive.EntityHorse.class.isAssignableFrom(nmsClass)) { return CraftHorse.class; }
+                    else { return CraftAnimals.class; }
+                }
+                // Monsters
+                else if (net.minecraft.entity.monster.EntityMob.class.isAssignableFrom(nmsClass)) {
+                    if (net.minecraft.entity.monster.EntityZombie.class.isAssignableFrom(nmsClass)) {
+                        if (net.minecraft.entity.monster.EntityPigZombie.class.isAssignableFrom(nmsClass)) { return CraftPigZombie.class; }
+                        else { return CraftZombie.class; }
+                    }
+                    else if (net.minecraft.entity.monster.EntityCreeper.class.isAssignableFrom(nmsClass)) { return CraftCreeper.class; }
+                    else if (net.minecraft.entity.monster.EntityEnderman.class.isAssignableFrom(nmsClass)) { return CraftEnderman.class; }
+                    else if (net.minecraft.entity.monster.EntitySilverfish.class.isAssignableFrom(nmsClass)) { return CraftSilverfish.class; }
+                    else if (net.minecraft.entity.monster.EntityGiantZombie.class.isAssignableFrom(nmsClass)) { return CraftGiant.class; }
+                    else if (net.minecraft.entity.monster.EntitySkeleton.class.isAssignableFrom(nmsClass)) { return CraftSkeleton.class; }
+                    else if (net.minecraft.entity.monster.EntityBlaze.class.isAssignableFrom(nmsClass)) { return CraftBlaze.class; }
+                    else if (net.minecraft.entity.monster.EntityWitch.class.isAssignableFrom(nmsClass)) { return CraftWitch.class; }
+                    else if (net.minecraft.entity.boss.EntityWither.class.isAssignableFrom(nmsClass)) { return CraftWither.class; }
+                    else if (net.minecraft.entity.monster.EntitySpider.class.isAssignableFrom(nmsClass)) {
+                        if (net.minecraft.entity.monster.EntityCaveSpider.class.isAssignableFrom(nmsClass)) { return CraftCaveSpider.class; }
+                        else { return CraftSpider.class; }
+                    }
+
+                    else  { return CraftMonster.class; }
+                }
+                // Water Animals
+                else if (net.minecraft.entity.passive.EntityWaterMob.class.isAssignableFrom(nmsClass)) {
+                    if (net.minecraft.entity.passive.EntitySquid.class.isAssignableFrom(nmsClass)) { return CraftSquid.class; }
+                    else { return CraftWaterMob.class; }
+                }
+                else if (net.minecraft.entity.monster.EntityGolem.class.isAssignableFrom(nmsClass)) {
+                    if (net.minecraft.entity.monster.EntitySnowman.class.isAssignableFrom(nmsClass)) { return CraftSnowman.class; }
+                    else if (net.minecraft.entity.monster.EntityIronGolem.class.isAssignableFrom(nmsClass)) { return CraftIronGolem.class; }
+                    else { return CraftLivingEntity.class; }
+                }
+                else if (net.minecraft.entity.passive.EntityVillager.class.isAssignableFrom(nmsClass)) { return CraftVillager.class; }
+                else { return CraftCreature.class; }
+            }
+            // Slimes are a special (and broken) case
+            else if (net.minecraft.entity.monster.EntitySlime.class.isAssignableFrom(nmsClass)) {
+                if (net.minecraft.entity.monster.EntityMagmaCube.class.isAssignableFrom(nmsClass)) { return CraftMagmaCube.class; }
+                else { return CraftSlime.class; }
+            }
+            // Flying
+            else if (net.minecraft.entity.EntityFlying.class.isAssignableFrom(nmsClass)) {
+                if (net.minecraft.entity.monster.EntityGhast.class.isAssignableFrom(nmsClass)) { return CraftGhast.class; }
+                else { return CraftFlying.class; }
+            }
+            else if (net.minecraft.entity.boss.EntityDragon.class.isAssignableFrom(nmsClass)) {
+                return CraftEnderDragon.class;
+            }
+            // Ambient
+            else if (net.minecraft.entity.passive.EntityAmbientCreature.class.isAssignableFrom(nmsClass)) {
+                if (net.minecraft.entity.passive.EntityBat.class.isAssignableFrom(nmsClass)) { return CraftBat.class; }
+                else { return CraftAmbient.class; }
+            }
+            else  { return CraftLivingEntity.class; }
+        }
+        else if (net.minecraft.entity.boss.EntityDragonPart.class.isAssignableFrom(nmsClass)) {
+            /* Cauldron - no instance, best we can say is this is a CraftComplexPart
+            net.minecraft.entity.boss.EntityDragonPart part = (net.minecraft.entity.boss.EntityDragonPart) entity;
+            if (part.entityDragonObj instanceof net.minecraft.entity.boss.EntityDragon) { return CraftEnderDragonPart.class; }
+            else { return CraftComplexPart.class; }
+            */
+            return CraftComplexPart.class;
+        }
+        else if (net.minecraft.entity.item.EntityXPOrb.class.isAssignableFrom(nmsClass)) { return CraftExperienceOrb.class; }
+        else if (net.minecraft.entity.projectile.EntityArrow.class.isAssignableFrom(nmsClass)) { return CraftArrow.class; }
+        else if (net.minecraft.entity.item.EntityBoat.class.isAssignableFrom(nmsClass)) { return CraftBoat.class; }
+        else if (net.minecraft.entity.projectile.EntityThrowable.class.isAssignableFrom(nmsClass)) {
+            if (net.minecraft.entity.projectile.EntityEgg.class.isAssignableFrom(nmsClass)) { return CraftEgg.class; }
+            else if (net.minecraft.entity.projectile.EntitySnowball.class.isAssignableFrom(nmsClass)) { return CraftSnowball.class; }
+            else if (net.minecraft.entity.projectile.EntityPotion.class.isAssignableFrom(nmsClass)) { return CraftThrownPotion.class; }
+            else if (net.minecraft.entity.item.EntityEnderPearl.class.isAssignableFrom(nmsClass)) { return CraftEnderPearl.class; }
+            else if (net.minecraft.entity.item.EntityExpBottle.class.isAssignableFrom(nmsClass)) { return CraftThrownExpBottle.class; }
+            else { return CraftProjectile.class; } // Cauldron
+        }
+        else if (net.minecraft.entity.item.EntityFallingBlock.class.isAssignableFrom(nmsClass)) { return CraftFallingSand.class; }
+        else if (net.minecraft.entity.projectile.EntityFireball.class.isAssignableFrom(nmsClass)) {
+            if (net.minecraft.entity.projectile.EntitySmallFireball.class.isAssignableFrom(nmsClass)) { return CraftSmallFireball.class; }
+            else if (net.minecraft.entity.projectile.EntityLargeFireball.class.isAssignableFrom(nmsClass)) { return CraftLargeFireball.class; }
+            else if (net.minecraft.entity.projectile.EntityWitherSkull.class.isAssignableFrom(nmsClass)) { return CraftWitherSkull.class; }
+            else { return CraftFireball.class; }
+        }
+        else if (net.minecraft.entity.item.EntityEnderEye.class.isAssignableFrom(nmsClass)) { return CraftEnderSignal.class; }
+        else if (net.minecraft.entity.item.EntityEnderCrystal.class.isAssignableFrom(nmsClass)) { return CraftEnderCrystal.class; }
+        else if (net.minecraft.entity.projectile.EntityFishHook.class.isAssignableFrom(nmsClass)) { return CraftFish.class; }
+        else if (net.minecraft.entity.item.EntityItem.class.isAssignableFrom(nmsClass)) { return CraftItem.class; }
+        else if (net.minecraft.entity.effect.EntityWeatherEffect.class.isAssignableFrom(nmsClass)) {
+            if (net.minecraft.entity.effect.EntityLightningBolt.class.isAssignableFrom(nmsClass)) { return CraftLightningStrike.class; }
+            else { return CraftWeather.class; }
+        }
+        else if (net.minecraft.entity.item.EntityMinecart.class.isAssignableFrom(nmsClass)) {
+            if (net.minecraft.entity.item.EntityMinecartFurnace.class.isAssignableFrom(nmsClass)) { return CraftMinecartFurnace.class; }
+            else if (net.minecraft.entity.item.EntityMinecartChest.class.isAssignableFrom(nmsClass)) { return CraftMinecartChest.class; }
+            else if (net.minecraft.entity.item.EntityMinecartTNT.class.isAssignableFrom(nmsClass)) { return CraftMinecartTNT.class; }
+            else if (net.minecraft.entity.item.EntityMinecartHopper.class.isAssignableFrom(nmsClass)) { return CraftMinecartHopper.class; }
+            else if (net.minecraft.entity.ai.EntityMinecartMobSpawner.class.isAssignableFrom(nmsClass)) { return CraftMinecartMobSpawner.class; }
+            else if (net.minecraft.entity.item.EntityMinecartEmpty.class.isAssignableFrom(nmsClass)) { return CraftMinecartRideable.class; }
+            else if (net.minecraft.entity.EntityMinecartCommandBlock.class.isAssignableFrom(nmsClass)) { return CraftMinecartCommand.class; }
+            else { return CraftMinecart.class; } // Cauldron - other minecarts (Steve's Carts)
+        } else if (net.minecraft.entity.EntityHanging.class.isAssignableFrom(nmsClass)) {
+            if (net.minecraft.entity.item.EntityPainting.class.isAssignableFrom(nmsClass)) { return CraftPainting.class; }
+            else if (net.minecraft.entity.item.EntityItemFrame.class.isAssignableFrom(nmsClass)) { return CraftItemFrame.class; }
+            else if (net.minecraft.entity.EntityLeashKnot.class.isAssignableFrom(nmsClass)) { return CraftLeash.class; }
+            else { return CraftHanging.class; }
+        }
+        else if (net.minecraft.entity.item.EntityTNTPrimed.class.isAssignableFrom(nmsClass)) { return CraftTNTPrimed.class; }
+        else if (net.minecraft.entity.item.EntityFireworkRocket.class.isAssignableFrom(nmsClass)) { return CraftFirework.class; }
+        // Cauldron - used for custom entities that extend Entity directly
+        else if (net.minecraft.entity.Entity.class.isAssignableFrom(nmsClass)) { return CraftCustomEntity.class; }
+
+        throw new AssertionError("Unknown entity class " + nmsClass == null ? null : nmsClass); // Cauldron - show the entity that caused exception
+    }
+
+    // add Bukkit wrappers
+    public static void initMappings() {
+        for (Map.Entry<Class<? extends Entity>, String> entry : cpw.mods.fml.common.registry.EntityRegistry.entityTypeMap.entrySet()) {
+            Class<? extends Entity> entityClass = entry.getKey();
+            String entityName = entry.getValue();
+            int entityId = getEntityTypeIDfromClass(entityClass);
+
+            Class<? extends org.bukkit.entity.Entity> bukkitEntityClass = CraftEntity.getEntityClass(entityClass);
+            EnumHelper.addBukkitEntityType(entityName, bukkitEntityClass, entityId, false);
+        }
+    }
+
+    // Lookup entity id from NMS entity class
+    private static int getEntityTypeIDfromClass(Class entityClass) {
+        // check both maps, since mods can add to either
+
+        Map<Class, Integer> classToIDMapping = cpw.mods.fml.relauncher.ReflectionHelper.getPrivateValue(net.minecraft.entity.EntityList.class, null, "field_75624_e", "classToIDMapping");
+        if (classToIDMapping.containsKey(entityClass)) {
+            return classToIDMapping.get(entityClass);
+        }
+
+        Map<Integer, Class> IDtoClassMapping = cpw.mods.fml.relauncher.ReflectionHelper.getPrivateValue(net.minecraft.entity.EntityList.class, null, "field_75623_d", "IDtoClassMapping");
+        for (Map.Entry<Integer, Class> entry : IDtoClassMapping.entrySet()) {
+            int entityId = entry.getKey();
+            Class thisEntityClass = entry.getValue();
+
+            if (thisEntityClass.getName().equals(entityClass.getName())) {
+                return entityId;
+            }
+        }
+
+        // if there is no entity ID, choose a negative integer based on the class name
+        return -Math.abs(entityClass.getName().hashCode()^(entityClass.getName().hashCode()>>>16));
+    }
+    // Cauldron end
+
+    public Location getLocation() {
+        return new Location(getWorld(), entity.posX, entity.posY, entity.posZ, entity.rotationYaw, entity.rotationPitch);
+    }
+
+    public Location getLocation(Location loc) {
+        if (loc != null) {
+            loc.setWorld(getWorld());
+            loc.setX(entity.posX);
+            loc.setY(entity.posY);
+            loc.setZ(entity.posZ);
+            loc.setYaw(entity.rotationYaw);
+            loc.setPitch(entity.rotationPitch);
+        }
+
+        return loc;
+    }
+
+    public Vector getVelocity() {
+        return new Vector(entity.motionX, entity.motionY, entity.motionZ);
+    }
+
+    public void setVelocity(Vector vel) {
+        entity.motionX = vel.getX();
+        entity.motionY = vel.getY();
+        entity.motionZ = vel.getZ();
+        entity.velocityChanged = true;
+    }
+
+    public boolean isOnGround() {
+        if (entity instanceof net.minecraft.entity.projectile.EntityArrow) {
+            return ((net.minecraft.entity.projectile.EntityArrow) entity).isInGround();
+        }
+        return entity.onGround;
+    }
+
+    public World getWorld() {
+        // Cauldron start - fixes MFR proxy worlds used with grinder/slaughterhouse
+        if (entity.worldObj.getWorld() == null)
+        {
+            return DimensionManager.getWorld(0).getWorld();
+        }
+        // Cauldron end
+        return entity.worldObj.getWorld();
+    }
+
+    public boolean teleport(Location location) {
+        return teleport(location, TeleportCause.PLUGIN);
+    }
+
+    public boolean teleport(Location location, TeleportCause cause) {
+        if (entity.ridingEntity != null || entity.riddenByEntity != null || entity.isDead) {
+            return false;
+        }
+
+        entity.worldObj = ((CraftWorld) location.getWorld()).getHandle();
+        entity.setPositionAndRotation(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
+        // entity.setLocation() throws no event, and so cannot be cancelled
+        return true;
+    }
+
+    public boolean teleport(org.bukkit.entity.Entity destination) {
+        return teleport(destination.getLocation());
+    }
+
+    public boolean teleport(org.bukkit.entity.Entity destination, TeleportCause cause) {
+        return teleport(destination.getLocation(), cause);
+    }
+
+    public List<org.bukkit.entity.Entity> getNearbyEntities(double x, double y, double z) {
+        @SuppressWarnings("unchecked")
+        List<net.minecraft.entity.Entity> notchEntityList = entity.worldObj.getEntitiesWithinAABBExcludingEntity(entity, entity.boundingBox.expand(x, y, z));
+        List<org.bukkit.entity.Entity> bukkitEntityList = new java.util.ArrayList<org.bukkit.entity.Entity>(notchEntityList.size());
+
+        for (net.minecraft.entity.Entity e : notchEntityList) {
+            bukkitEntityList.add(e.getBukkitEntity());
+        }
+        return bukkitEntityList;
+    }
+
+    public int getEntityId() {
+        return entity.getEntityId();
+    }
+
+    public int getFireTicks() {
+        return entity.fire;
+    }
+
+    public int getMaxFireTicks() {
+        return entity.fireResistance;
+    }
+
+    public void setFireTicks(int ticks) {
+        entity.fire = ticks;
+    }
+
+    public void remove() {
+        entity.isDead = true;
+    }
+
+    public boolean isDead() {
+        return !entity.isEntityAlive();
+    }
+
+    public boolean isValid() {
+        return entity.isEntityAlive() && entity.valid;
+    }
+
+    public Server getServer() {
+        return server;
+    }
+
+    public Vector getMomentum() {
+        return getVelocity();
+    }
+
+    public void setMomentum(Vector value) {
+        setVelocity(value);
+    }
+
+    public org.bukkit.entity.Entity getPassenger() {
+        return isEmpty() ? null : getHandle().riddenByEntity.getBukkitEntity();
+    }
+
+    public boolean setPassenger(org.bukkit.entity.Entity passenger) {
+        if (passenger instanceof CraftEntity) {
+            ((CraftEntity) passenger).getHandle().setPassengerOf(getHandle());
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean isEmpty() {
+        return getHandle().riddenByEntity == null;
+    }
+
+    public boolean eject() {
+        if (getHandle().riddenByEntity == null) {
+            return false;
+        }
+
+        getHandle().riddenByEntity.setPassengerOf(null);
+        return true;
+    }
+
+    public float getFallDistance() {
+        return getHandle().fallDistance;
+    }
+
+    public void setFallDistance(float distance) {
+        getHandle().fallDistance = distance;
+    }
+
+    public void setLastDamageCause(EntityDamageEvent event) {
+        lastDamageEvent = event;
+    }
+
+    public EntityDamageEvent getLastDamageCause() {
+        return lastDamageEvent;
+    }
+
+    public UUID getUniqueId() {
+        return getHandle().entityUniqueID;
+    }
+
+    public int getTicksLived() {
+        return getHandle().ticksExisted;
+    }
+
+    public void setTicksLived(int value) {
+        if (value <= 0) {
+            throw new IllegalArgumentException("Age must be at least 1 tick");
+        }
+        getHandle().ticksExisted = value;
+    }
+
+    public net.minecraft.entity.Entity getHandle() {
+        return entity;
+    }
+
+    public void playEffect(EntityEffect type) {
+        this.getHandle().worldObj.setEntityState(getHandle(), type.getData());
+    }
+
+    public void setHandle(final net.minecraft.entity.Entity entity) {
+        this.entity = entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftEntity{" + "id=" + getEntityId() + '}';
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final CraftEntity other = (CraftEntity) obj;
+        return (this.getEntityId() == other.getEntityId());
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 29 * hash + this.getEntityId();
+        return hash;
+    }
+
+    public void setMetadata(String metadataKey, MetadataValue newMetadataValue) {
+        server.getEntityMetadata().setMetadata(this, metadataKey, newMetadataValue);
+    }
+
+    public List<MetadataValue> getMetadata(String metadataKey) {
+        return server.getEntityMetadata().getMetadata(this, metadataKey);
+    }
+
+    public boolean hasMetadata(String metadataKey) {
+        return server.getEntityMetadata().hasMetadata(this, metadataKey);
+    }
+
+    public void removeMetadata(String metadataKey, Plugin owningPlugin) {
+        server.getEntityMetadata().removeMetadata(this, metadataKey, owningPlugin);
+    }
+
+    public boolean isInsideVehicle() {
+        return getHandle().ridingEntity != null;
+    }
+
+    public boolean leaveVehicle() {
+        if (getHandle().ridingEntity == null) {
+            return false;
+        }
+
+        getHandle().setPassengerOf(null);
+        return true;
+    }
+
+    public org.bukkit.entity.Entity getVehicle() {
+        if (getHandle().ridingEntity == null) {
+            return null;
+        }
+
+        return getHandle().ridingEntity.getBukkitEntity();
+    }
+
+    // Spigot start
+    private final Spigot spigot = new Spigot()
+    {
+        @Override
+        public boolean isInvulnerable()
+        {
+            return getHandle().isEntityInvulnerable();
+        }
+    };
+
+    public Spigot spigot()
+    {
+        return spigot;
+    }
+    // Spigot end
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java

@@ -0,0 +1,34 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityXPOrb;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.ExperienceOrb;
+
+public class CraftExperienceOrb extends CraftEntity implements ExperienceOrb {
+    public CraftExperienceOrb(CraftServer server, EntityXPOrb entity) {
+        super(server, entity);
+    }
+
+    public int getExperience() {
+        return getHandle().xpValue;
+    }
+
+    public void setExperience(int value) {
+        getHandle().xpValue = value;
+    }
+
+    @Override
+    public EntityXPOrb getHandle() {
+        return (EntityXPOrb) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftExperienceOrb";
+    }
+
+    public EntityType getType() {
+        return EntityType.EXPERIENCE_ORB;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftFallingSand.java

@@ -0,0 +1,50 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityFallingBlock;
+
+import org.bukkit.Material;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.FallingSand;
+
+public class CraftFallingSand extends CraftEntity implements FallingSand {
+
+    public CraftFallingSand(CraftServer server, net.minecraft.entity.item.EntityFallingBlock entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityFallingBlock getHandle() {
+        return (EntityFallingBlock) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftFallingSand";
+    }
+
+    public EntityType getType() {
+        return EntityType.FALLING_BLOCK;
+    }
+
+    public Material getMaterial() {
+        return Material.getMaterial(getBlockId());
+    }
+
+    public int getBlockId() {
+        return CraftMagicNumbers.getId(getHandle().field_145811_e);
+    }
+
+    public byte getBlockData() {
+        return (byte) getHandle().field_145814_a;
+    }
+
+    public boolean getDropItem() {
+        return getHandle().field_145813_c;
+    }
+
+    public void setDropItem(boolean drop) {
+        getHandle().field_145813_c = drop;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftFireball.java

@@ -0,0 +1,89 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.projectile.EntityFireball;
+import net.minecraft.util.MathHelper;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Fireball;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.projectiles.ProjectileSource;
+import org.bukkit.util.Vector;
+
+public class CraftFireball extends AbstractProjectile implements Fireball {
+    public CraftFireball(CraftServer server, EntityFireball entity) {
+        super(server, entity);
+    }
+
+    public float getYield() {
+        return getHandle().bukkitYield;
+    }
+
+    public boolean isIncendiary() {
+        return getHandle().isIncendiary;
+    }
+
+    public void setIsIncendiary(boolean isIncendiary) {
+        getHandle().isIncendiary = isIncendiary;
+    }
+
+    public void setYield(float yield) {
+        getHandle().bukkitYield = yield;
+    }
+
+    public ProjectileSource getShooter() {
+        return getHandle().projectileSource;
+    }
+
+    public void setShooter(ProjectileSource shooter) {
+        if (shooter instanceof CraftLivingEntity) {
+            getHandle().shootingEntity = ((CraftLivingEntity) shooter).getHandle();
+        } else {
+            getHandle().shootingEntity = null;
+        }
+        getHandle().projectileSource = shooter;
+    }
+
+    public Vector getDirection() {
+        return new Vector(getHandle().accelerationX, getHandle().accelerationY, getHandle().accelerationZ);
+    }
+
+    public void setDirection(Vector direction) {
+        Validate.notNull(direction, "Direction can not be null");
+        double x = direction.getX();
+        double y = direction.getY();
+        double z = direction.getZ();
+        double magnitude = (double) MathHelper.sqrt_double(x * x + y * y + z * z);
+        getHandle().accelerationX = x / magnitude;
+        getHandle().accelerationY = y / magnitude;
+        getHandle().accelerationZ = z / magnitude;
+    }
+
+    @Override
+    public EntityFireball getHandle() {
+        return (EntityFireball) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftFireball";
+    }
+
+    public EntityType getType() {
+        return EntityType.UNKNOWN;
+    }
+
+    @Deprecated
+    public void _INVALID_setShooter(LivingEntity shooter) {
+        setShooter(shooter);
+    }
+
+    @Deprecated
+    public LivingEntity _INVALID_getShooter() {
+        if (getHandle().shootingEntity != null) {
+            return (LivingEntity) getHandle().shootingEntity.getBukkitEntity();
+        }
+        return null;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java

@@ -0,0 +1,74 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.item.EntityFireworkRocket;
+import net.minecraft.item.ItemStack;
+import net.minecraft.init.Items;
+
+import org.bukkit.Material;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Firework;
+import org.bukkit.inventory.meta.FireworkMeta;
+
+import java.util.Random;
+
+public class CraftFirework extends CraftEntity implements Firework {
+    private static final int FIREWORK_ITEM_INDEX = 8;
+
+    private final Random random = new Random();
+    private final CraftItemStack item;
+
+    public CraftFirework(CraftServer server, EntityFireworkRocket entity) {
+        super(server, entity);
+
+        ItemStack item = getHandle().getDataWatcher().getWatchableObjectItemStack(FIREWORK_ITEM_INDEX);
+
+        if (item == null) {
+            item = new ItemStack(Items.fireworks);
+            getHandle().getDataWatcher().updateObject(FIREWORK_ITEM_INDEX, item);
+        }
+
+        this.item = CraftItemStack.asCraftMirror(item);
+
+        // Ensure the item is a firework...
+        if (this.item.getType() != Material.FIREWORK) {
+            this.item.setType(Material.FIREWORK);
+        }
+    }
+
+    @Override
+    public EntityFireworkRocket getHandle() {
+        return (EntityFireworkRocket) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftFirework";
+    }
+
+    @Override
+    public EntityType getType() {
+        return EntityType.FIREWORK;
+    }
+
+    @Override
+    public FireworkMeta getFireworkMeta() {
+        return (FireworkMeta) item.getItemMeta();
+    }
+
+    @Override
+    public void setFireworkMeta(FireworkMeta meta) {
+        item.setItemMeta(meta);
+
+        // Copied from EntityFireworks constructor, update firework lifetime/power
+        getHandle().lifetime = 10 * (1 + meta.getPower()) + random.nextInt(6) + random.nextInt(7);
+
+        getHandle().getDataWatcher().setObjectWatched(FIREWORK_ITEM_INDEX); // Update
+    }
+
+    @Override
+    public void detonate() {
+        getHandle().lifetime = 0;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftFish.java

@@ -0,0 +1,75 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.projectile.EntityFishHook;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.MathHelper;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Fish;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.projectiles.ProjectileSource;
+
+public class CraftFish extends AbstractProjectile implements Fish {
+    private double biteChance = -1;
+
+    public CraftFish(CraftServer server, EntityFishHook entity) {
+        super(server, entity);
+    }
+
+    public ProjectileSource getShooter() {
+        if (getHandle().field_146042_b != null) {
+            return getHandle().field_146042_b.getBukkitEntity();
+        }
+
+        return null;
+    }
+
+    public void setShooter(ProjectileSource shooter) {
+        if (shooter instanceof CraftHumanEntity) {
+            getHandle().field_146042_b = (EntityPlayer) ((CraftHumanEntity) shooter).entity;
+        }
+    }
+
+    @Override
+    public EntityFishHook getHandle() {
+        return (EntityFishHook) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftFish";
+    }
+
+    public EntityType getType() {
+        return EntityType.FISHING_HOOK;
+    }
+
+    public double getBiteChance() {
+        EntityFishHook hook = getHandle();
+
+        if (this.biteChance == -1) {
+            if (hook.worldObj.canLightningStrikeAt(MathHelper.floor_double(hook.posX), net.minecraft.util.MathHelper.floor_double(hook.posY) + 1, net.minecraft.util.MathHelper.floor_double(hook.posZ))) {
+                return 1/300.0;
+            }
+            return 1/500.0;
+        }
+        return this.biteChance;
+    }
+
+    public void setBiteChance(double chance) {
+        Validate.isTrue(chance >= 0 && chance <= 1, "The bite chance must be between 0 and 1.");
+        this.biteChance = chance;
+    }
+
+    @Deprecated
+    public LivingEntity _INVALID_getShooter() {
+        return (LivingEntity) getShooter();
+    }
+
+    @Deprecated
+    public void _INVALID_setShooter(LivingEntity shooter) {
+        setShooter(shooter);
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftFlying.java

@@ -0,0 +1,22 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.EntityFlying;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Flying;
+
+public class CraftFlying extends CraftLivingEntity implements Flying {
+
+    public CraftFlying(CraftServer server, EntityFlying entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityFlying getHandle() {
+        return (EntityFlying) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftFlying";
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftGhast.java

@@ -0,0 +1,28 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityGhast;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Ghast;
+
+public class CraftGhast extends CraftFlying implements Ghast {
+
+    public CraftGhast(CraftServer server, net.minecraft.entity.monster.EntityGhast entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityGhast getHandle() {
+        return (EntityGhast) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftGhast";
+    }
+
+    public EntityType getType() {
+        return EntityType.GHAST;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftGiant.java

@@ -0,0 +1,28 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityGiantZombie;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Giant;
+
+public class CraftGiant extends CraftMonster implements Giant {
+
+    public CraftGiant(CraftServer server, EntityGiantZombie entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityGiantZombie getHandle() {
+        return (EntityGiantZombie) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftGiant";
+    }
+
+    public EntityType getType() {
+        return EntityType.GIANT;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftGolem.java

@@ -0,0 +1,21 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.monster.EntityGolem;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Golem;
+
+public class CraftGolem extends CraftCreature implements Golem {
+    public CraftGolem(CraftServer server, EntityGolem entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityGolem getHandle() {
+        return (EntityGolem) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftGolem";
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftHanging.java

@@ -0,0 +1,82 @@
+package org.bukkit.craftbukkit.entity;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Hanging;
+
+public class CraftHanging extends CraftEntity implements Hanging {
+    public CraftHanging(CraftServer server, net.minecraft.entity.EntityHanging entity) {
+        super(server, entity);
+    }
+
+    public BlockFace getAttachedFace() {
+        return getFacing().getOppositeFace();
+    }
+
+    public void setFacingDirection(BlockFace face) {
+        setFacingDirection(face, false);
+    }
+
+    public boolean setFacingDirection(BlockFace face, boolean force) {
+        Block block = getLocation().getBlock().getRelative(getAttachedFace()).getRelative(face.getOppositeFace()).getRelative(getFacing());
+        net.minecraft.entity.EntityHanging hanging = getHandle();
+        int x = hanging.field_146063_b, y = hanging.field_146064_c, z = hanging.field_146062_d, dir = hanging.hangingDirection;
+        hanging.field_146063_b = block.getX();
+        hanging.field_146064_c = block.getY();
+        hanging.field_146062_d = block.getZ();
+        switch (face) {
+            case SOUTH:
+            default:
+                getHandle().setDirection(0);
+                break;
+            case WEST:
+                getHandle().setDirection(1);
+                break;
+            case NORTH:
+                getHandle().setDirection(2);
+                break;
+            case EAST:
+                getHandle().setDirection(3);
+                break;
+        }
+        if (!force && !hanging.onValidSurface()) {
+            // Revert since it doesn't fit
+            hanging.field_146063_b = x;
+            hanging.field_146064_c = y;
+            hanging.field_146062_d = z;
+            hanging.setDirection(dir);
+            return false;
+        }
+        return true;
+    }
+
+    public BlockFace getFacing() {
+        switch (this.getHandle().hangingDirection) {
+            case 0:
+            default:
+                return BlockFace.SOUTH;
+            case 1:
+                return BlockFace.WEST;
+            case 2:
+                return BlockFace.NORTH;
+            case 3:
+                return BlockFace.EAST;
+        }
+    }
+
+    @Override
+    public net.minecraft.entity.EntityHanging getHandle() {
+        return (net.minecraft.entity.EntityHanging) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftHanging";
+    }
+
+    public EntityType getType() {
+        return EntityType.UNKNOWN;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftHorse.java

@@ -0,0 +1,146 @@
+package org.bukkit.craftbukkit.entity;
+
+import net.minecraft.entity.passive.EntityHorse;
+import org.apache.commons.lang.Validate;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.inventory.CraftInventoryHorse;
+import org.bukkit.entity.AnimalTamer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.bukkit.inventory.HorseInventory;
+
+import java.util.UUID;
+
+public class CraftHorse extends CraftAnimals implements Horse {
+
+    public CraftHorse(CraftServer server, EntityHorse entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public EntityHorse getHandle() {
+        return (EntityHorse) entity;
+    }
+
+    public Variant getVariant() {
+        return Variant.values()[getHandle().getHorseType()];
+    }
+
+    public void setVariant(Variant variant) {
+        Validate.notNull(variant, "Variant cannot be null");
+        getHandle().setHorseType(variant.ordinal());
+    }
+
+    public Color getColor() {
+        return Color.values()[getHandle().getHorseVariant() & 0xFF];
+    }
+
+    public void setColor(Color color) {
+        Validate.notNull(color, "Color cannot be null");
+        getHandle().setHorseVariant(color.ordinal() & 0xFF | getStyle().ordinal() << 8);
+    }
+
+    public Style getStyle() {
+        return Style.values()[getHandle().getHorseVariant() >>> 8];
+    }
+
+    public void setStyle(Style style) {
+        Validate.notNull(style, "Style cannot be null");
+        getHandle().setHorseVariant(getColor().ordinal() & 0xFF | style.ordinal() << 8);
+    }
+
+    public boolean isCarryingChest() {
+        return getHandle().isChested();
+    }
+
+    public void setCarryingChest(boolean chest) {
+        if (chest == isCarryingChest()) return;
+        getHandle().setChested(chest);
+        getHandle().func_110226_cD();
+    }
+
+    public int getDomestication() {
+        return getHandle().getTemper();
+    }
+
+    public void setDomestication(int value) {
+        Validate.isTrue(value >= 0, "Domestication cannot be less than zero");
+        Validate.isTrue(value <= getMaxDomestication(), "Domestication cannot be greater than the max domestication");
+        getHandle().setTemper(value);
+    }
+
+    public int getMaxDomestication() {
+        return getHandle().getMaxTemper();
+    }
+
+    public void setMaxDomestication(int value) {
+        Validate.isTrue(value > 0, "Max domestication cannot be zero or less");
+        getHandle().maxDomestication = value;
+    }
+
+    public double getJumpStrength() {
+        return getHandle().getHorseJumpStrength();
+    }
+
+    public void setJumpStrength(double strength) {
+        Validate.isTrue(strength >= 0, "Jump strength cannot be less than zero");
+        getHandle().getEntityAttribute(EntityHorse.horseJumpStrength).setBaseValue(strength);
+    }
+
+    @Override
+    public boolean isTamed() {
+        return getHandle().isTame();
+    }
+
+    @Override
+    public void setTamed(boolean tamed) {
+        getHandle().setHorseTamed(tamed);
+    }
+
+    @Override
+    public AnimalTamer getOwner() {
+        if (getOwnerUUID() == null) return null;
+        return getServer().getOfflinePlayer(getOwnerUUID());
+    }
+
+    @Override
+    public void setOwner(AnimalTamer owner) {
+        if (owner != null) {
+            setTamed(true);
+            getHandle().setPathToEntity(null);
+            setOwnerUUID(owner.getUniqueId());
+        } else {
+            setTamed(false);
+            setOwnerUUID(null);
+        }
+    }
+
+    public UUID getOwnerUUID() {
+        try {
+            return UUID.fromString(getHandle().func_152119_ch());
+        } catch (IllegalArgumentException ex) {
+            return null;
+        }
+    }
+
+    public void setOwnerUUID(UUID uuid) {
+        if (uuid == null) {
+            getHandle().func_152120_b("");
+        } else {
+            getHandle().func_152120_b(uuid.toString());
+        }
+    }
+
+    public HorseInventory getInventory() {
+        return new CraftInventoryHorse(getHandle().horseChest);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftHorse{variant=" + getVariant() + ", owner=" + getOwner() + '}';
+    }
+
+    public EntityType getType() {
+        return EntityType.HORSE;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java

@@ -0,0 +1,327 @@
+package org.bukkit.craftbukkit.entity;
+
+import java.util.Set;
+
+
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.block.Block;
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+import org.bukkit.craftbukkit.inventory.CraftContainer;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.craftbukkit.inventory.CraftInventoryPlayer;
+import org.bukkit.craftbukkit.inventory.CraftInventoryView;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.permissions.PermissibleBase;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+
+public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+    private CraftInventoryPlayer inventory;
+    private final CraftInventory enderChest;
+    protected final PermissibleBase perm = new PermissibleBase(this);
+    private boolean op;
+    private GameMode mode;
+
+    public CraftHumanEntity(final CraftServer server, final net.minecraft.entity.player.EntityPlayer entity) {
+        super(server, entity);
+        mode = server.getDefaultGameMode();
+        this.inventory = new CraftInventoryPlayer(entity.inventory);
+        enderChest = new CraftInventory(entity.getInventoryEnderChest());
+    }
+
+    public String getName() {
+        return getHandle().getCommandSenderName();
+    }
+
+    public PlayerInventory getInventory() {
+        return inventory;
+    }
+
+    public EntityEquipment getEquipment() {
+        return inventory;
+    }
+
+    public Inventory getEnderChest() {
+        return enderChest;
+    }
+
+    public ItemStack getItemInHand() {
+        return getInventory().getItemInHand();
+    }
+
+    public void setItemInHand(ItemStack item) {
+        getInventory().setItemInHand(item);
+    }
+
+    public ItemStack getItemOnCursor() {
+        return CraftItemStack.asCraftMirror(getHandle().inventory.getItemStack());
+    }
+
+    public void setItemOnCursor(ItemStack item) {
+        net.minecraft.item.ItemStack stack = CraftItemStack.asNMSCopy(item);
+        getHandle().inventory.setItemStack(stack);
+        if (this instanceof CraftPlayer) {
+            ((net.minecraft.entity.player.EntityPlayerMP) getHandle()).updateHeldItem(); // Send set slot for cursor
+        }
+    }
+
+    public boolean isSleeping() {
+        return getHandle().sleeping;
+    }
+
+    public int getSleepTicks() {
+        return getHandle().sleepTimer;
+    }
+
+    public boolean isOp() {
+        return op;
+    }
+
+    public boolean isPermissionSet(String name) {
+        return perm.isPermissionSet(name);
+    }
+
+    public boolean isPermissionSet(Permission perm) {
+        return this.perm.isPermissionSet(perm);
+    }
+
+    public boolean hasPermission(String name) {
+        return perm.hasPermission(name);
+    }
+
+    public boolean hasPermission(Permission perm) {
+        return this.perm.hasPermission(perm);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value) {
+        return perm.addAttachment(plugin, name, value);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin) {
+        return perm.addAttachment(plugin);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value, int ticks) {
+        return perm.addAttachment(plugin, name, value, ticks);
+    }
+
+    public PermissionAttachment addAttachment(Plugin plugin, int ticks) {
+        return perm.addAttachment(plugin, ticks);
+    }
+
+    public void removeAttachment(PermissionAttachment attachment) {
+        perm.removeAttachment(attachment);
+    }
+
+    public void recalculatePermissions() {
+        perm.recalculatePermissions();
+    }
+
+    public void setOp(boolean value) {
+        this.op = value;
+        perm.recalculatePermissions();
+    }
+
+    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
+        return perm.getEffectivePermissions();
+    }
+
+    public GameMode getGameMode() {
+        return mode;
+    }
+
+    public void setGameMode(GameMode mode) {
+        if (mode == null) {
+            throw new IllegalArgumentException("Mode cannot be null");
+        }
+
+        this.mode = mode;
+    }
+
+    @Override
+    public net.minecraft.entity.player.EntityPlayer getHandle() {
+        return (net.minecraft.entity.player.EntityPlayer) entity;
+    }
+
+    public void setHandle(final net.minecraft.entity.player.EntityPlayer entity) {
+        super.setHandle(entity);
+        this.inventory = new CraftInventoryPlayer(entity.inventory);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftHumanEntity{" + "id=" + getEntityId() + "name=" + getName() + '}';
+    }
+
+    public InventoryView getOpenInventory() {
+        return getHandle().openContainer.getBukkitView();
+    }
+
+    public InventoryView openInventory(Inventory inventory) {
+        if(!(getHandle() instanceof net.minecraft.entity.player.EntityPlayerMP)) return null;
+        net.minecraft.entity.player.EntityPlayerMP player = (net.minecraft.entity.player.EntityPlayerMP) getHandle();
+        InventoryType type = inventory.getType();
+        net.minecraft.inventory.Container formerContainer = getHandle().openContainer;
+        // TODO: Should we check that it really IS a CraftInventory first?
+        CraftInventory craftinv = (CraftInventory) inventory;
+        switch(type) {
+        case PLAYER:
+        case CHEST:
+        case ENDER_CHEST:
+            getHandle().displayGUIChest(craftinv.getInventory());
+            break;
+        case DISPENSER:
+            if (craftinv.getInventory() instanceof net.minecraft.tileentity.TileEntityDispenser) {
+                getHandle().func_146102_a((net.minecraft.tileentity.TileEntityDispenser) craftinv.getInventory());
+            } else {
+                openCustomInventory(inventory, player, 3);
+            }
+            break;
+        case FURNACE:
+            if (craftinv.getInventory() instanceof net.minecraft.tileentity.TileEntityFurnace) {
+                getHandle().func_146101_a((net.minecraft.tileentity.TileEntityFurnace) craftinv.getInventory());
+            } else {
+                openCustomInventory(inventory, player, 2);
+            }
+            break;
+        case WORKBENCH:
+            openCustomInventory(inventory, player, 1);
+            break;
+        case BREWING:
+            if (craftinv.getInventory() instanceof net.minecraft.tileentity.TileEntityBrewingStand) {
+                getHandle().func_146098_a((net.minecraft.tileentity.TileEntityBrewingStand) craftinv.getInventory());
+            } else {
+                openCustomInventory(inventory, player, 5);
+            }
+            break;
+        case ENCHANTING:
+            openCustomInventory(inventory, player, 4);
+            break;
+        case HOPPER:
+            if (craftinv.getInventory() instanceof net.minecraft.tileentity.TileEntityHopper) {
+                getHandle().func_146093_a((net.minecraft.tileentity.TileEntityHopper) craftinv.getInventory());
+            } else if (craftinv.getInventory() instanceof net.minecraft.entity.item.EntityMinecartHopper) {
+                getHandle().displayGUIHopperMinecart((net.minecraft.entity.item.EntityMinecartHopper) craftinv.getInventory());
+            } else {
+                openCustomInventory(inventory, player, 9);
+            }
+            break;
+        case CREATIVE:
+        case CRAFTING:
+            throw new IllegalArgumentException("Can't open a " + type + " inventory!");
+        }
+        if (getHandle().openContainer == formerContainer) {
+            return null;
+        }
+        getHandle().openContainer.checkReachable = false;
+        return getHandle().openContainer.getBukkitView();
+    }
+
+    private void openCustomInventory(Inventory inventory, net.minecraft.entity.player.EntityPlayerMP player, int windowType) {
+        if (player.playerNetServerHandler == null) return;
+        net.minecraft.inventory.Container container = new CraftContainer(inventory, this, player.nextContainerCounter());
+
+        container = CraftEventFactory.callInventoryOpenEvent(player, container);
+        if(container == null) return;
+
+        String title = container.getBukkitView().getTitle();
+        int size = container.getBukkitView().getTopInventory().getSize();
+
+        player.playerNetServerHandler.sendPacket(new net.minecraft.network.play.server.S2DPacketOpenWindow(container.windowId, windowType, title, size, true));
+        getHandle().openContainer = container;
+        getHandle().openContainer.addCraftingToCrafters(player);
+    }
+
+    public InventoryView openWorkbench(Location location, boolean force) {
+        if (!force) {
+            Block block = location.getBlock();
+            if (block.getType() != Material.WORKBENCH) {
+                return null;
+            }
+        }
+        if (location == null) {
+            location = getLocation();
+        }
+        getHandle().displayGUIWorkbench(location.getBlockX(), location.getBlockY(), location.getBlockZ());
+        if (force) {
+            getHandle().openContainer.checkReachable = false;
+        }
+        return getHandle().openContainer.getBukkitView();
+    }
+
+    public InventoryView openEnchanting(Location location, boolean force) {
+        if (!force) {
+            Block block = location.getBlock();
+            if (block.getType() != Material.ENCHANTMENT_TABLE) {
+                return null;
+            }
+        }
+        if (location == null) {
+            location = getLocation();
+        }
+        getHandle().displayGUIEnchantment(location.getBlockX(), location.getBlockY(), location.getBlockZ(), null);
+        if (force) {
+            getHandle().openContainer.checkReachable = false;
+        }
+        return getHandle().openContainer.getBukkitView();
+    }
+
+    public void openInventory(InventoryView inventory) {
+        if (!(getHandle() instanceof net.minecraft.entity.player.EntityPlayerMP)) return; // TODO: NPC support?
+        if (((net.minecraft.entity.player.EntityPlayerMP) getHandle()).playerNetServerHandler == null) return;
+        if (getHandle().openContainer != getHandle().inventoryContainer) {
+            // fire INVENTORY_CLOSE if one already open
+            ((net.minecraft.entity.player.EntityPlayerMP)getHandle()).playerNetServerHandler.processCloseWindow(new net.minecraft.network.play.client.C0DPacketCloseWindow(getHandle().openContainer.windowId));
+        }
+        net.minecraft.entity.player.EntityPlayerMP player = (net.minecraft.entity.player.EntityPlayerMP) getHandle();
+        net.minecraft.inventory.Container container;
+        if (inventory instanceof CraftInventoryView) {
+            container = ((CraftInventoryView) inventory).getHandle();
+        } else {
+            container = new CraftContainer(inventory, player.nextContainerCounter());
+        }
+
+        // Trigger an INVENTORY_OPEN event
+        container = CraftEventFactory.callInventoryOpenEvent(player, container);
+        if (container == null) {
+            return;
+        }
+
+        // Now open the window
+        InventoryType type = inventory.getType();
+        int windowType = CraftContainer.getNotchInventoryType(type);
+        String title = inventory.getTitle();
+        int size = inventory.getTopInventory().getSize();
+        player.playerNetServerHandler.sendPacket(new net.minecraft.network.play.server.S2DPacketOpenWindow(container.windowId, windowType, title, size, false));
+        player.openContainer = container;
+        player.openContainer.addCraftingToCrafters(player);
+    }
+
+    public void closeInventory() {
+        getHandle().closeScreen();
+    }
+
+    public boolean isBlocking() {
+        return getHandle().isBlocking();
+    }
+
+    public boolean setWindowProperty(InventoryView.Property prop, int value) {
+        return false;
+    }
+
+    public int getExpToLevel() {
+        return getHandle().xpBarCap();
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftIronGolem.java

@@ -0,0 +1,34 @@
+package org.bukkit.craftbukkit.entity;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.IronGolem;
+
+public class CraftIronGolem extends CraftGolem implements IronGolem {
+    public CraftIronGolem(CraftServer server, net.minecraft.entity.monster.EntityIronGolem entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public net.minecraft.entity.monster.EntityIronGolem getHandle() {
+        return (net.minecraft.entity.monster.EntityIronGolem) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftIronGolem";
+    }
+
+    public boolean isPlayerCreated() {
+        return getHandle().isPlayerCreated();
+    }
+
+    public void setPlayerCreated(boolean playerCreated) {
+        getHandle().setPlayerCreated(playerCreated);
+    }
+
+    @Override
+    public EntityType getType() {
+        return EntityType.IRON_GOLEM;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java

@@ -0,0 +1,46 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Item;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.CraftServer;
+
+public class CraftItem extends CraftEntity implements Item {
+    private final net.minecraft.entity.item.EntityItem item;
+
+    public CraftItem(CraftServer server, net.minecraft.entity.Entity entity, net.minecraft.entity.item.EntityItem item) {
+        super(server, entity);
+        this.item = item;
+    }
+
+    public CraftItem(CraftServer server, net.minecraft.entity.item.EntityItem entity) {
+        this(server, entity, entity);
+    }
+
+    public ItemStack getItemStack() {
+        return CraftItemStack.asCraftMirror(item.getEntityItem());
+    }
+
+    public void setItemStack(ItemStack stack) {
+        item.setEntityItemStack(CraftItemStack.asNMSCopy(stack));
+    }
+
+    public int getPickupDelay() {
+        return item.delayBeforeCanPickup;
+    }
+
+    public void setPickupDelay(int delay) {
+        item.delayBeforeCanPickup = delay;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftItem";
+    }
+
+    public EntityType getType() {
+        return EntityType.DROPPED_ITEM;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftItemFrame.java

@@ -0,0 +1,97 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.apache.commons.lang.Validate;
+
+import org.bukkit.Rotation;
+import org.bukkit.block.BlockFace;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.ItemFrame;
+
+public class CraftItemFrame extends CraftHanging implements ItemFrame {
+    public CraftItemFrame(CraftServer server, net.minecraft.entity.item.EntityItemFrame entity) {
+        super(server, entity);
+    }
+
+    public boolean setFacingDirection(BlockFace face, boolean force) {
+        if (!super.setFacingDirection(face, force)) {
+            return false;
+        }
+
+        net.minecraft.world.WorldServer world = ((CraftWorld) this.getWorld()).getHandle();
+        world.getEntityTracker().removeEntityFromAllTrackingPlayers(this.getHandle());
+        world.getEntityTracker().addEntityToTracker(this.getHandle());
+        return true;
+    }
+
+    public void setItem(org.bukkit.inventory.ItemStack item) {
+        if (item == null || item.getTypeId() == 0) {
+            getHandle().getDataWatcher().addObjectByDataType(2, 5);
+            getHandle().getDataWatcher().setObjectWatched(2);
+        } else {
+            getHandle().setDisplayedItem(CraftItemStack.asNMSCopy(item));
+        }
+    }
+
+    public org.bukkit.inventory.ItemStack getItem() {
+        return CraftItemStack.asBukkitCopy(getHandle().getDisplayedItem());
+    }
+
+    public Rotation getRotation() {
+        return toBukkitRotation(getHandle().getRotation());
+    }
+
+    Rotation toBukkitRotation(int value) {
+        // Translate NMS rotation integer to Bukkit API
+        switch (value) {
+        case 0:
+            return Rotation.NONE;
+        case 1:
+            return Rotation.CLOCKWISE;
+        case 2:
+            return Rotation.FLIPPED;
+        case 3:
+            return Rotation.COUNTER_CLOCKWISE;
+        default:
+            throw new AssertionError("Unknown rotation " + value + " for " + getHandle());
+        }
+    }
+
+    public void setRotation(Rotation rotation) {
+        Validate.notNull(rotation, "Rotation cannot be null");
+        getHandle().setItemRotation(toInteger(rotation));
+    }
+
+    static int toInteger(Rotation rotation) {
+        // Translate Bukkit API rotation to NMS integer
+        switch (rotation) {
+        case NONE:
+            return 0;
+        case CLOCKWISE:
+            return 1;
+        case FLIPPED:
+            return 2;
+        case COUNTER_CLOCKWISE:
+            return 3;
+        default:
+            throw new IllegalArgumentException(rotation + " is not applicable to an ItemFrame");
+        }
+    }
+
+    @Override
+    public net.minecraft.entity.item.EntityItemFrame getHandle() {
+        return (net.minecraft.entity.item.EntityItemFrame) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftItemFrame{item=" + getItem() + ", rotation=" + getRotation() + "}";
+    }
+
+    public EntityType getType() {
+        return EntityType.ITEM_FRAME;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftLargeFireball.java

@@ -0,0 +1,31 @@
+package org.bukkit.craftbukkit.entity;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LargeFireball;
+
+public class CraftLargeFireball extends CraftFireball implements LargeFireball {
+    public CraftLargeFireball(CraftServer server, net.minecraft.entity.projectile.EntityLargeFireball entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public void setYield(float yield) {
+        super.setYield(yield);
+        getHandle().field_92057_e = (int) yield;
+    }
+
+    @Override
+    public net.minecraft.entity.projectile.EntityLargeFireball getHandle() {
+        return (net.minecraft.entity.projectile.EntityLargeFireball) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftLargeFireball";
+    }
+
+    public EntityType getType() {
+        return EntityType.FIREBALL;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftLeash.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LeashHitch;
+
+public class CraftLeash extends CraftHanging implements LeashHitch {
+    public CraftLeash(CraftServer server, net.minecraft.entity.EntityLeashKnot entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public net.minecraft.entity.EntityLeashKnot getHandle() {
+        return (net.minecraft.entity.EntityLeashKnot) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftLeash";
+    }
+
+    public EntityType getType() {
+        return EntityType.LEASH_HITCH;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftLightningStrike.java

@@ -0,0 +1,29 @@
+package org.bukkit.craftbukkit.entity;
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LightningStrike;
+
+public class CraftLightningStrike extends CraftEntity implements LightningStrike {
+    public CraftLightningStrike(final CraftServer server, final net.minecraft.entity.effect.EntityLightningBolt entity) {
+        super(server, entity);
+    }
+
+    public boolean isEffect() {
+        return ((net.minecraft.entity.effect.EntityLightningBolt) super.getHandle()).isEffect;
+    }
+
+    @Override
+    public net.minecraft.entity.effect.EntityLightningBolt getHandle() {
+        return (net.minecraft.entity.effect.EntityLightningBolt) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftLightningStrike";
+    }
+
+    public EntityType getType() {
+        return EntityType.LIGHTNING;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java

@@ -0,0 +1,506 @@
+package org.bukkit.craftbukkit.entity;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.inventory.CraftEntityEquipment;
+import org.bukkit.craftbukkit.inventory.CraftItemStack;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Egg;
+import org.bukkit.entity.EnderPearl;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Fireball;
+import org.bukkit.entity.Fish;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.SmallFireball;
+import org.bukkit.entity.Snowball;
+import org.bukkit.entity.ThrownExpBottle;
+import org.bukkit.entity.ThrownPotion;
+import org.bukkit.entity.WitherSkull;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.BlockIterator;
+import org.bukkit.util.NumberConversions;
+import org.bukkit.util.Vector;
+
+import cpw.mods.fml.common.registry.EntityRegistry; // Cauldron
+
+public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+    private CraftEntityEquipment equipment;
+    // Cauldron start
+    public Class<? extends net.minecraft.entity.EntityLivingBase> entityClass;
+    public String entityName;
+    // Cauldron end
+
+    public CraftLivingEntity(final CraftServer server, final net.minecraft.entity.EntityLivingBase entity) {
+        super(server, entity);
+        // Cauldron start
+        this.entityClass = entity.getClass();
+        this.entityName = EntityRegistry.getCustomEntityTypeName(entityClass);
+        if (entityName == null)
+            entityName = entity.getCommandSenderName();
+        // Cauldron end
+
+        if (entity instanceof net.minecraft.entity.EntityLiving) {
+            equipment = new CraftEntityEquipment(this);
+        }
+    }
+
+    public double getHealth() {
+        return Math.min(Math.max(0, getHandle().getHealth()), getMaxHealth());
+    }
+
+    public void setHealth(double health) {
+        if ((health < 0) || (health > getMaxHealth())) {
+            throw new IllegalArgumentException("Health must be between 0 and " + getMaxHealth());
+        }
+
+        // Cauldron start - setHealth must be set before onDeath to respect events that may prevent death.
+        getHandle().setHealth((float) health);
+
+        if (entity instanceof net.minecraft.entity.player.EntityPlayerMP && health == 0) {
+            ((net.minecraft.entity.player.EntityPlayerMP) entity).onDeath(net.minecraft.util.DamageSource.generic);
+        }
+        // Cauldron end
+    }
+
+    public double getMaxHealth() {
+        return getHandle().getMaxHealth();
+    }
+
+    public void setMaxHealth(double amount) {
+        Validate.isTrue(amount > 0, "Max health must be greater than 0");
+
+        getHandle().getEntityAttribute(net.minecraft.entity.SharedMonsterAttributes.maxHealth).setBaseValue(amount);
+
+        if (getHealth() > amount) {
+            setHealth(amount);
+        }
+    }
+
+    public void resetMaxHealth() {
+        setMaxHealth(getHandle().getMaxHealth());
+    }
+
+    @Deprecated
+    public Egg throwEgg() {
+        return launchProjectile(Egg.class);
+    }
+
+    @Deprecated
+    public Snowball throwSnowball() {
+        return launchProjectile(Snowball.class);
+    }
+
+    public double getEyeHeight() {
+        return getHandle().getEyeHeight();
+    }
+
+    public double getEyeHeight(boolean ignoreSneaking) {
+        return getEyeHeight();
+    }
+
+    private List<Block> getLineOfSight(HashSet<Byte> transparent, int maxDistance, int maxLength) {
+        if (maxDistance > 120) {
+            maxDistance = 120;
+        }
+        ArrayList<Block> blocks = new ArrayList<Block>();
+        Iterator<Block> itr = new BlockIterator(this, maxDistance);
+        while (itr.hasNext()) {
+            Block block = itr.next();
+            blocks.add(block);
+            if (maxLength != 0 && blocks.size() > maxLength) {
+                blocks.remove(0);
+            }
+            int id = block.getTypeId();
+            if (transparent == null) {
+                if (id != 0) {
+                    break;
+                }
+            } else {
+                if (!transparent.contains((byte) id)) {
+                    break;
+                }
+            }
+        }
+        return blocks;
+    }
+
+    public List<Block> getLineOfSight(HashSet<Byte> transparent, int maxDistance) {
+        return getLineOfSight(transparent, maxDistance, 0);
+    }
+
+    public Block getTargetBlock(HashSet<Byte> transparent, int maxDistance) {
+        List<Block> blocks = getLineOfSight(transparent, maxDistance, 1);
+        return blocks.get(0);
+    }
+
+    public List<Block> getLastTwoTargetBlocks(HashSet<Byte> transparent, int maxDistance) {
+        return getLineOfSight(transparent, maxDistance, 2);
+    }
+
+    @Deprecated
+    public Arrow shootArrow() {
+        return launchProjectile(Arrow.class);
+    }
+
+    public int getRemainingAir() {
+        return getHandle().getAir();
+    }
+
+    public void setRemainingAir(int ticks) {
+        getHandle().setAir(ticks);
+    }
+
+    public int getMaximumAir() {
+        return getHandle().maxAirTicks;
+    }
+
+    public void setMaximumAir(int ticks) {
+        getHandle().maxAirTicks = ticks;
+    }
+
+    public void damage(double amount) {
+        damage(amount, null);
+    }
+
+    public void damage(double amount, org.bukkit.entity.Entity source) {
+        net.minecraft.util.DamageSource reason = net.minecraft.util.DamageSource.generic;
+
+        if (source instanceof HumanEntity) {
+            reason = net.minecraft.util.DamageSource.causePlayerDamage(((CraftHumanEntity) source).getHandle());
+        } else if (source instanceof LivingEntity) {
+            reason = net.minecraft.util.DamageSource.causeMobDamage(((CraftLivingEntity) source).getHandle());
+        }
+
+        if (entity instanceof net.minecraft.entity.boss.EntityDragon) {
+            ((net.minecraft.entity.boss.EntityDragon) entity).func_82195_e(reason, (float) amount);
+        } else {
+            entity.attackEntityFrom(reason, (float) amount);
+        }
+    }
+
+    public Location getEyeLocation() {
+        Location loc = getLocation();
+        loc.setY(loc.getY() + getEyeHeight());
+        return loc;
+    }
+
+    public int getMaximumNoDamageTicks() {
+        return getHandle().maxHurtResistantTime;
+    }
+
+    public void setMaximumNoDamageTicks(int ticks) {
+        getHandle().maxHurtResistantTime = ticks;
+    }
+
+    public double getLastDamage() {
+        return getHandle().lastDamage;
+    }
+
+    public void setLastDamage(double damage) {
+        getHandle().lastDamage = (float) damage;
+    }
+
+    public int getNoDamageTicks() {
+        return getHandle().hurtResistantTime;
+    }
+
+    public void setNoDamageTicks(int ticks) {
+        getHandle().hurtResistantTime = ticks;
+    }
+
+    @Override
+    public net.minecraft.entity.EntityLivingBase getHandle() {
+        return (net.minecraft.entity.EntityLivingBase) entity;
+    }
+
+    public void setHandle(final net.minecraft.entity.EntityLivingBase entity) {
+        super.setHandle(entity);
+    }
+
+    @Override
+    public String toString() {
+        return this.entityName; // Cauldron
+    }
+
+    public Player getKiller() {
+        return getHandle().attackingPlayer == null ? null : (Player) getHandle().attackingPlayer.getBukkitEntity();
+    }
+
+    public boolean addPotionEffect(PotionEffect effect) {
+        return addPotionEffect(effect, false);
+    }
+
+    public boolean addPotionEffect(PotionEffect effect, boolean force) {
+        if (hasPotionEffect(effect.getType())) {
+            if (!force) {
+                return false;
+            }
+            removePotionEffect(effect.getType());
+        }
+        getHandle().addPotionEffect(new net.minecraft.potion.PotionEffect(effect.getType().getId(), effect.getDuration(), effect.getAmplifier(), effect.isAmbient()));
+        return true;
+    }
+
+    public boolean addPotionEffects(Collection<PotionEffect> effects) {
+        boolean success = true;
+        for (PotionEffect effect : effects) {
+            success &= addPotionEffect(effect);
+        }
+        return success;
+    }
+
+    public boolean hasPotionEffect(PotionEffectType type) {
+        return getHandle().isPotionActive(net.minecraft.potion.Potion.potionTypes[type.getId()]);
+    }
+
+    public void removePotionEffect(PotionEffectType type) {
+        getHandle().removePotionEffect(type.getId()); // Should be removeEffect.
+    }
+
+    public Collection<PotionEffect> getActivePotionEffects() {
+        List<PotionEffect> effects = new ArrayList<PotionEffect>();
+        for (Object raw : getHandle().activePotionsMap.values()) {
+            if (!(raw instanceof net.minecraft.potion.PotionEffect))
+                continue;
+            net.minecraft.potion.PotionEffect handle = (net.minecraft.potion.PotionEffect) raw;
+            if (PotionEffectType.getById(handle.getPotionID()) == null) continue; // Cauldron - ignore null types
+            effects.add(new PotionEffect(PotionEffectType.getById(handle.getPotionID()), handle.getDuration(), handle.getAmplifier(), handle.getIsAmbient()));
+        }
+        return effects;
+    }
+
+    public <T extends Projectile> T launchProjectile(Class<? extends T> projectile) {
+        return launchProjectile(projectile, null);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends Projectile> T launchProjectile(Class<? extends T> projectile, Vector velocity) {
+        net.minecraft.world.World world = ((CraftWorld) getWorld()).getHandle();
+        net.minecraft.entity.Entity launch = null;
+
+        if (Snowball.class.isAssignableFrom(projectile)) {
+            launch = new net.minecraft.entity.projectile.EntitySnowball(world, getHandle());
+        } else if (Egg.class.isAssignableFrom(projectile)) {
+            launch = new net.minecraft.entity.projectile.EntityEgg(world, getHandle());
+        } else if (EnderPearl.class.isAssignableFrom(projectile)) {
+            launch = new net.minecraft.entity.item.EntityEnderPearl(world, getHandle());
+        } else if (Arrow.class.isAssignableFrom(projectile)) {
+            launch = new net.minecraft.entity.projectile.EntityArrow(world, getHandle(), 1);
+        } else if (ThrownPotion.class.isAssignableFrom(projectile)) {
+            launch = new net.minecraft.entity.projectile.EntityPotion(world, getHandle(), CraftItemStack.asNMSCopy(new ItemStack(Material.POTION, 1)));
+        } else if (ThrownExpBottle.class.isAssignableFrom(projectile)) {
+            launch = new net.minecraft.entity.item.EntityExpBottle(world, getHandle());
+        } else if (Fish.class.isAssignableFrom(projectile) && getHandle() instanceof net.minecraft.entity.player.EntityPlayer) {
+            launch = new net.minecraft.entity.projectile.EntityFishHook(world, (net.minecraft.entity.player.EntityPlayer) getHandle());
+        } else if (Fireball.class.isAssignableFrom(projectile)) {
+            Location location = getEyeLocation();
+            Vector direction = location.getDirection().multiply(10);
+
+            if (SmallFireball.class.isAssignableFrom(projectile)) {
+                launch = new net.minecraft.entity.projectile.EntitySmallFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
+            } else if (WitherSkull.class.isAssignableFrom(projectile)) {
+                launch = new net.minecraft.entity.projectile.EntityWitherSkull(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
+            } else {
+                launch = new net.minecraft.entity.projectile.EntityLargeFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
+            }
+
+            ((net.minecraft.entity.projectile.EntityFireball) launch).projectileSource = this;
+            launch.setLocationAndAngles(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
+        }
+
+        Validate.notNull(launch, "Projectile not supported");
+
+        if (velocity != null) {
+            ((T) launch.getBukkitEntity()).setVelocity(velocity);
+        }
+
+        world.spawnEntityInWorld(launch);
+        return (T) launch.getBukkitEntity();
+    }
+
+    public EntityType getType() {
+        // Cauldron start
+        EntityType type = EntityType.fromName(this.entityName);
+        if (type != null)
+            return type;
+        else return EntityType.UNKNOWN;
+        // Cauldron end
+    }
+
+    public boolean hasLineOfSight(Entity other) {
+        return getHandle().canEntityBeSeen(((CraftEntity) other).getHandle());
+    }
+
+    public boolean getRemoveWhenFarAway() {
+        return getHandle() instanceof net.minecraft.entity.EntityLiving && !((net.minecraft.entity.EntityLiving) getHandle()).persistenceRequired;
+    }
+
+    public void setRemoveWhenFarAway(boolean remove) {
+        if (getHandle() instanceof net.minecraft.entity.EntityLiving) {
+            ((net.minecraft.entity.EntityLiving) getHandle()).persistenceRequired = !remove;
+        }
+    }
+
+    public EntityEquipment getEquipment() {
+        return equipment;
+    }
+
+    public void setCanPickupItems(boolean pickup) {
+        if (getHandle() instanceof net.minecraft.entity.EntityLiving) {
+            ((net.minecraft.entity.EntityLiving) getHandle()).canPickUpLoot = pickup;
+        }
+    }
+
+    public boolean getCanPickupItems() {
+        return getHandle() instanceof net.minecraft.entity.EntityLiving && ((net.minecraft.entity.EntityLiving) getHandle()).canPickUpLoot;
+    }
+
+    @Override
+    public boolean teleport(Location location, PlayerTeleportEvent.TeleportCause cause) {
+        if (getHealth() == 0) {
+            return false;
+        }
+
+        return super.teleport(location, cause);
+    }
+
+    public void setCustomName(String name) {
+        if (!(getHandle() instanceof net.minecraft.entity.EntityLiving)) {
+            return;
+        }
+
+        if (name == null) {
+            name = "";
+        }
+
+        // Names cannot be more than 64 characters due to DataWatcher limitations
+        if (name.length() > 64) {
+            name = name.substring(0, 64);
+        }
+
+        ((net.minecraft.entity.EntityLiving) getHandle()).setCustomNameTag(name);
+    }
+
+    public String getCustomName() {
+        if (!(getHandle() instanceof net.minecraft.entity.EntityLiving)) {
+            return null;
+        }
+
+        String name = ((net.minecraft.entity.EntityLiving) getHandle()).getCustomNameTag();
+
+        if (name == null || name.length() == 0) {
+            return null;
+        }
+
+        return name;
+    }
+
+    public void setCustomNameVisible(boolean flag) {
+        if (getHandle() instanceof net.minecraft.entity.EntityLiving) {
+            ((net.minecraft.entity.EntityLiving) getHandle()).setAlwaysRenderNameTag(flag);
+        }
+    }
+
+    public boolean isCustomNameVisible() {
+        return getHandle() instanceof net.minecraft.entity.EntityLiving && ((net.minecraft.entity.EntityLiving) getHandle()).getAlwaysRenderNameTag();
+    }
+
+    public boolean isLeashed() {
+        if (!(getHandle() instanceof net.minecraft.entity.EntityLiving)) {
+            return false;
+        }
+        return ((net.minecraft.entity.EntityLiving) getHandle()).getLeashedToEntity() != null;
+    }
+
+    public Entity getLeashHolder() throws IllegalStateException {
+        if (!isLeashed()) {
+            throw new IllegalStateException("Entity not leashed");
+        }
+        return ((net.minecraft.entity.EntityLiving) getHandle()).getLeashedToEntity().getBukkitEntity();
+    }
+
+    private boolean unleash() {
+        if (!isLeashed()) {
+            return false;
+        }
+        ((net.minecraft.entity.EntityLiving) getHandle()).clearLeashed(true, false);
+        return true;
+    }
+
+    public boolean setLeashHolder(Entity holder) {
+        if ((getHandle() instanceof net.minecraft.entity.boss.EntityWither) || !(getHandle() instanceof net.minecraft.entity.EntityLiving)) {
+            return false;
+        }
+
+        if (holder == null) {
+            return unleash();
+        }
+
+        if (holder.isDead()) {
+            return false;
+        }
+
+        unleash();
+        ((net.minecraft.entity.EntityLiving) getHandle()).setLeashedToEntity(((CraftEntity) holder).getHandle(), true);
+        return true;
+    }
+
+    @Deprecated
+    public int _INVALID_getLastDamage() {
+        return NumberConversions.ceil(getLastDamage());
+    }
+
+    @Deprecated
+    public void _INVALID_setLastDamage(int damage) {
+        setLastDamage(damage);
+    }
+
+    @Deprecated
+    public void _INVALID_damage(int amount) {
+        damage(amount);
+    }
+
+    @Deprecated
+    public void _INVALID_damage(int amount, Entity source) {
+        damage(amount, source);
+    }
+
+    @Deprecated
+    public int _INVALID_getHealth() {
+        return NumberConversions.ceil(getHealth());
+    }
+
+    @Deprecated
+    public void _INVALID_setHealth(int health) {
+        setHealth(health);
+    }
+
+    @Deprecated
+    public int _INVALID_getMaxHealth() {
+        return NumberConversions.ceil(getMaxHealth());
+    }
+
+    @Deprecated
+    public void _INVALID_setMaxHealth(int health) {
+        setMaxHealth(health);
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMagmaCube.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.MagmaCube;
+
+public class CraftMagmaCube extends CraftSlime implements MagmaCube {
+
+    public CraftMagmaCube(CraftServer server, net.minecraft.entity.monster.EntityMagmaCube entity) {
+        super(server, entity);
+    }
+
+    public net.minecraft.entity.monster.EntityMagmaCube getHandle() {
+        return (net.minecraft.entity.monster.EntityMagmaCube) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMagmaCube";
+    }
+
+    public EntityType getType() {
+        return EntityType.MAGMA_CUBE;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecart.java

@@ -0,0 +1,76 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Minecart;
+import org.bukkit.util.NumberConversions;
+import org.bukkit.util.Vector;
+
+public class CraftMinecart extends CraftVehicle implements Minecart { // Cauldron - concrete for modded minecarts
+    public CraftMinecart(CraftServer server, net.minecraft.entity.item.EntityMinecart entity) {
+        super(server, entity);
+    }
+
+    // Cauldron start
+    public org.bukkit.entity.EntityType getType() {
+        return org.bukkit.entity.EntityType.MINECART;
+    }
+    // Cauldron end
+
+    public void setDamage(double damage) {
+        getHandle().setDamage((float) damage);
+    }
+
+    public double getDamage() {
+        return getHandle().getDamage();
+    }
+
+    public double getMaxSpeed() {
+        return getHandle().maxSpeed;
+    }
+
+    public void setMaxSpeed(double speed) {
+        if (speed >= 0D) {
+            getHandle().maxSpeed = speed;
+        }
+    }
+
+    public boolean isSlowWhenEmpty() {
+        return getHandle().slowWhenEmpty;
+    }
+
+    public void setSlowWhenEmpty(boolean slow) {
+        getHandle().slowWhenEmpty = slow;
+    }
+
+    public Vector getFlyingVelocityMod() {
+        return getHandle().getFlyingVelocityMod();
+    }
+
+    public void setFlyingVelocityMod(Vector flying) {
+        getHandle().setFlyingVelocityMod(flying);
+    }
+
+    public Vector getDerailedVelocityMod() {
+        return getHandle().getDerailedVelocityMod();
+    }
+
+    public void setDerailedVelocityMod(Vector derailed) {
+        getHandle().setDerailedVelocityMod(derailed);
+    }
+
+    @Override
+    public net.minecraft.entity.item.EntityMinecart getHandle() {
+        return (net.minecraft.entity.item.EntityMinecart) entity;
+    }
+
+    @Deprecated
+    public void _INVALID_setDamage(int damage) {
+        setDamage(damage);
+    }
+
+    @Deprecated
+    public int _INVALID_getDamage() {
+        return NumberConversions.ceil(getDamage());
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartChest.java

@@ -0,0 +1,31 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.StorageMinecart;
+import org.bukkit.inventory.Inventory;
+
+@SuppressWarnings("deprecation")
+public class CraftMinecartChest extends CraftMinecart implements StorageMinecart {
+    private final CraftInventory inventory;
+
+    public CraftMinecartChest(CraftServer server, net.minecraft.entity.item.EntityMinecartChest entity) {
+        super(server, entity);
+        inventory = new CraftInventory(entity);
+    }
+
+    public Inventory getInventory() {
+        return inventory;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMinecartChest{" + "inventory=" + inventory + '}';
+    }
+
+    public EntityType getType() {
+        return EntityType.MINECART_CHEST;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartCommand.java

@@ -0,0 +1,126 @@
+package org.bukkit.craftbukkit.entity;
+
+import java.util.Set;
+
+
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.minecart.CommandMinecart;
+import org.bukkit.permissions.PermissibleBase;
+import org.bukkit.permissions.Permission;
+import org.bukkit.permissions.PermissionAttachment;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.Plugin;
+
+public class CraftMinecartCommand extends CraftMinecart implements CommandMinecart {
+    private final PermissibleBase perm = new PermissibleBase(this);
+
+    public CraftMinecartCommand(CraftServer server, net.minecraft.entity.EntityMinecartCommandBlock entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public String getCommand() {
+        return ((net.minecraft.entity.EntityMinecartCommandBlock) getHandle()).func_145822_e().field_145763_e;
+    }
+
+    @Override
+    public void setCommand(String command) {
+        ((net.minecraft.entity.EntityMinecartCommandBlock) getHandle()).func_145822_e().func_145752_a(command != null ? command : "");
+    }
+
+    @Override
+    public void setName(String name) {
+        ((net.minecraft.entity.EntityMinecartCommandBlock) getHandle()).func_145822_e().func_145754_b(name != null ? name : "@");
+    }
+
+    @Override
+    public EntityType getType() {
+        return EntityType.MINECART_COMMAND;
+    }
+
+    @Override
+    public void sendMessage(String message) {
+    }
+
+    @Override
+    public void sendMessage(String[] messages) {
+    }
+
+    @Override
+    public String getName() {
+        return ((net.minecraft.entity.EntityMinecartCommandBlock) getHandle()).func_145822_e().getCommandSenderName();
+    }
+
+    @Override
+    public boolean isOp() {
+        return true;
+    }
+
+    @Override
+    public void setOp(boolean value) {
+        throw new UnsupportedOperationException("Cannot change operator status of a minecart");
+    }
+
+    @Override
+    public boolean isPermissionSet(String name) {
+        return perm.isPermissionSet(name);
+    }
+
+    @Override
+    public boolean isPermissionSet(Permission perm) {
+        return this.perm.isPermissionSet(perm);
+    }
+
+    @Override
+    public boolean hasPermission(String name) {
+        return perm.hasPermission(name);
+    }
+
+    @Override
+    public boolean hasPermission(Permission perm) {
+        return this.perm.hasPermission(perm);
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value) {
+        return perm.addAttachment(plugin, name, value);
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(Plugin plugin) {
+        return perm.addAttachment(plugin);
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(Plugin plugin, String name, boolean value, int ticks) {
+        return perm.addAttachment(plugin, name, value, ticks);
+    }
+
+    @Override
+    public PermissionAttachment addAttachment(Plugin plugin, int ticks) {
+        return perm.addAttachment(plugin, ticks);
+    }
+
+    @Override
+    public void removeAttachment(PermissionAttachment attachment) {
+        perm.removeAttachment(attachment);
+    }
+
+    @Override
+    public void recalculatePermissions() {
+        perm.recalculatePermissions();
+    }
+
+    @Override
+    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
+        return perm.getEffectivePermissions();
+    }
+
+    @Override
+    public Server getServer() {
+        return Bukkit.getServer();
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartFurnace.java

@@ -0,0 +1,22 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.PoweredMinecart;
+
+@SuppressWarnings("deprecation")
+public class CraftMinecartFurnace extends CraftMinecart implements PoweredMinecart {
+    public CraftMinecartFurnace(CraftServer server, net.minecraft.entity.item.EntityMinecartFurnace entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMinecartFurnace";
+    }
+
+    public EntityType getType() {
+        return EntityType.MINECART_FURNACE;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartHopper.java

@@ -0,0 +1,30 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.inventory.CraftInventory;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.minecart.HopperMinecart;
+import org.bukkit.inventory.Inventory;
+
+final class CraftMinecartHopper extends CraftMinecart implements HopperMinecart {
+    private final CraftInventory inventory;
+
+    CraftMinecartHopper(CraftServer server, net.minecraft.entity.item.EntityMinecartHopper entity) {
+        super(server, entity);
+        inventory = new CraftInventory(entity);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMinecartHopper{" + "inventory=" + inventory + '}';
+    }
+
+    public EntityType getType() {
+        return EntityType.MINECART_HOPPER;
+    }
+
+    public Inventory getInventory() {
+        return inventory;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartMobSpawner.java

@@ -0,0 +1,21 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.minecart.SpawnerMinecart;
+
+final class CraftMinecartMobSpawner extends CraftMinecart implements SpawnerMinecart {
+    CraftMinecartMobSpawner(CraftServer server, net.minecraft.entity.ai.EntityMinecartMobSpawner entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMinecartMobSpawner";
+    }
+
+    public EntityType getType() {
+        return EntityType.MINECART_MOB_SPAWNER;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartRideable.java

@@ -0,0 +1,21 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.minecart.RideableMinecart;
+
+public class CraftMinecartRideable extends CraftMinecart implements RideableMinecart {
+    public CraftMinecartRideable(CraftServer server, net.minecraft.entity.item.EntityMinecart entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMinecartRideable";
+    }
+
+    public EntityType getType() {
+        return EntityType.MINECART;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartTNT.java

@@ -0,0 +1,21 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.minecart.ExplosiveMinecart;
+
+final class CraftMinecartTNT extends CraftMinecart implements ExplosiveMinecart {
+    CraftMinecartTNT(CraftServer server, net.minecraft.entity.item.EntityMinecartTNT entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMinecartTNT";
+    }
+
+    public EntityType getType() {
+        return EntityType.MINECART_TNT;
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMonster.java

@@ -0,0 +1,22 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.Monster;
+
+public class CraftMonster extends CraftCreature implements Monster {
+
+    public CraftMonster(CraftServer server, net.minecraft.entity.monster.EntityMob entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public net.minecraft.entity.monster.EntityMob getHandle() {
+        return (net.minecraft.entity.monster.EntityMob) entity;
+    }
+
+    @Override
+    public String toString() {
+        return this.entityName; // Cauldron
+    }
+}

src/main/java/org/bukkit/craftbukkit/entity/CraftMushroomCow.java

@@ -0,0 +1,26 @@
+package org.bukkit.craftbukkit.entity;
+
+
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.MushroomCow;
+
+public class CraftMushroomCow extends CraftCow implements MushroomCow {
+    public CraftMushroomCow(CraftServer server, net.minecraft.entity.passive.EntityMooshroom entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public net.minecraft.entity.passive.EntityMooshroom getHandle() {
+        return (net.minecraft.entity.passive.EntityMooshroom) entity;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftMushroomCow";
+    }
+
+    public EntityType getType() {
+        return EntityType.MUSHROOM_COW;
+    }
+}