TemplateGenerator + OBCTemplateGenerator

/**
****************************************************************************************
****************************************************************************************
*** Bukkit TemplateGenerator
*** Contents:
***  TemplateChunkGenerator.java
***  OBCTemplateChunkGenerator.java
***  Usage docs
***
*** @author Kane York (riking)
*** @date 4 June 2013
*** @license This code is released into the public domain in the hope that it may be
***     useful. No restrictions are placed upon copying or reuse, even commercially.
***     This code is provided as-is, without any warranty. If it doesn't work, it
***     (may not be) my fault, but I'm not liable for any losses you incur from trying
***     to get it to work or from malfunctions.
***
*** The documentation you see below may be outdated, see http://jd.bukkit.org/ for
*** up-to-date usage information.
***
*** Also, no additional support will be provided for the OBC version. Figure it out
*** yourself once you get the pure-bukkit version going.
****************************************************************************************
*** TemplateGenerator.java
***************************************************************************************/
import java.util.Random;

import org.bukkit.generator.ChunkGenerator;
import org.bukkit.ChunkSnapshot;
import org.bukkit.World;

public class TemplateChunkGenerator extends ChunkGenerator {
    protected World world;

    public TemplateChunkGenerator(World templateWorld) {
        this.world = templateWorld;
    }

    /*
    void setBlock(short[][] result, int x, int y, int z, short blkid) {
        if (result[y >> 4] == null) {
            result[y >> 4] = new short[4096];
        }
        result[y >> 4][((y & 0xF) << 8) | (z << 4) | x] = blkid;
    }
    */

    @Override
    public short[][] generateExtBlockSections(World contextWorld, Random worldRandom, int cx, int cz, BiomeGrid biomes) {
        ChunkSnapshot templateChunk = world.getChunkAt(cx, cz).getChunkSnapshot();

        // Pure-bukkit impl - can be optimized via NMS

        // Load block IDs
        short[][] result = new short[256 / 16][];
        for (int y = 0; y < 256; y += 16) {
            short[] locres = new short[4096];
            for (int py = y; py < y + 16; py++) {
                for (int px = 0; px < 16; px++) {
                    for (int pz = 0; pz < 16; pz++) {
                        locres[((py & 0xF) << 8) | (pz << 4) | px] = (short) templateChunk.getBlockTypeId(px, py, pz);
                    }
                }
            }
            result[y >> 4] = locres;
        }

        loadBiomesIntoGrid(biomes, templateChunk);

        return result;
    }

    public void loadBiomesIntoGrid(BiomeGrid biomes, ChunkSnapshot template) {
        for (int px = 0; px < 16; px++) {
            for (int pz = 0; pz < 16; pz++) {
                biomes.setBiome(px, pz, template.getBiome(px, pz));
            }
        }
    }
}
/***************************************************************************************
*** OBCTemplateGenerator.java
***************************************************************************************/
import java.lang.reflect.Field;
import java.util.Random;

import org.bukkit.ChunkSnapshot;
import org.bukkit.World;
import org.bukkit.craftbukkit.CraftChunkSnapshot; // THIS MUST BE CHANGED TO THE CORRECT VERSIONED PACKAGE


public class OBCTemplateChunkGenerator extends TemplateChunkGenerator {

    public OBCTemplateChunkGenerator(World templateWorld) {
        super(templateWorld);
    }

    /**
     * @throws NoClassDefFoundError on wrong version of craftbukkit
     */
    @Override
    public short[][] generateExtBlockSections(World contextWorld, Random worldRandom, int cx, int cz, BiomeGrid biomes)
      throws RuntimeException {
        ChunkSnapshot tmp = world.getChunkAt(cx, cz).getChunkSnapshot();
        // let's do this first, shall we?
        loadBiomesIntoGrid(biomes, tmp);

        try {
            CraftChunkSnapshot templateChunk = (CraftChunkSnapshot)tmp;

            Field blockids = CraftChunkSnapshot.class.getDeclaredField("blockids");
            blockids.setAccessible(true);

            short[][] result = (short[][]) blockids.get(templateChunk);
            return result;
        } catch (Throwable e) {
            System.err.println("[WARNING] Suppressing" + e.toString() + ", falling back on pure-bukkit");
            return super.generateExtBlockSections(contextWorld, worldRandom, cx, cz, biomes);
        }
    }
}

/***************************************************************************************
*** Usage Notes
***************************************************************************************/

/**
 * The TemplateGenerator loads chunks from an alternate world to a 'main'
 * world that can be modified and reset as needed.
 * <p>
 * How to use:
 * <p>
 * The first method we want to look at is
 * {@link org.bukkit.Server#createWorld(org.bukkit.WorldCreator)}. This takes
 * a WorldCreator, what's that? Well, the constructor is WorldCreator(String
 * name).
 * <p>
 * The general use-case for this is a unchanging template populating a
 * revertable main world. So, we don't want any of the random parts of
 * Minecraft worldgen.
 * <p>
 * Let's say that your template world is named "gameTemplate", and the game
 * world (the one that players join) will be named "gameWorld". So first:
 *
 * <pre>
 * World templateWorld = getServer().createWorld(new WorldCreator(&quot;gameTemplate&quot;));
 * </pre>
 *
 * Now that we have the template world loaded, we want to setup the playing
 * world. We need to set the generator, and some other options to make sure
 * that Minecraft doesn't mess us up and add stuff to our beautiful template:
 *
 * <pre>
 * WorldCreator gameCreator = new WorldCreator("gameWorld")
 *   .generateStructures(false) // no mineshafts
 *   .type(WorldType.FLAT) // no ores
 *   .generator(new TemplateGenerator(templateWorld));
 * </pre>
 *
 * Now, you need to be aware of this caveat: No block data, entities (like
 * paintings and item frames), or tile entities (like chests, signs, furnaces,
 * pistons, beacons, player skulls, or anything else with a BlockState) is
 * loaded from the template world.
 * <p>
 * The first step in fixing this is the TemplateBlockPopulator.
 * // TODO expand, create the TemplateBlockPopulator
 * <p>
 * And we're almost done setting up! Now we just need to:
 *
 * <pre>
 * World gameWorld = getServer().createWorld(gameCreator);
 * </pre>
 *
 * We can now teleport players into the gameWorld and let them play away.
 * When the game is done and it's time to clean up, use
 * {@link World#regenerateChunk(int, int)} and the Game world will revert back
 * to the Template world. It's as simple as that!
 *
 * <p>
 *
 * If you want to use the OBCTemplateGenerator, which should be faster, do this:
 * <pre>
 * WorldCreator gameCreator = ...; // same as above
 * try {
 *   gameCreator.generator(new OBCTemplateGenerator(templateWorld));
 * } catch (Throwable t) {
 *   // ignore - we can't use it right now
 * }
 */