Move sources and resources

6 files changed, 704 insertions, 0 deletions

diff --git a/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldGround.java b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldGround.java
new file mode 100644
index 0000000000..f68c97b3c5
--- /dev/null
+++ b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldGround.java
@@ -0,0 +1,25 @@
+package gtPlusPlus.everglades.block;
+
+import cpw.mods.fml.common.registry.LanguageRegistry;
+
+import net.minecraft.block.BlockGrass;
+
+import gtPlusPlus.api.interfaces.ITileTooltip;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+
+public class BlockDarkWorldGround extends BlockGrass implements ITileTooltip{
+
+	public BlockDarkWorldGround() {
+		this.setCreativeTab(AddToCreativeTab.tabBOP);
+		this.setBlockName("blockDarkWorldGround");
+		this.setHardness(1.0F);
+		this.setBlockTextureName("minecraft" + ":" + "grass");
+		LanguageRegistry.addName(this, "Unstable Earth");
+	}
+
+	@Override
+	public int getTooltipID() {
+		return 2;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldPollutedDirt.java b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldPollutedDirt.java
new file mode 100644
index 0000000000..a1fcc588b5
--- /dev/null
+++ b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldPollutedDirt.java
@@ -0,0 +1,74 @@
+package gtPlusPlus.everglades.block;
+
+import cpw.mods.fml.common.registry.LanguageRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.block.BlockDirt;
+import net.minecraft.world.ColorizerGrass;
+import net.minecraft.world.IBlockAccess;
+
+import gtPlusPlus.api.interfaces.ITileTooltip;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+
+public class BlockDarkWorldPollutedDirt extends BlockDirt implements ITileTooltip{
+
+	public BlockDarkWorldPollutedDirt() {
+		this.setCreativeTab(AddToCreativeTab.tabBOP);
+		this.setBlockName("blockDarkWorldGround2");
+		this.setHardness(0.5F);
+		this.setBlockTextureName("minecraft" + ":" + "dirt");
+		LanguageRegistry.addName(this, "Polluted Soil");
+	}
+	
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getBlockColor()
+	{
+		double d0 = 0.5D;
+		double d1 = 1.0D;
+		return ColorizerGrass.getGrassColor(d0, d1);
+	}
+
+	/**
+	 * Returns the color this block should be rendered. Used by leaves.
+	 */
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int getRenderColor(int p_149741_1_)
+	{
+		return this.getBlockColor();
+	}
+
+	/**
+	 * Returns a integer with hex for 0xrrggbb with this color multiplied against the blocks color. Note only called
+	 * when first determining what to render.
+	 */
+	@Override
+	@SideOnly(Side.CLIENT)
+	public int colorMultiplier(IBlockAccess p_149720_1_, int p_149720_2_, int p_149720_3_, int p_149720_4_)
+	{
+		int l = 0;
+		int i1 = 0;
+		int j1 = 0;
+
+		for (int k1 = -1; k1 <= 1; ++k1)
+		{
+			for (int l1 = -1; l1 <= 1; ++l1)
+			{
+				int i2 = p_149720_1_.getBiomeGenForCoords(p_149720_2_ + l1, p_149720_4_ + k1).getBiomeGrassColor(p_149720_2_ + l1, p_149720_3_, p_149720_4_ + k1);
+				l += (i2 & 16711680) >> 16;
+			i1 += (i2 & 65280) >> 8;
+			j1 += i2 & 255;
+			}
+		}
+
+		return (l / 9 & 255) << 16 | (i1 / 9 & 255) << 8 | j1 / 9 & 255;
+	}
+
+	@Override
+	public int getTooltipID() {
+		return 3;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldPortalFrame.java b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldPortalFrame.java
new file mode 100644
index 0000000000..09dea46ab1
--- /dev/null
+++ b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldPortalFrame.java
@@ -0,0 +1,30 @@
+package gtPlusPlus.everglades.block;
+
+import cpw.mods.fml.common.registry.LanguageRegistry;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+
+import gtPlusPlus.api.interfaces.ITileTooltip;
+import gtPlusPlus.core.creative.AddToCreativeTab;
+import gtPlusPlus.core.lib.CORE;
+
+public class BlockDarkWorldPortalFrame extends Block implements ITileTooltip{
+
+	public BlockDarkWorldPortalFrame() {
+		super(Material.iron);
+		this.setCreativeTab(AddToCreativeTab.tabBOP);
+		this.setBlockName("blockDarkWorldPortalFrame");
+		this.setHardness(3.0F);
+		this.setLightLevel(0.5F);
+		this.setBlockTextureName(CORE.MODID + ":" + "metro/TEXTURE_TECH_PANEL_A");
+		LanguageRegistry.addName(this, "Containment Frame");
+
+	}
+
+	@Override
+	public int getTooltipID() {
+		return 0;
+	}
+
+}
diff --git a/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldSludgeFluid.java b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldSludgeFluid.java
new file mode 100644
index 0000000000..3c0445c86d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/everglades/block/BlockDarkWorldSludgeFluid.java
@@ -0,0 +1,101 @@
+package gtPlusPlus.everglades.block;
+
+import net.minecraft.block.material.MapColor;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.material.MaterialLiquid;
+
+import net.minecraftforge.fluids.Fluid;
+
+public class BlockDarkWorldSludgeFluid extends Fluid {
+
+
+	public static final Material SLUDGE = new MaterialLiquid(MapColor.dirtColor);
+
+	protected static int mapColor = 0xFFFFFFFF;
+	protected static float overlayAlpha = 0.2F;
+	//protected static SoundEvent emptySound = SoundEvents.ITEM_BUCKET_EMPTY;
+	//protected static SoundEvent fillSound = SoundEvents.ITEM_BUCKET_FILL;
+	protected static Material material = SLUDGE;
+
+
+	public BlockDarkWorldSludgeFluid(String fluidName, int rgbColour) {
+		this(fluidName, rgbColour, null);
+	}
+	
+	public BlockDarkWorldSludgeFluid(String fluidName, int rgbColour, Float overlayAlpha) {
+		super(fluidName);
+		setColor(rgbColour);
+		if (overlayAlpha != null){
+			setAlpha(overlayAlpha.floatValue());			
+		}
+		else {
+			setAlpha(0);
+		}
+	}
+
+	@Override
+	public int getColor()
+	{
+		return mapColor;
+	}
+
+	public BlockDarkWorldSludgeFluid setColor(int parColor)
+	{
+		mapColor = parColor;
+		return this;
+	}
+
+	public float getAlpha()
+	{
+		return overlayAlpha;
+	}
+
+	public BlockDarkWorldSludgeFluid setAlpha(float parOverlayAlpha)
+	{
+		overlayAlpha = parOverlayAlpha;
+		return this;
+	}
+
+	/*public blockDarkWorldSludgeFluid setEmptySound(SoundEvent parSound)
+	{
+		emptySound = parSound;
+		return this;
+	}
+
+	public SoundEvent getEmptySound()
+	{
+		return emptySound;
+	}
+
+	@Override
+	public blockDarkWorldSludgeFluid setFillSound(SoundEvent parSound)
+	{
+		fillSound = parSound;
+		return this;
+	}
+
+	@Override
+	public SoundEvent getFillSound()
+	{
+		return fillSound;
+	}*/
+
+	public BlockDarkWorldSludgeFluid setMaterial(Material parMaterial)
+	{
+		material = parMaterial;
+		return this;
+	}
+
+	public Material getMaterial()
+	{
+		return material;
+	}
+
+	/*@Override
+	public boolean doesVaporize(FluidStack fluidStack)
+	{
+		if (block == null)
+			return false;
+		return block.getDefaultState().getMaterial() == getMaterial();
+	}*/
+}
diff --git a/src/main/java/gtPlusPlus/everglades/block/BlockEvergladesPortal.java b/src/main/java/gtPlusPlus/everglades/block/BlockEvergladesPortal.java
new file mode 100644
index 0000000000..e64968888d
--- /dev/null
+++ b/src/main/java/gtPlusPlus/everglades/block/BlockEvergladesPortal.java
@@ -0,0 +1,403 @@
+package gtPlusPlus.everglades.block;
+
+import java.util.Random;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockBreakable;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IIconRegister;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+
+import gtPlusPlus.api.interfaces.ITileTooltip;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.everglades.dimension.Dimension_Everglades;
+import gtPlusPlus.everglades.world.TeleporterDimensionMod;
+
+public class BlockEvergladesPortal extends BlockBreakable implements ITileTooltip{
+	IIcon gor = null, dol = null, st1 = null, st2 = null, st3 = null, st4 = null;
+
+	public BlockEvergladesPortal() {
+		super("portal", Material.portal, false);
+		this.setTickRandomly(true);
+		this.setHardness(-1.0F);
+		this.setLightLevel(0.75F);
+		this.setCreativeTab(CreativeTabs.tabBlock);
+		this.setBlockName("blockDarkWorldPortal");
+
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public IIcon getIcon(int i, int par2) {
+
+		if (i == 0)
+			return gor;
+
+		else if (i == 1)
+			return dol;
+
+		else if (i == 2)
+			return st1;
+
+		else if (i == 3)
+			return st2;
+
+		else if (i == 4)
+			return st4;
+
+		else if (i == 5)
+			return st3;
+
+		else
+			return gor;
+
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void registerBlockIcons(IIconRegister reg) {
+		this.gor = reg.registerIcon("portal");
+		this.dol = reg.registerIcon("portal");
+		this.st1 = reg.registerIcon("portal");
+		this.st2 = reg.registerIcon("portal");
+		this.st3 = reg.registerIcon("portal");
+		this.st4 = reg.registerIcon("portal");
+	}
+
+	/**
+	 * Ticks the block if it's been scheduled
+	 */
+	@Override
+	public void updateTick(World par1World, int x, int y, int z, Random par5Random) {
+		super.updateTick(par1World, x, y, z, par5Random);
+
+		int blockCount = 0;
+		BlockPos portal = new BlockPos(x, y, z, par1World.provider.dimensionId);
+
+		for (BlockPos side : portal.getSurroundingBlocks()) {
+			Block b = side.getBlockAtPos();
+			if (b == Dimension_Everglades.blockPortalFrame || b == Dimension_Everglades.portalBlock) {
+				blockCount++;
+			}
+		}		
+		if (blockCount < 4) {
+			par1World.setBlockToAir(x, y, z);
+		}	
+
+	}
+
+	/**
+	 * Returns a bounding box from the pool of bounding boxes (this means
+	 * this box can change after the pool has been cleared to be reused)
+	 */
+	@Override
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4) {
+		return null;
+	}
+
+	/**
+	 * Updates the blocks bounds based on its current state. Args: world, x,
+	 * y, z
+	 */
+	@Override
+	public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4) {
+		float f;
+		float f1;
+		if (par1IBlockAccess.getBlock(par2 - 1, par3, par4) != this && par1IBlockAccess.getBlock(par2 + 1, par3, par4) != this) {
+			f = 0.125F;
+			f1 = 0.5F;
+			this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
+		} else {
+			f = 0.5F;
+			f1 = 0.125F;
+			this.setBlockBounds(0.5F - f, 0.0F, 0.5F - f1, 0.5F + f, 1.0F, 0.5F + f1);
+		}
+	}
+
+	/**
+	 * Is this block (a) opaque and (B) a full 1m cube? This determines
+	 * whether or not to render the shared face of two adjacent blocks and
+	 * also whether the player can attach torches, redstone wire, etc to
+	 * this block.
+	 */
+	@Override
+	public boolean isOpaqueCube() {
+		return false;
+	}
+
+	/**
+	 * If this block doesn't render as an ordinary block it will return
+	 * False (examples: signs, buttons, stairs, etc)
+	 */
+	@Override
+	public boolean renderAsNormalBlock() {
+		return false;
+	}
+
+	/**
+	 * Checks to see if this location is valid to create a portal and will
+	 * return True if it does. Args: world, x, y, z
+	 */
+	public boolean tryToCreatePortal(World par1World, int par2, int par3, int par4) {
+		byte b0 = 0;
+		byte b1 = 0;
+		if (par1World.getBlock(par2 - 1, par3, par4) == Dimension_Everglades.blockPortalFrame
+				|| par1World.getBlock(par2 + 1, par3, par4) == Dimension_Everglades.blockPortalFrame) {
+			b0 = 1;
+		}
+		if (par1World.getBlock(par2, par3, par4 - 1) == Dimension_Everglades.blockPortalFrame
+				|| par1World.getBlock(par2, par3, par4 + 1) == Dimension_Everglades.blockPortalFrame) {
+			b1 = 1;
+		}
+		if (b0 == b1) {
+			return false;
+		} else {
+			if (par1World.getBlock(par2 - b0, par3, par4 - b1) == Blocks.air) {
+				par2 -= b0;
+				par4 -= b1;
+			}
+			int l;
+			int i1;
+			for (l = -1; l <= 2; ++l) {
+				for (i1 = -1; i1 <= 3; ++i1) {
+					boolean flag = l == -1 || l == 2 || i1 == -1 || i1 == 3;
+					if (l != -1 && l != 2 || i1 != -1 && i1 != 3) {
+						Block j1 = par1World.getBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l);
+						if (flag) {
+							if (j1 != Dimension_Everglades.blockPortalFrame) {
+								return false;
+							}
+						}
+						/*
+						 * else if (j1 != 0 && j1 !=
+						 * Main.TutorialFire.blockID) { return false; }
+						 */
+					}
+				}
+			}
+			for (l = 0; l < 2; ++l) {
+				for (i1 = 0; i1 < 3; ++i1) {
+					par1World.setBlock(par2 + b0 * l, par3 + i1, par4 + b1 * l, this, 0, 2);
+				}
+			}
+			return true;
+		}
+	}
+
+	/**
+	 * Lets the block know when one of its neighbor changes. Doesn't know
+	 * which neighbor changed (coordinates passed are their own) Args: x, y,
+	 * z, neighbor blockID
+	 */
+	public void onNeighborBlockChange(BlockPos pos) {
+		int x = pos.xPos, y = pos.yPos, z = pos.zPos;
+		Logger.INFO("Trigger");
+		int blockCount = 0;
+		BlockPos portal = pos;
+		World par1World = portal.world;
+		for (BlockPos side : portal.getSurroundingBlocks()) {
+			Block b = side.getBlockAtPos();
+			if (b == Dimension_Everglades.blockPortalFrame || b == Dimension_Everglades.portalBlock) {
+				blockCount++;
+			}
+		}		
+		if (blockCount < 4) {
+			par1World.setBlockToAir(x, y, z);
+			par1World.scheduleBlockUpdate(x, y, z, portal.getBlockAtPos(), 0);
+		}
+
+
+
+		byte b0 = 0;
+		byte b1 = 1;
+		if (par1World.getBlock(x - 1, y, z) == this || par1World.getBlock(x + 1, y, z) == this) {
+			b0 = 1;
+			b1 = 0;
+		}
+		int i1;
+		for (i1 = y; par1World.getBlock(x, i1 - 1, z) == this; --i1) {
+			;
+		}
+		if (par1World.getBlock(x, i1 - 1, z) != Dimension_Everglades.blockPortalFrame) {
+			par1World.setBlockToAir(x, y, z);
+		} else {
+			int j1;
+			for (j1 = 1; j1 < 4 && par1World.getBlock(x, i1 + j1, z) == this; ++j1) {
+				;
+			}
+			if (j1 == 3 && par1World.getBlock(x, i1 + j1, z) == Dimension_Everglades.blockPortalFrame) {
+				boolean flag = par1World.getBlock(x - 1, y, z) == this || par1World.getBlock(x + 1, y, z) == this;
+				boolean flag1 = par1World.getBlock(x, y, z - 1) == this || par1World.getBlock(x, y, z + 1) == this;
+				if (flag && flag1) {
+					par1World.setBlockToAir(x, y, z);
+				} else {
+					if ((par1World.getBlock(x + b0, y, z + b1) != Dimension_Everglades.blockPortalFrame || par1World
+							.getBlock(x - b0, y, z - b1) != this)
+							&& (par1World.getBlock(x - b0, y, z - b1) != Dimension_Everglades.blockPortalFrame || par1World.getBlock(x + b0, y,
+									z + b1) != this)) {
+						par1World.setBlockToAir(x, y, z);
+					}
+				}
+			} else {
+				par1World.setBlockToAir(x, y, z);
+			}
+		}
+	}
+
+	@Override
+	public void onNeighborBlockChange(World world, int x, int y, int z,	Block block) {
+		onNeighborBlockChange(new BlockPos(x, y, z, world.provider.dimensionId));
+		super.onNeighborBlockChange(world, x, y, z, block);
+	}
+
+	/*@Override
+	public void onNeighborChange(IBlockAccess world, int x, int y, int z, int tileX, int tileY, int tileZ) {
+		onNeighborBlockChange(new BlockPos(x, y, z, world.));
+		super.onNeighborChange(world, x, y, z, tileX, tileY, tileZ);
+	}*/
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	/**
+	 * Returns true if the given side of this block type should be rendered, if the adjacent block is at the given
+	 * coordinates. Args: blockAccess, x, y, z, side
+	 */
+	public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {
+		if (par1IBlockAccess.getBlock(par2, par3, par4) == this) {
+			return false;
+		} else {
+			boolean flag = par1IBlockAccess.getBlock(par2 - 1, par3, par4) == this && par1IBlockAccess.getBlock(par2 - 2, par3, par4) != this;
+			boolean flag1 = par1IBlockAccess.getBlock(par2 + 1, par3, par4) == this && par1IBlockAccess.getBlock(par2 + 2, par3, par4) != this;
+			boolean flag2 = par1IBlockAccess.getBlock(par2, par3, par4 - 1) == this && par1IBlockAccess.getBlock(par2, par3, par4 - 2) != this;
+			boolean flag3 = par1IBlockAccess.getBlock(par2, par3, par4 + 1) == this && par1IBlockAccess.getBlock(par2, par3, par4 + 2) != this;
+			boolean flag4 = flag || flag1;
+			boolean flag5 = flag2 || flag3;
+			return flag4 && par5 == 4 ? true : (flag4 && par5 == 5 ? true : (flag5 && par5 == 2 ? true : flag5 && par5 == 3));
+		}
+	}
+
+	/**
+	 * Returns the quantity of items to drop on block destruction.
+	 */
+	@Override
+	public int quantityDropped(Random par1Random) {
+		return 0;
+	}
+
+	/**
+	 * Triggered whenever an entity collides with this block (enters into
+	 * the block). Args: world, x, y, z, entity
+	 */
+	@Override
+	public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) {
+		if ((par5Entity.ridingEntity == null) && (par5Entity.riddenByEntity == null) && ((par5Entity instanceof EntityPlayerMP))) {
+			EntityPlayerMP thePlayer = (EntityPlayerMP) par5Entity;
+			if (thePlayer.timeUntilPortal > 0) {
+				thePlayer.timeUntilPortal = 100;
+			} else if (thePlayer.dimension != Dimension_Everglades.DIMID) {
+				thePlayer.timeUntilPortal = 100;
+				thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, Dimension_Everglades.DIMID,
+						new TeleporterDimensionMod(thePlayer.mcServer.worldServerForDimension(Dimension_Everglades.DIMID)));
+			} else {
+				thePlayer.timeUntilPortal = 100;
+				thePlayer.mcServer.getConfigurationManager().transferPlayerToDimension(thePlayer, 0,
+						new TeleporterDimensionMod(thePlayer.mcServer.worldServerForDimension(0)));
+			}
+		}
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	/**
+	 * Returns which pass should this block be rendered on. 0 for solids and 1 for alpha
+	 */
+	public int getRenderBlockPass() {
+		return 1;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	/**
+	 * A randomly called display update to be able to add particles or other items for display
+	 */
+	public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random) {
+		if (CORE.RANDOM.nextInt(100) == 0) {
+			par1World.playSound(par2 + 0.5D, par3 + 0.5D, par4 + 0.5D, "portal.portal", 0.5F,
+					CORE.RANDOM.nextFloat() * 0.4F + 0.8F, false);
+		}
+		for (int l = 0; l < 4; ++l) {
+			double d0 = par2 + CORE.RANDOM.nextFloat();
+			double d1 = par3 + CORE.RANDOM.nextFloat();
+			double d2 = par4 + CORE.RANDOM.nextFloat();
+			double d3 = 0.0D;
+			double d4 = 0.0D;
+			double d5 = 0.0D;
+			int i1 = CORE.RANDOM.nextInt(2) * 2 - 1;
+			d3 = (CORE.RANDOM.nextFloat() - 0.5D) * 0.5D;
+			d4 = (CORE.RANDOM.nextFloat() - 0.5D) * 0.5D;
+			d5 = (CORE.RANDOM.nextFloat() - 0.5D) * 0.5D;
+			if (par1World.getBlock(par2 - 1, par3, par4) != this && par1World.getBlock(par2 + 1, par3, par4) != this) {
+				d0 = par2 + 0.5D + 0.25D * i1;
+				d3 = CORE.RANDOM.nextFloat() * 2.0F * i1;
+			} else {
+				d2 = par4 + 0.5D + 0.25D * i1;
+				d5 = CORE.RANDOM.nextFloat() * 2.0F * i1;
+			}
+			par1World.spawnParticle("reddust", d0+0.1D, d1, d2, d3, d4, d5);
+			par1World.spawnParticle("smoke", d0, d1+0.1D, d2, 0, 0, 0);
+
+			Random R = new Random();
+
+			if (R.nextInt(10) == 0){
+				par1World.spawnParticle("largesmoke", d0, d1, d2, 0, 0+0.2D, 0);
+			}
+			else if (R.nextInt(5)==1){
+				par1World.spawnParticle("flame", d0, d1, d2, 0, 0+0.1D, 0);
+			}
+		}
+	}
+
+	@SideOnly(Side.CLIENT)
+	/**
+	 * only called by clickMiddleMouseButton , and passed to inventory.setCurrentItem (along with isCreative)
+	 */
+	public int idPicked(World par1World, int par2, int par3, int par4) {
+		return 0;
+	}
+
+	@Override
+	public int colorMultiplier(final IBlockAccess par1IBlockAccess, final int par2, final int par3, final int par4){
+		return Utils.rgbtoHexValue(0, 255, 0);
+	}
+
+	@Override
+	public int getRenderColor(final int aMeta) {
+		return Utils.rgbtoHexValue(0, 255, 0);
+	}
+
+	@Override
+	public String getLocalizedName() {
+		return EnumChatFormatting.OBFUSCATED+super.getLocalizedName();
+	}
+
+	@Override
+	public int getTooltipID() {
+		return 1;
+	}
+}
+
+
diff --git a/src/main/java/gtPlusPlus/everglades/block/DarkWorldContentLoader.java b/src/main/java/gtPlusPlus/everglades/block/DarkWorldContentLoader.java
new file mode 100644
index 0000000000..9d0e425e3a
--- /dev/null
+++ b/src/main/java/gtPlusPlus/everglades/block/DarkWorldContentLoader.java
@@ -0,0 +1,71 @@
+package gtPlusPlus.everglades.block;
+
+import static gtPlusPlus.everglades.dimension.Dimension_Everglades.*;
+
+import cpw.mods.fml.common.registry.GameRegistry;
+
+import net.minecraft.init.Blocks;
+
+import gtPlusPlus.core.block.base.BlockBaseFluid;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.everglades.item.ItemBlockToxicEverglades;
+import gtPlusPlus.everglades.item.ItemEvergladesPortalTrigger;
+import net.minecraftforge.fluids.FluidRegistry;
+
+public class DarkWorldContentLoader {
+
+	//Static Vars
+	public static BlockDarkWorldSludgeFluid SLUDGE;
+
+
+	public synchronized static void run() {
+		initMisc();
+		initItems();
+		initBlocks();
+	}
+
+	public synchronized static boolean initMisc(){		
+
+		//Fluids
+		SLUDGE = (BlockDarkWorldSludgeFluid) new BlockDarkWorldSludgeFluid(
+				"sludge", 
+				Utils.rgbtoHexValue(30, 130, 30))
+				.setDensity(1800)
+				.setGaseous(false)
+				.setLuminosity(2)
+				.setViscosity(25000)
+				.setTemperature(300);		
+		FluidRegistry.registerFluid(SLUDGE);
+
+		return true;
+	}
+
+	public synchronized static boolean initItems(){
+		portalItem = (ItemEvergladesPortalTrigger) (new ItemEvergladesPortalTrigger().setUnlocalizedName("everglades.trigger"));
+		GameRegistry.registerItem(portalItem, "everglades.trigger");	
+		return true;
+	}
+
+	public synchronized static boolean initBlocks(){		
+
+		//Create Block Instances
+		blockFluidLakes = new BlockBaseFluid("Sludge", SLUDGE, BlockDarkWorldSludgeFluid.SLUDGE).setLightLevel(2f).setLightOpacity(1).setBlockName("fluidSludge");
+		portalBlock = new BlockEvergladesPortal();
+		blockTopLayer = new BlockDarkWorldGround();
+		blockSecondLayer = new BlockDarkWorldPollutedDirt();
+		blockPortalFrame = new BlockDarkWorldPortalFrame();
+		
+		//Registry
+		GameRegistry.registerBlock(portalBlock, ItemBlockToxicEverglades.class, "dimensionDarkWorld_portal");
+		GameRegistry.registerBlock(blockTopLayer, ItemBlockToxicEverglades.class, "blockDarkWorldGround");
+		GameRegistry.registerBlock(blockSecondLayer, ItemBlockToxicEverglades.class, "blockDarkWorldGround2");
+		GameRegistry.registerBlock(blockPortalFrame, ItemBlockToxicEverglades.class, "blockDarkWorldPortalFrame");
+		
+		//Make Flammable
+		Blocks.fire.setFireInfo(blockTopLayer, 30, 20);
+
+		return true;
+	}
+
+
+}