Development Assistance Need help with schematic world generating

Im trying to make a world generate in a pattern
XXXXXXXXXXXX
OOOOOOOOOOO
XXXXXXXXXXXX
OOOOOOOOOOO
from two schematic files, i have a chunk generator that works fine but once i add the block populator it crashes the server and what ever i try it doesn't fix it. Can some one please try to get it working for me?

CellPopulator (open) CellPopulator (close)

Code:

import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

import org.bukkit.Chunk;
import org.bukkit.World;
import org.bukkit.generator.BlockPopulator;

public class CellPopulator extends BlockPopulator {

    //public String filepath;

    @Override
    @SuppressWarnings("deprecation")
    public void populate(World world, Random rand, Chunk chunk) {

        if (chunk.getX() % 2 == 0 && chunk.getZ() % 2 == 0) {

            try {
                File file = new File("plugins/NyxPrison/" + File.separator + "NCCell.schematic");
                //File file = new File(this.filepath);
                SchematicsManager man = new SchematicsManager();
                man.loadGzipedSchematic(file);

                int width = man.getWidth();
                int height = man.getHeight();
                int length = man.getLength();

                int starty = world.getHighestBlockAt(chunk.getX() * 16, chunk.getZ() * 16).getY();
                int endy = starty + height;

                for (int x = 0; x < width; x++) {
                    for (int z = 0; z < length; z++) {
                        int realX = x + chunk.getX() * 16;
                        int realZ = z + chunk.getZ() * 16;

                        for (int y = starty; y<=endy && y <255; y++) {

                            int rely = y - starty;
                            int id = man.getBlockIdAt(x, rely, z);
                            byte data = man.getMetadataAt(x, rely, z);
                            //System.out.println("GEN");
                            if (id != -1) world.getBlockAt(realX, y, realZ).setTypeId(id);
                            if (id != -1) world.getBlockAt(realX, y, realZ).setData(data);
                        }
                    }
                }

            } catch (IOException e) {
                System.out.println("Could not read the schematic file");
                e.printStackTrace();
            }
        }
    }

}

class SchematicsManager {

    private byte[] blocks,metadata;
    private short width,height,length;

    public void loadUncompressedSchematic(DataInput in) throws IOException{
        NBT_Tag compound = NBT_Tag.readTag(in);
        NBT_Tag_Compound tag = (NBT_Tag_Compound) compound;

        this.width = ((NBT_Tag_Short)tag.payload.get("Width")).payload;///x axis
        this.height = ((NBT_Tag_Short)tag.payload.get("Height")).payload;//y axis
        this.length = ((NBT_Tag_Short)tag.payload.get("Length")).payload;//z axis

        this.blocks = ((NBT_Tag_Byte_Array)tag.payload.get("Blocks")).payload;
        this.metadata = ((NBT_Tag_Byte_Array)tag.payload.get("Data")).payload;
    }

    public void writeUncompressedSchematic(DataOutput out) throws IOException {
        NBT_Tag_Compound root = new NBT_Tag_Compound("Schematic");
        root.payload.put("Width", new NBT_Tag_Short("Width",this.width));
        root.payload.put("Height", new NBT_Tag_Short("Height",this.height));
        root.payload.put("Length", new NBT_Tag_Short("Length",this.length));

        root.payload.put("Blocks", new NBT_Tag_Byte_Array("Blocks",this.blocks));
        root.payload.put("Data", new NBT_Tag_Byte_Array("Data",this.metadata));
        root.writeTag(out);
    }

    public void writeUncompressedSchematic(File f) throws IOException {
        DataOutputStream out = new DataOutputStream(new FileOutputStream(f));
        writeUncompressedSchematic(out);
        out.close();
    }

    public void writeGzipedSchematic(File f) throws IOException {
        DataOutputStream out = new DataOutputStream(new GZIPOutputStream(new FileOutputStream(f)));
        writeUncompressedSchematic(out);
        out.close();
    }

    //Most schematics are gzipped
    public void loadGzipedSchematic(File f) throws IOException {
        DataInputStream in = new DataInputStream(new GZIPInputStream(new FileInputStream(f)));
        loadUncompressedSchematic(in);
        in.close();
    }

    public void loadUncompressedSchematic(File f) throws IOException {
        DataInputStream in = new DataInputStream(new FileInputStream(f));
        loadUncompressedSchematic(in);
        in.close();
    }

    private int getBlockOffset(int x, int y, int z) {
        return y * width * length + z * width + x;
    }

    public byte getBlockIdAt(int x, int y, int z) {
        int offset = getBlockOffset(x, y, z);
        if (offset < this.blocks.length && offset >= 0) return this.blocks[offset];
        else return -1;
    }

    public void setBlockIdAt(int x, int y, int z, byte id) {
        int offset = getBlockOffset(x, y, z);
        if (offset < this.blocks.length && offset >= 0) this.blocks[offset] = id;
    }

    public byte getMetadataAt(int x, int y, int z) {
        int offset = getBlockOffset(x, y, z);
        if (offset < this.metadata.length && offset >= 0) return this.metadata[offset];
        else return 0;
    }

    public void setMetadataIdAt(int x, int y, int z, byte data) {
        int offset = getBlockOffset(x, y, z);
        if (offset < this.metadata.length && offset >= 0) this.metadata[offset] = data;
    }


    public short getWidth() {
        return width;
    }

    public void setWidth(short width) {
        this.width = width;
    }

    public short getHeight() {
        return height;
    }

    public void setHeight(short height) {
        this.height = height;
    }

    public short getLength() {
        return length;
    }

    public void setLength(short length) {
        this.length = length;
    }

    public byte[] getBlocks() {
        return blocks;
    }

    public void setBlocks(byte[] blocks) {
        this.blocks = blocks;
    }

    public byte[] getMetadata() {
        return metadata;
    }

    public void setMetadata(byte[] metadata) {
        this.metadata = metadata;
    }
}


//This marks the end of compound tags.
//It has no name, and is only ever a single byte
class NBT_Tag_End extends NBT_Tag{

    public NBT_Tag_End(String name){
        super(0, "");
    }

    public NBT_Tag_End(String name, int payload){
        super(8, name);
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        System.out.println("An error has occoured. An named binary tree tag 'end' has had it's payload read. It doesn't have a payload. Fix your code :D");
    }

    @Override
    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
    }

    public void writePayload(DataOutput out) throws IOException {}

}

class NBT_Tag_Double extends NBT_Tag{

    public double payload;

    public NBT_Tag_Double(String name){
        super(6, name);
    }

    public NBT_Tag_Double(String name, double payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readDouble();
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }
    public void writePayload(DataOutput out) throws IOException {
        out.writeDouble(this.payload);
    }
}

class NBT_Tag_Compound extends NBT_Tag{

    public HashMap<String,NBT_Tag> payload;

    public NBT_Tag_Compound(String name){
        super(10, name);
    }
    public NBT_Tag_Compound(String name, HashMap<String,NBT_Tag> payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        payload = new HashMap<String,NBT_Tag>();
        NBT_Tag tag;
        //while it isn't Tag_End
        while ((tag = NBT_Tag.readTag(in)).id != 0) {
            this.payload.put(tag.name,tag);
        }
        this.payload.put("__end",new NBT_Tag_End("__end"));
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        for(String key : payload.keySet()) {
            NBT_Tag tag = payload.get(key);
            tag.writeTag(out);
        }
    }
}

class NBT_Tag_Byte extends NBT_Tag{

    public byte payload;

    public NBT_Tag_Byte(String name){
        super(1,name);
    }
    public NBT_Tag_Byte(String name, byte payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readByte();
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        out.write(this.payload);
    }
}

class NBT_Tag_Byte_Array extends NBT_Tag{

    public int size;
    public byte[] payload;

    public NBT_Tag_Byte_Array(String name){
        super(7, name);
    }

    public NBT_Tag_Byte_Array(String name, byte[] payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        int size = in.readInt();
        this.size = size;
        this.payload = new byte[size];

        in.readFully(this.payload);
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        out.writeInt(this.size);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        for (byte i: this.payload) {
            out.writeByte(i);
        }
    }
}

class NBT_Tag_String extends NBT_Tag{

    public String payload;

    public NBT_Tag_String(String name){
        super(8, name);
    }
    public NBT_Tag_String(String name, String payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readUTF();
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        out.writeUTF(this.payload);
    }
}

class NBT_Tag_Short extends NBT_Tag{

    public short payload;

    public NBT_Tag_Short(String name){
        super(2, name);
    }
    public NBT_Tag_Short(String name, short payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readShort();
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        out.writeShort(this.payload);
    }

}

class NBT_Tag_Long extends NBT_Tag{

    public long payload;

    public NBT_Tag_Long(String name){
        super(4, name);
    }

    public NBT_Tag_Long(String name, Long payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readLong();
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        out.writeLong(this.payload);
    }

}

class NBT_Tag_List extends NBT_Tag{

    public byte tag_type;
    public int size;
    public ArrayList<NBT_Tag> payload;

    public NBT_Tag_List(String name){
        super(9, name);
    }

    public NBT_Tag_List(String name, ArrayList<NBT_Tag> payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.tag_type = in.readByte();
        int size = in.readInt();
        this.size = size;
        this.payload = new ArrayList<NBT_Tag>();

        for (int i = 0; i < size; i++) {
            NBT_Tag tag = NBT_Tag.getNewTag(this.tag_type, "");
            tag.readTagPayload(in);
            this.payload.add(tag);
        }
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        out.writeInt(this.size);

        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        for (NBT_Tag tag : this.payload) {
            tag.writePayload(out);
        }
    }
}

class NBT_Tag_Int extends NBT_Tag{

    public int payload;

    public NBT_Tag_Int(String name){
        super(3, name);
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readInt();
    }

    public NBT_Tag_Int(String name, int payload){
        super(8, name);
        this.payload = payload;
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        out.writeInt(this.payload);
    }

}

class NBT_Tag_Int_Array extends NBT_Tag{

    public int size;
    public int[] payload;

    public NBT_Tag_Int_Array(String name){
        super(11, name);
    }

    public NBT_Tag_Int_Array(String name, int[] payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        int size = in.readInt();
        this.size = size;
        this.payload = new int[size];

        for (int i = 0; i < size; i++) {
            this.payload[i] = in.readInt();
        }
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        out.writeInt(this.size);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        for (int i: this.payload) {
            out.writeInt(i);
        }
    }
}

class NBT_Tag_Float extends NBT_Tag{

    public float payload;

    public NBT_Tag_Float(String name){
        super(5, name);
    }
    public NBT_Tag_Float(String name, float payload){
        super(8, name);
        this.payload = payload;
    }

    @Override
    public void readTagPayload(DataInput in) throws IOException {
        this.payload = in.readFloat();
    }

    public void writeTag(DataOutput out) throws IOException {
        out.write(this.id);
        out.writeUTF(this.name);
        this.writePayload(out);
    }

    public void writePayload(DataOutput out) throws IOException {
        out.writeFloat(this.payload);
    }

}

abstract class NBT_Tag {

    public static NBT_Tag getNewTag(int id,String name) {
        switch (id) {
        case 0 : return new NBT_Tag_End("");
        case 1 : return new NBT_Tag_Byte(name);
        case 2 : return new NBT_Tag_Short(name);
        case 3 : return new NBT_Tag_Int(name);
        case 4 : return new NBT_Tag_Long(name);
        case 5 : return new NBT_Tag_Float(name);
        case 6 : return new NBT_Tag_Double(name);
        case 7 : return new NBT_Tag_Byte_Array(name);
        case 8 : return new NBT_Tag_String(name);
        case 9 : return new NBT_Tag_List(name);
        case 10 : return new NBT_Tag_Compound(name);
        case 11 : return new NBT_Tag_Int_Array(name);
        default : return null;
        }
    }
    public static NBT_Tag readTag(DataInput in) throws IOException {
        NBT_Tag tag;
        byte tag_id = in.readByte();
        if (tag_id == 0) return new NBT_Tag_End("");
        String tag_name = in.readUTF();
        tag = getNewTag(tag_id,tag_name);
        tag.readTagPayload(in);
        return tag;
    }

    //First byte of the tag is the type id
    byte id;

    //Then the name of the tag in UTF-8
    String name;

    //Then the tag-specific payload...

    public NBT_Tag(String name) {
        this.id = 0; //overwritten
        this.name = name;
    }
    protected NBT_Tag(int id, String name) {
        this.id = (byte) id;
        this.name = name;
    }

    //Read the tag's payload (assumes that the id,
    //name_length and name have already been read
    //in order to identfy the tag
    public abstract void readTagPayload(DataInput in) throws IOException;

    public abstract void writeTag(DataOutput out) throws IOException;

    public abstract void writePayload(DataOutput out) throws IOException;
}

CellGenerator (open) CellGenerator (close)

Code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.generator.*;
import org.bukkit.util.noise.SimplexNoiseGenerator;
import org.bukkit.util.noise.SimplexOctaveGenerator;

public class CellGenerator extends ChunkGenerator {

    /**
     * @param x        X co-ordinate of the block to be set in the array
     * @param y        Y co-ordinate of the block to be set in the array
     * @param z        Z co-ordinate of the block to be set in the array
     * @param chunk    An array containing the Block id's of all the blocks in the chunk. The first offset
     *                 is the block section number. There are 16 block sections, stacked vertically, each of which
     *                 16 by 16 by 16 blocks.
     * @param material The material to set the block to.
     */
    byte getBlock(int x, int y, int z, byte[][] chunk) {
        //if the Block section the block is in hasn't been used yet, allocate it
        if (chunk[y >> 4] == null)
            return 0; //block is air as it hasnt been allocated
        if (!(y <= 256 && y >= 0 && x <= 16 && x >= 0 && z <= 16 && z >= 0))
            return 0;
        try {
            return chunk[y >> 4][((y & 0xF) << 8) | (z << 4) | x];
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    void setBlock(int x, int y, int z, byte[][] chunk, Material material) {
        //if the Block section the block is in hasn't been used yet, allocate it
        if (chunk[y >> 4] == null)
            chunk[y >> 4] = new byte[16 * 16 * 16];
        if (!(y <= 256 && y >= 0 && x <= 16 && x >= 0 && z <= 16 && z >= 0))
            return;
        try {
            chunk[y >> 4][((y & 0xF) << 8) | (z << 4) | x] = (byte) material
                    .getId();
        } catch (Exception e) {
            // do nothing
        }
    }


    /**
     * @param world  The world the chunk belongs to
     * @param rand   Don't use this, make a new random object using the world seed (world.getSeed())
     * @param biome  Use this to set/get the current biome
     * @param ChunkX and ChunkZ
     *               The x and z co-ordinates of the current chunk.
     */
    @Override
    public byte[][] generateBlockSections(World world, Random rand, int ChunkX,
            int ChunkZ, BiomeGrid biome) {

        SimplexOctaveGenerator gen = new SimplexOctaveGenerator(world, 8);
        gen.setScale(1 / 12);
        byte[][] chunk = new byte[world.getMaxHeight() / 16][];

        for (int x = 0; x < 16; x++) {
            for (int z = 0; z < 16; z++) {
                setBlock(x, 0, z, chunk, Material.BEDROCK);
            }
        }
        for (int x = 0; x < 16; x++) {
            for (int z = 0; z < 16; z++) {
                double whatever = gen.noise(x + ChunkX * 16, z + ChunkZ * 16, 0.5, 0.5);
                for (int y = 1; y < 50 + whatever; y++) {
                    setBlock(x, y, z, chunk, Material.STONE);

                }
            }
        }
        // System.out.println("GENERATED");
        return chunk;
    }

    /**
     * Returns a list of all of the block populators (that do "little" features)
     * to be called after the chunk generator
     */
    @Override
    public List<BlockPopulator> getDefaultPopulators(World world) {
        ArrayList<BlockPopulator> pops = new ArrayList<BlockPopulator>();
        return Arrays.asList((BlockPopulator)new CellPopulator());
        //return pops;
    }


    public boolean canSpawn(World world, int x, int z) {
        return x > 5000 && z > 500;
    }
}

Crash Report (open) Crash Report (close)

Code:

---- Minecraft Crash Report ----
// Oh - I know what I did wrong!

Time: 12/18/14 12:59 AM
Description: Exception in server tick loop

java.lang.NullPointerException: Exception in server tick loop
    at org.bukkit.craftbukkit.v1_8_R1.util.CraftMagicNumbers.getBlock(CraftMagicNumbers.java:83)
    at org.bukkit.craftbukkit.v1_8_R1.util.CraftMagicNumbers.getBlock(CraftMagicNumbers.java:39)
    at org.bukkit.craftbukkit.v1_8_R1.block.CraftBlock.getNMSBlock(CraftBlock.java:47)
    at org.bukkit.craftbukkit.v1_8_R1.block.CraftBlock.setTypeId(CraftBlock.java:124)
    at org.bukkit.craftbukkit.v1_8_R1.block.CraftBlock.setTypeId(CraftBlock.java:120)
    at net.nyxcraft.dev.prison.world.CellPopulator.populate(CellPopulator.java:55)
    at net.minecraft.server.v1_8_R1.ChunkProviderServer.getChunkAt(ChunkProviderServer.java:283)
    at net.minecraft.server.v1_8_R1.Chunk.loadNearby(Chunk.java:982)
    at org.bukkit.craftbukkit.v1_8_R1.chunkio.ChunkIOProvider.callStage2(ChunkIOProvider.java:68)
    at org.bukkit.craftbukkit.v1_8_R1.chunkio.ChunkIOProvider.callStage2(ChunkIOProvider.java:13)
    at org.bukkit.craftbukkit.v1_8_R1.util.AsynchronousExecutor$Task.finish(AsynchronousExecutor.java:188)
    at org.bukkit.craftbukkit.v1_8_R1.util.AsynchronousExecutor.finishActive(AsynchronousExecutor.java:347)
    at org.bukkit.craftbukkit.v1_8_R1.chunkio.ChunkIOExecutor.tick(ChunkIOExecutor.java:34)
    at net.minecraft.server.v1_8_R1.MinecraftServer.z(MinecraftServer.java:705)
    at net.minecraft.server.v1_8_R1.DedicatedServer.z(DedicatedServer.java:316)
    at net.minecraft.server.v1_8_R1.MinecraftServer.y(MinecraftServer.java:623)
    at net.minecraft.server.v1_8_R1.MinecraftServer.run(MinecraftServer.java:526)
    at java.lang.Thread.run(Thread.java:745)

 

Moved to Alternatives Section.

 

Bump.
I figured out the problem but now it generates only a few rows of the schematic