2016-02-10 19:59:51 +01:00
|
|
|
package com.intellectualcrafters.plot.generator;
|
|
|
|
|
2016-03-31 19:23:26 +02:00
|
|
|
import com.intellectualcrafters.jnbt.CompoundTag;
|
2016-03-23 02:41:37 +01:00
|
|
|
import com.intellectualcrafters.plot.object.PlotArea;
|
|
|
|
import com.intellectualcrafters.plot.object.PlotBlock;
|
|
|
|
import com.intellectualcrafters.plot.object.PlotId;
|
|
|
|
import com.intellectualcrafters.plot.object.PlotManager;
|
|
|
|
import com.intellectualcrafters.plot.object.PseudoRandom;
|
2016-02-10 19:59:51 +01:00
|
|
|
import com.intellectualcrafters.plot.util.MathMan;
|
|
|
|
import com.intellectualcrafters.plot.util.PlotChunk;
|
2016-03-31 19:23:26 +02:00
|
|
|
import com.intellectualcrafters.plot.util.SchematicHandler;
|
2016-02-26 07:29:31 +01:00
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.Map.Entry;
|
|
|
|
|
2016-02-10 19:59:51 +01:00
|
|
|
public class HybridGen extends IndependentPlotGenerator {
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String getName() {
|
|
|
|
return "PlotSquared";
|
|
|
|
}
|
2016-03-23 02:41:37 +01:00
|
|
|
|
2016-02-10 19:59:51 +01:00
|
|
|
@Override
|
|
|
|
public void generateChunk(PlotChunk<?> result, PlotArea settings, PseudoRandom random) {
|
|
|
|
HybridPlotWorld hpw = (HybridPlotWorld) settings;
|
|
|
|
// Biome
|
|
|
|
for (short x = 0; x < 16; x++) {
|
|
|
|
for (short z = 0; z < 16; z++) {
|
|
|
|
result.setBiome(x, z, hpw.PLOT_BIOME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Bedrock
|
|
|
|
if (hpw.PLOT_BEDROCK) {
|
|
|
|
for (short x = 0; x < 16; x++) {
|
|
|
|
for (short z = 0; z < 16; z++) {
|
|
|
|
result.setBlock(x, 0, z, (short) 7, (byte) 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Coords
|
|
|
|
int cx = result.getX();
|
|
|
|
int cz = result.getZ();
|
2016-02-12 17:25:04 +01:00
|
|
|
int bx = (cx << 4) - hpw.ROAD_OFFSET_X;
|
|
|
|
int bz = (cz << 4) - hpw.ROAD_OFFSET_Z;
|
2016-03-23 02:41:37 +01:00
|
|
|
short rbx;
|
|
|
|
if (bx < 0) {
|
|
|
|
rbx = (short) (hpw.SIZE + (bx % hpw.SIZE));
|
|
|
|
} else {
|
|
|
|
rbx = (short) (bx % hpw.SIZE);
|
|
|
|
}
|
|
|
|
short rbz;
|
|
|
|
if (bz < 0) {
|
|
|
|
rbz = (short) (hpw.SIZE + (bz % hpw.SIZE));
|
|
|
|
} else {
|
|
|
|
rbz = (short) (bz % hpw.SIZE);
|
|
|
|
}
|
2016-02-10 19:59:51 +01:00
|
|
|
short[] rx = new short[16];
|
|
|
|
boolean[] gx = new boolean[16];
|
|
|
|
boolean[] wx = new boolean[16];
|
|
|
|
for (short i = 0; i < 16; i++) {
|
|
|
|
short v = (short) (rbx + i);
|
|
|
|
if (v >= hpw.SIZE) {
|
|
|
|
v -= hpw.SIZE;
|
|
|
|
}
|
|
|
|
rx[i] = v;
|
|
|
|
if (hpw.ROAD_WIDTH != 0) {
|
|
|
|
gx[i] = v < hpw.PATH_WIDTH_LOWER || v > hpw.PATH_WIDTH_UPPER;
|
|
|
|
wx[i] = v == hpw.PATH_WIDTH_LOWER || v == hpw.PATH_WIDTH_UPPER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
short[] rz = new short[16];
|
|
|
|
boolean[] gz = new boolean[16];
|
|
|
|
boolean[] wz = new boolean[16];
|
|
|
|
for (short i = 0; i < 16; i++) {
|
|
|
|
short v = (short) (rbz + i);
|
|
|
|
if (v >= hpw.SIZE) {
|
|
|
|
v -= hpw.SIZE;
|
|
|
|
}
|
|
|
|
rz[i] = v;
|
|
|
|
if (hpw.ROAD_WIDTH != 0) {
|
|
|
|
gz[i] = v < hpw.PATH_WIDTH_LOWER || v > hpw.PATH_WIDTH_UPPER;
|
|
|
|
wz[i] = v == hpw.PATH_WIDTH_LOWER || v == hpw.PATH_WIDTH_UPPER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// generation
|
|
|
|
HashMap<Integer, HashMap<Integer, PlotBlock>> sch = hpw.G_SCH;
|
|
|
|
for (short x = 0; x < 16; x++) {
|
|
|
|
if (gx[x]) {
|
|
|
|
for (short z = 0; z < 16; z++) {
|
|
|
|
// Road
|
|
|
|
for (int y = 1; y <= hpw.ROAD_HEIGHT; y++) {
|
|
|
|
result.setBlock(x, y, z, hpw.ROAD_BLOCK);
|
|
|
|
}
|
|
|
|
if (hpw.ROAD_SCHEMATIC_ENABLED) {
|
2016-02-26 07:29:31 +01:00
|
|
|
HashMap<Integer, PlotBlock> map = sch.get(MathMan.pair(rx[x], rz[z]));
|
2016-02-10 19:59:51 +01:00
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, PlotBlock> entry : map.entrySet()) {
|
|
|
|
result.setBlock(x, entry.getKey(), z, entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (wx[x]) {
|
|
|
|
for (short z = 0; z < 16; z++) {
|
|
|
|
if (gz[z]) {
|
|
|
|
// road
|
|
|
|
for (int y = 1; y <= hpw.ROAD_HEIGHT; y++) {
|
|
|
|
result.setBlock(x, y, z, hpw.ROAD_BLOCK);
|
|
|
|
}
|
|
|
|
if (hpw.ROAD_SCHEMATIC_ENABLED) {
|
2016-02-26 07:29:31 +01:00
|
|
|
HashMap<Integer, PlotBlock> map = sch.get(MathMan.pair(rx[x], rz[z]));
|
2016-02-10 19:59:51 +01:00
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, PlotBlock> entry : map.entrySet()) {
|
|
|
|
result.setBlock(x, entry.getKey(), z, entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// wall
|
|
|
|
for (int y = 1; y <= hpw.WALL_HEIGHT; y++) {
|
|
|
|
result.setBlock(x, y, z, hpw.WALL_FILLING);
|
|
|
|
}
|
|
|
|
if (!hpw.ROAD_SCHEMATIC_ENABLED) {
|
|
|
|
result.setBlock(x, hpw.WALL_HEIGHT + 1, z, hpw.WALL_BLOCK);
|
|
|
|
} else {
|
2016-02-26 07:29:31 +01:00
|
|
|
HashMap<Integer, PlotBlock> map = sch.get(MathMan.pair(rx[x], rz[z]));
|
2016-02-10 19:59:51 +01:00
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, PlotBlock> entry : map.entrySet()) {
|
|
|
|
result.setBlock(x, entry.getKey(), z, entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (short z = 0; z < 16; z++) {
|
|
|
|
if (gz[z]) {
|
|
|
|
// road
|
|
|
|
for (int y = 1; y <= hpw.ROAD_HEIGHT; y++) {
|
|
|
|
result.setBlock(x, y, z, hpw.ROAD_BLOCK);
|
|
|
|
}
|
|
|
|
if (hpw.ROAD_SCHEMATIC_ENABLED) {
|
2016-02-26 07:29:31 +01:00
|
|
|
HashMap<Integer, PlotBlock> map = sch.get(MathMan.pair(rx[x], rz[z]));
|
2016-02-10 19:59:51 +01:00
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, PlotBlock> entry : map.entrySet()) {
|
|
|
|
result.setBlock(x, entry.getKey(), z, entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (wz[z]) {
|
|
|
|
// wall
|
|
|
|
for (int y = 1; y <= hpw.WALL_HEIGHT; y++) {
|
|
|
|
result.setBlock(x, y, z, hpw.WALL_FILLING);
|
|
|
|
}
|
|
|
|
if (!hpw.ROAD_SCHEMATIC_ENABLED) {
|
|
|
|
result.setBlock(x, hpw.WALL_HEIGHT + 1, z, hpw.WALL_BLOCK);
|
|
|
|
} else {
|
2016-02-26 07:29:31 +01:00
|
|
|
HashMap<Integer, PlotBlock> map = sch.get(MathMan.pair(rx[x], rz[z]));
|
2016-02-10 19:59:51 +01:00
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, PlotBlock> entry : map.entrySet()) {
|
|
|
|
result.setBlock(x, entry.getKey(), z, entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// plot
|
|
|
|
for (int y = 1; y < hpw.PLOT_HEIGHT; y++) {
|
|
|
|
result.setBlock(x, y, z, hpw.MAIN_BLOCK[random.random(hpw.MAIN_BLOCK.length)]);
|
|
|
|
}
|
|
|
|
result.setBlock(x, hpw.PLOT_HEIGHT, z, hpw.TOP_BLOCK[random.random(hpw.TOP_BLOCK.length)]);
|
|
|
|
if (hpw.PLOT_SCHEMATIC) {
|
2016-03-31 19:23:26 +02:00
|
|
|
int pair = MathMan.pair(rx[x], rz[z]);
|
|
|
|
HashMap<Integer, PlotBlock> map = sch.get(pair);
|
2016-02-10 19:59:51 +01:00
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, PlotBlock> entry : map.entrySet()) {
|
|
|
|
result.setBlock(x, entry.getKey(), z, entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-23 02:41:37 +01:00
|
|
|
|
2016-03-31 19:23:26 +02:00
|
|
|
@Override
|
|
|
|
public boolean populateChunk(PlotChunk<?> result, PlotArea settings, PseudoRandom random) {
|
|
|
|
HybridPlotWorld hpw = (HybridPlotWorld) settings;
|
|
|
|
if (hpw.G_SCH_STATE != null) {
|
|
|
|
int cx = result.getX();
|
|
|
|
int cz = result.getZ();
|
|
|
|
int p1x = cx << 4;
|
|
|
|
int p1z = cz << 4;
|
|
|
|
int bx = p1x - hpw.ROAD_OFFSET_X;
|
|
|
|
int bz = p1z - hpw.ROAD_OFFSET_Z;
|
|
|
|
short rbx;
|
|
|
|
if (bx < 0) {
|
|
|
|
rbx = (short) (hpw.SIZE + (bx % hpw.SIZE));
|
|
|
|
} else {
|
|
|
|
rbx = (short) (bx % hpw.SIZE);
|
|
|
|
}
|
|
|
|
short rbz;
|
|
|
|
if (bz < 0) {
|
|
|
|
rbz = (short) (hpw.SIZE + (bz % hpw.SIZE));
|
|
|
|
} else {
|
|
|
|
rbz = (short) (bz % hpw.SIZE);
|
|
|
|
}
|
|
|
|
short[] rx = new short[16];
|
|
|
|
for (short i = 0; i < 16; i++) {
|
|
|
|
short v = (short) (rbx + i);
|
|
|
|
if (v >= hpw.SIZE) {
|
|
|
|
v -= hpw.SIZE;
|
|
|
|
}
|
|
|
|
rx[i] = v;
|
|
|
|
}
|
|
|
|
short[] rz = new short[16];
|
|
|
|
for (short i = 0; i < 16; i++) {
|
|
|
|
short v = (short) (rbz + i);
|
|
|
|
if (v >= hpw.SIZE) {
|
|
|
|
v -= hpw.SIZE;
|
|
|
|
}
|
|
|
|
rz[i] = v;
|
|
|
|
}
|
|
|
|
for (short x = 0; x < 16; x++) {
|
|
|
|
for (short z = 0; z < 16; z++) {
|
|
|
|
int pair = MathMan.pair(rx[x], rz[z]);
|
|
|
|
HashMap<Integer, CompoundTag> map = hpw.G_SCH_STATE.get(pair);
|
|
|
|
if (map != null) {
|
|
|
|
for (Entry<Integer, CompoundTag> entry : map.entrySet()) {
|
|
|
|
SchematicHandler.manager.restoreTile(hpw.worldname, entry.getValue(), p1x + x, entry.getKey(), p1z + z);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-02-10 19:59:51 +01:00
|
|
|
@Override
|
|
|
|
public PlotArea getNewPlotArea(String world, String id, PlotId min, PlotId max) {
|
|
|
|
return new HybridPlotWorld(world, id, this, min, max);
|
|
|
|
}
|
2016-03-23 02:41:37 +01:00
|
|
|
|
2016-02-10 19:59:51 +01:00
|
|
|
@Override
|
|
|
|
public PlotManager getNewPlotManager() {
|
|
|
|
return new HybridPlotManager();
|
|
|
|
}
|
2016-03-23 02:41:37 +01:00
|
|
|
|
2016-02-10 19:59:51 +01:00
|
|
|
@Override
|
|
|
|
public void initialize(PlotArea area) {
|
|
|
|
// All initialization is done in the PlotArea class
|
|
|
|
}
|
|
|
|
}
|