Brandon/CavePVP-Stuff
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
CavePVP-Stuff/cSpigot-master/spigot-server-Patches/0004-mc-dev-imports.patch

6672 lines
221 KiB
Diff
Raw Permalink Normal View History

Oi oi fuck simplytrash <3
2023-05-01 20:59:40 +02:00
From 9d81fa71539abae7bb7da53ea6824ab1743972d8 Mon Sep 17 00:00:00 2001
From: Zach Brown <Zbob750@live.com>
Date: Tue, 22 Jul 2014 21:05:53 -0500
Subject: [PATCH] mc-dev imports
diff --git a/src/main/java/net/minecraft/server/BiomeBase.java b/src/main/java/net/minecraft/server/BiomeBase.java
new file mode 100644
index 000000000..1372955b3
--- /dev/null
+++ b/src/main/java/net/minecraft/server/BiomeBase.java
@@ -0,0 +1,391 @@
+package net.minecraft.server;
+
+import net.minecraft.util.com.google.common.collect.Sets;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public abstract class BiomeBase {
+
+ private static final Logger aC = LogManager.getLogger();
+ protected static final BiomeTemperature a = new BiomeTemperature(0.1F, 0.2F);
+ protected static final BiomeTemperature b = new BiomeTemperature(-0.5F, 0.0F);
+ protected static final BiomeTemperature c = new BiomeTemperature(-1.0F, 0.1F);
+ protected static final BiomeTemperature d = new BiomeTemperature(-1.8F, 0.1F);
+ protected static final BiomeTemperature e = new BiomeTemperature(0.125F, 0.05F);
+ protected static final BiomeTemperature f = new BiomeTemperature(0.2F, 0.2F);
+ protected static final BiomeTemperature g = new BiomeTemperature(0.45F, 0.3F);
+ protected static final BiomeTemperature h = new BiomeTemperature(1.5F, 0.025F);
+ protected static final BiomeTemperature i = new BiomeTemperature(1.0F, 0.5F);
+ protected static final BiomeTemperature j = new BiomeTemperature(0.0F, 0.025F);
+ protected static final BiomeTemperature k = new BiomeTemperature(0.1F, 0.8F);
+ protected static final BiomeTemperature l = new BiomeTemperature(0.2F, 0.3F);
+ protected static final BiomeTemperature m = new BiomeTemperature(-0.2F, 0.1F);
+ private static final BiomeBase[] biomes = new BiomeBase[256];
+ public static final Set n = Sets.newHashSet();
+ public static final BiomeBase OCEAN = (new BiomeOcean(0)).b(112).a("Ocean").a(c);
+ public static final BiomeBase PLAINS = (new BiomePlains(1)).b(9286496).a("Plains");
+ public static final BiomeBase DESERT = (new BiomeDesert(2)).b(16421912).a("Desert").b().a(2.0F, 0.0F).a(e);
+ public static final BiomeBase EXTREME_HILLS = (new BiomeBigHills(3, false)).b(6316128).a("Extreme Hills").a(i).a(0.2F, 0.3F);
+ public static final BiomeBase FOREST = (new BiomeForest(4, 0)).b(353825).a("Forest");
+ public static final BiomeBase TAIGA = (new BiomeTaiga(5, 0)).b(747097).a("Taiga").a(5159473).a(0.25F, 0.8F).a(f);
+ public static final BiomeBase SWAMPLAND = (new BiomeSwamp(6)).b(522674).a("Swampland").a(9154376).a(m).a(0.8F, 0.9F);
+ public static final BiomeBase RIVER = (new BiomeRiver(7)).b(255).a("River").a(b);
+ public static final BiomeBase HELL = (new BiomeHell(8)).b(16711680).a("Hell").b().a(2.0F, 0.0F);
+ public static final BiomeBase SKY = (new BiomeTheEnd(9)).b(8421631).a("Sky").b();
+ public static final BiomeBase FROZEN_OCEAN = (new BiomeOcean(10)).b(9474208).a("FrozenOcean").c().a(c).a(0.0F, 0.5F);
+ public static final BiomeBase FROZEN_RIVER = (new BiomeRiver(11)).b(10526975).a("FrozenRiver").c().a(b).a(0.0F, 0.5F);
+ public static final BiomeBase ICE_PLAINS = (new BiomeIcePlains(12, false)).b(16777215).a("Ice Plains").c().a(0.0F, 0.5F).a(e);
+ public static final BiomeBase ICE_MOUNTAINS = (new BiomeIcePlains(13, false)).b(10526880).a("Ice Mountains").c().a(g).a(0.0F, 0.5F);
+ public static final BiomeBase MUSHROOM_ISLAND = (new BiomeMushrooms(14)).b(16711935).a("MushroomIsland").a(0.9F, 1.0F).a(l);
+ public static final BiomeBase MUSHROOM_SHORE = (new BiomeMushrooms(15)).b(10486015).a("MushroomIslandShore").a(0.9F, 1.0F).a(j);
+ public static final BiomeBase BEACH = (new BiomeBeach(16)).b(16440917).a("Beach").a(0.8F, 0.4F).a(j);
+ public static final BiomeBase DESERT_HILLS = (new BiomeDesert(17)).b(13786898).a("DesertHills").b().a(2.0F, 0.0F).a(g);
+ public static final BiomeBase FOREST_HILLS = (new BiomeForest(18, 0)).b(2250012).a("ForestHills").a(g);
+ public static final BiomeBase TAIGA_HILLS = (new BiomeTaiga(19, 0)).b(1456435).a("TaigaHills").a(5159473).a(0.25F, 0.8F).a(g);
+ public static final BiomeBase SMALL_MOUNTAINS = (new BiomeBigHills(20, true)).b(7501978).a("Extreme Hills Edge").a(i.a()).a(0.2F, 0.3F);
+ public static final BiomeBase JUNGLE = (new BiomeJungle(21, false)).b(5470985).a("Jungle").a(5470985).a(0.95F, 0.9F);
+ public static final BiomeBase JUNGLE_HILLS = (new BiomeJungle(22, false)).b(2900485).a("JungleHills").a(5470985).a(0.95F, 0.9F).a(g);
+ public static final BiomeBase JUNGLE_EDGE = (new BiomeJungle(23, true)).b(6458135).a("JungleEdge").a(5470985).a(0.95F, 0.8F);
+ public static final BiomeBase DEEP_OCEAN = (new BiomeOcean(24)).b(48).a("Deep Ocean").a(d);
+ public static final BiomeBase STONE_BEACH = (new BiomeStoneBeach(25)).b(10658436).a("Stone Beach").a(0.2F, 0.3F).a(k);
+ public static final BiomeBase COLD_BEACH = (new BiomeBeach(26)).b(16445632).a("Cold Beach").a(0.05F, 0.3F).a(j).c();
+ public static final BiomeBase BIRCH_FOREST = (new BiomeForest(27, 2)).a("Birch Forest").b(3175492);
+ public static final BiomeBase BIRCH_FOREST_HILLS = (new BiomeForest(28, 2)).a("Birch Forest Hills").b(2055986).a(g);
+ public static final BiomeBase ROOFED_FOREST = (new BiomeForest(29, 3)).b(4215066).a("Roofed Forest");
+ public static final BiomeBase COLD_TAIGA = (new BiomeTaiga(30, 0)).b(3233098).a("Cold Taiga").a(5159473).c().a(-0.5F, 0.4F).a(f).c(16777215);
+ public static final BiomeBase COLD_TAIGA_HILLS = (new BiomeTaiga(31, 0)).b(2375478).a("Cold Taiga Hills").a(5159473).c().a(-0.5F, 0.4F).a(g).c(16777215);
+ public static final BiomeBase MEGA_TAIGA = (new BiomeTaiga(32, 1)).b(5858897).a("Mega Taiga").a(5159473).a(0.3F, 0.8F).a(f);
+ public static final BiomeBase MEGA_TAIGA_HILLS = (new BiomeTaiga(33, 1)).b(4542270).a("Mega Taiga Hills").a(5159473).a(0.3F, 0.8F).a(g);
+ public static final BiomeBase EXTREME_HILLS_PLUS = (new BiomeBigHills(34, true)).b(5271632).a("Extreme Hills+").a(i).a(0.2F, 0.3F);
+ public static final BiomeBase SAVANNA = (new BiomeSavanna(35)).b(12431967).a("Savanna").a(1.2F, 0.0F).b().a(e);
+ public static final BiomeBase SAVANNA_PLATEAU = (new BiomeSavanna(36)).b(10984804).a("Savanna Plateau").a(1.0F, 0.0F).b().a(h);
+ public static final BiomeBase MESA = (new BiomeMesa(37, false, false)).b(14238997).a("Mesa");
+ public static final BiomeBase MESA_PLATEAU_F = (new BiomeMesa(38, false, true)).b(11573093).a("Mesa Plateau F").a(h);
+ public static final BiomeBase MESA_PLATEAU = (new BiomeMesa(39, false, false)).b(13274213).a("Mesa Plateau").a(h);
+ protected static final NoiseGenerator3 ac;
+ protected static final NoiseGenerator3 ad;
+ protected static final WorldGenTallPlant ae;
+ public String af;
+ public int ag;
+ public int ah;
+ public Block ai;
+ public int aj;
+ public Block ak;
+ public int al;
+ public float am;
+ public float an;
+ public float temperature;
+ public float humidity;
+ public int aq;
+ public BiomeDecorator ar;
+ protected List as;
+ protected List at;
+ protected List au;
+ protected List av;
+ protected boolean aw;
+ protected boolean ax;
+ public final int id;
+ protected WorldGenTrees az;
+ protected WorldGenBigTree aA;
+ protected WorldGenSwampTree aB;
+
+ protected BiomeBase(int i) {
+ this.ai = Blocks.GRASS;
+ this.aj = 0;
+ this.ak = Blocks.DIRT;
+ this.al = 5169201;
+ this.am = a.a;
+ this.an = a.b;
+ this.temperature = 0.5F;
+ this.humidity = 0.5F;
+ this.aq = 16777215;
+ this.as = new ArrayList();
+ this.at = new ArrayList();
+ this.au = new ArrayList();
+ this.av = new ArrayList();
+ this.ax = true;
+ this.az = new WorldGenTrees(false);
+ this.aA = new WorldGenBigTree(false);
+ this.aB = new WorldGenSwampTree();
+ this.id = i;
+ biomes[i] = this;
+ this.ar = this.a();
+ this.at.add(new BiomeMeta(EntitySheep.class, 12, 4, 4));
+ this.at.add(new BiomeMeta(EntityPig.class, 10, 4, 4));
+ this.at.add(new BiomeMeta(EntityChicken.class, 10, 4, 4));
+ this.at.add(new BiomeMeta(EntityCow.class, 8, 4, 4));
+ this.as.add(new BiomeMeta(EntitySpider.class, 100, 4, 4));
+ this.as.add(new BiomeMeta(EntityZombie.class, 100, 4, 4));
+ this.as.add(new BiomeMeta(EntitySkeleton.class, 100, 4, 4));
+ this.as.add(new BiomeMeta(EntityCreeper.class, 100, 4, 4));
+ this.as.add(new BiomeMeta(EntitySlime.class, 100, 4, 4));
+ this.as.add(new BiomeMeta(EntityEnderman.class, 10, 1, 4));
+ this.as.add(new BiomeMeta(EntityWitch.class, 5, 1, 1));
+ this.au.add(new BiomeMeta(EntitySquid.class, 10, 4, 4));
+ this.av.add(new BiomeMeta(EntityBat.class, 10, 8, 8));
+ }
+
+ protected BiomeDecorator a() {
+ return new BiomeDecorator();
+ }
+
+ protected BiomeBase a(float f, float f1) {
+ if (f > 0.1F && f < 0.2F) {
+ throw new IllegalArgumentException("Please avoid temperatures in the range 0.1 - 0.2 because of snow");
+ } else {
+ this.temperature = f;
+ this.humidity = f1;
+ return this;
+ }
+ }
+
+ protected final BiomeBase a(BiomeTemperature biometemperature) {
+ this.am = biometemperature.a;
+ this.an = biometemperature.b;
+ return this;
+ }
+
+ protected BiomeBase b() {
+ this.ax = false;
+ return this;
+ }
+
+ public WorldGenTreeAbstract a(Random random) {
+ return (WorldGenTreeAbstract) (random.nextInt(10) == 0 ? this.aA : this.az);
+ }
+
+ public WorldGenerator b(Random random) {
+ return new WorldGenGrass(Blocks.LONG_GRASS, 1);
+ }
+
+ public String a(Random random, int i, int j, int k) {
+ return random.nextInt(3) > 0 ? BlockFlowers.b[0] : BlockFlowers.a[0];
+ }
+
+ protected BiomeBase c() {
+ this.aw = true;
+ return this;
+ }
+
+ protected BiomeBase a(String s) {
+ this.af = s;
+ return this;
+ }
+
+ protected BiomeBase a(int i) {
+ this.al = i;
+ return this;
+ }
+
+ protected BiomeBase b(int i) {
+ this.a(i, false);
+ return this;
+ }
+
+ protected BiomeBase c(int i) {
+ this.ah = i;
+ return this;
+ }
+
+ protected BiomeBase a(int i, boolean flag) {
+ this.ag = i;
+ if (flag) {
+ this.ah = (i & 16711422) >> 1;
+ } else {
+ this.ah = i;
+ }
+
+ return this;
+ }
+
+ public List getMobs(EnumCreatureType enumcreaturetype) {
+ return enumcreaturetype == EnumCreatureType.MONSTER ? this.as : (enumcreaturetype == EnumCreatureType.CREATURE ? this.at : (enumcreaturetype == EnumCreatureType.WATER_CREATURE ? this.au : (enumcreaturetype == EnumCreatureType.AMBIENT ? this.av : null)));
+ }
+
+ public boolean d() {
+ return this.j();
+ }
+
+ public boolean e() {
+ return this.j() ? false : this.ax;
+ }
+
+ public boolean f() {
+ return this.humidity > 0.85F;
+ }
+
+ public float g() {
+ return 0.1F;
+ }
+
+ public final int h() {
+ return (int) (this.humidity * 65536.0F);
+ }
+
+ public final float a(int i, int j, int k) {
+ if (j > 64) {
+ float f = (float) ac.a((double) i * 1.0D / 8.0D, (double) k * 1.0D / 8.0D) * 4.0F;
+
+ return this.temperature - (f + (float) j - 64.0F) * 0.05F / 30.0F;
+ } else {
+ return this.temperature;
+ }
+ }
+
+ public void a(World world, Random random, int i, int j) {
+ this.ar.a(world, random, this, i, j);
+ }
+
+ public boolean j() {
+ return this.aw;
+ }
+
+ public void a(World world, Random random, Block[] ablock, byte[] abyte, int i, int j, double d0) {
+ this.b(world, random, ablock, abyte, i, j, d0);
+ }
+
+ public final void b(World world, Random random, Block[] ablock, byte[] abyte, int i, int j, double d0) {
+ boolean flag = true;
+ Block block = this.ai;
+ byte b0 = (byte) (this.aj & 255);
+ Block block1 = this.ak;
+ int k = -1;
+ int l = (int) (d0 / 3.0D + 3.0D + random.nextDouble() * 0.25D);
+ int i1 = i & 15;
+ int j1 = j & 15;
+ int k1 = ablock.length / 256;
+
+ for (int l1 = 255; l1 >= 0; --l1) {
+ int i2 = (j1 * 16 + i1) * k1 + l1;
+
+ if (l1 <= 0 + random.nextInt(5)) {
+ ablock[i2] = Blocks.BEDROCK;
+ } else {
+ Block block2 = ablock[i2];
+
+ if (block2 != null && block2.getMaterial() != Material.AIR) {
+ if (block2 == Blocks.STONE) {
+ if (k == -1) {
+ if (l <= 0) {
+ block = null;
+ b0 = 0;
+ block1 = Blocks.STONE;
+ } else if (l1 >= 59 && l1 <= 64) {
+ block = this.ai;
+ b0 = (byte) (this.aj & 255);
+ block1 = this.ak;
+ }
+
+ if (l1 < 63 && (block == null || block.getMaterial() == Material.AIR)) {
+ if (this.a(i, l1, j) < 0.15F) {
+ block = Blocks.ICE;
+ b0 = 0;
+ } else {
+ block = Blocks.STATIONARY_WATER;
+ b0 = 0;
+ }
+ }
+
+ k = l;
+ if (l1 >= 62) {
+ ablock[i2] = block;
+ abyte[i2] = b0;
+ } else if (l1 < 56 - l) {
+ block = null;
+ block1 = Blocks.STONE;
+ ablock[i2] = Blocks.GRAVEL;
+ } else {
+ ablock[i2] = block1;
+ }
+ } else if (k > 0) {
+ --k;
+ ablock[i2] = block1;
+ if (k == 0 && block1 == Blocks.SAND) {
+ k = random.nextInt(4) + Math.max(0, l1 - 63);
+ block1 = Blocks.SANDSTONE;
+ }
+ }
+ }
+ } else {
+ k = -1;
+ }
+ }
+ }
+ }
+
+ protected BiomeBase k() {
+ return new BiomeBaseSub(this.id + 128, this);
+ }
+
+ public Class l() {
+ return this.getClass();
+ }
+
+ public boolean a(BiomeBase biomebase) {
+ return biomebase == this ? true : (biomebase == null ? false : this.l() == biomebase.l());
+ }
+
+ public EnumTemperature m() {
+ return (double) this.temperature < 0.2D ? EnumTemperature.COLD : ((double) this.temperature < 1.0D ? EnumTemperature.MEDIUM : EnumTemperature.WARM);
+ }
+
+ public static BiomeBase[] getBiomes() {
+ return biomes;
+ }
+
+ public static BiomeBase getBiome(int i) {
+ if (i >= 0 && i <= biomes.length) {
+ return biomes[i];
+ } else {
+ aC.warn("Biome ID is out of bounds: " + i + ", defaulting to 0 (Ocean)");
+ return OCEAN;
+ }
+ }
+
+ static {
+ PLAINS.k();
+ DESERT.k();
+ FOREST.k();
+ TAIGA.k();
+ SWAMPLAND.k();
+ ICE_PLAINS.k();
+ JUNGLE.k();
+ JUNGLE_EDGE.k();
+ COLD_TAIGA.k();
+ SAVANNA.k();
+ SAVANNA_PLATEAU.k();
+ MESA.k();
+ MESA_PLATEAU_F.k();
+ MESA_PLATEAU.k();
+ BIRCH_FOREST.k();
+ BIRCH_FOREST_HILLS.k();
+ ROOFED_FOREST.k();
+ MEGA_TAIGA.k();
+ EXTREME_HILLS.k();
+ EXTREME_HILLS_PLUS.k();
+ biomes[MEGA_TAIGA_HILLS.id + 128] = biomes[MEGA_TAIGA.id + 128];
+ BiomeBase[] abiomebase = biomes;
+ int i = abiomebase.length;
+
+ for (int j = 0; j < i; ++j) {
+ BiomeBase biomebase = abiomebase[j];
+
+ if (biomebase != null && biomebase.id < 128) {
+ n.add(biomebase);
+ }
+ }
+
+ n.remove(HELL);
+ n.remove(SKY);
+ n.remove(FROZEN_OCEAN);
+ n.remove(SMALL_MOUNTAINS);
+ ac = new NoiseGenerator3(new Random(1234L), 1);
+ ad = new NoiseGenerator3(new Random(2345L), 1);
+ ae = new WorldGenTallPlant();
+ }
+}
diff --git a/src/main/java/net/minecraft/server/BiomeCache.java b/src/main/java/net/minecraft/server/BiomeCache.java
new file mode 100644
index 000000000..833854f5f
--- /dev/null
+++ b/src/main/java/net/minecraft/server/BiomeCache.java
@@ -0,0 +1,65 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BiomeCache {
+
+ private final WorldChunkManager a;
+ private long b;
+ private LongHashMap c = new LongHashMap();
+ private List d = new ArrayList();
+
+ public BiomeCache(WorldChunkManager worldchunkmanager) {
+ this.a = worldchunkmanager;
+ }
+
+ public BiomeCacheBlock a(int i, int j) {
+ i >>= 4;
+ j >>= 4;
+ long k = (long) i & 4294967295L | ((long) j & 4294967295L) << 32;
+ BiomeCacheBlock biomecacheblock = (BiomeCacheBlock) this.c.getEntry(k);
+
+ if (biomecacheblock == null) {
+ biomecacheblock = new BiomeCacheBlock(this, i, j);
+ this.c.put(k, biomecacheblock);
+ this.d.add(biomecacheblock);
+ }
+
+ biomecacheblock.e = MinecraftServer.ar();
+ return biomecacheblock;
+ }
+
+ public BiomeBase b(int i, int j) {
+ return this.a(i, j).a(i, j);
+ }
+
+ public void a() {
+ long i = MinecraftServer.ar();
+ long j = i - this.b;
+
+ if (j > 7500L || j < 0L) {
+ this.b = i;
+
+ for (int k = 0; k < this.d.size(); ++k) {
+ BiomeCacheBlock biomecacheblock = (BiomeCacheBlock) this.d.get(k);
+ long l = i - biomecacheblock.e;
+
+ if (l > 30000L || l < 0L) {
+ this.d.remove(k--);
+ long i1 = (long) biomecacheblock.c & 4294967295L | ((long) biomecacheblock.d & 4294967295L) << 32;
+
+ this.c.remove(i1);
+ }
+ }
+ }
+ }
+
+ public BiomeBase[] d(int i, int j) {
+ return this.a(i, j).b;
+ }
+
+ static WorldChunkManager a(BiomeCache biomecache) {
+ return biomecache.a;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/BiomeMesa.java b/src/main/java/net/minecraft/server/BiomeMesa.java
new file mode 100644
index 000000000..7a184e23a
--- /dev/null
+++ b/src/main/java/net/minecraft/server/BiomeMesa.java
@@ -0,0 +1,279 @@
+package net.minecraft.server;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public class BiomeMesa extends BiomeBase {
+
+ private byte[] aC;
+ private long aD;
+ private NoiseGenerator3 aE;
+ private NoiseGenerator3 aF;
+ private NoiseGenerator3 aG;
+ private boolean aH;
+ private boolean aI;
+
+ public BiomeMesa(int i, boolean flag, boolean flag1) {
+ super(i);
+ this.aH = flag;
+ this.aI = flag1;
+ this.b();
+ this.a(2.0F, 0.0F);
+ this.at.clear();
+ this.ai = Blocks.SAND;
+ this.aj = 1;
+ this.ak = Blocks.STAINED_HARDENED_CLAY;
+ this.ar.x = -999;
+ this.ar.A = 20;
+ this.ar.C = 3;
+ this.ar.D = 5;
+ this.ar.y = 0;
+ this.at.clear();
+ if (flag1) {
+ this.ar.x = 5;
+ }
+ }
+
+ public WorldGenTreeAbstract a(Random random) {
+ return this.az;
+ }
+
+ public void a(World world, Random random, int i, int j) {
+ super.a(world, random, i, j);
+ }
+
+ public void a(World world, Random random, Block[] ablock, byte[] abyte, int i, int j, double d0) {
+ if (this.aC == null || this.aD != world.getSeed()) {
+ this.a(world.getSeed());
+ }
+
+ if (this.aE == null || this.aF == null || this.aD != world.getSeed()) {
+ Random random1 = new Random(this.aD);
+
+ this.aE = new NoiseGenerator3(random1, 4);
+ this.aF = new NoiseGenerator3(random1, 1);
+ }
+
+ this.aD = world.getSeed();
+ double d1 = 0.0D;
+ int k;
+ int l;
+
+ if (this.aH) {
+ k = (i & -16) + (j & 15);
+ l = (j & -16) + (i & 15);
+ double d2 = Math.min(Math.abs(d0), this.aE.a((double) k * 0.25D, (double) l * 0.25D));
+
+ if (d2 > 0.0D) {
+ double d3 = 0.001953125D;
+ double d4 = Math.abs(this.aF.a((double) k * d3, (double) l * d3));
+
+ d1 = d2 * d2 * 2.5D;
+ double d5 = Math.ceil(d4 * 50.0D) + 14.0D;
+
+ if (d1 > d5) {
+ d1 = d5;
+ }
+
+ d1 += 64.0D;
+ }
+ }
+
+ k = i & 15;
+ l = j & 15;
+ boolean flag = true;
+ Block block = Blocks.STAINED_HARDENED_CLAY;
+ Block block1 = this.ak;
+ int i1 = (int) (d0 / 3.0D + 3.0D + random.nextDouble() * 0.25D);
+ boolean flag1 = Math.cos(d0 / 3.0D * 3.141592653589793D) > 0.0D;
+ int j1 = -1;
+ boolean flag2 = false;
+ int k1 = ablock.length / 256;
+
+ for (int l1 = 255; l1 >= 0; --l1) {
+ int i2 = (l * 16 + k) * k1 + l1;
+
+ if ((ablock[i2] == null || ablock[i2].getMaterial() == Material.AIR) && l1 < (int) d1) {
+ ablock[i2] = Blocks.STONE;
+ }
+
+ if (l1 <= 0 + random.nextInt(5)) {
+ ablock[i2] = Blocks.BEDROCK;
+ } else {
+ Block block2 = ablock[i2];
+
+ if (block2 != null && block2.getMaterial() != Material.AIR) {
+ if (block2 == Blocks.STONE) {
+ byte b0;
+
+ if (j1 == -1) {
+ flag2 = false;
+ if (i1 <= 0) {
+ block = null;
+ block1 = Blocks.STONE;
+ } else if (l1 >= 59 && l1 <= 64) {
+ block = Blocks.STAINED_HARDENED_CLAY;
+ block1 = this.ak;
+ }
+
+ if (l1 < 63 && (block == null || block.getMaterial() == Material.AIR)) {
+ block = Blocks.STATIONARY_WATER;
+ }
+
+ j1 = i1 + Math.max(0, l1 - 63);
+ if (l1 >= 62) {
+ if (this.aI && l1 > 86 + i1 * 2) {
+ if (flag1) {
+ ablock[i2] = Blocks.DIRT;
+ abyte[i2] = 1;
+ } else {
+ ablock[i2] = Blocks.GRASS;
+ }
+ } else if (l1 > 66 + i1) {
+ b0 = 16;
+ if (l1 >= 64 && l1 <= 127) {
+ if (!flag1) {
+ b0 = this.d(i, l1, j);
+ }
+ } else {
+ b0 = 1;
+ }
+
+ if (b0 < 16) {
+ ablock[i2] = Blocks.STAINED_HARDENED_CLAY;
+ abyte[i2] = (byte) b0;
+ } else {
+ ablock[i2] = Blocks.HARDENED_CLAY;
+ }
+ } else {
+ ablock[i2] = this.ai;
+ abyte[i2] = (byte) this.aj;
+ flag2 = true;
+ }
+ } else {
+ ablock[i2] = block1;
+ if (block1 == Blocks.STAINED_HARDENED_CLAY) {
+ abyte[i2] = 1;
+ }
+ }
+ } else if (j1 > 0) {
+ --j1;
+ if (flag2) {
+ ablock[i2] = Blocks.STAINED_HARDENED_CLAY;
+ abyte[i2] = 1;
+ } else {
+ b0 = this.d(i, l1, j);
+ if (b0 < 16) {
+ ablock[i2] = Blocks.STAINED_HARDENED_CLAY;
+ abyte[i2] = b0;
+ } else {
+ ablock[i2] = Blocks.HARDENED_CLAY;
+ }
+ }
+ }
+ }
+ } else {
+ j1 = -1;
+ }
+ }
+ }
+ }
+
+ private void a(long i) {
+ this.aC = new byte[64];
+ Arrays.fill(this.aC, (byte) 16);
+ Random random = new Random(i);
+
+ this.aG = new NoiseGenerator3(random, 1);
+
+ int j;
+
+ for (j = 0; j < 64; ++j) {
+ j += random.nextInt(5) + 1;
+ if (j < 64) {
+ this.aC[j] = 1;
+ }
+ }
+
+ j = random.nextInt(4) + 2;
+
+ int k;
+ int l;
+ int i1;
+ int j1;
+
+ for (k = 0; k < j; ++k) {
+ l = random.nextInt(3) + 1;
+ i1 = random.nextInt(64);
+
+ for (j1 = 0; i1 + j1 < 64 && j1 < l; ++j1) {
+ this.aC[i1 + j1] = 4;
+ }
+ }
+
+ k = random.nextInt(4) + 2;
+
+ int k1;
+
+ for (l = 0; l < k; ++l) {
+ i1 = random.nextInt(3) + 2;
+ j1 = random.nextInt(64);
+
+ for (k1 = 0; j1 + k1 < 64 && k1 < i1; ++k1) {
+ this.aC[j1 + k1] = 12;
+ }
+ }
+
+ l = random.nextInt(4) + 2;
+
+ for (i1 = 0; i1 < l; ++i1) {
+ j1 = random.nextInt(3) + 1;
+ k1 = random.nextInt(64);
+
+ for (int l1 = 0; k1 + l1 < 64 && l1 < j1; ++l1) {
+ this.aC[k1 + l1] = 14;
+ }
+ }
+
+ i1 = random.nextInt(3) + 3;
+ j1 = 0;
+
+ for (k1 = 0; k1 < i1; ++k1) {
+ byte b0 = 1;
+
+ j1 += random.nextInt(16) + 4;
+
+ for (int i2 = 0; j1 + i2 < 64 && i2 < b0; ++i2) {
+ this.aC[j1 + i2] = 0;
+ if (j1 + i2 > 1 && random.nextBoolean()) {
+ this.aC[j1 + i2 - 1] = 8;
+ }
+
+ if (j1 + i2 < 63 && random.nextBoolean()) {
+ this.aC[j1 + i2 + 1] = 8;
+ }
+ }
+ }
+ }
+
+ private byte d(int i, int j, int k) {
+ int l = (int) Math.round(this.aG.a((double) i * 1.0D / 512.0D, (double) i * 1.0D / 512.0D) * 2.0D);
+
+ return this.aC[(j + l + 64) % 64];
+ }
+
+ protected BiomeBase k() {
+ boolean flag = this.id == BiomeBase.MESA.id;
+ BiomeMesa biomemesa = new BiomeMesa(this.id + 128, flag, this.aI);
+
+ if (!flag) {
+ biomemesa.a(g);
+ biomemesa.a(this.af + " M");
+ } else {
+ biomemesa.a(this.af + " (Bryce)");
+ }
+
+ biomemesa.a(this.ag, true);
+ return biomemesa;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/BlockFalling.java b/src/main/java/net/minecraft/server/BlockFalling.java
new file mode 100644
index 000000000..473fc3121
--- /dev/null
+++ b/src/main/java/net/minecraft/server/BlockFalling.java
@@ -0,0 +1,78 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockFalling extends Block {
+
+ public static boolean instaFall;
+
+ public BlockFalling() {
+ super(Material.SAND);
+ this.a(CreativeModeTab.b);
+ }
+
+ public BlockFalling(Material material) {
+ super(material);
+ }
+
+ public void onPlace(World world, int i, int j, int k) {
+ world.a(i, j, k, this, this.a(world));
+ }
+
+ public void doPhysics(World world, int i, int j, int k, Block block) {
+ world.a(i, j, k, this, this.a(world));
+ }
+
+ public void a(World world, int i, int j, int k, Random random) {
+ if (!world.isStatic) {
+ this.m(world, i, j, k);
+ }
+ }
+
+ private void m(World world, int i, int j, int k) {
+ if (canFall(world, i, j - 1, k) && j >= 0) {
+ byte b0 = 32;
+
+ if (!instaFall && world.b(i - b0, j - b0, k - b0, i + b0, j + b0, k + b0)) {
+ if (!world.isStatic) {
+ EntityFallingBlock entityfallingblock = new EntityFallingBlock(world, (double) ((float) i + 0.5F), (double) ((float) j + 0.5F), (double) ((float) k + 0.5F), this, world.getData(i, j, k));
+
+ this.a(entityfallingblock);
+ world.addEntity(entityfallingblock);
+ }
+ } else {
+ world.setAir(i, j, k);
+
+ while (canFall(world, i, j - 1, k) && j > 0) {
+ --j;
+ }
+
+ if (j > 0) {
+ world.setTypeUpdate(i, j, k, this);
+ }
+ }
+ }
+ }
+
+ protected void a(EntityFallingBlock entityfallingblock) {}
+
+ public int a(World world) {
+ return 2;
+ }
+
+ public static boolean canFall(World world, int i, int j, int k) {
+ Block block = world.getType(i, j, k);
+
+ if (block.material == Material.AIR) {
+ return true;
+ } else if (block == Blocks.FIRE) {
+ return true;
+ } else {
+ Material material = block.material;
+
+ return material == Material.WATER ? true : material == Material.LAVA;
+ }
+ }
+
+ public void a(World world, int i, int j, int k, int l) {}
+}
diff --git a/src/main/java/net/minecraft/server/BlockMinecartTrackAbstract.java b/src/main/java/net/minecraft/server/BlockMinecartTrackAbstract.java
new file mode 100644
index 000000000..d36aacbda
--- /dev/null
+++ b/src/main/java/net/minecraft/server/BlockMinecartTrackAbstract.java
@@ -0,0 +1,145 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public abstract class BlockMinecartTrackAbstract extends Block {
+
+ protected final boolean a;
+
+ public static final boolean b_(World world, int i, int j, int k) {
+ return a(world.getType(i, j, k));
+ }
+
+ public static final boolean a(Block block) {
+ return block == Blocks.RAILS || block == Blocks.GOLDEN_RAIL || block == Blocks.DETECTOR_RAIL || block == Blocks.ACTIVATOR_RAIL;
+ }
+
+ protected BlockMinecartTrackAbstract(boolean flag) {
+ super(Material.ORIENTABLE);
+ this.a = flag;
+ this.a(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F);
+ this.a(CreativeModeTab.e);
+ }
+
+ public boolean e() {
+ return this.a;
+ }
+
+ public AxisAlignedBB a(World world, int i, int j, int k) {
+ return null;
+ }
+
+ public boolean c() {
+ return false;
+ }
+
+ public MovingObjectPosition a(World world, int i, int j, int k, Vec3D vec3d, Vec3D vec3d1) {
+ this.updateShape(world, i, j, k);
+ return super.a(world, i, j, k, vec3d, vec3d1);
+ }
+
+ public void updateShape(IBlockAccess iblockaccess, int i, int j, int k) {
+ int l = iblockaccess.getData(i, j, k);
+
+ if (l >= 2 && l <= 5) {
+ this.a(0.0F, 0.0F, 0.0F, 1.0F, 0.625F, 1.0F);
+ } else {
+ this.a(0.0F, 0.0F, 0.0F, 1.0F, 0.125F, 1.0F);
+ }
+ }
+
+ public boolean d() {
+ return false;
+ }
+
+ public int b() {
+ return 9;
+ }
+
+ public int a(Random random) {
+ return 1;
+ }
+
+ public boolean canPlace(World world, int i, int j, int k) {
+ return World.a((IBlockAccess) world, i, j - 1, k);
+ }
+
+ public void onPlace(World world, int i, int j, int k) {
+ if (!world.isStatic) {
+ this.a(world, i, j, k, true);
+ if (this.a) {
+ this.doPhysics(world, i, j, k, this);
+ }
+ }
+ }
+
+ public void doPhysics(World world, int i, int j, int k, Block block) {
+ if (!world.isStatic) {
+ int l = world.getData(i, j, k);
+ int i1 = l;
+
+ if (this.a) {
+ i1 = l & 7;
+ }
+
+ boolean flag = false;
+
+ if (!World.a((IBlockAccess) world, i, j - 1, k)) {
+ flag = true;
+ }
+
+ if (i1 == 2 && !World.a((IBlockAccess) world, i + 1, j, k)) {
+ flag = true;
+ }
+
+ if (i1 == 3 && !World.a((IBlockAccess) world, i - 1, j, k)) {
+ flag = true;
+ }
+
+ if (i1 == 4 && !World.a((IBlockAccess) world, i, j, k - 1)) {
+ flag = true;
+ }
+
+ if (i1 == 5 && !World.a((IBlockAccess) world, i, j, k + 1)) {
+ flag = true;
+ }
+
+ if (flag) {
+ this.b(world, i, j, k, world.getData(i, j, k), 0);
+ world.setAir(i, j, k);
+ } else {
+ this.a(world, i, j, k, l, i1, block);
+ }
+ }
+ }
+
+ protected void a(World world, int i, int j, int k, int l, int i1, Block block) {}
+
+ protected void a(World world, int i, int j, int k, boolean flag) {
+ if (!world.isStatic) {
+ (new MinecartTrackLogic(this, world, i, j, k)).a(world.isBlockIndirectlyPowered(i, j, k), flag);
+ }
+ }
+
+ public int h() {
+ return 0;
+ }
+
+ public void remove(World world, int i, int j, int k, Block block, int l) {
+ int i1 = l;
+
+ if (this.a) {
+ i1 = l & 7;
+ }
+
+ super.remove(world, i, j, k, block, l);
+ if (i1 == 2 || i1 == 3 || i1 == 4 || i1 == 5) {
+ world.applyPhysics(i, j + 1, k, block);
+ }
+
+ if (this.a) {
+ world.applyPhysics(i, j, k, block);
+ world.applyPhysics(i, j - 1, k, block);
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/BlockTorch.java b/src/main/java/net/minecraft/server/BlockTorch.java
new file mode 100644
index 000000000..d95aff288
--- /dev/null
+++ b/src/main/java/net/minecraft/server/BlockTorch.java
@@ -0,0 +1,167 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class BlockTorch extends Block {
+
+ protected BlockTorch() {
+ super(Material.ORIENTABLE);
+ this.a(true);
+ this.a(CreativeModeTab.c);
+ }
+
+ public AxisAlignedBB a(World world, int i, int j, int k) {
+ return null;
+ }
+
+ public boolean c() {
+ return false;
+ }
+
+ public boolean d() {
+ return false;
+ }
+
+ public int b() {
+ return 2;
+ }
+
+ private boolean m(World world, int i, int j, int k) {
+ if (World.a((IBlockAccess) world, i, j, k)) {
+ return true;
+ } else {
+ Block block = world.getType(i, j, k);
+
+ return block == Blocks.FENCE || block == Blocks.NETHER_FENCE || block == Blocks.GLASS || block == Blocks.COBBLE_WALL;
+ }
+ }
+
+ public boolean canPlace(World world, int i, int j, int k) {
+ return world.c(i - 1, j, k, true) ? true : (world.c(i + 1, j, k, true) ? true : (world.c(i, j, k - 1, true) ? true : (world.c(i, j, k + 1, true) ? true : this.m(world, i, j - 1, k))));
+ }
+
+ public int getPlacedData(World world, int i, int j, int k, int l, float f, float f1, float f2, int i1) {
+ int j1 = i1;
+
+ if (l == 1 && this.m(world, i, j - 1, k)) {
+ j1 = 5;
+ }
+
+ if (l == 2 && world.c(i, j, k + 1, true)) {
+ j1 = 4;
+ }
+
+ if (l == 3 && world.c(i, j, k - 1, true)) {
+ j1 = 3;
+ }
+
+ if (l == 4 && world.c(i + 1, j, k, true)) {
+ j1 = 2;
+ }
+
+ if (l == 5 && world.c(i - 1, j, k, true)) {
+ j1 = 1;
+ }
+
+ return j1;
+ }
+
+ public void a(World world, int i, int j, int k, Random random) {
+ super.a(world, i, j, k, random);
+ if (world.getData(i, j, k) == 0) {
+ this.onPlace(world, i, j, k);
+ }
+ }
+
+ public void onPlace(World world, int i, int j, int k) {
+ if (world.getData(i, j, k) == 0) {
+ if (world.c(i - 1, j, k, true)) {
+ world.setData(i, j, k, 1, 2);
+ } else if (world.c(i + 1, j, k, true)) {
+ world.setData(i, j, k, 2, 2);
+ } else if (world.c(i, j, k - 1, true)) {
+ world.setData(i, j, k, 3, 2);
+ } else if (world.c(i, j, k + 1, true)) {
+ world.setData(i, j, k, 4, 2);
+ } else if (this.m(world, i, j - 1, k)) {
+ world.setData(i, j, k, 5, 2);
+ }
+ }
+
+ this.e(world, i, j, k);
+ }
+
+ public void doPhysics(World world, int i, int j, int k, Block block) {
+ this.b(world, i, j, k, block);
+ }
+
+ protected boolean b(World world, int i, int j, int k, Block block) {
+ if (this.e(world, i, j, k)) {
+ int l = world.getData(i, j, k);
+ boolean flag = false;
+
+ if (!world.c(i - 1, j, k, true) && l == 1) {
+ flag = true;
+ }
+
+ if (!world.c(i + 1, j, k, true) && l == 2) {
+ flag = true;
+ }
+
+ if (!world.c(i, j, k - 1, true) && l == 3) {
+ flag = true;
+ }
+
+ if (!world.c(i, j, k + 1, true) && l == 4) {
+ flag = true;
+ }
+
+ if (!this.m(world, i, j - 1, k) && l == 5) {
+ flag = true;
+ }
+
+ if (flag) {
+ this.b(world, i, j, k, world.getData(i, j, k), 0);
+ world.setAir(i, j, k);
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ return true;
+ }
+ }
+
+ protected boolean e(World world, int i, int j, int k) {
+ if (!this.canPlace(world, i, j, k)) {
+ if (world.getType(i, j, k) == this) {
+ this.b(world, i, j, k, world.getData(i, j, k), 0);
+ world.setAir(i, j, k);
+ }
+
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ public MovingObjectPosition a(World world, int i, int j, int k, Vec3D vec3d, Vec3D vec3d1) {
+ int l = world.getData(i, j, k) & 7;
+ float f = 0.15F;
+
+ if (l == 1) {
+ this.a(0.0F, 0.2F, 0.5F - f, f * 2.0F, 0.8F, 0.5F + f);
+ } else if (l == 2) {
+ this.a(1.0F - f * 2.0F, 0.2F, 0.5F - f, 1.0F, 0.8F, 0.5F + f);
+ } else if (l == 3) {
+ this.a(0.5F - f, 0.2F, 0.0F, 0.5F + f, 0.8F, f * 2.0F);
+ } else if (l == 4) {
+ this.a(0.5F - f, 0.2F, 1.0F - f * 2.0F, 0.5F + f, 0.8F, 1.0F);
+ } else {
+ f = 0.1F;
+ this.a(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, 0.6F, 0.5F + f);
+ }
+
+ return super.a(world, i, j, k, vec3d, vec3d1);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ChunkCoordIntPair.java b/src/main/java/net/minecraft/server/ChunkCoordIntPair.java
new file mode 100644
index 000000000..1594f40de
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ChunkCoordIntPair.java
@@ -0,0 +1,51 @@
+package net.minecraft.server;
+
+public class ChunkCoordIntPair {
+
+ public final int x;
+ public final int z;
+
+ public ChunkCoordIntPair(int i, int j) {
+ this.x = i;
+ this.z = j;
+ }
+
+ public static long a(int i, int j) {
+ return (long) i & 4294967295L | ((long) j & 4294967295L) << 32;
+ }
+
+ public int hashCode() {
+ int i = 1664525 * this.x + 1013904223;
+ int j = 1664525 * (this.z ^ -559038737) + 1013904223;
+
+ return i ^ j;
+ }
+
+ public boolean equals(Object object) {
+ if (this == object) {
+ return true;
+ } else if (!(object instanceof ChunkCoordIntPair)) {
+ return false;
+ } else {
+ ChunkCoordIntPair chunkcoordintpair = (ChunkCoordIntPair) object;
+
+ return this.x == chunkcoordintpair.x && this.z == chunkcoordintpair.z;
+ }
+ }
+
+ public int a() {
+ return (this.x << 4) + 8;
+ }
+
+ public int b() {
+ return (this.z << 4) + 8;
+ }
+
+ public ChunkPosition a(int i) {
+ return new ChunkPosition(this.a(), i, this.b());
+ }
+
+ public String toString() {
+ return "[" + this.x + ", " + this.z + "]";
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ChunkMap.java b/src/main/java/net/minecraft/server/ChunkMap.java
new file mode 100644
index 000000000..374983a06
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ChunkMap.java
@@ -0,0 +1,10 @@
+package net.minecraft.server;
+
+public class ChunkMap {
+
+ public byte[] a;
+ public int b;
+ public int c;
+
+ public ChunkMap() {}
+}
diff --git a/src/main/java/net/minecraft/server/ChunkProviderFlat.java b/src/main/java/net/minecraft/server/ChunkProviderFlat.java
new file mode 100644
index 000000000..0f7518287
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ChunkProviderFlat.java
@@ -0,0 +1,238 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+public class ChunkProviderFlat implements IChunkProvider {
+
+ private World a;
+ private Random b;
+ private final Block[] c = new Block[256];
+ private final byte[] d = new byte[256];
+ private final WorldGenFlatInfo e;
+ private final List f = new ArrayList();
+ private final boolean g;
+ private final boolean h;
+ private WorldGenLakes i;
+ private WorldGenLakes j;
+
+ public ChunkProviderFlat(World world, long i, boolean flag, String s) {
+ this.a = world;
+ this.b = new Random(i);
+ this.e = WorldGenFlatInfo.a(s);
+ if (flag) {
+ Map map = this.e.b();
+
+ if (map.containsKey("village")) {
+ Map map1 = (Map) map.get("village");
+
+ if (!map1.containsKey("size")) {
+ map1.put("size", "1");
+ }
+
+ this.f.add(new WorldGenVillage(map1));
+ }
+
+ if (map.containsKey("biome_1")) {
+ this.f.add(new WorldGenLargeFeature((Map) map.get("biome_1")));
+ }
+
+ if (map.containsKey("mineshaft")) {
+ this.f.add(new WorldGenMineshaft((Map) map.get("mineshaft")));
+ }
+
+ if (map.containsKey("stronghold")) {
+ this.f.add(new WorldGenStronghold((Map) map.get("stronghold")));
+ }
+ }
+
+ this.g = this.e.b().containsKey("decoration");
+ if (this.e.b().containsKey("lake")) {
+ this.i = new WorldGenLakes(Blocks.STATIONARY_WATER);
+ }
+
+ if (this.e.b().containsKey("lava_lake")) {
+ this.j = new WorldGenLakes(Blocks.STATIONARY_LAVA);
+ }
+
+ this.h = this.e.b().containsKey("dungeon");
+ Iterator iterator = this.e.c().iterator();
+
+ while (iterator.hasNext()) {
+ WorldGenFlatLayerInfo worldgenflatlayerinfo = (WorldGenFlatLayerInfo) iterator.next();
+
+ for (int j = worldgenflatlayerinfo.d(); j < worldgenflatlayerinfo.d() + worldgenflatlayerinfo.a(); ++j) {
+ this.c[j] = worldgenflatlayerinfo.b();
+ this.d[j] = (byte) worldgenflatlayerinfo.c();
+ }
+ }
+ }
+
+ public Chunk getChunkAt(int i, int j) {
+ return this.getOrCreateChunk(i, j);
+ }
+
+ public Chunk getOrCreateChunk(int i, int j) {
+ Chunk chunk = new Chunk(this.a, i, j);
+
+ int k;
+
+ for (int l = 0; l < this.c.length; ++l) {
+ Block block = this.c[l];
+
+ if (block != null) {
+ k = l >> 4;
+ ChunkSection chunksection = chunk.getSections()[k];
+
+ if (chunksection == null) {
+ chunksection = new ChunkSection(l, !this.a.worldProvider.g);
+ chunk.getSections()[k] = chunksection;
+ }
+
+ for (int i1 = 0; i1 < 16; ++i1) {
+ for (int j1 = 0; j1 < 16; ++j1) {
+ chunksection.setTypeId(i1, l & 15, j1, block);
+ chunksection.setData(i1, l & 15, j1, this.d[l]);
+ }
+ }
+ }
+ }
+
+ chunk.initLighting();
+ BiomeBase[] abiomebase = this.a.getWorldChunkManager().getBiomeBlock((BiomeBase[]) null, i * 16, j * 16, 16, 16);
+ byte[] abyte = chunk.m();
+
+ for (k = 0; k < abyte.length; ++k) {
+ abyte[k] = (byte) abiomebase[k].id;
+ }
+
+ Iterator iterator = this.f.iterator();
+
+ while (iterator.hasNext()) {
+ WorldGenBase worldgenbase = (WorldGenBase) iterator.next();
+
+ worldgenbase.a(this, this.a, i, j, (Block[]) null);
+ }
+
+ chunk.initLighting();
+ return chunk;
+ }
+
+ public boolean isChunkLoaded(int i, int j) {
+ return true;
+ }
+
+ public void getChunkAt(IChunkProvider ichunkprovider, int i, int j) {
+ int k = i * 16;
+ int l = j * 16;
+ BiomeBase biomebase = this.a.getBiome(k + 16, l + 16);
+ boolean flag = false;
+
+ this.b.setSeed(this.a.getSeed());
+ long i1 = this.b.nextLong() / 2L * 2L + 1L;
+ long j1 = this.b.nextLong() / 2L * 2L + 1L;
+
+ this.b.setSeed((long) i * i1 + (long) j * j1 ^ this.a.getSeed());
+ Iterator iterator = this.f.iterator();
+
+ while (iterator.hasNext()) {
+ StructureGenerator structuregenerator = (StructureGenerator) iterator.next();
+ boolean flag1 = structuregenerator.a(this.a, this.b, i, j);
+
+ if (structuregenerator instanceof WorldGenVillage) {
+ flag |= flag1;
+ }
+ }
+
+ int k1;
+ int l1;
+ int i2;
+
+ if (this.i != null && !flag && this.b.nextInt(4) == 0) {
+ l1 = k + this.b.nextInt(16) + 8;
+ k1 = this.b.nextInt(256);
+ i2 = l + this.b.nextInt(16) + 8;
+ this.i.generate(this.a, this.b, l1, k1, i2);
+ }
+
+ if (this.j != null && !flag && this.b.nextInt(8) == 0) {
+ l1 = k + this.b.nextInt(16) + 8;
+ k1 = this.b.nextInt(this.b.nextInt(248) + 8);
+ i2 = l + this.b.nextInt(16) + 8;
+ if (k1 < 63 || this.b.nextInt(10) == 0) {
+ this.j.generate(this.a, this.b, l1, k1, i2);
+ }
+ }
+
+ if (this.h) {
+ for (l1 = 0; l1 < 8; ++l1) {
+ k1 = k + this.b.nextInt(16) + 8;
+ i2 = this.b.nextInt(256);
+ int j2 = l + this.b.nextInt(16) + 8;
+
+ (new WorldGenDungeons()).generate(this.a, this.b, k1, i2, j2);
+ }
+ }
+
+ if (this.g) {
+ biomebase.a(this.a, this.b, k, l);
+ }
+ }
+
+ public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate) {
+ return true;
+ }
+
+ public void c() {}
+
+ public boolean unloadChunks() {
+ return false;
+ }
+
+ public boolean canSave() {
+ return true;
+ }
+
+ public String getName() {
+ return "FlatLevelSource";
+ }
+
+ public List getMobsFor(EnumCreatureType enumcreaturetype, int i, int j, int k) {
+ BiomeBase biomebase = this.a.getBiome(i, k);
+
+ return biomebase.getMobs(enumcreaturetype);
+ }
+
+ public ChunkPosition findNearestMapFeature(World world, String s, int i, int j, int k) {
+ if ("Stronghold".equals(s)) {
+ Iterator iterator = this.f.iterator();
+
+ while (iterator.hasNext()) {
+ StructureGenerator structuregenerator = (StructureGenerator) iterator.next();
+
+ if (structuregenerator instanceof WorldGenStronghold) {
+ return structuregenerator.getNearestGeneratedFeature(world, i, j, k);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public int getLoadedChunks() {
+ return 0;
+ }
+
+ public void recreateStructures(int i, int j) {
+ Iterator iterator = this.f.iterator();
+
+ while (iterator.hasNext()) {
+ StructureGenerator structuregenerator = (StructureGenerator) iterator.next();
+
+ structuregenerator.a(this, this.a, i, j, (Block[]) null);
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ChunkProviderGenerate.java b/src/main/java/net/minecraft/server/ChunkProviderGenerate.java
new file mode 100644
index 000000000..813df4d63
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ChunkProviderGenerate.java
@@ -0,0 +1,392 @@
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Random;
+
+public class ChunkProviderGenerate implements IChunkProvider {
+
+ private Random i;
+ private NoiseGeneratorOctaves j;
+ private NoiseGeneratorOctaves k;
+ private NoiseGeneratorOctaves l;
+ private NoiseGenerator3 m;
+ public NoiseGeneratorOctaves a;
+ public NoiseGeneratorOctaves b;
+ public NoiseGeneratorOctaves c;
+ private World n;
+ private final boolean o;
+ private WorldType p;
+ private final double[] q;
+ private final float[] r;
+ private double[] s = new double[256];
+ private WorldGenBase t = new WorldGenCaves();
+ private WorldGenStronghold u = new WorldGenStronghold();
+ private WorldGenVillage v = new WorldGenVillage();
+ private WorldGenMineshaft w = new WorldGenMineshaft();
+ private WorldGenLargeFeature x = new WorldGenLargeFeature();
+ private WorldGenBase y = new WorldGenCanyon();
+ private BiomeBase[] z;
+ double[] d;
+ double[] e;
+ double[] f;
+ double[] g;
+ int[][] h = new int[32][32];
+
+ public ChunkProviderGenerate(World world, long i, boolean flag) {
+ this.n = world;
+ this.o = flag;
+ this.p = world.getWorldData().getType();
+ this.i = new Random(i);
+ this.j = new NoiseGeneratorOctaves(this.i, 16);
+ this.k = new NoiseGeneratorOctaves(this.i, 16);
+ this.l = new NoiseGeneratorOctaves(this.i, 8);
+ this.m = new NoiseGenerator3(this.i, 4);
+ this.a = new NoiseGeneratorOctaves(this.i, 10);
+ this.b = new NoiseGeneratorOctaves(this.i, 16);
+ this.c = new NoiseGeneratorOctaves(this.i, 8);
+ this.q = new double[825];
+ this.r = new float[25];
+
+ for (int j = -2; j <= 2; ++j) {
+ for (int k = -2; k <= 2; ++k) {
+ float f = 10.0F / MathHelper.c((float) (j * j + k * k) + 0.2F);
+
+ this.r[j + 2 + (k + 2) * 5] = f;
+ }
+ }
+ }
+
+ public void a(int i, int j, Block[] ablock) {
+ byte b0 = 63;
+
+ this.z = this.n.getWorldChunkManager().getBiomes(this.z, i * 4 - 2, j * 4 - 2, 10, 10);
+ this.a(i * 4, 0, j * 4);
+
+ for (int k = 0; k < 4; ++k) {
+ int l = k * 5;
+ int i1 = (k + 1) * 5;
+
+ for (int j1 = 0; j1 < 4; ++j1) {
+ int k1 = (l + j1) * 33;
+ int l1 = (l + j1 + 1) * 33;
+ int i2 = (i1 + j1) * 33;
+ int j2 = (i1 + j1 + 1) * 33;
+
+ for (int k2 = 0; k2 < 32; ++k2) {
+ double d0 = 0.125D;
+ double d1 = this.q[k1 + k2];
+ double d2 = this.q[l1 + k2];
+ double d3 = this.q[i2 + k2];
+ double d4 = this.q[j2 + k2];
+ double d5 = (this.q[k1 + k2 + 1] - d1) * d0;
+ double d6 = (this.q[l1 + k2 + 1] - d2) * d0;
+ double d7 = (this.q[i2 + k2 + 1] - d3) * d0;
+ double d8 = (this.q[j2 + k2 + 1] - d4) * d0;
+
+ for (int l2 = 0; l2 < 8; ++l2) {
+ double d9 = 0.25D;
+ double d10 = d1;
+ double d11 = d2;
+ double d12 = (d3 - d1) * d9;
+ double d13 = (d4 - d2) * d9;
+
+ for (int i3 = 0; i3 < 4; ++i3) {
+ int j3 = i3 + k * 4 << 12 | 0 + j1 * 4 << 8 | k2 * 8 + l2;
+ short short1 = 256;
+
+ j3 -= short1;
+ double d14 = 0.25D;
+ double d15 = (d11 - d10) * d14;
+ double d16 = d10 - d15;
+
+ for (int k3 = 0; k3 < 4; ++k3) {
+ if ((d16 += d15) > 0.0D) {
+ ablock[j3 += short1] = Blocks.STONE;
+ } else if (k2 * 8 + l2 < b0) {
+ ablock[j3 += short1] = Blocks.STATIONARY_WATER;
+ } else {
+ ablock[j3 += short1] = null;
+ }
+ }
+
+ d10 += d12;
+ d11 += d13;
+ }
+
+ d1 += d5;
+ d2 += d6;
+ d3 += d7;
+ d4 += d8;
+ }
+ }
+ }
+ }
+ }
+
+ public void a(int i, int j, Block[] ablock, byte[] abyte, BiomeBase[] abiomebase) {
+ double d0 = 0.03125D;
+
+ this.s = this.m.a(this.s, (double) (i * 16), (double) (j * 16), 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D);
+
+ for (int k = 0; k < 16; ++k) {
+ for (int l = 0; l < 16; ++l) {
+ BiomeBase biomebase = abiomebase[l + k * 16];
+
+ biomebase.a(this.n, this.i, ablock, abyte, i * 16 + k, j * 16 + l, this.s[l + k * 16]);
+ }
+ }
+ }
+
+ public Chunk getChunkAt(int i, int j) {
+ return this.getOrCreateChunk(i, j);
+ }
+
+ public Chunk getOrCreateChunk(int i, int j) {
+ this.i.setSeed((long) i * 341873128712L + (long) j * 132897987541L);
+ Block[] ablock = new Block[65536];
+ byte[] abyte = new byte[65536];
+
+ this.a(i, j, ablock);
+ this.z = this.n.getWorldChunkManager().getBiomeBlock(this.z, i * 16, j * 16, 16, 16);
+ this.a(i, j, ablock, abyte, this.z);
+ this.t.a(this, this.n, i, j, ablock);
+ this.y.a(this, this.n, i, j, ablock);
+ if (this.o) {
+ this.w.a(this, this.n, i, j, ablock);
+ this.v.a(this, this.n, i, j, ablock);
+ this.u.a(this, this.n, i, j, ablock);
+ this.x.a(this, this.n, i, j, ablock);
+ }
+
+ Chunk chunk = new Chunk(this.n, ablock, abyte, i, j);
+ byte[] abyte1 = chunk.m();
+
+ for (int k = 0; k < abyte1.length; ++k) {
+ abyte1[k] = (byte) this.z[k].id;
+ }
+
+ chunk.initLighting();
+ return chunk;
+ }
+
+ private void a(int i, int j, int k) {
+ double d0 = 684.412D;
+ double d1 = 684.412D;
+ double d2 = 512.0D;
+ double d3 = 512.0D;
+
+ this.g = this.b.a(this.g, i, k, 5, 5, 200.0D, 200.0D, 0.5D);
+ this.d = this.l.a(this.d, i, j, k, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);
+ this.e = this.j.a(this.e, i, j, k, 5, 33, 5, 684.412D, 684.412D, 684.412D);
+ this.f = this.k.a(this.f, i, j, k, 5, 33, 5, 684.412D, 684.412D, 684.412D);
+ boolean flag = false;
+ boolean flag1 = false;
+ int l = 0;
+ int i1 = 0;
+ double d4 = 8.5D;
+
+ for (int j1 = 0; j1 < 5; ++j1) {
+ for (int k1 = 0; k1 < 5; ++k1) {
+ float f = 0.0F;
+ float f1 = 0.0F;
+ float f2 = 0.0F;
+ byte b0 = 2;
+ BiomeBase biomebase = this.z[j1 + 2 + (k1 + 2) * 10];
+
+ for (int l1 = -b0; l1 <= b0; ++l1) {
+ for (int i2 = -b0; i2 <= b0; ++i2) {
+ BiomeBase biomebase1 = this.z[j1 + l1 + 2 + (k1 + i2 + 2) * 10];
+ float f3 = biomebase1.am;
+ float f4 = biomebase1.an;
+
+ if (this.p == WorldType.AMPLIFIED && f3 > 0.0F) {
+ f3 = 1.0F + f3 * 2.0F;
+ f4 = 1.0F + f4 * 4.0F;
+ }
+
+ float f5 = this.r[l1 + 2 + (i2 + 2) * 5] / (f3 + 2.0F);
+
+ if (biomebase1.am > biomebase.am) {
+ f5 /= 2.0F;
+ }
+
+ f += f4 * f5;
+ f1 += f3 * f5;
+ f2 += f5;
+ }
+ }
+
+ f /= f2;
+ f1 /= f2;
+ f = f * 0.9F + 0.1F;
+ f1 = (f1 * 4.0F - 1.0F) / 8.0F;
+ double d5 = this.g[i1] / 8000.0D;
+
+ if (d5 < 0.0D) {
+ d5 = -d5 * 0.3D;
+ }
+
+ d5 = d5 * 3.0D - 2.0D;
+ if (d5 < 0.0D) {
+ d5 /= 2.0D;
+ if (d5 < -1.0D) {
+ d5 = -1.0D;
+ }
+
+ d5 /= 1.4D;
+ d5 /= 2.0D;
+ } else {
+ if (d5 > 1.0D) {
+ d5 = 1.0D;
+ }
+
+ d5 /= 8.0D;
+ }
+
+ ++i1;
+ double d6 = (double) f1;
+ double d7 = (double) f;
+
+ d6 += d5 * 0.2D;
+ d6 = d6 * 8.5D / 8.0D;
+ double d8 = 8.5D + d6 * 4.0D;
+
+ for (int j2 = 0; j2 < 33; ++j2) {
+ double d9 = ((double) j2 - d8) * 12.0D * 128.0D / 256.0D / d7;
+
+ if (d9 < 0.0D) {
+ d9 *= 4.0D;
+ }
+
+ double d10 = this.e[l] / 512.0D;
+ double d11 = this.f[l] / 512.0D;
+ double d12 = (this.d[l] / 10.0D + 1.0D) / 2.0D;
+ double d13 = MathHelper.b(d10, d11, d12) - d9;
+
+ if (j2 > 29) {
+ double d14 = (double) ((float) (j2 - 29) / 3.0F);
+
+ d13 = d13 * (1.0D - d14) + -10.0D * d14;
+ }
+
+ this.q[l] = d13;
+ ++l;
+ }
+ }
+ }
+ }
+
+ public boolean isChunkLoaded(int i, int j) {
+ return true;
+ }
+
+ public void getChunkAt(IChunkProvider ichunkprovider, int i, int j) {
+ BlockFalling.instaFall = true;
+ int k = i * 16;
+ int l = j * 16;
+ BiomeBase biomebase = this.n.getBiome(k + 16, l + 16);
+
+ this.i.setSeed(this.n.getSeed());
+ long i1 = this.i.nextLong() / 2L * 2L + 1L;
+ long j1 = this.i.nextLong() / 2L * 2L + 1L;
+
+ this.i.setSeed((long) i * i1 + (long) j * j1 ^ this.n.getSeed());
+ boolean flag = false;
+
+ if (this.o) {
+ this.w.a(this.n, this.i, i, j);
+ flag = this.v.a(this.n, this.i, i, j);
+ this.u.a(this.n, this.i, i, j);
+ this.x.a(this.n, this.i, i, j);
+ }
+
+ int k1;
+ int l1;
+ int i2;
+
+ if (biomebase != BiomeBase.DESERT && biomebase != BiomeBase.DESERT_HILLS && !flag && this.i.nextInt(4) == 0) {
+ k1 = k + this.i.nextInt(16) + 8;
+ l1 = this.i.nextInt(256);
+ i2 = l + this.i.nextInt(16) + 8;
+ (new WorldGenLakes(Blocks.STATIONARY_WATER)).generate(this.n, this.i, k1, l1, i2);
+ }
+
+ if (!flag && this.i.nextInt(8) == 0) {
+ k1 = k + this.i.nextInt(16) + 8;
+ l1 = this.i.nextInt(this.i.nextInt(248) + 8);
+ i2 = l + this.i.nextInt(16) + 8;
+ if (l1 < 63 || this.i.nextInt(10) == 0) {
+ (new WorldGenLakes(Blocks.STATIONARY_LAVA)).generate(this.n, this.i, k1, l1, i2);
+ }
+ }
+
+ for (k1 = 0; k1 < 8; ++k1) {
+ l1 = k + this.i.nextInt(16) + 8;
+ i2 = this.i.nextInt(256);
+ int j2 = l + this.i.nextInt(16) + 8;
+
+ (new WorldGenDungeons()).generate(this.n, this.i, l1, i2, j2);
+ }
+
+ biomebase.a(this.n, this.i, k, l);
+ SpawnerCreature.a(this.n, biomebase, k + 8, l + 8, 16, 16, this.i);
+ k += 8;
+ l += 8;
+
+ for (k1 = 0; k1 < 16; ++k1) {
+ for (l1 = 0; l1 < 16; ++l1) {
+ i2 = this.n.h(k + k1, l + l1);
+ if (this.n.r(k1 + k, i2 - 1, l1 + l)) {
+ this.n.setTypeAndData(k1 + k, i2 - 1, l1 + l, Blocks.ICE, 0, 2);
+ }
+
+ if (this.n.e(k1 + k, i2, l1 + l, true)) {
+ this.n.setTypeAndData(k1 + k, i2, l1 + l, Blocks.SNOW, 0, 2);
+ }
+ }
+ }
+
+ BlockFalling.instaFall = false;
+ }
+
+ public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate) {
+ return true;
+ }
+
+ public void c() {}
+
+ public boolean unloadChunks() {
+ return false;
+ }
+
+ public boolean canSave() {
+ return true;
+ }
+
+ public String getName() {
+ return "RandomLevelSource";
+ }
+
+ public List getMobsFor(EnumCreatureType enumcreaturetype, int i, int j, int k) {
+ BiomeBase biomebase = this.n.getBiome(i, k);
+
+ return enumcreaturetype == EnumCreatureType.MONSTER && this.x.a(i, j, k) ? this.x.b() : biomebase.getMobs(enumcreaturetype);
+ }
+
+ public ChunkPosition findNearestMapFeature(World world, String s, int i, int j, int k) {
+ return "Stronghold".equals(s) && this.u != null ? this.u.getNearestGeneratedFeature(world, i, j, k) : null;
+ }
+
+ public int getLoadedChunks() {
+ return 0;
+ }
+
+ public void recreateStructures(int i, int j) {
+ if (this.o) {
+ this.w.a(this, this.n, i, j, (Block[]) null);
+ this.v.a(this, this.n, i, j, (Block[]) null);
+ this.u.a(this, this.n, i, j, (Block[]) null);
+ this.x.a(this, this.n, i, j, (Block[]) null);
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ChunkProviderHell.java b/src/main/java/net/minecraft/server/ChunkProviderHell.java
new file mode 100644
index 000000000..ef4894e63
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ChunkProviderHell.java
@@ -0,0 +1,445 @@
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Random;
+
+public class ChunkProviderHell implements IChunkProvider {
+
+ private Random i;
+ private NoiseGeneratorOctaves j;
+ private NoiseGeneratorOctaves k;
+ private NoiseGeneratorOctaves l;
+ private NoiseGeneratorOctaves m;
+ private NoiseGeneratorOctaves n;
+ public NoiseGeneratorOctaves a;
+ public NoiseGeneratorOctaves b;
+ private World o;
+ private double[] p;
+ public WorldGenNether c = new WorldGenNether();
+ private double[] q = new double[256];
+ private double[] r = new double[256];
+ private double[] s = new double[256];
+ private WorldGenBase t = new WorldGenCavesHell();
+ double[] d;
+ double[] e;
+ double[] f;
+ double[] g;
+ double[] h;
+
+ public ChunkProviderHell(World world, long i) {
+ this.o = world;
+ this.i = new Random(i);
+ this.j = new NoiseGeneratorOctaves(this.i, 16);
+ this.k = new NoiseGeneratorOctaves(this.i, 16);
+ this.l = new NoiseGeneratorOctaves(this.i, 8);
+ this.m = new NoiseGeneratorOctaves(this.i, 4);
+ this.n = new NoiseGeneratorOctaves(this.i, 4);
+ this.a = new NoiseGeneratorOctaves(this.i, 10);
+ this.b = new NoiseGeneratorOctaves(this.i, 16);
+ }
+
+ public void a(int i, int j, Block[] ablock) {
+ byte b0 = 4;
+ byte b1 = 32;
+ int k = b0 + 1;
+ byte b2 = 17;
+ int l = b0 + 1;
+
+ this.p = this.a(this.p, i * b0, 0, j * b0, k, b2, l);
+
+ for (int i1 = 0; i1 < b0; ++i1) {
+ for (int j1 = 0; j1 < b0; ++j1) {
+ for (int k1 = 0; k1 < 16; ++k1) {
+ double d0 = 0.125D;
+ double d1 = this.p[((i1 + 0) * l + j1 + 0) * b2 + k1 + 0];
+ double d2 = this.p[((i1 + 0) * l + j1 + 1) * b2 + k1 + 0];
+ double d3 = this.p[((i1 + 1) * l + j1 + 0) * b2 + k1 + 0];
+ double d4 = this.p[((i1 + 1) * l + j1 + 1) * b2 + k1 + 0];
+ double d5 = (this.p[((i1 + 0) * l + j1 + 0) * b2 + k1 + 1] - d1) * d0;
+ double d6 = (this.p[((i1 + 0) * l + j1 + 1) * b2 + k1 + 1] - d2) * d0;
+ double d7 = (this.p[((i1 + 1) * l + j1 + 0) * b2 + k1 + 1] - d3) * d0;
+ double d8 = (this.p[((i1 + 1) * l + j1 + 1) * b2 + k1 + 1] - d4) * d0;
+
+ for (int l1 = 0; l1 < 8; ++l1) {
+ double d9 = 0.25D;
+ double d10 = d1;
+ double d11 = d2;
+ double d12 = (d3 - d1) * d9;
+ double d13 = (d4 - d2) * d9;
+
+ for (int i2 = 0; i2 < 4; ++i2) {
+ int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1;
+ short short1 = 128;
+ double d14 = 0.25D;
+ double d15 = d10;
+ double d16 = (d11 - d10) * d14;
+
+ for (int k2 = 0; k2 < 4; ++k2) {
+ Block block = null;
+
+ if (k1 * 8 + l1 < b1) {
+ block = Blocks.STATIONARY_LAVA;
+ }
+
+ if (d15 > 0.0D) {
+ block = Blocks.NETHERRACK;
+ }
+
+ ablock[j2] = block;
+ j2 += short1;
+ d15 += d16;
+ }
+
+ d10 += d12;
+ d11 += d13;
+ }
+
+ d1 += d5;
+ d2 += d6;
+ d3 += d7;
+ d4 += d8;
+ }
+ }
+ }
+ }
+ }
+
+ public void b(int i, int j, Block[] ablock) {
+ byte b0 = 64;
+ double d0 = 0.03125D;
+
+ this.q = this.m.a(this.q, i * 16, j * 16, 0, 16, 16, 1, d0, d0, 1.0D);
+ this.r = this.m.a(this.r, i * 16, 109, j * 16, 16, 1, 16, d0, 1.0D, d0);
+ this.s = this.n.a(this.s, i * 16, j * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D, d0 * 2.0D);
+
+ for (int k = 0; k < 16; ++k) {
+ for (int l = 0; l < 16; ++l) {
+ boolean flag = this.q[k + l * 16] + this.i.nextDouble() * 0.2D > 0.0D;
+ boolean flag1 = this.r[k + l * 16] + this.i.nextDouble() * 0.2D > 0.0D;
+ int i1 = (int) (this.s[k + l * 16] / 3.0D + 3.0D + this.i.nextDouble() * 0.25D);
+ int j1 = -1;
+ Block block = Blocks.NETHERRACK;
+ Block block1 = Blocks.NETHERRACK;
+
+ for (int k1 = 127; k1 >= 0; --k1) {
+ int l1 = (l * 16 + k) * 128 + k1;
+
+ if (k1 < 127 - this.i.nextInt(5) && k1 > 0 + this.i.nextInt(5)) {
+ Block block2 = ablock[l1];
+
+ if (block2 != null && block2.getMaterial() != Material.AIR) {
+ if (block2 == Blocks.NETHERRACK) {
+ if (j1 == -1) {
+ if (i1 <= 0) {
+ block = null;
+ block1 = Blocks.NETHERRACK;
+ } else if (k1 >= b0 - 4 && k1 <= b0 + 1) {
+ block = Blocks.NETHERRACK;
+ block1 = Blocks.NETHERRACK;
+ if (flag1) {
+ block = Blocks.GRAVEL;
+ block1 = Blocks.NETHERRACK;
+ }
+
+ if (flag) {
+ block = Blocks.SOUL_SAND;
+ block1 = Blocks.SOUL_SAND;
+ }
+ }
+
+ if (k1 < b0 && (block == null || block.getMaterial() == Material.AIR)) {
+ block = Blocks.STATIONARY_LAVA;
+ }
+
+ j1 = i1;
+ if (k1 >= b0 - 1) {
+ ablock[l1] = block;
+ } else {
+ ablock[l1] = block1;
+ }
+ } else if (j1 > 0) {
+ --j1;
+ ablock[l1] = block1;
+ }
+ }
+ } else {
+ j1 = -1;
+ }
+ } else {
+ ablock[l1] = Blocks.BEDROCK;
+ }
+ }
+ }
+ }
+ }
+
+ public Chunk getChunkAt(int i, int j) {
+ return this.getOrCreateChunk(i, j);
+ }
+
+ public Chunk getOrCreateChunk(int i, int j) {
+ this.i.setSeed((long) i * 341873128712L + (long) j * 132897987541L);
+ Block[] ablock = new Block['\u8000'];
+
+ this.a(i, j, ablock);
+ this.b(i, j, ablock);
+ this.t.a(this, this.o, i, j, ablock);
+ this.c.a(this, this.o, i, j, ablock);
+ Chunk chunk = new Chunk(this.o, ablock, i, j);
+ BiomeBase[] abiomebase = this.o.getWorldChunkManager().getBiomeBlock((BiomeBase[]) null, i * 16, j * 16, 16, 16);
+ byte[] abyte = chunk.m();
+
+ for (int k = 0; k < abyte.length; ++k) {
+ abyte[k] = (byte) abiomebase[k].id;
+ }
+
+ chunk.n();
+ return chunk;
+ }
+
+ private double[] a(double[] adouble, int i, int j, int k, int l, int i1, int j1) {
+ if (adouble == null) {
+ adouble = new double[l * i1 * j1];
+ }
+
+ double d0 = 684.412D;
+ double d1 = 2053.236D;
+
+ this.g = this.a.a(this.g, i, j, k, l, 1, j1, 1.0D, 0.0D, 1.0D);
+ this.h = this.b.a(this.h, i, j, k, l, 1, j1, 100.0D, 0.0D, 100.0D);
+ this.d = this.l.a(this.d, i, j, k, l, i1, j1, d0 / 80.0D, d1 / 60.0D, d0 / 80.0D);
+ this.e = this.j.a(this.e, i, j, k, l, i1, j1, d0, d1, d0);
+ this.f = this.k.a(this.f, i, j, k, l, i1, j1, d0, d1, d0);
+ int k1 = 0;
+ int l1 = 0;
+ double[] adouble1 = new double[i1];
+
+ int i2;
+
+ for (i2 = 0; i2 < i1; ++i2) {
+ adouble1[i2] = Math.cos((double) i2 * 3.141592653589793D * 6.0D / (double) i1) * 2.0D;
+ double d2 = (double) i2;
+
+ if (i2 > i1 / 2) {
+ d2 = (double) (i1 - 1 - i2);
+ }
+
+ if (d2 < 4.0D) {
+ d2 = 4.0D - d2;
+ adouble1[i2] -= d2 * d2 * d2 * 10.0D;
+ }
+ }
+
+ for (i2 = 0; i2 < l; ++i2) {
+ for (int j2 = 0; j2 < j1; ++j2) {
+ double d3 = (this.g[l1] + 256.0D) / 512.0D;
+
+ if (d3 > 1.0D) {
+ d3 = 1.0D;
+ }
+
+ double d4 = 0.0D;
+ double d5 = this.h[l1] / 8000.0D;
+
+ if (d5 < 0.0D) {
+ d5 = -d5;
+ }
+
+ d5 = d5 * 3.0D - 3.0D;
+ if (d5 < 0.0D) {
+ d5 /= 2.0D;
+ if (d5 < -1.0D) {
+ d5 = -1.0D;
+ }
+
+ d5 /= 1.4D;
+ d5 /= 2.0D;
+ d3 = 0.0D;
+ } else {
+ if (d5 > 1.0D) {
+ d5 = 1.0D;
+ }
+
+ d5 /= 6.0D;
+ }
+
+ d3 += 0.5D;
+ d5 = d5 * (double) i1 / 16.0D;
+ ++l1;
+
+ for (int k2 = 0; k2 < i1; ++k2) {
+ double d6 = 0.0D;
+ double d7 = adouble1[k2];
+ double d8 = this.e[k1] / 512.0D;
+ double d9 = this.f[k1] / 512.0D;
+ double d10 = (this.d[k1] / 10.0D + 1.0D) / 2.0D;
+
+ if (d10 < 0.0D) {
+ d6 = d8;
+ } else if (d10 > 1.0D) {
+ d6 = d9;
+ } else {
+ d6 = d8 + (d9 - d8) * d10;
+ }
+
+ d6 -= d7;
+ double d11;
+
+ if (k2 > i1 - 4) {
+ d11 = (double) ((float) (k2 - (i1 - 4)) / 3.0F);
+ d6 = d6 * (1.0D - d11) + -10.0D * d11;
+ }
+
+ if ((double) k2 < d4) {
+ d11 = (d4 - (double) k2) / 4.0D;
+ if (d11 < 0.0D) {
+ d11 = 0.0D;
+ }
+
+ if (d11 > 1.0D) {
+ d11 = 1.0D;
+ }
+
+ d6 = d6 * (1.0D - d11) + -10.0D * d11;
+ }
+
+ adouble[k1] = d6;
+ ++k1;
+ }
+ }
+ }
+
+ return adouble;
+ }
+
+ public boolean isChunkLoaded(int i, int j) {
+ return true;
+ }
+
+ public void getChunkAt(IChunkProvider ichunkprovider, int i, int j) {
+ BlockFalling.instaFall = true;
+ int k = i * 16;
+ int l = j * 16;
+
+ this.c.a(this.o, this.i, i, j);
+
+ int i1;
+ int j1;
+ int k1;
+ int l1;
+
+ for (i1 = 0; i1 < 8; ++i1) {
+ j1 = k + this.i.nextInt(16) + 8;
+ k1 = this.i.nextInt(120) + 4;
+ l1 = l + this.i.nextInt(16) + 8;
+ (new WorldGenHellLava(Blocks.LAVA, false)).generate(this.o, this.i, j1, k1, l1);
+ }
+
+ i1 = this.i.nextInt(this.i.nextInt(10) + 1) + 1;
+
+ int i2;
+
+ for (j1 = 0; j1 < i1; ++j1) {
+ k1 = k + this.i.nextInt(16) + 8;
+ l1 = this.i.nextInt(120) + 4;
+ i2 = l + this.i.nextInt(16) + 8;
+ (new WorldGenFire()).generate(this.o, this.i, k1, l1, i2);
+ }
+
+ i1 = this.i.nextInt(this.i.nextInt(10) + 1);
+
+ for (j1 = 0; j1 < i1; ++j1) {
+ k1 = k + this.i.nextInt(16) + 8;
+ l1 = this.i.nextInt(120) + 4;
+ i2 = l + this.i.nextInt(16) + 8;
+ (new WorldGenLightStone1()).generate(this.o, this.i, k1, l1, i2);
+ }
+
+ for (j1 = 0; j1 < 10; ++j1) {
+ k1 = k + this.i.nextInt(16) + 8;
+ l1 = this.i.nextInt(128);
+ i2 = l + this.i.nextInt(16) + 8;
+ (new WorldGenLightStone2()).generate(this.o, this.i, k1, l1, i2);
+ }
+
+ if (this.i.nextInt(1) == 0) {
+ j1 = k + this.i.nextInt(16) + 8;
+ k1 = this.i.nextInt(128);
+ l1 = l + this.i.nextInt(16) + 8;
+ (new WorldGenFlowers(Blocks.BROWN_MUSHROOM)).generate(this.o, this.i, j1, k1, l1);
+ }
+
+ if (this.i.nextInt(1) == 0) {
+ j1 = k + this.i.nextInt(16) + 8;
+ k1 = this.i.nextInt(128);
+ l1 = l + this.i.nextInt(16) + 8;
+ (new WorldGenFlowers(Blocks.RED_MUSHROOM)).generate(this.o, this.i, j1, k1, l1);
+ }
+
+ WorldGenMinable worldgenminable = new WorldGenMinable(Blocks.QUARTZ_ORE, 13, Blocks.NETHERRACK);
+
+ int j2;
+
+ for (k1 = 0; k1 < 16; ++k1) {
+ l1 = k + this.i.nextInt(16);
+ i2 = this.i.nextInt(108) + 10;
+ j2 = l + this.i.nextInt(16);
+ worldgenminable.generate(this.o, this.i, l1, i2, j2);
+ }
+
+ for (k1 = 0; k1 < 16; ++k1) {
+ l1 = k + this.i.nextInt(16);
+ i2 = this.i.nextInt(108) + 10;
+ j2 = l + this.i.nextInt(16);
+ (new WorldGenHellLava(Blocks.LAVA, true)).generate(this.o, this.i, l1, i2, j2);
+ }
+
+ BlockFalling.instaFall = false;
+ }
+
+ public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate) {
+ return true;
+ }
+
+ public void c() {}
+
+ public boolean unloadChunks() {
+ return false;
+ }
+
+ public boolean canSave() {
+ return true;
+ }
+
+ public String getName() {
+ return "HellRandomLevelSource";
+ }
+
+ public List getMobsFor(EnumCreatureType enumcreaturetype, int i, int j, int k) {
+ if (enumcreaturetype == EnumCreatureType.MONSTER) {
+ if (this.c.b(i, j, k)) {
+ return this.c.b();
+ }
+
+ if (this.c.d(i, j, k) && this.o.getType(i, j - 1, k) == Blocks.NETHER_BRICK) {
+ return this.c.b();
+ }
+ }
+
+ BiomeBase biomebase = this.o.getBiome(i, k);
+
+ return biomebase.getMobs(enumcreaturetype);
+ }
+
+ public ChunkPosition findNearestMapFeature(World world, String s, int i, int j, int k) {
+ return null;
+ }
+
+ public int getLoadedChunks() {
+ return 0;
+ }
+
+ public void recreateStructures(int i, int j) {
+ this.c.a(this, this.o, i, j, (Block[]) null);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/FileIOThread.java b/src/main/java/net/minecraft/server/FileIOThread.java
new file mode 100644
index 000000000..e9c333bfb
--- /dev/null
+++ b/src/main/java/net/minecraft/server/FileIOThread.java
@@ -0,0 +1,70 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class FileIOThread implements Runnable {
+
+ public static final FileIOThread a = new FileIOThread();
+ private List b = Collections.synchronizedList(new ArrayList());
+ private volatile long c;
+ private volatile long d;
+ private volatile boolean e;
+
+ private FileIOThread() {
+ Thread thread = new Thread(this, "File IO Thread");
+
+ thread.setPriority(1);
+ thread.start();
+ }
+
+ public void run() {
+ while (true) {
+ this.b();
+ }
+ }
+
+ private void b() {
+ for (int i = 0; i < this.b.size(); ++i) {
+ IAsyncChunkSaver iasyncchunksaver = (IAsyncChunkSaver) this.b.get(i);
+ boolean flag = iasyncchunksaver.c();
+
+ if (!flag) {
+ this.b.remove(i--);
+ ++this.d;
+ }
+
+ try {
+ Thread.sleep(this.e ? 0L : 10L);
+ } catch (InterruptedException interruptedexception) {
+ interruptedexception.printStackTrace();
+ }
+ }
+
+ if (this.b.isEmpty()) {
+ try {
+ Thread.sleep(25L);
+ } catch (InterruptedException interruptedexception1) {
+ interruptedexception1.printStackTrace();
+ }
+ }
+ }
+
+ public void a(IAsyncChunkSaver iasyncchunksaver) {
+ if (!this.b.contains(iasyncchunksaver)) {
+ ++this.c;
+ this.b.add(iasyncchunksaver);
+ }
+ }
+
+ public void a() throws InterruptedException {
+ this.e = true;
+
+ while (this.c != this.d) {
+ Thread.sleep(10L);
+ }
+
+ this.e = false;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/GenLayer.java b/src/main/java/net/minecraft/server/GenLayer.java
new file mode 100644
index 000000000..b15e0f608
--- /dev/null
+++ b/src/main/java/net/minecraft/server/GenLayer.java
@@ -0,0 +1,168 @@
+package net.minecraft.server;
+
+import java.util.concurrent.Callable;
+
+public abstract class GenLayer {
+
+ private long c;
+ protected GenLayer a;
+ private long d;
+ protected long b;
+
+ public static GenLayer[] a(long i, WorldType worldtype) {
+ boolean flag = false;
+ LayerIsland layerisland = new LayerIsland(1L);
+ GenLayerZoomFuzzy genlayerzoomfuzzy = new GenLayerZoomFuzzy(2000L, layerisland);
+ GenLayerIsland genlayerisland = new GenLayerIsland(1L, genlayerzoomfuzzy);
+ GenLayerZoom genlayerzoom = new GenLayerZoom(2001L, genlayerisland);
+
+ genlayerisland = new GenLayerIsland(2L, genlayerzoom);
+ genlayerisland = new GenLayerIsland(50L, genlayerisland);
+ genlayerisland = new GenLayerIsland(70L, genlayerisland);
+ GenLayerIcePlains genlayericeplains = new GenLayerIcePlains(2L, genlayerisland);
+ GenLayerTopSoil genlayertopsoil = new GenLayerTopSoil(2L, genlayericeplains);
+
+ genlayerisland = new GenLayerIsland(3L, genlayertopsoil);
+ GenLayerSpecial genlayerspecial = new GenLayerSpecial(2L, genlayerisland, EnumGenLayerSpecial.COOL_WARM);
+
+ genlayerspecial = new GenLayerSpecial(2L, genlayerspecial, EnumGenLayerSpecial.HEAT_ICE);
+ genlayerspecial = new GenLayerSpecial(3L, genlayerspecial, EnumGenLayerSpecial.PUFFERFISH);
+ genlayerzoom = new GenLayerZoom(2002L, genlayerspecial);
+ genlayerzoom = new GenLayerZoom(2003L, genlayerzoom);
+ genlayerisland = new GenLayerIsland(4L, genlayerzoom);
+ GenLayerMushroomIsland genlayermushroomisland = new GenLayerMushroomIsland(5L, genlayerisland);
+ GenLayerDeepOcean genlayerdeepocean = new GenLayerDeepOcean(4L, genlayermushroomisland);
+ GenLayer genlayer = GenLayerZoom.b(1000L, genlayerdeepocean, 0);
+ byte b0 = 4;
+
+ if (worldtype == WorldType.LARGE_BIOMES) {
+ b0 = 6;
+ }
+
+ if (flag) {
+ b0 = 4;
+ }
+
+ GenLayer genlayer1 = GenLayerZoom.b(1000L, genlayer, 0);
+ GenLayerCleaner genlayercleaner = new GenLayerCleaner(100L, genlayer1);
+ Object object = new GenLayerBiome(200L, genlayer, worldtype);
+
+ if (!flag) {
+ GenLayer genlayer2 = GenLayerZoom.b(1000L, (GenLayer) object, 2);
+
+ object = new GenLayerDesert(1000L, genlayer2);
+ }
+
+ GenLayer genlayer3 = GenLayerZoom.b(1000L, genlayercleaner, 2);
+ GenLayerRegionHills genlayerregionhills = new GenLayerRegionHills(1000L, (GenLayer) object, genlayer3);
+
+ genlayer1 = GenLayerZoom.b(1000L, genlayercleaner, 2);
+ genlayer1 = GenLayerZoom.b(1000L, genlayer1, b0);
+ GenLayerRiver genlayerriver = new GenLayerRiver(1L, genlayer1);
+ GenLayerSmooth genlayersmooth = new GenLayerSmooth(1000L, genlayerriver);
+
+ object = new GenLayerPlains(1001L, genlayerregionhills);
+
+ for (int j = 0; j < b0; ++j) {
+ object = new GenLayerZoom((long) (1000 + j), (GenLayer) object);
+ if (j == 0) {
+ object = new GenLayerIsland(3L, (GenLayer) object);
+ }
+
+ if (j == 1) {
+ object = new GenLayerMushroomShore(1000L, (GenLayer) object);
+ }
+ }
+
+ GenLayerSmooth genlayersmooth1 = new GenLayerSmooth(1000L, (GenLayer) object);
+ GenLayerRiverMix genlayerrivermix = new GenLayerRiverMix(100L, genlayersmooth1, genlayersmooth);
+ GenLayerZoomVoronoi genlayerzoomvoronoi = new GenLayerZoomVoronoi(10L, genlayerrivermix);
+
+ genlayerrivermix.a(i);
+ genlayerzoomvoronoi.a(i);
+ return new GenLayer[] { genlayerrivermix, genlayerzoomvoronoi, genlayerrivermix};
+ }
+
+ public GenLayer(long i) {
+ this.b = i;
+ this.b *= this.b * 6364136223846793005L + 1442695040888963407L;
+ this.b += i;
+ this.b *= this.b * 6364136223846793005L + 1442695040888963407L;
+ this.b += i;
+ this.b *= this.b * 6364136223846793005L + 1442695040888963407L;
+ this.b += i;
+ }
+
+ public void a(long i) {
+ this.c = i;
+ if (this.a != null) {
+ this.a.a(i);
+ }
+
+ this.c *= this.c * 6364136223846793005L + 1442695040888963407L;
+ this.c += this.b;
+ this.c *= this.c * 6364136223846793005L + 1442695040888963407L;
+ this.c += this.b;
+ this.c *= this.c * 6364136223846793005L + 1442695040888963407L;
+ this.c += this.b;
+ }
+
+ public void a(long i, long j) {
+ this.d = this.c;
+ this.d *= this.d * 6364136223846793005L + 1442695040888963407L;
+ this.d += i;
+ this.d *= this.d * 6364136223846793005L + 1442695040888963407L;
+ this.d += j;
+ this.d *= this.d * 6364136223846793005L + 1442695040888963407L;
+ this.d += i;
+ this.d *= this.d * 6364136223846793005L + 1442695040888963407L;
+ this.d += j;
+ }
+
+ protected int a(int i) {
+ int j = (int) ((this.d >> 24) % (long) i);
+
+ if (j < 0) {
+ j += i;
+ }
+
+ this.d *= this.d * 6364136223846793005L + 1442695040888963407L;
+ this.d += this.c;
+ return j;
+ }
+
+ public abstract int[] a(int i, int j, int k, int l);
+
+ protected static boolean a(int i, int j) {
+ if (i == j) {
+ return true;
+ } else if (i != BiomeBase.MESA_PLATEAU_F.id && i != BiomeBase.MESA_PLATEAU.id) {
+ try {
+ return BiomeBase.getBiome(i) != null && BiomeBase.getBiome(j) != null ? BiomeBase.getBiome(i).a(BiomeBase.getBiome(j)) : false;
+ } catch (Throwable throwable) {
+ CrashReport crashreport = CrashReport.a(throwable, "Comparing biomes");
+ CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Biomes being compared");
+
+ crashreportsystemdetails.a("Biome A ID", Integer.valueOf(i));
+ crashreportsystemdetails.a("Biome B ID", Integer.valueOf(j));
+ crashreportsystemdetails.a("Biome A", (Callable) (new CrashReportGenLayer1(i)));
+ crashreportsystemdetails.a("Biome B", (Callable) (new CrashReportGenLayer2(j)));
+ throw new ReportedException(crashreport);
+ }
+ } else {
+ return j == BiomeBase.MESA_PLATEAU_F.id || j == BiomeBase.MESA_PLATEAU.id;
+ }
+ }
+
+ protected static boolean b(int i) {
+ return i == BiomeBase.OCEAN.id || i == BiomeBase.DEEP_OCEAN.id || i == BiomeBase.FROZEN_OCEAN.id;
+ }
+
+ protected int a(int... aint) {
+ return aint[this.a(aint.length)];
+ }
+
+ protected int b(int i, int j, int k, int l) {
+ return j == k && k == l ? j : (i == j && i == k ? i : (i == j && i == l ? i : (i == k && i == l ? i : (i == j && k != l ? i : (i == k && j != l ? i : (i == l && j != k ? i : (j == k && i != l ? j : (j == l && i != k ? j : (k == l && i != j ? k : this.a(new int[] { i, j, k, l}))))))))));
+ }
+}
diff --git a/src/main/java/net/minecraft/server/GenLayerBiome.java b/src/main/java/net/minecraft/server/GenLayerBiome.java
new file mode 100644
index 000000000..42fe8f1a1
--- /dev/null
+++ b/src/main/java/net/minecraft/server/GenLayerBiome.java
@@ -0,0 +1,69 @@
+package net.minecraft.server;
+
+public class GenLayerBiome extends GenLayer {
+
+ private BiomeBase[] c;
+ private BiomeBase[] d;
+ private BiomeBase[] e;
+ private BiomeBase[] f;
+
+ public GenLayerBiome(long i, GenLayer genlayer, WorldType worldtype) {
+ super(i);
+ this.c = new BiomeBase[] { BiomeBase.DESERT, BiomeBase.DESERT, BiomeBase.DESERT, BiomeBase.SAVANNA, BiomeBase.SAVANNA, BiomeBase.PLAINS};
+ this.d = new BiomeBase[] { BiomeBase.FOREST, BiomeBase.ROOFED_FOREST, BiomeBase.EXTREME_HILLS, BiomeBase.PLAINS, BiomeBase.BIRCH_FOREST, BiomeBase.SWAMPLAND};
+ this.e = new BiomeBase[] { BiomeBase.FOREST, BiomeBase.EXTREME_HILLS, BiomeBase.TAIGA, BiomeBase.PLAINS};
+ this.f = new BiomeBase[] { BiomeBase.ICE_PLAINS, BiomeBase.ICE_PLAINS, BiomeBase.ICE_PLAINS, BiomeBase.COLD_TAIGA};
+ this.a = genlayer;
+ if (worldtype == WorldType.NORMAL_1_1) {
+ this.c = new BiomeBase[] { BiomeBase.DESERT, BiomeBase.FOREST, BiomeBase.EXTREME_HILLS, BiomeBase.SWAMPLAND, BiomeBase.PLAINS, BiomeBase.TAIGA};
+ }
+ }
+
+ public int[] a(int i, int j, int k, int l) {
+ int[] aint = this.a.a(i, j, k, l);
+ int[] aint1 = IntCache.a(k * l);
+
+ for (int i1 = 0; i1 < l; ++i1) {
+ for (int j1 = 0; j1 < k; ++j1) {
+ this.a((long) (j1 + i), (long) (i1 + j));
+ int k1 = aint[j1 + i1 * k];
+ int l1 = (k1 & 3840) >> 8;
+
+ k1 &= -3841;
+ if (b(k1)) {
+ aint1[j1 + i1 * k] = k1;
+ } else if (k1 == BiomeBase.MUSHROOM_ISLAND.id) {
+ aint1[j1 + i1 * k] = k1;
+ } else if (k1 == 1) {
+ if (l1 > 0) {
+ if (this.a(3) == 0) {
+ aint1[j1 + i1 * k] = BiomeBase.MESA_PLATEAU.id;
+ } else {
+ aint1[j1 + i1 * k] = BiomeBase.MESA_PLATEAU_F.id;
+ }
+ } else {
+ aint1[j1 + i1 * k] = this.c[this.a(this.c.length)].id;
+ }
+ } else if (k1 == 2) {
+ if (l1 > 0) {
+ aint1[j1 + i1 * k] = BiomeBase.JUNGLE.id;
+ } else {
+ aint1[j1 + i1 * k] = this.d[this.a(this.d.length)].id;
+ }
+ } else if (k1 == 3) {
+ if (l1 > 0) {
+ aint1[j1 + i1 * k] = BiomeBase.MEGA_TAIGA.id;
+ } else {
+ aint1[j1 + i1 * k] = this.e[this.a(this.e.length)].id;
+ }
+ } else if (k1 == 4) {
+ aint1[j1 + i1 * k] = this.f[this.a(this.f.length)].id;
+ } else {
+ aint1[j1 + i1 * k] = BiomeBase.MUSHROOM_ISLAND.id;
+ }
+ }
+ }
+
+ return aint1;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/GenLayerRegionHills.java b/src/main/java/net/minecraft/server/GenLayerRegionHills.java
new file mode 100644
index 000000000..7543f301b
--- /dev/null
+++ b/src/main/java/net/minecraft/server/GenLayerRegionHills.java
@@ -0,0 +1,131 @@
+package net.minecraft.server;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+public class GenLayerRegionHills extends GenLayer {
+
+ private static final Logger c = LogManager.getLogger();
+ private GenLayer d;
+
+ public GenLayerRegionHills(long i, GenLayer genlayer, GenLayer genlayer1) {
+ super(i);
+ this.a = genlayer;
+ this.d = genlayer1;
+ }
+
+ public int[] a(int i, int j, int k, int l) {
+ int[] aint = this.a.a(i - 1, j - 1, k + 2, l + 2);
+ int[] aint1 = this.d.a(i - 1, j - 1, k + 2, l + 2);
+ int[] aint2 = IntCache.a(k * l);
+
+ for (int i1 = 0; i1 < l; ++i1) {
+ for (int j1 = 0; j1 < k; ++j1) {
+ this.a((long) (j1 + i), (long) (i1 + j));
+ int k1 = aint[j1 + 1 + (i1 + 1) * (k + 2)];
+ int l1 = aint1[j1 + 1 + (i1 + 1) * (k + 2)];
+ boolean flag = (l1 - 2) % 29 == 0;
+
+ if (k1 > 255) {
+ c.debug("old! " + k1);
+ }
+
+ if (k1 != 0 && l1 >= 2 && (l1 - 2) % 29 == 1 && k1 < 128) {
+ if (BiomeBase.getBiome(k1 + 128) != null) {
+ aint2[j1 + i1 * k] = k1 + 128;
+ } else {
+ aint2[j1 + i1 * k] = k1;
+ }
+ } else if (this.a(3) != 0 && !flag) {
+ aint2[j1 + i1 * k] = k1;
+ } else {
+ int i2 = k1;
+ int j2;
+
+ if (k1 == BiomeBase.DESERT.id) {
+ i2 = BiomeBase.DESERT_HILLS.id;
+ } else if (k1 == BiomeBase.FOREST.id) {
+ i2 = BiomeBase.FOREST_HILLS.id;
+ } else if (k1 == BiomeBase.BIRCH_FOREST.id) {
+ i2 = BiomeBase.BIRCH_FOREST_HILLS.id;
+ } else if (k1 == BiomeBase.ROOFED_FOREST.id) {
+ i2 = BiomeBase.PLAINS.id;
+ } else if (k1 == BiomeBase.TAIGA.id) {
+ i2 = BiomeBase.TAIGA_HILLS.id;
+ } else if (k1 == BiomeBase.MEGA_TAIGA.id) {
+ i2 = BiomeBase.MEGA_TAIGA_HILLS.id;
+ } else if (k1 == BiomeBase.COLD_TAIGA.id) {
+ i2 = BiomeBase.COLD_TAIGA_HILLS.id;
+ } else if (k1 == BiomeBase.PLAINS.id) {
+ if (this.a(3) == 0) {
+ i2 = BiomeBase.FOREST_HILLS.id;
+ } else {
+ i2 = BiomeBase.FOREST.id;
+ }
+ } else if (k1 == BiomeBase.ICE_PLAINS.id) {
+ i2 = BiomeBase.ICE_MOUNTAINS.id;
+ } else if (k1 == BiomeBase.JUNGLE.id) {
+ i2 = BiomeBase.JUNGLE_HILLS.id;
+ } else if (k1 == BiomeBase.OCEAN.id) {
+ i2 = BiomeBase.DEEP_OCEAN.id;
+ } else if (k1 == BiomeBase.EXTREME_HILLS.id) {
+ i2 = BiomeBase.EXTREME_HILLS_PLUS.id;
+ } else if (k1 == BiomeBase.SAVANNA.id) {
+ i2 = BiomeBase.SAVANNA_PLATEAU.id;
+ } else if (a(k1, BiomeBase.MESA_PLATEAU_F.id)) {
+ i2 = BiomeBase.MESA.id;
+ } else if (k1 == BiomeBase.DEEP_OCEAN.id && this.a(3) == 0) {
+ j2 = this.a(2);
+ if (j2 == 0) {
+ i2 = BiomeBase.PLAINS.id;
+ } else {
+ i2 = BiomeBase.FOREST.id;
+ }
+ }
+
+ if (flag && i2 != k1) {
+ if (BiomeBase.getBiome(i2 + 128) != null) {
+ i2 += 128;
+ } else {
+ i2 = k1;
+ }
+ }
+
+ if (i2 == k1) {
+ aint2[j1 + i1 * k] = k1;
+ } else {
+ j2 = aint[j1 + 1 + (i1 + 1 - 1) * (k + 2)];
+ int k2 = aint[j1 + 1 + 1 + (i1 + 1) * (k + 2)];
+ int l2 = aint[j1 + 1 - 1 + (i1 + 1) * (k + 2)];
+ int i3 = aint[j1 + 1 + (i1 + 1 + 1) * (k + 2)];
+ int j3 = 0;
+
+ if (a(j2, k1)) {
+ ++j3;
+ }
+
+ if (a(k2, k1)) {
+ ++j3;
+ }
+
+ if (a(l2, k1)) {
+ ++j3;
+ }
+
+ if (a(i3, k1)) {
+ ++j3;
+ }
+
+ if (j3 >= 3) {
+ aint2[j1 + i1 * k] = i2;
+ } else {
+ aint2[j1 + i1 * k] = k1;
+ }
+ }
+ }
+ }
+ }
+
+ return aint2;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ItemEgg.java b/src/main/java/net/minecraft/server/ItemEgg.java
new file mode 100644
index 000000000..b74c8fe65
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemEgg.java
@@ -0,0 +1,22 @@
+package net.minecraft.server;
+
+public class ItemEgg extends Item {
+
+ public ItemEgg() {
+ this.maxStackSize = 16;
+ this.a(CreativeModeTab.l);
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F));
+ if (!world.isStatic) {
+ world.addEntity(new EntityEgg(world, entityhuman));
+ }
+
+ return itemstack;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/ItemEnderEye.java b/src/main/java/net/minecraft/server/ItemEnderEye.java
new file mode 100644
index 000000000..91d9770c2
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemEnderEye.java
@@ -0,0 +1,134 @@
+package net.minecraft.server;
+
+public class ItemEnderEye extends Item {
+
+ public ItemEnderEye() {
+ this.a(CreativeModeTab.f);
+ }
+
+ public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) {
+ Block block = world.getType(i, j, k);
+ int i1 = world.getData(i, j, k);
+
+ if (entityhuman.a(i, j, k, l, itemstack) && block == Blocks.ENDER_PORTAL_FRAME && !BlockEnderPortalFrame.b(i1)) {
+ if (world.isStatic) {
+ return true;
+ } else {
+ world.setData(i, j, k, i1 + 4, 2);
+ world.updateAdjacentComparators(i, j, k, Blocks.ENDER_PORTAL_FRAME);
+ --itemstack.count;
+
+ int j1;
+
+ for (j1 = 0; j1 < 16; ++j1) {
+ double d0 = (double) ((float) i + (5.0F + g.nextFloat() * 6.0F) / 16.0F);
+ double d1 = (double) ((float) j + 0.8125F);
+ double d2 = (double) ((float) k + (5.0F + g.nextFloat() * 6.0F) / 16.0F);
+ double d3 = 0.0D;
+ double d4 = 0.0D;
+ double d5 = 0.0D;
+
+ world.addParticle("smoke", d0, d1, d2, d3, d4, d5);
+ }
+
+ j1 = i1 & 3;
+ int k1 = 0;
+ int l1 = 0;
+ boolean flag = false;
+ boolean flag1 = true;
+ int i2 = Direction.g[j1];
+
+ int j2;
+ int k2;
+ int l2;
+
+ for (l2 = -2; l2 <= 2; ++l2) {
+ j2 = i + Direction.a[i2] * l2;
+ k2 = k + Direction.b[i2] * l2;
+ if (world.getType(j2, j, k2) == Blocks.ENDER_PORTAL_FRAME) {
+ if (!BlockEnderPortalFrame.b(world.getData(j2, j, k2))) {
+ flag1 = false;
+ break;
+ }
+
+ l1 = l2;
+ if (!flag) {
+ k1 = l2;
+ flag = true;
+ }
+ }
+ }
+
+ if (flag1 && l1 == k1 + 2) {
+ for (l2 = k1; l2 <= l1; ++l2) {
+ j2 = i + Direction.a[i2] * l2;
+ k2 = k + Direction.b[i2] * l2;
+ j2 += Direction.a[j1] * 4;
+ k2 += Direction.b[j1] * 4;
+ if (world.getType(j2, j, k2) != Blocks.ENDER_PORTAL_FRAME || !BlockEnderPortalFrame.b(world.getData(j2, j, k2))) {
+ flag1 = false;
+ break;
+ }
+ }
+
+ int i3;
+
+ for (l2 = k1 - 1; l2 <= l1 + 1; l2 += 4) {
+ for (j2 = 1; j2 <= 3; ++j2) {
+ k2 = i + Direction.a[i2] * l2;
+ i3 = k + Direction.b[i2] * l2;
+ k2 += Direction.a[j1] * j2;
+ i3 += Direction.b[j1] * j2;
+ if (world.getType(k2, j, i3) != Blocks.ENDER_PORTAL_FRAME || !BlockEnderPortalFrame.b(world.getData(k2, j, i3))) {
+ flag1 = false;
+ break;
+ }
+ }
+ }
+
+ if (flag1) {
+ for (l2 = k1; l2 <= l1; ++l2) {
+ for (j2 = 1; j2 <= 3; ++j2) {
+ k2 = i + Direction.a[i2] * l2;
+ i3 = k + Direction.b[i2] * l2;
+ k2 += Direction.a[j1] * j2;
+ i3 += Direction.b[j1] * j2;
+ world.setTypeAndData(k2, j, i3, Blocks.ENDER_PORTAL, 0, 2);
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ MovingObjectPosition movingobjectposition = this.a(world, entityhuman, false);
+
+ if (movingobjectposition != null && movingobjectposition.type == EnumMovingObjectType.BLOCK && world.getType(movingobjectposition.b, movingobjectposition.c, movingobjectposition.d) == Blocks.ENDER_PORTAL_FRAME) {
+ return itemstack;
+ } else {
+ if (!world.isStatic) {
+ ChunkPosition chunkposition = world.b("Stronghold", (int) entityhuman.locX, (int) entityhuman.locY, (int) entityhuman.locZ);
+
+ if (chunkposition != null) {
+ EntityEnderSignal entityendersignal = new EntityEnderSignal(world, entityhuman.locX, entityhuman.locY + 1.62D - (double) entityhuman.height, entityhuman.locZ);
+
+ entityendersignal.a((double) chunkposition.x, chunkposition.y, (double) chunkposition.z);
+ world.addEntity(entityendersignal);
+ world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F));
+ world.a((EntityHuman) null, 1002, (int) entityhuman.locX, (int) entityhuman.locY, (int) entityhuman.locZ, 0);
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+ }
+ }
+
+ return itemstack;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ItemEnderPearl.java b/src/main/java/net/minecraft/server/ItemEnderPearl.java
new file mode 100644
index 000000000..2fe9c3c6c
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemEnderPearl.java
@@ -0,0 +1,23 @@
+package net.minecraft.server;
+
+public class ItemEnderPearl extends Item {
+
+ public ItemEnderPearl() {
+ this.maxStackSize = 16;
+ this.a(CreativeModeTab.f);
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (entityhuman.abilities.canInstantlyBuild) {
+ return itemstack;
+ } else {
+ --itemstack.count;
+ world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F));
+ if (!world.isStatic) {
+ world.addEntity(new EntityEnderPearl(world, entityhuman));
+ }
+
+ return itemstack;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/ItemExpBottle.java b/src/main/java/net/minecraft/server/ItemExpBottle.java
new file mode 100644
index 000000000..a7eba06db
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemExpBottle.java
@@ -0,0 +1,21 @@
+package net.minecraft.server;
+
+public class ItemExpBottle extends Item {
+
+ public ItemExpBottle() {
+ this.a(CreativeModeTab.f);
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F));
+ if (!world.isStatic) {
+ world.addEntity(new EntityThrownExpBottle(world, entityhuman));
+ }
+
+ return itemstack;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/ItemFireworks.java b/src/main/java/net/minecraft/server/ItemFireworks.java
new file mode 100644
index 000000000..ad61d22a2
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemFireworks.java
@@ -0,0 +1,21 @@
+package net.minecraft.server;
+
+public class ItemFireworks extends Item {
+
+ public ItemFireworks() {}
+
+ public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) {
+ if (!world.isStatic) {
+ EntityFireworks entityfireworks = new EntityFireworks(world, (double) ((float) i + f), (double) ((float) j + f1), (double) ((float) k + f2), itemstack);
+
+ world.addEntity(entityfireworks);
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/ItemMilkBucket.java b/src/main/java/net/minecraft/server/ItemMilkBucket.java
new file mode 100644
index 000000000..39f1bc031
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemMilkBucket.java
@@ -0,0 +1,34 @@
+package net.minecraft.server;
+
+public class ItemMilkBucket extends Item {
+
+ public ItemMilkBucket() {
+ this.e(1);
+ this.a(CreativeModeTab.f);
+ }
+
+ public ItemStack b(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ if (!world.isStatic) {
+ entityhuman.removeAllEffects();
+ }
+
+ return itemstack.count <= 0 ? new ItemStack(Items.BUCKET) : itemstack;
+ }
+
+ public int d_(ItemStack itemstack) {
+ return 32;
+ }
+
+ public EnumAnimation d(ItemStack itemstack) {
+ return EnumAnimation.DRINK;
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ entityhuman.a(itemstack, this.d_(itemstack));
+ return itemstack;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/ItemPotion.java b/src/main/java/net/minecraft/server/ItemPotion.java
new file mode 100644
index 000000000..120bf1ce3
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemPotion.java
@@ -0,0 +1,147 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ItemPotion extends Item {
+
+ private HashMap a = new HashMap();
+ private static final Map b = new LinkedHashMap();
+
+ public ItemPotion() {
+ this.e(1);
+ this.a(true);
+ this.setMaxDurability(0);
+ this.a(CreativeModeTab.k);
+ }
+
+ public List g(ItemStack itemstack) {
+ if (itemstack.hasTag() && itemstack.getTag().hasKeyOfType("CustomPotionEffects", 9)) {
+ ArrayList arraylist = new ArrayList();
+ NBTTagList nbttaglist = itemstack.getTag().getList("CustomPotionEffects", 10);
+
+ for (int i = 0; i < nbttaglist.size(); ++i) {
+ NBTTagCompound nbttagcompound = nbttaglist.get(i);
+ MobEffect mobeffect = MobEffect.b(nbttagcompound);
+
+ if (mobeffect != null) {
+ arraylist.add(mobeffect);
+ }
+ }
+
+ return arraylist;
+ } else {
+ List list = (List) this.a.get(Integer.valueOf(itemstack.getData()));
+
+ if (list == null) {
+ list = PotionBrewer.getEffects(itemstack.getData(), false);
+ this.a.put(Integer.valueOf(itemstack.getData()), list);
+ }
+
+ return list;
+ }
+ }
+
+ public List c(int i) {
+ List list = (List) this.a.get(Integer.valueOf(i));
+
+ if (list == null) {
+ list = PotionBrewer.getEffects(i, false);
+ this.a.put(Integer.valueOf(i), list);
+ }
+
+ return list;
+ }
+
+ public ItemStack b(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ if (!world.isStatic) {
+ List list = this.g(itemstack);
+
+ if (list != null) {
+ Iterator iterator = list.iterator();
+
+ while (iterator.hasNext()) {
+ MobEffect mobeffect = (MobEffect) iterator.next();
+
+ entityhuman.addEffect(new MobEffect(mobeffect));
+ }
+ }
+ }
+
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ if (itemstack.count <= 0) {
+ return new ItemStack(Items.GLASS_BOTTLE);
+ }
+
+ entityhuman.inventory.pickup(new ItemStack(Items.GLASS_BOTTLE));
+ }
+
+ return itemstack;
+ }
+
+ public int d_(ItemStack itemstack) {
+ return 32;
+ }
+
+ public EnumAnimation d(ItemStack itemstack) {
+ return EnumAnimation.DRINK;
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (g(itemstack.getData())) {
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F));
+ if (!world.isStatic) {
+ world.addEntity(new EntityPotion(world, entityhuman, itemstack));
+ }
+
+ return itemstack;
+ } else {
+ entityhuman.a(itemstack, this.d_(itemstack));
+ return itemstack;
+ }
+ }
+
+ public boolean interactWith(ItemStack itemstack, EntityHuman entityhuman, World world, int i, int j, int k, int l, float f, float f1, float f2) {
+ return false;
+ }
+
+ public static boolean g(int i) {
+ return (i & 16384) != 0;
+ }
+
+ public String n(ItemStack itemstack) {
+ if (itemstack.getData() == 0) {
+ return LocaleI18n.get("item.emptyPotion.name").trim();
+ } else {
+ String s = "";
+
+ if (g(itemstack.getData())) {
+ s = LocaleI18n.get("potion.prefix.grenade").trim() + " ";
+ }
+
+ List list = Items.POTION.g(itemstack);
+ String s1;
+
+ if (list != null && !list.isEmpty()) {
+ s1 = ((MobEffect) list.get(0)).f();
+ s1 = s1 + ".postfix";
+ return s + LocaleI18n.get(s1).trim();
+ } else {
+ s1 = PotionBrewer.c(itemstack.getData());
+ return LocaleI18n.get(s1).trim() + " " + super.n(itemstack);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/ItemSnowball.java b/src/main/java/net/minecraft/server/ItemSnowball.java
new file mode 100644
index 000000000..fb5e8536d
--- /dev/null
+++ b/src/main/java/net/minecraft/server/ItemSnowball.java
@@ -0,0 +1,22 @@
+package net.minecraft.server;
+
+public class ItemSnowball extends Item {
+
+ public ItemSnowball() {
+ this.maxStackSize = 16;
+ this.a(CreativeModeTab.f);
+ }
+
+ public ItemStack a(ItemStack itemstack, World world, EntityHuman entityhuman) {
+ if (!entityhuman.abilities.canInstantlyBuild) {
+ --itemstack.count;
+ }
+
+ world.makeSound(entityhuman, "random.bow", 0.5F, 0.4F / (g.nextFloat() * 0.4F + 0.8F));
+ if (!world.isStatic) {
+ world.addEntity(new EntitySnowball(world, entityhuman));
+ }
+
+ return itemstack;
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/net/minecraft/server/LayerIsland.java b/src/main/java/net/minecraft/server/LayerIsland.java
new file mode 100644
index 000000000..8a21033cc
--- /dev/null
+++ b/src/main/java/net/minecraft/server/LayerIsland.java
@@ -0,0 +1,25 @@
+package net.minecraft.server;
+
+public class LayerIsland extends GenLayer {
+
+ public LayerIsland(long i) {
+ super(i);
+ }
+
+ public int[] a(int i, int j, int k, int l) {
+ int[] aint = IntCache.a(k * l);
+
+ for (int i1 = 0; i1 < l; ++i1) {
+ for (int j1 = 0; j1 < k; ++j1) {
+ this.a((long) (i + j1), (long) (j + i1));
+ aint[j1 + i1 * k] = this.a(10) == 0 ? 1 : 0;
+ }
+ }
+
+ if (i > -k && i <= 0 && j > -l && j <= 0) {
+ aint[-i + -j * k] = 1;
+ }
+
+ return aint;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/MobEffectAttackDamage.java b/src/main/java/net/minecraft/server/MobEffectAttackDamage.java
new file mode 100644
index 000000000..3eb029d46
--- /dev/null
+++ b/src/main/java/net/minecraft/server/MobEffectAttackDamage.java
@@ -0,0 +1,12 @@
+package net.minecraft.server;
+
+public class MobEffectAttackDamage extends MobEffectList {
+
+ protected MobEffectAttackDamage(int i, boolean flag, int j) {
+ super(i, flag, j);
+ }
+
+ public double a(int i, AttributeModifier attributemodifier) {
+ return this.id == MobEffectList.WEAKNESS.id ? (double) (-0.5F * (float) (i + 1)) : 1.3D * (double) (i + 1);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/NBTTagList.java b/src/main/java/net/minecraft/server/NBTTagList.java
new file mode 100644
index 000000000..bdde30a29
--- /dev/null
+++ b/src/main/java/net/minecraft/server/NBTTagList.java
@@ -0,0 +1,168 @@
+package net.minecraft.server;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class NBTTagList extends NBTBase {
+
+ private List list = new ArrayList();
+ private byte type = 0;
+
+ public NBTTagList() {}
+
+ void write(DataOutput dataoutput) throws IOException {
+ if (!this.list.isEmpty()) {
+ this.type = ((NBTBase) this.list.get(0)).getTypeId();
+ } else {
+ this.type = 0;
+ }
+
+ dataoutput.writeByte(this.type);
+ dataoutput.writeInt(this.list.size());
+
+ for (int i = 0; i < this.list.size(); ++i) {
+ ((NBTBase) this.list.get(i)).write(dataoutput);
+ }
+ }
+
+ void load(DataInput datainput, int i, NBTReadLimiter nbtreadlimiter) throws IOException {
+ if (i > 512) {
+ throw new RuntimeException("Tried to read NBT tag with too high complexity, depth > 512");
+ } else {
+ nbtreadlimiter.a(8L);
+ this.type = datainput.readByte();
+ int j = datainput.readInt();
+
+ this.list = new ArrayList();
+
+ for (int k = 0; k < j; ++k) {
+ NBTBase nbtbase = NBTBase.createTag(this.type);
+
+ nbtbase.load(datainput, i + 1, nbtreadlimiter);
+ this.list.add(nbtbase);
+ }
+ }
+ }
+
+ public byte getTypeId() {
+ return (byte) 9;
+ }
+
+ public String toString() {
+ String s = "[";
+ int i = 0;
+
+ for (Iterator iterator = this.list.iterator(); iterator.hasNext(); ++i) {
+ NBTBase nbtbase = (NBTBase) iterator.next();
+
+ s = s + "" + i + ':' + nbtbase + ',';
+ }
+
+ return s + "]";
+ }
+
+ public void add(NBTBase nbtbase) {
+ if (this.type == 0) {
+ this.type = nbtbase.getTypeId();
+ } else if (this.type != nbtbase.getTypeId()) {
+ System.err.println("WARNING: Adding mismatching tag types to tag list");
+ return;
+ }
+
+ this.list.add(nbtbase);
+ }
+
+ public NBTTagCompound get(int i) {
+ if (i >= 0 && i < this.list.size()) {
+ NBTBase nbtbase = (NBTBase) this.list.get(i);
+
+ return nbtbase.getTypeId() == 10 ? (NBTTagCompound) nbtbase : new NBTTagCompound();
+ } else {
+ return new NBTTagCompound();
+ }
+ }
+
+ public int[] c(int i) {
+ if (i >= 0 && i < this.list.size()) {
+ NBTBase nbtbase = (NBTBase) this.list.get(i);
+
+ return nbtbase.getTypeId() == 11 ? ((NBTTagIntArray) nbtbase).c() : new int[0];
+ } else {
+ return new int[0];
+ }
+ }
+
+ public double d(int i) {
+ if (i >= 0 && i < this.list.size()) {
+ NBTBase nbtbase = (NBTBase) this.list.get(i);
+
+ return nbtbase.getTypeId() == 6 ? ((NBTTagDouble) nbtbase).g() : 0.0D;
+ } else {
+ return 0.0D;
+ }
+ }
+
+ public float e(int i) {
+ if (i >= 0 && i < this.list.size()) {
+ NBTBase nbtbase = (NBTBase) this.list.get(i);
+
+ return nbtbase.getTypeId() == 5 ? ((NBTTagFloat) nbtbase).h() : 0.0F;
+ } else {
+ return 0.0F;
+ }
+ }
+
+ public String getString(int i) {
+ if (i >= 0 && i < this.list.size()) {
+ NBTBase nbtbase = (NBTBase) this.list.get(i);
+
+ return nbtbase.getTypeId() == 8 ? nbtbase.a_() : nbtbase.toString();
+ } else {
+ return "";
+ }
+ }
+
+ public int size() {
+ return this.list.size();
+ }
+
+ public NBTBase clone() {
+ NBTTagList nbttaglist = new NBTTagList();
+
+ nbttaglist.type = this.type;
+ Iterator iterator = this.list.iterator();
+
+ while (iterator.hasNext()) {
+ NBTBase nbtbase = (NBTBase) iterator.next();
+ NBTBase nbtbase1 = nbtbase.clone();
+
+ nbttaglist.list.add(nbtbase1);
+ }
+
+ return nbttaglist;
+ }
+
+ public boolean equals(Object object) {
+ if (super.equals(object)) {
+ NBTTagList nbttaglist = (NBTTagList) object;
+
+ if (this.type == nbttaglist.type) {
+ return this.list.equals(nbttaglist.list);
+ }
+ }
+
+ return false;
+ }
+
+ public int hashCode() {
+ return super.hashCode() ^ this.list.hashCode();
+ }
+
+ public int d() {
+ return this.type;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/NBTTagString.java b/src/main/java/net/minecraft/server/NBTTagString.java
new file mode 100644
index 000000000..9b0697965
--- /dev/null
+++ b/src/main/java/net/minecraft/server/NBTTagString.java
@@ -0,0 +1,60 @@
+package net.minecraft.server;
+
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+
+public class NBTTagString extends NBTBase {
+
+ private String data;
+
+ public NBTTagString() {
+ this.data = "";
+ }
+
+ public NBTTagString(String s) {
+ this.data = s;
+ if (s == null) {
+ throw new IllegalArgumentException("Empty string not allowed");
+ }
+ }
+
+ void write(DataOutput dataoutput) throws IOException {
+ dataoutput.writeUTF(this.data);
+ }
+
+ void load(DataInput datainput, int i, NBTReadLimiter nbtreadlimiter) throws IOException {
+ this.data = datainput.readUTF();
+ nbtreadlimiter.a((long) (16 * this.data.length()));
+ }
+
+ public byte getTypeId() {
+ return (byte) 8;
+ }
+
+ public String toString() {
+ return "\"" + this.data + "\"";
+ }
+
+ public NBTBase clone() {
+ return new NBTTagString(this.data);
+ }
+
+ public boolean equals(Object object) {
+ if (!super.equals(object)) {
+ return false;
+ } else {
+ NBTTagString nbttagstring = (NBTTagString) object;
+
+ return this.data == null && nbttagstring.data == null || this.data != null && this.data.equals(nbttagstring.data);
+ }
+ }
+
+ public int hashCode() {
+ return super.hashCode() ^ this.data.hashCode();
+ }
+
+ public String a_() {
+ return this.data;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/Navigation.java b/src/main/java/net/minecraft/server/Navigation.java
new file mode 100644
index 000000000..7002621b1
--- /dev/null
+++ b/src/main/java/net/minecraft/server/Navigation.java
@@ -0,0 +1,348 @@
+package net.minecraft.server;
+
+public class Navigation {
+
+ private EntityInsentient a;
+ private World b;
+ private PathEntity c;
+ private double d;
+ private AttributeInstance e;
+ private boolean f;
+ private int g;
+ private int h;
+ private Vec3D i = Vec3D.a(0.0D, 0.0D, 0.0D);
+ private boolean j = true;
+ private boolean k;
+ private boolean l;
+ private boolean m;
+
+ public Navigation(EntityInsentient entityinsentient, World world) {
+ this.a = entityinsentient;
+ this.b = world;
+ this.e = entityinsentient.getAttributeInstance(GenericAttributes.b);
+ }
+
+ public void a(boolean flag) {
+ this.l = flag;
+ }
+
+ public boolean a() {
+ return this.l;
+ }
+
+ public void b(boolean flag) {
+ this.k = flag;
+ }
+
+ public void c(boolean flag) {
+ this.j = flag;
+ }
+
+ public boolean c() {
+ return this.k;
+ }
+
+ public void d(boolean flag) {
+ this.f = flag;
+ }
+
+ public void a(double d0) {
+ this.d = d0;
+ }
+
+ public void e(boolean flag) {
+ this.m = flag;
+ }
+
+ public float d() {
+ return (float) this.e.getValue();
+ }
+
+ public PathEntity a(double d0, double d1, double d2) {
+ return !this.l() ? null : this.b.a(this.a, MathHelper.floor(d0), (int) d1, MathHelper.floor(d2), this.d(), this.j, this.k, this.l, this.m);
+ }
+
+ public boolean a(double d0, double d1, double d2, double d3) {
+ PathEntity pathentity = this.a((double) MathHelper.floor(d0), (double) ((int) d1), (double) MathHelper.floor(d2));
+
+ return this.a(pathentity, d3);
+ }
+
+ public PathEntity a(Entity entity) {
+ return !this.l() ? null : this.b.findPath(this.a, entity, this.d(), this.j, this.k, this.l, this.m);
+ }
+
+ public boolean a(Entity entity, double d0) {
+ PathEntity pathentity = this.a(entity);
+
+ return pathentity != null ? this.a(pathentity, d0) : false;
+ }
+
+ public boolean a(PathEntity pathentity, double d0) {
+ if (pathentity == null) {
+ this.c = null;
+ return false;
+ } else {
+ if (!pathentity.a(this.c)) {
+ this.c = pathentity;
+ }
+
+ if (this.f) {
+ this.n();
+ }
+
+ if (this.c.d() == 0) {
+ return false;
+ } else {
+ this.d = d0;
+ Vec3D vec3d = this.j();
+
+ this.h = this.g;
+ this.i.a = vec3d.a;
+ this.i.b = vec3d.b;
+ this.i.c = vec3d.c;
+ return true;
+ }
+ }
+ }
+
+ public PathEntity e() {
+ return this.c;
+ }
+
+ public void f() {
+ ++this.g;
+ if (!this.g()) {
+ if (this.l()) {
+ this.i();
+ }
+
+ if (!this.g()) {
+ Vec3D vec3d = this.c.a((Entity) this.a);
+
+ if (vec3d != null) {
+ this.a.getControllerMove().a(vec3d.a, vec3d.b, vec3d.c, this.d);
+ }
+ }
+ }
+ }
+
+ private void i() {
+ Vec3D vec3d = this.j();
+ int i = this.c.d();
+
+ for (int j = this.c.e(); j < this.c.d(); ++j) {
+ if (this.c.a(j).b != (int) vec3d.b) {
+ i = j;
+ break;
+ }
+ }
+
+ float f = this.a.width * this.a.width;
+
+ int k;
+
+ for (k = this.c.e(); k < i; ++k) {
+ if (vec3d.distanceSquared(this.c.a(this.a, k)) < (double) f) {
+ this.c.c(k + 1);
+ }
+ }
+
+ k = MathHelper.f(this.a.width);
+ int l = (int) this.a.length + 1;
+ int i1 = k;
+
+ for (int j1 = i - 1; j1 >= this.c.e(); --j1) {
+ if (this.a(vec3d, this.c.a(this.a, j1), k, l, i1)) {
+ this.c.c(j1);
+ break;
+ }
+ }
+
+ if (this.g - this.h > 100) {
+ if (vec3d.distanceSquared(this.i) < 2.25D) {
+ this.h();
+ }
+
+ this.h = this.g;
+ this.i.a = vec3d.a;
+ this.i.b = vec3d.b;
+ this.i.c = vec3d.c;
+ }
+ }
+
+ public boolean g() {
+ return this.c == null || this.c.b();
+ }
+
+ public void h() {
+ this.c = null;
+ }
+
+ private Vec3D j() {
+ return Vec3D.a(this.a.locX, (double) this.k(), this.a.locZ);
+ }
+
+ private int k() {
+ if (this.a.M() && this.m) {
+ int i = (int) this.a.boundingBox.b;
+ Block block = this.b.getType(MathHelper.floor(this.a.locX), i, MathHelper.floor(this.a.locZ));
+ int j = 0;
+
+ do {
+ if (block != Blocks.WATER && block != Blocks.STATIONARY_WATER) {
+ return i;
+ }
+
+ ++i;
+ block = this.b.getType(MathHelper.floor(this.a.locX), i, MathHelper.floor(this.a.locZ));
+ ++j;
+ } while (j <= 16);
+
+ return (int) this.a.boundingBox.b;
+ } else {
+ return (int) (this.a.boundingBox.b + 0.5D);
+ }
+ }
+
+ private boolean l() {
+ return this.a.onGround || this.m && this.m() || this.a.am() && this.a instanceof EntityZombie && this.a.vehicle instanceof EntityChicken;
+ }
+
+ private boolean m() {
+ return this.a.M() || this.a.P();
+ }
+
+ private void n() {
+ if (!this.b.i(MathHelper.floor(this.a.locX), (int) (this.a.boundingBox.b + 0.5D), MathHelper.floor(this.a.locZ))) {
+ for (int i = 0; i < this.c.d(); ++i) {
+ PathPoint pathpoint = this.c.a(i);
+
+ if (this.b.i(pathpoint.a, pathpoint.b, pathpoint.c)) {
+ this.c.b(i - 1);
+ return;
+ }
+ }
+ }
+ }
+
+ private boolean a(Vec3D vec3d, Vec3D vec3d1, int i, int j, int k) {
+ int l = MathHelper.floor(vec3d.a);
+ int i1 = MathHelper.floor(vec3d.c);
+ double d0 = vec3d1.a - vec3d.a;
+ double d1 = vec3d1.c - vec3d.c;
+ double d2 = d0 * d0 + d1 * d1;
+
+ if (d2 < 1.0E-8D) {
+ return false;
+ } else {
+ double d3 = 1.0D / Math.sqrt(d2);
+
+ d0 *= d3;
+ d1 *= d3;
+ i += 2;
+ k += 2;
+ if (!this.a(l, (int) vec3d.b, i1, i, j, k, vec3d, d0, d1)) {
+ return false;
+ } else {
+ i -= 2;
+ k -= 2;
+ double d4 = 1.0D / Math.abs(d0);
+ double d5 = 1.0D / Math.abs(d1);
+ double d6 = (double) (l * 1) - vec3d.a;
+ double d7 = (double) (i1 * 1) - vec3d.c;
+
+ if (d0 >= 0.0D) {
+ ++d6;
+ }
+
+ if (d1 >= 0.0D) {
+ ++d7;
+ }
+
+ d6 /= d0;
+ d7 /= d1;
+ int j1 = d0 < 0.0D ? -1 : 1;
+ int k1 = d1 < 0.0D ? -1 : 1;
+ int l1 = MathHelper.floor(vec3d1.a);
+ int i2 = MathHelper.floor(vec3d1.c);
+ int j2 = l1 - l;
+ int k2 = i2 - i1;
+
+ do {
+ if (j2 * j1 <= 0 && k2 * k1 <= 0) {
+ return true;
+ }
+
+ if (d6 < d7) {
+ d6 += d4;
+ l += j1;
+ j2 = l1 - l;
+ } else {
+ d7 += d5;
+ i1 += k1;
+ k2 = i2 - i1;
+ }
+ } while (this.a(l, (int) vec3d.b, i1, i, j, k, vec3d, d0, d1));
+
+ return false;
+ }
+ }
+ }
+
+ private boolean a(int i, int j, int k, int l, int i1, int j1, Vec3D vec3d, double d0, double d1) {
+ int k1 = i - l / 2;
+ int l1 = k - j1 / 2;
+
+ if (!this.b(k1, j, l1, l, i1, j1, vec3d, d0, d1)) {
+ return false;
+ } else {
+ for (int i2 = k1; i2 < k1 + l; ++i2) {
+ for (int j2 = l1; j2 < l1 + j1; ++j2) {
+ double d2 = (double) i2 + 0.5D - vec3d.a;
+ double d3 = (double) j2 + 0.5D - vec3d.c;
+
+ if (d2 * d0 + d3 * d1 >= 0.0D) {
+ Block block = this.b.getType(i2, j - 1, j2);
+ Material material = block.getMaterial();
+
+ if (material == Material.AIR) {
+ return false;
+ }
+
+ if (material == Material.WATER && !this.a.M()) {
+ return false;
+ }
+
+ if (material == Material.LAVA) {
+ return false;
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+ }
+
+ private boolean b(int i, int j, int k, int l, int i1, int j1, Vec3D vec3d, double d0, double d1) {
+ for (int k1 = i; k1 < i + l; ++k1) {
+ for (int l1 = j; l1 < j + i1; ++l1) {
+ for (int i2 = k; i2 < k + j1; ++i2) {
+ double d2 = (double) k1 + 0.5D - vec3d.a;
+ double d3 = (double) i2 + 0.5D - vec3d.c;
+
+ if (d2 * d0 + d3 * d1 >= 0.0D) {
+ Block block = this.b.getType(k1, l1, i2);
+
+ if (!block.b(this.b, k1, l1, i2)) {
+ return false;
+ }
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/Pathfinder.java b/src/main/java/net/minecraft/server/Pathfinder.java
new file mode 100644
index 000000000..de9593976
--- /dev/null
+++ b/src/main/java/net/minecraft/server/Pathfinder.java
@@ -0,0 +1,283 @@
+package net.minecraft.server;
+
+public class Pathfinder {
+
+ private IBlockAccess a;
+ private Path b = new Path();
+ private IntHashMap c = new IntHashMap();
+ private PathPoint[] d = new PathPoint[32];
+ private boolean e;
+ private boolean f;
+ private boolean g;
+ private boolean h;
+
+ public Pathfinder(IBlockAccess iblockaccess, boolean flag, boolean flag1, boolean flag2, boolean flag3) {
+ this.a = iblockaccess;
+ this.e = flag;
+ this.f = flag1;
+ this.g = flag2;
+ this.h = flag3;
+ }
+
+ public PathEntity a(Entity entity, Entity entity1, float f) {
+ return this.a(entity, entity1.locX, entity1.boundingBox.b, entity1.locZ, f);
+ }
+
+ public PathEntity a(Entity entity, int i, int j, int k, float f) {
+ return this.a(entity, (double) ((float) i + 0.5F), (double) ((float) j + 0.5F), (double) ((float) k + 0.5F), f);
+ }
+
+ private PathEntity a(Entity entity, double d0, double d1, double d2, float f) {
+ this.b.a();
+ this.c.c();
+ boolean flag = this.g;
+ int i = MathHelper.floor(entity.boundingBox.b + 0.5D);
+
+ if (this.h && entity.M()) {
+ i = (int) entity.boundingBox.b;
+
+ for (Block block = this.a.getType(MathHelper.floor(entity.locX), i, MathHelper.floor(entity.locZ)); block == Blocks.WATER || block == Blocks.STATIONARY_WATER; block = this.a.getType(MathHelper.floor(entity.locX), i, MathHelper.floor(entity.locZ))) {
+ ++i;
+ }
+
+ flag = this.g;
+ this.g = false;
+ } else {
+ i = MathHelper.floor(entity.boundingBox.b + 0.5D);
+ }
+
+ PathPoint pathpoint = this.a(MathHelper.floor(entity.boundingBox.a), i, MathHelper.floor(entity.boundingBox.c));
+ PathPoint pathpoint1 = this.a(MathHelper.floor(d0 - (double) (entity.width / 2.0F)), MathHelper.floor(d1), MathHelper.floor(d2 - (double) (entity.width / 2.0F)));
+ PathPoint pathpoint2 = new PathPoint(MathHelper.d(entity.width + 1.0F), MathHelper.d(entity.length + 1.0F), MathHelper.d(entity.width + 1.0F));
+ PathEntity pathentity = this.a(entity, pathpoint, pathpoint1, pathpoint2, f);
+
+ this.g = flag;
+ return pathentity;
+ }
+
+ private PathEntity a(Entity entity, PathPoint pathpoint, PathPoint pathpoint1, PathPoint pathpoint2, float f) {
+ pathpoint.e = 0.0F;
+ pathpoint.f = pathpoint.b(pathpoint1);
+ pathpoint.g = pathpoint.f;
+ this.b.a();
+ this.b.a(pathpoint);
+ PathPoint pathpoint3 = pathpoint;
+
+ while (!this.b.e()) {
+ PathPoint pathpoint4 = this.b.c();
+
+ if (pathpoint4.equals(pathpoint1)) {
+ return this.a(pathpoint, pathpoint1);
+ }
+
+ if (pathpoint4.b(pathpoint1) < pathpoint3.b(pathpoint1)) {
+ pathpoint3 = pathpoint4;
+ }
+
+ pathpoint4.i = true;
+ int i = this.b(entity, pathpoint4, pathpoint2, pathpoint1, f);
+
+ for (int j = 0; j < i; ++j) {
+ PathPoint pathpoint5 = this.d[j];
+ float f1 = pathpoint4.e + pathpoint4.b(pathpoint5);
+
+ if (!pathpoint5.a() || f1 < pathpoint5.e) {
+ pathpoint5.h = pathpoint4;
+ pathpoint5.e = f1;
+ pathpoint5.f = pathpoint5.b(pathpoint1);
+ if (pathpoint5.a()) {
+ this.b.a(pathpoint5, pathpoint5.e + pathpoint5.f);
+ } else {
+ pathpoint5.g = pathpoint5.e + pathpoint5.f;
+ this.b.a(pathpoint5);
+ }
+ }
+ }
+ }
+
+ if (pathpoint3 == pathpoint) {
+ return null;
+ } else {
+ return this.a(pathpoint, pathpoint3);
+ }
+ }
+
+ private int b(Entity entity, PathPoint pathpoint, PathPoint pathpoint1, PathPoint pathpoint2, float f) {
+ int i = 0;
+ byte b0 = 0;
+
+ if (this.a(entity, pathpoint.a, pathpoint.b + 1, pathpoint.c, pathpoint1) == 1) {
+ b0 = 1;
+ }
+
+ PathPoint pathpoint3 = this.a(entity, pathpoint.a, pathpoint.b, pathpoint.c + 1, pathpoint1, b0);
+ PathPoint pathpoint4 = this.a(entity, pathpoint.a - 1, pathpoint.b, pathpoint.c, pathpoint1, b0);
+ PathPoint pathpoint5 = this.a(entity, pathpoint.a + 1, pathpoint.b, pathpoint.c, pathpoint1, b0);
+ PathPoint pathpoint6 = this.a(entity, pathpoint.a, pathpoint.b, pathpoint.c - 1, pathpoint1, b0);
+
+ if (pathpoint3 != null && !pathpoint3.i && pathpoint3.a(pathpoint2) < f) {
+ this.d[i++] = pathpoint3;
+ }
+
+ if (pathpoint4 != null && !pathpoint4.i && pathpoint4.a(pathpoint2) < f) {
+ this.d[i++] = pathpoint4;
+ }
+
+ if (pathpoint5 != null && !pathpoint5.i && pathpoint5.a(pathpoint2) < f) {
+ this.d[i++] = pathpoint5;
+ }
+
+ if (pathpoint6 != null && !pathpoint6.i && pathpoint6.a(pathpoint2) < f) {
+ this.d[i++] = pathpoint6;
+ }
+
+ return i;
+ }
+
+ private PathPoint a(Entity entity, int i, int j, int k, PathPoint pathpoint, int l) {
+ PathPoint pathpoint1 = null;
+ int i1 = this.a(entity, i, j, k, pathpoint);
+
+ if (i1 == 2) {
+ return this.a(i, j, k);
+ } else {
+ if (i1 == 1) {
+ pathpoint1 = this.a(i, j, k);
+ }
+
+ if (pathpoint1 == null && l > 0 && i1 != -3 && i1 != -4 && this.a(entity, i, j + l, k, pathpoint) == 1) {
+ pathpoint1 = this.a(i, j + l, k);
+ j += l;
+ }
+
+ if (pathpoint1 != null) {
+ int j1 = 0;
+ int k1 = 0;
+
+ while (j > 0) {
+ k1 = this.a(entity, i, j - 1, k, pathpoint);
+ if (this.g && k1 == -1) {
+ return null;
+ }
+
+ if (k1 != 1) {
+ break;
+ }
+
+ if (j1++ >= entity.ax()) {
+ return null;
+ }
+
+ --j;
+ if (j > 0) {
+ pathpoint1 = this.a(i, j, k);
+ }
+ }
+
+ if (k1 == -2) {
+ return null;
+ }
+ }
+
+ return pathpoint1;
+ }
+ }
+
+ private final PathPoint a(int i, int j, int k) {
+ int l = PathPoint.a(i, j, k);
+ PathPoint pathpoint = (PathPoint) this.c.get(l);
+
+ if (pathpoint == null) {
+ pathpoint = new PathPoint(i, j, k);
+ this.c.a(l, pathpoint);
+ }
+
+ return pathpoint;
+ }
+
+ public int a(Entity entity, int i, int j, int k, PathPoint pathpoint) {
+ return a(entity, i, j, k, pathpoint, this.g, this.f, this.e);
+ }
+
+ public static int a(Entity entity, int i, int j, int k, PathPoint pathpoint, boolean flag, boolean flag1, boolean flag2) {
+ boolean flag3 = false;
+
+ for (int l = i; l < i + pathpoint.a; ++l) {
+ for (int i1 = j; i1 < j + pathpoint.b; ++i1) {
+ for (int j1 = k; j1 < k + pathpoint.c; ++j1) {
+ Block block = entity.world.getType(l, i1, j1);
+
+ if (block.getMaterial() != Material.AIR) {
+ if (block == Blocks.TRAP_DOOR) {
+ flag3 = true;
+ } else if (block != Blocks.WATER && block != Blocks.STATIONARY_WATER) {
+ if (!flag2 && block == Blocks.WOODEN_DOOR) {
+ return 0;
+ }
+ } else {
+ if (flag) {
+ return -1;
+ }
+
+ flag3 = true;
+ }
+
+ int k1 = block.b();
+
+ if (entity.world.getType(l, i1, j1).b() == 9) {
+ int l1 = MathHelper.floor(entity.locX);
+ int i2 = MathHelper.floor(entity.locY);
+ int j2 = MathHelper.floor(entity.locZ);
+
+ if (entity.world.getType(l1, i2, j2).b() != 9 && entity.world.getType(l1, i2 - 1, j2).b() != 9) {
+ return -3;
+ }
+ } else if (!block.b(entity.world, l, i1, j1) && (!flag1 || block != Blocks.WOODEN_DOOR)) {
+ if (k1 == 11 || block == Blocks.FENCE_GATE || k1 == 32) {
+ return -3;
+ }
+
+ if (block == Blocks.TRAP_DOOR) {
+ return -4;
+ }
+
+ Material material = block.getMaterial();
+
+ if (material != Material.LAVA) {
+ return 0;
+ }
+
+ if (!entity.P()) {
+ return -2;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return flag3 ? 2 : 1;
+ }
+
+ private PathEntity a(PathPoint pathpoint, PathPoint pathpoint1) {
+ int i = 1;
+
+ PathPoint pathpoint2;
+
+ for (pathpoint2 = pathpoint1; pathpoint2.h != null; pathpoint2 = pathpoint2.h) {
+ ++i;
+ }
+
+ PathPoint[] apathpoint = new PathPoint[i];
+
+ pathpoint2 = pathpoint1;
+ --i;
+
+ for (apathpoint[i] = pathpoint1; pathpoint2.h != null; apathpoint[i] = pathpoint2) {
+ pathpoint2 = pathpoint2.h;
+ --i;
+ }
+
+ return new PathEntity(apathpoint);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalAvoidPlayer.java b/src/main/java/net/minecraft/server/PathfinderGoalAvoidPlayer.java
new file mode 100644
index 000000000..e964925af
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalAvoidPlayer.java
@@ -0,0 +1,82 @@
+package net.minecraft.server;
+
+import java.util.List;
+
+public class PathfinderGoalAvoidPlayer extends PathfinderGoal {
+
+ public final IEntitySelector a = new EntitySelectorViewable(this);
+ private EntityCreature b;
+ private double c;
+ private double d;
+ private Entity e;
+ private float f;
+ private PathEntity g;
+ private Navigation h;
+ private Class i;
+
+ public PathfinderGoalAvoidPlayer(EntityCreature entitycreature, Class oclass, float f, double d0, double d1) {
+ this.b = entitycreature;
+ this.i = oclass;
+ this.f = f;
+ this.c = d0;
+ this.d = d1;
+ this.h = entitycreature.getNavigation();
+ this.a(1);
+ }
+
+ public boolean a() {
+ if (this.i == EntityHuman.class) {
+ if (this.b instanceof EntityTameableAnimal && ((EntityTameableAnimal) this.b).isTamed()) {
+ return false;
+ }
+
+ this.e = this.b.world.findNearbyPlayer(this.b, (double) this.f);
+ if (this.e == null) {
+ return false;
+ }
+ } else {
+ List list = this.b.world.a(this.i, this.b.boundingBox.grow((double) this.f, 3.0D, (double) this.f), this.a);
+
+ if (list.isEmpty()) {
+ return false;
+ }
+
+ this.e = (Entity) list.get(0);
+ }
+
+ Vec3D vec3d = RandomPositionGenerator.b(this.b, 16, 7, Vec3D.a(this.e.locX, this.e.locY, this.e.locZ));
+
+ if (vec3d == null) {
+ return false;
+ } else if (this.e.e(vec3d.a, vec3d.b, vec3d.c) < this.e.f((Entity) this.b)) {
+ return false;
+ } else {
+ this.g = this.h.a(vec3d.a, vec3d.b, vec3d.c);
+ return this.g == null ? false : this.g.b(vec3d);
+ }
+ }
+
+ public boolean b() {
+ return !this.h.g();
+ }
+
+ public void c() {
+ this.h.a(this.g, this.c);
+ }
+
+ public void d() {
+ this.e = null;
+ }
+
+ public void e() {
+ if (this.b.f(this.e) < 49.0D) {
+ this.b.getNavigation().a(this.d);
+ } else {
+ this.b.getNavigation().a(this.c);
+ }
+ }
+
+ static EntityCreature a(PathfinderGoalAvoidPlayer pathfindergoalavoidplayer) {
+ return pathfindergoalavoidplayer.b;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalFleeSun.java b/src/main/java/net/minecraft/server/PathfinderGoalFleeSun.java
new file mode 100644
index 000000000..846214a4d
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalFleeSun.java
@@ -0,0 +1,65 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class PathfinderGoalFleeSun extends PathfinderGoal {
+
+ private EntityCreature a;
+ private double b;
+ private double c;
+ private double d;
+ private double e;
+ private World f;
+
+ public PathfinderGoalFleeSun(EntityCreature entitycreature, double d0) {
+ this.a = entitycreature;
+ this.e = d0;
+ this.f = entitycreature.world;
+ this.a(1);
+ }
+
+ public boolean a() {
+ if (!this.f.w()) {
+ return false;
+ } else if (!this.a.isBurning()) {
+ return false;
+ } else if (!this.f.i(MathHelper.floor(this.a.locX), (int) this.a.boundingBox.b, MathHelper.floor(this.a.locZ))) {
+ return false;
+ } else {
+ Vec3D vec3d = this.f();
+
+ if (vec3d == null) {
+ return false;
+ } else {
+ this.b = vec3d.a;
+ this.c = vec3d.b;
+ this.d = vec3d.c;
+ return true;
+ }
+ }
+ }
+
+ public boolean b() {
+ return !this.a.getNavigation().g();
+ }
+
+ public void c() {
+ this.a.getNavigation().a(this.b, this.c, this.d, this.e);
+ }
+
+ private Vec3D f() {
+ Random random = this.a.aI();
+
+ for (int i = 0; i < 10; ++i) {
+ int j = MathHelper.floor(this.a.locX + (double) random.nextInt(20) - 10.0D);
+ int k = MathHelper.floor(this.a.boundingBox.b + (double) random.nextInt(6) - 3.0D);
+ int l = MathHelper.floor(this.a.locZ + (double) random.nextInt(20) - 10.0D);
+
+ if (!this.f.i(j, k, l) && this.a.a(j, k, l) < 0.0F) {
+ return Vec3D.a((double) j, (double) k, (double) l);
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalJumpOnBlock.java b/src/main/java/net/minecraft/server/PathfinderGoalJumpOnBlock.java
new file mode 100644
index 000000000..e28f3f20e
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalJumpOnBlock.java
@@ -0,0 +1,98 @@
+package net.minecraft.server;
+
+public class PathfinderGoalJumpOnBlock extends PathfinderGoal {
+
+ private final EntityOcelot a;
+ private final double b;
+ private int c;
+ private int d;
+ private int e;
+ private int f;
+ private int g;
+ private int h;
+
+ public PathfinderGoalJumpOnBlock(EntityOcelot entityocelot, double d0) {
+ this.a = entityocelot;
+ this.b = d0;
+ this.a(5);
+ }
+
+ public boolean a() {
+ return this.a.isTamed() && !this.a.isSitting() && this.a.aI().nextDouble() <= 0.006500000134110451D && this.f();
+ }
+
+ public boolean b() {
+ return this.c <= this.e && this.d <= 60 && this.a(this.a.world, this.f, this.g, this.h);
+ }
+
+ public void c() {
+ this.a.getNavigation().a((double) ((float) this.f) + 0.5D, (double) (this.g + 1), (double) ((float) this.h) + 0.5D, this.b);
+ this.c = 0;
+ this.d = 0;
+ this.e = this.a.aI().nextInt(this.a.aI().nextInt(1200) + 1200) + 1200;
+ this.a.getGoalSit().setSitting(false);
+ }
+
+ public void d() {
+ this.a.setSitting(false);
+ }
+
+ public void e() {
+ ++this.c;
+ this.a.getGoalSit().setSitting(false);
+ if (this.a.e((double) this.f, (double) (this.g + 1), (double) this.h) > 1.0D) {
+ this.a.setSitting(false);
+ this.a.getNavigation().a((double) ((float) this.f) + 0.5D, (double) (this.g + 1), (double) ((float) this.h) + 0.5D, this.b);
+ ++this.d;
+ } else if (!this.a.isSitting()) {
+ this.a.setSitting(true);
+ } else {
+ --this.d;
+ }
+ }
+
+ private boolean f() {
+ int i = (int) this.a.locY;
+ double d0 = 2.147483647E9D;
+
+ for (int j = (int) this.a.locX - 8; (double) j < this.a.locX + 8.0D; ++j) {
+ for (int k = (int) this.a.locZ - 8; (double) k < this.a.locZ + 8.0D; ++k) {
+ if (this.a(this.a.world, j, i, k) && this.a.world.isEmpty(j, i + 1, k)) {
+ double d1 = this.a.e((double) j, (double) i, (double) k);
+
+ if (d1 < d0) {
+ this.f = j;
+ this.g = i;
+ this.h = k;
+ d0 = d1;
+ }
+ }
+ }
+ }
+
+ return d0 < 2.147483647E9D;
+ }
+
+ private boolean a(World world, int i, int j, int k) {
+ Block block = world.getType(i, j, k);
+ int l = world.getData(i, j, k);
+
+ if (block == Blocks.CHEST) {
+ TileEntityChest tileentitychest = (TileEntityChest) world.getTileEntity(i, j, k);
+
+ if (tileentitychest.o < 1) {
+ return true;
+ }
+ } else {
+ if (block == Blocks.BURNING_FURNACE) {
+ return true;
+ }
+
+ if (block == Blocks.BED && !BlockBed.b(l)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalMoveIndoors.java b/src/main/java/net/minecraft/server/PathfinderGoalMoveIndoors.java
new file mode 100644
index 000000000..06f2765d6
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalMoveIndoors.java
@@ -0,0 +1,62 @@
+package net.minecraft.server;
+
+public class PathfinderGoalMoveIndoors extends PathfinderGoal {
+
+ private EntityCreature a;
+ private VillageDoor b;
+ private int c = -1;
+ private int d = -1;
+
+ public PathfinderGoalMoveIndoors(EntityCreature entitycreature) {
+ this.a = entitycreature;
+ this.a(1);
+ }
+
+ public boolean a() {
+ int i = MathHelper.floor(this.a.locX);
+ int j = MathHelper.floor(this.a.locY);
+ int k = MathHelper.floor(this.a.locZ);
+
+ if ((!this.a.world.w() || this.a.world.Q() || !this.a.world.getBiome(i, k).e()) && !this.a.world.worldProvider.g) {
+ if (this.a.aI().nextInt(50) != 0) {
+ return false;
+ } else if (this.c != -1 && this.a.e((double) this.c, this.a.locY, (double) this.d) < 4.0D) {
+ return false;
+ } else {
+ Village village = this.a.world.villages.getClosestVillage(i, j, k, 14);
+
+ if (village == null) {
+ return false;
+ } else {
+ this.b = village.c(i, j, k);
+ return this.b != null;
+ }
+ }
+ } else {
+ return false;
+ }
+ }
+
+ public boolean b() {
+ return !this.a.getNavigation().g();
+ }
+
+ public void c() {
+ this.c = -1;
+ if (this.a.e((double) this.b.getIndoorsX(), (double) this.b.locY, (double) this.b.getIndoorsZ()) > 256.0D) {
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 14, 3, Vec3D.a((double) this.b.getIndoorsX() + 0.5D, (double) this.b.getIndoorsY(), (double) this.b.getIndoorsZ() + 0.5D));
+
+ if (vec3d != null) {
+ this.a.getNavigation().a(vec3d.a, vec3d.b, vec3d.c, 1.0D);
+ }
+ } else {
+ this.a.getNavigation().a((double) this.b.getIndoorsX() + 0.5D, (double) this.b.getIndoorsY(), (double) this.b.getIndoorsZ() + 0.5D, 1.0D);
+ }
+ }
+
+ public void d() {
+ this.c = this.b.getIndoorsX();
+ this.d = this.b.getIndoorsZ();
+ this.b = null;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalMoveThroughVillage.java b/src/main/java/net/minecraft/server/PathfinderGoalMoveThroughVillage.java
new file mode 100644
index 000000000..f4ec2d44d
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalMoveThroughVillage.java
@@ -0,0 +1,121 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class PathfinderGoalMoveThroughVillage extends PathfinderGoal {
+
+ private EntityCreature a;
+ private double b;
+ private PathEntity c;
+ private VillageDoor d;
+ private boolean e;
+ private List f = new ArrayList();
+
+ public PathfinderGoalMoveThroughVillage(EntityCreature entitycreature, double d0, boolean flag) {
+ this.a = entitycreature;
+ this.b = d0;
+ this.e = flag;
+ this.a(1);
+ }
+
+ public boolean a() {
+ this.f();
+ if (this.e && this.a.world.w()) {
+ return false;
+ } else {
+ Village village = this.a.world.villages.getClosestVillage(MathHelper.floor(this.a.locX), MathHelper.floor(this.a.locY), MathHelper.floor(this.a.locZ), 0);
+
+ if (village == null) {
+ return false;
+ } else {
+ this.d = this.a(village);
+ if (this.d == null) {
+ return false;
+ } else {
+ boolean flag = this.a.getNavigation().c();
+
+ this.a.getNavigation().b(false);
+ this.c = this.a.getNavigation().a((double) this.d.locX, (double) this.d.locY, (double) this.d.locZ);
+ this.a.getNavigation().b(flag);
+ if (this.c != null) {
+ return true;
+ } else {
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 10, 7, Vec3D.a((double) this.d.locX, (double) this.d.locY, (double) this.d.locZ));
+
+ if (vec3d == null) {
+ return false;
+ } else {
+ this.a.getNavigation().b(false);
+ this.c = this.a.getNavigation().a(vec3d.a, vec3d.b, vec3d.c);
+ this.a.getNavigation().b(flag);
+ return this.c != null;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ public boolean b() {
+ if (this.a.getNavigation().g()) {
+ return false;
+ } else {
+ float f = this.a.width + 4.0F;
+
+ return this.a.e((double) this.d.locX, (double) this.d.locY, (double) this.d.locZ) > (double) (f * f);
+ }
+ }
+
+ public void c() {
+ this.a.getNavigation().a(this.c, this.b);
+ }
+
+ public void d() {
+ if (this.a.getNavigation().g() || this.a.e((double) this.d.locX, (double) this.d.locY, (double) this.d.locZ) < 16.0D) {
+ this.f.add(this.d);
+ }
+ }
+
+ private VillageDoor a(Village village) {
+ VillageDoor villagedoor = null;
+ int i = Integer.MAX_VALUE;
+ List list = village.getDoors();
+ Iterator iterator = list.iterator();
+
+ while (iterator.hasNext()) {
+ VillageDoor villagedoor1 = (VillageDoor) iterator.next();
+ int j = villagedoor1.b(MathHelper.floor(this.a.locX), MathHelper.floor(this.a.locY), MathHelper.floor(this.a.locZ));
+
+ if (j < i && !this.a(villagedoor1)) {
+ villagedoor = villagedoor1;
+ i = j;
+ }
+ }
+
+ return villagedoor;
+ }
+
+ private boolean a(VillageDoor villagedoor) {
+ Iterator iterator = this.f.iterator();
+
+ VillageDoor villagedoor1;
+
+ do {
+ if (!iterator.hasNext()) {
+ return false;
+ }
+
+ villagedoor1 = (VillageDoor) iterator.next();
+ } while (villagedoor.locX != villagedoor1.locX || villagedoor.locY != villagedoor1.locY || villagedoor.locZ != villagedoor1.locZ);
+
+ return true;
+ }
+
+ private void f() {
+ if (this.f.size() > 15) {
+ this.f.remove(0);
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsRestriction.java b/src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsRestriction.java
new file mode 100644
index 000000000..69a940e5d
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsRestriction.java
@@ -0,0 +1,42 @@
+package net.minecraft.server;
+
+public class PathfinderGoalMoveTowardsRestriction extends PathfinderGoal {
+
+ private EntityCreature a;
+ private double b;
+ private double c;
+ private double d;
+ private double e;
+
+ public PathfinderGoalMoveTowardsRestriction(EntityCreature entitycreature, double d0) {
+ this.a = entitycreature;
+ this.e = d0;
+ this.a(1);
+ }
+
+ public boolean a() {
+ if (this.a.bU()) {
+ return false;
+ } else {
+ ChunkCoordinates chunkcoordinates = this.a.bV();
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 16, 7, Vec3D.a((double) chunkcoordinates.x, (double) chunkcoordinates.y, (double) chunkcoordinates.z));
+
+ if (vec3d == null) {
+ return false;
+ } else {
+ this.b = vec3d.a;
+ this.c = vec3d.b;
+ this.d = vec3d.c;
+ return true;
+ }
+ }
+ }
+
+ public boolean b() {
+ return !this.a.getNavigation().g();
+ }
+
+ public void c() {
+ this.a.getNavigation().a(this.b, this.c, this.d, this.e);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsTarget.java b/src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsTarget.java
new file mode 100644
index 000000000..28c6252c8
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalMoveTowardsTarget.java
@@ -0,0 +1,51 @@
+package net.minecraft.server;
+
+public class PathfinderGoalMoveTowardsTarget extends PathfinderGoal {
+
+ private EntityCreature a;
+ private EntityLiving b;
+ private double c;
+ private double d;
+ private double e;
+ private double f;
+ private float g;
+
+ public PathfinderGoalMoveTowardsTarget(EntityCreature entitycreature, double d0, float f) {
+ this.a = entitycreature;
+ this.f = d0;
+ this.g = f;
+ this.a(1);
+ }
+
+ public boolean a() {
+ this.b = this.a.getGoalTarget();
+ if (this.b == null) {
+ return false;
+ } else if (this.b.f(this.a) > (double) (this.g * this.g)) {
+ return false;
+ } else {
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 16, 7, Vec3D.a(this.b.locX, this.b.locY, this.b.locZ));
+
+ if (vec3d == null) {
+ return false;
+ } else {
+ this.c = vec3d.a;
+ this.d = vec3d.b;
+ this.e = vec3d.c;
+ return true;
+ }
+ }
+ }
+
+ public boolean b() {
+ return !this.a.getNavigation().g() && this.b.isAlive() && this.b.f(this.a) < (double) (this.g * this.g);
+ }
+
+ public void d() {
+ this.b = null;
+ }
+
+ public void c() {
+ this.a.getNavigation().a(this.c, this.d, this.e, this.f);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalPlay.java b/src/main/java/net/minecraft/server/PathfinderGoalPlay.java
new file mode 100644
index 000000000..8fba19a7f
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalPlay.java
@@ -0,0 +1,87 @@
+package net.minecraft.server;
+
+import java.util.Iterator;
+import java.util.List;
+
+public class PathfinderGoalPlay extends PathfinderGoal {
+
+ private EntityVillager a;
+ private EntityLiving b;
+ private double c;
+ private int d;
+
+ public PathfinderGoalPlay(EntityVillager entityvillager, double d0) {
+ this.a = entityvillager;
+ this.c = d0;
+ this.a(1);
+ }
+
+ public boolean a() {
+ if (this.a.getAge() >= 0) {
+ return false;
+ } else if (this.a.aI().nextInt(400) != 0) {
+ return false;
+ } else {
+ List list = this.a.world.a(EntityVillager.class, this.a.boundingBox.grow(6.0D, 3.0D, 6.0D));
+ double d0 = Double.MAX_VALUE;
+ Iterator iterator = list.iterator();
+
+ while (iterator.hasNext()) {
+ EntityVillager entityvillager = (EntityVillager) iterator.next();
+
+ if (entityvillager != this.a && !entityvillager.cb() && entityvillager.getAge() < 0) {
+ double d1 = entityvillager.f(this.a);
+
+ if (d1 <= d0) {
+ d0 = d1;
+ this.b = entityvillager;
+ }
+ }
+ }
+
+ if (this.b == null) {
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 16, 3);
+
+ if (vec3d == null) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ }
+
+ public boolean b() {
+ return this.d > 0;
+ }
+
+ public void c() {
+ if (this.b != null) {
+ this.a.j(true);
+ }
+
+ this.d = 1000;
+ }
+
+ public void d() {
+ this.a.j(false);
+ this.b = null;
+ }
+
+ public void e() {
+ --this.d;
+ if (this.b != null) {
+ if (this.a.f(this.b) > 4.0D) {
+ this.a.getNavigation().a((Entity) this.b, this.c);
+ }
+ } else if (this.a.getNavigation().g()) {
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 16, 3);
+
+ if (vec3d == null) {
+ return;
+ }
+
+ this.a.getNavigation().a(vec3d.a, vec3d.b, vec3d.c, this.c);
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/PathfinderGoalRandomStroll.java b/src/main/java/net/minecraft/server/PathfinderGoalRandomStroll.java
new file mode 100644
index 000000000..396997afe
--- /dev/null
+++ b/src/main/java/net/minecraft/server/PathfinderGoalRandomStroll.java
@@ -0,0 +1,43 @@
+package net.minecraft.server;
+
+public class PathfinderGoalRandomStroll extends PathfinderGoal {
+
+ private EntityCreature a;
+ private double b;
+ private double c;
+ private double d;
+ private double e;
+
+ public PathfinderGoalRandomStroll(EntityCreature entitycreature, double d0) {
+ this.a = entitycreature;
+ this.e = d0;
+ this.a(1);
+ }
+
+ public boolean a() {
+ if (this.a.aN() >= 100) {
+ return false;
+ } else if (this.a.aI().nextInt(120) != 0) {
+ return false;
+ } else {
+ Vec3D vec3d = RandomPositionGenerator.a(this.a, 10, 7);
+
+ if (vec3d == null) {
+ return false;
+ } else {
+ this.b = vec3d.a;
+ this.c = vec3d.b;
+ this.d = vec3d.c;
+ return true;
+ }
+ }
+ }
+
+ public boolean b() {
+ return !this.a.getNavigation().g();
+ }
+
+ public void c() {
+ this.a.getNavigation().a(this.b, this.c, this.d, this.e);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/QueuedProtocolSwitch.java b/src/main/java/net/minecraft/server/QueuedProtocolSwitch.java
new file mode 100644
index 000000000..344e4f00b
--- /dev/null
+++ b/src/main/java/net/minecraft/server/QueuedProtocolSwitch.java
@@ -0,0 +1,29 @@
+package net.minecraft.server;
+
+import net.minecraft.util.io.netty.channel.ChannelFutureListener;
+import net.minecraft.util.io.netty.util.concurrent.GenericFutureListener;
+
+class QueuedProtocolSwitch implements Runnable {
+
+ final EnumProtocol a;
+ final EnumProtocol b;
+ final Packet c;
+ final GenericFutureListener[] d;
+ final NetworkManager e;
+
+ QueuedProtocolSwitch(NetworkManager networkmanager, EnumProtocol enumprotocol, EnumProtocol enumprotocol1, Packet packet, GenericFutureListener[] agenericfuturelistener) {
+ this.e = networkmanager;
+ this.a = enumprotocol;
+ this.b = enumprotocol1;
+ this.c = packet;
+ this.d = agenericfuturelistener;
+ }
+
+ public void run() {
+ if (this.a != this.b) {
+ this.e.a(this.a);
+ }
+
+ NetworkManager.a(this.e).writeAndFlush(this.c).addListeners(this.d).addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/RandomPositionGenerator.java b/src/main/java/net/minecraft/server/RandomPositionGenerator.java
new file mode 100644
index 000000000..9342a3f42
--- /dev/null
+++ b/src/main/java/net/minecraft/server/RandomPositionGenerator.java
@@ -0,0 +1,74 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class RandomPositionGenerator {
+
+ private static Vec3D a = Vec3D.a(0.0D, 0.0D, 0.0D);
+
+ public static Vec3D a(EntityCreature entitycreature, int i, int j) {
+ return c(entitycreature, i, j, (Vec3D) null);
+ }
+
+ public static Vec3D a(EntityCreature entitycreature, int i, int j, Vec3D vec3d) {
+ a.a = vec3d.a - entitycreature.locX;
+ a.b = vec3d.b - entitycreature.locY;
+ a.c = vec3d.c - entitycreature.locZ;
+ return c(entitycreature, i, j, a);
+ }
+
+ public static Vec3D b(EntityCreature entitycreature, int i, int j, Vec3D vec3d) {
+ a.a = entitycreature.locX - vec3d.a;
+ a.b = entitycreature.locY - vec3d.b;
+ a.c = entitycreature.locZ - vec3d.c;
+ return c(entitycreature, i, j, a);
+ }
+
+ private static Vec3D c(EntityCreature entitycreature, int i, int j, Vec3D vec3d) {
+ Random random = entitycreature.aI();
+ boolean flag = false;
+ int k = 0;
+ int l = 0;
+ int i1 = 0;
+ float f = -99999.0F;
+ boolean flag1;
+
+ if (entitycreature.bY()) {
+ double d0 = (double) (entitycreature.bV().e(MathHelper.floor(entitycreature.locX), MathHelper.floor(entitycreature.locY), MathHelper.floor(entitycreature.locZ)) + 4.0F);
+ double d1 = (double) (entitycreature.bW() + (float) i);
+
+ flag1 = d0 < d1 * d1;
+ } else {
+ flag1 = false;
+ }
+
+ for (int j1 = 0; j1 < 10; ++j1) {
+ int k1 = random.nextInt(2 * i) - i;
+ int l1 = random.nextInt(2 * j) - j;
+ int i2 = random.nextInt(2 * i) - i;
+
+ if (vec3d == null || (double) k1 * vec3d.a + (double) i2 * vec3d.c >= 0.0D) {
+ k1 += MathHelper.floor(entitycreature.locX);
+ l1 += MathHelper.floor(entitycreature.locY);
+ i2 += MathHelper.floor(entitycreature.locZ);
+ if (!flag1 || entitycreature.b(k1, l1, i2)) {
+ float f1 = entitycreature.a(k1, l1, i2);
+
+ if (f1 > f) {
+ f = f1;
+ k = k1;
+ l = l1;
+ i1 = i2;
+ flag = true;
+ }
+ }
+ }
+ }
+
+ if (flag) {
+ return Vec3D.a((double) k, (double) l, (double) i1);
+ } else {
+ return null;
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/RegistryBlocks.java b/src/main/java/net/minecraft/server/RegistryBlocks.java
new file mode 100644
index 000000000..43f926919
--- /dev/null
+++ b/src/main/java/net/minecraft/server/RegistryBlocks.java
@@ -0,0 +1,35 @@
+package net.minecraft.server;
+
+public class RegistryBlocks extends RegistryMaterials {
+
+ private final String d;
+ private Object e;
+
+ public RegistryBlocks(String s) {
+ this.d = s;
+ }
+
+ public void a(int i, String s, Object object) {
+ if (this.d.equals(s)) {
+ this.e = object;
+ }
+
+ super.a(i, s, object);
+ }
+
+ public Object get(String s) {
+ Object object = super.get(s);
+
+ return object == null ? this.e : object;
+ }
+
+ public Object a(int i) {
+ Object object = super.a(i);
+
+ return object == null ? this.e : object;
+ }
+
+ public Object get(Object object) {
+ return this.get((String) object);
+ }
+}
diff --git a/src/main/java/net/minecraft/server/Scoreboard.java b/src/main/java/net/minecraft/server/Scoreboard.java
new file mode 100644
index 000000000..d3511ca08
--- /dev/null
+++ b/src/main/java/net/minecraft/server/Scoreboard.java
@@ -0,0 +1,275 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class Scoreboard {
+
+ private final Map objectivesByName = new HashMap();
+ private final Map objectivesByCriteria = new HashMap();
+ private final Map playerScores = new HashMap();
+ private final ScoreboardObjective[] displaySlots = new ScoreboardObjective[3];
+ private final Map teamsByName = new HashMap();
+ private final Map teamsByPlayer = new HashMap();
+
+ public Scoreboard() {}
+
+ public ScoreboardObjective getObjective(String s) {
+ return (ScoreboardObjective) this.objectivesByName.get(s);
+ }
+
+ public ScoreboardObjective registerObjective(String s, IScoreboardCriteria iscoreboardcriteria) {
+ ScoreboardObjective scoreboardobjective = this.getObjective(s);
+
+ if (scoreboardobjective != null) {
+ throw new IllegalArgumentException("An objective with the name \'" + s + "\' already exists!");
+ } else {
+ scoreboardobjective = new ScoreboardObjective(this, s, iscoreboardcriteria);
+ Object object = (List) this.objectivesByCriteria.get(iscoreboardcriteria);
+
+ if (object == null) {
+ object = new ArrayList();
+ this.objectivesByCriteria.put(iscoreboardcriteria, object);
+ }
+
+ ((List) object).add(scoreboardobjective);
+ this.objectivesByName.put(s, scoreboardobjective);
+ this.handleObjectiveAdded(scoreboardobjective);
+ return scoreboardobjective;
+ }
+ }
+
+ public Collection getObjectivesForCriteria(IScoreboardCriteria iscoreboardcriteria) {
+ Collection collection = (Collection) this.objectivesByCriteria.get(iscoreboardcriteria);
+
+ return collection == null ? new ArrayList() : new ArrayList(collection);
+ }
+
+ public ScoreboardScore getPlayerScoreForObjective(String s, ScoreboardObjective scoreboardobjective) {
+ Object object = (Map) this.playerScores.get(s);
+
+ if (object == null) {
+ object = new HashMap();
+ this.playerScores.put(s, object);
+ }
+
+ ScoreboardScore scoreboardscore = (ScoreboardScore) ((Map) object).get(scoreboardobjective);
+
+ if (scoreboardscore == null) {
+ scoreboardscore = new ScoreboardScore(this, scoreboardobjective, s);
+ ((Map) object).put(scoreboardobjective, scoreboardscore);
+ }
+
+ return scoreboardscore;
+ }
+
+ public Collection getScoresForObjective(ScoreboardObjective scoreboardobjective) {
+ ArrayList arraylist = new ArrayList();
+ Iterator iterator = this.playerScores.values().iterator();
+
+ while (iterator.hasNext()) {
+ Map map = (Map) iterator.next();
+ ScoreboardScore scoreboardscore = (ScoreboardScore) map.get(scoreboardobjective);
+
+ if (scoreboardscore != null) {
+ arraylist.add(scoreboardscore);
+ }
+ }
+
+ Collections.sort(arraylist, ScoreboardScore.a);
+ return arraylist;
+ }
+
+ public Collection getObjectives() {
+ return this.objectivesByName.values();
+ }
+
+ public Collection getPlayers() {
+ return this.playerScores.keySet();
+ }
+
+ public void resetPlayerScores(String s) {
+ Map map = (Map) this.playerScores.remove(s);
+
+ if (map != null) {
+ this.handlePlayerRemoved(s);
+ }
+ }
+
+ public Collection getScores() {
+ Collection collection = this.playerScores.values();
+ ArrayList arraylist = new ArrayList();
+ Iterator iterator = collection.iterator();
+
+ while (iterator.hasNext()) {
+ Map map = (Map) iterator.next();
+
+ arraylist.addAll(map.values());
+ }
+
+ return arraylist;
+ }
+
+ public Map getPlayerObjectives(String s) {
+ Object object = (Map) this.playerScores.get(s);
+
+ if (object == null) {
+ object = new HashMap();
+ }
+
+ return (Map) object;
+ }
+
+ public void unregisterObjective(ScoreboardObjective scoreboardobjective) {
+ this.objectivesByName.remove(scoreboardobjective.getName());
+
+ for (int i = 0; i < 3; ++i) {
+ if (this.getObjectiveForSlot(i) == scoreboardobjective) {
+ this.setDisplaySlot(i, (ScoreboardObjective) null);
+ }
+ }
+
+ List list = (List) this.objectivesByCriteria.get(scoreboardobjective.getCriteria());
+
+ if (list != null) {
+ list.remove(scoreboardobjective);
+ }
+
+ Iterator iterator = this.playerScores.values().iterator();
+
+ while (iterator.hasNext()) {
+ Map map = (Map) iterator.next();
+
+ map.remove(scoreboardobjective);
+ }
+
+ this.handleObjectiveRemoved(scoreboardobjective);
+ }
+
+ public void setDisplaySlot(int i, ScoreboardObjective scoreboardobjective) {
+ this.displaySlots[i] = scoreboardobjective;
+ }
+
+ public ScoreboardObjective getObjectiveForSlot(int i) {
+ return this.displaySlots[i];
+ }
+
+ public ScoreboardTeam getTeam(String s) {
+ return (ScoreboardTeam) this.teamsByName.get(s);
+ }
+
+ public ScoreboardTeam createTeam(String s) {
+ ScoreboardTeam scoreboardteam = this.getTeam(s);
+
+ if (scoreboardteam != null) {
+ throw new IllegalArgumentException("A team with the name \'" + s + "\' already exists!");
+ } else {
+ scoreboardteam = new ScoreboardTeam(this, s);
+ this.teamsByName.put(s, scoreboardteam);
+ this.handleTeamAdded(scoreboardteam);
+ return scoreboardteam;
+ }
+ }
+
+ public void removeTeam(ScoreboardTeam scoreboardteam) {
+ this.teamsByName.remove(scoreboardteam.getName());
+ Iterator iterator = scoreboardteam.getPlayerNameSet().iterator();
+
+ while (iterator.hasNext()) {
+ String s = (String) iterator.next();
+
+ this.teamsByPlayer.remove(s);
+ }
+
+ this.handleTeamRemoved(scoreboardteam);
+ }
+
+ public boolean addPlayerToTeam(String s, String s1) {
+ if (!this.teamsByName.containsKey(s1)) {
+ return false;
+ } else {
+ ScoreboardTeam scoreboardteam = this.getTeam(s1);
+
+ if (this.getPlayerTeam(s) != null) {
+ this.removePlayerFromTeam(s);
+ }
+
+ this.teamsByPlayer.put(s, scoreboardteam);
+ scoreboardteam.getPlayerNameSet().add(s);
+ return true;
+ }
+ }
+
+ public boolean removePlayerFromTeam(String s) {
+ ScoreboardTeam scoreboardteam = this.getPlayerTeam(s);
+
+ if (scoreboardteam != null) {
+ this.removePlayerFromTeam(s, scoreboardteam);
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public void removePlayerFromTeam(String s, ScoreboardTeam scoreboardteam) {
+ if (this.getPlayerTeam(s) != scoreboardteam) {
+ throw new IllegalStateException("Player is either on another team or not on any team. Cannot remove from team \'" + scoreboardteam.getName() + "\'.");
+ } else {
+ this.teamsByPlayer.remove(s);
+ scoreboardteam.getPlayerNameSet().remove(s);
+ }
+ }
+
+ public Collection getTeamNames() {
+ return this.teamsByName.keySet();
+ }
+
+ public Collection getTeams() {
+ return this.teamsByName.values();
+ }
+
+ public ScoreboardTeam getPlayerTeam(String s) {
+ return (ScoreboardTeam) this.teamsByPlayer.get(s);
+ }
+
+ public void handleObjectiveAdded(ScoreboardObjective scoreboardobjective) {}
+
+ public void handleObjectiveChanged(ScoreboardObjective scoreboardobjective) {}
+
+ public void handleObjectiveRemoved(ScoreboardObjective scoreboardobjective) {}
+
+ public void handleScoreChanged(ScoreboardScore scoreboardscore) {}
+
+ public void handlePlayerRemoved(String s) {}
+
+ public void handleTeamAdded(ScoreboardTeam scoreboardteam) {}
+
+ public void handleTeamChanged(ScoreboardTeam scoreboardteam) {}
+
+ public void handleTeamRemoved(ScoreboardTeam scoreboardteam) {}
+
+ public static String getSlotName(int i) {
+ switch (i) {
+ case 0:
+ return "list";
+
+ case 1:
+ return "sidebar";
+
+ case 2:
+ return "belowName";
+
+ default:
+ return null;
+ }
+ }
+
+ public static int getSlotForName(String s) {
+ return s.equalsIgnoreCase("list") ? 0 : (s.equalsIgnoreCase("sidebar") ? 1 : (s.equalsIgnoreCase("belowName") ? 2 : -1));
+ }
+}
diff --git a/src/main/java/net/minecraft/server/TileEntityEnderChest.java b/src/main/java/net/minecraft/server/TileEntityEnderChest.java
new file mode 100644
index 000000000..b205ab70d
--- /dev/null
+++ b/src/main/java/net/minecraft/server/TileEntityEnderChest.java
@@ -0,0 +1,84 @@
+package net.minecraft.server;
+
+public class TileEntityEnderChest extends TileEntity {
+
+ public float a;
+ public float i;
+ public int j;
+ private int k;
+
+ public TileEntityEnderChest() {}
+
+ public void h() {
+ super.h();
+ if (++this.k % 20 * 4 == 0) {
+ this.world.playBlockAction(this.x, this.y, this.z, Blocks.ENDER_CHEST, 1, this.j);
+ }
+
+ this.i = this.a;
+ float f = 0.1F;
+ double d0;
+
+ if (this.j > 0 && this.a == 0.0F) {
+ double d1 = (double) this.x + 0.5D;
+
+ d0 = (double) this.z + 0.5D;
+ this.world.makeSound(d1, (double) this.y + 0.5D, d0, "random.chestopen", 0.5F, this.world.random.nextFloat() * 0.1F + 0.9F);
+ }
+
+ if (this.j == 0 && this.a > 0.0F || this.j > 0 && this.a < 1.0F) {
+ float f1 = this.a;
+
+ if (this.j > 0) {
+ this.a += f;
+ } else {
+ this.a -= f;
+ }
+
+ if (this.a > 1.0F) {
+ this.a = 1.0F;
+ }
+
+ float f2 = 0.5F;
+
+ if (this.a < f2 && f1 >= f2) {
+ d0 = (double) this.x + 0.5D;
+ double d2 = (double) this.z + 0.5D;
+
+ this.world.makeSound(d0, (double) this.y + 0.5D, d2, "random.chestclosed", 0.5F, this.world.random.nextFloat() * 0.1F + 0.9F);
+ }
+
+ if (this.a < 0.0F) {
+ this.a = 0.0F;
+ }
+ }
+ }
+
+ public boolean c(int i, int j) {
+ if (i == 1) {
+ this.j = j;
+ return true;
+ } else {
+ return super.c(i, j);
+ }
+ }
+
+ public void s() {
+ this.u();
+ super.s();
+ }
+
+ public void a() {
+ ++this.j;
+ this.world.playBlockAction(this.x, this.y, this.z, Blocks.ENDER_CHEST, 1, this.j);
+ }
+
+ public void b() {
+ --this.j;
+ this.world.playBlockAction(this.x, this.y, this.z, Blocks.ENDER_CHEST, 1, this.j);
+ }
+
+ public boolean a(EntityHuman entityhuman) {
+ return this.world.getTileEntity(this.x, this.y, this.z) != this ? false : entityhuman.e((double) this.x + 0.5D, (double) this.y + 0.5D, (double) this.z + 0.5D) <= 64.0D;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/TileEntityLightDetector.java b/src/main/java/net/minecraft/server/TileEntityLightDetector.java
new file mode 100644
index 000000000..143cffbab
--- /dev/null
+++ b/src/main/java/net/minecraft/server/TileEntityLightDetector.java
@@ -0,0 +1,15 @@
+package net.minecraft.server;
+
+public class TileEntityLightDetector extends TileEntity {
+
+ public TileEntityLightDetector() {}
+
+ public void h() {
+ if (this.world != null && !this.world.isStatic && this.world.getTime() % 20L == 0L) {
+ this.h = this.q();
+ if (this.h instanceof BlockDaylightDetector) {
+ ((BlockDaylightDetector) this.h).e(this.world, this.x, this.y, this.z);
+ }
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldChunkManager.java b/src/main/java/net/minecraft/server/WorldChunkManager.java
new file mode 100644
index 000000000..4b94d1cf6
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldChunkManager.java
@@ -0,0 +1,195 @@
+package net.minecraft.server;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class WorldChunkManager {
+
+ private GenLayer c;
+ private GenLayer d;
+ private BiomeCache e;
+ private List f;
+
+ protected WorldChunkManager() {
+ this.e = new BiomeCache(this);
+ this.f = new ArrayList();
+ this.f.add(BiomeBase.FOREST);
+ this.f.add(BiomeBase.PLAINS);
+ this.f.add(BiomeBase.TAIGA);
+ this.f.add(BiomeBase.TAIGA_HILLS);
+ this.f.add(BiomeBase.FOREST_HILLS);
+ this.f.add(BiomeBase.JUNGLE);
+ this.f.add(BiomeBase.JUNGLE_HILLS);
+ }
+
+ public WorldChunkManager(long i, WorldType worldtype) {
+ this();
+ GenLayer[] agenlayer = GenLayer.a(i, worldtype);
+
+ this.c = agenlayer[0];
+ this.d = agenlayer[1];
+ }
+
+ public WorldChunkManager(World world) {
+ this(world.getSeed(), world.getWorldData().getType());
+ }
+
+ public List a() {
+ return this.f;
+ }
+
+ public BiomeBase getBiome(int i, int j) {
+ return this.e.b(i, j);
+ }
+
+ public float[] getWetness(float[] afloat, int i, int j, int k, int l) {
+ IntCache.a();
+ if (afloat == null || afloat.length < k * l) {
+ afloat = new float[k * l];
+ }
+
+ int[] aint = this.d.a(i, j, k, l);
+
+ for (int i1 = 0; i1 < k * l; ++i1) {
+ try {
+ float f = (float) BiomeBase.getBiome(aint[i1]).h() / 65536.0F;
+
+ if (f > 1.0F) {
+ f = 1.0F;
+ }
+
+ afloat[i1] = f;
+ } catch (Throwable throwable) {
+ CrashReport crashreport = CrashReport.a(throwable, "Invalid Biome id");
+ CrashReportSystemDetails crashreportsystemdetails = crashreport.a("DownfallBlock");
+
+ crashreportsystemdetails.a("biome id", Integer.valueOf(i1));
+ crashreportsystemdetails.a("downfalls[] size", Integer.valueOf(afloat.length));
+ crashreportsystemdetails.a("x", Integer.valueOf(i));
+ crashreportsystemdetails.a("z", Integer.valueOf(j));
+ crashreportsystemdetails.a("w", Integer.valueOf(k));
+ crashreportsystemdetails.a("h", Integer.valueOf(l));
+ throw new ReportedException(crashreport);
+ }
+ }
+
+ return afloat;
+ }
+
+ public BiomeBase[] getBiomes(BiomeBase[] abiomebase, int i, int j, int k, int l) {
+ IntCache.a();
+ if (abiomebase == null || abiomebase.length < k * l) {
+ abiomebase = new BiomeBase[k * l];
+ }
+
+ int[] aint = this.c.a(i, j, k, l);
+
+ try {
+ for (int i1 = 0; i1 < k * l; ++i1) {
+ abiomebase[i1] = BiomeBase.getBiome(aint[i1]);
+ }
+
+ return abiomebase;
+ } catch (Throwable throwable) {
+ CrashReport crashreport = CrashReport.a(throwable, "Invalid Biome id");
+ CrashReportSystemDetails crashreportsystemdetails = crashreport.a("RawBiomeBlock");
+
+ crashreportsystemdetails.a("biomes[] size", Integer.valueOf(abiomebase.length));
+ crashreportsystemdetails.a("x", Integer.valueOf(i));
+ crashreportsystemdetails.a("z", Integer.valueOf(j));
+ crashreportsystemdetails.a("w", Integer.valueOf(k));
+ crashreportsystemdetails.a("h", Integer.valueOf(l));
+ throw new ReportedException(crashreport);
+ }
+ }
+
+ public BiomeBase[] getBiomeBlock(BiomeBase[] abiomebase, int i, int j, int k, int l) {
+ return this.a(abiomebase, i, j, k, l, true);
+ }
+
+ public BiomeBase[] a(BiomeBase[] abiomebase, int i, int j, int k, int l, boolean flag) {
+ IntCache.a();
+ if (abiomebase == null || abiomebase.length < k * l) {
+ abiomebase = new BiomeBase[k * l];
+ }
+
+ if (flag && k == 16 && l == 16 && (i & 15) == 0 && (j & 15) == 0) {
+ BiomeBase[] abiomebase1 = this.e.d(i, j);
+
+ System.arraycopy(abiomebase1, 0, abiomebase, 0, k * l);
+ return abiomebase;
+ } else {
+ int[] aint = this.d.a(i, j, k, l);
+
+ for (int i1 = 0; i1 < k * l; ++i1) {
+ abiomebase[i1] = BiomeBase.getBiome(aint[i1]);
+ }
+
+ return abiomebase;
+ }
+ }
+
+ public boolean a(int i, int j, int k, List list) {
+ IntCache.a();
+ int l = i - k >> 2;
+ int i1 = j - k >> 2;
+ int j1 = i + k >> 2;
+ int k1 = j + k >> 2;
+ int l1 = j1 - l + 1;
+ int i2 = k1 - i1 + 1;
+ int[] aint = this.c.a(l, i1, l1, i2);
+
+ try {
+ for (int j2 = 0; j2 < l1 * i2; ++j2) {
+ BiomeBase biomebase = BiomeBase.getBiome(aint[j2]);
+
+ if (!list.contains(biomebase)) {
+ return false;
+ }
+ }
+
+ return true;
+ } catch (Throwable throwable) {
+ CrashReport crashreport = CrashReport.a(throwable, "Invalid Biome id");
+ CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Layer");
+
+ crashreportsystemdetails.a("Layer", this.c.toString());
+ crashreportsystemdetails.a("x", Integer.valueOf(i));
+ crashreportsystemdetails.a("z", Integer.valueOf(j));
+ crashreportsystemdetails.a("radius", Integer.valueOf(k));
+ crashreportsystemdetails.a("allowed", list);
+ throw new ReportedException(crashreport);
+ }
+ }
+
+ public ChunkPosition a(int i, int j, int k, List list, Random random) {
+ IntCache.a();
+ int l = i - k >> 2;
+ int i1 = j - k >> 2;
+ int j1 = i + k >> 2;
+ int k1 = j + k >> 2;
+ int l1 = j1 - l + 1;
+ int i2 = k1 - i1 + 1;
+ int[] aint = this.c.a(l, i1, l1, i2);
+ ChunkPosition chunkposition = null;
+ int j2 = 0;
+
+ for (int k2 = 0; k2 < l1 * i2; ++k2) {
+ int l2 = l + k2 % l1 << 2;
+ int i3 = i1 + k2 / l1 << 2;
+ BiomeBase biomebase = BiomeBase.getBiome(aint[k2]);
+
+ if (list.contains(biomebase) && (chunkposition == null || random.nextInt(j2 + 1) == 0)) {
+ chunkposition = new ChunkPosition(l2, 0, i3);
+ ++j2;
+ }
+ }
+
+ return chunkposition;
+ }
+
+ public void b() {
+ this.e.a();
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldData.java b/src/main/java/net/minecraft/server/WorldData.java
new file mode 100644
index 000000000..3036d3d31
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldData.java
@@ -0,0 +1,417 @@
+package net.minecraft.server;
+
+import java.util.concurrent.Callable;
+
+public class WorldData {
+
+ private long seed;
+ private WorldType type;
+ private String generatorOptions;
+ private int spawnX;
+ private int spawnY;
+ private int spawnZ;
+ private long time;
+ private long dayTime;
+ private long lastPlayed;
+ private long sizeOnDisk;
+ private NBTTagCompound playerData;
+ private int dimension;
+ private String name;
+ private int version;
+ private boolean isRaining;
+ private int rainTicks;
+ private boolean isThundering;
+ private int thunderTicks;
+ private EnumGamemode gameType;
+ private boolean useMapFeatures;
+ private boolean hardcore;
+ private boolean allowCommands;
+ private boolean initialized;
+ private GameRules gameRules;
+
+ protected WorldData() {
+ this.type = WorldType.NORMAL;
+ this.generatorOptions = "";
+ this.gameRules = new GameRules();
+ }
+
+ public WorldData(NBTTagCompound nbttagcompound) {
+ this.type = WorldType.NORMAL;
+ this.generatorOptions = "";
+ this.gameRules = new GameRules();
+ this.seed = nbttagcompound.getLong("RandomSeed");
+ if (nbttagcompound.hasKeyOfType("generatorName", 8)) {
+ String s = nbttagcompound.getString("generatorName");
+
+ this.type = WorldType.getType(s);
+ if (this.type == null) {
+ this.type = WorldType.NORMAL;
+ } else if (this.type.f()) {
+ int i = 0;
+
+ if (nbttagcompound.hasKeyOfType("generatorVersion", 99)) {
+ i = nbttagcompound.getInt("generatorVersion");
+ }
+
+ this.type = this.type.a(i);
+ }
+
+ if (nbttagcompound.hasKeyOfType("generatorOptions", 8)) {
+ this.generatorOptions = nbttagcompound.getString("generatorOptions");
+ }
+ }
+
+ this.gameType = EnumGamemode.getById(nbttagcompound.getInt("GameType"));
+ if (nbttagcompound.hasKeyOfType("MapFeatures", 99)) {
+ this.useMapFeatures = nbttagcompound.getBoolean("MapFeatures");
+ } else {
+ this.useMapFeatures = true;
+ }
+
+ this.spawnX = nbttagcompound.getInt("SpawnX");
+ this.spawnY = nbttagcompound.getInt("SpawnY");
+ this.spawnZ = nbttagcompound.getInt("SpawnZ");
+ this.time = nbttagcompound.getLong("Time");
+ if (nbttagcompound.hasKeyOfType("DayTime", 99)) {
+ this.dayTime = nbttagcompound.getLong("DayTime");
+ } else {
+ this.dayTime = this.time;
+ }
+
+ this.lastPlayed = nbttagcompound.getLong("LastPlayed");
+ this.sizeOnDisk = nbttagcompound.getLong("SizeOnDisk");
+ this.name = nbttagcompound.getString("LevelName");
+ this.version = nbttagcompound.getInt("version");
+ this.rainTicks = nbttagcompound.getInt("rainTime");
+ this.isRaining = nbttagcompound.getBoolean("raining");
+ this.thunderTicks = nbttagcompound.getInt("thunderTime");
+ this.isThundering = nbttagcompound.getBoolean("thundering");
+ this.hardcore = nbttagcompound.getBoolean("hardcore");
+ if (nbttagcompound.hasKeyOfType("initialized", 99)) {
+ this.initialized = nbttagcompound.getBoolean("initialized");
+ } else {
+ this.initialized = true;
+ }
+
+ if (nbttagcompound.hasKeyOfType("allowCommands", 99)) {
+ this.allowCommands = nbttagcompound.getBoolean("allowCommands");
+ } else {
+ this.allowCommands = this.gameType == EnumGamemode.CREATIVE;
+ }
+
+ if (nbttagcompound.hasKeyOfType("Player", 10)) {
+ this.playerData = nbttagcompound.getCompound("Player");
+ this.dimension = this.playerData.getInt("Dimension");
+ }
+
+ if (nbttagcompound.hasKeyOfType("GameRules", 10)) {
+ this.gameRules.a(nbttagcompound.getCompound("GameRules"));
+ }
+ }
+
+ public WorldData(WorldSettings worldsettings, String s) {
+ this.type = WorldType.NORMAL;
+ this.generatorOptions = "";
+ this.gameRules = new GameRules();
+ this.seed = worldsettings.d();
+ this.gameType = worldsettings.e();
+ this.useMapFeatures = worldsettings.g();
+ this.name = s;
+ this.hardcore = worldsettings.f();
+ this.type = worldsettings.h();
+ this.generatorOptions = worldsettings.j();
+ this.allowCommands = worldsettings.i();
+ this.initialized = false;
+ }
+
+ public WorldData(WorldData worlddata) {
+ this.type = WorldType.NORMAL;
+ this.generatorOptions = "";
+ this.gameRules = new GameRules();
+ this.seed = worlddata.seed;
+ this.type = worlddata.type;
+ this.generatorOptions = worlddata.generatorOptions;
+ this.gameType = worlddata.gameType;
+ this.useMapFeatures = worlddata.useMapFeatures;
+ this.spawnX = worlddata.spawnX;
+ this.spawnY = worlddata.spawnY;
+ this.spawnZ = worlddata.spawnZ;
+ this.time = worlddata.time;
+ this.dayTime = worlddata.dayTime;
+ this.lastPlayed = worlddata.lastPlayed;
+ this.sizeOnDisk = worlddata.sizeOnDisk;
+ this.playerData = worlddata.playerData;
+ this.dimension = worlddata.dimension;
+ this.name = worlddata.name;
+ this.version = worlddata.version;
+ this.rainTicks = worlddata.rainTicks;
+ this.isRaining = worlddata.isRaining;
+ this.thunderTicks = worlddata.thunderTicks;
+ this.isThundering = worlddata.isThundering;
+ this.hardcore = worlddata.hardcore;
+ this.allowCommands = worlddata.allowCommands;
+ this.initialized = worlddata.initialized;
+ this.gameRules = worlddata.gameRules;
+ }
+
+ public NBTTagCompound a() {
+ NBTTagCompound nbttagcompound = new NBTTagCompound();
+
+ this.a(nbttagcompound, this.playerData);
+ return nbttagcompound;
+ }
+
+ public NBTTagCompound a(NBTTagCompound nbttagcompound) {
+ NBTTagCompound nbttagcompound1 = new NBTTagCompound();
+
+ this.a(nbttagcompound1, nbttagcompound);
+ return nbttagcompound1;
+ }
+
+ private void a(NBTTagCompound nbttagcompound, NBTTagCompound nbttagcompound1) {
+ nbttagcompound.setLong("RandomSeed", this.seed);
+ nbttagcompound.setString("generatorName", this.type.name());
+ nbttagcompound.setInt("generatorVersion", this.type.getVersion());
+ nbttagcompound.setString("generatorOptions", this.generatorOptions);
+ nbttagcompound.setInt("GameType", this.gameType.getId());
+ nbttagcompound.setBoolean("MapFeatures", this.useMapFeatures);
+ nbttagcompound.setInt("SpawnX", this.spawnX);
+ nbttagcompound.setInt("SpawnY", this.spawnY);
+ nbttagcompound.setInt("SpawnZ", this.spawnZ);
+ nbttagcompound.setLong("Time", this.time);
+ nbttagcompound.setLong("DayTime", this.dayTime);
+ nbttagcompound.setLong("SizeOnDisk", this.sizeOnDisk);
+ nbttagcompound.setLong("LastPlayed", MinecraftServer.ar());
+ nbttagcompound.setString("LevelName", this.name);
+ nbttagcompound.setInt("version", this.version);
+ nbttagcompound.setInt("rainTime", this.rainTicks);
+ nbttagcompound.setBoolean("raining", this.isRaining);
+ nbttagcompound.setInt("thunderTime", this.thunderTicks);
+ nbttagcompound.setBoolean("thundering", this.isThundering);
+ nbttagcompound.setBoolean("hardcore", this.hardcore);
+ nbttagcompound.setBoolean("allowCommands", this.allowCommands);
+ nbttagcompound.setBoolean("initialized", this.initialized);
+ nbttagcompound.set("GameRules", this.gameRules.a());
+ if (nbttagcompound1 != null) {
+ nbttagcompound.set("Player", nbttagcompound1);
+ }
+ }
+
+ public long getSeed() {
+ return this.seed;
+ }
+
+ public int c() {
+ return this.spawnX;
+ }
+
+ public int d() {
+ return this.spawnY;
+ }
+
+ public int e() {
+ return this.spawnZ;
+ }
+
+ public long getTime() {
+ return this.time;
+ }
+
+ public long getDayTime() {
+ return this.dayTime;
+ }
+
+ public NBTTagCompound i() {
+ return this.playerData;
+ }
+
+ public int j() {
+ return this.dimension;
+ }
+
+ public void setTime(long i) {
+ this.time = i;
+ }
+
+ public void setDayTime(long i) {
+ this.dayTime = i;
+ }
+
+ public void setSpawn(int i, int j, int k) {
+ this.spawnX = i;
+ this.spawnY = j;
+ this.spawnZ = k;
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public void setName(String s) {
+ this.name = s;
+ }
+
+ public int l() {
+ return this.version;
+ }
+
+ public void e(int i) {
+ this.version = i;
+ }
+
+ public boolean isThundering() {
+ return this.isThundering;
+ }
+
+ public void setThundering(boolean flag) {
+ this.isThundering = flag;
+ }
+
+ public int getThunderDuration() {
+ return this.thunderTicks;
+ }
+
+ public void setThunderDuration(int i) {
+ this.thunderTicks = i;
+ }
+
+ public boolean hasStorm() {
+ return this.isRaining;
+ }
+
+ public void setStorm(boolean flag) {
+ this.isRaining = flag;
+ }
+
+ public int getWeatherDuration() {
+ return this.rainTicks;
+ }
+
+ public void setWeatherDuration(int i) {
+ this.rainTicks = i;
+ }
+
+ public EnumGamemode getGameType() {
+ return this.gameType;
+ }
+
+ public boolean shouldGenerateMapFeatures() {
+ return this.useMapFeatures;
+ }
+
+ public void setGameType(EnumGamemode enumgamemode) {
+ this.gameType = enumgamemode;
+ }
+
+ public boolean isHardcore() {
+ return this.hardcore;
+ }
+
+ public WorldType getType() {
+ return this.type;
+ }
+
+ public void setType(WorldType worldtype) {
+ this.type = worldtype;
+ }
+
+ public String getGeneratorOptions() {
+ return this.generatorOptions;
+ }
+
+ public boolean allowCommands() {
+ return this.allowCommands;
+ }
+
+ public boolean isInitialized() {
+ return this.initialized;
+ }
+
+ public void d(boolean flag) {
+ this.initialized = flag;
+ }
+
+ public GameRules getGameRules() {
+ return this.gameRules;
+ }
+
+ public void a(CrashReportSystemDetails crashreportsystemdetails) {
+ crashreportsystemdetails.a("Level seed", (Callable) (new CrashReportLevelSeed(this)));
+ crashreportsystemdetails.a("Level generator", (Callable) (new CrashReportLevelGenerator(this)));
+ crashreportsystemdetails.a("Level generator options", (Callable) (new CrashReportLevelGeneratorOptions(this)));
+ crashreportsystemdetails.a("Level spawn location", (Callable) (new CrashReportLevelSpawnLocation(this)));
+ crashreportsystemdetails.a("Level time", (Callable) (new CrashReportLevelTime(this)));
+ crashreportsystemdetails.a("Level dimension", (Callable) (new CrashReportLevelDimension(this)));
+ crashreportsystemdetails.a("Level storage version", (Callable) (new CrashReportLevelStorageVersion(this)));
+ crashreportsystemdetails.a("Level weather", (Callable) (new CrashReportLevelWeather(this)));
+ crashreportsystemdetails.a("Level game mode", (Callable) (new CrashReportLevelGameMode(this)));
+ }
+
+ static WorldType a(WorldData worlddata) {
+ return worlddata.type;
+ }
+
+ static boolean b(WorldData worlddata) {
+ return worlddata.useMapFeatures;
+ }
+
+ static String c(WorldData worlddata) {
+ return worlddata.generatorOptions;
+ }
+
+ static int d(WorldData worlddata) {
+ return worlddata.spawnX;
+ }
+
+ static int e(WorldData worlddata) {
+ return worlddata.spawnY;
+ }
+
+ static int f(WorldData worlddata) {
+ return worlddata.spawnZ;
+ }
+
+ static long g(WorldData worlddata) {
+ return worlddata.time;
+ }
+
+ static long h(WorldData worlddata) {
+ return worlddata.dayTime;
+ }
+
+ static int i(WorldData worlddata) {
+ return worlddata.dimension;
+ }
+
+ static int j(WorldData worlddata) {
+ return worlddata.version;
+ }
+
+ static int k(WorldData worlddata) {
+ return worlddata.rainTicks;
+ }
+
+ static boolean l(WorldData worlddata) {
+ return worlddata.isRaining;
+ }
+
+ static int m(WorldData worlddata) {
+ return worlddata.thunderTicks;
+ }
+
+ static boolean n(WorldData worlddata) {
+ return worlddata.isThundering;
+ }
+
+ static EnumGamemode o(WorldData worlddata) {
+ return worlddata.gameType;
+ }
+
+ static boolean p(WorldData worlddata) {
+ return worlddata.hardcore;
+ }
+
+ static boolean q(WorldData worlddata) {
+ return worlddata.allowCommands;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenCanyon.java b/src/main/java/net/minecraft/server/WorldGenCanyon.java
new file mode 100644
index 000000000..5c68df1a0
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenCanyon.java
@@ -0,0 +1,189 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class WorldGenCanyon extends WorldGenBase {
+
+ private float[] d = new float[1024];
+
+ public WorldGenCanyon() {}
+
+ protected void a(long i, int j, int k, Block[] ablock, double d0, double d1, double d2, float f, float f1, float f2, int l, int i1, double d3) {
+ Random random = new Random(i);
+ double d4 = (double) (j * 16 + 8);
+ double d5 = (double) (k * 16 + 8);
+ float f3 = 0.0F;
+ float f4 = 0.0F;
+
+ if (i1 <= 0) {
+ int j1 = this.a * 16 - 16;
+
+ i1 = j1 - random.nextInt(j1 / 4);
+ }
+
+ boolean flag = false;
+
+ if (l == -1) {
+ l = i1 / 2;
+ flag = true;
+ }
+
+ float f5 = 1.0F;
+
+ for (int k1 = 0; k1 < 256; ++k1) {
+ if (k1 == 0 || random.nextInt(3) == 0) {
+ f5 = 1.0F + random.nextFloat() * random.nextFloat() * 1.0F;
+ }
+
+ this.d[k1] = f5 * f5;
+ }
+
+ for (; l < i1; ++l) {
+ double d6 = 1.5D + (double) (MathHelper.sin((float) l * 3.1415927F / (float) i1) * f * 1.0F);
+ double d7 = d6 * d3;
+
+ d6 *= (double) random.nextFloat() * 0.25D + 0.75D;
+ d7 *= (double) random.nextFloat() * 0.25D + 0.75D;
+ float f6 = MathHelper.cos(f2);
+ float f7 = MathHelper.sin(f2);
+
+ d0 += (double) (MathHelper.cos(f1) * f6);
+ d1 += (double) f7;
+ d2 += (double) (MathHelper.sin(f1) * f6);
+ f2 *= 0.7F;
+ f2 += f4 * 0.05F;
+ f1 += f3 * 0.05F;
+ f4 *= 0.8F;
+ f3 *= 0.5F;
+ f4 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F;
+ f3 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F;
+ if (flag || random.nextInt(4) != 0) {
+ double d8 = d0 - d4;
+ double d9 = d2 - d5;
+ double d10 = (double) (i1 - l);
+ double d11 = (double) (f + 2.0F + 16.0F);
+
+ if (d8 * d8 + d9 * d9 - d10 * d10 > d11 * d11) {
+ return;
+ }
+
+ if (d0 >= d4 - 16.0D - d6 * 2.0D && d2 >= d5 - 16.0D - d6 * 2.0D && d0 <= d4 + 16.0D + d6 * 2.0D && d2 <= d5 + 16.0D + d6 * 2.0D) {
+ int l1 = MathHelper.floor(d0 - d6) - j * 16 - 1;
+ int i2 = MathHelper.floor(d0 + d6) - j * 16 + 1;
+ int j2 = MathHelper.floor(d1 - d7) - 1;
+ int k2 = MathHelper.floor(d1 + d7) + 1;
+ int l2 = MathHelper.floor(d2 - d6) - k * 16 - 1;
+ int i3 = MathHelper.floor(d2 + d6) - k * 16 + 1;
+
+ if (l1 < 0) {
+ l1 = 0;
+ }
+
+ if (i2 > 16) {
+ i2 = 16;
+ }
+
+ if (j2 < 1) {
+ j2 = 1;
+ }
+
+ if (k2 > 248) {
+ k2 = 248;
+ }
+
+ if (l2 < 0) {
+ l2 = 0;
+ }
+
+ if (i3 > 16) {
+ i3 = 16;
+ }
+
+ boolean flag1 = false;
+
+ int j3;
+ int k3;
+
+ for (j3 = l1; !flag1 && j3 < i2; ++j3) {
+ for (int l3 = l2; !flag1 && l3 < i3; ++l3) {
+ for (int i4 = k2 + 1; !flag1 && i4 >= j2 - 1; --i4) {
+ k3 = (j3 * 16 + l3) * 256 + i4;
+ if (i4 >= 0 && i4 < 256) {
+ Block block = ablock[k3];
+
+ if (block == Blocks.WATER || block == Blocks.STATIONARY_WATER) {
+ flag1 = true;
+ }
+
+ if (i4 != j2 - 1 && j3 != l1 && j3 != i2 - 1 && l3 != l2 && l3 != i3 - 1) {
+ i4 = j2;
+ }
+ }
+ }
+ }
+ }
+
+ if (!flag1) {
+ for (j3 = l1; j3 < i2; ++j3) {
+ double d12 = ((double) (j3 + j * 16) + 0.5D - d0) / d6;
+
+ for (k3 = l2; k3 < i3; ++k3) {
+ double d13 = ((double) (k3 + k * 16) + 0.5D - d2) / d6;
+ int j4 = (j3 * 16 + k3) * 256 + k2;
+ boolean flag2 = false;
+
+ if (d12 * d12 + d13 * d13 < 1.0D) {
+ for (int k4 = k2 - 1; k4 >= j2; --k4) {
+ double d14 = ((double) k4 + 0.5D - d1) / d7;
+
+ if ((d12 * d12 + d13 * d13) * (double) this.d[k4] + d14 * d14 / 6.0D < 1.0D) {
+ Block block1 = ablock[j4];
+
+ if (block1 == Blocks.GRASS) {
+ flag2 = true;
+ }
+
+ if (block1 == Blocks.STONE || block1 == Blocks.DIRT || block1 == Blocks.GRASS) {
+ if (k4 < 10) {
+ ablock[j4] = Blocks.LAVA;
+ } else {
+ ablock[j4] = null;
+ if (flag2 && ablock[j4 - 1] == Blocks.DIRT) {
+ ablock[j4 - 1] = this.c.getBiome(j3 + j * 16, k3 + k * 16).ai;
+ }
+ }
+ }
+ }
+
+ --j4;
+ }
+ }
+ }
+ }
+
+ if (flag) {
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ protected void a(World world, int i, int j, int k, int l, Block[] ablock) {
+ if (this.b.nextInt(50) == 0) {
+ double d0 = (double) (i * 16 + this.b.nextInt(16));
+ double d1 = (double) (this.b.nextInt(this.b.nextInt(40) + 8) + 20);
+ double d2 = (double) (j * 16 + this.b.nextInt(16));
+ byte b0 = 1;
+
+ for (int i1 = 0; i1 < b0; ++i1) {
+ float f = this.b.nextFloat() * 3.1415927F * 2.0F;
+ float f1 = (this.b.nextFloat() - 0.5F) * 2.0F / 8.0F;
+ float f2 = (this.b.nextFloat() * 2.0F + this.b.nextFloat()) * 2.0F;
+
+ this.a(this.b.nextLong(), k, l, ablock, d0, d1, d2, f2, f, f1, 0, 0, 3.0D);
+ }
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenCaves.java b/src/main/java/net/minecraft/server/WorldGenCaves.java
new file mode 100644
index 000000000..707938031
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenCaves.java
@@ -0,0 +1,206 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class WorldGenCaves extends WorldGenBase {
+
+ public WorldGenCaves() {}
+
+ protected void a(long i, int j, int k, Block[] ablock, double d0, double d1, double d2) {
+ this.a(i, j, k, ablock, d0, d1, d2, 1.0F + this.b.nextFloat() * 6.0F, 0.0F, 0.0F, -1, -1, 0.5D);
+ }
+
+ protected void a(long i, int j, int k, Block[] ablock, double d0, double d1, double d2, float f, float f1, float f2, int l, int i1, double d3) {
+ double d4 = (double) (j * 16 + 8);
+ double d5 = (double) (k * 16 + 8);
+ float f3 = 0.0F;
+ float f4 = 0.0F;
+ Random random = new Random(i);
+
+ if (i1 <= 0) {
+ int j1 = this.a * 16 - 16;
+
+ i1 = j1 - random.nextInt(j1 / 4);
+ }
+
+ boolean flag = false;
+
+ if (l == -1) {
+ l = i1 / 2;
+ flag = true;
+ }
+
+ int k1 = random.nextInt(i1 / 2) + i1 / 4;
+
+ for (boolean flag1 = random.nextInt(6) == 0; l < i1; ++l) {
+ double d6 = 1.5D + (double) (MathHelper.sin((float) l * 3.1415927F / (float) i1) * f * 1.0F);
+ double d7 = d6 * d3;
+ float f5 = MathHelper.cos(f2);
+ float f6 = MathHelper.sin(f2);
+
+ d0 += (double) (MathHelper.cos(f1) * f5);
+ d1 += (double) f6;
+ d2 += (double) (MathHelper.sin(f1) * f5);
+ if (flag1) {
+ f2 *= 0.92F;
+ } else {
+ f2 *= 0.7F;
+ }
+
+ f2 += f4 * 0.1F;
+ f1 += f3 * 0.1F;
+ f4 *= 0.9F;
+ f3 *= 0.75F;
+ f4 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F;
+ f3 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F;
+ if (!flag && l == k1 && f > 1.0F && i1 > 0) {
+ this.a(random.nextLong(), j, k, ablock, d0, d1, d2, random.nextFloat() * 0.5F + 0.5F, f1 - 1.5707964F, f2 / 3.0F, l, i1, 1.0D);
+ this.a(random.nextLong(), j, k, ablock, d0, d1, d2, random.nextFloat() * 0.5F + 0.5F, f1 + 1.5707964F, f2 / 3.0F, l, i1, 1.0D);
+ return;
+ }
+
+ if (flag || random.nextInt(4) != 0) {
+ double d8 = d0 - d4;
+ double d9 = d2 - d5;
+ double d10 = (double) (i1 - l);
+ double d11 = (double) (f + 2.0F + 16.0F);
+
+ if (d8 * d8 + d9 * d9 - d10 * d10 > d11 * d11) {
+ return;
+ }
+
+ if (d0 >= d4 - 16.0D - d6 * 2.0D && d2 >= d5 - 16.0D - d6 * 2.0D && d0 <= d4 + 16.0D + d6 * 2.0D && d2 <= d5 + 16.0D + d6 * 2.0D) {
+ int l1 = MathHelper.floor(d0 - d6) - j * 16 - 1;
+ int i2 = MathHelper.floor(d0 + d6) - j * 16 + 1;
+ int j2 = MathHelper.floor(d1 - d7) - 1;
+ int k2 = MathHelper.floor(d1 + d7) + 1;
+ int l2 = MathHelper.floor(d2 - d6) - k * 16 - 1;
+ int i3 = MathHelper.floor(d2 + d6) - k * 16 + 1;
+
+ if (l1 < 0) {
+ l1 = 0;
+ }
+
+ if (i2 > 16) {
+ i2 = 16;
+ }
+
+ if (j2 < 1) {
+ j2 = 1;
+ }
+
+ if (k2 > 248) {
+ k2 = 248;
+ }
+
+ if (l2 < 0) {
+ l2 = 0;
+ }
+
+ if (i3 > 16) {
+ i3 = 16;
+ }
+
+ boolean flag2 = false;
+
+ int j3;
+ int k3;
+
+ for (j3 = l1; !flag2 && j3 < i2; ++j3) {
+ for (int l3 = l2; !flag2 && l3 < i3; ++l3) {
+ for (int i4 = k2 + 1; !flag2 && i4 >= j2 - 1; --i4) {
+ k3 = (j3 * 16 + l3) * 256 + i4;
+ if (i4 >= 0 && i4 < 256) {
+ Block block = ablock[k3];
+
+ if (block == Blocks.WATER || block == Blocks.STATIONARY_WATER) {
+ flag2 = true;
+ }
+
+ if (i4 != j2 - 1 && j3 != l1 && j3 != i2 - 1 && l3 != l2 && l3 != i3 - 1) {
+ i4 = j2;
+ }
+ }
+ }
+ }
+ }
+
+ if (!flag2) {
+ for (j3 = l1; j3 < i2; ++j3) {
+ double d12 = ((double) (j3 + j * 16) + 0.5D - d0) / d6;
+
+ for (k3 = l2; k3 < i3; ++k3) {
+ double d13 = ((double) (k3 + k * 16) + 0.5D - d2) / d6;
+ int j4 = (j3 * 16 + k3) * 256 + k2;
+ boolean flag3 = false;
+
+ if (d12 * d12 + d13 * d13 < 1.0D) {
+ for (int k4 = k2 - 1; k4 >= j2; --k4) {
+ double d14 = ((double) k4 + 0.5D - d1) / d7;
+
+ if (d14 > -0.7D && d12 * d12 + d14 * d14 + d13 * d13 < 1.0D) {
+ Block block1 = ablock[j4];
+
+ if (block1 == Blocks.GRASS) {
+ flag3 = true;
+ }
+
+ if (block1 == Blocks.STONE || block1 == Blocks.DIRT || block1 == Blocks.GRASS) {
+ if (k4 < 10) {
+ ablock[j4] = Blocks.STATIONARY_LAVA;
+ } else {
+ ablock[j4] = null;
+ if (flag3 && ablock[j4 - 1] == Blocks.DIRT) {
+ ablock[j4 - 1] = this.c.getBiome(j3 + j * 16, k3 + k * 16).ai;
+ }
+ }
+ }
+ }
+
+ --j4;
+ }
+ }
+ }
+ }
+
+ if (flag) {
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ protected void a(World world, int i, int j, int k, int l, Block[] ablock) {
+ int i1 = this.b.nextInt(this.b.nextInt(this.b.nextInt(15) + 1) + 1);
+
+ if (this.b.nextInt(7) != 0) {
+ i1 = 0;
+ }
+
+ for (int j1 = 0; j1 < i1; ++j1) {
+ double d0 = (double) (i * 16 + this.b.nextInt(16));
+ double d1 = (double) this.b.nextInt(this.b.nextInt(120) + 8);
+ double d2 = (double) (j * 16 + this.b.nextInt(16));
+ int k1 = 1;
+
+ if (this.b.nextInt(4) == 0) {
+ this.a(this.b.nextLong(), k, l, ablock, d0, d1, d2);
+ k1 += this.b.nextInt(4);
+ }
+
+ for (int l1 = 0; l1 < k1; ++l1) {
+ float f = this.b.nextFloat() * 3.1415927F * 2.0F;
+ float f1 = (this.b.nextFloat() - 0.5F) * 2.0F / 8.0F;
+ float f2 = this.b.nextFloat() * 2.0F + this.b.nextFloat();
+
+ if (this.b.nextInt(10) == 0) {
+ f2 *= this.b.nextFloat() * this.b.nextFloat() * 3.0F + 1.0F;
+ }
+
+ this.a(this.b.nextLong(), k, l, ablock, d0, d1, d2, f2, f, f1, 0, 0, 1.0D);
+ }
+ }
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldGenMinable.java b/src/main/java/net/minecraft/server/WorldGenMinable.java
new file mode 100644
index 000000000..1d58f3e56
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldGenMinable.java
@@ -0,0 +1,67 @@
+package net.minecraft.server;
+
+import java.util.Random;
+
+public class WorldGenMinable extends WorldGenerator {
+
+ private Block a;
+ private int b;
+ private Block c;
+
+ public WorldGenMinable(Block block, int i) {
+ this(block, i, Blocks.STONE);
+ }
+
+ public WorldGenMinable(Block block, int i, Block block1) {
+ this.a = block;
+ this.b = i;
+ this.c = block1;
+ }
+
+ public boolean generate(World world, Random random, int i, int j, int k) {
+ float f = random.nextFloat() * 3.1415927F;
+ double d0 = (double) ((float) (i + 8) + MathHelper.sin(f) * (float) this.b / 8.0F);
+ double d1 = (double) ((float) (i + 8) - MathHelper.sin(f) * (float) this.b / 8.0F);
+ double d2 = (double) ((float) (k + 8) + MathHelper.cos(f) * (float) this.b / 8.0F);
+ double d3 = (double) ((float) (k + 8) - MathHelper.cos(f) * (float) this.b / 8.0F);
+ double d4 = (double) (j + random.nextInt(3) - 2);
+ double d5 = (double) (j + random.nextInt(3) - 2);
+
+ for (int l = 0; l <= this.b; ++l) {
+ double d6 = d0 + (d1 - d0) * (double) l / (double) this.b;
+ double d7 = d4 + (d5 - d4) * (double) l / (double) this.b;
+ double d8 = d2 + (d3 - d2) * (double) l / (double) this.b;
+ double d9 = random.nextDouble() * (double) this.b / 16.0D;
+ double d10 = (double) (MathHelper.sin((float) l * 3.1415927F / (float) this.b) + 1.0F) * d9 + 1.0D;
+ double d11 = (double) (MathHelper.sin((float) l * 3.1415927F / (float) this.b) + 1.0F) * d9 + 1.0D;
+ int i1 = MathHelper.floor(d6 - d10 / 2.0D);
+ int j1 = MathHelper.floor(d7 - d11 / 2.0D);
+ int k1 = MathHelper.floor(d8 - d10 / 2.0D);
+ int l1 = MathHelper.floor(d6 + d10 / 2.0D);
+ int i2 = MathHelper.floor(d7 + d11 / 2.0D);
+ int j2 = MathHelper.floor(d8 + d10 / 2.0D);
+
+ for (int k2 = i1; k2 <= l1; ++k2) {
+ double d12 = ((double) k2 + 0.5D - d6) / (d10 / 2.0D);
+
+ if (d12 * d12 < 1.0D) {
+ for (int l2 = j1; l2 <= i2; ++l2) {
+ double d13 = ((double) l2 + 0.5D - d7) / (d11 / 2.0D);
+
+ if (d12 * d12 + d13 * d13 < 1.0D) {
+ for (int i3 = k1; i3 <= j2; ++i3) {
+ double d14 = ((double) i3 + 0.5D - d8) / (d10 / 2.0D);
+
+ if (d12 * d12 + d13 * d13 + d14 * d14 < 1.0D && world.getType(k2, l2, i3) == this.c) {
+ world.setTypeAndData(k2, l2, i3, this.a, 0, 2);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/src/main/java/net/minecraft/server/WorldProvider.java b/src/main/java/net/minecraft/server/WorldProvider.java
new file mode 100644
index 000000000..bd9156552
--- /dev/null
+++ b/src/main/java/net/minecraft/server/WorldProvider.java
@@ -0,0 +1,99 @@
+package net.minecraft.server;
+
+public abstract class WorldProvider {
+
+ public static final float[] a = new float[] { 1.0F, 0.75F, 0.5F, 0.25F, 0.0F, 0.25F, 0.5F, 0.75F};
+ public World b;
+ public WorldType type;
+ public String d;
+ public WorldChunkManager e;
+ public boolean f;
+ public boolean g;
+ public float[] h = new float[16];
+ public int dimension;
+ private float[] j = new float[4];
+
+ public WorldProvider() {}
+
+ public final void a(World world) {
+ this.b = world;
+ this.type = world.getWorldData().getType();
+ this.d = world.getWorldData().getGeneratorOptions();
+ this.b();
+ this.a();
+ }
+
+ protected void a() {
+ float f = 0.0F;
+
+ for (int i = 0; i <= 15; ++i) {
+ float f1 = 1.0F - (float) i / 15.0F;
+
+ this.h[i] = (1.0F - f1) / (f1 * 3.0F + 1.0F) * (1.0F - f) + f;
+ }
+ }
+
+ protected void b() {
+ if (this.b.getWorldData().getType() == WorldType.FLAT) {
+ WorldGenFlatInfo worldgenflatinfo = WorldGenFlatInfo.a(this.b.getWorldData().getGeneratorOptions());
+
+ this.e = new WorldChunkManagerHell(BiomeBase.getBiome(worldgenflatinfo.a()), 0.5F);
+ } else {
+ this.e = new WorldChunkManager(this.b);
+ }
+ }
+
+ public IChunkProvider getChunkProvider() {
+ return (IChunkProvider) (this.type == WorldType.FLAT ? new ChunkProviderFlat(this.b, this.b.getSeed(), this.b.getWorldData().shouldGenerateMapFeatures(), this.d) : new ChunkProviderGenerate(this.b, this.b.getSeed(), this.b.getWorldData().shouldGenerateMapFeatures()));
+ }
+
+ public boolean canSpawn(int i, int j) {
+ return this.b.b(i, j) == Blocks.GRASS;
+ }
+
+ public float a(long i, float f) {
+ int j = (int) (i % 24000L);
+ float f1 = ((float) j + f) / 24000.0F - 0.25F;
+
+ if (f1 < 0.0F) {
+ ++f1;
+ }
+
+ if (f1 > 1.0F) {
+ --f1;
+ }
+
+ float f2 = f1;
+
+ f1 = 1.0F - (float) ((Math.cos((double) f1 * 3.141592653589793D) + 1.0D) / 2.0D);
+ f1 = f2 + (f1 - f2) / 3.0F;
+ return f1;
+ }
+
+ public int a(long i) {
+ return (int) (i / 24000L % 8L + 8L) % 8;
+ }
+
+ public boolean d() {
+ return true;
+ }
+
+ public boolean e() {
+ return true;
+ }
+
+ public static WorldProvider byDimension(int i) {
+ return (WorldProvider) (i == -1 ? new WorldProviderHell() : (i == 0 ? new WorldProviderNormal() : (i == 1 ? new WorldProviderTheEnd() : null)));
+ }
+
+ public ChunkCoordinates h() {
+ return null;
+ }
+
+ public int getSeaLevel() {
+ return this.type == WorldType.FLAT ? 4 : 64;
+ }
+
+ public abstract String getName();
+
+}
--
2.15.2 (Apple Git-101.1)
Reference in New Issue Copy Permalink