Signed-off-by: StevenRS11 <stevenrs11@aol.com>

Steven/Common/mod_pocketDim/DimData.java

@@ -0,0 +1,194 @@
+package Steven.Common.mod_pocketDim;
+
+import java.awt.List;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class DimData
+  implements Serializable
+{
+  public int dimID;
+  public boolean isPocket;
+  public int depth;
+  public World world;
+  public LinkData exitDimLink;
+  public boolean hasBeenFilled = false;
+  public boolean hasDoor = false;
+  public int dimOrientation;
+  public boolean isDimRandomRift = false;
+  public HashMap linksInThisDim = new HashMap();
+  HashMap dimX;
+  HashMap dimY;
+
+  public DimData(int dimID, boolean isPocket, int depth, LinkData exitLinkData)
+  {
+    this.dimID = dimID;
+    this.depth = depth;
+    this.isPocket = isPocket;
+
+    this.exitDimLink = exitLinkData;
+  }
+
+  public DimData(int dimID, boolean isPocket, int depth, int exitLinkDimID, int exitX, int exitY, int exitZ)
+  {
+    this.dimID = dimID;
+    this.depth = depth;
+    this.isPocket = isPocket;
+
+    this.exitDimLink = new LinkData(exitLinkDimID, exitX, exitY, exitZ);
+  }
+
+  public LinkData findNearestRift(World world, int range, int x, int y, int z)
+  {
+    LinkData nearest = null;
+    float distance = range + 1;
+    int i = -range;
+    int j = -range;
+    int k = -range;
+
+    while (i < range)
+    {
+      while (j < range)
+      {
+        while (k < range)
+        {
+          if ((world.getBlockId(x + i, y + j, z + k) == mod_pocketDim.blockRiftID) && (MathHelper.abs(i) + MathHelper.abs(j) + MathHelper.abs(k) < distance))
+          {
+            if (MathHelper.abs(i) + MathHelper.abs(j) + MathHelper.abs(k) != 0.0F)
+            {
+              nearest = findLinkAtCoords(x + i, y + j, z + k);
+              distance = MathHelper.abs(i) + MathHelper.abs(j) + MathHelper.abs(k);
+            }
+          }
+
+          k++;
+        }
+        k = -range;
+        j++;
+      }
+
+      j = -range;
+      i++;
+    }
+
+    return nearest;
+  }
+
+  public LinkData addLinkToDim(int destinationDimID, int locationXCoord, int locationYCoord, int locationZCoord, int destinationXCoord, int destinationYCoord, int destinationZCoord)
+  {
+    if (this.linksInThisDim.containsKey(Integer.valueOf(locationZCoord)))
+    {
+      this.dimY = ((HashMap)this.linksInThisDim.get(Integer.valueOf(locationZCoord)));
+
+      if (this.dimY.containsKey(Integer.valueOf(locationYCoord)))
+      {
+        this.dimX = ((HashMap)this.dimY.get(Integer.valueOf(locationYCoord)));
+      }
+      else
+      {
+        this.dimX = new HashMap();
+      }
+    }
+    else
+    {
+      this.dimX = new HashMap();
+      this.dimY = new HashMap();
+    }
+
+    LinkData linkData = new LinkData(this.dimID, destinationDimID, locationXCoord, locationYCoord, locationZCoord, destinationXCoord, destinationYCoord, destinationZCoord, this.isPocket);
+
+    this.dimX.put(Integer.valueOf(locationXCoord), linkData);
+    this.dimY.put(Integer.valueOf(locationYCoord), this.dimX);
+    this.linksInThisDim.put(Integer.valueOf(locationZCoord), this.dimY);
+
+    return linkData;
+  }
+
+  public void removeLinkAtCoords(int locationID, int locationXCoord, int locationYCoord, int locationZCoord)
+  {
+    if (this.linksInThisDim.containsKey(Integer.valueOf(locationZCoord)))
+    {
+      this.dimY = ((HashMap)this.linksInThisDim.get(Integer.valueOf(locationZCoord)));
+
+      if (this.dimY.containsKey(Integer.valueOf(locationYCoord)))
+      {
+        this.dimX = ((HashMap)this.dimY.get(Integer.valueOf(locationYCoord)));
+      }
+      else
+      {
+        this.dimX = new HashMap();
+      }
+    }
+    else
+    {
+      this.dimX = new HashMap();
+      this.dimY = new HashMap();
+    }
+
+    this.dimX.remove(Integer.valueOf(locationXCoord));
+    this.dimY.put(Integer.valueOf(locationYCoord), this.dimX);
+    this.linksInThisDim.put(Integer.valueOf(locationZCoord), this.dimY);
+  }
+
+  public LinkData findLinkAtCoords(int locationXCoord, int locationYCoord, int locationZCoord)
+  {
+    try
+    {
+      if (this.linksInThisDim.containsKey(Integer.valueOf(locationZCoord)))
+      {
+        this.dimY = ((HashMap)this.linksInThisDim.get(Integer.valueOf(locationZCoord)));
+
+        if (this.dimY.containsKey(Integer.valueOf(locationYCoord)))
+        {
+          this.dimX = ((HashMap)this.dimY.get(Integer.valueOf(locationYCoord)));
+
+          if (this.dimX.containsKey(Integer.valueOf(locationXCoord)))
+          {
+            return (LinkData)this.dimX.get(Integer.valueOf(locationXCoord));
+          }
+        }
+      }
+
+    }
+    catch (Exception E)
+    {
+      return null;
+    }
+
+    return null;
+  }
+
+  public Collection<LinkData> getAllLinkData()
+  {
+    Iterator itr = this.linksInThisDim.keySet().iterator();
+    Collection<LinkData> linksInDim = (Collection<LinkData>) new HashSet<LinkData>();
+
+    while (itr.hasNext())
+    {
+      HashMap first = (HashMap)this.linksInThisDim.get((Integer)itr.next());
+
+      Iterator itrfirst = first.keySet().iterator();
+
+      while (itrfirst.hasNext())
+      {
+        HashMap second = (HashMap)first.get((Integer)itrfirst.next());
+
+        Iterator itrsecond = second.keySet().iterator();
+        while (itrsecond.hasNext())
+        {
+          LinkData link = (LinkData)second.get((Integer)itrsecond.next());
+
+          linksInDim.add(link);
+        }
+      }
+    }
+    return linksInDim;
+  }
+ 
+}

Steven/Common/mod_pocketDim/LinkData.java

@@ -0,0 +1,56 @@
+package Steven.Common.mod_pocketDim;
+
+import java.io.PrintStream;
+import java.io.Serializable;
+
+public class LinkData
+  implements Serializable
+{
+  public int locXCoord;
+  public int locYCoord;
+  public int locZCoord;
+  public int destXCoord;
+  public int destYCoord;
+  public int destZCoord;
+  public int numberofChildren = 0;
+  public boolean isLocPocket;
+  public int linkOrientation;
+  public int destDimID;
+  public int locDimID;
+  public boolean exists = false;
+
+  public LinkData()
+  {
+    this.exists = false;
+  }
+
+  public LinkData(int exitLinkDimID, int exitX, int exitY, int exitZ)
+  {
+    this.destDimID = exitLinkDimID;
+    this.destXCoord = exitX;
+    this.destYCoord = exitY;
+    this.destZCoord = exitZ;
+  }
+
+  public LinkData(int locationDimID, int destinationDimID, int locationXCoord, int locationYCoord, int locationZCoord, int destinationXCoord, int destinationYCoord, int destinationZCoord, boolean isPocket)
+  {
+    this.exists = true;
+    this.locXCoord = locationXCoord;
+    this.locYCoord = locationYCoord;
+    this.locZCoord = locationZCoord;
+
+    this.destXCoord = destinationXCoord;
+    this.destYCoord = destinationYCoord;
+    this.destZCoord = destinationZCoord;
+
+    this.destDimID = destinationDimID;
+    this.locDimID = locationDimID;
+    this.isLocPocket = isPocket;
+  }
+
+  public void printLinkData()
+  {
+    System.out.println(String.valueOf(this.locDimID) + "locDimID " + String.valueOf(this.locXCoord) + "-locXCoord " + String.valueOf(this.locYCoord) + "-locYCoord " + String.valueOf(this.locZCoord) + "-locZCoord ");
+    System.out.println(String.valueOf(this.destDimID) + "DestDimID " + String.valueOf(this.destXCoord) + "-destXCoord " + String.valueOf(this.destYCoord) + "-destYCoord " + String.valueOf(this.destZCoord) + "-destZCoord ");
+  }
+}

Steven/Common/mod_pocketDim/mod_pocketDim.java

@@ -0,0 +1,6 @@
+package Steven.Common.mod_pocketDim;
+
+public class mod_pocketDim extends StevenDimDoors.mod_pocketDim.mod_pocketDim
+{
+	
+}

StevenDimDoors/mod_pocketDim/BlockDimWall.java

@@ -0,0 +1,69 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.world.World;
+
+public class BlockDimWall extends Block
+{
+	
+	protected BlockDimWall(int i, int j, Material par2Material) 
+	{
+		 super(i, j, Material.ground);
+	        setTickRandomly(true);
+	        this.setCreativeTab(CreativeTabs.tabBlock);
+	        this.setTextureFile("/PocketBlockTextures.png");
+	       
+	       
+	        
+	}
+    public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5) {}
+    
+    public int quantityDropped(Random par1Random)
+    {
+        
+        
+            return 0;
+        
+    }
+   
+    /**
+     * replaces the block clicked with the held block, instead of placing the block on top of it. Shift click to disable. 
+     */
+    public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer entityPlayer, int par6, float par7, float par8, float par9)
+    {
+        if(!par1World.isRemote&&entityPlayer.getCurrentEquippedItem()!=null)
+        {
+        
+        	if(entityPlayer.getCurrentEquippedItem().getItem() instanceof ItemBlock)
+        	{
+        		if(!entityPlayer.capabilities.isCreativeMode)
+        		{
+        			entityPlayer.getCurrentEquippedItem().stackSize--;
+        		}
+        		par1World.setBlockAndMetadataWithNotify(par2, par3, par4,  entityPlayer.getCurrentEquippedItem().itemID, entityPlayer.getCurrentEquippedItem().getItemDamage());
+        		return true;
+        	}
+        	
+        }
+        if(par1World.isRemote&&entityPlayer.getCurrentEquippedItem()!=null)
+        {
+        
+        	if(entityPlayer.getCurrentEquippedItem().getItem() instanceof ItemBlock)
+        	{      		
+        		return true;
+        	}
+        	
+        }
+	
+	return false;
+
+    }
+   
+
+}

StevenDimDoors/mod_pocketDim/BlockDimWallPerm.java

@@ -0,0 +1,77 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+public class BlockDimWallPerm extends Block
+{
+	
+	protected BlockDimWallPerm(int i, int j, Material par2Material) 
+	{
+		 super(i, j, Material.ground);
+	        setTickRandomly(true);
+	      //  this.setCreativeTab(CreativeTabs.tabBlock);
+	      this.setTextureFile("/PocketBlockTextures.png");
+
+	       
+	       
+	        
+	}
+    public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5) {}
+    
+    /**
+     * Only matters if the player is in limbo, acts to teleport the player from limbo back to dim 0
+     */
+    public void onEntityWalking(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+    	if(!par1World.isRemote&&par1World.provider.dimensionId==mod_pocketDim.limboDimID)
+    	{
+			 Random rand = new Random();
+    	
+    		int size = dimHelper.instance.linksForRendering.size();
+    		LinkData link;
+    		if(size!=0)
+    		{
+    			 link = (LinkData) dimHelper.instance.linksForRendering.get(rand.nextInt(size));
+    		}
+    		else
+    		{
+    			 link =new LinkData(0,0,0,0);
+    		}
+
+    		
+    		
+    		if(dimHelper.getWorld(link.destDimID)!=null)
+    		{
+    			World world = dimHelper.getWorld(0);
+    			
+    			int x = (link.destXCoord + rand.nextInt(100000)-50000);
+    			int z = (link.destZCoord + rand.nextInt(100000)-50000);
+    			
+    			x=x+(x>> 4)+1; //make sure I am in the middle of a chunk, andnot on a boundry, so it doesnt load the chunk next to me
+    			z=z+(z>> 4)+1;
+
+    			world.getChunkProvider().loadChunk(x >> 4, z >> 4);
+    			
+    		   	int y = world.getHeightValue(x, z);
+    		   	
+    		   	//this complicated chunk teleports the player back to the overworld at some random location. Looks funky becaue it has to load the chunk
+        		dimHelper.instance.teleportToPocket(par1World, 
+        				new LinkData(0,0,x,y,z,link.locXCoord,link.locYCoord,link.locZCoord,link.isLocPocket), 
+        				EntityPlayer.class.cast(par5Entity));
+
+    		    			
+    		   	EntityPlayer.class.cast(par5Entity).setPositionAndUpdate( x, y, z );
+
+    		   	//makes sure they can breath when they teleport
+    		   	world.setBlockWithNotify(x, y, z, 0);
+    		    	
+    		}
+    	}
+    }
+}

StevenDimDoors/mod_pocketDim/BlockLimbo.java

@@ -0,0 +1,67 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+public class BlockLimbo extends Block
+{
+	
+	protected BlockLimbo(int i, int j, Material par2Material) 
+	{
+		 super(i, j, Material.ground);
+	        setTickRandomly(false);
+	        this.setCreativeTab(CreativeTabs.tabBlock);
+	        this.setTextureFile("/PocketBlockTextures.png");
+	       
+	       
+	        
+	}
+	
+	
+    public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5) {}
+    
+    //part of the decay mech, if a block has fallen onto it, when it turns, it makes sure any block above it gets added too. 
+    @Override
+    public void onBlockAdded(World par1World, int par2, int par3, int par4)
+    {
+    	if(par1World.getBlockId(par2, par3+1, par4)==Block.gravel.blockID)
+    	{
+    		 Point3D point = new Point3D(par2,par3+1,par4);
+             dimHelper.blocksToDecay.add(point);
+    	}
+    }
+    public int quantityDropped(Random par1Random)
+    {
+        
+        
+            return 1;
+        
+    }
+    public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer entityPlayer, int par6, float par7, float par8, float par9)
+    {
+       
+	return false;
+
+    }
+    //if a block lands on it and its gravel, adds it to the decay list
+    public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5) 
+    {
+    	
+    	if(par1World.getBlockId(par2, par3+1, par4)==Block.gravel.blockID)
+    	{
+    		 Point3D point = new Point3D(par2,par3+1,par4);
+             dimHelper.blocksToDecay.add(point);
+    	}
+    	
+    }
+
+   
+   //TODO set render color!!
+}

StevenDimDoors/mod_pocketDim/BlockRift.java

@@ -0,0 +1,293 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.item.Item;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDimClient.ClosingRiftFX;
+import StevenDimDoors.mod_pocketDimClient.GoggleRiftFX;
+import StevenDimDoors.mod_pocketDimClient.RiftFX;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class BlockRift extends BlockContainer
+{
+	
+	protected BlockRift(int i, int j, Material par2Material) 
+	{
+		 super(i, j, Material.snow);
+	        setTickRandomly(true);
+	      //  this.setCreativeTab(CreativeTabs.tabBlock);
+	        this.setTextureFile("/PocketBlockTextures.png");
+	        this.setLightOpacity(14);
+	        
+
+	       
+	       
+	        
+	}
+	//sends a packet informing the client that there is a link present so it renders properly. (when placed)
+	public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	{
+		try
+		{
+			PacketHandler.onLinkCreatedPacket(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World));
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+	//	this.updateTick(par1World, par2, par3, par4, new Random());
+		
+	}
+	 public boolean isCollidable()
+	 {
+	        return false;
+	 }
+	 
+    public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5) {}
+    
+    
+    public boolean isOpaqueCube()
+    {
+        return false;
+    }
+
+    /**
+     * Returns whether this block is collideable based on the arguments passed in Args: blockMetaData, unknownFlag
+     */
+    public boolean canCollideCheck(int par1, boolean par2)
+    {
+    	
+        return par2;
+    }
+
+    /**
+     * Returns Returns true if the given side of this block type should be rendered (if it's solid or not), if the
+     * adjacent block is at the given coordinates. Args: blockAccess, x, y, z, side
+     */
+    public boolean isBlockSolid(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
+    {
+       return true;
+    }
+    //this doesnt do anything yet.
+    public int getRenderType()
+    {
+    	if(mod_pocketDim.isPlayerWearingGoogles)
+    	{
+    		return 0;
+    	}
+    	
+        return 8;
+    }
+
+    @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)
+    {
+      return true;
+    }
+
+    /**
+     * 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)
+     */
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
+    {
+        return null;
+    }
+    //function that regulates how many blocks it eats/ how fast it eates them. 
+    public void updateTick(World world, int x, int y, int z, Random random)
+    {
+    	if(!world.isRemote&&dimHelper.instance.getLinkDataFromCoords(x, y, z, world.provider.dimensionId)!=null)
+    	{
+    		TileEntityRift rift = (TileEntityRift) world.getBlockTileEntity(x, y, z);
+    		if(rift.isNearRift)
+    		{
+    		
+    		int range=4;
+    		
+    		float distance=range+range/4;
+    		int i=-range;
+    		int j=-range;
+    		int k=-range;
+    		boolean flag=true;
+    		while (i<range&&flag)
+    		{
+    			while (j<range&&flag)
+    			{
+    				while (k<range&&flag)
+    				{
+    					if(!mod_pocketDim.blocksImmuneToRift.contains(world.getBlockId(x+i, y+j, z+k))&&MathHelper.abs(i)+MathHelper.abs(j)+MathHelper.abs(k)<distance&&!world.isAirBlock(x+i, y+j, z+k))
+    					{
+    						if(MathHelper.abs(i)+MathHelper.abs(j)+MathHelper.abs(k)!=0&&random.nextInt(2)==0)
+    						{
+    							world.setBlockWithNotify(x+i, y+j, z+k,0);
+    							flag=random.nextBoolean()||random.nextBoolean();
+    						}
+    						
+    					}
+    					k++;
+    				}
+    				k=-range;
+    				j++;
+    				
+    			}
+    			j=-range;
+    			i++;		
+    			
+    		}
+    		
+    		
+    		
+    		}
+    		
+    	}
+    }
+    /**
+     * regulates the render effect, especially when multiple rifts start to link up. Has 3 main parts- Grows toward and away from nearest rft, bends toward it, and a randomization function
+     */
+    @SideOnly(Side.CLIENT)
+    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random rand)
+    {
+     
+        int count;
+        //growth in the direction towards the nearby rift
+        float xGrowth=0;
+        float yGrowth=0;
+        float zGrowth=0;
+        //growth away from the nearby rift
+        float xGrowthn=0;
+        float yGrowthn=0;
+        float zGrowthn=0;
+        //how far the particles are away from original rift. Used to decrease noise the farther they are away. 
+        float xChange = 0;
+        float yChange = 0;
+        float zChange = 0;
+        
+        TileEntityRift tile = (TileEntityRift)par1World.getBlockTileEntity(par2, par3, par4);
+        
+        //the noise, ie, how far the rift particles are away from the intended location. 
+        float offset=0;
+        float Xoffset=0;
+        float Yoffset=0;
+        float Zoffset=0;
+            for (count = 0; count < 12 && tile!=null; ++count)
+            {
+            	//TODO change to a switch statement for clarity
+            	if(tile.xOffset>0)
+            	{
+            		if(rand.nextInt(tile.xOffset)==0)
+            		{
+            			xGrowth =xGrowth+.15F*tile.xOffset;
+            		
+            		}
+            	}
+            	else if(tile.xOffset<0)
+            	{
+            		if(rand.nextInt(-tile.xOffset)==0)
+            		{
+            			xGrowthn =xGrowthn-.15F*-tile.xOffset;
+            		
+            		}
+            	}
+            	
+            	if(tile.yOffset>0)
+            	{
+            		if(rand.nextInt(tile.yOffset)==0)
+            		{
+            			yGrowth =yGrowth+.15F*tile.yOffset;
+            		
+            		}
+            	}
+            	else if(tile.yOffset<0)
+            	{
+            		if(rand.nextInt(-tile.yOffset)==0)
+            		{
+            			yGrowthn =yGrowthn-.15F*-tile.yOffset;
+            		
+            		}
+            	}
+            	
+            	if(tile.zOffset>0)
+            	{
+            		if(rand.nextInt(tile.zOffset)==0)
+            		{
+            			zGrowth =zGrowth+.15F*tile.zOffset;
+            		
+            		}
+            	}
+            	else if(tile.zOffset<0)
+            	{
+            		if(rand.nextInt(-tile.zOffset)==0)
+            		{
+            			zGrowthn =zGrowthn-.15F*-tile.zOffset;
+            		
+            		}
+            	}
+            	
+            	
+            	xChange=(float) ((xGrowth+xGrowthn)+rand.nextGaussian()*.05F);
+            	yChange=(float) ((yGrowth+yGrowthn)+rand.nextGaussian()*.05F);
+            	zChange=(float) ((zGrowth+zGrowthn)+rand.nextGaussian()*.05F);
+	
+            	offset=  (float) ((0.2F/(1+Math.abs(xChange)+Math.abs(yChange)+Math.abs(zChange))));
+            	Xoffset=  (float) ((0.25F/(1+Math.abs(xChange))));
+
+            	Yoffset=  (float) ((0.25F/(1+Math.abs(yChange))));
+            	Zoffset=  (float) ((0.25F/(1+Math.abs(zChange))));
+
+            	
+            	
+               
+                FMLClientHandler.instance().getClient().effectRenderer.addEffect(new RiftFX(par1World,par2+.5+xChange+Xoffset*rand.nextGaussian(), par3+.5+yChange+Yoffset*rand.nextGaussian() , par4+.5+zChange+Zoffset*rand.nextGaussian(), rand.nextGaussian() * 0.001D, rand.nextGaussian()  * 0.001D, rand.nextGaussian() * 0.001D, FMLClientHandler.instance().getClient().effectRenderer));
+                FMLClientHandler.instance().getClient().effectRenderer.addEffect(new RiftFX(par1World,par2+.5-xChange-Xoffset*rand.nextGaussian(), par3+.5-yChange-Yoffset*rand.nextGaussian() , par4+.5-zChange-Zoffset*rand.nextGaussian(), rand.nextGaussian() * 0.001D, rand.nextGaussian()  * 0.001D, rand.nextGaussian() * 0.001D, FMLClientHandler.instance().getClient().effectRenderer));
+
+
+                if(rand.nextBoolean())
+                {
+                	//renders an extra little blob on top of the actual rift location so its easier to find. Eventually will only render if the player has the goggles. 
+                	FMLClientHandler.instance().getClient().effectRenderer.addEffect(new GoggleRiftFX(par1World,par2+.5, par3+.5, par4+.5, rand.nextGaussian() * 0.01D, rand.nextGaussian()  * 0.01D, rand.nextGaussian() * 0.01D, FMLClientHandler.instance().getClient().effectRenderer));
+                }
+                if(tile.shouldClose)
+                {
+                	//renders an opposite color effect if it is being closed by the rift remover
+                    FMLClientHandler.instance().getClient().effectRenderer.addEffect(new ClosingRiftFX(par1World,par2+.5, par3+.5, par4+.5, rand.nextGaussian() * 0.01D, rand.nextGaussian()  * 0.01D, rand.nextGaussian() * 0.01D, FMLClientHandler.instance().getClient().effectRenderer));
+	
+                }
+                
+            }
+        
+    }
+    public int idPicked(World par1World, int par2, int par3, int par4)
+    {
+        return 0;
+    }
+    
+    public int idDropped(int par1, Random par2Random, int par3)
+    {
+        return 0;
+    }
+
+	@Override
+	public TileEntity createNewTileEntity(World var1) 
+	
+	{
+		// TODO Auto-generated method stub
+		return new TileEntityRift();
+	}
+    
+   
+   
+}

StevenDimDoors/mod_pocketDim/ChaosDoor.java

@@ -0,0 +1,121 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ChaosDoor extends dimDoor
+{
+	
+	protected ChaosDoor(int par1, Material material) 
+	{
+		super(par1, Material.iron);
+	//	this.blockIndexInTexture = 18;
+        this.setTextureFile("/PocketBlockTextures.png");
+
+	}
+	
+	@Override
+	public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	{
+		if(!par1World.isRemote&&par1World.getBlockId(par2, par3-1, par4)==this.blockID)
+		{		
+			boolean newDim=false;
+			
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)==null)
+			{
+				newDim=true;
+			}
+		
+			if(newDim)
+			{
+				LinkData link = new LinkData(par1World.provider.dimensionId, mod_pocketDim.limboDimID, par2, par3, par4, par2, par3+500, par4, false);
+				link.linkOrientation= par1World.getBlockMetadata(par2, par3-1, par4);
+				dimHelper.instance.createLink(link);
+			//	System.out.println(link.linkOrientation);
+
+				
+			}
+
+			
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+			{
+				dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation=par1World.getBlockMetadata(par2, par3-1, par4);
+				
+
+			}
+		}
+		
+	}
+	
+	 
+    //uses the rift rendering list to find a random destination for the player
+    public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+     	
+        int var12 = (int) (MathHelper.floor_double((double)((par5Entity.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+       
+    	int num = par1World.getBlockMetadata(par2, par3-1, par4);
+    	if(!par1World.isRemote&&(num==5||num==4||num==6||num==7)&&(num-4)==var12&&par1World.getBlockId(par2, par3-1, par4)==mod_pocketDim.chaosDoorID)
+  		{
+    		EntityPlayer player;
+    		if(par5Entity instanceof EntityPlayer)
+    		{
+    		
+    			player= (EntityPlayer) par5Entity;
+    		 
+    			this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+    			
+    			boolean foundRandomDest=false;
+    			
+    			int i=0;
+    			
+	    		int size = dimHelper.instance.linksForRendering.size();
+	    		
+	    		Random rand= new Random();
+	    		
+	    		while (!foundRandomDest&&size>0&&i<100)
+	    		{
+	    			i++;
+	    			
+	    			LinkData link = (LinkData) dimHelper.instance.linksForRendering.get(rand.nextInt(size));
+	    			
+	    			if(link!=null)
+	    			{
+	    			
+	    				if(!link.isLocPocket&&link.linkOrientation!=-10&&link.destDimID!=mod_pocketDim.limboDimID)
+	    				{
+	    					foundRandomDest=true;
+	    					
+	    					dimHelper.instance.teleportToPocket(par1World, new LinkData(link.destDimID,link.locDimID,link.destXCoord,link.destYCoord,link.destZCoord,link.locXCoord,link.locYCoord,link.locZCoord,link.isLocPocket), player);
+	    					
+	    					if(dimHelper.getWorld(link.locDimID)!=null)
+	    					{
+	    						if(dimHelper.getWorld(link.locDimID).isAirBlock(link.locXCoord,link.locYCoord,link.locZCoord))
+	    						{
+	    							dimHelper.getWorld(link.locDimID).setBlockWithNotify(link.locXCoord,link.locYCoord,link.locZCoord, mod_pocketDim.blockRiftID);
+	    						}
+	    					}	    				    			
+	    				}
+	    			}    	   
+	    		}   			   		
+    		}
+		}
+    }
+
+}

StevenDimDoors/mod_pocketDim/CloudRenderBlank.java

@@ -0,0 +1,16 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraftforge.client.IRenderHandler;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class CloudRenderBlank extends IRenderHandler
+{
+    @SideOnly(Side.CLIENT)
+    public void render(float partialTicks, WorldClient world, Minecraft mc)
+    {
+    	
+    }
+}

StevenDimDoors/mod_pocketDim/CommonProxy.java

@@ -0,0 +1,141 @@
+package StevenDimDoors.mod_pocketDim;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.network.IGuiHandler;
+public class CommonProxy implements IGuiHandler
+{
+    public static String BLOCK_PNG = "/PocketBlockTextures.png";
+    public static String ITEM_PNG = "/PocketItemTextures.png";
+    public static String RIFT_PNG = "/RIFT.png";
+    public static String RIFT2_PNG = "/RIFT2.png";
+    public static String WARP_PNG = "/WARP.png";
+
+    public  void registerRenderers()
+
+    {
+    }
+    public void registerEntity(Class <? extends Entity > entity, String entityname, int id, Object mod, int trackingrange, int updateFreq, boolean updatevelo)
+    {
+    }
+
+    @Override
+    public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
+    {
+        return null;
+    }
+
+    @Override
+    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
+    {
+        return null;
+    }
+
+    public void loadTextures()
+    {
+    }
+
+    public void writeNBTToFile(World world)
+    {
+        boolean flag = true;
+        boolean secondTry = false;
+
+        try
+        {
+            File dataStore = world.getSaveHandler().getMapFileFromName("idcounts");
+            String dirFolder = dataStore.getCanonicalPath();
+            dirFolder = dirFolder.replace("idcounts.dat", "");
+
+            if (!flag)
+            {
+                dirFolder.replace("saves/", FMLCommonHandler.instance().getMinecraftServerInstance().getFolderName());
+                secondTry = true;
+            }
+
+            File file = new File(dirFolder, "GGMData.dat");
+
+            if (!file.exists())
+            {
+                file.createNewFile();
+            }
+
+            FileOutputStream fileoutputstream = new FileOutputStream(file);
+            NBTTagCompound nbttagcompound = new NBTTagCompound();
+            
+
+            
+            CompressedStreamTools.writeCompressed(nbttagcompound, fileoutputstream);
+            fileoutputstream.close();
+        }
+        catch (Exception exception)
+        {
+         //   exception.printStackTrace();
+
+            if (!(exception instanceof NullPointerException))
+            {
+            }
+
+            flag = false;
+        }
+    }
+
+    public void readNBTFromFile(World world)
+    {
+        boolean flag = true;
+        boolean secondTry = false;
+
+        try
+        {
+            File dataStore = world.getSaveHandler().getMapFileFromName("idcounts");
+            String dirFolder = dataStore.getCanonicalPath();
+            dirFolder = dirFolder.replace("idcounts.dat", "");
+
+            if (!flag)
+            {
+                dirFolder.replace("saves/", FMLCommonHandler.instance().getMinecraftServerInstance().getFolderName());
+                secondTry = true;
+            }
+
+            File file = new File(dirFolder, "GGMData.dat");
+
+            if (!file.exists())
+            {
+                file.createNewFile();
+                FileOutputStream fileoutputstream = new FileOutputStream(file);
+                NBTTagCompound nbttagcompound = new NBTTagCompound();
+                
+                CompressedStreamTools.writeCompressed(nbttagcompound, fileoutputstream);
+                fileoutputstream.close();
+            }
+
+            FileInputStream fileinputstream = new FileInputStream(file);
+            NBTTagCompound nbttagcompound = CompressedStreamTools.readCompressed(fileinputstream);
+
+           
+
+            fileinputstream.close();
+        }
+        catch (Exception exception)
+        {
+           // exception.printStackTrace();
+
+            if (!(exception instanceof NullPointerException))
+            {
+            }
+
+            flag = false;
+        }
+    }
+
+    public  void printStringClient(String string)
+    {
+    	
+    }
+}

StevenDimDoors/mod_pocketDim/CommonTickHandler.java

@@ -0,0 +1,160 @@
+package StevenDimDoors.mod_pocketDim;
+import java.util.EnumSet;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.world.World;
+import cpw.mods.fml.common.FMLCommonHandler;
+import cpw.mods.fml.common.ITickHandler;
+import cpw.mods.fml.common.TickType;
+import cpw.mods.fml.relauncher.Side;
+public class CommonTickHandler implements ITickHandler
+{
+	 Random rand= new Random();
+    public int tickCount=0;
+    public int tickCount2=0;
+
+    @Override
+    public void tickStart(EnumSet<TickType> type, Object... tickData) {}
+
+    @Override
+    public void tickEnd(EnumSet<TickType> type, Object... tickData)
+    {
+        if (type.equals(EnumSet.of(TickType.SERVER)))
+        {
+            onTickInGame();
+        }
+    }
+
+    public EnumSet ticks()
+    {
+        return EnumSet.of(TickType.SERVER);
+    }
+
+    public String getLabel()
+    {
+        return null;
+    }
+
+    //replaces rifts in game that have been destroyed/have blocks placed over them. 
+    private void onTickInGame()
+    {
+    	try
+    	{
+    	
+    	if(tickCount>200)
+    	{
+    		tickCount=0;
+    		int i=0;
+    		
+      
+    		while (i<15&&dimHelper.instance.linksForRendering.size()>0&&FMLCommonHandler.instance().getEffectiveSide()==Side.SERVER)
+    		{
+    			i++;
+    			LinkData link;
+    			
+    			//actually gets the random rift based on the size of the list
+        		link = (LinkData) dimHelper.instance.linksForRendering.get(rand.nextInt(dimHelper.instance.linksForRendering.size()));
+
+    			
+    			
+    			if(link!=null)
+    			{
+    			
+    				if(dimHelper.getWorld(link.locDimID)!=null)
+    				{
+    					World world=dimHelper.getWorld(link.locDimID);
+    					
+    					int blocktoReplace = world.getBlockId(link.locXCoord, link.locYCoord, link.locZCoord);
+    					
+    					if(!mod_pocketDim.blocksImmuneToRift.contains(blocktoReplace))//makes sure the rift doesnt replace a door or something
+    					{
+    						if(dimHelper.instance.getLinkDataFromCoords(link.locXCoord, link.locYCoord, link.locZCoord, link.locDimID)==null)
+    						{
+    							dimHelper.instance.linksForRendering.remove(link);
+    						}
+    						else
+    						{
+    							dimHelper.getWorld(link.locDimID).setBlockWithNotify(link.locXCoord, link.locYCoord, link.locZCoord, mod_pocketDim.blockRiftID);
+
+    						}
+    					}
+    				}
+    			}
+    		}
+    	}
+    	
+    	
+    	}
+    	catch (Exception e)
+    	{
+    		tickCount++;
+    		System.out.println("something on tick went wrong");
+    	}
+    	tickCount++;
+    	
+    	//this section regulates decay in Limbo- it records any blocks placed by the player and later progresss them through the decay cycle
+    	if(tickCount2>10&&dimHelper.blocksToDecay!=null)
+    	{
+    		tickCount2=0;
+    		if(!dimHelper.blocksToDecay.isEmpty()&&mod_pocketDim.limbo!=null)
+    		{
+    		
+    		
+    			if(dimHelper.blocksToDecay.size()>rand.nextInt(400))
+    			{
+    				int index = rand.nextInt(dimHelper.blocksToDecay.size());
+    				Point3D point = (Point3D) dimHelper.blocksToDecay.get(index);
+
+    				int blockID = mod_pocketDim.limbo.getBlockId(point.getX(), point.getY(), point.getZ());
+    				int idToSet=Block.stone.blockID;
+    				
+    				if(blockID==0||blockID==mod_pocketDim.blockLimboID)
+    				{
+    					dimHelper.blocksToDecay.remove(index);
+    				}
+    				else
+    				{
+    					if(Block.blocksList[idToSet] instanceof BlockContainer)
+    					{
+    						idToSet=-1;
+    						dimHelper.blocksToDecay.remove(index); 
+    					}
+    					
+    		
+    			
+    					if(blockID==Block.cobblestone.blockID)
+    					{
+    						idToSet=Block.gravel.blockID;
+    					}
+    					if(blockID==Block.stone.blockID)
+    					{
+    						idToSet=Block.cobblestone.blockID;
+
+    					}
+    					if(blockID==Block.gravel.blockID&&!mod_pocketDim.limbo.isAirBlock(point.getX(), point.getY()-1, point.getZ()))
+    					{
+    						idToSet=mod_pocketDim.blockLimboID;
+    					}
+    					else if(blockID==Block.gravel.blockID)
+    					{
+    						dimHelper.blocksToDecay.remove(index);
+    						idToSet=-1;
+
+    					}
+    					
+    					if(idToSet!=-1)
+    					{
+    					
+    						mod_pocketDim.limbo.setBlockWithNotify(point.getX(), point.getY(), point.getZ(), idToSet);
+
+    					}    		
+    				}   		    		
+    			}   		
+    		}
+    	}
+    	
+    	tickCount2++;
+    }
+}

StevenDimDoors/mod_pocketDim/ConnectionHandler.java

@@ -0,0 +1,79 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.NetLoginHandler;
+import net.minecraft.network.packet.NetHandler;
+import net.minecraft.network.packet.Packet1Login;
+import net.minecraft.server.MinecraftServer;
+import cpw.mods.fml.common.network.IConnectionHandler;
+import cpw.mods.fml.common.network.Player;
+
+public class ConnectionHandler
+
+
+  implements IConnectionHandler
+{
+	private static boolean connected = false;
+
+	//sends a packet to clients containing all the information about the dims and links. Lots of packets, actually. 
+	@Override
+	public String connectionReceived(NetLoginHandler netHandler, INetworkManager manager) 
+	{
+		Collection set = new ArrayList();
+		set.addAll(dimHelper.dimList.keySet());	
+		PacketHandler.onClientJoinPacket(manager, dimHelper.dimList);
+		PacketHandler.onDimCreatedPacket(new DimData(mod_pocketDim.limboDimID, false, 0, 0, 0, 0, 0));
+		return null;
+	}
+
+	@Override
+	public void connectionOpened(NetHandler netClientHandler, String server,int port, INetworkManager manager) 
+	{
+		connected = true;		
+	}
+
+	@Override
+	public void connectionOpened(NetHandler netClientHandler,MinecraftServer server, INetworkManager manager) 
+	{
+	
+	}
+
+	@Override
+	public void connectionClosed(INetworkManager manager) 
+	{
+		if (connected)
+		{
+			System.out.println("Clearing dim cache");
+			dimHelper.instance.save();
+			dimHelper.instance.unregsisterDims();
+			dimHelper.dimList.clear();
+			dimHelper.instance.linksForRendering.clear();
+		    
+		}
+		connected = false;
+	
+	}
+
+	@Override
+	public void clientLoggedIn(NetHandler clientHandler, INetworkManager manager,
+		Packet1Login login) 
+	{
+		
+	
+	
+	}
+
+	@Override
+	public void playerLoggedIn(Player player, NetHandler netHandler,
+		INetworkManager manager) 
+	{
+		
+		
+
+	
+	
+	}
+}

StevenDimDoors/mod_pocketDim/CustomCaveGen.java

@@ -0,0 +1,260 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import net.minecraft.world.gen.MapGenBase;
+
+public class CustomCaveGen extends MapGenBase
+{
+    /**
+     * Generates a larger initial cave node than usual. Called 25% of the time.
+     */
+    protected void generateLargeCaveNode(long par1, int par3, int par4, byte[] par5ArrayOfByte, double par6, double par8, double par10)
+    {
+        this.generateCaveNode(par1, par3, par4, par5ArrayOfByte, par6, par8, par10, 1.0F + this.rand.nextFloat() * 6.0F, 0.0F, 0.0F, -1, -1, 0.5D);
+    }
+
+    /**
+     * Generates a node in the current cave system recursion tree.
+     */
+    protected void generateCaveNode(long par1, int par3, int par4, byte[] par5ArrayOfByte, double par6, double par8, double par10, float par12, float par13, float par14, int par15, int par16, double par17)
+    {
+        double var19 = (double)(par3 * 16 + 8);
+        double var21 = (double)(par4 * 16 + 8);
+        float var23 = 0.0F;
+        float var24 = 0.0F;
+        Random var25 = new Random(par1);
+
+        if (par16 <= 0)
+        {
+            int var26 = this.range * 16 - 16;
+            par16 = var26 - var25.nextInt(var26 / 4);
+        }
+
+        boolean var54 = false;
+
+        if (par15 == -1)
+        {
+            par15 = par16 / 2;
+            var54 = true;
+        }
+
+        int var27 = var25.nextInt(par16 / 2) + par16 / 4;
+
+        for (boolean var28 = var25.nextInt(6) == 0; par15 < par16; ++par15)
+        {
+            double var29 = 1.5D + (double)(MathHelper.sin((float)par15 * (float)Math.PI / (float)par16) * par12 * 1.0F);
+            double var31 = var29 * par17;
+            float var33 = MathHelper.cos(par14);
+            float var34 = MathHelper.sin(par14);
+            par6 += (double)(MathHelper.cos(par13) * var33);
+            par8 += (double)var34;
+            par10 += (double)(MathHelper.sin(par13) * var33);
+
+            if (var28)
+            {
+                par14 *= 0.92F;
+            }
+            else
+            {
+                par14 *= 0.7F;
+            }
+
+            par14 += var24 * 0.1F;
+            par13 += var23 * 0.1F;
+            var24 *= 0.9F;
+            var23 *= 0.75F;
+            var24 += (var25.nextFloat() - var25.nextFloat()) * var25.nextFloat() * 2.0F;
+            var23 += (var25.nextFloat() - var25.nextFloat()) * var25.nextFloat() * 4.0F;
+
+            if (!var54 && par15 == var27 && par12 > 1.0F && par16 > 0)
+            {
+                this.generateCaveNode(var25.nextLong(), par3, par4, par5ArrayOfByte, par6, par8, par10, var25.nextFloat() * 0.5F + 0.5F, par13 - ((float)Math.PI / 2F), par14 / 3.0F, par15, par16, 1.0D);
+                this.generateCaveNode(var25.nextLong(), par3, par4, par5ArrayOfByte, par6, par8, par10, var25.nextFloat() * 0.5F + 0.5F, par13 + ((float)Math.PI / 2F), par14 / 3.0F, par15, par16, 1.0D);
+                return;
+            }
+
+            if (var54 || var25.nextInt(4) != 0)
+            {
+                double var35 = par6 - var19;
+                double var37 = par10 - var21;
+                double var39 = (double)(par16 - par15);
+                double var41 = (double)(par12 + 2.0F + 16.0F);
+
+                if (var35 * var35 + var37 * var37 - var39 * var39 > var41 * var41)
+                {
+                    return;
+                }
+
+                if (par6 >= var19 - 16.0D - var29 * 2.0D && par10 >= var21 - 16.0D - var29 * 2.0D && par6 <= var19 + 16.0D + var29 * 2.0D && par10 <= var21 + 16.0D + var29 * 2.0D)
+                {
+                    int var55 = MathHelper.floor_double(par6 - var29) - par3 * 16 - 1;
+                    int var36 = MathHelper.floor_double(par6 + var29) - par3 * 16 + 1;
+                    int var57 = MathHelper.floor_double(par8 - var31) - 1;
+                    int var38 = MathHelper.floor_double(par8 + var31) + 1;
+                    int var56 = MathHelper.floor_double(par10 - var29) - par4 * 16 - 1;
+                    int var40 = MathHelper.floor_double(par10 + var29) - par4 * 16 + 1;
+
+                    if (var55 < 0)
+                    {
+                        var55 = 0;
+                    }
+
+                    if (var36 > 16)
+                    {
+                        var36 = 16;
+                    }
+
+                    if (var57 < 1)
+                    {
+                        var57 = 1;
+                    }
+
+                    if (var38 > 120)
+                    {
+                        var38 = 120;
+                    }
+
+                    if (var56 < 0)
+                    {
+                        var56 = 0;
+                    }
+
+                    if (var40 > 16)
+                    {
+                        var40 = 16;
+                    }
+
+                    boolean var58 = false;
+                    int var42;
+                    int var45;
+
+                    for (var42 = var55; !var58 && var42 < var36; ++var42)
+                    {
+                        for (int var43 = var56; !var58 && var43 < var40; ++var43)
+                        {
+                            for (int var44 = var38 + 1; !var58 && var44 >= var57 - 1; --var44)
+                            {
+                                var45 = (var42 * 16 + var43) * 128 + var44;
+
+                                if (var44 >= 0 && var44 < 128)
+                                {
+                                    if (par5ArrayOfByte[var45] == Block.waterMoving.blockID || par5ArrayOfByte[var45] == Block.waterStill.blockID)
+                                    {
+                                        var58 = true;
+                                    }
+
+                                    if (var44 != var57 - 1 && var42 != var55 && var42 != var36 - 1 && var43 != var56 && var43 != var40 - 1)
+                                    {
+                                        var44 = var57;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    if (!var58)
+                    {
+                        for (var42 = var55; var42 < var36; ++var42)
+                        {
+                            double var59 = ((double)(var42 + par3 * 16) + 0.5D - par6) / var29;
+
+                            for (var45 = var56; var45 < var40; ++var45)
+                            {
+                                double var46 = ((double)(var45 + par4 * 16) + 0.5D - par10) / var29;
+                                int var48 = (var42 * 16 + var45) * 128 + var38;
+                                boolean var49 = false;
+
+                                if (var59 * var59 + var46 * var46 < 1.0D)
+                                {
+                                    for (int var50 = var38 - 1; var50 >= var57; --var50)
+                                    {
+                                        double var51 = ((double)var50 + 0.5D - par8) / var31;
+
+                                        if (var51 > -0.7D && var59 * var59 + var51 * var51 + var46 * var46 < 1.0D)
+                                        {
+                                            byte var53 = par5ArrayOfByte[var48];
+
+                                            if (var53 == Block.grass.blockID)
+                                            {
+                                                var49 = true;
+                                            }
+
+                                            if (var53 == mod_pocketDim.blockLimboID|| var53 == Block.dirt.blockID || var53 == Block.grass.blockID)
+                                            {
+                                                if (var50 < 10)
+                                                {
+                                                    par5ArrayOfByte[var48] = (byte)Block.lavaMoving.blockID;
+                                                }
+                                                else
+                                                {
+                                                    par5ArrayOfByte[var48] = 0;
+
+                                                    if (var49 && par5ArrayOfByte[var48 - 1] == Block.dirt.blockID)
+                                                    {
+                                                        par5ArrayOfByte[var48 - 1] = this.worldObj.getBiomeGenForCoords(var42 + par3 * 16, var45 + par4 * 16).topBlock;
+                                                    }
+                                                }
+                                            }
+                                        }
+
+                                        --var48;
+                                    }
+                                }
+                            }
+                        }
+
+                        if (var54)
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Recursively called by generate() (generate) and optionally by itself.
+     */
+    protected void recursiveGenerate(World par1World, int par2, int par3, int par4, int par5, byte[] par6ArrayOfByte)
+    {
+        int var7 = this.rand.nextInt(this.rand.nextInt(this.rand.nextInt(40) + 1) + 1);
+
+        if (this.rand.nextInt(15) != 0)
+        {
+            var7 = 0;
+        }
+
+        for (int var8 = 0; var8 < var7; ++var8)
+        {
+            double var9 = (double)(par2 * 16 + this.rand.nextInt(16));
+            double var11 = (double)this.rand.nextInt(this.rand.nextInt(120) + 8);
+            double var13 = (double)(par3 * 16 + this.rand.nextInt(16));
+            int var15 = 1;
+
+            if (this.rand.nextInt(4) == 0)
+            {
+                this.generateLargeCaveNode(this.rand.nextLong(), par4, par5, par6ArrayOfByte, var9, var11, var13);
+                var15 += this.rand.nextInt(4);
+            }
+
+            for (int var16 = 0; var16 < var15; ++var16)
+            {
+                float var17 = this.rand.nextFloat() * (float)Math.PI * 2.0F;
+                float var18 = (this.rand.nextFloat() - 0.5F) * 2.0F / 8.0F;
+                float var19 = this.rand.nextFloat() * 2.0F + this.rand.nextFloat();
+
+                if (this.rand.nextInt(10) == 0)
+                {
+                    var19 *= this.rand.nextFloat() * this.rand.nextFloat() * 3.0F + 1.0F;
+                }
+
+                this.generateCaveNode(this.rand.nextLong(), par4, par5, par6ArrayOfByte, var9, var11, var13, var19, var17, var18, 0, 0, 1.0D);
+            }
+        }
+    }
+}

StevenDimDoors/mod_pocketDim/DimData.java

@@ -0,0 +1,258 @@
+package StevenDimDoors.mod_pocketDim;
+/**Class that contains all the information about a specific dim that is pertienent to Dim Doors. Holds all the rifts present in the dim sorted by x,y,z and 
+ * wether or not the dim is a pocket or not, along with its depth. 
+ * @Return
+ */
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class DimData implements Serializable
+{
+	public int dimID;
+	public int depth;
+	public int dimOrientation;
+	
+	public World world;
+	
+	public LinkData exitDimLink;
+	
+	public boolean isPocket;
+	public boolean hasBeenFilled=false;
+	public boolean hasDoor=false;
+	public boolean isDimRandomRift=false;
+	
+	public HashMap<Integer, HashMap<Integer, HashMap<Integer,  LinkData>>> linksInThisDim=new HashMap();
+	HashMap<Integer, LinkData> dimX;
+	HashMap<Integer, HashMap<Integer, LinkData>> dimY ;
+	
+	static final long serialVersionUID = 454342L;
+	
+	public DimData(int dimID, boolean isPocket, int depth, LinkData exitLinkData)
+	{
+		this.dimID=dimID;
+		this.depth=depth;
+		this.isPocket=isPocket;
+		
+		this.exitDimLink= exitLinkData;
+		
+	}
+	
+	public DimData(int dimID, boolean isPocket, int depth, int exitLinkDimID, int exitX, int exitY, int exitZ)
+	{
+		this.dimID=dimID;
+		this.depth=depth;
+		this.isPocket=isPocket;
+
+		this.exitDimLink= new LinkData(exitLinkDimID,  exitX, exitY, exitZ);
+		
+	}
+	
+	public LinkData findNearestRift(World world, int range, int x, int y, int z)
+	{
+		LinkData nearest=null;
+		float distance=range+1;
+		int i=-range;
+		int j=-range;
+		int k=-range;
+		
+		while (i<range)
+		{
+			while (j<range)
+			{
+				while (k<range)
+				{
+					if(world.getBlockId(x+i, y+j, z+k)==mod_pocketDim.blockRiftID&&MathHelper.abs(i)+MathHelper.abs(j)+MathHelper.abs(k)<distance)
+					{
+						if(MathHelper.abs(i)+MathHelper.abs(j)+MathHelper.abs(k)!=0)
+						{
+							nearest=this.findLinkAtCoords(x+i, y+j, z+k);
+							distance=MathHelper.abs(i)+MathHelper.abs(j)+MathHelper.abs(k);
+						}
+						
+					}
+					k++;
+				}
+				k=-range;
+				j++;
+				
+			}
+			j=-range;
+			i++;		
+			
+		}
+		
+		
+		return nearest;
+		
+	}
+	
+	public LinkData addLinkToDim(LinkData link)
+	{
+		if(this.linksInThisDim.containsKey(link.locZCoord))
+		{
+			this.dimY=this.linksInThisDim.get(link.locZCoord);
+			
+			if(this.dimY.containsKey(link.locYCoord))
+			{
+				this.dimX=this.dimY.get(link.locYCoord);
+			}
+			else
+			{
+				this.dimX=new HashMap<Integer, LinkData>();
+			}
+		}
+		else
+		{
+			this.dimX=new HashMap<Integer, LinkData>();
+			this.dimY=new HashMap<Integer, HashMap<Integer, LinkData>>();
+		}
+		
+		this.dimX.put(link.locXCoord, link);
+		this.dimY.put(link.locYCoord, dimX);
+		this.linksInThisDim.put(link.locZCoord, dimY);
+		
+		//System.out.println("added link to dim "+this.dimID);
+		return link;	
+		
+	}
+	
+	public LinkData addLinkToDim( int destinationDimID, int locationXCoord, int locationYCoord, int locationZCoord, int destinationXCoord, int destinationYCoord, int destinationZCoord, int linkOrientation)
+	{
+		
+		
+	
+		
+		LinkData linkData= new LinkData(this.dimID, destinationDimID, locationXCoord, locationYCoord, locationZCoord, destinationXCoord, destinationYCoord,destinationZCoord,this.isPocket);
+		
+		linkData.linkOrientation=linkOrientation;
+		
+		return this.addLinkToDim(linkData);
+		
+		
+		
+		
+		
+		
+	}
+	
+	public boolean isLimbo()
+	{
+		if(this.dimID==mod_pocketDim.limboDimID)
+		{
+			return true;
+			
+		}
+		else
+		{
+			return false;
+		}
+	}
+	public void removeLinkAtCoords(LinkData link)
+	{
+		this.removeLinkAtCoords(link.locDimID, link.locXCoord, link.locYCoord, link.locZCoord);
+	}
+	public void removeLinkAtCoords(int locationID, int locationXCoord, int locationYCoord, int locationZCoord)
+	{
+		
+		
+		if(this.linksInThisDim.containsKey(locationZCoord))
+		{
+			this.dimY=this.linksInThisDim.get(locationZCoord);
+			
+			if(this.dimY.containsKey(locationYCoord))
+			{
+				this.dimX=this.dimY.get(locationYCoord);
+			}
+			else
+			{
+				this.dimX=new HashMap<Integer, LinkData>();
+			}
+		}
+		else
+		{
+			this.dimX=new HashMap<Integer, LinkData>();
+			this.dimY=new HashMap<Integer, HashMap<Integer, LinkData>>();
+		}
+		
+		
+		this.dimX.remove(locationXCoord);
+		this.dimY.put(locationYCoord, dimX);
+		this.linksInThisDim.put(locationZCoord, dimY);
+		
+		
+		
+		
+		
+		
+		
+		
+		
+	}
+	
+	public LinkData findLinkAtCoords(int locationXCoord, int locationYCoord, int locationZCoord)
+	{
+		try
+		{
+		if(this.linksInThisDim.containsKey(locationZCoord))
+		{
+			this.dimY=this.linksInThisDim.get(locationZCoord);
+			
+			if(this.dimY.containsKey(locationYCoord))
+			{
+				this.dimX=this.dimY.get(locationYCoord);
+				
+				if(this.dimX.containsKey(locationXCoord))
+				{
+				return this.dimX.get(locationXCoord);
+				}
+				
+			}
+		}
+		}
+		catch(Exception E)
+		{
+			return null;
+		}
+		
+		return null;
+			
+	}
+	
+	
+	
+	public void printAllLinkData()
+	{
+		Iterator itr= this.linksInThisDim.keySet().iterator();
+		
+		while (itr.hasNext())
+		{
+			HashMap first = this.linksInThisDim.get((Integer)itr.next());
+			
+			Iterator itrfirst= first.keySet().iterator();
+			
+			while (itrfirst.hasNext())
+			{
+				HashMap second = (HashMap) first.get((Integer)itrfirst.next());
+				
+				Iterator itrsecond= second.keySet().iterator();
+				
+				while (itrsecond.hasNext())
+				{
+					
+//TODO make a for(each : in) loops, and make it so that it returns the links instead of printing them 			
+					
+					LinkData link = (LinkData) second.get((Integer)itrsecond.next());
+						
+					link.printLinkData();
+					
+					
+					
+				}
+			}				
+		}
+	}
+}

StevenDimDoors/mod_pocketDim/DimUpdatePacket.java

@@ -0,0 +1,17 @@
+package StevenDimDoors.mod_pocketDim; 
+
+
+public class DimUpdatePacket
+{
+	
+	public DimUpdatePacket(int dim)
+	{
+	
+	}
+			
+			
+			
+
+			
+			
+}

StevenDimDoors/mod_pocketDim/DungeonGenerator.java

@@ -0,0 +1,188 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Random;
+
+import net.minecraft.world.World;
+
+
+
+public class DungeonGenerator
+{
+
+	public int weight;
+	public String schematicPath;
+	public ArrayList<HashMap> sideRifts = new ArrayList<HashMap>();
+	public LinkData exitLink; 
+	public static Random rand = new Random();
+	
+	
+	
+	public DungeonGenerator(int weight, String schematicPath, ArrayList<HashMap> sideRifts)
+	{
+		this.weight=weight;
+		this.schematicPath=schematicPath;
+		this.sideRifts=sideRifts;
+		
+	}
+	
+	
+	
+	
+	public static void generateDungeonlink(LinkData incoming)
+	{
+		//DungeonGenerator dungeon = mod_pocketDim.registeredDungeons.get(new Random().nextInt(mod_pocketDim.registeredDungeons.size()));
+		DungeonGenerator dungeon;
+		int depth = dimHelper.instance.getDimDepth(incoming.locDimID)+2;
+		
+		int depthWeight = rand.nextInt(depth)+rand.nextInt(depth)-2;
+		
+		depth=depth-2;
+	//	DungeonGenerator
+		boolean flag = true;
+		int count=10;
+		
+		if(incoming.destYCoord>10)
+		{
+		do
+		{
+			count--;
+			flag = true;
+			 dungeon = mod_pocketDim.registeredDungeons.get(rand.nextInt(mod_pocketDim.registeredDungeons.size()));
+
+			if(depth<=1)
+			{
+				if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.complexHalls.get(rand.nextInt(mod_pocketDim.complexHalls.size()));
+
+				}
+				else if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.hubs.get(rand.nextInt(mod_pocketDim.hubs.size()));
+
+				}
+				else  if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.hubs.get(rand.nextInt(mod_pocketDim.hubs.size()));
+
+				}
+				else if(mod_pocketDim.deadEnds.contains(dungeon)||mod_pocketDim.exits.contains(dungeon))
+						{
+						flag=false;
+						}
+				
+		
+				
+			}
+			else if(depth<=3&&(mod_pocketDim.deadEnds.contains(dungeon)||mod_pocketDim.exits.contains(dungeon)||rand.nextBoolean()))
+			{
+				if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.hubs.get(rand.nextInt(mod_pocketDim.hubs.size()));
+					
+				}
+				else if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.mazes.get(rand.nextInt(mod_pocketDim.mazes.size()));
+				}
+				else if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.pistonTraps.get(rand.nextInt(mod_pocketDim.pistonTraps.size()));
+
+				}
+				else
+				{
+					flag=false;
+				}
+			}
+			else if(rand.nextInt(3)==0&&!mod_pocketDim.complexHalls.contains(dungeon))
+			{
+				if(rand.nextInt(3)==0)
+				{
+					dungeon = mod_pocketDim.simpleHalls.get(rand.nextInt(mod_pocketDim.simpleHalls.size()));
+				}
+				else if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.pistonTraps.get(rand.nextInt(mod_pocketDim.pistonTraps.size()));
+
+				}
+				else if(depth<4)
+				{
+					dungeon = mod_pocketDim.hubs.get(rand.nextInt(mod_pocketDim.hubs.size()));
+
+				}
+
+			}
+			else if(depthWeight-depthWeight/2>depth-4&&(mod_pocketDim.deadEnds.contains(dungeon)||mod_pocketDim.exits.contains(dungeon)))
+			{
+				if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.simpleHalls.get(rand.nextInt(mod_pocketDim.simpleHalls.size()));
+				}
+				else if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.complexHalls.get(rand.nextInt(mod_pocketDim.complexHalls.size()));
+				}
+				else if(rand.nextBoolean())
+				{
+					dungeon = mod_pocketDim.pistonTraps.get(rand.nextInt(mod_pocketDim.pistonTraps.size()));
+
+				}
+				else	
+				{
+					flag=false;
+				}
+			}
+			else if(depthWeight>7&&mod_pocketDim.hubs.contains(dungeon))
+			{
+				if(rand.nextInt(12)+5<depthWeight)
+				{
+					if(rand.nextBoolean())
+					{
+						dungeon = mod_pocketDim.exits.get(rand.nextInt(mod_pocketDim.exits.size()));
+					}
+					else if(rand.nextBoolean())
+					{
+						dungeon = mod_pocketDim.deadEnds.get(rand.nextInt(mod_pocketDim.deadEnds.size()));
+					}
+					else
+					{
+						dungeon = mod_pocketDim.pistonTraps.get(rand.nextInt(mod_pocketDim.pistonTraps.size()));
+
+					}
+					
+				}
+				else
+				{
+					flag = false;
+				}
+			}
+			else if(depth>10&&mod_pocketDim.hubs.contains(dungeon))
+			{
+				flag = false;
+			}
+			
+		}
+		while(!flag&&count>0);
+		}
+		else
+		{
+			dungeon= mod_pocketDim.defaultUp;
+		}
+		
+		
+		mod_pocketDim.loader.init(dungeon.schematicPath, incoming, 0,0,0);
+		//mod_pocketDim.loader.generateSchematic(incoming,0,0,0);
+	
+		
+				
+
+				
+
+			
+		
+	}
+	
+}

StevenDimDoors/mod_pocketDim/EventHookContainer.java

@@ -0,0 +1,228 @@
+package StevenDimDoors.mod_pocketDim;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.monster.EntityEnderman;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumMovingObjectType;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.event.ForgeSubscribe;
+import net.minecraftforge.event.entity.living.LivingFallEvent;
+import net.minecraftforge.event.entity.player.PlayerDropsEvent;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.event.world.WorldEvent;
+public class EventHookContainer
+{
+	Random rand= new Random();
+    @ForgeSubscribe
+    public void onWorldLoad(WorldEvent.Load event)
+    {
+    	
+    	if(!mod_pocketDim.hasInitDims&&event.world.provider.dimensionId==0&&!event.world.isRemote)
+    	{
+    		dimHelper.instance.unregsisterDims();
+        	dimHelper.dimList.clear();
+        	dimHelper.instance.interDimLinkList.clear();
+        	dimHelper.instance.linksForRendering.clear();
+        	dimHelper.instance.initPockets();
+        	
+        	mod_pocketDim.limbo= dimHelper.instance.getWorld(mod_pocketDim.limboDimID);
+        	
+    	}
+    	
+    	
+    	
+    	
+    	
+		Iterator itr = ((ArrayList) dimHelper.instance.linksForRendering.clone()).listIterator();
+  
+		while (itr.hasNext())
+		{
+			
+			
+			LinkData link = (LinkData) itr.next();
+			
+			if(link!=null)
+			{
+			
+			if(dimHelper.getWorld(link.locDimID)!=null)
+			{
+			//	link.printLinkData();
+				World world=dimHelper.getWorld(link.locDimID);
+				int blocktoReplace = world.getBlockId(link.locXCoord, link.locYCoord, link.locZCoord);
+				if(!mod_pocketDim.blocksImmuneToRift.contains(blocktoReplace))
+				{
+					if(dimHelper.instance.getLinkDataFromCoords(link.locXCoord, link.locYCoord, link.locZCoord, link.locDimID)==null)
+					{
+						dimHelper.instance.linksForRendering.remove(link);
+					}
+					else
+					{
+						dimHelper.getWorld(link.locDimID).setBlockWithNotify(link.locXCoord, link.locYCoord, link.locZCoord, mod_pocketDim.blockRiftID);
+
+					}
+				}
+			}
+			}
+	   
+		}
+    	
+    	
+       
+    }
+    @ForgeSubscribe
+	public void EntityJoinWorldEvent(net.minecraftforge.event.entity.EntityJoinWorldEvent event)
+    {
+    if(event.entity instanceof EntityPlayer)
+    	{
+    //	System.out.println(event.entity.worldObj.provider.dimensionId);
+
+    	//	PacketDispatcher.sendPacketToPlayer(DimUpdatePacket.sendPacket(event.world.provider.dimensionId,1),(Player) event.entity);
+    		
+    		
+    		
+    	}
+        
+    }
+    @ForgeSubscribe
+    public void onPlayerFall(LivingFallEvent event)
+    {
+    	
+    		event.setCanceled(event.entity.worldObj.provider.dimensionId==mod_pocketDim.limboDimID);
+    	
+    }
+    
+    @ForgeSubscribe
+    public void onPlayerInteract(PlayerInteractEvent event)
+    {
+     
+    
+    		
+    	
+    	
+     if(event.entityPlayer.worldObj.provider.dimensionId==mod_pocketDim.limboDimID&&event.action==PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK)
+     {
+        
+
+         int x = event.x;
+         int y = event.y;
+         
+         int z = event.z;
+         
+         
+         
+//need to propely separate client/server
+         int face = event.face;
+         switch (face) {
+             case 0:  y = y-1;
+                      break;
+             case 1: y=y+1;
+                      break;
+             case 2:  z=z-1;
+                      break;
+             case 3:  z=z+1;
+                      break;
+             case 4:  x=x-1;
+                      break;
+             case 5:  x=x+1 ;
+                      break;
+             default:
+                      break;
+         }
+         
+         if(event.entityPlayer.getHeldItem()!=null)
+         {
+         if(event.entityPlayer.getHeldItem().getItem() instanceof ItemBlock)
+         {
+        //	if(event.entityPlayer instanceof EntityPlayerMP)
+        	{
+        	
+        		Point3D point = new Point3D(x,y,z);
+        		dimHelper.blocksToDecay.add(point);
+        	}
+         }
+         else
+         {
+        	 event.setCanceled(true);
+         }
+         
+         
+         }
+     }
+     
+    	}
+     
+     
+    
+    
+ //   @ForgeSubscribe
+    public void onPlayerEvent(PlayerEvent event)
+    {
+    	/**
+       if(!event.entity.worldObj.isRemote)
+       {
+    	   ItemStack item =  event.entityPlayer.inventory.getCurrentItem();
+    	   if(item!=null)
+    	   {
+    		   if(item.getItem() instanceof ItemRiftBlade)
+    		   {
+					List<EntityLiving> list =  event.entity.worldObj.getEntitiesWithinAABB(EntityLiving.class, AxisAlignedBB.getBoundingBox( event.entityPlayer.posX-7,event.entityPlayer.posY-7, event.entityPlayer.posZ-7, event.entityPlayer.posX+7,event.entityPlayer.posY+7, event.entityPlayer.posZ+7));
+					list.remove(event.entity);
+	    			  
+
+					for(EntityLiving ent : list)
+					{
+						
+						  Vec3 var3 = event.entityPlayer.getLook(1.0F).normalize();
+				            Vec3 var4 =  event.entityPlayer.worldObj.getWorldVec3Pool().getVecFromPool(ent.posX -  event.entityPlayer.posX, ent.boundingBox.minY + (double)((ent.height) / 2.0F) - ( event.entityPlayer.posY + (double) event.entityPlayer.getEyeHeight()), ent.posZ -  event.entityPlayer.posZ);
+				            double var5 = var4.lengthVector();
+				            var4 = var4.normalize();
+				            double var7 = var3.dotProduct(var4);
+				            if( (var7+.1) > 1.0D - 0.025D / var5 ?  event.entityPlayer.canEntityBeSeen(ent) : false)
+				            {
+				            	 System.out.println(list.size());
+				            	ItemRiftBlade.class.cast(item.getItem()).teleportToEntity(item,ent, event.entityPlayer);
+				            	break;
+
+				            	//ItemRiftBlade.class.cast(item.getItem()).teleportTo(event.entityPlayer, ent.posX, ent.posY, ent.posZ);
+				            }
+					}
+    			
+    		   }
+    	   }
+       }
+       **/
+    }
+    @ForgeSubscribe
+    public void onPlayerDrops(PlayerDropsEvent event)
+    {
+    	mod_pocketDim.limboSpawnInventory=event.drops;
+    }
+
+    @ForgeSubscribe
+    public void onWorldunload(WorldEvent.Unload event)
+    {
+     
+    	
+    }
+
+    @ForgeSubscribe
+    public void onWorldsave(WorldEvent.Save event)
+    {
+    
+    	if(mod_pocketDim.hasInitDims&&event.world.provider.dimensionId==0)
+    	{
+    		dimHelper.instance.save();
+    	}
+    }
+}

StevenDimDoors/mod_pocketDim/ExitDoor.java

@@ -0,0 +1,141 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class ExitDoor extends dimDoor
+{
+
+	protected ExitDoor(int par1, Material par2Material) 
+	{
+		
+		super(par1, Material.wood);
+	//	this.blockIndexInTexture = 19;
+        this.setTextureFile("/PocketBlockTextures.png");
+
+		// TODO Auto-generated constructor stub
+	}
+	
+	 @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+	@Override
+	public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	{
+		
+		
+		if(!par1World.isRemote&&par1World.getBlockId(par2, par3-1, par4)==this.blockID)
+		{
+			
+		
+			int locDimID=par1World.provider.dimensionId;
+			
+			if(dimHelper.instance.dimList.containsKey(locDimID)&&dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)==null)
+			{
+				DimData dimData = dimHelper.dimList.get(locDimID);
+				int ExitDimID = dimData.exitDimLink.destDimID;
+	   		
+	   		
+	   			if(dimHelper.instance.getDimDepth(locDimID)==1)			
+	   			{
+	   				//System.out.println("exitToOverowrld from "+String.valueOf(locDimID));
+	   				
+				   	
+				   		
+						
+					dimHelper.instance.createLink(locDimID, ExitDimID, par2, par3, par4, par2, par3, par4,par1World.getBlockMetadata(par2, par3-1, par4));
+					dimHelper.instance.createLink(ExitDimID, locDimID, par2, par3, par4, par2, par3, par4,dimHelper.instance.flipDoorMetadata(par1World.getBlockMetadata(par2, par3-1, par4)));
+
+					
+
+
+	   			}
+	   			else if(dimHelper.dimList.get(par1World.provider.dimensionId).isPocket)
+	   			{
+	   				//System.out.println("Created new dim from "+String.valueOf(par1World.provider.dimensionId));
+
+	   				LinkData link = new LinkData(par1World.provider.dimensionId, 0, par2, par3, par4, par2, par3, par4, true);
+					link.linkOrientation= par1World.getBlockMetadata(par2, par3-1, par4);
+					dimHelper.instance.createPocket(link,false, false);
+
+				
+	   				
+	   			//	dimHelper.instance.generatePocket(dimHelper.getWorld(destDimID), par2, par3, par4,par1World.getBlockMetadata(par2, par3-1, par4));
+
+
+	   			}
+   		 	
+			}
+			else if (dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+			{
+				
+				//System.out.println("RiftPresent at "+String.valueOf(par1World.provider.dimensionId));
+				dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation=par1World.getBlockMetadata(par2, par3-1, par4);
+				
+
+				
+
+				
+
+			}
+			
+		
+		
+		}
+		
+		//this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+		
+	}
+	@Override
+	public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+        int var12 = (int) (MathHelper.floor_double((double)((par5Entity.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+       
+    	int num = par1World.getBlockMetadata(par2, par3-1, par4);
+    	if(!par1World.isRemote&&(num==5||num==4||num==6||num==7)&&(num-4)==var12&&par1World.getBlockId(par2, par3-1, par4)==mod_pocketDim.ExitDoorID)
+			{
+    	EntityPlayer player;
+		if(par5Entity instanceof EntityPlayerMP)
+    	{
+    		
+    		 player= (EntityPlayer) par5Entity;
+    		 //int destinationID= dimHelper.instance.getDestIDFromCoords(par2, par3, par4, par1World);
+    		 
+    		 this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+
+    		 LinkData linkData= dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World);
+    		 if(linkData!=null)
+    		 {
+    			 if(dimHelper.dimList.containsKey(linkData.destDimID))
+    			 dimHelper.instance.teleportToPocket(par1World, linkData, player);
+    		 }
+     			
+    		
+    	}
+		}
+    }
+	
+	 public int idPicked(World par1World, int par2, int par3, int par4)
+	    {
+	        return Item.doorWood.itemID;
+	    }
+	    
+	    public int idDropped(int par1, Random par2Random, int par3)
+	    {
+	        return (par1 & 8) != 0 ? 0 : (Item.doorWood.itemID);
+	    }
+	
+	
+	
+
+}

StevenDimDoors/mod_pocketDim/ItemChaosDoor.java

@@ -0,0 +1,44 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemDoor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class ItemChaosDoor extends itemDimDoor
+{
+    private Material doorMaterial;
+
+    public ItemChaosDoor(int par1, Material par2Material)
+    {
+    	  super(par1, par2Material);
+          this.doorMaterial = par2Material;
+          this.setCreativeTab(CreativeTabs.tabTransport);
+    }
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+    @Override
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    
+    		par3List.add("Caution- leads to random destination");
+    	
+    	
+
+
+    	
+    
+   
+    }
+    
+}

StevenDimDoors/mod_pocketDim/ItemRiftBlade.java

@@ -0,0 +1,281 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemRiftBlade extends itemDimDoor
+{
+    private Material doorMaterial;
+    Random rand = new Random();
+    public ItemRiftBlade(int par1, Material par2Material)
+    {
+    	 super(par1, par2Material);
+    	 this.setMaxStackSize(1);
+    	// this.setTextureFile("/PocketBlockTextures.png");
+         this.setCreativeTab(CreativeTabs.tabTransport);
+      
+
+      //   this.iconIndex=5;
+         this.setMaxDamage(500);
+         this.hasSubtypes=false;
+    	 //TODO move to proxy
+    }
+    
+    @SideOnly(Side.CLIENT)
+    @Override
+    public boolean hasEffect(ItemStack par1ItemStack)
+    {
+    	
+		
+    		return true;
+    	
+    }
+    public boolean hitEntity(ItemStack par1ItemStack, EntityLiving par2EntityLiving, EntityLiving par3EntityLiving)
+    {
+        par1ItemStack.damageItem(1, par3EntityLiving);
+        return true;
+    }
+    public int getDamageVsEntity(Entity par1Entity)
+    {
+        return 6;
+    }
+    
+    
+    public MovingObjectPosition getMovingObjectPositionFromPlayer(World par1World, EntityPlayer par2EntityPlayer, boolean par3)
+    {
+        float var4 = 1.0F;
+        float var5 = par2EntityPlayer.prevRotationPitch + (par2EntityPlayer.rotationPitch - par2EntityPlayer.prevRotationPitch) * var4;
+        float var6 = par2EntityPlayer.prevRotationYaw + (par2EntityPlayer.rotationYaw - par2EntityPlayer.prevRotationYaw) * var4;
+        double var7 = par2EntityPlayer.prevPosX + (par2EntityPlayer.posX - par2EntityPlayer.prevPosX) * (double)var4;
+        double var9 = par2EntityPlayer.prevPosY + (par2EntityPlayer.posY - par2EntityPlayer.prevPosY) * (double)var4 + 1.62D - (double)par2EntityPlayer.yOffset;
+        double var11 = par2EntityPlayer.prevPosZ + (par2EntityPlayer.posZ - par2EntityPlayer.prevPosZ) * (double)var4;
+        Vec3 var13 = par1World.getWorldVec3Pool().getVecFromPool(var7, var9, var11);
+        float var14 = MathHelper.cos(-var6 * 0.017453292F - (float)Math.PI);
+        float var15 = MathHelper.sin(-var6 * 0.017453292F - (float)Math.PI);
+        float var16 = -MathHelper.cos(-var5 * 0.017453292F);
+        float var17 = MathHelper.sin(-var5 * 0.017453292F);
+        float var18 = var15 * var16;
+        float var20 = var14 * var16;
+        double var21 = 5.0D;
+        if (par2EntityPlayer instanceof EntityPlayerMP)
+        {
+            var21 = 7;
+        }
+        Vec3 var23 = var13.addVector((double)var18 * var21, (double)var17 * var21, (double)var20 * var21);
+        return par1World.rayTraceBlocks_do_do(var13, var23, true, false);
+    }
+
+
+    protected boolean teleportToEntity(ItemStack item, Entity par1Entity, EntityPlayer holder)
+    {
+        Vec3 var2 = holder.worldObj.getWorldVec3Pool().getVecFromPool(holder.posX - par1Entity.posX, holder.boundingBox.minY + (double)(holder.height / 2.0F) - par1Entity.posY + (double)par1Entity.getEyeHeight(), holder.posZ - par1Entity.posZ);
+     
+      
+        double cooef =( var2.lengthVector()-2.5)/var2.lengthVector();
+        var2.xCoord*=cooef;
+        var2.yCoord*=cooef;
+        var2.zCoord*=cooef;
+        double var5 = holder.posX  - var2.xCoord;
+        double var9 = holder.posZ - var2.zCoord;
+        double var7 =holder.worldObj.getHeightValue(MathHelper.floor_double(var5), MathHelper.floor_double(var9));
+        if((Math.abs((holder.posY  - var2.yCoord)-var7)>2))
+        		{
+        			
+        			var7 = MathHelper.floor_double(holder.posY  - var2.yCoord) ;
+        			
+        			int var14 = MathHelper.floor_double(var5);
+        	        int var15 = MathHelper.floor_double(var7);
+        	        int var16 = MathHelper.floor_double(var9);
+        	        while(!holder.worldObj.isAirBlock(var14, var15, var16))
+        	        {
+        	        	var15++;
+        	        }
+        	        var7=var15;
+        		}
+
+
+        holder.setPositionAndUpdate(var5, var7, var9);
+        holder.playSound("mob.endermen.portal", 1.0F, 1.0F);
+        holder.worldObj.playSoundEffect(holder.posX, holder.posY, holder.posZ, "mob.endermen.portal", 1.0F, 1.0F);
+
+    
+        return true;
+    }
+
+    
+    public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+    {
+    	MovingObjectPosition hit = 	this.getMovingObjectPositionFromPlayer(par3EntityPlayer.worldObj, par3EntityPlayer, false );
+		if(hit!=null)
+		{
+			if(par2World.getBlockId(hit.blockX, hit.blockY, hit.blockZ)==mod_pocketDim.blockRiftID)
+			{
+				LinkData link = dimHelper.instance.getLinkDataFromCoords(hit.blockX, hit.blockY, hit.blockZ, par2World);
+				if(link!=null)
+				{
+				    
+	               Block var11 = mod_pocketDim.transientDoor;
+	               int par4 = hit.blockX;
+	               int par5 = hit.blockY-1;
+	               int par6 = hit.blockZ;
+	               int par7 = 0 ;
+	            
+	            
+	            
+
+	            if (par3EntityPlayer.canPlayerEdit(par4, par5, par6, par7, par1ItemStack) && par3EntityPlayer.canPlayerEdit(par4, par5 + 1, par6, par7, par1ItemStack)&&!par2World.isRemote)
+	            {
+	                int var12 = MathHelper.floor_double((double)((par3EntityPlayer.rotationYaw + 180.0F) * 4.0F / 360.0F) - 0.5D) & 3;
+
+	                if (!this.canPlace(par2World, par4, par5, par6, var12)||dimHelper.instance.getLinkDataFromCoords(par4, par5+1, par6, par2World)==null)
+	                {
+	                	
+	                }
+	               else 
+	                {
+	              
+	                    placeDoorBlock(par2World, par4, par5, par6, var12, var11);
+
+	                   
+	                   par1ItemStack.damageItem(10, par3EntityPlayer);
+	                
+	                }
+	            }
+				}
+			}
+			
+		}
+		
+		
+		if(!par3EntityPlayer.worldObj.isRemote)
+		{
+		List<EntityLiving> list =  par3EntityPlayer.worldObj.getEntitiesWithinAABB(EntityLiving.class, AxisAlignedBB.getBoundingBox( par3EntityPlayer.posX-7,par3EntityPlayer.posY-7, par3EntityPlayer.posZ-7, par3EntityPlayer.posX+7,par3EntityPlayer.posY+7, par3EntityPlayer.posZ+7));
+		list.remove(par3EntityPlayer);
+		  
+		
+		for(EntityLiving ent : list)
+		{
+			
+			  Vec3 var3 = par3EntityPlayer.getLook(1.0F).normalize();
+	            Vec3 var4 =  par3EntityPlayer.worldObj.getWorldVec3Pool().getVecFromPool(ent.posX -  par3EntityPlayer.posX, ent.boundingBox.minY + (double)((ent.height) / 2.0F) - ( par3EntityPlayer.posY + (double) par3EntityPlayer.getEyeHeight()), ent.posZ -  par3EntityPlayer.posZ);
+	            double var5 = var4.lengthVector();
+	            var4 = var4.normalize();
+	            double var7 = var3.dotProduct(var4);
+	            if( (var7+.1) > 1.0D - 0.025D / var5 ?  par3EntityPlayer.canEntityBeSeen(ent) : false)
+	            {
+	            	 System.out.println(list.size());
+	            	ItemRiftBlade.class.cast(par1ItemStack.getItem()).teleportToEntity(par1ItemStack,ent, par3EntityPlayer);
+	            	break;
+
+	            	//ItemRiftBlade.class.cast(item.getItem()).teleportTo(event.entityPlayer, ent.posX, ent.posY, ent.posZ);
+	            }
+		}
+	
+   
+		}
+		return par1ItemStack;
+    
+    }
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+
+    public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+    {
+        if (par7 != 1)
+        {
+            return false;
+        }
+        else
+        {
+            ++par5;
+            Block var11;
+
+          
+            
+                var11 = mod_pocketDim.transientDoor;
+            
+            
+            
+            
+
+            if (par2EntityPlayer.canPlayerEdit(par4, par5, par6, par7, par1ItemStack) && par2EntityPlayer.canPlayerEdit(par4, par5 + 1, par6, par7, par1ItemStack)&&!par3World.isRemote)
+            {
+                int var12 = MathHelper.floor_double((double)((par2EntityPlayer.rotationYaw + 180.0F) * 4.0F / 360.0F) - 0.5D) & 3;
+
+                if (!this.canPlace(par3World, par4, par5, par6, var12)||dimHelper.instance.getLinkDataFromCoords(par4, par5+1, par6, par3World)==null)
+                {
+                    return false;
+                }
+                else 
+                {
+                
+                    placeDoorBlock(par3World, par4, par5, par6, var12, var11);
+
+                   
+                   par1ItemStack.damageItem(10, par2EntityPlayer);
+                    return true;
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+    
+    @SideOnly(Side.CLIENT)
+
+    /**
+     * allows items to add custom lines of information to the mouseover description
+     */
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    	
+    
+    	
+    		par3List.add("Opens a temporary door");
+    		par3List.add ("when used on a rift");
+    		par3List.add ("Also rotates existing doors");
+
+
+
+    	
+    }
+    @Override
+    public void onCreated(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) 
+    {
+    	if(!par2World.isRemote)
+    	{
+    		/**
+    		//creates the first half of the link on item creation
+    		int key= dimHelper.instance.createUniqueInterDimLinkKey();
+    		LinkData linkData= new LinkData(par2World.provider.dimensionId,MathHelper.floor_double(par3EntityPlayer.posX),MathHelper.floor_double(par3EntityPlayer.posY),MathHelper.floor_double(par3EntityPlayer.posZ));
+    		System.out.println(key);
+
+    		dimHelper.instance.interDimLinkList.put(key, linkData);
+    		par1ItemStack.setItemDamage(key);
+    		**/
+    	}
+    }
+}

StevenDimDoors/mod_pocketDim/ItemRiftGoggles.java

@@ -0,0 +1,24 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.EnumArmorMaterial;
+import net.minecraft.item.ItemArmor;
+
+public class ItemRiftGoggles extends ItemArmor
+{
+    private Material doorMaterial;
+
+    public ItemRiftGoggles(int par1, int par2, int par3)
+    {
+    	  super(par1, EnumArmorMaterial.IRON, par1, par1);
+          this.setCreativeTab(CreativeTabs.tabRedstone);
+        //  this.setIconIndex(Item.doorWood.getIconFromDamage(0));
+    }
+    
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+}

StevenDimDoors/mod_pocketDim/ItemStableFabric.java

@@ -0,0 +1,54 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public class ItemStableFabric extends Item
+{
+    private Material doorMaterial;
+
+    public ItemStableFabric(int par1, int par2)
+    {
+    	  super(par1);
+          this.setCreativeTab(CreativeTabs.tabRedstone);
+        //  this.setIconIndex(Item.doorWood.getIconFromDamage(0));
+          this.setCreativeTab(CreativeTabs.tabTransport);
+
+    }
+    
+    public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+    {
+    	if(!par3World.isRemote)
+    	{
+    		LinkData link = new LinkData(par3World.provider.dimensionId, 0,  par4, par5+2, par6, par4, par5+2, par6, true);
+			link =dimHelper.instance.createPocket(link,true, true);
+    	}
+    	System.out.println("Block metadata is "+par3World.getBlockMetadata(par4, par5, par6));
+    	return true;
+    }
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    	
+    
+    	
+    		par3List.add("DEBUG/ADMIN ONLY ITEM");
+    		par3List.add ("on use creates a ");
+    		par3List.add ("random dungeon rift");
+
+
+
+    	
+    }
+}

StevenDimDoors/mod_pocketDim/LimboGenerator.java

@@ -0,0 +1,440 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.util.IProgressUpdate;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.ChunkPosition;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.IChunkProvider;
+import net.minecraft.world.gen.ChunkProviderGenerate;
+import net.minecraft.world.gen.MapGenBase;
+import net.minecraft.world.gen.MapGenRavine;
+import net.minecraft.world.gen.NoiseGeneratorOctaves;
+import net.minecraft.world.gen.feature.MapGenScatteredFeature;
+import net.minecraft.world.gen.structure.MapGenMineshaft;
+import net.minecraft.world.gen.structure.MapGenStronghold;
+import net.minecraft.world.gen.structure.MapGenVillage;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.Event.Result;
+import net.minecraftforge.event.terraingen.ChunkProviderEvent;
+
+public class LimboGenerator extends ChunkProviderGenerate implements IChunkProvider
+{
+	  private Random rand;
+
+	    /** A NoiseGeneratorOctaves used in generating terrain */
+	    private NoiseGeneratorOctaves noiseGen1;
+
+	    /** A NoiseGeneratorOctaves used in generating terrain */
+	    private NoiseGeneratorOctaves noiseGen2;
+
+	    /** A NoiseGeneratorOctaves used in generating terrain */
+	    private NoiseGeneratorOctaves noiseGen3;
+
+	    /** A NoiseGeneratorOctaves used in generating terrain */
+	    private NoiseGeneratorOctaves noiseGen4;
+
+	    /** A NoiseGeneratorOctaves used in generating terrain */
+	    public NoiseGeneratorOctaves noiseGen5;
+	    
+		public World world;
+		 private final byte[] field_82700_c = new byte[256];
+		    private final byte[] field_82698_d = new byte[256];
+
+	    /** A NoiseGeneratorOctaves used in generating terrain */
+	    public NoiseGeneratorOctaves noiseGen6;
+	    public NoiseGeneratorOctaves mobSpawnerNoise;
+
+	    /** Reference to the World object. */
+	    private World worldObj;
+
+	    /** are map structures going to be generated (e.g. strongholds) */
+	    private final boolean mapFeaturesEnabled = false;
+
+	    /** Holds the overall noise array used in chunk generation */
+	    private double[] noiseArray;
+	    private double[] stoneNoise = new double[256];
+	    private MapGenBase caveGenerator = new CustomCaveGen();
+
+	    /** Holds Stronghold Generator */
+	    private MapGenStronghold strongholdGenerator = new MapGenStronghold();
+
+	    /** Holds Village Generator */
+	    private MapGenVillage villageGenerator = new MapGenVillage();
+
+	    /** Holds Mineshaft Generator */
+	    private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();
+	    private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();
+
+	    /** Holds ravine generator */
+	    private MapGenBase ravineGenerator = new MapGenRavine();
+
+	    /** The biomes that are used to generate the chunk */
+	    private BiomeGenBase[] biomesForGeneration = new BiomeGenBase[1];
+
+	    /** A double array that hold terrain noise from noiseGen3 */
+	    double[] noise3;
+
+	    /** A double array that hold terrain noise */
+	    double[] noise1;
+
+	    /** A double array that hold terrain noise from noiseGen2 */
+	    double[] noise2;
+
+	    /** A double array that hold terrain noise from noiseGen5 */
+	    double[] noise5;
+
+	    /** A double array that holds terrain noise from noiseGen6 */
+	    double[] noise6;
+
+	    /**
+	     * Used to store the 5x5 parabolic field that is used during terrain generation.
+	     */
+	    float[] parabolicField;
+	    int[][] field_73219_j = new int[32][32];
+	    {
+	   //     caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE);
+
+	    }
+
+
+	public LimboGenerator(World par1World, long par2) 
+	{
+		
+		
+		
+		super(par1World, par2, false);
+		//par2 = 90899090;
+		 this.rand = new Random(par2);
+	        this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16); //base terrain
+	        this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16); //hillyness
+	        this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, 80);  //seems to adjust the size of features, how stretched things are -default 8
+	        this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4);
+	        this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
+	        this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
+	        this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
+
+	        NoiseGeneratorOctaves[] noiseGens = {noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise};
+	   //     noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.rand, noiseGens);
+	        this.noiseGen1 = noiseGens[0];
+	        this.noiseGen2 = noiseGens[1];
+	        this.noiseGen3 = noiseGens[2];
+	        this.noiseGen4 = noiseGens[3];
+	        this.noiseGen5 = noiseGens[4];
+	        this.noiseGen6 = noiseGens[5];
+	        this.mobSpawnerNoise = noiseGens[6];
+		// TODO Auto-generated constructor stub
+		this.worldObj=par1World;
+	}
+
+	@Override
+	public boolean chunkExists(int var1, int var2) {
+		// TODO Auto-generated method stub
+		return super.chunkExists(var1, var2);
+	}
+
+	@Override
+	public Chunk provideChunk(int par1, int par2)
+    {
+		this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
+        byte[] var3 = new byte[32768];
+        this.generateTerrain(par1, par2, var3);
+        this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);
+
+     
+       
+
+        Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
+    
+
+        var4.generateSkylightMap();
+        return var4;
+    }
+	@Override
+	public Chunk loadChunk(int var1, int var2) {
+		// TODO Auto-generated method stub
+		return super.provideChunk(var1, var2);
+	}
+
+	@Override
+	public void populate(IChunkProvider var1, int var2, int var3) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public boolean saveChunks(boolean var1, IProgressUpdate var2) {
+		// TODO Auto-generated method stub
+		return super.saveChunks(var1, var2);
+	}
+	 private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
+	    {
+	        ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
+	        MinecraftForge.EVENT_BUS.post(event);
+	        if (event.getResult() == Result.DENY) return event.noisefield;
+
+	        if (par1ArrayOfDouble == null)
+	        {
+	            par1ArrayOfDouble = new double[par5 * par6 * par7];
+	        }
+
+	        if (this.parabolicField == null)
+	        {
+	            this.parabolicField = new float[25];
+
+	            for (int var8 = -2; var8 <= 2; ++var8)
+	            {
+	                for (int var9 = -2; var9 <= 2; ++var9)
+	                {
+	                    float var10 = 10.0F / MathHelper.sqrt_float((float)(var8 * var8 + var9 * var9) + 0.2F);
+	                    this.parabolicField[var8 + 2 + (var9 + 2) * 5] = var10;
+	                }
+	            }
+	        }
+
+	        double var44 = 884.412D; //large values here create spiky land. add a 0, good -default 884
+	        double var45 = 9840.412D; //large values here make sheets- default - 684
+	        this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
+	        this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
+	        this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);
+	        this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, var44, var45, var44);
+	        this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44);
+	        boolean var43 = false;
+	        boolean var42 = false;
+	        int var12 = 0;
+	        int var13 = 0;
+
+	        for (int var14 = 0; var14 < par5; ++var14)
+	        {
+	            for (int var15 = 0; var15 < par7; ++var15)
+	            {
+	                float var16 = 0.0F;
+	                float var17 = 0.0F;
+	                float var18 = 0.0F;
+	                byte var19 = 2;
+	                BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)];
+
+	                for (int var21 = -var19; var21 <= var19; ++var21)
+	                {
+	                    for (int var22 = -var19; var22 <= var19; ++var22)
+	                    {
+	                        float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (BiomeGenBase.plains.minHeight + 9.0F);
+
+	                       
+//this adjusts the height of the terrain
+	                        
+	                        var16 += BiomeGenBase.plains.maxHeight * var24+4;
+	                        var17 += BiomeGenBase.plains.minHeight * var24-1;
+	                        var18 += var24;
+	                    }
+	                }
+
+	                var16 /= var18;
+	                var17 /= var18;
+	                var16 =  (var16 * 0.9F + 0.1F);
+	                var17 = (var17 * 4.0F - 1.0F) / 8.0F;
+	                double var47 = this.noise6[var13] / 8000.0D;
+
+	                if (var47 < 0.0D)
+	                {
+	                    var47 = -var47 * 0.3D;
+	                }
+
+	                var47 = var47 * 3.0D - 2.0D;
+
+	                if (var47 < 0.0D)
+	                {
+	                    var47 /= 2.0D;
+
+	                    if (var47 < -1.0D)
+	                    {
+	                        var47 = -1.0D;
+	                    }
+
+	                    var47 /= 1.4D;
+	                    var47 /= 2.0D;
+	                }
+	                else
+	                {
+	                    if (var47 > 1.0D)
+	                    {
+	                        var47 = 1.0D;
+	                    }
+
+	                    var47 /= 8.0D;
+	                }
+
+	                ++var13;
+
+	                for (int var46 = 0; var46 < par6; ++var46)
+	                {
+	                    double var48 = (double)var17;
+	                    double var26 = (double)var16;
+	                    var48 += var47 * 0.2D;
+	                    var48 = var48 * (double)par6 / 16.0D;
+	                    double var28 = (double)par6 / 2.0D + var48 * 4.0D;
+	                    double var30 = 0.0D;
+	                    double var32 = ((double)var46 - var28) * 12.0D * 128.0D / 128.0D / var26;
+
+	                    if (var32 < 0.0D)
+	                    {
+	                        var32 *= 4.0D;
+	                    }
+
+	                    double var34 = this.noise1[var12] / 512.0D;
+	                    double var36 = this.noise2[var12] / 512.0D;
+	                    double var38 = (this.noise3[var12] / 10.0D + 1.0D) / 2.0D;
+
+	                    if (var38 < 0.0D)
+	                    {
+	                        var30 = var34;
+	                    }
+	                    else if (var38 > 1.0D)
+	                    {
+	                        var30 = var36;
+	                    }
+	                    else
+	                    {
+	                        var30 = var34 + (var36 - var34) * var38;
+	                    }
+
+	                    var30 -= var32;
+
+	                    if (var46 > par6 - 4)
+	                    {
+	                        double var40 = (double)((float)(var46 - (par6 - 4)) / 3.0F);
+	                        var30 = var30 * (1.0D - var40) + -10.0D * var40;
+	                    }
+
+	                    par1ArrayOfDouble[var12] = var30;
+	                    ++var12;
+	                }
+	            }
+	        }
+
+	        return par1ArrayOfDouble;
+	    }
+	public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte)
+    {
+        byte var4 = 4;
+        byte var5 = 16;
+        byte var6 = 16;
+        int var7 = var4 + 1;
+        byte var8 = 17;
+        int var9 = var4 + 1;
+        this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, var7 + 5, var9 + 5);
+        this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * var4, 0, par2 * var4, var7, var8, var9);
+
+        for (int var10 = 0; var10 < var4; ++var10)
+        {
+            for (int var11 = 0; var11 < var4; ++var11)
+            {
+                for (int var12 = 0; var12 < var5; ++var12)
+                {
+                    double var13 = 0.125D;
+                    double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];
+                    double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];
+                    double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];
+                    double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];
+                    double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;
+                    double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;
+                    double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;
+                    double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;
+
+                    for (int var31 = 0; var31 < 8; ++var31)
+                    {
+                        double var32 = 0.25D;
+                        double var34 = var15;
+                        double var36 = var17;
+                        double var38 = (var19 - var15) * var32;
+                        double var40 = (var21 - var17) * var32;
+
+                        for (int var42 = 0; var42 < 4; ++var42)
+                        {
+                            int var43 = var42 + var10 * 4 << 11 | 0 + var11 * 4 << 7 | var12 * 8 + var31;
+                            short var44 = 128;
+                            var43 -= var44;
+                            double var45 = 0.25D;
+                            double var49 = (var36 - var34) * var45;
+                            double var47 = var34 - var49;
+
+                            for (int var51 = 0; var51 < 4; ++var51)
+                            {
+                                if ((var47 += var49) > 0.0D)
+                                {
+                                    par3ArrayOfByte[var43 += var44] = (byte)mod_pocketDim.blockLimboID;
+                                }
+                                else if (var12 * 8 + var31 < var6)
+                                {
+                                    par3ArrayOfByte[var43 += var44] = (byte)mod_pocketDim.blockDimWallPermID;
+                                }
+                                else
+                                {
+                                    par3ArrayOfByte[var43 += var44] = 0;
+                                }
+                            }
+
+                            var34 += var38;
+                            var36 += var40;
+                        }
+
+                        var15 += var23;
+                        var17 += var25;
+                        var19 += var27;
+                        var21 += var29;
+                    }
+                }
+            }
+        }
+    }
+
+	@Override
+	public boolean unload100OldestChunks() {
+		// TODO Auto-generated method stub
+		return super.unload100OldestChunks();
+	}
+
+	@Override
+	public boolean canSave() {
+		// TODO Auto-generated method stub
+		return super.canSave();
+	}
+
+	@Override
+	public String makeString() {
+		// TODO Auto-generated method stub
+		return super.makeString();
+	}
+
+	@Override
+	public List getPossibleCreatures(EnumCreatureType var1, int var2, int var3,
+			int var4) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public ChunkPosition findClosestStructure(World var1, String var2,
+			int var3, int var4, int var5) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public int getLoadedChunkCount() {
+		// TODO Auto-generated method stub
+		return super.getLoadedChunkCount();
+	}
+
+	@Override
+	public void recreateStructures(int var1, int var2) {
+		// TODO Auto-generated method stub
+		
+	}
+	
+}

StevenDimDoors/mod_pocketDim/LimboProvider.java

@@ -0,0 +1,161 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.ChunkCoordinates;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.EnumGameType;
+import net.minecraft.world.WorldProvider;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraft.world.chunk.IChunkProvider;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+
+public class LimboProvider extends WorldProvider
+{
+
+	@Override
+	public String getDimensionName() {
+		// TODO Auto-generated method stub
+		return "Limbo";
+	}
+
+	public int exitXCoord;
+	public int exitYCoord;
+	public int exitZCoord;
+	public int exitDimID;
+	public LimboProvider()
+	{
+		this.hasNoSky=true;
+		//  super.setAllowedSpawnTypes(false, false);
+		
+	}
+	  public boolean canRespawnHere()
+	    {
+	        return true;
+	    }
+	
+	
+	
+	  @Override
+	    public boolean canSnowAt(int x, int y, int z)
+	    {
+	        return false;
+	    }
+	@Override
+	 protected void generateLightBrightnessTable()
+	    {
+	        float modifier = 0.0F;
+
+	        for (int steps = 0; steps <= 15; ++steps)
+	        {
+	            float var3 = 1.0F - (float)steps / 15.0F;
+	            this.lightBrightnessTable[steps] = ((0.0F + var3) / (var3 * 3.0F + 1.0F) * (1.0F - modifier) + modifier)*3;
+	       //     System.out.println( this.lightBrightnessTable[steps]+"light");
+	        }
+	    }
+	 
+	public void setAllowedSpawnTypes(boolean allowHostile, boolean allowPeaceful)
+    {
+        super.setAllowedSpawnTypes(false, false);
+      
+    }
+
+	 public float calculateCelestialAngle(long par1, float par3)
+	    {
+	        int var4 = (int)(par1 % 24000L);
+	        float var5 = ((float)var4 + par3) / 24000.0F - 0.25F;
+
+	        if (var5 < 0.0F)
+	        {
+	            ++var5;
+	        }
+
+	        if (var5 > 1.0F)
+	        {
+	            --var5;
+	        }
+
+	        float var6 = var5;
+	        var5 = 1.0F - (float)((Math.cos((double)var5 * Math.PI) + 1.0D) / 2.0D);
+	        var5 = var6 + (var5 - var6) / 3.0F;
+	        return 0;
+	    }
+
+	    @SideOnly(Side.CLIENT)
+	    public int getMoonPhase(long par1, float par3)
+	    {
+	        return 4;
+	    }
+
+    @SideOnly(Side.CLIENT)
+	@Override
+	public String getSaveFolder()
+    {
+        return (dimensionId == 0 ? null : "DimensionalDoors/Limbo" + dimensionId);
+    }
+    
+    public boolean canCoordinateBeSpawn(int par1, int par2)
+    {
+        int var3 = this.worldObj.getFirstUncoveredBlock(par1, par2);
+        return var3 == mod_pocketDim.blockLimboID;
+    }
+    @Override
+	public double getHorizon()
+    {
+        return worldObj.getHeight()/4-800;
+    }
+	public Vec3 getSkyColor(Entity cameraEntity, float partialTicks)
+	{
+    	setCloudRenderer( new CloudRenderBlank());
+        return this.worldObj.getWorldVec3Pool().getVecFromPool((double)0, (double)0, (double)0);
+
+	}
+    @SideOnly(Side.CLIENT)
+	@Override
+	public Vec3 getFogColor(float par1, float par2)
+    {
+        return this.worldObj.getWorldVec3Pool().getVecFromPool((double).2, (double).2, (double).2);
+
+    }
+    public int getRespawnDimension(EntityPlayerMP player)
+    {
+        return 0;
+    }
+	
+	@Override
+	public IChunkProvider createChunkGenerator()
+	{
+		return new LimboGenerator(worldObj, 45);
+	}
+	  public boolean canBlockFreeze(int x, int y, int z, boolean byWater)
+	    {
+	        return false;
+	    }
+
+	@Override
+	 public ChunkCoordinates getRandomizedSpawnPoint()
+    {
+        ChunkCoordinates var5 = new ChunkCoordinates(this.worldObj.getSpawnPoint());
+
+        boolean isAdventure = worldObj.getWorldInfo().getGameType() == EnumGameType.ADVENTURE;
+        int spawnFuzz = 10000;
+        int spawnFuzzHalf = spawnFuzz / 2;
+
+        {
+            var5.posX += this.worldObj.rand.nextInt(spawnFuzz) - spawnFuzzHalf;
+            var5.posZ += this.worldObj.rand.nextInt(spawnFuzz) - spawnFuzzHalf;
+            var5.posY = 700;
+        }
+
+        return var5;
+    
+		
+	}
+	
+
+
+	
+	
+}

StevenDimDoors/mod_pocketDim/LinkData.java

@@ -0,0 +1,72 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.io.Serializable;
+
+public class LinkData implements Serializable
+{
+	
+	public int locXCoord;
+	public int locYCoord;
+	public int locZCoord;
+	
+	public int destXCoord;
+	public int destYCoord;
+	public int destZCoord;
+	public int numberofChildren;
+	public boolean isLocPocket;
+	public int linkOrientation;
+	
+
+	
+	public int destDimID;
+	public int locDimID;
+	
+	public boolean exists=false;
+	public boolean hasGennedDoor=false;
+	
+	static final long serialVersionUID = 45544342L;
+	
+	
+	public LinkData()
+	{
+		this.exists=false;
+	}
+	
+	 public LinkData(int exitLinkDimID,  int exitX, int exitY, int exitZ)
+	 {
+		 this.destDimID=exitLinkDimID;
+		 this.destXCoord=exitX;
+		 this.destYCoord=exitY;
+		 this.destZCoord=exitZ;
+	 }
+
+	public LinkData(int locationDimID, int destinationDimID,   int locationXCoord, int locationYCoord, int locationZCoord, int destinationXCoord, int destinationYCoord, int destinationZCoord, boolean isPocket)
+	{
+		
+		this.exists=true;
+		this.locXCoord=locationXCoord;
+		this.locYCoord=locationYCoord;
+		this.locZCoord=locationZCoord;
+		
+		this.destXCoord=destinationXCoord;
+		this.destYCoord=destinationYCoord;
+		this.destZCoord=destinationZCoord;
+		
+		this.destDimID=destinationDimID;
+		this.locDimID=locationDimID;
+		this.isLocPocket=isPocket;
+		
+		
+
+	}
+	 
+	public void printLinkData()
+	{
+		
+		
+		System.out.println(String.valueOf(this.locDimID)+"locDimID "+String.valueOf(this.locXCoord)+"-locXCoord "+String.valueOf(this.locYCoord)+"-locYCoord "+String.valueOf(this.locZCoord)+"-locZCoord ");
+		System.out.println(String.valueOf(this.destDimID)+"DestDimID "+String.valueOf(this.destXCoord)+"-destXCoord "+String.valueOf(this.destYCoord)+"-destYCoord "+String.valueOf(this.destZCoord)+"-destZCoord ");
+		
+
+	}
+}

StevenDimDoors/mod_pocketDim/ObjectSaveInputStream.java

@@ -0,0 +1,43 @@
+package StevenDimDoors.mod_pocketDim;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InvalidClassException;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamClass;
+import java.util.logging.Logger;
+
+
+public class ObjectSaveInputStream extends ObjectInputStream {
+
+  //  private static Logger logger = LoggerFactory.getLogger(ObjectSaveInputStream.class);
+
+    public ObjectSaveInputStream(InputStream in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
+        ObjectStreamClass resultClassDescriptor = super.readClassDescriptor(); // initially streams descriptor
+        Class localClass; // the class in the local JVM that this descriptor represents.
+        try {
+            localClass = Class.forName(resultClassDescriptor.getName()); 
+        } catch (ClassNotFoundException e) {
+         //   logger.error("No local class for " + resultClassDescriptor.getName(), e);
+            return resultClassDescriptor;
+        }
+        ObjectStreamClass localClassDescriptor = ObjectStreamClass.lookup(localClass);
+        if (localClassDescriptor != null) { // only if class implements serializable
+            final long localSUID = localClassDescriptor.getSerialVersionUID();
+            final long streamSUID = resultClassDescriptor.getSerialVersionUID();
+            if (streamSUID != localSUID) { // check for serialVersionUID mismatch.
+                final StringBuffer s = new StringBuffer("Overriding serialized class version mismatch: ");
+                s.append("local serialVersionUID = ").append(localSUID);
+                s.append(" stream serialVersionUID = ").append(streamSUID);
+                Exception e = new InvalidClassException(s.toString());
+           //     logger.error("Potentially Fatal Deserialization Operation.", e);
+                resultClassDescriptor = localClassDescriptor; // Use local class descriptor for deserialization
+            }
+        }
+        return resultClassDescriptor;
+    }
+}

StevenDimDoors/mod_pocketDim/OldSaveHandler.java

@@ -0,0 +1,137 @@
+
+package StevenDimDoors.mod_pocketDim;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.util.Collection;
+import java.util.HashMap;
+
+public class OldSaveHandler {
+
+  private OldSaveHandler() {}
+ 
+  public static final void copy( File source, File destination ) throws IOException 
+  {
+    if( source.isDirectory() ) 
+    {
+      copyDirectory( source, destination );
+    } else 
+    {
+      copyFile( source, destination );
+    }
+  }
+ 
+  public static final void copyDirectory( File source, File destination ) throws IOException 
+  {
+    if( !source.isDirectory() ) 
+    {
+      throw new IllegalArgumentException( "Source (" + source.getPath() + ") must be a directory." );
+    }
+   
+    if( !source.exists() ) 
+    {
+      throw new IllegalArgumentException( "Source directory (" + source.getPath() + ") doesn't exist." );
+    }
+   
+    if( destination.exists() ) 
+    {
+      throw new IllegalArgumentException( "Destination (" + destination.getPath() + ") exists." );
+    }
+   
+    destination.mkdirs();
+    File[] files = source.listFiles();
+   
+    for( File file : files ) 
+    {
+      if( file.isDirectory() ) 
+      {
+        copyDirectory( file, new File( destination, file.getName() ) );
+      } else 
+      {
+        copyFile( file, new File( destination, file.getName() ) );
+      }
+    }
+  }
+ 
+  public static void handleOldSaveData(File oldSaveData) throws IOException, ClassNotFoundException
+	{
+    
+		
+      
+      try
+      {
+    	  
+
+  		FileInputStream oldSaveInput = new FileInputStream(oldSaveData);
+  	    ObjectSaveInputStream save = new ObjectSaveInputStream(oldSaveInput);
+  	    HashMap comboSave =((HashMap)save.readObject());
+  	         
+  		System.out.println("FOUND OLD SAVE DATA");
+    
+     	HashMap oldDimList =(HashMap) comboSave.get("dimList");
+     	
+     	Collection<Steven.Common.mod_pocketDim.DimData> AllDims = oldDimList.values();
+     	for(Steven.Common.mod_pocketDim.DimData oldDimData : AllDims)
+     	{
+     			DimData newDimData = new DimData(oldDimData.dimID, oldDimData.isPocket, oldDimData.depth,  oldDimData.exitDimLink.destDimID, oldDimData.exitDimLink.destXCoord , oldDimData.exitDimLink.destYCoord,oldDimData.exitDimLink.destZCoord);
+     			newDimData.hasBeenFilled=oldDimData.hasBeenFilled;
+     			newDimData.isDimRandomRift=oldDimData.isDimRandomRift;
+     			dimHelper.dimList.put(newDimData.dimID, newDimData);
+     			
+     			
+     			for(Steven.Common.mod_pocketDim.LinkData oldLinkData : oldDimData.getAllLinkData())
+     			{
+     				dimHelper.instance.createLink(oldLinkData.locDimID, oldLinkData.destDimID, oldLinkData.locXCoord, oldLinkData.locYCoord, oldLinkData.locZCoord, oldLinkData.destXCoord, oldLinkData.destYCoord, oldLinkData.destZCoord);
+     				oldLinkData.printLinkData();
+     			}
+     		
+     			
+     			File oldSave= new File(oldSaveData.getParentFile().getParent()+ "/DIM"+oldDimData.dimID);
+				System.out.println(oldSaveData.getParentFile().getParent()+ "/DIM"+oldDimData.dimID+" is Being Copied to "+ oldSaveData.getParentFile().getParent()+"DimensionalDoors"  );
+
+  			if(oldSave.exists())
+  			{
+  				
+  				try
+  				{
+  					OldSaveHandler.copyDirectory(  oldSave, new File( oldSaveData.getParentFile().getParent()+"/DimensionalDoors/pocketDimID"+oldDimData.dimID ));
+  					
+  				}
+  				catch(Exception e)
+  				{
+  					e.printStackTrace();
+  				}
+  			}
+     			
+     			
+     			
+     			
+     		
+     		
+     		}
+     	save.close();
+     		oldSaveInput.close();
+     		dimHelper.instance.save();
+     		System.out.println(oldSaveData.delete());
+     	
+      } 
+      catch(Exception e)
+      {
+    	oldSaveData.renameTo(new File(oldSaveData.getAbsoluteFile()+"-restore failed"));
+      	e.printStackTrace();
+      	System.out.println("Could not load pocket dim list. Saves probably lost, but repairable. Move the files from indivual pocket dim files to active ones. See MC thread for details.");
+      }
+    
+	}
+  public static final void copyFile( File source, File destination ) throws IOException
+  {
+    FileChannel sourceChannel = new FileInputStream( source ).getChannel();
+    FileChannel targetChannel = new FileOutputStream( destination ).getChannel();
+    sourceChannel.transferTo(0, sourceChannel.size(), targetChannel);
+    sourceChannel.close();
+    targetChannel.close();
+  }
+} 

StevenDimDoors/mod_pocketDim/PacketHandler.java

@@ -0,0 +1,415 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.Packet250CustomPayload;
+
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteStreams;
+
+import cpw.mods.fml.common.network.IPacketHandler;
+import cpw.mods.fml.common.network.PacketDispatcher;
+import cpw.mods.fml.common.network.Player;
+
+public class PacketHandler implements IPacketHandler 
+{
+	public static int regsiterDimPacketID = 3;
+	public static int registerLinkPacketID = 4;
+	public static int removeLinkPacketID = 5;
+	public static int linkKeyPacketID = 7;
+	public static int dimPacketID = 6;
+
+
+	public static int dimUpdatePacketID = 1;
+
+	
+
+        @Override
+        public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player) 
+        {
+               
+                if (packet.channel.equals("GenericRandom")) 
+                { 
+                	handleRandom(packet,player);      
+                      
+                }
+                
+        }
+       
+        private void handleRandom(Packet250CustomPayload packet, Player player) 
+        {
+                ByteArrayDataInput data =  ByteStreams.newDataInput(packet.data);
+              
+                int id=data.readByte();
+              
+                
+                
+              
+                
+                if(id==regsiterDimPacketID)
+                {
+                
+                
+                
+                		int dimId = data.readInt();
+                	//	System.out.println("regsitered dim ID" + dimId);
+                		try
+                		{
+                			DimData dimDataToAdd = new DimData(dimId, data.readBoolean(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt());
+
+                			if(!dimHelper.dimList.containsKey(dimId))
+                			{
+                			dimHelper.dimList.put(dimId, dimDataToAdd);
+                			}
+                			if(dimDataToAdd.isPocket)
+                			{
+                			dimHelper.registerDimension(dimId, mod_pocketDim.providerID);
+                			//System.out.println("regsitered dim ID" + dimId);
+                			}
+
+                		}
+                		catch (Exception e)
+                		{
+                		//	e.printStackTrace();
+                			if(dimId!=0)
+                			{
+                			//	System.out.println(String.valueOf(dimId)+"dimID already registered");
+                			}
+                		}
+                	
+                
+                }
+                
+                if(id==registerLinkPacketID)
+                {
+                
+                
+                
+                	
+                		int dimId = data.readInt();
+                		try
+                		{
+                			DimData dimDataToAddLink= dimHelper.dimList.get(dimId);
+
+                			LinkData linkToAdd = new LinkData(dimId, data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readBoolean());
+                			linkToAdd.hasGennedDoor=data.readBoolean();
+                			linkToAdd.linkOrientation=data.readInt();
+                			
+                			dimHelper.instance.createLink(linkToAdd);
+                			
+                		}
+                		catch (Exception e)
+                		{
+                			e.printStackTrace();
+                			System.out.println("Tried to update client link data & failed!");
+                		}
+                	
+                
+                }
+                if(id==removeLinkPacketID)
+                {
+                
+                
+                
+                	
+                		int dimId = data.readInt();
+                		try
+                		{
+                			DimData dimDataToRemoveFrom= dimHelper.dimList.get(dimId);
+
+                			LinkData linkToAdd = new LinkData(dimId, data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readInt(), data.readBoolean());
+                			dimDataToRemoveFrom.removeLinkAtCoords(linkToAdd.locDimID, linkToAdd.locXCoord,linkToAdd.locYCoord, linkToAdd.locZCoord);
+                			
+                			dimHelper.instance.linksForRendering.remove(linkToAdd);
+                		}
+                		catch (Exception e)
+                		{
+                			//e.printStackTrace();
+                			System.out.println("Tried to update client link data & failed!");
+                		}
+                	
+                
+                }
+                if(id==this.linkKeyPacketID)
+                {
+                	LinkData link = new LinkData(data.readInt(), data.readInt(), data.readInt(), data.readInt());
+                	dimHelper.instance.interDimLinkList.put(data.readInt(), link);
+                }
+               
+              
+               
+        }
+        
+		public static void onClientJoinPacket(INetworkManager manager, HashMap<Integer, DimData> dimList)
+		{
+			
+			Collection<Integer> dimIDs= dimList.keySet();
+			Collection<DimData> dimDataSet= dimList.values();
+			Collection<Packet250CustomPayload> packetsToSend = new HashSet();
+			
+
+			
+			for(DimData data : dimDataSet)
+			{
+				
+				manager.addToSendQueue(PacketHandler.onDimCreatedPacket(data));
+				 	
+				 	Collection <HashMap<Integer, HashMap<Integer,  LinkData>>> linkList = data.linksInThisDim.values();
+				 	
+				 	for(HashMap map :  linkList )
+				 	{
+				 		
+				 		Collection <HashMap<Integer,  LinkData>> linkList2 = map.values();
+				 		
+				 		for(HashMap map2 : linkList2)
+				 		{
+					 		Collection <LinkData> linkList3 = map2.values();
+					 		
+					 		for(LinkData link : linkList3)
+					 		{
+					 			
+					 			packetsToSend.add(( PacketHandler.onLinkCreatedPacket(link)));
+
+								
+					 		}
+
+				 			
+				 			
+				 		}
+				 		
+				 	}
+				 	
+				 	
+				 	
+				 	
+				 	
+			}
+			for (Packet250CustomPayload packet : packetsToSend)
+			{
+				manager.addToSendQueue(packet);
+			}
+			
+		}
+	
+		
+		public static Packet250CustomPayload onLinkCreatedPacket(LinkData link)
+		{
+			ByteArrayOutputStream bos = new ByteArrayOutputStream();
+			DataOutputStream  dataOut = new DataOutputStream(bos);
+			 
+			 try
+			    {
+				 	
+				 	dataOut.writeByte(PacketHandler.registerLinkPacketID);
+			    	dataOut.writeInt(link.locDimID);
+			    	dataOut.writeInt(link.destDimID);
+			    	dataOut.writeInt(link.locXCoord);
+			    	dataOut.writeInt(link.locYCoord);
+			    	dataOut.writeInt(link.locZCoord);
+			    	dataOut.writeInt(link.destXCoord);
+			    	dataOut.writeInt(link.destYCoord);
+			    	dataOut.writeInt(link.destZCoord);
+			    	dataOut.writeBoolean(link.isLocPocket);
+			    	dataOut.writeBoolean(link.hasGennedDoor);
+			    	dataOut.writeInt(link.linkOrientation);
+
+			    	
+			    	
+			    }
+			    
+			    
+			    
+			    catch (IOException e) 
+			    {
+			        e.printStackTrace();
+			    }
+			 
+			 	Packet250CustomPayload packet= new Packet250CustomPayload();
+			 	packet.channel="GenericRandom";
+			 	packet.data = bos.toByteArray();
+			 	packet.length = bos.size();;
+			 	PacketDispatcher.sendPacketToAllPlayers(packet);
+			 	return packet;
+		}
+		
+		
+		public static Packet250CustomPayload linkKeyPacket(LinkData link, int key)
+		{
+			ByteArrayOutputStream bos = new ByteArrayOutputStream();
+			DataOutputStream  dataOut = new DataOutputStream(bos);
+			 
+			 try
+			    {
+				 	
+				 	dataOut.writeByte(PacketHandler.linkKeyPacketID);
+			    	
+			    	dataOut.writeInt(link.destDimID);
+			    	dataOut.writeInt(link.destXCoord);
+			    	dataOut.writeInt(link.destYCoord);
+			    	dataOut.writeInt(link.destZCoord);
+			    	dataOut.writeInt(key);
+
+			    	
+			    	
+			    }
+			    
+			    
+			    
+			    catch (IOException e) 
+			    {
+			        e.printStackTrace();
+			    }
+			 
+			 	Packet250CustomPayload packet= new Packet250CustomPayload();
+			 	packet.channel="GenericRandom";
+			 	packet.data = bos.toByteArray();
+			 	packet.length = bos.size();;
+			 	PacketDispatcher.sendPacketToAllPlayers(packet);
+			 	return packet;
+		}
+		
+		
+		public static void onLinkRemovedPacket(LinkData link)
+		{
+			ByteArrayOutputStream bos = new ByteArrayOutputStream();
+			DataOutputStream  dataOut = new DataOutputStream(bos);
+			
+			 
+			 try
+			    {
+				 	
+				 	dataOut.writeByte(PacketHandler.removeLinkPacketID);
+			    	dataOut.writeInt(link.locDimID);
+			    	dataOut.writeInt(link.destDimID);
+			    	dataOut.writeInt(link.locXCoord);
+			    	dataOut.writeInt(link.locYCoord);
+			    	dataOut.writeInt(link.locZCoord);
+			    	dataOut.writeInt(link.destXCoord);
+			    	dataOut.writeInt(link.destYCoord);
+			    	dataOut.writeInt(link.destZCoord);
+			    	dataOut.writeBoolean(link.isLocPocket);
+			    	
+			    	
+			    	
+			    }
+			    
+			    
+			    
+			    catch (IOException e) 
+			    {
+			        e.printStackTrace();
+			    }
+			 
+			 	Packet250CustomPayload packet= new Packet250CustomPayload();
+			 	packet.channel="GenericRandom";
+			 	packet.data = bos.toByteArray();
+			 	packet.length = bos.size();;
+			 	PacketDispatcher.sendPacketToAllPlayers(packet);
+		}
+		
+		
+		public static Packet250CustomPayload onDimCreatedPacket(DimData data)
+		{
+
+
+			 ByteArrayOutputStream bos = new ByteArrayOutputStream();
+			 DataOutputStream dataOut = new DataOutputStream(bos);
+			 
+			 
+			 try
+			    {
+				 	
+				 	dataOut.writeByte(PacketHandler.regsiterDimPacketID);
+			    	dataOut.writeInt(data.dimID);
+			    	dataOut.writeBoolean(data.isPocket);
+
+			    	dataOut.writeInt(data.depth);
+			    	dataOut.writeInt(data.exitDimLink.destDimID);
+			    	dataOut.writeInt(data.exitDimLink.destXCoord);
+			    	dataOut.writeInt(data.exitDimLink.destYCoord);
+			    	dataOut.writeInt(data.exitDimLink.destZCoord);
+
+			    	
+			    	
+			    	
+			    }
+			    
+			    
+			    
+			    catch (IOException e) 
+			    {
+			        e.printStackTrace();
+			    }
+			 
+			 	Packet250CustomPayload packet= new Packet250CustomPayload();
+			 	packet.channel="GenericRandom";
+			 	packet.data = bos.toByteArray();
+			 	packet.length = bos.size();
+			 	
+			 	PacketDispatcher.sendPacketToAllPlayers(packet);
+			 	return packet;
+         
+		
+		}
+		/**
+		 private void handleObjectPacket(Packet250CustomPayload packet, Player player) 
+	        {
+	                ObjectInputStream data =  new ObjectInputStream;
+	                int length = data.readInt();
+	                int id=data.readByte();
+	                System.out.println(id);
+	                if(id==dimPacketID)
+	                {
+	                
+	                
+	                
+	                	
+	                		
+	                		try
+	                		{
+	                			DimData dimData = data.read
+	                			
+	                			dimHelper.dimList.put(key, value)
+	                			
+	                		}
+	                		catch (Exception e)
+	                		{
+	                			e.printStackTrace();
+	                		}
+	                	
+	                
+	                }
+	        }
+		**/
+		public static void sendDimObject(DimData dim)
+		{
+			 try 
+			 {
+				 ByteArrayOutputStream bos = new ByteArrayOutputStream();
+				 ObjectOutputStream dataOut = new ObjectOutputStream(bos);
+				 dataOut.writeObject(dim);
+				 
+					Packet250CustomPayload packet= new Packet250CustomPayload();
+				 	packet.channel="GenericRandom";
+				 	packet.data = bos.toByteArray();
+				 	packet.length = bos.size();;
+				 	PacketDispatcher.sendPacketToAllPlayers(packet);
+			 } 
+			 catch (IOException e) 
+			 
+			 
+			 {
+				e.printStackTrace();
+			 }
+		}
+
+
+
+}

StevenDimDoors/mod_pocketDim/PlayerRespawnTracker.java

@@ -0,0 +1,63 @@
+
+
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+import cpw.mods.fml.common.IPlayerTracker;
+
+
+public class PlayerRespawnTracker implements IPlayerTracker
+{
+	
+
+	@Override
+	public void onPlayerLogin(EntityPlayer player) {
+		// TODO Auto-generated method stub
+	
+	}
+
+	@Override
+	public void onPlayerLogout(EntityPlayer player) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void onPlayerChangedDimension(EntityPlayer player) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void onPlayerRespawn(EntityPlayer player) 
+	{
+		if(player.worldObj.provider.dimensionId==mod_pocketDim.limboDimID)
+			{
+			
+			if(!player.worldObj.isRemote)
+			{
+
+				for(EntityItem drop :  mod_pocketDim.limboSpawnInventory)
+				{
+					
+					player.inventory.addItemStackToInventory(drop.func_92014_d());
+				
+				
+				}
+			
+				
+				
+			
+			}
+		
+		}
+
+		
+		
+	}
+	
+}

StevenDimDoors/mod_pocketDim/Point3D.java

@@ -0,0 +1,58 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.io.Serializable;
+public class Point3D implements Serializable {
+ 
+    private  int x;
+    private  int y;
+    private  int z;
+ 
+     public Point3D(int x, int y,int z) 
+     
+     
+     {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+ 
+    public int getX() 
+    {
+        return x;
+    }
+ 
+    public int getY() 
+    {
+        return y;
+    }
+    
+    public int getZ() 
+    {
+        return z;
+    }
+ 
+      public int setY(int y) 
+      {
+        return this.y=y;
+    }
+       public int setX(int x) 
+       {
+        return this. x=x;
+    }
+     public int setZ(int z) 
+     {
+        return this. z=z;
+    }
+ public boolean equals(Object other) 
+ {
+    boolean result = false;
+    if (other instanceof Point3D) 
+    {
+        Point3D that = (Point3D) other;
+        result = (this.getX() == that.getX() && this.getY() == that.getY()&& this.getY() == that.getZ());
+    }
+    return result;
+}
+ 
+ 
+}

StevenDimDoors/mod_pocketDim/RiftGenerator.java

@@ -0,0 +1,251 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.IChunkProvider;
+import cpw.mods.fml.common.IWorldGenerator;
+
+public class RiftGenerator implements IWorldGenerator
+{
+    private int minableBlockId;
+    private int numberOfBlocks;
+    int cycles=40;
+    boolean shouldSave = false;
+    int count = 0;
+    int i;
+    int k;
+    int j;
+    Random rand = new Random();
+    boolean shouldGenHere=true;
+    LinkData link;
+   
+    
+    DimData dimData;
+
+    @Override
+    public void generate(Random random, int chunkX, int chunkZ, World world,	IChunkProvider chunkGenerator, IChunkProvider chunkProvider)
+    {
+    	//Long ntime = System.nanoTime();
+    	shouldGenHere=true;
+    	  
+    	if(world.provider.getDimensionName()=="PocketDim"||!mod_pocketDim.riftsInWorldGen ||world.isRemote)
+        {
+    	
+    			this.shouldGenHere=false;
+    			
+        	
+        }
+    	
+    
+    	if(this.shouldGenHere)
+    	{
+    
+         
+    		if(random.nextInt(3500)==0)
+    		{
+    			i=chunkX*16-random.nextInt(16);
+    			k=chunkZ*16-random.nextInt(16);
+    
+    			j= world.getHeightValue(i, k);
+			
+    			if(j>20&&world.getBlockId(i, j, k)==0)
+    			{
+		//			System.out.println(String.valueOf(i)+"x "+String.valueOf(j)+"y "+String.valueOf(k)+"z"+"Large gen");
+				
+    				link = new LinkData(world.provider.dimensionId, 0,  i, j+1, k, i, j+1, k, true);
+    				link = dimHelper.instance.createPocket(link,true, true);
+    				this.shouldSave=true;
+    		
+			
+		//	SchematicLoader loader = new SchematicLoader();
+		//	loader.init(link);
+		//	loader.generateSchematic(link);
+			
+    	
+    				count=0;
+    				while(random.nextInt(4)!=1)
+    				{
+    					i=chunkX*16-random.nextInt(16);
+    					k=chunkZ*16-random.nextInt(16);
+        
+    					j= world.getHeightValue(i, k);
+        	
+    					if(world.isAirBlock(i, j+1, k))
+    					{
+    				
+    					
+        				 
+    						 link = dimHelper.instance.createLink(link.locDimID,link.destDimID, i, j+1, k,link.destXCoord,link.destYCoord,link.destZCoord);
+    						 
+
+        				
+
+    					
+    				
+        	
+    					}
+        	 
+    				}
+         
+    			}
+    		}
+    	
+    		if(random.nextInt(540)==0)
+    		{
+    			i=chunkX*16-random.nextInt(16);
+    			k=chunkZ*16-random.nextInt(16);
+    
+    			j= world.getHeightValue(i, k);
+    			if(j>20&&world.getBlockId(i, j, k)==0)
+    			{
+    				//System.out.println(String.valueOf(i)+"x "+String.valueOf(j)+"y "+String.valueOf(k)+"z"+"med gen");
+
+    				link = new LinkData(world.provider.dimensionId, 0,  i, j+1, k, i, j+1, k, true);
+    				link = dimHelper.instance.createPocket(link,true, true);
+    				this.shouldSave=true;
+			
+			
+    				//	SchematicLoader loader = new SchematicLoader();
+    				//	loader.init(link);
+    				//	loader.generateSchematic(link);
+    				count=0;
+    		
+    		
+    				while(random.nextInt(3)!=1)
+    				{
+    					i=chunkX*16-random.nextInt(16);
+    					k=chunkZ*16-random.nextInt(16);
+        
+    					j= world.getHeightValue(i, k);
+        	
+    					if(world.isAirBlock(i, j+1, k))
+    					{
+    			
+    					
+        				 
+    						link = dimHelper.instance.createLink(link.locDimID,link.destDimID, i, j+1, k,link.destXCoord,link.destYCoord,link.destZCoord);
+
+
+    					
+    				
+        	
+    					}
+        	 
+    				}
+         
+    			}
+    		}
+    	
+    	}
+    		if(random.nextInt(100)==0&&world.provider.getDimensionName()!="PocketDim"&&!world.isRemote)
+    		{
+    		//	System.out.println("tryingToGen");
+    			int blockID=Block.stoneBrick.blockID;
+    			if(world.provider.dimensionId==mod_pocketDim.limboDimID)
+    			{
+    				blockID= mod_pocketDim.blockLimboID;
+    			}
+    			i=chunkX*16-random.nextInt(16);
+    			k=chunkZ*16-random.nextInt(16);
+    
+    			j= world.getHeightValue(i, k);
+    			if(j>20&&world.getBlockId(i, j, k)==0)
+    			{
+    				//System.out.println(String.valueOf(i)+"x "+String.valueOf(j)+"y "+String.valueOf(k)+"z"+"small gen");
+
+    				count=0; 
+				
+    			
+    				if(world.isAirBlock(i, j+1, k))
+    				{
+    				
+    					
+        				 
+    					
+    					if(world.isBlockOpaqueCube(i, j-2, k)||world.isBlockOpaqueCube(i, j-1, k))
+    					{
+    						link = new LinkData(world.provider.dimensionId, 0,  i, j+1, k, i, j+1, k, true);
+        					link =dimHelper.instance.createPocket(link,true, true);
+    						
+    						for(int xc=-3;xc<4;xc++)
+    						{
+    							for(int zc=-3;zc<4;zc++)
+    							{
+        							for(int yc=0;yc<200;yc++)
+        							{
+        								if(yc==0&&world.isBlockOpaqueCube(i+xc, j-2,k +zc))
+        								{
+        									
+        									if(Math.abs(xc)+Math.abs(zc)<rand.nextInt(3)+2)
+        									{
+        										world.setBlock(i+xc, j-1+yc, k+zc, blockID);
+        									}
+        									else if(Math.abs(xc)+Math.abs(zc)<rand.nextInt(3)+3)
+
+        									{
+        										world.setBlockAndMetadata(i+xc, j-1+yc, k+zc, blockID,2);
+
+        									}
+        								}
+
+        							}
+
+    							}
+    						}
+    						
+    						ItemRiftBlade.placeDoorBlock(world, i, j+1, k, 0, mod_pocketDim.transientDoor);
+
+    						{
+							world.setBlockAndMetadata(i, j+1, k-1, blockID,0);
+							world.setBlockAndMetadata(i, j+1, k+1, blockID,0);
+							world.setBlockAndMetadata(i, j, k-1, blockID,0);
+							world.setBlockAndMetadata(i, j, k+1, blockID,0);
+							world.setBlockAndMetadata(i, j+2, k+1, blockID,3);
+							world.setBlockAndMetadata(i, j+2, k-1, blockID,3);
+    						}
+    						
+
+    						
+						
+    						
+    						
+    						
+							this.shouldSave=true;
+
+    					}
+    					
+    					//	 dimData = dimHelper.instance.dimList.get(link.destDimID);
+    						
+    						
+    					//	SchematicLoader loader = new SchematicLoader();
+    					//	loader.init(link);
+    					//	loader.generateSchematic(link);
+    						
+    						
+    					
+    						
+
+    						
+    						
+        	 
+    				}
+         
+    			}
+    		}
+    		if(this.shouldSave)
+    		{
+    		//	dimHelper.instance.save();
+    		}
+    		
+    	//	mod_pocketDim.genTime=((System.nanoTime()-ntime)+mod_pocketDim.genTime);
+    	//	System.out.println(	mod_pocketDim.genTime);
+    	//	System.out.println(	(System.nanoTime()-ntime));
+
+    	//	ntime=0L;
+    		
+    	}
+    
+    
+}

StevenDimDoors/mod_pocketDim/SchematicLoader.java

@@ -0,0 +1,921 @@
+package StevenDimDoors.mod_pocketDim;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.BlockStairs;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompressedStreamTools;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntityChest;
+import net.minecraft.tileentity.TileEntityDispenser;
+import net.minecraft.util.WeightedRandomChestContent;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.EmptyChunk;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+import net.minecraftforge.common.ChestGenHooks;
+ 
+public class SchematicLoader 
+
+{
+    public short width;
+    public short height;
+    public short length;
+    
+    public byte[] blocks;
+    public byte[] data;
+    public NBTTagList entities;
+    public NBTTagList tileentities;
+    private Random rand = new Random();
+  //  public World world;
+    public Point3D incomingLink= new Point3D(0,0,0);
+    public ArrayList<Point3D> sideLinks = new ArrayList<Point3D>();
+    public ArrayList<Point3D> exitLinks = new ArrayList<Point3D>();
+    public int transMeta;
+  //  public Chunk chunk;
+    public int cX;
+    public int cZ;
+    public int cY;
+    
+
+    
+    public boolean didRead=false;
+    public String schematic;
+    
+    public SchematicLoader()
+    {
+    //	this.schematic="/schematics/"+filePath;
+    }
+        
+    
+    public void init(String filePath, LinkData link, int x, int y , int z)
+    {
+    	
+    	this.schematic="/schematics/"+filePath;
+        try 
+        {
+        	
+       
+        	String fname= schematic ;
+        	
+        	InputStream input = this.getClass().getResourceAsStream(fname);
+        	//FileInputStream fileinputstream = new FileInputStream(file);
+        	NBTTagCompound nbtdata = CompressedStreamTools.readCompressed(input);
+
+
+            
+             width = nbtdata.getShort("Width");
+             height = nbtdata.getShort("Height");
+             length = nbtdata.getShort("Length");
+ 
+             blocks = nbtdata.getByteArray("Blocks");
+             data = nbtdata.getByteArray("Data");
+             
+             entities = nbtdata.getTagList("Entities");
+             tileentities = nbtdata.getTagList("TileEntities");
+             this.didRead=true;
+             input.close();
+          
+        }
+        catch (Exception e) 
+        {
+        	this.didRead=false;
+        	System.out.println("Error- could not find file "+schematic);
+            e.printStackTrace();
+            
+        }
+        
+        this.generateSchematic(link, 0, 0, 0);
+        
+    }
+    	public int transformMetadata(int metadata, int orientation, int blockID)
+    	{
+    		if(mod_pocketDim.metadataFlipList.contains(blockID))
+    		{
+    			switch (orientation)
+				{
+				case 0:
+					
+					if(Block.blocksList[blockID] instanceof BlockStairs)
+	    			{
+					
+	    				switch (metadata)
+	    				{
+	    				case 0:
+	    					metadata = 2;
+	    					break;
+	    				case 1:
+	    					metadata = 3;
+	    					break;
+	    				case 2:
+	    					metadata = 1;
+	    					break;
+	    				case 3:
+	    					metadata = 0;
+	    					break;
+	    				case 7:
+	    					metadata = 4;
+	    					break;
+	    				case 6:
+	    					metadata = 5;
+	    					break;
+	    				case 5:
+	    					metadata = 7;
+	    					break;
+	    				case 4:
+	    					metadata = 6;
+	    					break;
+	    			
+	    				}
+	    			}
+					
+					if(blockID== Block.lever.blockID||blockID== Block.torchWood.blockID||blockID== Block.torchRedstoneIdle.blockID||blockID== Block.torchRedstoneActive.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 12:
+	    					metadata = 9;
+	    					break;
+	    				case 11:
+	    					metadata = 10;
+	    					break;
+	    				case 10:
+	    					metadata = 12;
+	    					break;
+	    				case 9:
+	    					metadata = 11;
+	    					break;					
+	    				case 2:
+	    					metadata = 4;
+	    					break;
+	    				case 3:
+	    					metadata = 2;
+	    					break;
+	    				case 1:
+	    					metadata = 3;
+	    					break;
+	    				case 4:
+	    					metadata = 1;
+	    					
+	    					break;
+
+	    				}
+
+	    			}
+			
+					if(blockID== Block.pistonBase.blockID||blockID==Block.pistonStickyBase.blockID||blockID==Block.dispenser.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 4:
+	    					metadata = 2;
+	    					break;
+	    				case 5:
+	    					metadata = 3;
+	    					break;
+	    				case 13:
+	    					metadata = 11;
+	    					break;
+	    				case 12:
+	    					metadata = 10;
+	    					break;
+	    				case 3:
+	    					metadata = 4;
+	    					break;
+	    				case 2:
+	    					metadata = 5;
+	    					break;
+	    				case 11:
+	    					metadata = 12;
+	    					break;
+	    				case 10:
+	    					metadata = 13;
+	    					break;
+	    				
+	    			
+	    				}
+	    			
+					
+					
+	    			}
+					
+					if(blockID== Block.redstoneRepeaterActive.blockID||blockID==Block.redstoneRepeaterIdle.blockID||blockID== Block.tripWireSource.blockID||blockID== Block.doorSteel.blockID||blockID==Block.doorWood.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 0:
+	    					metadata = 1;
+	    					break;
+	    				case 1:
+	    					metadata = 2;
+	    					break;
+	    				case 2:
+	    					metadata = 3;
+	    					break;
+	    				case 3:
+	    					metadata = 0;
+	    					break;
+	    				case 4:
+	    					metadata = 5;
+	    					break;
+	    				case 5:
+	    					metadata = 6;
+	    					break;
+	    				case 6:
+	    					metadata = 7;
+	    					break;
+	    				case 7:
+	    					metadata = 4;
+	    					break;
+	    				case 8:
+	    					metadata = 9;
+	    					break;
+	    				case 9:
+	    					metadata = 10;
+	    					break;
+	    				case 10:
+	    					metadata = 11;
+	    					break;
+	    				case 11:
+	    					metadata = 8;
+	    					break;
+	    				case 12:
+	    					metadata = 13;
+	    					break;
+	    				case 13:
+	    					metadata = 14;
+	    					break;
+	    				case 14:
+	    					metadata = 15;
+	    					break;
+	    				case 15:
+	    					metadata = 12;
+	    					break;
+	    				
+	    			
+	    				}
+	    			
+					
+					
+	    			}
+					
+					
+					
+					
+				
+					break;
+				case 1:
+
+					
+					if(Block.blocksList[blockID] instanceof BlockStairs)
+	    			{
+					
+	    				switch (metadata)
+	    				{
+	    				case 0:
+	    					metadata = 1;
+	    					break;
+	    				case 1:
+	    					metadata = 0;
+	    					break;
+	    				case 2:
+	    					metadata = 3;
+	    					break;
+	    				case 3:
+	    					metadata = 2;
+	    					break;
+	    				case 7:
+	    					metadata = 6;
+	    					break;
+	    				case 6:
+	    					metadata = 7;
+	    					break;
+	    				case 5:
+	    					metadata = 4;
+	    					break;
+	    				case 4:
+	    					metadata = 5;
+	    					break;
+	    			
+	    				}
+	    			}
+					
+					if(blockID== Block.lever.blockID||blockID== Block.torchWood.blockID||blockID== Block.torchRedstoneIdle.blockID||blockID== Block.torchRedstoneActive.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 12:
+	    					metadata = 11;
+	    					break;
+	    				case 11:
+	    					metadata = 12;
+	    					break;
+	    				case 10:
+	    					metadata = 9;
+	    					break;
+	    				case 9:
+	    					metadata = 10;
+	    					break;					
+	    				case 2:
+	    					metadata = 1;
+	    					break;
+	    				case 3:
+	    					metadata = 4;
+	    					break;
+	    				case 1:
+	    					metadata = 2;
+	    					break;
+	    				case 4:
+	    					metadata = 3;
+	    					
+	    					break;
+
+	    				}
+
+	    			}
+			
+					if(blockID== Block.pistonBase.blockID||blockID==Block.pistonStickyBase.blockID||blockID==Block.dispenser.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 4:
+	    					metadata = 5;
+	    					break;
+	    				case 5:
+	    					metadata = 4;
+	    					break;
+	    				case 13:
+	    					metadata = 12;
+	    					break;
+	    				case 12:
+	    					metadata = 13;
+	    					break;
+	    				case 3:
+	    					metadata = 2;
+	    					break;
+	    				case 2:
+	    					metadata = 3;
+	    					break;
+	    				case 11:
+	    					metadata = 10;
+	    					break;
+	    				case 10:
+	    					metadata = 11;
+	    					break;
+	    			
+	    				}
+	    			
+					
+					
+	    			}
+					
+					if(blockID== Block.redstoneRepeaterActive.blockID||blockID==Block.redstoneRepeaterIdle.blockID||blockID== Block.tripWireSource.blockID||blockID== Block.doorSteel.blockID||blockID==Block.doorWood.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 0:
+	    					metadata = 2;
+	    					break;
+	    				case 1:
+	    					metadata = 3;
+	    					break;
+	    				case 2:
+	    					metadata = 0;
+	    					break;
+	    				case 3:
+	    					metadata = 1;
+	    					break;
+	    				case 4:
+	    					metadata = 6;
+	    					break;
+	    				case 5:
+	    					metadata = 7;
+	    					break;
+	    				case 6:
+	    					metadata = 4;
+	    					break;
+	    				case 7:
+	    					metadata = 5;
+	    					break;
+	    				case 8:
+	    					metadata = 10;
+	    					break;
+	    				case 9:
+	    					metadata = 11;
+	    					break;
+	    				case 10:
+	    					metadata = 8;
+	    					break;
+	    				case 11:
+	    					metadata = 9;
+	    					break;
+	    				case 12:
+	    					metadata = 14;
+	    					break;
+	    				case 13:
+	    					metadata = 15;
+	    					break;
+	    				case 14:
+	    					metadata = 12;
+	    					break;
+	    				case 15:
+	    					metadata = 13;
+	    					break;
+	    				
+	    			
+	    				}
+	    			
+					
+					
+	    			}
+					
+					break;
+				case 2:
+					
+					if(Block.blocksList[blockID] instanceof BlockStairs)
+	    			{
+					
+						switch (metadata)
+	    				{
+	    				case 2:
+	    					metadata = 0;
+	    					break;
+	    				case 3:
+	    					metadata = 1;
+	    					break;
+	    				case 1:
+	    					metadata = 2;
+	    					break;
+	    				case 0:
+	    					metadata = 3;
+	    					break;
+	    				case 4:
+	    					metadata = 7;
+	    					break;
+	    				case 5:
+	    					metadata = 6;
+	    					break;
+	    				case 7:
+	    					metadata = 5;
+	    					break;
+	    				case 6:
+	    					metadata = 4;
+	    					break;
+	    			
+	    				}
+	    			}
+					
+					if(blockID== Block.lever.blockID||blockID== Block.torchWood.blockID||blockID== Block.torchRedstoneIdle.blockID||blockID== Block.torchRedstoneActive.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 9:
+	    					metadata = 12;
+	    					break;
+	    				case 10:
+	    					metadata = 11;
+	    					break;
+	    				case 12:
+	    					metadata = 10;
+	    					break;
+	    				case 11:
+	    					metadata = 9;
+	    					break;					
+	    				case 4:
+	    					metadata = 2;
+	    					break;
+	    				case 2:
+	    					metadata = 3;
+	    					break;
+	    				case 3:
+	    					metadata = 1;
+	    					break;
+	    				case 1:
+	    					metadata = 4;
+	    					
+	    					break;
+
+	    				}
+
+	    			}
+			
+					if(blockID== Block.pistonBase.blockID||blockID==Block.pistonStickyBase.blockID||blockID==Block.dispenser.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 2:
+	    					metadata = 4;
+	    					break;
+	    				case 3:
+	    					metadata = 5;
+	    					break;
+	    				case 11:
+	    					metadata = 13;
+	    					break;
+	    				case 10:
+	    					metadata = 12;
+	    					break;
+	    				case 4:
+	    					metadata = 3;
+	    					break;
+	    				case 5:
+	    					metadata = 2;
+	    					break;
+	    				case 12:
+	    					metadata = 11;
+	    					break;
+	    				case 13:
+	    					metadata = 10;
+	    					break;
+	    				
+	    			
+	    				}
+	    			
+					
+					
+	    			}
+					
+					if(blockID== Block.redstoneRepeaterActive.blockID||blockID==Block.redstoneRepeaterIdle.blockID||blockID== Block.tripWireSource.blockID||blockID== Block.doorSteel.blockID||blockID==Block.doorWood.blockID)
+	    			{
+	    				switch (metadata)
+	    				{
+	    				case 1:
+	    					metadata = 0;
+	    					break;
+	    				case 2:
+	    					metadata = 1;
+	    					break;
+	    				case 3:
+	    					metadata = 2;
+	    					break;
+	    				case 0:
+	    					metadata = 3;
+	    					break;
+	    				case 5:
+	    					metadata = 4;
+	    					break;
+	    				case 6:
+	    					metadata = 5;
+	    					break;
+	    				case 7:
+	    					metadata = 6;
+	    					break;
+	    				case 4:
+	    					metadata = 7;
+	    					break;
+	    				case 9:
+	    					metadata = 8;
+	    					break;
+	    				case 10:
+	    					metadata = 9;
+	    					break;
+	    				case 11:
+	    					metadata = 10;
+	    					break;
+	    				case 8:
+	    					metadata = 11;
+	    					break;
+	    				case 13:
+	    					metadata = 12;
+	    					break;
+	    				case 14:
+	    					metadata = 13;
+	    					break;
+	    				case 15:
+	    					metadata = 14;
+	    					break;
+	    				case 12:
+	    					metadata = 15;
+	    					break;
+	    				
+	    			
+	    				}
+	    			
+					
+					
+	    			}
+					
+					
+					
+					
+					
+					
+					break;
+				case 3:
+					/**
+					 * this is the default case- never need to change anything here
+					 * 
+					 */
+					
+					
+					
+					
+					break;
+			
+				}
+    			
+    			
+    		}
+    		return metadata;
+    	}
+
+		public void generateSchematic(LinkData link, int xOffset, int yOffset, int zOffset)
+		{
+			
+			World world;
+			Chunk chunk;
+			dimHelper.dimList.get(link.destDimID).hasBeenFilled=this.didRead;
+			SchematicLoader loader=this;
+			
+			int i = link.destXCoord;
+			int j = link.destYCoord-1;
+			int k = link.destZCoord;
+			
+		
+			
+			
+			
+			
+			if(dimHelper.getWorld(link.destDimID)==null)
+			{
+				dimHelper.initDimension(link.destDimID);
+			}
+			world=dimHelper.getWorld(link.destDimID);
+		
+			int x;
+			int y;
+			int z;
+			
+			
+			int xCooe=0;
+            int yCooe=0;
+            int zCooe=0;
+            
+            
+        	
+        	
+		        
+			
+		         
+			
+			  for ( x = 0; x < loader.width; ++x) 
+			  {
+		            for ( y = 0; y < loader.height; ++y) 
+		            {
+		                for ( z = 0; z < loader.length; ++z) 
+		                {
+		                	if(link.linkOrientation==0)
+		                	{
+		                		zCooe=x-20;
+		                		yCooe=y-6;
+		                		xCooe=-z+35;
+		                		
+		                	}
+		                	if(link.linkOrientation==1)
+		                	{
+		                		xCooe=-x+20;
+		                		yCooe=y-6;
+		                		zCooe=-z+35;
+		                	}
+		                	if(link.linkOrientation==2)
+		                	{
+		                		zCooe=-x+20;
+		                		yCooe=y-6;
+		                		xCooe=+z-35;
+		                	}
+		                	if(link.linkOrientation==3)
+		                	{
+		                		xCooe=x-20;
+		                		yCooe=y-6;
+		                		zCooe=z-35;
+		                	}
+		                		
+		                    int index = y * loader.width * loader.length + z * loader.width + x;
+		                    
+		                    int blockToReplace=loader.blocks[index];
+		                    int blockMetaData=loader.data[index];
+		                    NBTTagList tileEntity = loader.tileentities;
+		                    HashMap tileEntityMap= new HashMap();
+		                    int size = tileEntity.tagCount();
+		                    
+		                    
+		                    if(blockToReplace==Block.doorSteel.blockID)
+		                    {
+		                    	this.sideLinks.add(new Point3D(i+xCooe, j+yCooe, k+zCooe));
+		                    }
+		                    if(blockToReplace==Block.doorWood.blockID)
+		                    {
+		                    	this.exitLinks.add(new Point3D(i+xCooe, j+yCooe, k+zCooe));
+		                    }
+		                    if(blockToReplace==-124)
+		                    {
+		                    	blockToReplace=Block.tripWire.blockID;
+		                    }
+		                    if(blockToReplace==-125)
+		                    {
+		                    	blockToReplace=Block.tripWireSource.blockID;
+		                    }
+		                    if(blockToReplace<0&&blockToReplace!=-39)
+		                    {
+		                    }
+		                    
+		                    if(blockToReplace<0)
+		                    {
+		                    	blockToReplace=mod_pocketDim.blockDimWallID;
+		                    }
+		                    
+		                    if(blockToReplace>0)
+		                    {
+		                    	
+		                    	this.transMeta=this.transformMetadata(blockMetaData, link.linkOrientation, blockToReplace);
+
+		                    	if(blockToReplace==Block.doorSteel.blockID)
+				                {
+		                    		setBlockDirectly(world,i+xCooe,j+yCooe,k+zCooe,mod_pocketDim.dimDoorID, transMeta );
+				                }
+		                    	else
+				                if(blockToReplace==Block.doorWood.blockID)
+				                {
+				                	setBlockDirectly(world,i+xCooe,j+yCooe,k+zCooe,mod_pocketDim.ExitDoorID, transMeta );
+				                }
+				                else
+				                {
+				                    
+		                    	setBlockDirectly(world,i+xCooe,j+yCooe,k+zCooe,blockToReplace, transMeta );
+				                }
+	                    		
+		                    	if(Block.blocksList[blockToReplace] instanceof BlockContainer)
+		                    	{
+		                    	//	System.out.println("found container");
+		                    		Random rand= new Random();
+		                    		if(world.getBlockTileEntity(i+xCooe, j+yCooe, k+zCooe) instanceof TileEntityChest)
+		                    		{
+		                    			TileEntityChest chest = (TileEntityChest) world.getBlockTileEntity(i+xCooe, j+yCooe, k+zCooe);
+		                    			chest.setInventorySlotContents(rand.nextInt(30+1), new ItemStack(mod_pocketDim.blockDimWall, 64));
+		                    			
+		                    		   ChestGenHooks info = ChestGenHooks.getInfo(ChestGenHooks.DUNGEON_CHEST);
+                                       WeightedRandomChestContent.generateChestContents(rand, info.getItems(rand),(TileEntityChest)world.getBlockTileEntity(i+xCooe, j+yCooe, k+zCooe)  , info.getCount(rand));
+		                    			chest.setInventorySlotContents(rand.nextInt(30+1), new ItemStack(mod_pocketDim.blockDimWall, 64));
+ 
+                                    
+
+		                    		}
+		                    		if(world.getBlockTileEntity(i+xCooe, j+yCooe, k+zCooe) instanceof TileEntityDispenser)
+		                    		{
+		                    			TileEntityDispenser dispenser = (TileEntityDispenser) world.getBlockTileEntity(i+xCooe, j+yCooe, k+zCooe);
+		                    			dispenser.addItem(new ItemStack(Item.arrow, 64));
+		                    	
+		                    		}
+		                    		
+		                    	}
+		                    }
+		            }
+		        }
+			
+			  
+			  }
+			  
+			  
+			  
+			 LinkData outgoingLink = dimHelper.instance.getLinkDataFromCoords(link.destXCoord, link.destYCoord, link.destZCoord, link.destDimID);
+			 
+			 
+
+			 	
+				 
+				
+			 
+			 for(Point3D point : this.sideLinks)
+			 {
+				 if(world.getBlockId(point.getX(), point.getY(), point.getZ())==mod_pocketDim.dimDoorID&&world.getBlockId(point.getX(), point.getY()-1, point.getZ())==mod_pocketDim.dimDoorID)
+				 {
+					 
+					int depth = dimHelper.instance.getDimDepth(link.locDimID);
+					int xNoise = 0;
+					int zNoise =0;
+					switch(world.getBlockMetadata(point.getX(), point.getY()-1, point.getZ()))
+					{
+					case 0:
+						 xNoise = (int)rand.nextInt(depth+1*200)+depth*50;
+						 zNoise = (int)rand.nextInt(depth+1*20)-(10)*depth;
+						
+						break;
+					case 1:
+						xNoise =  (int)rand.nextInt(depth+1*20)-(10)*depth;
+						zNoise = (int) rand.nextInt(depth+1*200)+depth*50;
+						
+						break;
+					case 2:
+						 xNoise = - (rand.nextInt(depth+1*200)+depth*50);
+						 zNoise =  (int)rand.nextInt(depth+1*20)-(10)*depth;
+						
+						break;
+					case 3:
+						 xNoise =  (int)rand.nextInt(depth+1*20)-(10)*depth;
+						 zNoise = -(rand.nextInt(depth+1*200)+depth*50);
+						
+						break;
+					
+					}
+				
+
+					
+					
+					
+					
+					
+				 	LinkData sideLink = new LinkData(link.destDimID,0,point.getX(), point.getY(), point.getZ(),xNoise+point.getX(), point.getY()+1, zNoise+point.getZ(),true);
+				 	sideLink.linkOrientation=world.getBlockMetadata(point.getX(), point.getY()-1, point.getZ());
+					dimHelper.instance.createPocket(sideLink, true, true);
+					
+
+					//setBlockDirectly(world,point.getX(), point.getY()-1, point.getZ(),mod_pocketDim.dimDoorID,sideLink.linkOrientation);
+				//	setBlockDirectly(world,point.getX(), point.getY(), point.getZ(),mod_pocketDim.dimDoorID,8);
+
+				
+				 }
+			 }
+			 for(Point3D point : this.exitLinks)
+			 {
+				 if(world.getBlockId(point.getX(), point.getY(), point.getZ())==mod_pocketDim.ExitDoorID&&world.getBlockId(point.getX(), point.getY()-1, point.getZ())==mod_pocketDim.ExitDoorID&&world.getBlockId(point.getX(), point.getY()-2, point.getZ())==Block.sandStone.blockID)
+				 {
+					 	
+					 	World exitWorld = dimHelper.getWorld(dimHelper.dimList.get(world.provider.dimensionId).exitDimLink.destDimID);
+					 	
+					 	
+
+					 	exitWorld.getChunkProvider().loadChunk(point.getX() >> 4, point.getZ() >> 4);
+					 	
+						LinkData sideLink = new LinkData(link.destDimID,dimHelper.dimList.get(link.locDimID).exitDimLink.destDimID,point.getX(), point.getY(), point.getZ(),point.getX(), exitWorld.getHeightValue(point.getX(), point.getZ())+1, point.getZ(),true);
+					 	sideLink.linkOrientation=world.getBlockMetadata(point.getX(), point.getY()-1, point.getZ());
+						dimHelper.instance.createLink(sideLink);
+						dimHelper.instance.createLink(sideLink.destDimID , sideLink.locDimID, sideLink.destXCoord, sideLink.destYCoord, sideLink.destZCoord, sideLink.locXCoord, sideLink.locYCoord, sideLink.locZCoord, dimHelper.instance.flipDoorMetadata(sideLink.linkOrientation));
+						
+						
+						setBlockDirectly(world,point.getX(), point.getY()-2, point.getZ(), Block.stone.blockID,0);
+					//	setBlockDirectly(world,point.getX(), point.getY()-1, point.getZ(),mod_pocketDim.ExitDoorID,sideLink.linkOrientation);
+					//	setBlockDirectly(world,point.getX(), point.getY(), point.getZ(),mod_pocketDim.ExitDoorID,8);
+
+				 }
+				 else if ((world.getBlockId(point.getX(), point.getY(), point.getZ())==mod_pocketDim.ExitDoorID&&world.getBlockId(point.getX(), point.getY()-1, point.getZ())==mod_pocketDim.ExitDoorID&&world.getBlockId(point.getX(), point.getY()-2, point.getZ())!=Block.sandStone.blockID))
+				 {
+					 this.incomingLink = point;
+				 }
+			 }
+			 
+			 
+			 if(!this.incomingLink.equals(new Point3D(0,0,0)))
+			 	{
+			 		outgoingLink.locXCoord=this.incomingLink.getX();
+			 		outgoingLink.locYCoord=this.incomingLink.getY();
+			 		outgoingLink.locZCoord=this.incomingLink.getZ();
+			 		outgoingLink.linkOrientation=world.getBlockMetadata(incomingLink.getX(), incomingLink.getY()-1, incomingLink.getZ());
+				 	dimHelper.instance.createLink(outgoingLink);
+
+			 		link.destXCoord=this.incomingLink.getX();
+			 		link.destYCoord=this.incomingLink.getY();
+			 		link.destZCoord=this.incomingLink.getZ();
+			 	}
+
+		}
+
+		
+		public void setBlockDirectly(World world, int x, int y, int z,int id, int metadata)
+		{
+			Chunk chunk;
+			this.cX=x >>4;
+			this.cZ=z >>4;
+			this.cY=y >>4;
+
+			int chunkX=(x % 16)< 0 ? ((x) % 16)+16 : ((x) % 16);
+			int chunkY=y;
+			int chunkZ=((z) % 16)< 0 ? ((z) % 16)+16 : ((z) % 16);
+			
+			
+    		//	this.chunk=new EmptyChunk(world,cX, cZ);
+			try
+			{
+			chunk=world.getChunkFromChunkCoords(cX, cZ);
+				 if (chunk.getBlockStorageArray()[cY] == null) {
+					 chunk.getBlockStorageArray()[cY] = new ExtendedBlockStorage(cY << 4, !world.provider.hasNoSky);
+             }
+    		
+    		
+    		chunk.getBlockStorageArray()[cY].setExtBlockID(chunkX, (y) & 15, chunkZ, id);
+    		chunk.getBlockStorageArray()[cY].setExtBlockMetadata(chunkX, (y) & 15, chunkZ, metadata);
+			}
+			catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+        	
+		}
+	
+ 
+}

StevenDimDoors/mod_pocketDim/ServerPacketHandler.java

@@ -0,0 +1,15 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.Packet250CustomPayload;
+import cpw.mods.fml.common.network.IPacketHandler;
+import cpw.mods.fml.common.network.Player;
+
+public class ServerPacketHandler implements IPacketHandler
+{
+    @Override
+    public void onPacketData(INetworkManager manager,
+            Packet250CustomPayload packet, Player player)
+    {
+    }
+}

StevenDimDoors/mod_pocketDim/TileEntityDimDoor.java

@@ -0,0 +1,70 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+
+public class TileEntityDimDoor extends TileEntity
+
+{
+	public boolean openOrClosed;
+	public int orientation;
+	public boolean hasExit;
+	public boolean isDungeonChainLink;
+	
+	
+	
+	
+	 public boolean canUpdate()
+	 {
+		 return false;
+	 }
+	 
+	 public void updateEntity() 
+	 {
+     	
+
+	 }
+	 
+	 @Override
+	    public void readFromNBT(NBTTagCompound nbt)
+	    {
+	        super.readFromNBT(nbt);
+	        int i = nbt.getInteger(("Size"));
+
+	        try
+	        {
+	            this.openOrClosed = nbt.getBoolean("openOrClosed");
+	            
+	            this.orientation = nbt.getInteger("orientation");
+	            
+	            this.hasExit = nbt.getBoolean("hasExit");
+	            
+	            this.isDungeonChainLink = nbt.getBoolean("isDungeonChainLink");
+
+	          
+
+	           
+
+	        }
+	        catch (Exception e)
+	        {
+	            
+	        }
+	    }
+
+	    @Override
+	    public void writeToNBT(NBTTagCompound nbt)
+	    {
+	        int i = 0;
+	        super.writeToNBT(nbt);
+	        nbt.setBoolean("openOrClosed", this.openOrClosed);
+	        
+	        nbt.setBoolean("hasExit", this.hasExit);
+
+	       	nbt.setInteger("orientation", this.orientation);
+	       	
+	       	nbt.setBoolean("isDungeonChainLink", isDungeonChainLink);
+
+          
+	    }
+}

StevenDimDoors/mod_pocketDim/TileEntityRift.java

@@ -0,0 +1,204 @@
+package StevenDimDoors.mod_pocketDim;
+
+
+
+import java.util.List;
+import java.util.Random;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.monster.EntityEnderman;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.MathHelper;
+
+public class TileEntityRift extends TileEntity
+
+{
+	public int xOffset=0;
+	public int yOffset=0;
+	public int zOffset=0;
+	public int distance=0;
+	public boolean hasGrownRifts=false;
+	public boolean shouldClose=false;
+	//public boolean isClosing=false;
+	public boolean isNearRift=false;
+	private int count=200;
+	private int count2 = 0;
+	public LinkData nearestRiftData;
+	Random rand = new Random();
+	
+	
+	
+	 public boolean canUpdate()
+	 {
+		 return true;
+	 }
+	 
+	 public void updateEntity() 
+	 {
+		
+		if(count>200&&dimHelper.dimList.get(this.worldObj.provider.dimensionId)!=null)
+		 {
+			 nearestRiftData = dimHelper.dimList.get(this.worldObj.provider.dimensionId).findNearestRift(worldObj, 5, xCoord, yCoord, zCoord);
+			 if(nearestRiftData!=null)
+			 {
+				 this.xOffset=this.xCoord-nearestRiftData.locXCoord;
+				 this.yOffset=this.yCoord-nearestRiftData.locYCoord;
+				 this.zOffset=this.zCoord-nearestRiftData.locZCoord;
+				 this.distance=(int) (MathHelper.abs(xOffset)+MathHelper.abs(yOffset)+MathHelper.abs(zOffset));
+				 this.isNearRift=true;
+		 
+				 if(!this.worldObj.isRemote&&distance>1)
+				 {
+					 try
+					 {
+						 grow(distance);
+					 }
+					 catch(Exception e)
+					 {
+						 
+					 }
+					 
+				 }
+				 if(rand.nextInt(30)==0&&!this.worldObj.isRemote)
+				 {
+					
+					List list =  worldObj.getEntitiesWithinAABB(EntityEnderman.class, AxisAlignedBB.getBoundingBox( this.xCoord-9, this.yCoord-3, this.zCoord-9, this.xCoord+9, this.yCoord+3, this.zCoord+9));
+					
+					if(list.size()<5)
+					{
+					 
+					 
+					  EntityEnderman creeper = new EntityEnderman(worldObj);
+	                  creeper.setLocationAndAngles(this.xCoord+.5, this.yCoord-1, this.zCoord+.5, 5, 6);
+	                  worldObj.spawnEntityInWorld(creeper);
+					}
+				 }
+		 
+		 
+		 
+
+			 }
+			 else
+			 {
+				 this.isNearRift=false;
+			 }
+			 count=0;
+		 }
+		 count++;
+		 
+		 if(this.shouldClose)
+		 {
+			// System.out.println(count2);
+			 if(count2>20&&count2<22)
+			 {			 
+				 nearestRiftData = dimHelper.dimList.get(this.worldObj.provider.dimensionId).findNearestRift(worldObj, 10, xCoord, yCoord, zCoord);
+				 if(this.nearestRiftData!=null)
+				 {
+				 TileEntityRift rift = (TileEntityRift) this.worldObj.getBlockTileEntity(nearestRiftData.locXCoord, nearestRiftData.locYCoord, nearestRiftData.locZCoord);
+				 if(rift!=null)
+				 {
+					 rift.shouldClose=true;
+				 }
+				 }
+			 }
+			 if(count2>40)
+			 {
+				 this.invalidate();
+				 this.worldObj.setBlockWithNotify(this.xCoord, this.yCoord, this.zCoord,0);
+				if(dimHelper.instance.getLinkDataFromCoords(this.xCoord, this.yCoord, this.zCoord, this.worldObj.provider.dimensionId)!=null)
+				{
+				 dimHelper.instance.removeLink(this.worldObj.provider.dimensionId, this.xCoord, this.yCoord, this.zCoord);
+				}
+				
+			 }
+			 count2++;
+		 }
+		
+
+	 }
+	 public void grow(int distance)
+	 {
+		 int count=0;
+		 if(rand.nextInt(distance*2)==0)
+		 {
+			
+			 int x=0,y=0,z=0;
+			 while(count<100)
+			 {
+				 count++;
+				  x=this.xCoord+(1-(rand.nextInt(2)*2)*rand.nextInt(6));
+				  y=this.yCoord+(1-(rand.nextInt(2)*2)*rand.nextInt(4));
+				  z=this.zCoord+(1-(rand.nextInt(2)*2)*rand.nextInt(6));
+				  if(this.worldObj.isAirBlock(x, y, z))
+				  {
+					  break;
+				  }
+				 
+			 }
+			
+			 
+			 if (count<100)
+			 {
+			
+				LinkData link = dimHelper.instance.getLinkDataFromCoords(this.xCoord, this.yCoord, this.zCoord, worldObj);
+				if(link!=null)
+				{
+					if(!this.hasGrownRifts&&rand.nextInt(3)==0)
+					{
+				//	System.out.println(link.numberofChildren);
+					link.numberofChildren++;
+					dimHelper.instance.createLink(this.worldObj.provider.dimensionId, link.destDimID, x, y, z, link.destXCoord, link.destYCoord, link.destZCoord).numberofChildren=link.numberofChildren+1;
+					this.hasGrownRifts=true;
+					}
+				}
+			 }
+			
+		 }
+		 
+	 }
+	 
+	 @Override
+	    public void readFromNBT(NBTTagCompound nbt)
+	    {
+	        super.readFromNBT(nbt);
+	        int i = nbt.getInteger(("Size"));
+
+	        try
+	        {
+	            this.xOffset = nbt.getInteger("xOffset");
+	            this.yOffset = nbt.getInteger("yOffset");
+	            this.zOffset = nbt.getInteger("zOffset");
+	            this.hasGrownRifts =nbt.getBoolean("grownRifts");
+	            this.count=nbt.getInteger("count");
+	            this.count2=nbt.getInteger("count2");
+	            this.shouldClose=nbt.getBoolean("shouldClose");
+  
+
+	         
+	           
+
+	        }
+	        catch (Exception e)
+	        {
+	            
+	        }
+	    }
+
+	    @Override
+	    public void writeToNBT(NBTTagCompound nbt)
+	    {
+	        int i = 0;
+	        super.writeToNBT(nbt);
+	        nbt.setInteger("xOffset", this.xOffset);
+	        nbt.setInteger("yOffset", this.yOffset);
+	        nbt.setInteger("zOffset", this.zOffset);
+	        nbt.setBoolean("grownRifts",this.hasGrownRifts);
+	        nbt.setInteger("count", this.count);
+	        nbt.setInteger("count2", this.count2);
+	        nbt.setBoolean("shouldClose", this.shouldClose);
+	       
+	    }
+}

StevenDimDoors/mod_pocketDim/TransientDoor.java

@@ -0,0 +1,132 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class TransientDoor extends ExitDoor
+{
+	
+	protected TransientDoor(int par1, Material material) 
+	{
+		super(par1, Material.air);
+	//	this.blockIndexInTexture = 18;
+        this.setTextureFile("/PocketBlockTextures.png");
+
+	}
+	 public boolean isCollidable()
+	 {
+	        return false;
+	 }
+	 
+	    public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	    {
+	    	this.updateAttatchedTile(par1World, par2, par3, par4);
+	    }
+
+	@Override
+	public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+		
+        int var12 = (int) (MathHelper.floor_double((double)((par5Entity.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+        int num = par1World.getBlockMetadata(par2, par3, par4);
+     //   System.out.println("metadata "+num+" orientation "+var12);
+    	
+    	if(!par1World.isRemote&&(num)==var12)
+			{
+    	EntityPlayer player;
+		if(par5Entity instanceof EntityPlayerMP)
+    	{
+    		
+    		 player= (EntityPlayer) par5Entity;
+    		 //int destinationID= dimHelper.instance.getDestIDFromCoords(par2, par3, par4, par1World);
+    		 
+    		
+
+    		 LinkData linkData= dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World);
+    		 if(linkData!=null)
+    		 {
+    			 if(dimHelper.dimList.containsKey(linkData.destDimID))
+    			 {
+    				 dimHelper.instance.teleportToPocket(par1World, linkData, player);
+    				 par1World.setBlockWithNotify(par2, par3, par4, 0);
+    			 }
+    		 }
+    		
+        		  else
+        		  {
+        			  linkData= dimHelper.instance.getLinkDataFromCoords(par2, par3+1, par4, par1World);
+            		  if(linkData!=null)
+             		 {
+             			 if(dimHelper.dimList.containsKey(linkData.destDimID))
+             			 {
+             				 dimHelper.instance.teleportToPocket(par1World, linkData, player);
+             				 par1World.setBlockWithNotify(par2, par3, par4, 0);
+             			 }
+             		 } 
+        		  }
+
+    		 }
+     			
+    		
+    	}
+		
+    }
+	public void onPoweredBlockChange(World par1World, int par2, int par3, int par4, boolean par5)
+    {
+      
+    }
+	
+	
+	 
+	  public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
+	    {
+	        return super.getCollisionBoundingBoxFromPool(par1World, 0, 0, 0);
+	    }
+
+		
+	 public int idPicked(World par1World, int par2, int par3, int par4)
+	    {
+	        return 0;
+	    }
+	    
+	    public int idDropped(int par1, Random par2Random, int par3)
+	    {
+	        return 0;
+	    }
+	    
+	    
+	    public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
+	    {
+	        
+	    	return false;
+	       
+	    }
+
+	    /**
+	     * A function to open a door.
+	     */
+	    
+	    public int getRenderType()
+	    {
+	        return 8;
+	    }
+
+
+}

StevenDimDoors/mod_pocketDim/dimDoor.java

@@ -0,0 +1,700 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class dimDoor extends BlockContainer
+{
+	
+	protected dimDoor(int par1, Material material) 
+	{
+		super(par1, Material.iron);
+	//	this.blockIndexInTexture = 18;
+
+
+	}
+	
+	 @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+	 
+	//spawns the rift attatched to the block. Doesnt work in creative mode for some reason
+	 //TODO make work in creative
+    public void onBlockDestroyedByPlayer(World par1World, int par2, int par3, int par4, int par5) 
+    {
+    	if(!par1World.isRemote)
+    	{
+    		if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+    		{
+    			LinkData link= dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World);
+    			par1World.setBlockWithNotify(par2, par3, par4, mod_pocketDim.blockRiftID);
+    		
+    		}
+    		 if(dimHelper.instance.getLinkDataFromCoords(par2, par3-1, par4, par1World)!=null)
+    		{
+    			LinkData link= dimHelper.instance.getLinkDataFromCoords(par2, par3-1, par4, par1World);
+    			par1World.setBlockWithNotify(par2, par3-1, par4, mod_pocketDim.blockRiftID);
+    		
+    		}
+    		 if(dimHelper.instance.getLinkDataFromCoords(par2, par3+1, par4, par1World)!=null)
+    		{
+    			LinkData link= dimHelper.instance.getLinkDataFromCoords(par2, par3+1, par4, par1World);
+    			par1World.setBlockWithNotify(par2, par3+1, par4, mod_pocketDim.blockRiftID);
+    		
+    		}
+    					
+    	}
+    	
+    }
+
+    //finds the rift data and teleports the player to it. 
+    public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+    
+    	if(!par1World.isRemote)
+    	{
+    		int var12 = (int) (MathHelper.floor_double((double)((par5Entity.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+       
+    		int num = par1World.getBlockMetadata(par2, par3-1, par4);
+    		if(!par1World.isRemote&&(num==5||num==4||num==6||num==7)&&(num-4)==var12&&par1World.getBlockId(par2, par3-1, par4)==mod_pocketDim.dimDoorID)
+    		{
+    			EntityPlayer player;
+    		
+    			if(par5Entity instanceof EntityPlayerMP)
+    			{
+    		
+    				player= (EntityPlayer) par5Entity;
+    				//int destinationID= dimHelper.instance.getDestIDFromCoords(par2, par3, par4, par1World);
+    		 
+    				this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+
+    				LinkData linkData= dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World);
+    				dimHelper.instance.teleportToPocket(par1World, linkData, player);
+     			
+    		
+    			}
+    		}
+    	}
+    }
+
+	public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
+    {
+        
+     boolean shouldOpen=true;
+     
+    		//System.out.println(String.valueOf(par1World.getBlockMetadata(par2, par3, par4)));
+		if(par5EntityPlayer.inventory.getCurrentItem()!=null)
+		{
+			if(par5EntityPlayer.inventory.getCurrentItem().getItem() == mod_pocketDim.itemRiftBlade)
+			{
+				shouldOpen=false;
+				if(!par1World.isRemote&&par1World.getBlockId(par2, par3-1, par4)==this.blockID)
+				{
+					int var12 = (int) (MathHelper.floor_double((double)((par5EntityPlayer.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+	    		
+					if(par1World.getBlockMetadata(par2, par3-1, par4)==var12)
+					{
+						var12=dimHelper.instance.flipDoorMetadata(var12);
+					}
+					par1World.setBlockMetadataWithNotify(par2, par3-1, par4, var12);
+					if(	dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+					{
+						dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation= par1World.getBlockMetadata(par2, par3-1, par4);
+	    			
+					}
+				}
+				if(!par1World.isRemote&&par1World.getBlockId(par2, par3+1, par4)==this.blockID)
+				{
+					int var12 = (int) (MathHelper.floor_double((double)((par5EntityPlayer.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+					if(par1World.getBlockMetadata(par2, par3, par4)==var12)
+					{
+						var12=dimHelper.instance.flipDoorMetadata(var12);
+					}
+					par1World.setBlockMetadataWithNotify(par2, par3, par4, var12);
+					if(	dimHelper.instance.getLinkDataFromCoords(par2, par3+1, par4, par1World)!=null)
+					{
+						dimHelper.instance.getLinkDataFromCoords(par2, par3+1, par4, par1World).linkOrientation= par1World.getBlockMetadata(par2, par3, par4);
+					}
+				}
+	            par1World.playAuxSFXAtEntity(par5EntityPlayer, 1001, par2, par3, par4, 0);
+
+			if(!shouldOpen&&!par1World.isRemote)
+			{
+
+				par5EntityPlayer.inventory.getCurrentItem().damageItem(5, par5EntityPlayer);
+			
+			//	par5EntityPlayer.sendChatToPlayer("You wedge the stick into a cranny in the door attempt to rotate the it");
+			//	par5EntityPlayer.sendChatToPlayer("The door rotates, but the stick breaks in half and is lost");
+			}
+			
+
+			
+		}
+	}
+		
+     if(shouldOpen)
+     {
+        	
+            int var10 = this.getFullMetadata(par1World, par2, par3, par4);
+            int var11 = var10 & 7;
+            var11 ^= 4;
+
+            if ((var10 & 8) == 0)
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3, par4, var11);
+                par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
+            }
+            else
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3 - 1, par4, var11);
+                par1World.markBlockRangeForRenderUpdate(par2, par3 - 1, par4, par2, par3, par4);
+            }
+
+            par1World.playAuxSFXAtEntity(par5EntityPlayer, 1003, par2, par3, par4, 0);
+            if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+            {
+          //  	System.out.println("Link orient is- " +dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation);
+            }
+            return true;
+     }
+     else 
+     {
+    	 return false;
+     }
+       
+    }
+
+    /**
+     * A function to open a door.
+     */
+    public void onPoweredBlockChange(World par1World, int par2, int par3, int par4, boolean par5)
+    {
+        int var6 = this.getFullMetadata(par1World, par2, par3, par4);
+        boolean var7 = (var6 & 4) != 0;
+
+        if (var7 != par5)
+        {
+            int var8 = var6 & 7;
+            var8 ^= 4;
+
+            if ((var6 & 8) == 0)
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3, par4, var8);
+                par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
+            }
+            else
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3 - 1, par4, var8);
+                par1World.markBlockRangeForRenderUpdate(par2, par3 - 1, par4, par2, par3, par4);
+            }
+
+            par1World.playAuxSFXAtEntity((EntityPlayer)null, 1003, par2, par3, par4, 0);
+        }
+    }
+//TODO simplify this
+	@Override
+	public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	{
+		if(!par1World.isRemote&&par1World.getBlockId(par2, par3-1, par4)==this.blockID)
+		{		
+			boolean newDim=false;
+			
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)==null)
+			{
+				newDim=true;
+			}
+		
+			if(newDim)
+			{
+				LinkData link = new LinkData(par1World.provider.dimensionId, 0, par2, par3, par4, par2, par3, par4, true);
+				link.linkOrientation= par1World.getBlockMetadata(par2, par3-1, par4);
+				dimHelper.instance.createPocket(link,true, false);
+			//	System.out.println(link.linkOrientation);
+
+				
+			}
+
+			
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+			{
+				dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation=par1World.getBlockMetadata(par2, par3-1, par4);
+				
+
+			}
+		}
+		
+	}
+	
+	@SideOnly(Side.CLIENT)
+
+    /**
+     * Retrieves the block texture to use based on the display side. Args: iBlockAccess, x, y, z, side
+     */
+    public int getBlockTexture(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
+    {
+        if (par5 != 0 && par5 != 1)
+        {
+            int var6 = this.getFullMetadata(par1IBlockAccess, par2, par3, par4);
+            int var7 = this.blockIndexInTexture;
+
+            if ((var6 & 8) != 0)
+            {
+                var7 -= 16;
+            }
+
+            int var8 = var6 & 3;
+            boolean var9 = (var6 & 4) != 0;
+
+            if (var9)
+            {
+                if (var8 == 0 && par5 == 2)
+                {
+                    var7 = -var7;
+                }
+                else if (var8 == 1 && par5 == 5)
+                {
+                    var7 = -var7;
+                }
+                else if (var8 == 2 && par5 == 3)
+                {
+                    var7 = -var7;
+                }
+                else if (var8 == 3 && par5 == 4)
+                {
+                    var7 = -var7;
+                }
+            }
+            else
+            {
+                if (var8 == 0 && par5 == 5)
+                {
+                    var7 = -var7;
+                }
+                else if (var8 == 1 && par5 == 3)
+                {
+                    var7 = -var7;
+                }
+                else if (var8 == 2 && par5 == 4)
+                {
+                    var7 = -var7;
+                }
+                else if (var8 == 3 && par5 == 2)
+                {
+                    var7 = -var7;
+                }
+
+                if ((var6 & 16) != 0)
+                {
+                    var7 = -var7;
+                }
+            }
+            
+
+            return Math.abs(var7);
+            
+        }
+        else
+        {
+            return this.blockIndexInTexture;
+        }
+    }
+
+	//Called to update the render information on the tile entity. Could probably implement a data watcher, but this works fine and is more versatile I think. 
+	public dimDoor updateAttatchedTile(IBlockAccess par1World, int par2, int par3, int par4)
+	{
+		TileEntity tile = (TileEntity) par1World.getBlockTileEntity(par2, par3, par4);
+		if(tile instanceof TileEntityDimDoor )
+		{
+			TileEntityDimDoor dimTile=(TileEntityDimDoor)tile;
+			
+			if(par1World.getBlockId( par2, par3+1, par4 )==par1World.getBlockId( par2, par3, par4 ))
+			{
+				//dimTile.openOrClosed=false;
+			}
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, (World)par1World)==null)
+			{
+				dimTile.openOrClosed=false;
+			}
+			else
+			{
+				dimTile.openOrClosed=true;
+			}
+			
+			int metaData = this.getFullMetadata(par1World, par2, par3, par4)%8;
+			dimTile.orientation=metaData;
+		}
+    	return this;
+    	
+	}
+	
+    /**
+     * 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.
+     */
+    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) 
+    {
+    	
+    	
+    		
+    		
+    	
+    		
+    	TileEntityDimDoor tile = (TileEntityDimDoor) par1World.getBlockTileEntity(par2, par3, par4);
+    	tile.openOrClosed=this.isDoorOpen( par1World,  par2,  par3,  par4);  	
+    	int metaData = this.getFullMetadata(par1World, par2, par3, par4);
+    	tile.orientation=metaData%8 ;
+    		
+    		
+    		
+    		
+    		
+    		
+    		
+    	
+    	
+    	
+    	
+    	
+    	
+    }
+    public boolean isOpaqueCube()
+    {
+        return false;
+    }
+
+    public boolean getBlocksMovement(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
+    {
+        int var5 = this.getFullMetadata(par1IBlockAccess, par2, par3, par4);
+        return (var5 & 4) != 0;
+    }
+
+    /**
+     * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc)
+     */
+    public boolean renderAsNormalBlock()
+    {
+        return false;
+    }
+
+    /**
+     * The type of render function that is called for this block
+     */
+    public int getRenderType()
+    {
+        return 7;
+    }
+
+    @SideOnly(Side.CLIENT)
+
+    /**
+     * Returns the bounding box of the wired rectangular prism to render.
+     */
+    public AxisAlignedBB getSelectedBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
+    {
+        this.setBlockBoundsBasedOnState(par1World, par2, par3, par4);
+        return super.getSelectedBoundingBoxFromPool(par1World, par2, par3, par4);
+    }
+
+    /**
+     * 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)
+     */
+    public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
+    {
+        this.setBlockBoundsBasedOnState(par1World, par2, par3, par4);
+        return super.getCollisionBoundingBoxFromPool(par1World, par2, par3, par4);
+    }
+
+    /**
+     * Updates the blocks bounds based on its current state. Args: world, x, y, z
+     */
+    public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
+    {
+        this.setDoorRotation(this.getFullMetadata(par1IBlockAccess, par2, par3, par4));
+    }
+
+    /**
+     * Returns 0, 1, 2 or 3 depending on where the hinge is.
+     */
+    public int getDoorOrientation(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
+    {
+        return this.getFullMetadata(par1IBlockAccess, par2, par3, par4) & 3;
+    }
+
+    public boolean isDoorOpen(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
+    {
+        return (this.getFullMetadata(par1IBlockAccess, par2, par3, par4) & 4) != 0;
+    }
+
+    private void setDoorRotation(int par1)
+    {
+        float var2 = 0.1875F;
+        this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 2.0F, 1.0F);
+        int var3 = par1 & 3;
+        boolean var4 = (par1 & 4) != 0;
+        boolean var5 = (par1 & 16) != 0;
+
+        if (var3 == 0)
+        {
+            if (var4)
+            {
+                if (!var5)
+                {
+                    this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var2);
+                }
+                else
+                {
+                    this.setBlockBounds(0.0F, 0.0F, 1.0F - var2, 1.0F, 1.0F, 1.0F);
+                }
+            }
+            else
+            {
+                this.setBlockBounds(0.0F, 0.0F, 0.0F, var2, 1.0F, 1.0F);
+            }
+        }
+        else if (var3 == 1)
+        {
+            if (var4)
+            {
+                if (!var5)
+                {
+                    this.setBlockBounds(1.0F - var2, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+                }
+                else
+                {
+                    this.setBlockBounds(0.0F, 0.0F, 0.0F, var2, 1.0F, 1.0F);
+                }
+            }
+            else
+            {
+                this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var2);
+            }
+        }
+        else if (var3 == 2)
+        {
+            if (var4)
+            {
+                if (!var5)
+                {
+                    this.setBlockBounds(0.0F, 0.0F, 1.0F - var2, 1.0F, 1.0F, 1.0F);
+                }
+                else
+                {
+                    this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, var2);
+                }
+            }
+            else
+            {
+                this.setBlockBounds(1.0F - var2, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+            }
+        }
+        else if (var3 == 3)
+        {
+            if (var4)
+            {
+                if (!var5)
+                {
+                    this.setBlockBounds(0.0F, 0.0F, 0.0F, var2, 1.0F, 1.0F);
+                }
+                else
+                {
+                    this.setBlockBounds(1.0F - var2, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
+                }
+            }
+            else
+            {
+                this.setBlockBounds(0.0F, 0.0F, 1.0F - var2, 1.0F, 1.0F, 1.0F);
+            }
+        }
+    }
+
+    /**
+     * Called when the block is clicked by a player. Args: x, y, z, entityPlayer
+     */
+    public void onBlockClicked(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
+    {
+    //	System.out.println(this.getFullMetadata(par1World, par2, par3, par4)%4);
+    }
+
+    /**
+     * Called upon block activation (right click on the block.)
+     */
+    
+
+    /**
+     * A function to open a door.
+     */
+    
+    /**
+     * 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(World par1World, int par2, int par3, int par4, int par5)
+    {
+        int var6 = par1World.getBlockMetadata(par2, par3, par4);
+
+        if ((var6 & 8) == 0)
+        {
+            boolean var7 = false;
+
+            if (par1World.getBlockId(par2, par3 + 1, par4) != this.blockID)
+            {
+                par1World.setBlockWithNotify(par2, par3, par4, 0);
+                var7 = true;
+            }
+
+            /**
+            if (!par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4))
+            {
+                par1World.setBlockWithNotify(par2, par3, par4, 0);
+                var7 = true;
+
+                if (par1World.getBlockId(par2, par3 + 1, par4) == this.blockID)
+                {
+                    par1World.setBlockWithNotify(par2, par3 + 1, par4, 0);
+                }
+            }
+            **/
+
+            if (var7)
+            {
+                if (!par1World.isRemote)
+                {
+                    this.dropBlockAsItem(par1World, par2, par3, par4, mod_pocketDim.dimDoorID, 0);
+                }
+            }
+            else
+            {
+                boolean var8 = par1World.isBlockIndirectlyGettingPowered(par2, par3, par4) || par1World.isBlockIndirectlyGettingPowered(par2, par3 + 1, par4);
+
+                if ((var8 || par5 > 0 && Block.blocksList[par5].canProvidePower()) && par5 != this.blockID)
+                {
+                    this.onPoweredBlockChange(par1World, par2, par3, par4, var8);
+                }
+            }
+        }
+        else
+        {
+            if (par1World.getBlockId(par2, par3 - 1, par4) != this.blockID)
+            {
+                par1World.setBlockWithNotify(par2, par3, par4, 0);
+            }
+
+            if (par5 > 0 && par5 != this.blockID)
+            {
+                this.onNeighborBlockChange(par1World, par2, par3 - 1, par4, par5);
+            }
+        }
+    }
+
+    /**
+     * Returns the ID of the items to drop on destruction.
+     */
+   
+
+    /**
+     * Ray traces through the blocks collision from start vector to end vector returning a ray trace hit. Args: world,
+     * x, y, z, startVec, endVec
+     */
+    public MovingObjectPosition collisionRayTrace(World par1World, int par2, int par3, int par4, Vec3 par5Vec3, Vec3 par6Vec3)
+    {
+        this.setBlockBoundsBasedOnState(par1World, par2, par3, par4);
+        return super.collisionRayTrace(par1World, par2, par3, par4, par5Vec3, par6Vec3);
+    }
+
+    /**
+     * Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
+     */
+    public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
+    {
+        return par3 >= 255 ? false : par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && super.canPlaceBlockAt(par1World, par2, par3, par4) && super.canPlaceBlockAt(par1World, par2, par3 + 1, par4);
+    }
+
+    /**
+     * Returns the mobility information of the block, 0 = free, 1 = can't push but can move over, 2 = total immobility
+     * and stop pistons
+     */
+    public int getMobilityFlag()
+    {
+        return 1;
+    }
+
+    /**
+     * Returns the full metadata value created by combining the metadata of both blocks the door takes up.
+     */
+    public int getFullMetadata(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
+    {
+        int var5 = par1IBlockAccess.getBlockMetadata(par2, par3, par4);
+        boolean var6 = (var5 & 8) != 0;
+        int var7;
+        int var8;
+
+        if (var6)
+        {
+            var7 = par1IBlockAccess.getBlockMetadata(par2, par3 - 1, par4);
+            var8 = var5;
+        }
+        else
+        {
+            var7 = var5;
+            var8 = par1IBlockAccess.getBlockMetadata(par2, par3 + 1, par4);
+        }
+
+        boolean var9 = (var8 & 1) != 0;
+        return var7 & 7 | (var6 ? 8 : 0) | (var9 ? 16 : 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 Item.doorSteel.itemID;
+    }
+    
+    public int idDropped(int par1, Random par2Random, int par3)
+    {
+        return (par1 & 8) != 0 ? 0 : (Item.doorSteel.itemID);
+    }
+
+    /**
+     * Called when the block is attempted to be harvested
+     */
+    public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5, EntityPlayer par6EntityPlayer)
+    {
+        if (par6EntityPlayer.capabilities.isCreativeMode && (par5 & 8) != 0 && par1World.getBlockId(par2, par3 - 1, par4) == this.blockID)
+        {
+            par1World.setBlockWithNotify(par2, par3 - 1, par4, 0);
+        }
+    }
+
+	
+	
+	 public TileEntity createNewTileEntity(World par1World)
+	    {
+		 
+		 TileEntity tile= new TileEntityDimDoor();
+		 
+	     return tile;
+	    }
+}

StevenDimDoors/mod_pocketDim/dimHatch.java

@@ -0,0 +1,75 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.block.BlockTrapDoor;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class dimHatch extends BlockTrapDoor
+{
+
+	protected dimHatch(int par1,int par2, Material par2Material) 
+	{
+		super(par1, Material.iron);
+        this.setCreativeTab(CreativeTabs.tabTransport);
+       // this.setTextureFile("/PocketBlockTextures.png");
+	//	 this.blockIndexInTexture =  16;
+	}
+
+	
+	 @Override
+	 public String getTextureFile()
+	 {
+		 this.blockIndexInTexture =  16;
+		 return "/PocketBlockTextures.png";
+	 }
+	 public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
+	    {
+	       
+	        {
+	            int var10 = par1World.getBlockMetadata(par2, par3, par4);
+	            par1World.setBlockMetadataWithNotify(par2, par3, par4, var10 ^ 4);
+	            par1World.playAuxSFXAtEntity(par5EntityPlayer, 1003, par2, par3, par4, 0);
+	            return true;
+	        }
+	    }
+	 //Teleports the player to the exit link of that dimension, assuming it is a pocket
+	 public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+	 {	 
+	    
+	    int num = par1World.getBlockMetadata(par2, par3, par4);
+	    
+	   	if(!par1World.isRemote&&(num>3&&num<8||num>11)&&par1World.provider instanceof pocketProvider)
+		{
+	    	EntityPlayerMP playerMP;
+	    	if(par5Entity instanceof EntityPlayerMP)
+	    	{
+	    		playerMP= (EntityPlayerMP) par5Entity;
+	    		this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+	    		 
+	   			DimData dimData = (DimData) dimHelper.instance.dimList.get(par1World.provider.dimensionId);
+	    			
+	    		LinkData exitLink=dimData.exitDimLink;
+	    		 
+	    		dimHelper.instance.teleportToPocket(par1World, exitLink, playerMP);
+	
+	    	}
+		}
+	 }
+
+	    public void onPoweredBlockChange(World par1World, int par2, int par3, int par4, boolean par5)
+	    {
+	        int var6 = par1World.getBlockMetadata(par2, par3, par4);
+	        boolean var7 = (var6 & 4) > 0;
+
+	        if (var7 != par5)
+	        {
+	            par1World.setBlockMetadataWithNotify(par2, par3, par4, var6 ^ 4);
+	            par1World.playAuxSFXAtEntity((EntityPlayer)null, 1003, par2, par3, par4, 0);
+	        }
+	    }
+}

StevenDimDoors/mod_pocketDim/itemDimDoor.java

@@ -0,0 +1,106 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemDoor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class itemDimDoor extends ItemDoor
+{
+    private Material doorMaterial;
+
+    public itemDimDoor(int par1, Material par2Material)
+    {
+    	  super(par1, par2Material);
+          this.doorMaterial = par2Material;
+          this.setCreativeTab(CreativeTabs.tabTransport);
+    }
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+   
+    
+    @Override
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    
+    		par3List.add("Place on the block under a rift");
+    		par3List.add ("to activate that rift,");
+    		par3List.add("or place anywhere else");
+    		par3List.add("to create a pocket dim");
+
+
+    	
+    }
+    @Override
+    public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+    {
+        if (par7 != 1)
+        {
+            return false;
+        }
+        else
+        {
+            ++par5;
+            Block var11;
+
+           
+            if(par1ItemStack.getItem() instanceof itemExitDoor )
+            {
+                var11 = mod_pocketDim.ExitDoor;
+            }
+            
+            else if(par1ItemStack.getItem() instanceof ItemChaosDoor )
+            {
+                var11 = mod_pocketDim.chaosDoor;
+            }
+            else
+            {
+                var11 = mod_pocketDim.dimDoor;
+            }
+            
+            
+            
+
+            if (par2EntityPlayer.canPlayerEdit(par4, par5, par6, par7, par1ItemStack) && par2EntityPlayer.canPlayerEdit(par4, par5 + 1, par6, par7, par1ItemStack)&&!par3World.isRemote)
+            {
+                int var12 = MathHelper.floor_double((double)((par2EntityPlayer.rotationYaw + 180.0F) * 4.0F / 360.0F) - 0.5D) & 3;
+
+                if (!var11.canPlaceBlockAt(par3World, par4, par5, par6)||!this.canPlace(par3World, par4, par5, par6, var12))
+                {
+                    return false;
+                }
+                else 
+                {
+                
+                    placeDoorBlock(par3World, par4, par5, par6, var12, var11);
+
+                   
+                    --par1ItemStack.stackSize;
+                    return true;
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+    
+    public boolean canPlace(World world,int i, int j, int k, int p)
+    {
+    	
+    	return true;
+         
+    }
+
+}

StevenDimDoors/mod_pocketDim/itemExitDoor.java

@@ -0,0 +1,49 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemDoor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class itemExitDoor extends itemDimDoor
+{
+    private Material doorMaterial;
+
+    public itemExitDoor(int par1, Material par2Material)
+    {
+    	  super(par1, par2Material);
+          this.doorMaterial = par2Material;
+          this.setCreativeTab(CreativeTabs.tabTransport);
+
+          //  this.setIconIndex(Item.doorWood.getIconFromDamage(0));
+    }
+    
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+    
+    
+    @Override
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    
+    		par3List.add("Place on the block under a rift");
+    		par3List.add ("in any dimension,");
+    		par3List.add("or place anywhere in pocket dim");
+    		par3List.add("to approach surface");
+
+
+    	
+    }
+    
+
+}

StevenDimDoors/mod_pocketDim/itemLinkSignature.java

@@ -0,0 +1,172 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class itemLinkSignature extends Item
+{
+    private Material doorMaterial;
+
+    public itemLinkSignature(int par1, Material par2Material)
+    {
+    	 super(par1);
+    	 this.setMaxStackSize(1);
+    	// this.setTextureFile("/PocketBlockTextures.png");
+         this.setCreativeTab(CreativeTabs.tabTransport);
+
+      //   this.iconIndex=5;
+         this.setMaxDamage(0);
+         this.hasSubtypes=true;
+    	 //TODO move to proxy
+    }
+    
+    @SideOnly(Side.CLIENT)
+    @Override
+    public boolean hasEffect(ItemStack par1ItemStack)
+    {
+    	// adds effect if item has a link stored
+    	int key=par1ItemStack.getItemDamage();
+		LinkData linkData= dimHelper.instance.interDimLinkList.get(key);
+    	if(linkData!=null)
+    	{
+    		return true;
+    	}
+       return false;
+    }
+    
+    
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+
+    @Override
+    public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
+    {
+    	int key;
+    	LinkData linkData;
+		int thisWorldID=par3World.provider.dimensionId;
+		
+		
+
+    	
+    	if(!par3World.isRemote)
+    	{		
+    		
+			//par1ItemStack= par2EntityPlayer.getCurrentEquippedItem();
+			
+    		
+    		
+    		key=par1ItemStack.getItemDamage();
+    		linkData = dimHelper.instance.interDimLinkList.get(key);
+    		//System.out.println(key);
+    		int offset = 2;
+    		if(linkData!=null&&key!=0)
+    		{
+    		// checks to see if the item has a link stored, if so, it creates it
+    			if(par3World.getBlockId(par4, par5, par6)==Block.snow.blockID)
+    			{
+    				offset = 1;
+    			}
+    				dimHelper.instance.createLink(par3World.provider.dimensionId, linkData.destDimID, par4, par5+offset, par6, linkData.destXCoord, linkData.destYCoord, linkData.destZCoord);		
+    				dimHelper.instance.createLink(linkData.destDimID, par3World.provider.dimensionId, linkData.destXCoord, linkData.destYCoord, linkData.destZCoord,par4, par5+offset, par6);		
+
+    				--par1ItemStack.stackSize;
+	    			par2EntityPlayer.sendChatToPlayer("Rift Created");
+	    			if(par2EntityPlayer.capabilities.isCreativeMode)
+	    			{
+		    			par2EntityPlayer.sendChatToPlayer("Rift Signature Cleared");
+
+	            		par2EntityPlayer.inventory.mainInventory[par2EntityPlayer.inventory.currentItem] = new ItemStack(this, 1, 0);
+
+	    			
+    			}
+    			/**
+    			else
+    			{
+	    			par2EntityPlayer.sendChatToPlayer("Both ends of a single rift cannot exist in the same dimension.");
+
+    			}
+    			**/
+    		}
+    		else 
+        	{
+    			if(par3World.getBlockId(par4, par5, par6)==Block.snow.blockID)
+    			{
+    				offset = 1;
+    			}
+    			//otherwise, it creates the first half of the link. Next click will complete it. 
+    			key= dimHelper.instance.createUniqueInterDimLinkKey();
+        		linkData= new LinkData(par3World.provider.dimensionId,par4, par5+offset, par6);
+        		
+
+        		dimHelper.instance.interDimLinkList.put(key, linkData);
+        		par1ItemStack.setItemDamage(key);
+        		
+        		PacketHandler.linkKeyPacket(linkData, key);
+    			par2EntityPlayer.sendChatToPlayer("Rift Signature Stored");
+
+        		par2EntityPlayer.inventory.mainInventory[par2EntityPlayer.inventory.currentItem] = new ItemStack(this, 1, key);
+
+        	}
+    		
+    		//dimHelper.instance.save();
+    	}
+    	
+    	
+    	return true;
+		
+    
+    }
+    
+    @SideOnly(Side.CLIENT)
+
+    /**
+     * allows items to add custom lines of information to the mouseover description
+     */
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    	LinkData linkData = dimHelper.instance.interDimLinkList.get(par1ItemStack.getItemDamage());
+    	if(linkData!=null)
+    	{
+    		par3List.add(String.valueOf("Leads to dim "+linkData.destDimID +" at depth "+dimHelper.instance.getDimDepth(linkData.destDimID)));
+    
+    	}
+    	else
+    	{
+    		par3List.add("First click stores location,");
+    		par3List.add ("second click creates two rifts,");
+    		par3List.add("that link the first location");
+    		par3List.add("with the second location");
+
+
+    	}
+    }
+    @Override
+    public void onCreated(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) 
+    {
+    	if(!par2World.isRemote)
+    	{
+    		/**
+    		//creates the first half of the link on item creation
+    		int key= dimHelper.instance.createUniqueInterDimLinkKey();
+    		LinkData linkData= new LinkData(par2World.provider.dimensionId,MathHelper.floor_double(par3EntityPlayer.posX),MathHelper.floor_double(par3EntityPlayer.posY),MathHelper.floor_double(par3EntityPlayer.posZ));
+    		System.out.println(key);
+
+    		dimHelper.instance.interDimLinkList.put(key, linkData);
+    		par1ItemStack.setItemDamage(key);
+    		**/
+    	}
+    }
+}

StevenDimDoors/mod_pocketDim/itemRiftRemover.java

@@ -0,0 +1,131 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class itemRiftRemover extends Item
+{
+    private Material doorMaterial;
+
+    public itemRiftRemover(int par1, Material par2Material)
+    {
+    	 super(par1);
+    	 this.setMaxStackSize(1);
+    	// this.setTextureFile("/PocketBlockTextures.png");
+         this.setCreativeTab(CreativeTabs.tabTransport);
+
+        // this.iconIndex=6;
+         this.setMaxDamage(5);
+         this.hasSubtypes=true;
+    	 //TODO move to proxy
+    }
+    
+    
+    @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+   
+    @SideOnly(Side.CLIENT)
+    @Override
+    public boolean hasEffect(ItemStack par1ItemStack)
+    {
+    	// adds effect if item has a link stored
+    	
+       return false;
+    }
+    
+    public static MovingObjectPosition getBlockTarget(World par1World, EntityPlayer par2EntityPlayer, boolean par3)
+    {
+        float var4 = 1.0F;
+        float var5 = par2EntityPlayer.prevRotationPitch + (par2EntityPlayer.rotationPitch - par2EntityPlayer.prevRotationPitch) * var4;
+        float var6 = par2EntityPlayer.prevRotationYaw + (par2EntityPlayer.rotationYaw - par2EntityPlayer.prevRotationYaw) * var4;
+        double var7 = par2EntityPlayer.prevPosX + (par2EntityPlayer.posX - par2EntityPlayer.prevPosX) * (double)var4;
+        double var9 = par2EntityPlayer.prevPosY + (par2EntityPlayer.posY - par2EntityPlayer.prevPosY) * (double)var4 + 1.62D - (double)par2EntityPlayer.yOffset;
+        double var11 = par2EntityPlayer.prevPosZ + (par2EntityPlayer.posZ - par2EntityPlayer.prevPosZ) * (double)var4;
+        Vec3 var13 = par1World.getWorldVec3Pool().getVecFromPool(var7, var9, var11);
+        float var14 = MathHelper.cos(-var6 * 0.017453292F - (float)Math.PI);
+        float var15 = MathHelper.sin(-var6 * 0.017453292F - (float)Math.PI);
+        float var16 = -MathHelper.cos(-var5 * 0.017453292F);
+        float var17 = MathHelper.sin(-var5 * 0.017453292F);
+        float var18 = var15 * var16;
+        float var20 = var14 * var16;
+        double var21 = 5.0D;
+        if (par2EntityPlayer instanceof EntityPlayerMP)
+        {
+            var21 = 6;
+        }
+        Vec3 var23 = var13.addVector((double)var18 * var21, (double)var17 * var21, (double)var20 * var21);
+        return par1World.rayTraceBlocks_do_do(var13, var23, true, false);
+    }
+
+    public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
+    {
+    	{		
+    		MovingObjectPosition hit = 	this.getBlockTarget(par3EntityPlayer.worldObj, par3EntityPlayer, false );
+    		if(hit!=null)
+    		{
+    			//System.out.println(hit.hitVec);
+    			if(dimHelper.instance.removeRift(par2World, hit.blockX, hit.blockY, hit.blockZ, 1, par3EntityPlayer, par1ItemStack))
+    			{
+    				
+    			}
+    			
+    		}
+    	//	dimHelper.removeRift( par3World,  par4,  par5,  par6,  range,  par2EntityPlayer,  par1ItemStack);
+    		
+    		
+    	}
+    	return par1ItemStack;
+    }
+    
+    
+    
+    @SideOnly(Side.CLIENT)
+
+    /**
+     * allows items to add custom lines of information to the mouseover description
+     */
+    @Override
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	
+    
+    		par3List.add("Use near exposed rift");
+    		par3List.add ("to remove it and");
+    		par3List.add("any nearby rifts");
+    	
+
+
+    	
+    }
+    @Override
+    public void onCreated(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) 
+    {
+    	if(!par2World.isRemote)
+    	{
+    		/**
+    		//creates the first half of the link on item creation
+    		int key= dimHelper.instance.createUniqueInterDimLinkKey();
+    		LinkData linkData= new LinkData(par2World.provider.dimensionId,MathHelper.floor_double(par3EntityPlayer.posX),MathHelper.floor_double(par3EntityPlayer.posY),MathHelper.floor_double(par3EntityPlayer.posZ));
+    		System.out.println(key);
+
+    		dimHelper.instance.interDimLinkList.put(key, linkData);
+    		par1ItemStack.setItemDamage(key);
+    		**/
+    	}
+    }
+}

StevenDimDoors/mod_pocketDim/linkDimDoor.java

@@ -0,0 +1,119 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.Item;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class linkDimDoor extends dimDoor
+{
+
+	protected linkDimDoor(int par1, Material par2Material) 
+	{
+		
+		super(par1, par2Material);
+		//this.blockIndexInTexture = 17;
+        this.setTextureFile("/PocketBlockTextures.png");
+
+		// TODO Auto-generated constructor stub
+	}
+	
+	 @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+	 
+	@Override
+	public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	{
+		if(!par1World.isRemote&&par1World.getBlockId(par2, par3-1, par4)==this.blockID)
+		{
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+			{
+				dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation=par1World.getBlockMetadata(par2, par3-1, par4);
+
+			}
+			else
+			{
+				System.out.println("couldnt find parent link!!!!!!");
+			}
+		
+		}
+		//this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+		
+	}
+	@Override
+	public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+    	
+        int var12 = (int) (MathHelper.floor_double((double)((par5Entity.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+       
+    	int num = par1World.getBlockMetadata(par2, par3-1, par4);
+    	if(!par1World.isRemote&&(num==5||num==4||num==6||num==7)&&(num-4)==var12&&par1World.getBlockId(par2, par3-1, par4)==mod_pocketDim.linkDimDoorID)
+			{
+    	EntityPlayer player;
+		if(par5Entity instanceof EntityPlayerMP)
+    	{
+    		
+    		 player= (EntityPlayer) par5Entity;
+    		 //int destinationID= dimHelper.instance.getDestIDFromCoords(par2, par3, par4, par1World);
+    		 
+    		 this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+
+    		 LinkData linkData= dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World);
+  	        dimHelper.instance.teleportToPocket(par1World, linkData, player);
+     			
+    		
+    	}
+		}
+    }
+	
+	 public int idPicked(World par1World, int par2, int par3, int par4)
+	    {
+	        return Item.doorSteel.itemID;
+	    }
+	    
+	    public int idDropped(int par1, Random par2Random, int par3)
+	    {
+	        return (par1 & 8) != 0 ? 0 : (Item.doorSteel.itemID);
+	    }
+	
+	@Override
+	public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
+    {
+        
+       
+
+        	
+        	//System.out.println(String.valueOf(par1World.getBlockMetadata(par2, par3-1, par4)));
+
+            int var10 = this.getFullMetadata(par1World, par2, par3, par4);
+            int var11 = var10 & 7;
+            var11 ^= 4;
+
+            if ((var10 & 8) == 0)
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3, par4, var11);
+                par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
+            }
+            else
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3 - 1, par4, var11);
+                par1World.markBlockRangeForRenderUpdate(par2, par3 - 1, par4, par2, par3, par4);
+            }
+
+            par1World.playAuxSFXAtEntity(par5EntityPlayer, 1003, par2, par3, par4, 0);
+            return true;
+       
+    }
+	
+	
+
+}

StevenDimDoors/mod_pocketDim/linkExitDoor.java

@@ -0,0 +1,120 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.Random;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+
+public class linkExitDoor extends dimDoor
+{
+
+	protected linkExitDoor(int par1,Material par2Material) 
+	{
+		
+		super(par1,  Material.wood);
+		//this.blockIndexInTexture = 20;
+		
+		
+		// TODO Auto-generated constructor stub
+	}
+	
+	 @Override
+	 public String getTextureFile()
+	 {
+		 return "/PocketBlockTextures.png";
+	 }
+	
+	@Override
+	public void onBlockAdded(World par1World, int par2, int par3, int par4) 
+	{
+		if(!par1World.isRemote&&par1World.getBlockId(par2, par3-1, par4)==this.blockID)
+		{
+			if(dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World)!=null)
+			{
+				dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World).linkOrientation=par1World.getBlockMetadata(par2, par3-1, par4);
+
+			}
+			else
+			{
+				System.out.println("couldnt find parent link!!!!");
+			}
+
+		
+		}
+		
+		//this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+		
+	}
+	@Override
+	public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, Entity par5Entity) 
+    {
+		
+		
+    	
+        int var12 = (int) (MathHelper.floor_double((double)((par5Entity.rotationYaw+90) * 4.0F / 360.0F) + 0.5D) & 3);
+       
+    	int num = par1World.getBlockMetadata(par2, par3-1, par4);
+    	if(!par1World.isRemote&&(num==5||num==4||num==6||num==7)&&(num-4)==var12&&par1World.getBlockId(par2, par3-1, par4)==mod_pocketDim.linkExitDoorID)
+			{
+    	EntityPlayer player;
+    	if(par5Entity instanceof EntityPlayer)
+    	{
+    		
+    		 player= (EntityPlayer) par5Entity;
+    		 //int destinationID= dimHelper.instance.getDestIDFromCoords(par2, par3, par4, par1World);
+    		 
+    		 this.onPoweredBlockChange(par1World, par2, par3, par4, false);
+
+    		 LinkData linkData= dimHelper.instance.getLinkDataFromCoords(par2, par3, par4, par1World);
+ 	        dimHelper.instance.teleportToPocket(par1World, linkData, player);
+     			
+    		
+    	}
+		}
+    }
+	
+	@Override
+	public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
+    {
+        
+       
+
+        	
+        	//System.out.println(String.valueOf(par1World.getBlockMetadata(par2, par3-1, par4)));
+
+            int var10 = this.getFullMetadata(par1World, par2, par3, par4);
+            int var11 = var10 & 7;
+            var11 ^= 4;
+
+            if ((var10 & 8) == 0)
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3, par4, var11);
+                par1World.markBlockRangeForRenderUpdate(par2, par3, par4, par2, par3, par4);
+            }
+            else
+            {
+                par1World.setBlockMetadataWithNotify(par2, par3 - 1, par4, var11);
+                par1World.markBlockRangeForRenderUpdate(par2, par3 - 1, par4, par2, par3, par4);
+            }
+
+            par1World.playAuxSFXAtEntity(par5EntityPlayer, 1003, par2, par3, par4, 0);
+            return true;
+
+    }
+	 public int idPicked(World par1World, int par2, int par3, int par4)
+	    {
+	        return Item.doorWood.itemID;
+	    }
+	    
+	    public int idDropped(int par1, Random par2Random, int par3)
+	    {
+	        return (par1 & 8) != 0 ? 0 : (Item.doorWood.itemID);
+	    }
+	
+
+}

StevenDimDoors/mod_pocketDim/mod_pocketDim.java

@@ -0,0 +1,582 @@
+package StevenDimDoors.mod_pocketDim;
+
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.tileentity.RenderEndPortal;
+import net.minecraft.client.renderer.tileentity.TileEntityRenderer;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntityEndPortal;
+import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraftforge.common.Configuration;
+import net.minecraftforge.common.DimensionManager;
+import net.minecraftforge.common.MinecraftForge;
+import StevenDimDoors.mod_pocketDimClient.ClientPacketHandler;
+import StevenDimDoors.mod_pocketDimClient.ClientTickHandler;
+import StevenDimDoors.mod_pocketDimClient.RenderDimDoor;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.common.Mod;
+import cpw.mods.fml.common.Mod.Init;
+import cpw.mods.fml.common.Mod.Instance;
+import cpw.mods.fml.common.Mod.PostInit;
+import cpw.mods.fml.common.Mod.PreInit;
+import cpw.mods.fml.common.Mod.ServerStarting;
+import cpw.mods.fml.common.Mod.ServerStopping;
+import cpw.mods.fml.common.SidedProxy;
+import cpw.mods.fml.common.event.FMLInitializationEvent;
+import cpw.mods.fml.common.event.FMLPostInitializationEvent;
+import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
+import cpw.mods.fml.common.event.FMLServerStoppingEvent;
+import cpw.mods.fml.common.network.NetworkMod;
+import cpw.mods.fml.common.network.NetworkMod.SidedPacketHandler;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.common.registry.LanguageRegistry;
+import cpw.mods.fml.common.registry.TickRegistry;
+import cpw.mods.fml.relauncher.Side;
+
+@Mod(modid = "DimensionalDoors", name = "Dimensional Doors", version = "1.2.0")
+
+@NetworkMod(clientSideRequired = true, serverSideRequired = false,
+        clientPacketHandlerSpec =
+                @SidedPacketHandler(channels = {"pocketDim" }, packetHandler = ClientPacketHandler.class),
+        serverPacketHandlerSpec =
+                @SidedPacketHandler(channels = {"pocketDim" }, packetHandler = ServerPacketHandler.class),
+                channels={"GenericRandom"}, packetHandler = PacketHandler.class, connectionHandler=ConnectionHandler.class)
+
+public class mod_pocketDim
+{
+	//need to clean up 
+    @SidedProxy(clientSide = "StevenDimDoors.mod_pocketDimClient.ClientProxy", serverSide = "StevenDimDoors.mod_pocketDim.CommonProxy")
+    public static CommonProxy proxy;
+
+    @Instance("PocketDimensions")
+    public static mod_pocketDim instance = new mod_pocketDim();
+    public static SchematicLoader loader = new SchematicLoader();
+ 
+    
+    public static int providerID;
+    public static int dimDoorID;
+    public static int ExitDoorID;
+    public static int linkExitDoorID;
+    public static int itemLinkSignatureID;
+    public static int blockRiftID;
+    public static int transientDoorID;
+    public static int itemRiftBladeID;
+
+    public static int itemStableFabricID;
+    public static int itemExitDoorID;
+    public static int limboDimID;
+    public static int limboProviderID;
+    public static int itemChaosDoorID;
+    public static int chaosDoorID;
+	public static int blockLimboID;
+    public static int dimHatchID;
+	public static int riftSpreadFactor;
+	public static int DoorRenderID=55;
+	public static int HOW_MUCH_TNT;
+
+	
+    public static int itemDimDoorID;
+    public static int linkDimDoorID;
+    public static int blockDimWallID;
+    public static int itemRiftRemoverID;
+    public static int blockDimWallPermID;
+    public static Block linkDimDoor;
+    public static Block transientDoor;
+    public static Block ExitDoor;
+    public static Block chaosDoor;
+    public static Block linkExitDoor;
+    public static Block blockRift;
+    public static Block blockLimbo;
+    public static  Block dimDoor;    
+    public static  Block blockDimWall;   
+    public static  Block dimHatch;
+    public static Block blockDimWallPerm;
+    public static  Item itemRiftBlade;
+
+    public static  Item itemDimDoor;
+    public static  Item itemExitDoor;
+    public static  Item itemRiftRemover;
+    public static  Item itemLinkSignature;
+    public static  Item itemStableFabric;
+    public static  Item itemChaosDoor;
+    
+    
+    
+    public static PlayerRespawnTracker tracker= new PlayerRespawnTracker();
+    
+    public static ArrayList<EntityItem> limboSpawnInventory=new ArrayList<EntityItem>();
+    
+    public static ArrayList blocksImmuneToRift= new ArrayList();
+	public static ArrayList<DungeonGenerator> registeredDungeons = new ArrayList<DungeonGenerator>();
+	
+	public static ArrayList<DungeonGenerator> simpleHalls = new ArrayList<DungeonGenerator>();
+
+	
+	public static ArrayList<DungeonGenerator> complexHalls = new ArrayList<DungeonGenerator>();
+
+	
+	public static ArrayList<DungeonGenerator> deadEnds = new ArrayList<DungeonGenerator>();
+
+	
+	public static ArrayList<DungeonGenerator> hubs = new ArrayList<DungeonGenerator>();
+
+	
+	public static ArrayList<DungeonGenerator> mazes = new ArrayList<DungeonGenerator>();
+
+	
+	public static ArrayList<DungeonGenerator> pistonTraps = new ArrayList<DungeonGenerator>();
+
+	
+	public static ArrayList<DungeonGenerator> exits = new ArrayList<DungeonGenerator>();
+
+	public static ArrayList metadataFlipList = new ArrayList();
+	public static ArrayList metadataNextList = new ArrayList();
+	
+	public static DungeonGenerator defaultUp = new DungeonGenerator(0, "smallStairsUp.schematic", null);
+
+
+
+    
+
+    
+    public static boolean riftsInWorldGen;
+ 
+	public static boolean isLimboActive;
+	
+	  public static boolean enableIronDimDoor;
+	  
+		public static boolean enableWoodenDimDoor;
+		
+		  public static boolean enableRiftSignature;
+		  
+			public static boolean enableRiftRemover;
+			
+			public static boolean enableUnstableDoor;
+
+			public static boolean enableRiftBlade;
+
+			public static boolean enableDimTrapDoor;
+
+			public static boolean enableDoorOpenGL;
+
+
+
+	public static boolean hasInitDims=false;
+
+    public static boolean TNFREAKINGT;
+
+	public static boolean isPlayerWearingGoogles=false;
+    
+
+
+	
+
+    public static RiftGenerator riftGen = new RiftGenerator();
+    
+    
+    public static World limbo= null;
+
+    public static long genTime;
+
+    
+
+
+
+
+
+    @PreInit
+    public void PreInit(FMLPreInitializationEvent event)
+    {
+    	
+        MinecraftForge.EVENT_BUS.register(new EventHookContainer());
+
+    
+
+        
+
+         Configuration config = new Configuration(event.getSuggestedConfigurationFile());
+         
+
+         
+         
+         config.load();
+         this.enableDimTrapDoor = config.get("BOOLEAN", "true to enable trap door crafting", true).getBoolean(true);
+         this.enableIronDimDoor = config.get("BOOLEAN", "true to enable iron dim door crafting", true).getBoolean(true);
+         this.enableRiftBlade = config.get("BOOLEAN", "true to enable rift blade crafting", true).getBoolean(true);
+         this.enableRiftRemover = config.get("BOOLEAN", "true to enable rift remover crafting", true).getBoolean(true);
+         this.enableRiftSignature = config.get("BOOLEAN", "true to enable rift signature crafting", true).getBoolean(true);
+         this.enableUnstableDoor = config.get("BOOLEAN", "true to enable unstable door crafting", true).getBoolean(true);
+         this.enableWoodenDimDoor = config.get("BOOLEAN", "true to enable wooden door crafting", true).getBoolean(true);
+         this.enableDoorOpenGL = config.get("BOOLEAN", "Toggles the door render effect", true).getBoolean(true);
+
+         chaosDoorID = config.getBlock("Chaos Door", 1978).getInt();
+         dimDoorID = config.getBlock("Dimensional Door", 1970).getInt();
+         dimHatchID = config.getBlock("Transdimensional Hatch", 1971).getInt();
+         linkDimDoorID= config.getBlock("Dimensional Door Link", 1972).getInt();
+         blockDimWallID=config.getBlock("Fabric of Reality", 1973).getInt();
+         ExitDoorID = config.getBlock("Warp Door", 1975).getInt();
+         linkExitDoorID = config.getBlock("Warp Door Link", 1976).getInt();
+         blockRiftID = config.getBlock("Rift", 1977).getInt();
+         transientDoorID = config.getBlock("transientDoorID", 1979).getInt();
+
+         itemRiftBladeID=config.getItem("Rift Blade", 5176).getInt();
+ 
+         itemChaosDoorID=config.getItem("Chaos Door", 5173).getInt();
+         itemRiftRemoverID=config.getItem("Rift Remover", 5171).getInt();
+         itemStableFabricID=config.getItem("Unstable Fabric", 5172).getInt();
+         itemExitDoorID=config.getItem("Warp Door Item", 5173).getInt();
+         itemDimDoorID=config.getItem("Dimensional Door Item", 5174).getInt();
+         itemLinkSignatureID=config.getItem("Rift Signature Item", 5175).getInt();
+         
+         TNFREAKINGT = config.get("BOOLEAN", "EXPLOSIONS!!???!!!?!?!!", false).getBoolean(false);
+         HOW_MUCH_TNT=config.get("Int", "Chance that a block will not be TNT. must be greater than 1. Explosions!?!?? must be set to true, and you figure out what it does. ", 25).getInt(25);
+
+   
+         blockLimboID=config.get("Int", "Block ID for Limbo- must be below 256", 217).getInt();
+         blockDimWallPermID=config.get("Int", "Block ID for blockDimWallPermID- must be below 256", 218).getInt();
+         this.limboDimID=config.get("Int", "Limbo Dimension ID", -23).getInt();
+
+         providerID=config.get("Int", "ProviderID", 12).getInt();
+         this.limboProviderID=config.get("Int", "Limbo Provider ID", 13).getInt();
+
+      
+         
+         this.riftsInWorldGen = config.get("BOOLEAN", "Should rifts generate natrually in the world? ", true).getBoolean(true);
+         this.isLimboActive = config.get("BOOLEAN", "Toggles limbo", true).getBoolean(true);
+
+         this.riftSpreadFactor =  config.get("Int", "How many times a rift can spread- 0 prevents rifts from spreading at all. I dont recommend putting it highter than 5, because its rather exponential. ", 3).getInt();
+
+         
+         config.save();
+	
+    }
+    
+    @Init
+    public void Init(FMLInitializationEvent event)
+    {
+    
+        transientDoor = (new TransientDoor(transientDoorID, Material.iron)).setHardness(1.0F).setRequiresSelfNotify().setBlockName("transientDoor");
+
+        linkDimDoor = (new linkDimDoor(linkDimDoorID, Material.iron)).setHardness(1.0F).setRequiresSelfNotify().setBlockName("dimDoor");
+        blockDimWall = (new BlockDimWall(blockDimWallID, 0, Material.iron)).setLightValue(1.0F).setHardness(0.1F).setBlockName("blockDimWall");
+        blockDimWallPerm = (new BlockDimWallPerm(blockDimWallPermID, 0, Material.iron)).setLightValue(1.0F).setBlockUnbreakable().setHardness(100000.0F).setBlockName("blockDimWallPerm");
+        ExitDoor = (new ExitDoor(ExitDoorID, Material.wood)).setHardness(1.0F).setRequiresSelfNotify().setBlockName("dimDoorexit");
+        linkExitDoor = (new linkExitDoor(linkExitDoorID, Material.wood)).setHardness(1.0F).setRequiresSelfNotify().setBlockName("dimDoorexitlink");
+        blockRift = (new BlockRift(blockRiftID, 0, Material.air).setHardness(1.0F).setRequiresSelfNotify().setBlockName("rift"));
+        blockLimbo = (new BlockLimbo(blockLimboID, 15, Material.iron).setHardness(.2F).setBlockName("limob").setLightValue(.0F));
+        chaosDoor = (new ChaosDoor(chaosDoorID, Material.iron).setHardness(.2F).setBlockName("chaosDoor").setLightValue(.0F).setRequiresSelfNotify());
+        dimDoor = (new dimDoor(dimDoorID, Material.iron)).setHardness(1.0F).setRequiresSelfNotify().setBlockName("dimDoor");
+        dimHatch = (new dimHatch(dimHatchID,   84, Material.iron)).setHardness(1.0F).setRequiresSelfNotify().setBlockName("dimHatch");
+        
+        itemDimDoor = (new itemDimDoor(itemDimDoorID, Material.iron)).setItemName("itemDimDoor");
+        itemExitDoor = (new itemExitDoor(itemExitDoorID, Material.wood)).setItemName("itemDimDoorexit");
+        itemLinkSignature = (new itemLinkSignature(itemLinkSignatureID, Material.wood)).setItemName("itemLinkSignature");
+        itemRiftRemover = (new itemRiftRemover(itemRiftRemoverID, Material.wood)).setItemName("itemRiftRemover");
+        itemStableFabric = (new ItemStableFabric(itemStableFabricID, 0)).setItemName("itemStableFabric");
+        itemChaosDoor = (new ItemChaosDoor(itemChaosDoorID, Material.iron)).setItemName("itemChaosDoor");
+        itemRiftBlade = (new ItemRiftBlade(itemRiftBladeID, Material.iron)).setItemName("ItemRiftBlade");
+
+        
+        proxy.loadTextures();
+    	proxy.registerRenderers();
+    	GameRegistry.registerWorldGenerator(this.riftGen);
+        
+        GameRegistry.registerBlock(chaosDoor, "Unstable Door");
+        GameRegistry.registerBlock(ExitDoor, "Warp Door");
+        GameRegistry.registerBlock(linkExitDoor, "Warp Door link");
+        GameRegistry.registerBlock(blockRift, "Rift");
+        GameRegistry.registerBlock(blockLimbo, "Unraveled Fabric");
+        GameRegistry.registerBlock(linkDimDoor, "Dimensional Door link");
+        GameRegistry.registerBlock(dimDoor, "Dimensional Door");
+        GameRegistry.registerBlock(dimHatch,"Transdimensional Trapdoor");
+        GameRegistry.registerBlock(blockDimWall, "Fabric of Reality");
+        GameRegistry.registerBlock(blockDimWallPerm, "Fabric of RealityPerm");
+        GameRegistry.registerBlock(transientDoor, "transientDoor");
+
+        GameRegistry.registerPlayerTracker(tracker);
+        
+        
+        
+        DimensionManager.registerProviderType(this.providerID, pocketProvider.class, false);
+        DimensionManager.registerProviderType(this.limboProviderID, LimboProvider.class, false);
+        
+        
+      
+        DimensionManager.registerDimension(this.limboDimID	, this.limboProviderID);
+        
+        LanguageRegistry.addName(transientDoor	, "transientDoor");
+
+        LanguageRegistry.addName(blockRift	, "Rift");
+        LanguageRegistry.addName(blockLimbo	, "Unraveled Fabric");
+        LanguageRegistry.addName(ExitDoor	, "Warp Door");
+        LanguageRegistry.addName(chaosDoor	, "Unstable Door");
+        LanguageRegistry.addName(linkDimDoor, "Dimensional Door");
+        LanguageRegistry.addName(blockDimWall	, "Fabric of Reality");
+        LanguageRegistry.addName(blockDimWallPerm	, "Fabric of Reality");
+        LanguageRegistry.addName(dimDoor, "Dimensional Door");
+        LanguageRegistry.addName(dimHatch, "Transdimensional Trapdoor");
+        
+        LanguageRegistry.addName(itemExitDoor	, "Warp Door");
+        LanguageRegistry.addName(itemLinkSignature	, "Rift Signature");
+        LanguageRegistry.addName(itemRiftRemover	, "Rift Remover");
+        LanguageRegistry.addName(itemStableFabric	, "Unstable Fabric");
+        LanguageRegistry.addName(itemChaosDoor	, "Unstable Door");
+        LanguageRegistry.addName(itemDimDoor, "Dimensional Door");
+        LanguageRegistry.addName(itemRiftBlade	, "Rift Blade");
+
+
+        TickRegistry.registerTickHandler(new ClientTickHandler(), Side.CLIENT);
+        TickRegistry.registerTickHandler(new CommonTickHandler(), Side.SERVER);
+
+        GameRegistry.registerTileEntity(TileEntityDimDoor.class, "TileEntityDimDoor");
+        GameRegistry.registerTileEntity(TileEntityRift.class, "TileEntityRift");
+
+        if(this.enableIronDimDoor)
+        {
+    	 GameRegistry.addRecipe(new ItemStack(itemDimDoor, 1), new Object[]
+                 {
+                     "   ", "yxy", "   ", 'x', Item.enderPearl,  'y', Item.doorSteel 
+                 });
+    	 
+    	 GameRegistry.addRecipe(new ItemStack(itemDimDoor, 1), new Object[]
+                 {
+                     "   ", "yxy", "   ", 'x', this.itemStableFabric,  'y', Item.doorSteel 
+                 });
+        }
+    	 
+        if(this.enableUnstableDoor)
+        {
+    	 GameRegistry.addRecipe(new ItemStack(itemChaosDoor, 1), new Object[]
+                 {
+                     "   ", "yxy", "   ", 'x', Item.eyeOfEnder,  'y', this.itemDimDoor 
+                 });
+        }
+        if(this.enableWoodenDimDoor)
+        {
+    	 GameRegistry.addRecipe(new ItemStack(itemExitDoor, 1), new Object[]
+                 {
+                     "   ", "yxy", "   ", 'x', Item.enderPearl,  'y', Item.doorWood 
+                 });
+    	 
+    	 GameRegistry.addRecipe(new ItemStack(itemExitDoor, 1), new Object[]
+                 {
+                     "   ", "yxy", "   ", 'x', this.itemStableFabric,  'y', Item.doorWood 
+                 });
+        }
+        if(this.enableDimTrapDoor)
+        {
+    	 GameRegistry.addRecipe(new ItemStack(dimHatch, 1), new Object[]
+                 {
+                     " y ", " x ", " y ", 'x', Item.enderPearl,  'y', Block.trapdoor
+                 });
+    	 
+    	 GameRegistry.addRecipe(new ItemStack(dimHatch, 1), new Object[]
+                 {
+                     " y ", " x ", " y ", 'x', this.itemStableFabric,  'y', Block.trapdoor
+                 });
+        }
+        if(this.enableRiftSignature)
+        {
+    	 GameRegistry.addRecipe(new ItemStack(itemLinkSignature, 1), new Object[]
+                 {
+                     " y ", "yxy", " y ", 'x', Item.enderPearl,  'y', Item.ingotIron
+                 });
+
+    	 GameRegistry.addRecipe(new ItemStack(itemLinkSignature, 1), new Object[]
+                 {
+                     " y ", "yxy", " y ", 'x', this.itemStableFabric,  'y', Item.ingotIron
+                 });
+        }
+        if(this.enableRiftRemover)
+        {
+    	 GameRegistry.addRecipe(new ItemStack(itemRiftRemover, 1), new Object[]
+                 {
+                     " y ", "yxy", " y ", 'x', Item.enderPearl,  'y', Item.ingotGold
+                 });
+    	 GameRegistry.addRecipe(new ItemStack(itemRiftRemover, 1), new Object[]
+                 {
+                     " y ", "yxy", " y ", 'x', this.itemStableFabric,  'y', Item.ingotGold
+                 });
+        }
+     
+    	
+    	
+    	
+        if(this.enableRiftBlade)
+        {
+    	
+    	 GameRegistry.addRecipe(new ItemStack(itemRiftBlade, 1), new Object[]
+                 {
+                     " x ", " x ", " y ", 'x', this.itemRiftRemover,  'y', Item.ingotGold
+                 });
+        }
+    	 
+        /**
+    	 GameRegistry.addRecipe(new ItemStack(itemStableFabric, 4), new Object[]
+                 {
+                     " y ", "yxy", " y ", 'x', Item.eyeOfEnder,  'y', this.blockLimbo
+                 });
+                 
+                 **/
+    	 
+    	 this.blocksImmuneToRift.add(this.blockDimWallID);
+    	 this.blocksImmuneToRift.add(this.blockDimWallPermID);
+    	 this.blocksImmuneToRift.add(this.dimDoorID);
+    	 this.blocksImmuneToRift.add(this.ExitDoorID);
+    	 this.blocksImmuneToRift.add(this.linkDimDoorID);
+    	 this.blocksImmuneToRift.add(this.linkExitDoorID);
+    	 this.blocksImmuneToRift.add(this.dimHatchID);
+    	 this.blocksImmuneToRift.add(this.chaosDoorID);
+    	 this.blocksImmuneToRift.add(this.blockRiftID);
+    	 this.blocksImmuneToRift.add(this.transientDoorID);
+    	 this.blocksImmuneToRift.add(Block.blockSteel.blockID);
+    	 this.blocksImmuneToRift.add(Block.blockDiamond.blockID);
+    	 this.blocksImmuneToRift.add(Block.blockEmerald.blockID);
+    	 this.blocksImmuneToRift.add(Block.blockGold.blockID);
+    	 this.blocksImmuneToRift.add(Block.blockLapis.blockID);
+    	 this.blocksImmuneToRift.add(Block.bedrock.blockID);
+
+    
+	 		this.hubs.add(new DungeonGenerator(0, "4WayBasicHall.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "4WayBasicHall.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "doorTotemRuins.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "hallwayTrapRooms1.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "longDoorHallway.schematic", null));
+    	 	this.hubs.add(new DungeonGenerator(0, "smallRotundaWithExit.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "fortRuins.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "4WayHallExit.schematic", null));
+ 	 		this.hubs.add(new DungeonGenerator(0, "4WayHallExit.schematic", null));
+
+
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "collapsedSingleTunnel1.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "singleStraightHall1.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "smallBranchWithExit.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "smallSimpleLeft.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "smallSimpleRight.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "simpleStairsUp.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "simpleStairsDown.schematic", null));
+ 	 		this.simpleHalls.add(new DungeonGenerator(0, "simpleSmallT1.schematic", null));
+
+
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "brokenPillarsO.schematic", null));
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "buggyTopEntry1.schematic", null));
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "exitRuinsWithHiddenDoor.schematic", null));
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "hallwayHiddenTreasure.schematic", null));
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "mediumPillarStairs.schematic", null));
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "ruinsO.schematic", null));
+ 	 		this.complexHalls.add(new DungeonGenerator(0, "pitStairs.schematic", null));
+
+ 	 		
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "azersDungeonO.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "diamondTowerTemple1.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "fallingTrapO.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "hiddenStaircaseO.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "lavaTrapO.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "randomTree.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "smallHiddenTowerO.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "smallSilverfishRoom.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "tntTrapO.schematic", null));
+ 			this.deadEnds.add(new DungeonGenerator(0, "smallDesert.schematic", null));
+ 	 		this.deadEnds.add(new DungeonGenerator(0, "smallPond.schematic", null));
+ 	 		
+ 	 		
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "fakeTNTTrap.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "hallwayPitFallTrap.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "hallwayPitFallTrap.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "pistonFallRuins.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "pistonFloorHall.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "pistonFloorHall.schematic", null));
+ 	 //		this.pistonTraps.add(new DungeonGenerator(0, "pistonHallway.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "pistonSmasherHall.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "raceTheTNTHall.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "simpleDropHall.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "wallFallcomboPistonHall.schematic", null));
+ 	 		this.pistonTraps.add(new DungeonGenerator(0, "wallFallcomboPistonHall.schematic", null));
+ 	 	
+	
+ 	 		this.mazes.add(new DungeonGenerator(0, "smallMaze1.schematic", null));
+ 	 		this.mazes.add(new DungeonGenerator(0, "smallMultilevelMaze.schematic", null));
+ 	 	
+
+ 	 		this.exits.add(new DungeonGenerator(0, "exitCube.schematic", null));
+ 	 		this.exits.add(new DungeonGenerator(0, "lockingExitHall.schematic", null));
+ 	 		this.exits.add(new DungeonGenerator(0, "smallExitPrison.schematic", null));
+ 	 		this.exits.add(new DungeonGenerator(0, "lockingExitHall.schematic", null));
+
+ 	 		this.registeredDungeons.addAll(this.simpleHalls);
+ 	 	 	this.registeredDungeons.addAll(this.exits);
+ 	 		this.registeredDungeons.addAll(this.pistonTraps);
+ 	 		this.registeredDungeons.addAll(this.mazes);
+ 	 		this.registeredDungeons.addAll(this.deadEnds);
+ 	 		this.registeredDungeons.addAll(this.complexHalls);
+ 	 		this.registeredDungeons.addAll(this.hubs);
+
+
+
+ 	 		
+    	 	
+
+    		this.metadataFlipList.add(Block.dispenser.blockID);
+    		this.metadataFlipList.add(Block.stairsStoneBrickSmooth.blockID);
+    		this.metadataFlipList.add(Block.lever.blockID);
+    		this.metadataFlipList.add(Block.stoneButton.blockID);
+    		this.metadataFlipList.add(Block.redstoneRepeaterIdle.blockID);
+    		this.metadataFlipList.add(Block.redstoneRepeaterActive.blockID);
+    		this.metadataFlipList.add(Block.tripWireSource.blockID);
+    		this.metadataFlipList.add(Block.torchWood.blockID);
+    		this.metadataFlipList.add(Block.torchRedstoneIdle.blockID);
+    		this.metadataFlipList.add(Block.torchRedstoneActive.blockID);
+    		this.metadataFlipList.add(Block.doorSteel.blockID);
+    		this.metadataFlipList.add(Block.doorWood.blockID);
+    		this.metadataFlipList.add(Block.pistonBase.blockID);
+    		this.metadataFlipList.add(Block.pistonStickyBase.blockID);
+    		
+    		this.metadataNextList.add(Block.redstoneRepeaterIdle.blockID);
+    		this.metadataNextList.add(Block.redstoneRepeaterActive.blockID);
+
+
+    }
+    
+    @PostInit
+    public void PostInit(FMLPostInitializationEvent event)
+    {
+    	//dimHelper.instance.dimList.put(this.limboDimID, new DimData( this.limboDimID,  false,  0,  new LinkData()));
+    }
+    
+    @ServerStopping
+    public void serverStopping(FMLServerStoppingEvent event)
+    {
+    	try
+    	{
+    	this.limbo=null;
+    	dimHelper.instance.save();
+    	dimHelper.instance.unregsisterDims();
+    	dimHelper.dimList.clear();
+    	dimHelper.blocksToDecay.clear();
+    	dimHelper.instance.interDimLinkList.clear();
+    	dimHelper.instance.linksForRendering.clear();
+    	this.hasInitDims=false;
+    	}
+    	catch(Exception e)
+    	{
+    		e.printStackTrace();
+    	}
+    }
+    @ServerStarting
+    public void serverStarting(FMLServerStartingEvent event)
+    {
+    	dimHelper.instance.load();
+   
+    
+    }
+    
+    
+}

StevenDimDoors/mod_pocketDim/pocketGenerator.java

@@ -0,0 +1,80 @@
+package StevenDimDoors.mod_pocketDim;
+
+import java.util.List;
+
+import net.minecraft.entity.EnumCreatureType;
+import net.minecraft.world.ChunkPosition;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.IChunkProvider;
+import net.minecraft.world.gen.ChunkProviderGenerate;
+
+public class pocketGenerator extends ChunkProviderGenerate implements IChunkProvider
+{
+	 private World world;
+
+	public pocketGenerator(World par1World, long par2, boolean par4) 
+	{
+		
+		super(par1World, par2, par4);
+		// TODO Auto-generated constructor stub
+		this.world=par1World;
+	}
+	@Override
+	public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte)
+    {
+    
+    }
+	
+	
+
+	@Override
+	public Chunk provideChunk(int par1, int par2)
+    {
+       
+		 byte[] var3 = new byte[32768];
+        
+        Chunk var4 = new Chunk(this.world, var3, par1, par2);
+       
+        return var4;
+    }
+
+
+	@Override
+	public Chunk loadChunk(int var1, int var2) {
+		// TODO Auto-generated method stub
+		return super.loadChunk(var1, var2);
+	}
+
+	@Override
+	public void populate(IChunkProvider var1, int var2, int var3) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	
+	
+	
+
+
+	
+
+	@Override
+	public List getPossibleCreatures(EnumCreatureType var1, int var2, int var3,
+			int var4) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public ChunkPosition findClosestStructure(World var1, String var2,
+			int var3, int var4, int var5) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+
+
+	
+
+}

StevenDimDoors/mod_pocketDim/pocketProvider.java

@@ -0,0 +1,95 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.WorldProvider;
+import net.minecraft.world.chunk.IChunkProvider;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class pocketProvider extends WorldProvider
+
+{
+	public int exitXCoord;
+	public int exitYCoord;
+	public int exitZCoord;
+	public int exitDimID;
+	public boolean hasNoSky = true;
+	public pocketProvider()
+	{
+		this.hasNoSky=true;
+		
+	}
+  //  @SideOnly(Side.CLIENT)
+	@Override
+	public String getSaveFolder()
+    {
+        return (dimensionId == 0 ? null : "DimensionalDoors/pocketDimID" + dimensionId);
+    }
+	public Vec3 getSkyColor(Entity cameraEntity, float partialTicks)
+	{
+    	setCloudRenderer( new CloudRenderBlank());
+        return this.worldObj.getWorldVec3Pool().getVecFromPool((double)0, (double)0, (double)0);
+
+	}
+	
+	 public void setAllowedSpawnTypes(boolean allowHostile, boolean allowPeaceful)
+	 {
+	       super.setAllowedSpawnTypes(false, false);
+	 }
+    @SideOnly(Side.CLIENT)
+	@Override
+	public Vec3 getFogColor(float par1, float par2)
+    {
+        return this.worldObj.getWorldVec3Pool().getVecFromPool((double)0, (double)0, (double)0);
+
+    }
+	@Override
+	public double getHorizon()
+    {
+        return worldObj.getHeight();
+    }
+	@Override
+	public IChunkProvider createChunkGenerator()
+	{
+		return new pocketGenerator(worldObj, dimensionId, false);
+	}
+	 @Override
+	    public boolean canSnowAt(int x, int y, int z)
+	    {
+	        return false;
+	    }
+	 public boolean canBlockFreeze(int x, int y, int z, boolean byWater)
+	    {
+	        return false;
+	    }
+
+	@Override
+	public String getDimensionName() 
+	{
+		// TODO Auto-generated method stub
+		return "PocketDim";
+	}
+	
+	
+	public int getRespawnDimension(EntityPlayerMP player)
+	{
+		if(mod_pocketDim.isLimboActive)
+		{
+	       return mod_pocketDim.limboDimID;
+		}
+		else
+		{
+			return dimHelper.dimList.get(this.dimensionId).exitDimLink.destDimID;
+		}
+	}
+	
+	 public boolean canRespawnHere()
+	    {
+	        return false;
+	    }
+
+	
+
+}

StevenDimDoors/mod_pocketDim/pocketTeleporter.java

@@ -0,0 +1,93 @@
+package StevenDimDoors.mod_pocketDim;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.Teleporter;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldServer;
+
+public class pocketTeleporter extends Teleporter
+{
+	int x,y,z;
+	World world;
+	LinkData sendingLink;
+	
+
+ public pocketTeleporter(WorldServer par1WorldServer, LinkData link) 
+	 
+	 {
+		
+		 
+		super(par1WorldServer);
+		this.x=link.destXCoord;
+		this.y=link.destYCoord;
+		this.z=link.destZCoord;
+		this.sendingLink=link;
+		 world = par1WorldServer;
+	 }
+	
+
+	    /**
+	     * Create a new portal near an entity.
+	     */
+	 @Override
+	    public void placeInPortal(Entity par1Entity, double par2, double par4, double par6, float par8)
+	    {
+	    	EntityPlayer player = (EntityPlayer) par1Entity;
+	    
+	    	
+            int id;
+         
+            	
+            		id=dimHelper.instance.getDestOrientation(sendingLink);
+            		//System.out.println("Teleporting with link oreintation "+id);
+
+         //   System.out.println(id);
+            player.rotationYaw=(id*90)+90;
+                if(id==2||id==6)
+                {
+                	player.setPositionAndUpdate( x+1.5, y-1, z+.5 );
+                	
+
+                }
+                else if(id==3||id==7)
+                {
+                	
+                	player.setPositionAndUpdate( x+.5, y-1, z+1.5 );
+                
+
+                }
+                else if(id==0||id==4)
+                {
+                	
+                	player.setPositionAndUpdate(x-.5, y-1, z+.5);
+                
+                }
+                else if(id==1||id==5)
+                {
+                	player.setPositionAndUpdate(x+.5, y-1, z-.5);	
+                	
+
+                }
+                else
+                {
+                	player.setPositionAndUpdate(x, y-1, z);	
+
+                }
+                
+                
+                
+                
+	    }
+
+	    @Override
+	    public boolean func_85188_a(Entity par1Entity)
+	    {
+	    	return true;
+	    }
+	    @Override
+	    public void func_85189_a(long par1)
+	    {
+	    
+	    }
+}

StevenDimDoors/mod_pocketDimClient/ClientPacketHandler.java

@@ -0,0 +1,26 @@
+
+
+// This is my package declaration, do not mess with the standard (package net.minecraft.src;) like I did,
+// Because I know what Im doing in this part, If you don't know what your doing keep it the normal (package net.minecraft.src;)
+package StevenDimDoors.mod_pocketDimClient;
+
+// Theses are all the imports you need
+import net.minecraft.network.INetworkManager;
+import net.minecraft.network.packet.Packet250CustomPayload;
+import cpw.mods.fml.common.network.IPacketHandler;
+import cpw.mods.fml.common.network.Player;
+
+// Create a class and implement IPacketHandler
+// This just handles the data packets in the server
+public class ClientPacketHandler implements IPacketHandler{
+
+
+
+
+@Override
+public void onPacketData(INetworkManager manager,
+		Packet250CustomPayload packet, Player player) {
+	// TODO Auto-generated method stub
+	
+}
+}

StevenDimDoors/mod_pocketDimClient/ClientProxy.java

@@ -0,0 +1,66 @@
+package StevenDimDoors.mod_pocketDimClient;
+import cpw.mods.fml.client.registry.ClientRegistry;
+import cpw.mods.fml.client.registry.RenderingRegistry;
+import net.minecraft.src.ModLoader;
+import net.minecraftforge.client.MinecraftForgeClient;
+import StevenDimDoors.mod_pocketDim.CommonProxy;
+import StevenDimDoors.mod_pocketDim.TileEntityDimDoor;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+
+public class ClientProxy extends CommonProxy
+{
+	@Override
+	public void registerRenderers()
+	{
+
+		MinecraftForgeClient.preloadTexture(BLOCK_PNG);
+		MinecraftForgeClient.preloadTexture(WARP_PNG);
+		MinecraftForgeClient.preloadTexture(RIFT_PNG);
+
+		MinecraftForgeClient.preloadTexture(RIFT2_PNG);
+
+		
+	}
+	
+	
+	@Override
+	public void loadTextures()
+	{
+
+		mod_pocketDim.itemStableFabric.setIconIndex(9).setItemName("451");  
+		mod_pocketDim.itemRiftBlade.setIconIndex(10).setItemName("445");  
+
+		mod_pocketDim.itemDimDoor.setIconIndex(8).setItemName("45");  
+		mod_pocketDim.itemExitDoor.setIconIndex(7).setItemName("233");  
+		mod_pocketDim.itemLinkSignature.setIconIndex(5).setItemName("5");  
+		mod_pocketDim.itemRiftRemover.setIconIndex(6).setItemName("6");  
+		mod_pocketDim.blockRift.blockIndexInTexture=0;
+		mod_pocketDim.blockDimWall.blockIndexInTexture=0;
+		mod_pocketDim.blockLimbo.blockIndexInTexture=15;
+		mod_pocketDim.itemChaosDoor.setIconIndex(21).setItemName("9");  
+
+		mod_pocketDim.blockDimWallPerm.blockIndexInTexture=0;
+		mod_pocketDim.blockRift.blockIndexInTexture=200;
+		mod_pocketDim.dimDoor.blockIndexInTexture=18;
+		mod_pocketDim.ExitDoor.blockIndexInTexture=19;
+		mod_pocketDim.chaosDoor.blockIndexInTexture=30;
+		mod_pocketDim.transientDoor.blockIndexInTexture=200;
+
+		mod_pocketDim.linkDimDoor.blockIndexInTexture=17;
+		mod_pocketDim.linkExitDoor.blockIndexInTexture=20;
+
+		
+        ClientRegistry.bindTileEntitySpecialRenderer(TileEntityDimDoor.class, new RenderDimDoor());
+
+		    
+	    
+	}
+	@Override
+	public  void printStringClient(String string)
+	{
+		
+		ModLoader.getMinecraftInstance().ingameGUI.getChatGUI().printChatMessage(string);
+	}
+	
+}

StevenDimDoors/mod_pocketDimClient/ClientTickHandler.java

@@ -0,0 +1,64 @@
+package StevenDimDoors.mod_pocketDimClient;
+import java.util.EnumSet;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import cpw.mods.fml.common.ITickHandler;
+import cpw.mods.fml.common.TickType;
+
+public class ClientTickHandler implements ITickHandler
+{
+    @Override
+    public void tickStart(EnumSet<TickType> type, Object... tickData) {}
+
+    @Override
+    public void tickEnd(EnumSet<TickType> type, Object... tickData)
+    {
+        if (type.equals(EnumSet.of(TickType.RENDER)))
+        {
+            onRenderTick();
+        }
+        else if (type.equals(EnumSet.of(TickType.CLIENT)))
+        {
+            GuiScreen guiscreen = Minecraft.getMinecraft().currentScreen;
+            if (guiscreen != null)
+            {
+                onTickInGUI(guiscreen);
+            } else {
+                onTickInGame();
+            }
+        }
+    }
+
+    @Override
+    public EnumSet<TickType> ticks()
+    {
+        return EnumSet.of(TickType.RENDER, TickType.CLIENT);
+        // In my testing only RENDER, CLIENT, & PLAYER did anything on the client side.
+        // Read 'cpw.mods.fml.common.TickType.java' for a full list and description of available types
+    }
+
+    @Override
+    public String getLabel() { return null; }
+
+
+    public void onRenderTick()
+    {
+        //System.out.println("onRenderTick");
+        //TODO: Your Code Here
+    }
+
+    public void onTickInGUI(GuiScreen guiscreen)
+    {
+        //System.out.println("onTickInGUI");
+        //TODO: Your Code Here
+    }
+
+    public void onTickInGame()
+    {
+
+    	
+        //System.out.println("onTickInGame");
+        //TODO: Your Code Here
+    }
+}

StevenDimDoors/mod_pocketDimClient/ClosingRiftFX.java

@@ -0,0 +1,192 @@
+package StevenDimDoors.mod_pocketDimClient;
+
+import StevenDimDoors.mod_pocketDim.dimHelper;
+import net.minecraft.client.particle.EffectRenderer;
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class ClosingRiftFX extends EntityFX
+{
+    private int field_92049_a = 160;
+    private boolean field_92054_ax;
+    private boolean field_92048_ay;
+    private final EffectRenderer field_92047_az;
+    private float field_92050_aA;
+    private float field_92051_aB;
+    private float field_92052_aC;
+    private boolean field_92053_aD;
+
+    public ClosingRiftFX(World par1World, double par2, double par4, double par6, double par8, double par10, double par12, EffectRenderer par14EffectRenderer)
+    {
+    	
+        super(par1World, par2, par4, par6);
+        this.motionX = par8;
+        this.motionY = par10;
+        this.motionZ = par12;
+        this.field_92047_az = par14EffectRenderer;
+        this.particleScale *= .55F;
+        this.particleMaxAge = 30 + this.rand.nextInt(16);
+        this.noClip = false;
+    }
+
+    public void func_92045_e(boolean par1)
+    {
+        this.field_92054_ax = par1;
+    }
+
+    public void func_92043_f(boolean par1)
+    {
+        this.field_92048_ay = par1;
+    }
+
+    public void func_92044_a(int par1)
+    {
+        float var2 = (float)((par1 & 16711680) >> 16) / 255.0F;
+        float var3 = (float)((par1 & 65280) >> 8) / 255.0F;
+        float var4 = (float)((par1 & 255) >> 0) / 255.0F;
+        float var5 = 1.0F;
+        this.setRBGColorF(var2 * var5, var3 * var5, var4 * var5);
+    }
+
+    public void func_92046_g(int par1)
+    {
+        this.field_92050_aA = (float)((par1 & 16711680) >> 16) / 255.0F;
+        this.field_92051_aB = (float)((par1 & 65280) >> 8) / 255.0F;
+        this.field_92052_aC = (float)((par1 & 255) >> 0) / 255.0F;
+        this.field_92053_aD = true;
+    }
+
+    /**
+     * returns the bounding box for this entity
+     */
+    public AxisAlignedBB getBoundingBox()
+    {
+        return null;
+    }
+
+    /**
+     * Returns true if this entity should push and be pushed by other entities when colliding.
+     */
+    public boolean canBePushed()
+    {
+        return false;
+    }
+
+    public void renderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
+    {
+        if (!this.field_92048_ay || this.particleAge < this.particleMaxAge / 3 || (this.particleAge + this.particleMaxAge) / 3 % 2 == 0)
+        {
+            this.doRenderParticle(par1Tessellator, par2, par3, par4, par5, par6, par7);
+        }
+    }
+    
+    public void doRenderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
+    {
+        float var8 = (float)(super.getParticleTextureIndex() % 16) / 16.0F;
+        float var9 = var8 + 0.0624375F;
+        float var10 = (float)(this.getParticleTextureIndex() / 16) / 16.0F;
+        float var11 = var10 + 0.0624375F;
+        float var12 = 0.1F * this.particleScale;
+        float var13 = (float)(this.prevPosX + (this.posX - this.prevPosX) * (double)par2 - interpPosX);
+        float var14 = (float)(this.prevPosY + (this.posY - this.prevPosY) * (double)par2 - interpPosY);
+        float var15 = (float)(this.prevPosZ + (this.posZ - this.prevPosZ) * (double)par2 - interpPosZ);
+        float var16 = .8F;
+        try
+        {
+        	if(dimHelper.dimList.get(this.worldObj.provider.dimensionId).isPocket)
+        	{
+        		var16=.4F;
+        	}
+        	else
+        	{
+        	
+        	}
+        }
+        catch(Exception E)
+        {
+        	
+        }
+        par1Tessellator.setColorRGBA_F(this.particleRed * var16, this.particleGreen * var16, this.particleBlue * var16, (float) .7);
+
+        par1Tessellator.addVertexWithUV((double)(var13 - par3 * var12 - par6 * var12), (double)(var14 - par4 * var12), (double)(var15 - par5 * var12 - par7 * var12), (double)var9, (double)var11);
+        par1Tessellator.addVertexWithUV((double)(var13 - par3 * var12 + par6 * var12), (double)(var14 + par4 * var12), (double)(var15 - par5 * var12 + par7 * var12), (double)var9, (double)var10);
+        par1Tessellator.addVertexWithUV((double)(var13 + par3 * var12 + par6 * var12), (double)(var14 + par4 * var12), (double)(var15 + par5 * var12 + par7 * var12), (double)var8, (double)var10);
+        par1Tessellator.addVertexWithUV((double)(var13 + par3 * var12 - par6 * var12), (double)(var14 - par4 * var12), (double)(var15 + par5 * var12 - par7 * var12), (double)var8, (double)var11);
+    }
+
+    /**
+     * Called to update the entity's position/logic.
+     */
+    public void onUpdate()
+    {
+        this.prevPosX = this.posX;
+        this.prevPosY = this.posY;
+        this.prevPosZ = this.posZ;
+
+        if (this.particleAge++ >= this.particleMaxAge)
+        {
+            this.setDead();
+        }
+
+        if (this.particleAge > this.particleMaxAge / 2)
+        {
+            this.setAlphaF(1.0F - ((float)this.particleAge - (float)(this.particleMaxAge / 2)) / (float)this.particleMaxAge);
+
+            if (this.field_92053_aD)
+            {
+                this.particleRed += (this.field_92050_aA - this.particleRed) * 0.2F;
+                this.particleGreen += (this.field_92051_aB - this.particleGreen) * 0.2F;
+                this.particleBlue += (this.field_92052_aC - this.particleBlue) * 0.2F;
+            }
+        }
+
+        this.setParticleTextureIndex(this.field_92049_a + (7 - this.particleAge * 8 / this.particleMaxAge));
+       // this.motionY -= 0.004D;
+        this.moveEntity(this.motionX, this.motionY, this.motionZ);
+        this.motionX *= 0.9100000262260437D;
+        this.motionY *= 0.9100000262260437D;
+        this.motionZ *= 0.9100000262260437D;
+
+        if (this.onGround)
+        {
+            this.motionX *= 0.699999988079071D;
+            this.motionZ *= 0.699999988079071D;
+        }
+
+        if (this.field_92054_ax && this.particleAge < this.particleMaxAge / 2 && (this.particleAge + this.particleMaxAge) % 2 == 0)
+        {
+            ClosingRiftFX var1 = new ClosingRiftFX(this.worldObj, this.posX, this.posY, this.posZ, 0.0D, 0.0D, 0.0D, this.field_92047_az);
+            var1.setRBGColorF(this.particleRed, this.particleGreen, this.particleBlue);
+            var1.particleAge = var1.particleMaxAge / 2;
+
+            if (this.field_92053_aD)
+            {
+                var1.field_92053_aD = true;
+                var1.field_92050_aA = this.field_92050_aA;
+                var1.field_92051_aB = this.field_92051_aB;
+                var1.field_92052_aC = this.field_92052_aC;
+            }
+
+            var1.field_92048_ay = this.field_92048_ay;
+            this.field_92047_az.addEffect(var1);
+        }
+    }
+
+    public int getBrightnessForRender(float par1)
+    {
+        return 15728880;
+    }
+
+    /**
+     * Gets how bright this entity is.
+     */
+    public float getBrightness(float par1)
+    {
+        return 1.0F;
+    }
+}

StevenDimDoors/mod_pocketDimClient/GoggleRiftFX.java

@@ -0,0 +1,192 @@
+package StevenDimDoors.mod_pocketDimClient;
+
+import StevenDimDoors.mod_pocketDim.dimHelper;
+import net.minecraft.client.particle.EffectRenderer;
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class GoggleRiftFX extends EntityFX
+{
+    private int field_92049_a = 160;
+    private boolean field_92054_ax;
+    private boolean field_92048_ay;
+    private final EffectRenderer field_92047_az;
+    private float field_92050_aA;
+    private float field_92051_aB;
+    private float field_92052_aC;
+    private boolean field_92053_aD;
+
+    public GoggleRiftFX(World par1World, double par2, double par4, double par6, double par8, double par10, double par12, EffectRenderer par14EffectRenderer)
+    {
+    	
+        super(par1World, par2, par4, par6);
+        this.motionX = par8;
+        this.motionY = par10;
+        this.motionZ = par12;
+        this.field_92047_az = par14EffectRenderer;
+        this.particleScale *= .55F;
+        this.particleMaxAge = 30 + this.rand.nextInt(16);
+        this.noClip = false;
+    }
+
+    public void func_92045_e(boolean par1)
+    {
+        this.field_92054_ax = par1;
+    }
+
+    public void func_92043_f(boolean par1)
+    {
+        this.field_92048_ay = par1;
+    }
+
+    public void func_92044_a(int par1)
+    {
+        float var2 = (float)((par1 & 16711680) >> 16) / 255.0F;
+        float var3 = (float)((par1 & 65280) >> 8) / 255.0F;
+        float var4 = (float)((par1 & 255) >> 0) / 255.0F;
+        float var5 = 1.0F;
+        this.setRBGColorF(var2 * var5, var3 * var5, var4 * var5);
+    }
+
+    public void func_92046_g(int par1)
+    {
+        this.field_92050_aA = (float)((par1 & 16711680) >> 16) / 255.0F;
+        this.field_92051_aB = (float)((par1 & 65280) >> 8) / 255.0F;
+        this.field_92052_aC = (float)((par1 & 255) >> 0) / 255.0F;
+        this.field_92053_aD = true;
+    }
+
+    /**
+     * returns the bounding box for this entity
+     */
+    public AxisAlignedBB getBoundingBox()
+    {
+        return null;
+    }
+
+    /**
+     * Returns true if this entity should push and be pushed by other entities when colliding.
+     */
+    public boolean canBePushed()
+    {
+        return false;
+    }
+
+    public void renderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
+    {
+        if (!this.field_92048_ay || this.particleAge < this.particleMaxAge / 3 || (this.particleAge + this.particleMaxAge) / 3 % 2 == 0)
+        {
+            this.doRenderParticle(par1Tessellator, par2, par3, par4, par5, par6, par7);
+        }
+    }
+    
+    public void doRenderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
+    {
+        float var8 = (float)(super.getParticleTextureIndex() % 16) / 16.0F;
+        float var9 = var8 + 0.0624375F;
+        float var10 = (float)(this.getParticleTextureIndex() / 16) / 16.0F;
+        float var11 = var10 + 0.0624375F;
+        float var12 = 0.1F * this.particleScale;
+        float var13 = (float)(this.prevPosX + (this.posX - this.prevPosX) * (double)par2 - interpPosX);
+        float var14 = (float)(this.prevPosY + (this.posY - this.prevPosY) * (double)par2 - interpPosY);
+        float var15 = (float)(this.prevPosZ + (this.posZ - this.prevPosZ) * (double)par2 - interpPosZ);
+        float var16 = .0F;
+        try
+        {
+        	if(dimHelper.dimList.get(this.worldObj.provider.dimensionId).isPocket)
+        	{
+        		var16=.7F;
+        	}
+        	else
+        	{
+        	
+        	}
+        }
+        catch(Exception E)
+        {
+        	
+        }
+        par1Tessellator.setColorRGBA_F(this.particleRed * var16, this.particleGreen * var16, this.particleBlue * var16, (float) .7);
+
+        par1Tessellator.addVertexWithUV((double)(var13 - par3 * var12 - par6 * var12), (double)(var14 - par4 * var12), (double)(var15 - par5 * var12 - par7 * var12), (double)var9, (double)var11);
+        par1Tessellator.addVertexWithUV((double)(var13 - par3 * var12 + par6 * var12), (double)(var14 + par4 * var12), (double)(var15 - par5 * var12 + par7 * var12), (double)var9, (double)var10);
+        par1Tessellator.addVertexWithUV((double)(var13 + par3 * var12 + par6 * var12), (double)(var14 + par4 * var12), (double)(var15 + par5 * var12 + par7 * var12), (double)var8, (double)var10);
+        par1Tessellator.addVertexWithUV((double)(var13 + par3 * var12 - par6 * var12), (double)(var14 - par4 * var12), (double)(var15 + par5 * var12 - par7 * var12), (double)var8, (double)var11);
+    }
+
+    /**
+     * Called to update the entity's position/logic.
+     */
+    public void onUpdate()
+    {
+        this.prevPosX = this.posX;
+        this.prevPosY = this.posY;
+        this.prevPosZ = this.posZ;
+
+        if (this.particleAge++ >= this.particleMaxAge)
+        {
+            this.setDead();
+        }
+
+        if (this.particleAge > this.particleMaxAge / 2)
+        {
+            this.setAlphaF(1.0F - ((float)this.particleAge - (float)(this.particleMaxAge / 2)) / (float)this.particleMaxAge);
+
+            if (this.field_92053_aD)
+            {
+                this.particleRed += (this.field_92050_aA - this.particleRed) * 0.2F;
+                this.particleGreen += (this.field_92051_aB - this.particleGreen) * 0.2F;
+                this.particleBlue += (this.field_92052_aC - this.particleBlue) * 0.2F;
+            }
+        }
+
+        this.setParticleTextureIndex(this.field_92049_a + (7 - this.particleAge * 8 / this.particleMaxAge));
+       // this.motionY -= 0.004D;
+        this.moveEntity(this.motionX, this.motionY, this.motionZ);
+        this.motionX *= 0.9100000262260437D;
+        this.motionY *= 0.9100000262260437D;
+        this.motionZ *= 0.9100000262260437D;
+
+        if (this.onGround)
+        {
+            this.motionX *= 0.699999988079071D;
+            this.motionZ *= 0.699999988079071D;
+        }
+
+        if (this.field_92054_ax && this.particleAge < this.particleMaxAge / 2 && (this.particleAge + this.particleMaxAge) % 2 == 0)
+        {
+            GoggleRiftFX var1 = new GoggleRiftFX(this.worldObj, this.posX, this.posY, this.posZ, 0.0D, 0.0D, 0.0D, this.field_92047_az);
+            var1.setRBGColorF(this.particleRed, this.particleGreen, this.particleBlue);
+            var1.particleAge = var1.particleMaxAge / 2;
+
+            if (this.field_92053_aD)
+            {
+                var1.field_92053_aD = true;
+                var1.field_92050_aA = this.field_92050_aA;
+                var1.field_92051_aB = this.field_92051_aB;
+                var1.field_92052_aC = this.field_92052_aC;
+            }
+
+            var1.field_92048_ay = this.field_92048_ay;
+            this.field_92047_az.addEffect(var1);
+        }
+    }
+
+    public int getBrightnessForRender(float par1)
+    {
+        return 15728880;
+    }
+
+    /**
+     * Gets how bright this entity is.
+     */
+    public float getBrightness(float par1)
+    {
+        return 1.0F;
+    }
+}

StevenDimDoors/mod_pocketDimClient/RenderDimDoor.java

@@ -0,0 +1,274 @@
+package StevenDimDoors.mod_pocketDimClient;
+
+import java.nio.FloatBuffer;
+import java.util.Random;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ActiveRenderInfo;
+import net.minecraft.client.renderer.GLAllocation;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
+import net.minecraft.tileentity.TileEntity;
+
+import org.lwjgl.opengl.GL11;
+
+import StevenDimDoors.mod_pocketDim.TileEntityDimDoor;
+import StevenDimDoors.mod_pocketDim.dimDoor;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RenderDimDoor extends TileEntitySpecialRenderer
+{
+    FloatBuffer field_76908_a = GLAllocation.createDirectFloatBuffer(16);
+
+    /**
+     * Renders the dimdoor.
+     */
+    public void renderDimDoorTileEntity(TileEntityDimDoor tile, double x, double y, double z, float par8)
+    {
+    	try
+    {
+    	dimDoor.class.cast(Block.blocksList[mod_pocketDim.dimDoorID]).updateAttatchedTile(tile.worldObj, tile.xCoord, tile.yCoord, tile.zCoord).getFullMetadata(tile.worldObj, tile.xCoord, tile.yCoord, tile.zCoord);
+
+    }
+    catch(Exception e)
+    {
+    	e.printStackTrace();
+    }
+    	
+    	
+        float playerX = (float)this.tileEntityRenderer.playerX;
+        float playerY = (float)this.tileEntityRenderer.playerY;
+        float playerZ = (float)this.tileEntityRenderer.playerZ;
+        
+        float distance = (float) tile.getDistanceFrom(playerX, playerY, playerZ);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        Random rand = new Random(31100L);
+        float var13 = 0.75F;
+
+        for (int count = 0; count < 16; ++count)
+        {
+            GL11.glPushMatrix();
+            float var15 = (float)(16 - count);
+            float var16 = 0.2625F;
+            float var17 = 1.0F / (var15 + 1.0F);
+
+            if (count == 0)
+            {
+                this.bindTextureByName("/RIFT.png");
+                var17 = 0.1F;
+                var15 = 25.0F;
+                var16 = 0.125F;
+                GL11.glEnable(GL11.GL_BLEND);
+                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+            }
+
+            if (count == 1)
+            {
+                this.bindTextureByName("/WARP.png");
+                GL11.glEnable(GL11.GL_BLEND);
+                GL11.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE);
+                var16 = .5F;
+            }
+
+            float startY = (float)(+(y + (double)var13));
+            float ratioY = startY + ActiveRenderInfo.objectY;
+            float ratioY2 = startY + var15 + ActiveRenderInfo.objectY;
+            float yConverted = ratioY / ratioY2;
+           
+            float startZ = (float)(+(z + (double)var13));
+            float ratioZ = startZ + ActiveRenderInfo.objectZ;
+            float ratioZ2 = startZ + var15 + ActiveRenderInfo.objectZ;
+            float zConverted = ratioZ / ratioZ2;
+           
+            float startX = (float)(+(x + (double)var13));
+            float ratioX = startX + ActiveRenderInfo.objectX;
+            float ratioX2 = startX + var15 + ActiveRenderInfo.objectX;
+            float xConverted = ratioX / ratioX2;
+ 
+          
+
+            
+            yConverted += (float)(y + (double)var13);
+            xConverted += (float)(x + (double)var13);
+            zConverted += (float)(z + (double)var13);
+
+            GL11.glTranslatef( (float)(Minecraft.getSystemTime() % 200000L) / 200000.0F,0, 0.0F);
+            GL11.glTranslatef(0, (float)(Minecraft.getSystemTime() % 200000L) / 200000.0F, 0.0F);
+
+            GL11.glTranslatef(0,0, (float)(Minecraft.getSystemTime() % 200000L) / 200000.0F);
+
+            GL11.glTexGeni(GL11.GL_S, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
+            GL11.glTexGeni(GL11.GL_T, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
+            GL11.glTexGeni(GL11.GL_R, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
+            GL11.glTexGeni(GL11.GL_Q, GL11.GL_TEXTURE_GEN_MODE, GL11.GL_OBJECT_LINEAR);
+            switch ((tile.orientation%4)+4)
+            {
+            case 4:
+            	GL11.glTexGen(GL11.GL_S, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 1.0F, 0.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_T, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 1.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_R, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 0.0F, 1.0F));
+                GL11.glTexGen(GL11.GL_Q, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(1.0F, 0.0F, 0.0F, 0.0F));
+            	 
+            	break;
+            case 5:
+            	
+            	GL11.glTexGen(GL11.GL_S, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 1.0F, 0.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_T, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(1.0F, 0.0F, 0.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_R, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 0.0F, 1.0F));
+                GL11.glTexGen(GL11.GL_Q, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 1.0F, 0.0F));
+            	break;
+            case 6:
+            	GL11.glTexGen(GL11.GL_S, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 1.0F, 0.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_T, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 1.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_R, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 0.0F, 1.0F));
+                GL11.glTexGen(GL11.GL_Q, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(1.0F, 0.0F, 0.0F, 0.0F));
+           
+            	break;
+            case 7:
+            	GL11.glTexGen(GL11.GL_S, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 1.0F, 0.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_T, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(1.0F, 0.0F, 0.0F, 0.0F));
+                GL11.glTexGen(GL11.GL_R, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 0.0F, 1.0F));
+                GL11.glTexGen(GL11.GL_Q, GL11.GL_OBJECT_PLANE, this.getFloatBuffer(0.0F, 0.0F, 1.0F, 0.0F));
+            	break;
+            	
+            		
+            	
+            }
+           
+          
+            GL11.glEnable(GL11.GL_TEXTURE_GEN_S);
+            GL11.glEnable(GL11.GL_TEXTURE_GEN_T);
+            GL11.glEnable(GL11.GL_TEXTURE_GEN_R);
+            GL11.glEnable(GL11.GL_TEXTURE_GEN_Q);
+            GL11.glPopMatrix();
+            GL11.glMatrixMode(GL11.GL_TEXTURE);
+            GL11.glPushMatrix();
+            GL11.glLoadIdentity();
+            GL11.glTranslatef(0.0F, (float)(Minecraft.getSystemTime() % 200000L) / 200000.0F*var15, 0.0F);
+            GL11.glScalef(var16, var16, var16);
+            GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+            GL11.glRotatef((float)(count * count * 4321 + count * 9) * 2.0F, 0.0F, 0.0F, 1.0F);
+            GL11.glTranslatef(0.5F, 0.5F, 0.5F);
+        
+            Tessellator var24 = Tessellator.instance;
+            var24.startDrawingQuads();
+            
+            
+            
+            float var21 = rand.nextFloat() * 0.5F + 0.1F;
+            float var22 = rand.nextFloat() * 0.4F + 0.4F;
+            float var23 = rand.nextFloat() * 0.6F + 0.5F;
+
+            if (count == 0)
+            {
+                var23 = 1.0F;
+                var22 = 1.0F;
+                yConverted = 1.0F;
+            }
+            var24.setColorRGBA_F(var21 * var17, var22 * var17, var23 * var17, 1.0F);
+            if(tile.openOrClosed)
+            {
+
+            switch (tile.orientation)
+            {
+            case 0:
+            	
+            	var24.addVertex(x+.01F, y-1 , z);
+            	var24.addVertex(x+.01, y-1, z+1.0D);
+            	var24.addVertex(x+.01 , y+1 , z + 1.0D);
+            	var24.addVertex(x+.01 , y+1 , z);
+            	break;
+            case 1:
+            	var24.addVertex(x , y+1 , z+.01);
+            	var24.addVertex(x+1 , y+1 , z+.01);
+            	var24.addVertex(x+1, y-1,  z+.01);
+            	var24.addVertex(x, y-1, z+.01);
+
+
+
+            	break;
+            case 2:     //      
+                var24.addVertex(x+.99 , y+1 , z);
+                var24.addVertex(x+.99 , y+1 , z + 1.0D);
+                var24.addVertex(x+.99, y-1, z+1.0D);
+                var24.addVertex(x+.99, y-1, z);
+                break;
+            case 3:
+            	var24.addVertex(x, y-1, z+.99);
+            	var24.addVertex(x+1, y-1,  z+.99);
+            	var24.addVertex(x+1 , y+1 , z+.99);
+            	var24.addVertex(x , y+1 , z+.99);
+                break;
+            case 4://
+             //   GL11.glTranslatef();
+
+            	var24.addVertex(x+.15F, y-1 , z);
+            	var24.addVertex(x+.15, y-1, z+1.0D);
+            	var24.addVertex(x+.15 , y+1 , z + 1.0D);
+            	var24.addVertex(x+.15 , y+1 , z);
+            	break;
+            case 5:
+            	var24.addVertex(x , y+1 , z+.15);
+            	var24.addVertex(x+1 , y+1 , z+.15);
+            	var24.addVertex(x+1, y-1,  z+.15);
+            	var24.addVertex(x, y-1, z+.15);
+
+
+
+            	break;
+            case 6:     //      
+                var24.addVertex(x+.85 , y+1 , z);
+                var24.addVertex(x+.85 , y+1 , z + 1.0D);
+                var24.addVertex(x+.85, y-1, z+1.0D);
+                var24.addVertex(x+.85, y-1, z);
+                break;
+            case 7:
+            	var24.addVertex(x, y-1, z+.85);
+            	var24.addVertex(x+1, y-1,  z+.85);
+            	var24.addVertex(x+1 , y+1 , z+.85);
+            	var24.addVertex(x , y+1 , z+.85);
+                break;
+            default:
+            	break;
+            }
+            }
+            
+            
+            
+            
+          
+            
+            var24.draw();
+           
+            GL11.glPopMatrix();
+            GL11.glMatrixMode(GL11.GL_MODELVIEW);
+        }
+
+        GL11.glDisable(GL11.GL_BLEND);
+        GL11.glDisable(GL11.GL_TEXTURE_GEN_S);
+        GL11.glDisable(GL11.GL_TEXTURE_GEN_T);
+        GL11.glDisable(GL11.GL_TEXTURE_GEN_R);
+        GL11.glDisable(GL11.GL_TEXTURE_GEN_Q);
+        GL11.glEnable(GL11.GL_LIGHTING);
+    }
+
+    private FloatBuffer getFloatBuffer(float par1, float par2, float par3, float par4)
+    {
+        this.field_76908_a.clear();
+        this.field_76908_a.put(par1).put(par2).put(par3).put(par4);
+        this.field_76908_a.flip();
+        return this.field_76908_a;
+    }
+
+    public void renderTileEntityAt(TileEntity par1TileEntity, double par2, double par4, double par6, float par8)
+    {
+    	if(mod_pocketDim.enableDoorOpenGL)
+    	{
+    		this.renderDimDoorTileEntity((TileEntityDimDoor)par1TileEntity, par2, par4, par6, par8);
+    	}
+    }
+}

StevenDimDoors/mod_pocketDimClient/RiftFX.java

@@ -0,0 +1,192 @@
+package StevenDimDoors.mod_pocketDimClient;
+
+import StevenDimDoors.mod_pocketDim.dimHelper;
+import net.minecraft.client.particle.EffectRenderer;
+import net.minecraft.client.particle.EntityFX;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class RiftFX extends EntityFX
+{
+    private int field_92049_a = 160;
+    private boolean field_92054_ax;
+    private boolean field_92048_ay;
+    private final EffectRenderer field_92047_az;
+    private float field_92050_aA;
+    private float field_92051_aB;
+    private float field_92052_aC;
+    private boolean field_92053_aD;
+
+    public RiftFX(World par1World, double par2, double par4, double par6, double par8, double par10, double par12, EffectRenderer par14EffectRenderer)
+    {
+    	
+        super(par1World, par2, par4, par6);
+        this.motionX = par8;
+        this.motionY = par10;
+        this.motionZ = par12;
+        this.field_92047_az = par14EffectRenderer;
+        this.particleScale *= 0.75F;
+        this.particleMaxAge = 40 + this.rand.nextInt(26);
+        this.noClip = false;
+    }
+
+    public void func_92045_e(boolean par1)
+    {
+        this.field_92054_ax = par1;
+    }
+
+    public void func_92043_f(boolean par1)
+    {
+        this.field_92048_ay = par1;
+    }
+
+    public void func_92044_a(int par1)
+    {
+        float var2 = (float)((par1 & 16711680) >> 16) / 255.0F;
+        float var3 = (float)((par1 & 65280) >> 8) / 255.0F;
+        float var4 = (float)((par1 & 255) >> 0) / 255.0F;
+        float var5 = 1.0F;
+        this.setRBGColorF(var2 * var5, var3 * var5, var4 * var5);
+    }
+
+    public void func_92046_g(int par1)
+    {
+        this.field_92050_aA = (float)((par1 & 16711680) >> 16) / 255.0F;
+        this.field_92051_aB = (float)((par1 & 65280) >> 8) / 255.0F;
+        this.field_92052_aC = (float)((par1 & 255) >> 0) / 255.0F;
+        this.field_92053_aD = true;
+    }
+
+    /**
+     * returns the bounding box for this entity
+     */
+    public AxisAlignedBB getBoundingBox()
+    {
+        return null;
+    }
+
+    /**
+     * Returns true if this entity should push and be pushed by other entities when colliding.
+     */
+    public boolean canBePushed()
+    {
+        return false;
+    }
+
+    public void renderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
+    {
+        if (!this.field_92048_ay || this.particleAge < this.particleMaxAge / 3 || (this.particleAge + this.particleMaxAge) / 3 % 2 == 0)
+        {
+            this.doRenderParticle(par1Tessellator, par2, par3, par4, par5, par6, par7);
+        }
+    }
+    
+    public void doRenderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
+    {
+        float var8 = (float)(super.getParticleTextureIndex() % 16) / 16.0F;
+        float var9 = var8 + 0.0624375F;
+        float var10 = (float)(this.getParticleTextureIndex() / 16) / 16.0F;
+        float var11 = var10 + 0.0624375F;
+        float var12 = 0.1F * this.particleScale;
+        float var13 = (float)(this.prevPosX + (this.posX - this.prevPosX) * (double)par2 - interpPosX);
+        float var14 = (float)(this.prevPosY + (this.posY - this.prevPosY) * (double)par2 - interpPosY);
+        float var15 = (float)(this.prevPosZ + (this.posZ - this.prevPosZ) * (double)par2 - interpPosZ);
+        float var16 = .0F;
+        try
+        {
+        	if(dimHelper.dimList.get(this.worldObj.provider.dimensionId).isPocket)
+        	{
+        		var16=.7F;
+        	}
+        	else
+        	{
+        	
+        	}
+        }
+        catch(Exception E)
+        {
+        	
+        }
+        par1Tessellator.setColorRGBA_F(this.particleRed * var16, this.particleGreen * var16, this.particleBlue * var16, (float) .7);
+
+        par1Tessellator.addVertexWithUV((double)(var13 - par3 * var12 - par6 * var12), (double)(var14 - par4 * var12), (double)(var15 - par5 * var12 - par7 * var12), (double)var9, (double)var11);
+        par1Tessellator.addVertexWithUV((double)(var13 - par3 * var12 + par6 * var12), (double)(var14 + par4 * var12), (double)(var15 - par5 * var12 + par7 * var12), (double)var9, (double)var10);
+        par1Tessellator.addVertexWithUV((double)(var13 + par3 * var12 + par6 * var12), (double)(var14 + par4 * var12), (double)(var15 + par5 * var12 + par7 * var12), (double)var8, (double)var10);
+        par1Tessellator.addVertexWithUV((double)(var13 + par3 * var12 - par6 * var12), (double)(var14 - par4 * var12), (double)(var15 + par5 * var12 - par7 * var12), (double)var8, (double)var11);
+    }
+
+    /**
+     * Called to update the entity's position/logic.
+     */
+    public void onUpdate()
+    {
+        this.prevPosX = this.posX;
+        this.prevPosY = this.posY;
+        this.prevPosZ = this.posZ;
+
+        if (this.particleAge++ >= this.particleMaxAge)
+        {
+            this.setDead();
+        }
+
+        if (this.particleAge > this.particleMaxAge / 2)
+        {
+            this.setAlphaF(1.0F - ((float)this.particleAge - (float)(this.particleMaxAge / 2)) / (float)this.particleMaxAge);
+
+            if (this.field_92053_aD)
+            {
+                this.particleRed += (this.field_92050_aA - this.particleRed) * 0.2F;
+                this.particleGreen += (this.field_92051_aB - this.particleGreen) * 0.2F;
+                this.particleBlue += (this.field_92052_aC - this.particleBlue) * 0.2F;
+            }
+        }
+
+        this.setParticleTextureIndex(this.field_92049_a + (7 - this.particleAge * 8 / this.particleMaxAge));
+       // this.motionY -= 0.004D;
+        this.moveEntity(this.motionX, this.motionY, this.motionZ);
+        this.motionX *= 0.9100000262260437D;
+        this.motionY *= 0.9100000262260437D;
+        this.motionZ *= 0.9100000262260437D;
+
+        if (this.onGround)
+        {
+            this.motionX *= 0.699999988079071D;
+            this.motionZ *= 0.699999988079071D;
+        }
+
+        if (this.field_92054_ax && this.particleAge < this.particleMaxAge / 2 && (this.particleAge + this.particleMaxAge) % 2 == 0)
+        {
+            RiftFX var1 = new RiftFX(this.worldObj, this.posX, this.posY, this.posZ, 0.0D, 0.0D, 0.0D, this.field_92047_az);
+            var1.setRBGColorF(this.particleRed, this.particleGreen, this.particleBlue);
+            var1.particleAge = var1.particleMaxAge / 2;
+
+            if (this.field_92053_aD)
+            {
+                var1.field_92053_aD = true;
+                var1.field_92050_aA = this.field_92050_aA;
+                var1.field_92051_aB = this.field_92051_aB;
+                var1.field_92052_aC = this.field_92052_aC;
+            }
+
+            var1.field_92048_ay = this.field_92048_ay;
+            this.field_92047_az.addEffect(var1);
+        }
+    }
+
+    public int getBrightnessForRender(float par1)
+    {
+        return 15728880;
+    }
+
+    /**
+     * Gets how bright this entity is.
+     */
+    public float getBrightness(float par1)
+    {
+        return 1.0F;
+    }
+}

mcmod.info

@@ -0,0 +1,19 @@
+[
+{
+"modid": "DimensionalDoors",
+"name": "Dimensional Doors",
+"description": "Bend and twist reality itelf, creating pocket dimensions, rifts, and much more",
+"version": "1.2.0",
+"credits": "Created by StevenRS11, logo by Jaitsu",
+"logoFile": "/dimdoors_logo.png",
+"mcversion": "",
+"url": "http://www.minecraftforum.net/topic/1650007-147smpssplan-dimensional-doors-v110-physics-what-physics-updated-with-fancy-opengl/",
+"updateUrl": "",
+"authors": [ "StevenRS11" ],
+"parent":"",
+"screenshots": [],
+"dependencies": [
+"mod_MinecraftForge"
+]
+}
+]