View difference between Paste ID: xzbYAHjW and mtFnd51U

-package test;
+/**
 ****************************************************************************************
 ****************************************************************************************
 *** Bukkit TemplateGenerator
 *** Contents:
 ***  TemplateChunkGenerator.java
 ***  OBCTemplateChunkGenerator.java
 ***  Usage docs
-public class TemplateGenerator extends ChunkGenerator {
+***
 *** @author Kane York (riking)
 *** @date 4 June 2013
-    public TemplateGenerator(World templateWorld) {
+*** @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) {
-}
+
             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
  * }
  */