net.minecraft.server.StructurePiece Maven / Gradle / Ivy

Go to download
package net.minecraft.server;

import java.util.Iterator;
import java.util.List;
import java.util.Random;

public abstract class StructurePiece {
	
	protected StructureBoundingBox l;
	protected EnumDirection m;
	protected int n;
	
	public StructurePiece() {
	}
	
	protected StructurePiece(int i) {
		this.n = i;
	}
	
	public static StructurePiece a(List list, StructureBoundingBox structureboundingbox) {
		Iterator iterator = list.iterator();
		
		StructurePiece structurepiece;
		
		do {
			if (!iterator.hasNext()) {
				return null;
			}
			
			structurepiece = (StructurePiece) iterator.next();
		} while (structurepiece.c() == null || !structurepiece.c().a(structureboundingbox));
		
		return structurepiece;
	}
	
	public NBTTagCompound b() {
		NBTTagCompound nbttagcompound = new NBTTagCompound();
		
		nbttagcompound.setString("id", WorldGenFactory.a(this));
		nbttagcompound.set("BB", this.l.g());
		nbttagcompound.setInt("O", this.m == null ? -1 : this.m.b());
		nbttagcompound.setInt("GD", this.n);
		this.a(nbttagcompound);
		return nbttagcompound;
	}
	
	protected abstract void a(NBTTagCompound nbttagcompound);
	
	public void a(World world, NBTTagCompound nbttagcompound) {
		if (nbttagcompound.hasKey("BB")) {
			this.l = new StructureBoundingBox(nbttagcompound.getIntArray("BB"));
		}
		
		int i = nbttagcompound.getInt("O");
		
		this.m = i == -1 ? null : EnumDirection.fromType2(i);
		this.n = nbttagcompound.getInt("GD");
		this.b(nbttagcompound);
	}
	
	protected abstract void b(NBTTagCompound nbttagcompound);
	
	public void a(StructurePiece structurepiece, List list, Random random) {
	}
	
	public abstract boolean a(World world, Random random, StructureBoundingBox structureboundingbox);
	
	public StructureBoundingBox c() {
		return this.l;
	}
	
	public int d() {
		return this.n;
	}
	
	public BlockPosition a() {
		return new BlockPosition(this.l.f());
	}
	
	protected boolean a(World world, StructureBoundingBox structureboundingbox) {
		int i = Math.max(this.l.a - 1, structureboundingbox.a);
		int j = Math.max(this.l.b - 1, structureboundingbox.b);
		int k = Math.max(this.l.c - 1, structureboundingbox.c);
		int l = Math.min(this.l.d + 1, structureboundingbox.d);
		int i1 = Math.min(this.l.e + 1, structureboundingbox.e);
		int j1 = Math.min(this.l.f + 1, structureboundingbox.f);
		BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
		
		int k1;
		int l1;
		
		for (k1 = i; k1 <= l; ++k1) {
			for (l1 = k; l1 <= j1; ++l1) {
				if (world.getType(blockposition_mutableblockposition.c(k1, j, l1)).getBlock().getMaterial().isLiquid()) {
					return true;
				}
				
				if (world.getType(blockposition_mutableblockposition.c(k1, i1, l1)).getBlock().getMaterial().isLiquid()) {
					return true;
				}
			}
		}
		
		for (k1 = i; k1 <= l; ++k1) {
			for (l1 = j; l1 <= i1; ++l1) {
				if (world.getType(blockposition_mutableblockposition.c(k1, l1, k)).getBlock().getMaterial().isLiquid()) {
					return true;
				}
				
				if (world.getType(blockposition_mutableblockposition.c(k1, l1, j1)).getBlock().getMaterial().isLiquid()) {
					return true;
				}
			}
		}
		
		for (k1 = k; k1 <= j1; ++k1) {
			for (l1 = j; l1 <= i1; ++l1) {
				if (world.getType(blockposition_mutableblockposition.c(i, l1, k1)).getBlock().getMaterial().isLiquid()) {
					return true;
				}
				
				if (world.getType(blockposition_mutableblockposition.c(l, l1, k1)).getBlock().getMaterial().isLiquid()) {
					return true;
				}
			}
		}
		
		return false;
	}
	
	protected int a(int i, int j) {
		if (this.m == null) {
			return i;
		} else {
			switch (SyntheticClass_1.a[this.m.ordinal()]) {
				case 1:
				case 2:
					return this.l.a + i;
				
				case 3:
					return this.l.d - j;
				
				case 4:
					return this.l.a + j;
				
				default:
					return i;
			}
		}
	}
	
	protected int d(int i) {
		return this.m == null ? i : i + this.l.b;
	}
	
	protected int b(int i, int j) {
		if (this.m == null) {
			return j;
		} else {
			switch (SyntheticClass_1.a[this.m.ordinal()]) {
				case 1:
					return this.l.f - j;
				
				case 2:
					return this.l.c + j;
				
				case 3:
				case 4:
					return this.l.c + i;
				
				default:
					return j;
			}
		}
	}
	
	protected int a(Block block, int i) {
		if (block == Blocks.RAIL) {
			if (this.m == EnumDirection.WEST || this.m == EnumDirection.EAST) {
				if (i == 1) {
					return 0;
				}
				
				return 1;
			}
		} else if (block instanceof BlockDoor) {
			if (this.m == EnumDirection.SOUTH) {
				if (i == 0) {
					return 2;
				}
				
				if (i == 2) {
					return 0;
				}
			} else {
				if (this.m == EnumDirection.WEST) {
					return i + 1 & 3;
				}
				
				if (this.m == EnumDirection.EAST) {
					return i + 3 & 3;
				}
			}
		} else if (block != Blocks.STONE_STAIRS && block != Blocks.OAK_STAIRS && block != Blocks.NETHER_BRICK_STAIRS && block != Blocks.STONE_BRICK_STAIRS && block != Blocks.SANDSTONE_STAIRS) {
			if (block == Blocks.LADDER) {
				if (this.m == EnumDirection.SOUTH) {
					if (i == EnumDirection.NORTH.a()) {
						return EnumDirection.SOUTH.a();
					}
					
					if (i == EnumDirection.SOUTH.a()) {
						return EnumDirection.NORTH.a();
					}
				} else if (this.m == EnumDirection.WEST) {
					if (i == EnumDirection.NORTH.a()) {
						return EnumDirection.WEST.a();
					}
					
					if (i == EnumDirection.SOUTH.a()) {
						return EnumDirection.EAST.a();
					}
					
					if (i == EnumDirection.WEST.a()) {
						return EnumDirection.NORTH.a();
					}
					
					if (i == EnumDirection.EAST.a()) {
						return EnumDirection.SOUTH.a();
					}
				} else if (this.m == EnumDirection.EAST) {
					if (i == EnumDirection.NORTH.a()) {
						return EnumDirection.EAST.a();
					}
					
					if (i == EnumDirection.SOUTH.a()) {
						return EnumDirection.WEST.a();
					}
					
					if (i == EnumDirection.WEST.a()) {
						return EnumDirection.NORTH.a();
					}
					
					if (i == EnumDirection.EAST.a()) {
						return EnumDirection.SOUTH.a();
					}
				}
			} else if (block == Blocks.STONE_BUTTON) {
				if (this.m == EnumDirection.SOUTH) {
					if (i == 3) {
						return 4;
					}
					
					if (i == 4) {
						return 3;
					}
				} else if (this.m == EnumDirection.WEST) {
					if (i == 3) {
						return 1;
					}
					
					if (i == 4) {
						return 2;
					}
					
					if (i == 2) {
						return 3;
					}
					
					if (i == 1) {
						return 4;
					}
				} else if (this.m == EnumDirection.EAST) {
					if (i == 3) {
						return 2;
					}
					
					if (i == 4) {
						return 1;
					}
					
					if (i == 2) {
						return 3;
					}
					
					if (i == 1) {
						return 4;
					}
				}
			} else if (block != Blocks.TRIPWIRE_HOOK && !(block instanceof BlockDirectional)) {
				if (block == Blocks.PISTON || block == Blocks.STICKY_PISTON || block == Blocks.LEVER || block == Blocks.DISPENSER) {
					if (this.m == EnumDirection.SOUTH) {
						if (i == EnumDirection.NORTH.a() || i == EnumDirection.SOUTH.a()) {
							return EnumDirection.fromType1(i).opposite().a();
						}
					} else if (this.m == EnumDirection.WEST) {
						if (i == EnumDirection.NORTH.a()) {
							return EnumDirection.WEST.a();
						}
						
						if (i == EnumDirection.SOUTH.a()) {
							return EnumDirection.EAST.a();
						}
						
						if (i == EnumDirection.WEST.a()) {
							return EnumDirection.NORTH.a();
						}
						
						if (i == EnumDirection.EAST.a()) {
							return EnumDirection.SOUTH.a();
						}
					} else if (this.m == EnumDirection.EAST) {
						if (i == EnumDirection.NORTH.a()) {
							return EnumDirection.EAST.a();
						}
						
						if (i == EnumDirection.SOUTH.a()) {
							return EnumDirection.WEST.a();
						}
						
						if (i == EnumDirection.WEST.a()) {
							return EnumDirection.NORTH.a();
						}
						
						if (i == EnumDirection.EAST.a()) {
							return EnumDirection.SOUTH.a();
						}
					}
				}
			} else {
				EnumDirection enumdirection = EnumDirection.fromType2(i);
				
				if (this.m == EnumDirection.SOUTH) {
					if (enumdirection == EnumDirection.SOUTH || enumdirection == EnumDirection.NORTH) {
						return enumdirection.opposite().b();
					}
				} else if (this.m == EnumDirection.WEST) {
					if (enumdirection == EnumDirection.NORTH) {
						return EnumDirection.WEST.b();
					}
					
					if (enumdirection == EnumDirection.SOUTH) {
						return EnumDirection.EAST.b();
					}
					
					if (enumdirection == EnumDirection.WEST) {
						return EnumDirection.NORTH.b();
					}
					
					if (enumdirection == EnumDirection.EAST) {
						return EnumDirection.SOUTH.b();
					}
				} else if (this.m == EnumDirection.EAST) {
					if (enumdirection == EnumDirection.NORTH) {
						return EnumDirection.EAST.b();
					}
					
					if (enumdirection == EnumDirection.SOUTH) {
						return EnumDirection.WEST.b();
					}
					
					if (enumdirection == EnumDirection.WEST) {
						return EnumDirection.NORTH.b();
					}
					
					if (enumdirection == EnumDirection.EAST) {
						return EnumDirection.SOUTH.b();
					}
				}
			}
		} else if (this.m == EnumDirection.SOUTH) {
			if (i == 2) {
				return 3;
			}
			
			if (i == 3) {
				return 2;
			}
		} else if (this.m == EnumDirection.WEST) {
			if (i == 0) {
				return 2;
			}
			
			if (i == 1) {
				return 3;
			}
			
			if (i == 2) {
				return 0;
			}
			
			if (i == 3) {
				return 1;
			}
		} else if (this.m == EnumDirection.EAST) {
			if (i == 0) {
				return 2;
			}
			
			if (i == 1) {
				return 3;
			}
			
			if (i == 2) {
				return 1;
			}
			
			if (i == 3) {
				return 0;
			}
		}
		
		return i;
	}
	
	protected void a(World world, IBlockData iblockdata, int i, int j, int k, StructureBoundingBox structureboundingbox) {
		BlockPosition blockposition = new BlockPosition(this.a(i, k), this.d(j), this.b(i, k));
		
		if (structureboundingbox.b(blockposition)) {
			world.setTypeAndData(blockposition, iblockdata, 2);
		}
	}
	
	protected IBlockData a(World world, int i, int j, int k, StructureBoundingBox structureboundingbox) {
		int l = this.a(i, k);
		int i1 = this.d(j);
		int j1 = this.b(i, k);
		BlockPosition blockposition = new BlockPosition(l, i1, j1);
		
		return !structureboundingbox.b(blockposition) ? Blocks.AIR.getBlockData() : world.getType(blockposition);
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, int i, int j, int k, int l, int i1, int j1) {
		for (int k1 = j; k1 <= i1; ++k1) {
			for (int l1 = i; l1 <= l; ++l1) {
				for (int i2 = k; i2 <= j1; ++i2) {
					this.a(world, Blocks.AIR.getBlockData(), l1, k1, i2, structureboundingbox);
				}
			}
		}
		
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, int i, int j, int k, int l, int i1, int j1, IBlockData iblockdata, IBlockData iblockdata1, boolean flag) {
		for (int k1 = j; k1 <= i1; ++k1) {
			for (int l1 = i; l1 <= l; ++l1) {
				for (int i2 = k; i2 <= j1; ++i2) {
					if (!flag || this.a(world, l1, k1, i2, structureboundingbox).getBlock().getMaterial() != Material.AIR) {
						if (k1 != j && k1 != i1 && l1 != i && l1 != l && i2 != k && i2 != j1) {
							this.a(world, iblockdata1, l1, k1, i2, structureboundingbox);
						} else {
							this.a(world, iblockdata, l1, k1, i2, structureboundingbox);
						}
					}
				}
			}
		}
		
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, int i, int j, int k, int l, int i1, int j1, boolean flag, Random random, StructurePieceBlockSelector structurepiece_structurepieceblockselector) {
		for (int k1 = j; k1 <= i1; ++k1) {
			for (int l1 = i; l1 <= l; ++l1) {
				for (int i2 = k; i2 <= j1; ++i2) {
					if (!flag || this.a(world, l1, k1, i2, structureboundingbox).getBlock().getMaterial() != Material.AIR) {
						structurepiece_structurepieceblockselector.a(random, l1, k1, i2, k1 == j || k1 == i1 || l1 == i || l1 == l || i2 == k || i2 == j1);
						this.a(world, structurepiece_structurepieceblockselector.a(), l1, k1, i2, structureboundingbox);
					}
				}
			}
		}
		
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, Random random, float f, int i, int j, int k, int l, int i1, int j1, IBlockData iblockdata, IBlockData iblockdata1, boolean flag) {
		for (int k1 = j; k1 <= i1; ++k1) {
			for (int l1 = i; l1 <= l; ++l1) {
				for (int i2 = k; i2 <= j1; ++i2) {
					if (random.nextFloat() <= f && (!flag || this.a(world, l1, k1, i2, structureboundingbox).getBlock().getMaterial() != Material.AIR)) {
						if (k1 != j && k1 != i1 && l1 != i && l1 != l && i2 != k && i2 != j1) {
							this.a(world, iblockdata1, l1, k1, i2, structureboundingbox);
						} else {
							this.a(world, iblockdata, l1, k1, i2, structureboundingbox);
						}
					}
				}
			}
		}
		
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, Random random, float f, int i, int j, int k, IBlockData iblockdata) {
		if (random.nextFloat() < f) {
			this.a(world, iblockdata, i, j, k, structureboundingbox);
		}
		
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, int i, int j, int k, int l, int i1, int j1, IBlockData iblockdata, boolean flag) {
		float f = (float) (l - i + 1);
		float f1 = (float) (i1 - j + 1);
		float f2 = (float) (j1 - k + 1);
		float f3 = (float) i + f / 2.0F;
		float f4 = (float) k + f2 / 2.0F;
		
		for (int k1 = j; k1 <= i1; ++k1) {
			float f5 = (float) (k1 - j) / f1;
			
			for (int l1 = i; l1 <= l; ++l1) {
				float f6 = ((float) l1 - f3) / (f * 0.5F);
				
				for (int i2 = k; i2 <= j1; ++i2) {
					float f7 = ((float) i2 - f4) / (f2 * 0.5F);
					
					if (!flag || this.a(world, l1, k1, i2, structureboundingbox).getBlock().getMaterial() != Material.AIR) {
						float f8 = f6 * f6 + f5 * f5 + f7 * f7;
						
						if (f8 <= 1.05F) {
							this.a(world, iblockdata, l1, k1, i2, structureboundingbox);
						}
					}
				}
			}
		}
		
	}
	
	protected void b(World world, int i, int j, int k, StructureBoundingBox structureboundingbox) {
		BlockPosition blockposition = new BlockPosition(this.a(i, k), this.d(j), this.b(i, k));
		
		if (structureboundingbox.b(blockposition)) {
			while (!world.isEmpty(blockposition) && blockposition.getY() < 255) {
				world.setTypeAndData(blockposition, Blocks.AIR.getBlockData(), 2);
				blockposition = blockposition.up();
			}
			
		}
	}
	
	protected void b(World world, IBlockData iblockdata, int i, int j, int k, StructureBoundingBox structureboundingbox) {
		int l = this.a(i, k);
		int i1 = this.d(j);
		int j1 = this.b(i, k);
		
		if (structureboundingbox.b(new BlockPosition(l, i1, j1))) {
			while ((world.isEmpty(new BlockPosition(l, i1, j1)) || world.getType(new BlockPosition(l, i1, j1)).getBlock().getMaterial().isLiquid()) && i1 > 1) {
				world.setTypeAndData(new BlockPosition(l, i1, j1), iblockdata, 2);
				--i1;
			}
			
		}
	}
	
	protected boolean a(World world, StructureBoundingBox structureboundingbox, Random random, int i, int j, int k, List list, int l) {
		BlockPosition blockposition = new BlockPosition(this.a(i, k), this.d(j), this.b(i, k));
		
		if (structureboundingbox.b(blockposition) && world.getType(blockposition).getBlock() != Blocks.CHEST) {
			IBlockData iblockdata = Blocks.CHEST.getBlockData();
			
			world.setTypeAndData(blockposition, Blocks.CHEST.f(world, blockposition, iblockdata), 2);
			TileEntity tileentity = world.getTileEntity(blockposition);
			
			if (tileentity instanceof TileEntityChest) {
				StructurePieceTreasure.a(random, list, (IInventory) tileentity, l);
			}
			
			return true;
		} else {
			return false;
		}
	}
	
	protected boolean a(World world, StructureBoundingBox structureboundingbox, Random random, int i, int j, int k, int l, List list, int i1) {
		BlockPosition blockposition = new BlockPosition(this.a(i, k), this.d(j), this.b(i, k));
		
		if (structureboundingbox.b(blockposition) && world.getType(blockposition).getBlock() != Blocks.DISPENSER) {
			world.setTypeAndData(blockposition, Blocks.DISPENSER.fromLegacyData(this.a(Blocks.DISPENSER, l)), 2);
			TileEntity tileentity = world.getTileEntity(blockposition);
			
			if (tileentity instanceof TileEntityDispenser) {
				StructurePieceTreasure.a(random, list, (TileEntityDispenser) tileentity, i1);
			}
			
			return true;
		} else {
			return false;
		}
	}
	
	protected void a(World world, StructureBoundingBox structureboundingbox, Random random, int i, int j, int k, EnumDirection enumdirection) {
		BlockPosition blockposition = new BlockPosition(this.a(i, k), this.d(j), this.b(i, k));
		
		if (structureboundingbox.b(blockposition)) {
			ItemDoor.a(world, blockposition, enumdirection.f(), Blocks.WOODEN_DOOR);
		}
		
	}
	
	public void a(int i, int j, int k) {
		this.l.a(i, j, k);
	}
	
	static class SyntheticClass_1 {
		
		static final int[] a = new int[EnumDirection.values().length];
		
		static {
			try {
				SyntheticClass_1.a[EnumDirection.NORTH.ordinal()] = 1;
			} catch (NoSuchFieldError nosuchfielderror) {
      }
			
			try {
				SyntheticClass_1.a[EnumDirection.SOUTH.ordinal()] = 2;
			} catch (NoSuchFieldError nosuchfielderror1) {
      }
			
			try {
				SyntheticClass_1.a[EnumDirection.WEST.ordinal()] = 3;
			} catch (NoSuchFieldError nosuchfielderror2) {
      }
			
			try {
				SyntheticClass_1.a[EnumDirection.EAST.ordinal()] = 4;
			} catch (NoSuchFieldError nosuchfielderror3) {
      }
			
		}
	}
	
	public abstract static class StructurePieceBlockSelector {
		
		protected IBlockData a;
		
		protected StructurePieceBlockSelector() {
			this.a = Blocks.AIR.getBlockData();
		}
		
		public abstract void a(Random random, int i, int j, int k, boolean flag);
		
		public IBlockData a() {
			return this.a;
		}
	}
}