diff --git a/src/main/java/net/minecraft/server/WorldGenBigTree.java b/src/main/java/net/minecraft/server/WorldGenBigTree.java
new file mode 100644
index 0000000000..7e093a6464
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenBigTree.java
@@ -0,0 +1,373 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+//CraftBukkit start
+import org.bukkit.BlockChangeDelegate;
+//CraftBukkit end
+
+public class WorldGenBigTree extends WorldGenerator {
+
+ static final byte[] a = new byte[] { (byte) 2, (byte) 0, (byte) 0, (byte) 1, (byte) 2, (byte) 1};
+ Random b = new Random();
+ // CraftBukkit start
+ BlockChangeDelegate c;
+ // CraftBukkit end
+ int[] d = new int[] { 0, 0, 0};
+ int e = 0;
+ int f;
+ double g = 0.618D;
+ double h = 1.0D;
+ double i = 0.381D;
+ double j = 1.0D;
+ double k = 1.0D;
+ int l = 1;
+ int m = 12;
+ int n = 4;
+ int[][] o;
+
+ public WorldGenBigTree() {}
+
+ void a() {
+ this.f = (int) ((double) this.e * this.g);
+ if (this.f >= this.e) {
+ this.f = this.e - 1;
+ }
+
+ int i = (int) (1.382D + Math.pow(this.k * (double) this.e / 13.0D, 2.0D));
+
+ if (i < 1) {
+ i = 1;
+ }
+
+ int[][] aint = new int[i * this.e][4];
+ int j = this.d[1] + this.e - this.n;
+ int k = 1;
+ int l = this.d[1] + this.f;
+ int i1 = j - this.d[1];
+
+ aint[0][0] = this.d[0];
+ aint[0][1] = j;
+ aint[0][2] = this.d[2];
+ aint[0][3] = l;
+ --j;
+
+ while (i1 >= 0) {
+ int j1 = 0;
+ float f = this.a(i1);
+
+ if (f < 0.0F) {
+ --j;
+ --i1;
+ } else {
+ for (double d0 = 0.5D; j1 < i; ++j1) {
+ double d1 = this.j * (double) f * ((double) this.b.nextFloat() + 0.328D);
+ double d2 = (double) this.b.nextFloat() * 2.0D * 3.14159D;
+ int k1 = (int) (d1 * Math.sin(d2) + (double) this.d[0] + d0);
+ int l1 = (int) (d1 * Math.cos(d2) + (double) this.d[2] + d0);
+ int[] aint1 = new int[] { k1, j, l1};
+ int[] aint2 = new int[] { k1, j + this.n, l1};
+
+ if (this.a(aint1, aint2) == -1) {
+ int[] aint3 = new int[] { this.d[0], this.d[1], this.d[2]};
+ double d3 = Math.sqrt(Math.pow((double) Math.abs(this.d[0] - aint1[0]), 2.0D) + Math.pow((double) Math.abs(this.d[2] - aint1[2]), 2.0D));
+ double d4 = d3 * this.i;
+
+ if ((double) aint1[1] - d4 > (double) l) {
+ aint3[1] = l;
+ } else {
+ aint3[1] = (int) ((double) aint1[1] - d4);
+ }
+
+ if (this.a(aint3, aint1) == -1) {
+ aint[k][0] = k1;
+ aint[k][1] = j;
+ aint[k][2] = l1;
+ aint[k][3] = aint3[1];
+ ++k;
+ }
+ }
+ }
+
+ --j;
+ --i1;
+ }
+ }
+
+ this.o = new int[k][4];
+ System.arraycopy(aint, 0, this.o, 0, k);
+ }
+
+ void a(int i, int j, int k, float f, byte b0, int l) {
+ int i1 = (int) ((double) f + 0.618D);
+ byte b1 = a[b0];
+ byte b2 = a[b0 + 3];
+ int[] aint = new int[] { i, j, k};
+ int[] aint1 = new int[] { 0, 0, 0};
+ int j1 = -i1;
+ int k1 = -i1;
+
+ for (aint1[b0] = aint[b0]; j1 <= i1; ++j1) {
+ aint1[b1] = aint[b1] + j1;
+ k1 = -i1;
+
+ while (k1 <= i1) {
+ double d0 = Math.sqrt(Math.pow((double) Math.abs(j1) + 0.5D, 2.0D) + Math.pow((double) Math.abs(k1) + 0.5D, 2.0D));
+
+ if (d0 > (double) f) {
+ ++k1;
+ } else {
+ aint1[b2] = aint[b2] + k1;
+ int l1 = this.c.getTypeId(aint1[0], aint1[1], aint1[2]);
+
+ if (l1 != 0 && l1 != 18) {
+ ++k1;
+ } else {
+ this.c.setTypeId(aint1[0], aint1[1], aint1[2], l);
+ ++k1;
+ }
+ }
+ }
+ }
+ }
+
+ float a(int i) {
+ if ((double) i < (double) ((float) this.e) * 0.3D) {
+ return -1.618F;
+ } else {
+ float f = (float) this.e / 2.0F;
+ float f1 = (float) this.e / 2.0F - (float) i;
+ float f2;
+
+ if (f1 == 0.0F) {
+ f2 = f;
+ } else if (Math.abs(f1) >= f) {
+ f2 = 0.0F;
+ } else {
+ f2 = (float) Math.sqrt(Math.pow((double) Math.abs(f), 2.0D) - Math.pow((double) Math.abs(f1), 2.0D));
+ }
+
+ f2 *= 0.5F;
+ return f2;
+ }
+ }
+
+ float b(int i) {
+ return i >= 0 && i < this.n ? (i != 0 && i != this.n - 1 ? 3.0F : 2.0F) : -1.0F;
+ }
+
+ void a(int i, int j, int k) {
+ int l = j;
+
+ for (int i1 = j + this.n; l < i1; ++l) {
+ float f = this.b(l - j);
+
+ this.a(i, l, k, f, (byte) 1, 18);
+ }
+ }
+
+ void a(int[] aint, int[] aint1, int i) {
+ int[] aint2 = new int[] { 0, 0, 0};
+ byte b0 = 0;
+
+ byte b1;
+
+ for (b1 = 0; b0 < 3; ++b0) {
+ aint2[b0] = aint1[b0] - aint[b0];
+ if (Math.abs(aint2[b0]) > Math.abs(aint2[b1])) {
+ b1 = b0;
+ }
+ }
+
+ if (aint2[b1] != 0) {
+ byte b2 = a[b1];
+ byte b3 = a[b1 + 3];
+ byte b4;
+
+ if (aint2[b1] > 0) {
+ b4 = 1;
+ } else {
+ b4 = -1;
+ }
+
+ double d0 = (double) aint2[b2] / (double) aint2[b1];
+ double d1 = (double) aint2[b3] / (double) aint2[b1];
+ int[] aint3 = new int[] { 0, 0, 0};
+ int j = 0;
+
+ for (int k = aint2[b1] + b4; j != k; j += b4) {
+ aint3[b1] = MathHelper.b((double) (aint[b1] + j) + 0.5D);
+ aint3[b2] = MathHelper.b((double) aint[b2] + (double) j * d0 + 0.5D);
+ aint3[b3] = MathHelper.b((double) aint[b3] + (double) j * d1 + 0.5D);
+ this.c.setTypeId(aint3[0], aint3[1], aint3[2], i);
+ }
+ }
+ }
+
+ void b() {
+ int i = 0;
+
+ for (int j = this.o.length; i < j; ++i) {
+ int k = this.o[i][0];
+ int l = this.o[i][1];
+ int i1 = this.o[i][2];
+
+ this.a(k, l, i1);
+ }
+ }
+
+ boolean c(int i) {
+ return (double) i >= (double) this.e * 0.2D;
+ }
+
+ void c() {
+ int i = this.d[0];
+ int j = this.d[1];
+ int k = this.d[1] + this.f;
+ int l = this.d[2];
+ int[] aint = new int[] { i, j, l};
+ int[] aint1 = new int[] { i, k, l};
+
+ this.a(aint, aint1, 17);
+ if (this.l == 2) {
+ ++aint[0];
+ ++aint1[0];
+ this.a(aint, aint1, 17);
+ ++aint[2];
+ ++aint1[2];
+ this.a(aint, aint1, 17);
+ aint[0] += -1;
+ aint1[0] += -1;
+ this.a(aint, aint1, 17);
+ }
+ }
+
+ void d() {
+ int i = 0;
+ int j = this.o.length;
+
+ for (int[] aint = new int[] { this.d[0], this.d[1], this.d[2]}; i < j; ++i) {
+ int[] aint1 = this.o[i];
+ int[] aint2 = new int[] { aint1[0], aint1[1], aint1[2]};
+
+ aint[1] = aint1[3];
+ int k = aint[1] - this.d[1];
+
+ if (this.c(k)) {
+ this.a(aint, aint2, 17);
+ }
+ }
+ }
+
+ int a(int[] aint, int[] aint1) {
+ int[] aint2 = new int[] { 0, 0, 0};
+ byte b0 = 0;
+
+ byte b1;
+
+ for (b1 = 0; b0 < 3; ++b0) {
+ aint2[b0] = aint1[b0] - aint[b0];
+ if (Math.abs(aint2[b0]) > Math.abs(aint2[b1])) {
+ b1 = b0;
+ }
+ }
+
+ if (aint2[b1] == 0) {
+ return -1;
+ } else {
+ byte b2 = a[b1];
+ byte b3 = a[b1 + 3];
+ byte b4;
+
+ if (aint2[b1] > 0) {
+ b4 = 1;
+ } else {
+ b4 = -1;
+ }
+
+ double d0 = (double) aint2[b2] / (double) aint2[b1];
+ double d1 = (double) aint2[b3] / (double) aint2[b1];
+ int[] aint3 = new int[] { 0, 0, 0};
+ int i = 0;
+
+ int j;
+
+ for (j = aint2[b1] + b4; i != j; i += b4) {
+ aint3[b1] = aint[b1] + i;
+ aint3[b2] = (int) ((double) aint[b2] + (double) i * d0);
+ aint3[b3] = (int) ((double) aint[b3] + (double) i * d1);
+ int k = this.c.getTypeId(aint3[0], aint3[1], aint3[2]);
+
+ if (k != 0 && k != 18) {
+ break;
+ }
+ }
+
+ return i == j ? -1 : Math.abs(i);
+ }
+ }
+
+ boolean e() {
+ int[] aint = new int[] { this.d[0], this.d[1], this.d[2]};
+ int[] aint1 = new int[] { this.d[0], this.d[1] + this.e - 1, this.d[2]};
+ int i = this.c.getTypeId(this.d[0], this.d[1] - 1, this.d[2]);
+
+ if (i != 2 && i != 3) {
+ return false;
+ } else {
+ int j = this.a(aint, aint1);
+
+ if (j == -1) {
+ return true;
+ } else if (j < 6) {
+ return false;
+ } else {
+ this.e = j;
+ return true;
+ }
+ }
+ }
+
+ public void a(double d0, double d1, double d2) {
+ this.m = (int) (d0 * 12.0D);
+ if (d0 > 0.5D) {
+ this.n = 5;
+ }
+
+ this.j = d1;
+ this.k = d2;
+ }
+
+ public boolean a(World world, Random random, int i, int j, int k) {
+ // CraftBukkit start
+ // sk: The idea is to have (our) WorldServer implement
+ // BlockChangeDelegate and then we can implicitly cast World to
+ // WorldServer (a safe cast, AFAIK) and no code will be broken. This
+ // then allows plugins to catch manually-invoked generation events
+ return generate((BlockChangeDelegate)world, random, i, j, k);
+ }
+
+ public boolean generate(BlockChangeDelegate world, Random random, int i, int j, int k) {
+ // CraftBukkit end
+ this.c = world;
+ long l = random.nextLong();
+
+ this.b.setSeed(l);
+ this.d[0] = i;
+ this.d[1] = j;
+ this.d[2] = k;
+ if (this.e == 0) {
+ this.e = 5 + this.b.nextInt(this.m);
+ }
+
+ if (!this.e()) {
+ return false;
+ } else {
+ this.a();
+ this.b();
+ this.c();
+ this.d();
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenForest.java b/src/main/java/net/minecraft/server/WorldGenForest.java
new file mode 100644
index 0000000000..6830fb93fe
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenForest.java
@@ -0,0 +1,100 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+//CraftBukkit start
+import org.bukkit.BlockChangeDelegate;
+//CraftBukkit end
+
+public class WorldGenForest extends WorldGenerator {
+
+ public WorldGenForest() {}
+
+ public boolean a(World world, Random random, int i, int j, int k) {
+ // CraftBukkit start
+ // sk: The idea is to have (our) WorldServer implement
+ // BlockChangeDelegate and then we can implicitly cast World to
+ // WorldServer (a safe cast, AFAIK) and no code will be broken. This
+ // then allows plugins to catch manually-invoked generation events
+ return generate((BlockChangeDelegate)world, random, i, j, k);
+ }
+
+ public boolean generate(BlockChangeDelegate world, Random random, int i, int j, int k) {
+ // CraftBukkit end
+ int l = random.nextInt(3) + 5;
+ boolean flag = true;
+
+ if (j >= 1 && j + l + 1 <= 128) {
+ int i1;
+ int j1;
+ int k1;
+ int l1;
+
+ for (i1 = j; i1 <= j + 1 + l; ++i1) {
+ byte b0 = 1;
+
+ if (i1 == j) {
+ b0 = 0;
+ }
+
+ if (i1 >= j + 1 + l - 2) {
+ b0 = 2;
+ }
+
+ for (j1 = i - b0; j1 <= i + b0 && flag; ++j1) {
+ for (k1 = k - b0; k1 <= k + b0 && flag; ++k1) {
+ if (i1 >= 0 && i1 < 128) {
+ l1 = world.getTypeId(j1, i1, k1);
+ if (l1 != 0 && l1 != Block.LEAVES.id) {
+ flag = false;
+ }
+ } else {
+ flag = false;
+ }
+ }
+ }
+ }
+
+ if (!flag) {
+ return false;
+ } else {
+ i1 = world.getTypeId(i, j - 1, k);
+ if ((i1 == Block.GRASS.id || i1 == Block.DIRT.id) && j < 128 - l - 1) {
+ world.setTypeId(i, j - 1, k, Block.DIRT.id);
+
+ int i2;
+
+ for (i2 = j - 3 + l; i2 <= j + l; ++i2) {
+ j1 = i2 - (j + l);
+ k1 = 1 - j1 / 2;
+
+ for (l1 = i - k1; l1 <= i + k1; ++l1) {
+ int j2 = l1 - i;
+
+ for (int k2 = k - k1; k2 <= k + k1; ++k2) {
+ int l2 = k2 - k;
+
+ if ((Math.abs(j2) != k1 || Math.abs(l2) != k1 || random.nextInt(2) != 0 && j1 != 0) && !Block.o[world.getTypeId(l1, i2, k2)]) {
+ world.setTypeIdAndData(l1, i2, k2, Block.LEAVES.id, 2);
+ }
+ }
+ }
+ }
+
+ for (i2 = 0; i2 < l; ++i2) {
+ j1 = world.getTypeId(i, j + i2, k);
+ if (j1 == 0 || j1 == Block.LEAVES.id) {
+ world.setTypeIdAndData(i, j + i2, k, Block.LOG.id, 2);
+ }
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+ } else {
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenTaiga1.java b/src/main/java/net/minecraft/server/WorldGenTaiga1.java
new file mode 100644
index 0000000000..f7fea2c4de
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenTaiga1.java
@@ -0,0 +1,104 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+//CraftBukkit start
+import org.bukkit.BlockChangeDelegate;
+//CraftBukkit end
+
+public class WorldGenTaiga1 extends WorldGenerator {
+
+ public WorldGenTaiga1() {}
+
+ public boolean a(World world, Random random, int i, int j, int k) {
+ // CraftBukkit start
+ // sk: The idea is to have (our) WorldServer implement
+ // BlockChangeDelegate and then we can implicitly cast World to
+ // WorldServer (a safe cast, AFAIK) and no code will be broken. This
+ // then allows plugins to catch manually-invoked generation events
+ return generate((BlockChangeDelegate)world, random, i, j, k);
+ }
+
+ public boolean generate(BlockChangeDelegate world, Random random, int i, int j, int k) {
+ // CraftBukkit end
+ int l = random.nextInt(5) + 7;
+ int i1 = l - random.nextInt(2) - 3;
+ int j1 = l - i1;
+ int k1 = 1 + random.nextInt(j1 + 1);
+ boolean flag = true;
+
+ if (j >= 1 && j + l + 1 <= 128) {
+ int l1;
+ int i2;
+ int j2;
+ int k2;
+ int l2;
+
+ for (l1 = j; l1 <= j + 1 + l && flag; ++l1) {
+ boolean flag1 = true;
+
+ if (l1 - j < i1) {
+ l2 = 0;
+ } else {
+ l2 = k1;
+ }
+
+ for (i2 = i - l2; i2 <= i + l2 && flag; ++i2) {
+ for (j2 = k - l2; j2 <= k + l2 && flag; ++j2) {
+ if (l1 >= 0 && l1 < 128) {
+ k2 = world.getTypeId(i2, l1, j2);
+ if (k2 != 0 && k2 != Block.LEAVES.id) {
+ flag = false;
+ }
+ } else {
+ flag = false;
+ }
+ }
+ }
+ }
+
+ if (!flag) {
+ return false;
+ } else {
+ l1 = world.getTypeId(i, j - 1, k);
+ if ((l1 == Block.GRASS.id || l1 == Block.DIRT.id) && j < 128 - l - 1) {
+ world.setTypeId(i, j - 1, k, Block.DIRT.id);
+ l2 = 0;
+
+ for (i2 = j + l; i2 >= j + i1; --i2) {
+ for (j2 = i - l2; j2 <= i + l2; ++j2) {
+ k2 = j2 - i;
+
+ for (int i3 = k - l2; i3 <= k + l2; ++i3) {
+ int j3 = i3 - k;
+
+ if ((Math.abs(k2) != l2 || Math.abs(j3) != l2 || l2 <= 0) && !Block.o[world.getTypeId(j2, i2, i3)]) {
+ world.setTypeIdAndData(j2, i2, i3, Block.LEAVES.id, 1);
+ }
+ }
+ }
+
+ if (l2 >= 1 && i2 == j + i1 + 1) {
+ --l2;
+ } else if (l2 < k1) {
+ ++l2;
+ }
+ }
+
+ for (i2 = 0; i2 < l - 1; ++i2) {
+ j2 = world.getTypeId(i, j + i2, k);
+ if (j2 == 0 || j2 == Block.LEAVES.id) {
+ world.setTypeIdAndData(i, j + i2, k, Block.LOG.id, 1);
+ }
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+ } else {
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenTaiga2.java b/src/main/java/net/minecraft/server/WorldGenTaiga2.java
new file mode 100644
index 0000000000..f2904b4e7a
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenTaiga2.java
@@ -0,0 +1,117 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+//CraftBukkit start
+import org.bukkit.BlockChangeDelegate;
+//CraftBukkit end
+
+public class WorldGenTaiga2 extends WorldGenerator {
+
+ public WorldGenTaiga2() {}
+
+ public boolean a(World world, Random random, int i, int j, int k) {
+ // CraftBukkit start
+ // sk: The idea is to have (our) WorldServer implement
+ // BlockChangeDelegate and then we can implicitly cast World to
+ // WorldServer (a safe cast, AFAIK) and no code will be broken. This
+ // then allows plugins to catch manually-invoked generation events
+ return generate((BlockChangeDelegate)world, random, i, j, k);
+ }
+
+ public boolean generate(BlockChangeDelegate world, Random random, int i, int j, int k) {
+ // CraftBukkit end
+ int l = random.nextInt(4) + 6;
+ int i1 = 1 + random.nextInt(2);
+ int j1 = l - i1;
+ int k1 = 2 + random.nextInt(2);
+ boolean flag = true;
+
+ if (j >= 1 && j + l + 1 <= 128) {
+ int l1;
+ int i2;
+ int j2;
+ int k2;
+
+ for (l1 = j; l1 <= j + 1 + l && flag; ++l1) {
+ boolean flag1 = true;
+
+ if (l1 - j < i1) {
+ k2 = 0;
+ } else {
+ k2 = k1;
+ }
+
+ for (i2 = i - k2; i2 <= i + k2 && flag; ++i2) {
+ for (int l2 = k - k2; l2 <= k + k2 && flag; ++l2) {
+ if (l1 >= 0 && l1 < 128) {
+ j2 = world.getTypeId(i2, l1, l2);
+ if (j2 != 0 && j2 != Block.LEAVES.id) {
+ flag = false;
+ }
+ } else {
+ flag = false;
+ }
+ }
+ }
+ }
+
+ if (!flag) {
+ return false;
+ } else {
+ l1 = world.getTypeId(i, j - 1, k);
+ if ((l1 == Block.GRASS.id || l1 == Block.DIRT.id) && j < 128 - l - 1) {
+ world.setTypeId(i, j - 1, k, Block.DIRT.id);
+ k2 = random.nextInt(2);
+ i2 = 1;
+ byte b0 = 0;
+
+ int i3;
+ int j3;
+
+ for (j2 = 0; j2 <= j1; ++j2) {
+ j3 = j + l - j2;
+
+ for (i3 = i - k2; i3 <= i + k2; ++i3) {
+ int k3 = i3 - i;
+
+ for (int l3 = k - k2; l3 <= k + k2; ++l3) {
+ int i4 = l3 - k;
+
+ if ((Math.abs(k3) != k2 || Math.abs(i4) != k2 || k2 <= 0) && !Block.o[world.getTypeId(i3, j3, l3)]) {
+ world.setTypeIdAndData(i3, j3, l3, Block.LEAVES.id, 1);
+ }
+ }
+ }
+
+ if (k2 >= i2) {
+ k2 = b0;
+ b0 = 1;
+ ++i2;
+ if (i2 > k1) {
+ i2 = k1;
+ }
+ } else {
+ ++k2;
+ }
+ }
+
+ j2 = random.nextInt(3);
+
+ for (j3 = 0; j3 < l - j2; ++j3) {
+ i3 = world.getTypeId(i, j + j3, k);
+ if (i3 == 0 || i3 == Block.LEAVES.id) {
+ world.setTypeIdAndData(i, j + j3, k, Block.LOG.id, 1);
+ }
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+ } else {
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenTrees.java b/src/main/java/net/minecraft/server/WorldGenTrees.java
new file mode 100644
index 0000000000..a6057e3bc2
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenTrees.java
@@ -0,0 +1,100 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+// CraftBukkit start
+import org.bukkit.BlockChangeDelegate;
+// CraftBukkit end
+
+public class WorldGenTrees extends WorldGenerator {
+
+ public WorldGenTrees() {}
+
+ public boolean a(World world, Random random, int i, int j, int k) {
+ // CraftBukkit start
+ // sk: The idea is to have (our) WorldServer implement
+ // BlockChangeDelegate and then we can implicitly cast World to
+ // WorldServer (a safe cast, AFAIK) and no code will be broken. This
+ // then allows plugins to catch manually-invoked generation events
+ return generate((BlockChangeDelegate)world, random, i, j, k);
+ }
+
+ public boolean generate(BlockChangeDelegate world, Random random, int i, int j, int k) {
+ // CraftBukkit end
+ int l = random.nextInt(3) + 4;
+ boolean flag = true;
+
+ if (j >= 1 && j + l + 1 <= 128) {
+ int i1;
+ int j1;
+ int k1;
+ int l1;
+
+ for (i1 = j; i1 <= j + 1 + l; ++i1) {
+ byte b0 = 1;
+
+ if (i1 == j) {
+ b0 = 0;
+ }
+
+ if (i1 >= j + 1 + l - 2) {
+ b0 = 2;
+ }
+
+ for (j1 = i - b0; j1 <= i + b0 && flag; ++j1) {
+ for (k1 = k - b0; k1 <= k + b0 && flag; ++k1) {
+ if (i1 >= 0 && i1 < 128) {
+ l1 = world.getTypeId(j1, i1, k1);
+ if (l1 != 0 && l1 != Block.LEAVES.id) {
+ flag = false;
+ }
+ } else {
+ flag = false;
+ }
+ }
+ }
+ }
+
+ if (!flag) {
+ return false;
+ } else {
+ i1 = world.getTypeId(i, j - 1, k);
+ if ((i1 == Block.GRASS.id || i1 == Block.DIRT.id) && j < 128 - l - 1) {
+ world.setTypeId(i, j - 1, k, Block.DIRT.id);
+
+ int i2;
+
+ for (i2 = j - 3 + l; i2 <= j + l; ++i2) {
+ j1 = i2 - (j + l);
+ k1 = 1 - j1 / 2;
+
+ for (l1 = i - k1; l1 <= i + k1; ++l1) {
+ int j2 = l1 - i;
+
+ for (int k2 = k - k1; k2 <= k + k1; ++k2) {
+ int l2 = k2 - k;
+
+ if ((Math.abs(j2) != k1 || Math.abs(l2) != k1 || random.nextInt(2) != 0 && j1 != 0) && !Block.o[world.getTypeId(l1, i2, k2)]) {
+ world.setTypeId(l1, i2, k2, Block.LEAVES.id);
+ }
+ }
+ }
+ }
+
+ for (i2 = 0; i2 < l; ++i2) {
+ j1 = world.getTypeId(i, j + i2, k);
+ if (j1 == 0 || j1 == Block.LEAVES.id) {
+ world.setTypeId(i, j + i2, k, Block.LOG.id);
+ }
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+ } else {
+ return false;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java
index faed7ca779..16e0530476 100644
--- a/src/main/java/net/minecraft/server/WorldServer.java
+++ b/src/main/java/net/minecraft/server/WorldServer.java
@@ -6,15 +6,16 @@ import java.util.List;
import java.util.Random;
// CraftBukkit start
+import org.bukkit.BlockChangeDelegate;
import org.bukkit.craftbukkit.CraftServer;
import org.bukkit.craftbukkit.CraftWorld;
import org.bukkit.event.Event;
import org.bukkit.event.Event.Type;
import org.bukkit.event.block.BlockCanBuildEvent;
import org.bukkit.event.block.BlockPhysicsEvent;
-// CraftBukkit end
-public class WorldServer extends World {
+public class WorldServer extends World implements BlockChangeDelegate {
+// CraftBukkit end
public ChunkProviderServer A;
public boolean B = false;
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
index 30e91359ca..a9c394f6d7 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
@@ -18,7 +18,9 @@ import org.bukkit.Chunk;
import org.bukkit.entity.ItemDrop;
import org.bukkit.inventory.ItemStack;
import org.bukkit.util.Vector;
+import org.bukkit.BlockChangeDelegate;
import org.bukkit.Location;
+import org.bukkit.TreeType;
import org.bukkit.World;
public class CraftWorld implements World {
@@ -194,14 +196,34 @@ public class CraftWorld implements World {
return (Boat) boat.getBukkitEntity();
}
- public boolean generateTree(Location loc) {
- WorldGenTrees treeGen = new WorldGenTrees();
- return treeGen.a(world, rand, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ public boolean generateTree(Location loc, TreeType type) {
+ return generateTree(loc, type, world);
}
-
- public boolean generateBigTree(Location loc) {
- WorldGenBigTree treeGen = new WorldGenBigTree();
- return treeGen.a(world, rand, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+
+ public boolean generateTree(Location loc, TreeType type, BlockChangeDelegate delegate) {
+ switch (type) {
+ case BIG_TREE:
+ return (new WorldGenBigTree())
+ .generate(delegate, rand,
+ loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ case BIRCH:
+ return (new WorldGenForest())
+ .generate(delegate, rand,
+ loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ case REDWOOD:
+ return (new WorldGenTaiga2())
+ .generate(delegate, rand,
+ loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ case TALL_REDWOOD:
+ return (new WorldGenTaiga1())
+ .generate(delegate, rand,
+ loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ case TREE:
+ default:
+ return (new WorldGenTrees())
+ .generate(delegate, rand,
+ loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
+ }
}
public TileEntity getTileEntityAt(final int x, final int y, final int z) {