Created build.gradle

Restructured folder structure for ForgeGradle

Signed-off-by: deathrat <deathrat43@gmail.com>

src/main/java/StevenDimDoors/mod_pocketDim/items/BaseItemDoor.java

@@ -0,0 +1,119 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemDoor;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDim.DDProperties;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import StevenDimDoors.mod_pocketDim.core.DimLink;
+import StevenDimDoors.mod_pocketDim.core.PocketManager;
+
+public abstract class BaseItemDoor extends ItemDoor
+{
+	private static DDProperties properties = null;
+
+	public BaseItemDoor(int itemID, Material material)
+	{
+		super(itemID, material);
+		this.setMaxStackSize(64);
+		this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+		if (properties == null)
+			properties = DDProperties.instance();
+	}
+
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName().replace("item.", ""));
+	}
+
+	@SuppressWarnings({ "rawtypes" })
+	@Override
+	public abstract void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4);
+
+	@Override
+	public abstract boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ);
+	
+	public static boolean tryItemUse(Block doorBlock, ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, boolean requireLink, boolean reduceStack)
+	{
+		// Only place doors on top of blocks - check if we're targeting the top side
+		if (side == 1 && !world.isRemote)
+		{
+			int blockID = world.getBlockId(x, y, z);
+			if (blockID != 0)
+			{
+				if (!Block.blocksList[blockID].isBlockReplaceable(world, x, y, z))
+				{
+					y++;
+				}
+			}
+
+			if (canPlace(world, x, y, z) && canPlace(world, x, y + 1, z) &&
+				player.canPlayerEdit(x, y, z, side, stack) && player.canPlayerEdit(x, y + 1, z, side, stack) &&
+				(!requireLink || PocketManager.getLink(x, y + 1, z, world) != null)&&stack.stackSize>0)
+			{
+				int orientation = MathHelper.floor_double((player.rotationYaw + 180.0F) * 4.0F / 360.0F - 0.5D) & 3;
+				placeDoorBlock(world, x, y, z, orientation, doorBlock);
+
+				if (!player.capabilities.isCreativeMode && reduceStack)
+				{
+					stack.stackSize--;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public abstract ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player);
+
+	public boolean tryPlacingDoor(Block doorBlock, World world, EntityPlayer player, ItemStack item)
+	{
+		if (world.isRemote)
+		{
+			return false;
+		}
+
+		MovingObjectPosition hit = this.getMovingObjectPositionFromPlayer(player.worldObj, player, true);
+		if (hit != null)
+		{
+			if (world.getBlockId(hit.blockX, hit.blockY, hit.blockZ) == properties.RiftBlockID)
+			{
+				DimLink link = PocketManager.getLink(hit.blockX, hit.blockY, hit.blockZ, world.provider.dimensionId);
+				if (link != null)
+				{
+					int x = hit.blockX;
+					int y = hit.blockY;
+					int z = hit.blockZ;
+
+					if (player.canPlayerEdit(x, y, z, hit.sideHit, item) && player.canPlayerEdit(x, y - 1, z, hit.sideHit, item))
+					{
+						if (canPlace(world, x, y, z) && canPlace(world, x, y - 1, z))
+						{
+							int orientation = MathHelper.floor_double(((player.rotationYaw + 180.0F) * 4.0F / 360.0F) - 0.5D) & 3;
+							placeDoorBlock(world, x, y - 1, z, orientation, doorBlock);
+							return true;
+						}
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	public static boolean canPlace(World world, int x, int y, int z)
+	{
+		int id = world.getBlockId(x, y, z);
+
+		return (id == properties.RiftBlockID || id == 0 || Block.blocksList[id].blockMaterial.isReplaceable());
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemBlockDimWall.java

@@ -0,0 +1,34 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemBlockDimWall extends ItemBlock
+{
+	private final static String[] subNames = {"Fabric of Reality", "Ancient Fabric"};
+	
+    public ItemBlockDimWall(int par1)
+    {
+    	  super(par1);
+          this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+          setHasSubtypes(true);
+    }
+    @Override
+	public void registerIcons(IconRegister par1IconRegister)
+    {
+        this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName().replace("tile.", ""));
+    }
+    
+    @Override
+	public int getMetadata (int damageValue) 
+    {
+		return damageValue;
+	}
+	
+    public String getUnlocalizedName(ItemStack par1ItemStack)
+    {
+        return subNames[this.getDamage(par1ItemStack)];
+    }  
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemDimensionalDoor.java

@@ -0,0 +1,48 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemDimensionalDoor extends BaseItemDoor
+{
+	public ItemDimensionalDoor(int itemID, Material material)
+	{
+		super(itemID, material);
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	@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 or place");
+		par3List.add("anywhere else to create a");
+		par3List.add("pocket dimension.");
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
+	{
+		if (!world.isRemote)
+		{
+			if (tryPlacingDoor(mod_pocketDim.dimensionalDoor, world, player, stack) &&
+				!player.capabilities.isCreativeMode)
+			{
+				stack.stackSize--;
+			}
+		}
+		return stack;
+	}
+	
+	@Override
+	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y,
+		int z, int par7, float par8, float par9, float par10)
+	{
+		return tryItemUse(mod_pocketDim.dimensionalDoor, stack, player, world, x, y, z, par7, false, true);
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemGoldDimDoor.java

@@ -0,0 +1,52 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemGoldDimDoor extends BaseItemDoor
+{
+
+	public ItemGoldDimDoor(int itemID, Material material) {
+		super(itemID, material);
+		// TODO Auto-generated constructor stub
+	}
+	
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	@Override
+	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+	{
+		par3List.add("Similar to a Iron Dim Door");
+		par3List.add("But if present in a pocket dim");
+		par3List.add("it will keep it loaded.");
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y,
+		int z, int par7, float par8, float par9, float par10)
+	{
+		return tryItemUse(mod_pocketDim.goldDimDoor, stack, player, world, x, y, z, par7, false, true);
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
+	{
+		if (!world.isRemote)
+		{
+			if (tryPlacingDoor(mod_pocketDim.goldDimDoor, world, player, stack) &&
+				!player.capabilities.isCreativeMode)
+			{
+				stack.stackSize--;
+			}
+		}
+		return stack;
+	}
+	
+	
+
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemGoldDoor.java

@@ -0,0 +1,58 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IconRegister;
+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 ItemGoldDoor extends ItemDoor
+{
+	public ItemGoldDoor(int par1, Material par2Material) 
+	{
+		super(par1, par2Material);
+	}
+
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName().replace("item.", ""));
+	}
+
+	@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 block = mod_pocketDim.goldDoor;
+
+			if (par2EntityPlayer.canPlayerEdit(par4, par5, par6, par7, par1ItemStack) && par2EntityPlayer.canPlayerEdit(par4, par5 + 1, par6, par7, par1ItemStack))
+			{
+				if (!block.canPlaceBlockAt(par3World, par4, par5, par6))
+				{
+					return false;
+				}
+				else
+				{
+					int i1 = MathHelper.floor_double((par2EntityPlayer.rotationYaw + 180.0F) * 4.0F / 360.0F - 0.5D) & 3;
+					placeDoorBlock(par3World, par4, par5, par6, i1, block);
+					--par1ItemStack.stackSize;
+					return true;
+				}
+			}
+			else
+			{
+				return false;
+			}
+		}
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemRiftBlade.java

@@ -0,0 +1,230 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.entity.ai.attributes.AttributeModifier;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.EnumToolMaterial;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemSword;
+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 StevenDimDoors.mod_pocketDim.DDProperties;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import StevenDimDoors.mod_pocketDim.core.PocketManager;
+import com.google.common.collect.Multimap;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemRiftBlade extends ItemSword
+{
+	private final DDProperties properties;
+
+	public ItemRiftBlade(int itemID, EnumToolMaterial material, DDProperties properties)
+	{
+		super(itemID, material);
+
+		this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+		this.setMaxStackSize(1);
+		this.setMaxDamage(500);
+		this.hasSubtypes = false;
+		this.properties = properties;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean isFull3D()
+	{
+		return true;
+	}
+
+	@Override
+	public float getStrVsBlock(ItemStack par1ItemStack, Block par2Block)
+	{
+		if (par2Block.blockID == Block.web.blockID)
+		{
+			return 15.0F;
+		}
+		else
+		{
+			Material material = par2Block.blockMaterial;
+			return material != Material.plants && material != Material.vine && material != Material.coral && material != Material.leaves && material != Material.pumpkin ? 1.0F : 1.5F;
+		}
+	}
+
+	@Override
+	public Multimap getItemAttributeModifiers()
+	{
+		Multimap multimap = super.getItemAttributeModifiers();
+		multimap.put(SharedMonsterAttributes.attackDamage.getAttributeUnlocalizedName(), new AttributeModifier(field_111210_e, "Weapon modifier", (double)7, 0));
+		return multimap;
+	}
+
+	@Override
+	@SideOnly(Side.CLIENT)
+	public boolean hasEffect(ItemStack par1ItemStack)
+	{
+		return true;
+	}
+
+	@Override
+	public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase par2EntityLiving, EntityLivingBase par3EntityLiving)
+	{
+		par1ItemStack.damageItem(1, par3EntityLiving);
+		return true;
+	}
+
+	@Override
+	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) * var4;
+		double var9 = par2EntityPlayer.prevPosY + (par2EntityPlayer.posY - par2EntityPlayer.prevPosY) * var4 + 1.62D - par2EntityPlayer.yOffset;
+		double var11 = par2EntityPlayer.prevPosZ + (par2EntityPlayer.posZ - par2EntityPlayer.prevPosZ) * 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(var18 * var21, var17 * var21, var20 * var21);
+		return par1World.rayTraceBlocks_do_do(var13, var23, true, false);
+	}
+
+	private boolean teleportToEntity(ItemStack item, Entity par1Entity, EntityPlayer holder)
+	{
+		Vec3 var2 = holder.worldObj.getWorldVec3Pool().getVecFromPool(holder.posX - par1Entity.posX, holder.boundingBox.minY + holder.height / 2.0F - par1Entity.posY + 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 = 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;
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
+	{
+		if (!world.isRemote)
+		{
+			@SuppressWarnings("unchecked")
+			List<EntityLiving> list =  world.getEntitiesWithinAABB(EntityLiving.class, AxisAlignedBB.getBoundingBox(player.posX-8,player.posY-8, player.posZ-8, player.posX+8,player.posY+8, player.posZ+8));
+			list.remove(player);
+
+			for (EntityLiving ent : list)
+			{
+				Vec3 var3 = player.getLook(1.0F).normalize();
+				Vec3 var4 =  player.worldObj.getWorldVec3Pool().getVecFromPool(ent.posX -  player.posX, ent.boundingBox.minY + (ent.height) / 2.0F - ( player.posY + player.getEyeHeight()), ent.posZ -  player.posZ);
+				double var5 = var4.lengthVector();
+				var4 = var4.normalize();
+				double var7 = var3.dotProduct(var4);
+				if( (var7+.1) > 1.0D - 0.025D / var5 ?  player.canEntityBeSeen(ent) : false)
+				{
+					teleportToEntity(stack, ent, player);
+					stack.damageItem(3, player);
+					return stack;
+				}
+			}
+
+			MovingObjectPosition hit = this.getMovingObjectPositionFromPlayer(world, player, false);
+			if (hit != null)
+			{
+				int x = hit.blockX;
+				int y = hit.blockY;
+				int z = hit.blockZ;
+				if (world.getBlockId(x, y, z) == properties.RiftBlockID)
+				{
+					if (PocketManager.getLink(x, y, z, world) != null)
+					{
+						if (player.canPlayerEdit(x, y, z, hit.sideHit, stack) &&
+							player.canPlayerEdit(x, y + 1, z, hit.sideHit, stack))
+						{
+							int orientation = MathHelper.floor_double((player.rotationYaw + 180.0F) * 4.0F / 360.0F - 0.5D) & 3;
+
+							if (BaseItemDoor.canPlace(world, x, y, z) &&
+								BaseItemDoor.canPlace(world, x, y - 1, z))
+							{
+								ItemDimensionalDoor.placeDoorBlock(world, x, y - 1, z, orientation, mod_pocketDim.transientDoor);
+								player.worldObj.playSoundAtEntity(player,mod_pocketDim.modid+":riftDoor", 0.6f, 1);
+								stack.damageItem(3, player);
+								return stack;
+							}
+						}
+					}
+				}
+			}
+			
+			player.setItemInUse(stack, this.getMaxItemUseDuration(stack));
+		}
+		return stack;
+	}
+
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName());
+	}
+
+	/**
+	 * Return whether this item is repairable in an anvil.
+	 */
+	@Override
+	public boolean getIsRepairable(ItemStack par1ItemStack, ItemStack par2ItemStack)
+	{
+		//Don't include a call to super.getIsRepairable()!
+    	//That would cause this sword to accept gold as a repair material (since we set material = Gold).
+		return mod_pocketDim.itemStableFabric.itemID == par2ItemStack.itemID ? true : false;
+	}
+
+	/**
+	 * allows items to add custom lines of information to the mouseover description
+	 */
+	@Override
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@SideOnly(Side.CLIENT)
+	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+	{
+		par3List.add("Creates temporary doors");
+		par3List.add("on rifts, rotates doors,");
+		par3List.add("and has a teleport attack.");
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemRiftGoggles.java

@@ -0,0 +1,18 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.item.EnumArmorMaterial;
+import net.minecraft.item.ItemArmor;
+
+public class ItemRiftGoggles extends ItemArmor
+{
+
+    public ItemRiftGoggles(int par1, int par2, int par3)
+    {
+    	  super(par1, EnumArmorMaterial.IRON, par1, par1);
+          this.setCreativeTab(CreativeTabs.tabRedstone);
+        //  this.setIconIndex(Item.doorWood.getIconFromDamage(0));
+    }
+    
+   
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemRiftSignature.java

@@ -0,0 +1,245 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import StevenDimDoors.mod_pocketDim.blocks.BaseDimDoor;
+import StevenDimDoors.mod_pocketDim.core.DimLink;
+import StevenDimDoors.mod_pocketDim.core.LinkTypes;
+import StevenDimDoors.mod_pocketDim.core.NewDimData;
+import StevenDimDoors.mod_pocketDim.core.PocketManager;
+import StevenDimDoors.mod_pocketDim.util.Point4D;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemRiftSignature extends Item
+{
+	public ItemRiftSignature(int itemID)
+	{
+		super(itemID);
+		this.setMaxStackSize(1);
+		this.setMaxDamage(0);
+		this.hasSubtypes = true;
+		this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+	}
+
+	@SideOnly(Side.CLIENT)
+	@Override
+	public boolean hasEffect(ItemStack stack)
+	{
+		//Make the item glow if it has one endpoint stored
+		return (stack.getItemDamage() != 0);
+	}
+
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName());
+	}
+
+	@Override
+	public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
+	{
+		//TODO- recognize doors and intelligently place rifts on them.
+		// We must use onItemUseFirst() instead of onItemUse() because Minecraft checks
+		// whether the user is in creative mode after calling onItemUse() and undoes any
+		// damage we might set to indicate the rift sig has been activated. Otherwise,
+		// we would need to rely on checking NBT tags for hasEffect() and that function
+		// gets called constantly. Avoiding NBT lookups reduces our performance impact.
+
+		// Return false on the client side to pass this request to the server
+		if (world.isRemote)
+		{
+			return false;
+		}
+		
+		y += 2; //Increase y by 2 to place the rift at head level
+		if (!player.canPlayerEdit(x, y, z, side, stack))
+		{
+			return true;
+		}
+		int adjustedY = adjustYForSpecialBlocks(world,x,y,z);
+		Point4DOrientation source = getSource(stack);
+		int orientation = MathHelper.floor_double((double) ((player.rotationYaw + 180.0F) * 4.0F / 360.0F) - 0.5D) & 3;
+		if (source != null)
+		{
+			//The link was used before and already has an endpoint stored. Create links connecting the two endpoints.
+			NewDimData sourceDimension = PocketManager.getDimensionData(source.getDimension());
+			NewDimData destinationDimension = PocketManager.getDimensionData(world);
+			DimLink link = sourceDimension.createLink(source.getX(), source.getY(), source.getZ(), LinkTypes.NORMAL,source.getOrientation());
+			DimLink reverse = destinationDimension.createLink(x, adjustedY, z, LinkTypes.NORMAL,orientation);
+			destinationDimension.setDestination(link, x, adjustedY, z);
+			sourceDimension.setDestination(reverse, source.getX(), source.getY(), source.getZ());
+
+			//Try placing a rift at the destination point
+			if (!mod_pocketDim.blockRift.isBlockImmune(world, x, adjustedY, z))
+			{
+				world.setBlock(x, adjustedY, z, mod_pocketDim.blockRift.blockID);
+			}
+
+			//Try placing a rift at the source point, but check if its world is loaded first
+			World sourceWorld = DimensionManager.getWorld(sourceDimension.id());
+			if (sourceWorld != null &&
+				!mod_pocketDim.blockRift.isBlockImmune(sourceWorld, source.getX(), source.getY(), source.getZ()))
+			{
+				sourceWorld.setBlock(source.getX(), source.getY(), source.getZ(), mod_pocketDim.blockRift.blockID);
+			}
+
+			if (!player.capabilities.isCreativeMode)
+			{
+				stack.stackSize--;
+			}
+			clearSource(stack);
+			mod_pocketDim.sendChat(player,("Rift Created"));
+			world.playSoundAtEntity(player,mod_pocketDim.modid+":riftEnd", 0.6f, 1);
+		}
+		else
+		{
+			//The link signature has not been used. Store its current target as the first location. 
+			setSource(stack, x, adjustedY, z,orientation, PocketManager.getDimensionData(world));
+			mod_pocketDim.sendChat(player,("Location Stored in Rift Signature"));
+			world.playSoundAtEntity(player,mod_pocketDim.modid+":riftStart", 0.6f, 1);
+		}
+		return true;
+	}
+
+	/**
+	 * allows items to add custom lines of information to the mouseover description
+	 */
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@SideOnly(Side.CLIENT)
+	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+	{
+		Point4DOrientation source = getSource(par1ItemStack);
+		if (source != null)
+		{
+			par3List.add("Leads to (" + source.getX() + ", " + source.getY() + ", " + source.getZ() + ") at dimension #" + source.getDimension());
+		}
+		else
+		{
+			par3List.add("First click stores a location;");
+			par3List.add("second click creates a pair of");
+			par3List.add("rifts linking the two locations.");
+		}
+	}
+
+	/**
+	 * Makes the rift placement account for replaceable blocks and doors.
+	 * @param world
+	 * @param x
+	 * @param y
+	 * @param z
+	 * @return the adjusted y coord
+	 */
+	public static int adjustYForSpecialBlocks(World world, int x, int y, int z)
+	{
+		y=y-2;//get the block the player actually clicked on
+		Block block = Block.blocksList[world.getBlockId(x, y, z)];
+		if(block.isBlockReplaceable(world, x, y, z))
+		{
+			return y+1;//move block placement down (-2+1) one so its directly over things like snow
+		}
+		if(block instanceof BaseDimDoor)
+		{
+			if(world.getBlockId(x, y-1, z)==block.blockID&&world.getBlockMetadata(x, y, z)==8)
+			{
+				return y;//move rift placement down two so its in the right place on the door. 
+			}
+			return y+1;
+		}
+		return y+2;
+	}
+	public static void setSource(ItemStack itemStack, int x, int y, int z, int orientation, NewDimData dimension)
+	{
+		NBTTagCompound tag = new NBTTagCompound();
+
+		tag.setInteger("linkX", x);
+		tag.setInteger("linkY", y);
+		tag.setInteger("linkZ", z);
+		tag.setInteger("orientation", orientation);
+		tag.setInteger("linkDimID", dimension.id());
+
+		itemStack.setTagCompound(tag);
+		itemStack.setItemDamage(1);
+	}
+
+	public static void clearSource(ItemStack itemStack)
+	{
+		//Don't just set the tag to null since there may be other data there (e.g. for renamed items)
+		NBTTagCompound tag = itemStack.getTagCompound();
+		tag.removeTag("linkX");
+		tag.removeTag("linkY");
+		tag.removeTag("linkZ");
+		tag.removeTag("orientation");
+		tag.removeTag("linkDimID");
+		itemStack.setItemDamage(0);
+	}
+
+	public static Point4DOrientation getSource(ItemStack itemStack)
+	{
+		if (itemStack.getItemDamage() != 0)
+		{
+			if (itemStack.hasTagCompound())
+			{
+				NBTTagCompound tag = itemStack.getTagCompound();
+
+				Integer x = tag.getInteger("linkX");
+				Integer y = tag.getInteger("linkY");
+				Integer z = tag.getInteger("linkZ");
+				Integer orientation = tag.getInteger("orientation");
+				Integer dimID = tag.getInteger("linkDimID");
+
+				if (x != null && y != null && z != null && dimID != null)
+				{
+					return new Point4DOrientation(x, y, z,orientation, dimID);
+				}
+			}
+			itemStack.setItemDamage(0);
+		}
+		return null;
+	}
+	
+	static class Point4DOrientation
+	{
+		private Point4D point;
+		private int orientation;
+		Point4DOrientation(int x, int y, int z, int orientation, int dimID)
+		{
+			this.point= new Point4D(x,y,z,dimID);
+			this.orientation=orientation;
+		}
+		
+		int getX()
+		{
+			return point.getX();
+		}
+		
+		int getY()
+		{
+			return point.getY();
+		}
+		
+		int getZ()
+		{
+			return point.getZ();
+		}
+		
+		int getDimension()
+		{
+			return point.getDimension();
+		}
+		int getOrientation()
+		{
+			return orientation;
+		}
+	}
+}
+

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemStabilizedRiftSignature.java

@@ -0,0 +1,126 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.MathHelper;
+import net.minecraft.world.World;
+import net.minecraftforge.common.DimensionManager;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import StevenDimDoors.mod_pocketDim.core.DimLink;
+import StevenDimDoors.mod_pocketDim.core.LinkTypes;
+import StevenDimDoors.mod_pocketDim.core.NewDimData;
+import StevenDimDoors.mod_pocketDim.core.PocketManager;
+import StevenDimDoors.mod_pocketDim.util.Point4D;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class ItemStabilizedRiftSignature extends ItemRiftSignature
+{
+	public ItemStabilizedRiftSignature(int itemID)
+	{
+		super(itemID);
+	}
+
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName().replace("item.", ""));
+	}
+
+	@Override
+	public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
+	{
+		// Return false on the client side to pass this request to the server
+		if (world.isRemote)
+		{
+			return false;
+		}
+
+		// We don't check for replaceable blocks. The user can deal with that. <_<
+		y += 2; //Increase y by 2 to place the rift at head level
+		if (!player.canPlayerEdit(x, y, z, side, stack))
+		{
+			return true;
+		}
+		Point4DOrientation source = getSource(stack);
+		int adjustedY = adjustYForSpecialBlocks(world,x,y,z);
+		
+		// Check if the Stabilized Rift Signature has been initialized
+		int orientation = MathHelper.floor_double((player.rotationYaw + 180.0F) * 4.0F / 360.0F - 0.5D) & 3;
+		if (source != null)
+		{
+			// Yes, it's initialized. Check if the player is in creative
+			// or if the player can pay an Ender Pearl to create a rift.
+			if (!player.capabilities.isCreativeMode && !player.inventory.hasItem(Item.enderPearl.itemID))
+			{
+				mod_pocketDim.sendChat(player,"You don't have any Ender Pearls!");
+				// I won't do this, but this is the chance to localize chat 
+				// messages sent to the player; look at ChatMessageComponent 
+				// and how MFR does it with items like the safari net launcher
+				return true;
+			}
+
+			//The link was used before and already has an endpoint stored. Create links connecting the two endpoints.
+			NewDimData sourceDimension = PocketManager.getDimensionData(source.getDimension());
+			NewDimData destinationDimension = PocketManager.getDimensionData(world);
+			DimLink link = sourceDimension.createLink(source.getX(), source.getY(), source.getZ(), LinkTypes.NORMAL,source.getOrientation());
+			DimLink reverse = destinationDimension.createLink(x, adjustedY, z, LinkTypes.NORMAL,orientation);
+			destinationDimension.setDestination(link, x, adjustedY, z);
+			sourceDimension.setDestination(reverse, source.getX(), source.getY(), source.getZ());
+
+			//Try placing a rift at the destination point
+			if (!mod_pocketDim.blockRift.isBlockImmune(world, x, adjustedY, z))
+			{
+				world.setBlock(x, adjustedY, z, mod_pocketDim.blockRift.blockID);
+			}
+
+			//Try placing a rift at the source point, but check if its world is loaded first
+			World sourceWorld = DimensionManager.getWorld(sourceDimension.id());
+			if (sourceWorld != null &&
+				!mod_pocketDim.blockRift.isBlockImmune(sourceWorld, source.getX(), source.getY(), source.getZ()))
+			{
+				sourceWorld.setBlock(source.getX(), source.getY(), source.getZ(), mod_pocketDim.blockRift.blockID);
+			}
+
+			if (!player.capabilities.isCreativeMode)
+			{
+				player.inventory.consumeInventoryItem(Item.enderPearl.itemID);
+			}
+			mod_pocketDim.sendChat(player,"Rift Created");
+			world.playSoundAtEntity(player,"mods.DimDoors.sfx.riftEnd", 0.6f, 1);
+		}
+		else
+		{
+			//The link signature has not been used. Store its current target as the first location. 
+			setSource(stack, x, adjustedY, z, orientation, PocketManager.getDimensionData(world));
+			mod_pocketDim.sendChat(player,"Location Stored in Rift Signature");
+			world.playSoundAtEntity(player,"mods.DimDoors.sfx.riftStart", 0.6f, 1);
+		}
+		return true;
+	}
+
+	/**
+	 * allows items to add custom lines of information to the mouseover description
+	 */
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	@SideOnly(Side.CLIENT)
+	@Override
+	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+	{
+		Point4DOrientation source = getSource(par1ItemStack);
+		if (source != null)
+		{
+			par3List.add("Leads to (" + source.getX() + ", " + source.getY() + ", " + source.getZ() + ") at dimension #" + source.getDimension());
+		}
+		else
+		{
+			par3List.add("First click stores a location,");
+			par3List.add("second click creates two rifts");
+			par3List.add("that link the locations together.");
+		}
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemStableFabric.java

@@ -0,0 +1,20 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.item.Item;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemStableFabric extends Item
+{
+	public ItemStableFabric(int itemID, int par2)
+	{
+		super(itemID);
+        this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+	}
+	
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName().replace("item.", ""));
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemUnstableDoor.java

@@ -0,0 +1,45 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemUnstableDoor extends BaseItemDoor
+{
+    public ItemUnstableDoor(int itemID, Material material)
+    {
+    	  super(itemID, material);
+    }
+    
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+    public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+    {
+    	par3List.add("Caution: Leads to random destination");
+    }
+    
+    @Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
+	{
+		if (!world.isRemote)
+		{
+			if (tryPlacingDoor(mod_pocketDim.unstableDoor, world, player, stack) &&
+				!player.capabilities.isCreativeMode)
+			{
+				stack.stackSize--;
+			}
+		}
+		return stack;
+	}
+    
+	@Override
+	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y,
+		int z, int par7, float par8, float par9, float par10)
+	{
+		return tryItemUse(mod_pocketDim.unstableDoor, stack, player, world, x, y, z, par7, false, true);
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemWarpDoor.java

@@ -0,0 +1,48 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemWarpDoor extends BaseItemDoor
+{
+	public ItemWarpDoor(int itemID, Material material)
+	{
+		super(itemID, material);
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+	public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
+	{
+		par3List.add("Place on the block under");
+		par3List.add("a rift to create a portal,");
+		par3List.add("or place anywhere in a");
+		par3List.add("pocket dimension to exit.");
+	}
+    
+	@Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
+	{
+		if (!world.isRemote)
+		{
+			if (tryPlacingDoor(mod_pocketDim.warpDoor, world, player, stack) &&
+				!player.capabilities.isCreativeMode)
+			{
+				stack.stackSize--;
+			}
+		}
+		return stack;
+	}
+
+	@Override
+	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y,
+		int z, int par7, float par8, float par9, float par10)
+	{
+		return tryItemUse(mod_pocketDim.warpDoor, stack, player, world, x, y, z, par7, false, true);
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/ItemWorldThread.java

@@ -0,0 +1,20 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.item.Item;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+
+public class ItemWorldThread extends Item
+{
+	public ItemWorldThread(int itemID)
+	{
+		super(itemID);
+        this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+	}
+	
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName().replace("item.", ""));
+	}
+}

src/main/java/StevenDimDoors/mod_pocketDim/items/itemRiftRemover.java

@@ -0,0 +1,137 @@
+package StevenDimDoors.mod_pocketDim.items;
+
+import java.util.List;
+
+import net.minecraft.block.material.Material;
+import net.minecraft.client.renderer.texture.IconRegister;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.World;
+import StevenDimDoors.mod_pocketDim.mod_pocketDim;
+import StevenDimDoors.mod_pocketDim.core.DimLink;
+import StevenDimDoors.mod_pocketDim.core.NewDimData;
+import StevenDimDoors.mod_pocketDim.core.PocketManager;
+import StevenDimDoors.mod_pocketDim.tileentities.TileEntityRift;
+import cpw.mods.fml.client.FMLClientHandler;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+
+public class itemRiftRemover extends Item
+{
+	public itemRiftRemover(int itemID, Material par2Material)
+	{
+		super(itemID);
+		this.setMaxStackSize(1);
+		this.setCreativeTab(mod_pocketDim.dimDoorsCreativeTab);
+		this.setMaxDamage(4);
+	}
+
+	@Override
+	public void registerIcons(IconRegister par1IconRegister)
+	{
+		this.itemIcon = par1IconRegister.registerIcon(mod_pocketDim.modid + ":" + this.getUnlocalizedName());
+	}
+
+	@Override
+	public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
+	{
+		// We invoke PlayerControllerMP.onPlayerRightClick() from here so that Minecraft
+		// will invoke onItemUseFirst() on the client side. We'll tell it to pass the
+		// request to the server, which will make sure that rift-related changes are
+		// reflected on the server.
+
+		if (!world.isRemote)
+		{
+			return stack;
+		}
+
+		MovingObjectPosition hit = this.getMovingObjectPositionFromPlayer(world, player, true);
+		if (hit != null)
+		{
+			int hx = hit.blockX;
+			int hy = hit.blockY;
+			int hz = hit.blockZ;
+			NewDimData dimension = PocketManager.getDimensionData(world);
+			DimLink link = dimension.getLink(hx, hy, hz);
+			if (world.getBlockId(hx, hy, hz) == mod_pocketDim.blockRift.blockID && link != null &&
+				player.canPlayerEdit(hx, hy, hz, hit.sideHit, stack))
+			{
+				// Invoke onPlayerRightClick()
+				FMLClientHandler.instance().getClient().playerController.onPlayerRightClick(
+					player, world, stack, hx, hy, hz, hit.sideHit, hit.hitVec);
+			}
+		}
+		return stack;
+	}
+
+	@Override
+	public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
+	{
+
+		// We want to use onItemUseFirst() here so that this code will run on the server side,
+		// so we don't need the client to send link-related updates to the server. Still,
+		// check whether we have a rift in sight before passing the request over.
+
+		// On integrated servers, the link won't be removed immediately because of the rift
+		// removal animation. That means we'll have a chance to check for the link before
+		// it's deleted. Otherwise the Rift Remover's durability wouldn't drop.
+		MovingObjectPosition hit = this.getMovingObjectPositionFromPlayer(world, player, true);
+		if (hit != null)
+		{
+			 x = hit.blockX;
+			 y = hit.blockY;
+			 z = hit.blockZ;
+			 
+			 NewDimData dimension = PocketManager.getDimensionData(world);
+			 DimLink link = dimension.getLink(x, y, z);
+			 if (world.getBlockId(x, y, z) == mod_pocketDim.blockRift.blockID && link != null &&
+				player.canPlayerEdit(x, y, z, side, stack))
+			 {
+				// Tell the rift's tile entity to do its removal animation
+				 TileEntity tileEntity = world.getBlockTileEntity(x, y, z);
+				 if (tileEntity != null && tileEntity instanceof TileEntityRift)
+				 {
+					 ((TileEntityRift) tileEntity).shouldClose = true;
+					 tileEntity.onInventoryChanged();
+				 }
+				 else if (!world.isRemote)
+				 {
+					 // Only set the block to air on the server side so that we don't
+					 // tell the server to remove the rift block before it can use the
+					 // Rift Remover. Otherwise, it won't know to reduce durability.
+					 world.setBlockToAir(x, y, z);
+				 }
+				 if (world.isRemote)
+				 {
+					 // Tell the server about this
+					 return false;
+				 }
+				 else
+				 {
+					 if (!player.capabilities.isCreativeMode)
+					 {
+						 stack.damageItem(1, player);
+					 }
+				player.worldObj.playSoundAtEntity(player, mod_pocketDim.modid+":riftClose", 0.8f, 1);
+				}
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * allows items to add custom lines of information to the mouseover description
+	 */
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	@SideOnly(Side.CLIENT)
+	@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.");
+	}
+}