commit 7084d88aa0178e46e101e5b64284f992ff7b092a Author: StevenRS11 Date: Sun Feb 17 21:46:16 2013 -0500 Signed-off-by: StevenRS11 diff --git a/PocketBlockTextures.png b/PocketBlockTextures.png new file mode 100644 index 00000000..059dad52 Binary files /dev/null and b/PocketBlockTextures.png differ diff --git a/RIFT.png b/RIFT.png new file mode 100644 index 00000000..ae24e834 Binary files /dev/null and b/RIFT.png differ diff --git a/Steven/Common/mod_pocketDim/DimData.java b/Steven/Common/mod_pocketDim/DimData.java new file mode 100644 index 00000000..6089c057 --- /dev/null +++ b/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 getAllLinkData() + { + Iterator itr = this.linksInThisDim.keySet().iterator(); + Collection linksInDim = (Collection) new HashSet(); + + 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; + } + +} \ No newline at end of file diff --git a/Steven/Common/mod_pocketDim/LinkData.java b/Steven/Common/mod_pocketDim/LinkData.java new file mode 100644 index 00000000..9264a8ff --- /dev/null +++ b/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 "); + } +} \ No newline at end of file diff --git a/Steven/Common/mod_pocketDim/mod_pocketDim.java b/Steven/Common/mod_pocketDim/mod_pocketDim.java new file mode 100644 index 00000000..7c0d6325 --- /dev/null +++ b/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 +{ + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/BlockDimWall.java b/StevenDimDoors/mod_pocketDim/BlockDimWall.java new file mode 100644 index 00000000..962961f5 --- /dev/null +++ b/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; + + } + + +} diff --git a/StevenDimDoors/mod_pocketDim/BlockDimWallPerm.java b/StevenDimDoors/mod_pocketDim/BlockDimWallPerm.java new file mode 100644 index 00000000..2a1c015f --- /dev/null +++ b/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); + + } + } + } +} diff --git a/StevenDimDoors/mod_pocketDim/BlockLimbo.java b/StevenDimDoors/mod_pocketDim/BlockLimbo.java new file mode 100644 index 00000000..8421546b --- /dev/null +++ b/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!! +} diff --git a/StevenDimDoors/mod_pocketDim/BlockRift.java b/StevenDimDoors/mod_pocketDim/BlockRift.java new file mode 100644 index 00000000..2c985a5a --- /dev/null +++ b/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 (i0) + { + 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(); + } + + + +} diff --git a/StevenDimDoors/mod_pocketDim/ChaosDoor.java b/StevenDimDoors/mod_pocketDim/ChaosDoor.java new file mode 100644 index 00000000..4faf698c --- /dev/null +++ b/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); + } + } + } + } + } + } + } + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/CloudRenderBlank.java b/StevenDimDoors/mod_pocketDim/CloudRenderBlank.java new file mode 100644 index 00000000..74f8f2d7 --- /dev/null +++ b/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) + { + + } +} diff --git a/StevenDimDoors/mod_pocketDim/CommonProxy.java b/StevenDimDoors/mod_pocketDim/CommonProxy.java new file mode 100644 index 00000000..eee4b831 --- /dev/null +++ b/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 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) + { + + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/CommonTickHandler.java b/StevenDimDoors/mod_pocketDim/CommonTickHandler.java new file mode 100644 index 00000000..bbf8e347 --- /dev/null +++ b/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 type, Object... tickData) {} + + @Override + public void tickEnd(EnumSet 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++; + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/ConnectionHandler.java b/StevenDimDoors/mod_pocketDim/ConnectionHandler.java new file mode 100644 index 00000000..30a41b68 --- /dev/null +++ b/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) + { + + + + + + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/CustomCaveGen.java b/StevenDimDoors/mod_pocketDim/CustomCaveGen.java new file mode 100644 index 00000000..0b8a4501 --- /dev/null +++ b/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); + } + } + } +} diff --git a/StevenDimDoors/mod_pocketDim/DimData.java b/StevenDimDoors/mod_pocketDim/DimData.java new file mode 100644 index 00000000..42873cbb --- /dev/null +++ b/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>> linksInThisDim=new HashMap(); + HashMap dimX; + HashMap> 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(); + } + } + else + { + this.dimX=new HashMap(); + this.dimY=new HashMap>(); + } + + 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(); + } + } + else + { + this.dimX=new HashMap(); + this.dimY=new HashMap>(); + } + + + 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(); + + + + } + } + } + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/DimUpdatePacket.java b/StevenDimDoors/mod_pocketDim/DimUpdatePacket.java new file mode 100644 index 00000000..daed1ea0 --- /dev/null +++ b/StevenDimDoors/mod_pocketDim/DimUpdatePacket.java @@ -0,0 +1,17 @@ +package StevenDimDoors.mod_pocketDim; + + +public class DimUpdatePacket +{ + + public DimUpdatePacket(int dim) + { + + } + + + + + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/DungeonGenerator.java b/StevenDimDoors/mod_pocketDim/DungeonGenerator.java new file mode 100644 index 00000000..0feda309 --- /dev/null +++ b/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 sideRifts = new ArrayList(); + public LinkData exitLink; + public static Random rand = new Random(); + + + + public DungeonGenerator(int weight, String schematicPath, ArrayList 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)+510&&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); + + + + + + + + + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/EventHookContainer.java b/StevenDimDoors/mod_pocketDim/EventHookContainer.java new file mode 100644 index 00000000..90e106ec --- /dev/null +++ b/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 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(); + } + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/ExitDoor.java b/StevenDimDoors/mod_pocketDim/ExitDoor.java new file mode 100644 index 00000000..e70c9d67 --- /dev/null +++ b/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); + } + + + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/ItemChaosDoor.java b/StevenDimDoors/mod_pocketDim/ItemChaosDoor.java new file mode 100644 index 00000000..83eb2527 --- /dev/null +++ b/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"); + + + + + + + + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/ItemRiftBlade.java b/StevenDimDoors/mod_pocketDim/ItemRiftBlade.java new file mode 100644 index 00000000..e1f41701 --- /dev/null +++ b/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 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); + **/ + } + } +} diff --git a/StevenDimDoors/mod_pocketDim/ItemRiftGoggles.java b/StevenDimDoors/mod_pocketDim/ItemRiftGoggles.java new file mode 100644 index 00000000..2ae9a067 --- /dev/null +++ b/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"; + } +} diff --git a/StevenDimDoors/mod_pocketDim/ItemStableFabric.java b/StevenDimDoors/mod_pocketDim/ItemStableFabric.java new file mode 100644 index 00000000..5f2a5750 --- /dev/null +++ b/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"); + + + + + } +} diff --git a/StevenDimDoors/mod_pocketDim/LimboGenerator.java b/StevenDimDoors/mod_pocketDim/LimboGenerator.java new file mode 100644 index 00000000..2d4c1388 --- /dev/null +++ b/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 + + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/LimboProvider.java b/StevenDimDoors/mod_pocketDim/LimboProvider.java new file mode 100644 index 00000000..f2c8ead9 --- /dev/null +++ b/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; + + + } + + + + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/LimboWorld.java b/StevenDimDoors/mod_pocketDim/LimboWorld.java new file mode 100644 index 00000000..e69de29b diff --git a/StevenDimDoors/mod_pocketDim/LinkData.java b/StevenDimDoors/mod_pocketDim/LinkData.java new file mode 100644 index 00000000..495a11eb --- /dev/null +++ b/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 "); + + + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/ObjectSaveInputStream.java b/StevenDimDoors/mod_pocketDim/ObjectSaveInputStream.java new file mode 100644 index 00000000..a70dfa83 --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/OldSaveHandler.java b/StevenDimDoors/mod_pocketDim/OldSaveHandler.java new file mode 100644 index 00000000..db9f3be7 --- /dev/null +++ b/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 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(); + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/PacketHandler.java b/StevenDimDoors/mod_pocketDim/PacketHandler.java new file mode 100644 index 00000000..24135291 --- /dev/null +++ b/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 dimList) + { + + Collection dimIDs= dimList.keySet(); + Collection dimDataSet= dimList.values(); + Collection packetsToSend = new HashSet(); + + + + for(DimData data : dimDataSet) + { + + manager.addToSendQueue(PacketHandler.onDimCreatedPacket(data)); + + Collection >> linkList = data.linksInThisDim.values(); + + for(HashMap map : linkList ) + { + + Collection > linkList2 = map.values(); + + for(HashMap map2 : linkList2) + { + Collection 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(); + } + } + + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/PlayerRespawnTracker.java b/StevenDimDoors/mod_pocketDim/PlayerRespawnTracker.java new file mode 100644 index 00000000..a860befa --- /dev/null +++ b/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()); + + + } + + + + + } + + } + + + + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/Point3D.java b/StevenDimDoors/mod_pocketDim/Point3D.java new file mode 100644 index 00000000..6c4d6084 --- /dev/null +++ b/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; +} + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/RiftGenerator.java b/StevenDimDoors/mod_pocketDim/RiftGenerator.java new file mode 100644 index 00000000..e144e490 --- /dev/null +++ b/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) sideLinks = new ArrayList(); + public ArrayList exitLinks = new ArrayList(); + 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(); + } + + } + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/ServerPacketHandler.java b/StevenDimDoors/mod_pocketDim/ServerPacketHandler.java new file mode 100644 index 00000000..4c003b1a --- /dev/null +++ b/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) + { + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/TileEntityDimDoor.java b/StevenDimDoors/mod_pocketDim/TileEntityDimDoor.java new file mode 100644 index 00000000..b96aad64 --- /dev/null +++ b/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); + + + } +} diff --git a/StevenDimDoors/mod_pocketDim/TileEntityRift.java b/StevenDimDoors/mod_pocketDim/TileEntityRift.java new file mode 100644 index 00000000..30891e59 --- /dev/null +++ b/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); + + } +} diff --git a/StevenDimDoors/mod_pocketDim/TransientDoor.java b/StevenDimDoors/mod_pocketDim/TransientDoor.java new file mode 100644 index 00000000..85773460 --- /dev/null +++ b/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; + } + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/dimDoor.java b/StevenDimDoors/mod_pocketDim/dimDoor.java new file mode 100644 index 00000000..786fa94a --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/dimHatch.java b/StevenDimDoors/mod_pocketDim/dimHatch.java new file mode 100644 index 00000000..e379a68d --- /dev/null +++ b/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); + } + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/dimHelper.java b/StevenDimDoors/mod_pocketDim/dimHelper.java new file mode 100644 index 00000000..81b9afc4 --- /dev/null +++ b/StevenDimDoors/mod_pocketDim/dimHelper.java @@ -0,0 +1,1147 @@ +package StevenDimDoors.mod_pocketDim; +/** + * This class regulates all the operations involving the storage and manipulation of dimensions. It handles saving dim data, teleporting the player, and + * creating/registering new dimensions as well as loading old dimensions on startup + * @Return + */ + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Random; +import java.util.Set; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.WorldServer; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.storage.ExtendedBlockStorage; +import net.minecraftforge.common.DimensionManager; +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.relauncher.Side; + +public class dimHelper extends DimensionManager +{ + /** + * HashMap containing all the dims registered with DimDoors, sorted by dim ID. loaded on startup + * @Return + */ + public static HashMap dimList=new HashMap(); + public static boolean isSaving=false; + + /** + * ArrayList containing any blocks in limbo that have been placed by the player. Cycled through in the common tick manager + * @Return + */ + public static ArrayList blocksToDecay= new ArrayList(); + + /** + * instance of the dimHelper + * @Return + */ + public static dimHelper instance = new dimHelper(); + + /** + * HashMap for temporary storage of Link Singnature damage hash values. See itemLinkSignature for more details + * @Return + */ + public HashMap interDimLinkList= new HashMap(); + + /** + * ArrayList containing all link data not sorted for easy random access, used for random doors and for recreating rifts if they have a block placed over them. + * See the common tick manager and the Chaos door for details on useage + * @Return + */ + public ArrayList linksForRendering =new ArrayList(); + Random rand= new Random(); + + //Stupid function I use because I dont understand bitwise operations yet. Used in door orientation + //TODO get rid of this + public int flipDoorMetadata(int data) + { + if(data==0) + { + return 2; + } + if(data==1) + { + return 3; + } + if(data==2) + { + return 0; + } + if(data==3) + { + return 1; + } + + + + if(data==4) + { + return 6; + } + if(data==5) + { + return 7; + } + if(data==6) + { + return 4; + } + if(data==7) + { + return 5; + } + else return -10; + } + + + + public int getDimDepth(int DimID) + { + if(this.dimList.containsKey(DimID)) + { + return (int)this.dimList.get(DimID).depth; + } + else return 1; + } + + + public void teleportToLimbo(World world,LinkData linkData, EntityPlayer player) + { + + EntityPlayerMP playerMP = (EntityPlayerMP) player; + player.fallDistance=-700; + + + //World worldLimbo= this.getWorld(mod_pocketDim.limboDimID); + mod_pocketDim.limbo=this.getWorld(mod_pocketDim.limboDimID); + if(mod_pocketDim.limbo==null) + { + this.initDimension(mod_pocketDim.limboDimID); + } + else if (mod_pocketDim.limbo.provider==null) + { + this.initDimension(mod_pocketDim.limboDimID); + + } + + //System.out.println(worldLimbo.getHeightValue( MathHelper.floor_double(player.posX), MathHelper.floor_double(player.posZ))); + playerMP.mcServer.getConfigurationManager().transferPlayerToDimension(playerMP, mod_pocketDim.limboDimID, new pocketTeleporter((WorldServer) this.getWorld(mod_pocketDim.limboDimID), linkData)); + + } + + /** + * Primary function used to teleport the player using doors. Performes numerous null checks, and also generates the destination door/pocket if it has not done so already. + * Also ensures correct orientation relative to the door using the pocketTeleporter. + * @param world- world the player is currently in + * @param linkData- the link the player is using to teleport, sends the player to its dest information. + * @param player- the instance of the player to be teleported + * @param orientation- the orientation of the door used to teleport, determines player orientation and door placement on arrival + * @Return + */ + public void teleportToPocket(World world,LinkData linkData, EntityPlayer player) + { + + + + if(linkData!=null) + { + int destinationID=linkData.destDimID; + int x=linkData.destXCoord; + int y=linkData.destYCoord; + int z=linkData.destZCoord; + + if(linkData.destDimID==mod_pocketDim.limboDimID) + { + this.teleportToLimbo(world, linkData, player); + } + + + int depth= this.getDimDepth(world.provider.dimensionId); + + if(this.dimList.containsKey(destinationID)) + { + this.generatePocket(linkData); + this.generateDoor(world,linkData); + + + if(player instanceof EntityPlayerMP) + { + + EntityPlayerMP playerMP = (EntityPlayerMP) player; + + if(linkData.destDimID==world.provider.dimensionId) + { + (new pocketTeleporter((WorldServer) world,linkData)).placeInPortal(playerMP, x, y, z, 0); + //tele.placeInPortal(playerMP, x, y, z, 0); + player.worldObj.playSoundEffect(player.posX, player.posY, player.posZ, "mob.endermen.portal", 1.0F, 1.0F); + + } + else + { + + + + + playerMP.mcServer.getConfigurationManager().transferPlayerToDimension(playerMP, destinationID, new pocketTeleporter((WorldServer) world, linkData)); + + player.worldObj.playSoundEffect(player.posX, player.posY, player.posZ, "mob.endermen.portal", 1.0F, 1.0F); + + int playerXCoord=MathHelper.floor_double(player.posX); + int playerYCoord=MathHelper.floor_double(player.posY); + int playerZCoord=MathHelper.floor_double(player.posZ); + + if(Block.blocksList.length>player.worldObj.getBlockId(playerXCoord,playerYCoord,playerZCoord)&&!player.worldObj.isAirBlock(playerXCoord,playerYCoord,playerZCoord)) + { + if(Block.blocksList[player.worldObj.getBlockId(playerXCoord,playerYCoord,playerZCoord)].isOpaqueCube()) + { + player.worldObj.setBlockWithNotify(playerXCoord,playerYCoord+1,playerZCoord,0); + } + } + if(player.worldObj.getBlockId(x, y, z)==mod_pocketDim.dimDoorID||player.worldObj.getBlockId(x, y, z)==mod_pocketDim.ExitDoorID) + { + if(this.getLinkDataFromCoords(x, y, z, player.worldObj)!=null) + { + //System.out.println("updated link orientation"); + this.getLinkDataFromCoords(x, y, z, player.worldObj).linkOrientation= player.worldObj.getBlockMetadata(x, y -1, z); + + } + } + } + } + } + } + if(!world.isRemote) + { + + } + } + /** + * Creates a link at the location, pointing to the destination. Does NOT create a pair, so must be called twice. + * @param locationDimID + * @param destinationDimID + * @param locationXCoord + * @param locationYCoord + * @param locationZCoord + * @param destinationXCoord + * @param destinationYCoord + * @param destinationZCoord + + * @return + */ + public LinkData createLink( int locationDimID, int destinationDimID, int locationXCoord, int locationYCoord, int locationZCoord, int destinationXCoord, int destinationYCoord, int destinationZCoord) + { + if(this.getLinkDataFromCoords(locationXCoord, locationYCoord, locationZCoord, locationDimID)!=null) + { + return this.createLink(locationDimID, destinationDimID, locationXCoord, locationYCoord, locationZCoord, destinationXCoord, destinationYCoord, destinationZCoord, this.getLinkDataFromCoords(locationXCoord, locationYCoord, locationZCoord, locationDimID).linkOrientation); + + } + return this.createLink(locationDimID, destinationDimID, locationXCoord, locationYCoord, locationZCoord, destinationXCoord, destinationYCoord, destinationZCoord, -10); + } + + + /** + * Creates a link at the location, pointing to the destination. Does NOT create a pair, so must be called twice. + * @param locationDimID + * @param destinationDimID + * @param locationXCoord + * @param locationYCoord + * @param locationZCoord + * @param destinationXCoord + * @param destinationYCoord + * @param destinationZCoord + * @param linkOrientation + * @return + */ + public LinkData createLink( int locationDimID, int destinationDimID, int locationXCoord, int locationYCoord, int locationZCoord, int destinationXCoord, int destinationYCoord, int destinationZCoord,int linkOrientation) + { + + + + LinkData linkData =new LinkData( locationDimID, destinationDimID, locationXCoord, locationYCoord, locationZCoord, destinationXCoord, destinationYCoord ,destinationZCoord,false); + linkData.linkOrientation=linkOrientation; + return this.createLink(linkData); + + + + } + + + public LinkData createLink(LinkData link) + { + + + if(!this.dimList.containsKey(link.locDimID)) + { + DimData locationDimData= new DimData(link.locDimID, false, 0, link.locDimID,link.locXCoord,link.locYCoord,link.locZCoord); + this.dimList.put(link.locDimID, locationDimData); + link.isLocPocket=false; + + } + + DimData locationDimData= this.dimList.get(link.locDimID); + link.isLocPocket=locationDimData.isPocket; + + locationDimData.addLinkToDim(link); + this.linksForRendering.add(link); + + if(dimHelper.getWorld(link.locDimID)!=null) + { + + //World world =dimHelper.getWorld(link.locDimID); + + + int blocktoReplace = dimHelper.getWorld(link.locDimID).getBlockId(link.locXCoord, link.locYCoord, link.locZCoord); + + if(!mod_pocketDim.blocksImmuneToRift.contains(blocktoReplace)) + { + dimHelper.getWorld(link.locDimID).setBlockWithNotify(link.locXCoord, link.locYCoord, link.locZCoord, mod_pocketDim.blockRiftID); + + } + + } + + + //Notifies other players that a link has been created. + if(FMLCommonHandler.instance().getEffectiveSide()==Side.SERVER) + { + + // System.out.println("Sending link creation packet with orientation "+link.linkOrientation); + PacketHandler.onLinkCreatedPacket(link); + + + } + + + return link; + + + + } + + public int getDestOrientation(LinkData link) + { + if(link !=null) + { + LinkData destLink = this.getLinkDataFromCoords(link.destXCoord, link.destYCoord, link.destZCoord, link.destDimID); + if(destLink!=null) + { + return destLink.linkOrientation; + } + else + { + //System.out.println("Cant find destination link"); + + return 0; + } + } + else + { + // System.out.println("sending link is null"); + return 0; + } + } + + + public void removeLink(LinkData link) + { + + this.removeLink(link.locDimID, link.locXCoord, link.locYCoord, link.locZCoord); + } + + /** + * properly deletes a link at the given coordinates. used by the rift remover. Also notifies clients of change. + * @param locationDimID + * @param locationXCoord + * @param locationYCoord + * @param locationZCoord + */ + public void removeLink( int locationDimID, int locationXCoord, int locationYCoord, int locationZCoord) + { + + if(!this.dimList.containsKey(locationDimID)) + { + DimData locationDimData= new DimData(locationDimID, false, 0, locationDimID,locationXCoord,locationYCoord,locationZCoord); + this.dimList.put(locationDimID, locationDimData); + + } + LinkData link = this.getLinkDataFromCoords(locationXCoord, locationYCoord, locationZCoord, locationDimID); + this.linksForRendering.remove(link); + + this.dimList.get(locationDimID).removeLinkAtCoords(link); + + //updates clients that a rift has been removed + if(FMLCommonHandler.instance().getEffectiveSide()==Side.SERVER) + { + PacketHandler.onLinkRemovedPacket(link); + this.save(); + } + + + + } + + public LinkData findNearestRift(World world, int x, int y, int z, int range) + { + return this.dimList.get(world).findNearestRift(world, range, x, y, z); + } + + /** + * generates a door based on what door was used to teleport. Only funtions once per linking. + * @param world- door + * @param linkData + */ + public void generateDoor(World world, LinkData linkData) + { + int locX = linkData.locXCoord; + int locY = linkData.locYCoord; + int locZ = linkData.locZCoord; + + int destX = linkData.destXCoord; + int destY = linkData.destYCoord; + int destZ = linkData.destZCoord; + + if(!linkData.hasGennedDoor) + { + + + int destinationID = linkData.destDimID; + + DimData data = this.dimList.get(destinationID); + + int id =world.getBlockId(locX, locY, locZ); + if(id==mod_pocketDim.ExitDoorID||id==mod_pocketDim.dimDoorID) + { + int doorTypeToPlace=id; + + + // World destWorld = this.getWorld(destinationID); + + + + if(this.getWorld(destinationID)==null) + { + this.initDimension(destinationID); + } + + int blockToReplace= this.getWorld(destinationID).getBlockId(destX, destY, destZ); + if(blockToReplace!=mod_pocketDim.dimDoorID&&blockToReplace!=mod_pocketDim.linkExitDoorID&&blockToReplace!=mod_pocketDim.linkDimDoorID&&blockToReplace!=mod_pocketDim.ExitDoorID&&blockToReplace!=mod_pocketDim.transientDoorID) + { + this.getWorld(destinationID).setBlockAndMetadata(destX, destY-1, destZ, doorTypeToPlace,dimHelper.instance.flipDoorMetadata(world.getBlockMetadata(locX, locY-1, locZ))); + this.getWorld(destinationID).setBlockAndMetadata(destX, destY, destZ, doorTypeToPlace,world.getBlockMetadata(locX, locY, locZ)); + // System.out.println("Genned door"); + } + + if(id==mod_pocketDim.transientDoorID&&!dimHelper.dimList.get((destinationID)).hasBeenFilled) + { + this.getWorld(destinationID).setBlockAndMetadata(destX, destY-1, destZ, id,dimHelper.instance.flipDoorMetadata(world.getBlockMetadata(locX, locY-1, locZ))); + this.getWorld(destinationID).setBlockAndMetadata(destX, destY, destZ, id,world.getBlockMetadata(locX, locY, locZ)); + } + + linkData.hasGennedDoor=true; + } + } + } + + + + + /** + * Generates the black pocket out of fabric of reality blocks. Placement of the pocket is based off of the orignial doors orientation. Kind of a clunky method, + * but is nessesarry to maintain a one to one relationship with the overworld. Is called every teleport, but checks if the dim has been filled first and is a pocket . + * Also responsible for generation the random dungeons. + * @param world- id of the world TO BE FILLED + * @param x + * @param y + * @param z + * @param orientation + * @return + */ + public void generatePocket(LinkData incomingLink) + { + if(this.getWorld(incomingLink.destDimID)==null) + { + this.initDimension(incomingLink.destDimID); + } + if(this.getWorld(incomingLink.destDimID).provider==null) + { + this.initDimension(incomingLink.destDimID); + } + // World world = this.getWorld(incomingLink.destDimID); + DimData data = this.dimList.get(incomingLink.destDimID); + + if(!data.hasBeenFilled&&data.isPocket&&!data.isDimRandomRift) + { + data.hasBeenFilled=true; + //System.out.println("genning pocket"); + int x = incomingLink.destXCoord; + int y = incomingLink.destYCoord; + int z = incomingLink.destZCoord; + int orientation= (incomingLink.linkOrientation); + + int depth= this.getDimDepth(incomingLink.locDimID); + //x=x*depth; + //y=y*depth; + //z=z*depth; + y=y+13; + + + if(orientation==0) + { + x=x+15; + } + else if(orientation==1) + { + z=z+15; + } + else if(orientation==2) + { + x=x-15; + } + else if(orientation==3) + { + z=z-15; + } + int searchRadius=19; + + if(!this.getWorld(incomingLink.destDimID).isRemote) + { + + + int xCount=-searchRadius; + int yCount=-searchRadius; + int zCount=-searchRadius; + + while (xCount<=searchRadius) + { + while(yCount<=searchRadius) + { + while(zCount<=searchRadius) + { + + if((Math.abs(xCount)>=15||Math.abs(yCount)>=15||Math.abs(zCount)>=15)&&this.getWorld(incomingLink.destDimID).isAirBlock( x+xCount, y+yCount, z+zCount)) + { + if(Math.abs(xCount)>=19||Math.abs(yCount)>=19||Math.abs(zCount)>=19) + { + this.setBlockDirectly(this.getWorld(incomingLink.destDimID), x+xCount, y+yCount, z+zCount,mod_pocketDim.blockDimWallPermID,0); + + } + else + { + this.setBlockDirectly(this.getWorld(incomingLink.destDimID), x+xCount, y+yCount, z+zCount,mod_pocketDim.blockDimWallID,0); + if(mod_pocketDim.TNFREAKINGT) + { + if((Math.abs(xCount)>=16||Math.abs(yCount)>=16||Math.abs(zCount)>=16)&&rand.nextInt(mod_pocketDim.HOW_MUCH_TNT)==1) + { + this.getWorld(incomingLink.destDimID).setBlock( x+xCount, y+yCount, z+zCount,Block.tnt.blockID); + } + } + } + } + + zCount++; + } + zCount=-searchRadius; + yCount++; + } + yCount=-searchRadius; + xCount++; + } + } + } + else if(!data.hasBeenFilled&&data.isPocket&&data.isDimRandomRift) + { + //System.out.println("genning dungeon pocket"); + + DungeonGenerator.generateDungeonlink(incomingLink); + data.hasBeenFilled=true; + + } + } + + /** + * simple method called on startup to register all dims saved in the dim list. Only tries to register pocket dims, though. Also calls load() + * @return + */ + public void initPockets() + { + mod_pocketDim.hasInitDims=true; + this.load(); + if(!this.dimList.isEmpty()) + { + Set allDimIds=dimList.keySet(); + + Iterator itr =allDimIds.iterator(); + while(itr.hasNext()) + { + DimData dimData = (DimData) dimList.get(itr.next()); + if(dimData.isPocket) + { + try + { + this.getNextFreeDimId(); + registerDimension(dimData.dimID,mod_pocketDim.providerID); + } + catch (Exception e) + { + if(dimData.isPocket) + { + System.out.println("Warning- could not register dim "+dimData.depth+" . Probably caused by a version update/save data corruption/other mods. "); + } + } + } + } + } + } + /** + * method called when the client disconects/server stops to unregister dims. + * @Return + */ + public void unregsisterDims() + { + + if(!this.dimList.isEmpty()) + { + Set allDimIds=dimList.keySet(); + + Iterator itr =allDimIds.iterator(); + while(itr.hasNext()) + { + DimData dimData = (DimData) dimList.get(itr.next()); + if(dimData.isPocket) + { + try + { + this.unregisterDimension(dimData.dimID); + } + catch(Exception e) + { + System.out.println("Dim-"+String.valueOf(dimData.dimID)+"is already unregistered, ok? Enough with it already."); + } + // initDimension(dimData.dimID); + } + + } + + } + + } + + /** + * Used to associate a damage value on a Rift Signature with a link pair. See LinkSignature for details. + * @return + */ + public int createUniqueInterDimLinkKey() + { + int linkKey; + Random rand= new Random(); + do + { + linkKey=rand.nextInt(30000); + } + while(this.interDimLinkList.containsKey(linkKey)); + return linkKey; + } + + /** + * Method used to create and register a new pocket dimension. Called on door placement and rift generation. It does NOT actually generate the structure of the dim, just + * registers it with the dimension manager and adds the necessary links and dim info to the dimlist/linklists. + * Also registers existing dims with the dimList, so link data can be stored for them. + * + * Handles the randomization associated with depth as well, going far enough causes the next dims exit link to be randomized. + * + * @param world- World currently occupied, the parent of the pocket dim to be created. + * @param x + * @param y + * @param z + * @param isGoingDown + * @param isRandomRift + * @param orientation- determines the orientation of the entrance link to this dim. Should be the metaData of the door occupying the rift. -1 if no door. + * @return + */ + public LinkData createPocket(LinkData link , boolean isGoingDown, boolean isRandomRift) + { + + + int dimensionID; + int depth = this.getDimDepth(link.locDimID); + // World world = this.getWorld(link.locDimID); + + dimensionID = getNextFreeDimId(); + registerDimension(dimensionID,mod_pocketDim.providerID); + + + + + DimData locationDimData; + DimData destDimData; + + if(this.dimList.containsKey(link.locDimID)&&!this.getWorld(link.locDimID).isRemote) //checks to see if dim is already registered. If not, it creates a DimData entry for it later + { + //randomizes exit if deep enough + locationDimData= dimList.get(this.getWorld(link.locDimID).provider.dimensionId); + + if(depth>5) + { + if(depth>=12) + { + depth=11; + } + if(rand.nextInt(13-depth)==0) + { + + boolean foundRandomDest=false; + int i=0; + int size = dimHelper.instance.linksForRendering.size(); + + while (!foundRandomDest&&size>0&&i<100) + { + i++; + + LinkData link1 = (LinkData) dimHelper.instance.linksForRendering.get(rand.nextInt(size)); + + if(link1!=null) + { + + if(!link1.isLocPocket) + { + foundRandomDest=true; + locationDimData.exitDimLink=new LinkData(link1.locDimID, link1.locDimID, link1.locXCoord, link1.locYCoord, link1.locZCoord, link1.locXCoord, link1.locYCoord, link1.locZCoord, false); + + } + } + } + } + } + + + + + if(locationDimData.isPocket) //determines the qualites of the pocket dim being created, based on parent dim. + { + if(isGoingDown) + { + destDimData= new DimData(dimensionID, true, locationDimData.depth+1, locationDimData.exitDimLink); + + } + else + { + destDimData= new DimData(dimensionID, true, locationDimData.depth-1, locationDimData.exitDimLink); + + } + } + else + { + destDimData= new DimData(dimensionID, true, 1, link.locDimID,link.locXCoord,link.locYCoord,link.locZCoord); + + } + + } + else + { + + locationDimData= new DimData(link.locDimID, false, 0, link.locDimID,link.locXCoord,link.locYCoord,link.locZCoord); + destDimData= new DimData(dimensionID, true, 1, link.locDimID,link.locXCoord,link.locYCoord,link.locZCoord); + + } + + + + + + + destDimData.isDimRandomRift=isRandomRift; + + this.dimList.put(this.getWorld(link.locDimID).provider.dimensionId, locationDimData); + this.dimList.put(dimensionID, destDimData); + + + + + if(FMLCommonHandler.instance().getEffectiveSide()==Side.SERVER)//sends packet to clients notifying them that a new dim has been created. + { + PacketHandler.onDimCreatedPacket(destDimData); + } + + LinkData linkData = this.createLink(this.getWorld(link.locDimID).provider.dimensionId,dimensionID,link.locXCoord,link.locYCoord,link.locZCoord, link.destXCoord,link.destYCoord,link.destZCoord,link.linkOrientation); //creates and registers the two rifts that link the parent and pocket dim. + this.createLink(dimensionID,this.getWorld(link.locDimID).provider.dimensionId, link.destXCoord,link.destYCoord,link.destZCoord, link.locXCoord,link.locYCoord,link.locZCoord, this.flipDoorMetadata(link.linkOrientation)); + + + + + + + + return link; + + + } + + + + /** + * function that saves all dim data in a hashMap. Calling too often can cause Concurrent modification exceptions, so be careful. + * @return + */ + //TODO change from saving serialized objects to just saving data for compatabilies sake. + public void save() + { + if(!this.isSaving) + { + System.out.println("saving"); + + this.isSaving=true; + HashMap comboSave=new HashMap(); + comboSave.put("dimList", this.dimList); + comboSave.put("interDimLinkList", this.interDimLinkList); + comboSave.put("linksForRendering", this.linksForRendering); + comboSave.put("blocksToDecay", this.blocksToDecay); + + + + FileOutputStream saveFile = null; + try + { + World world=FMLCommonHandler.instance().getMinecraftServerInstance().worldServers[0]; + String saveFileName=world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsDataTEMP"; + saveFile = new FileOutputStream(saveFileName); + + ObjectOutputStream save = new ObjectOutputStream(saveFile); + save.writeObject(comboSave); + save.close(); + saveFile.close(); + + if(new File(world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsDataOLD").exists()) + { + new File(world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsDataOLD").delete(); + } + new File(world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsData").renameTo(new File(world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsDataOLD")); + + new File(saveFileName).renameTo( new File(world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsData")); + // System.out.println(String.valueOf(this.dimensionList)); + } + catch(Exception e) + { + e.printStackTrace(); + System.out.println("Could not save data-- SEVERE"); + } + + + + + this.isSaving=false; + } + } + + /** + * loads the dim data from the saved hashMap. Also handles compatabilty with old saves, see OldSaveHandler + * @return + */ + //TODO change to loading vars instead of objects + public void load() + { + boolean firstRun=false; + System.out.println("Loading DimDoors data"); + FileInputStream saveFile = null; + + + try + { + + + + + World world=FMLCommonHandler.instance().getMinecraftServerInstance().worldServers[0]; + File dataStore =new File( world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsData"); + + if(!dataStore.exists()) + { + + + if(!new File( world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsDataOLD").exists()) + { + firstRun=true; + } + } + + + // File oldSave=new File( world.getSaveHandler().getMapFileFromName("idcounts").getParent()+"/PocketDimData"); //checks to see if old save data is present + // if(oldSave.exists()) + // { + // OldSaveHandler.handleOldSaveData(oldSave); + // } + + + saveFile = new FileInputStream(dataStore); + ObjectSaveInputStream save = new ObjectSaveInputStream(saveFile); + HashMap comboSave =((HashMap)save.readObject()); + + try + { + this.interDimLinkList=(HashMap) comboSave.get("interDimLinkList"); + } + catch(Exception e) + { + System.out.println("Could not load Link Signature list. Link Sig items will loose restored locations."); + } + + try + { + this.dimList=(HashMap) comboSave.get("dimList"); + } + catch(Exception e) + { + 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."); + } + + try + { + this.linksForRendering=(ArrayList) comboSave.get("linksForRendering"); + } + catch(Exception e) + { + System.out.println("Could not load link rendering list. Not really a big deal."); + } + + try + { + this.blocksToDecay=(ArrayList) comboSave.get("blocksToDecay"); + } + catch(Exception e) + { + System.out.println("Could not load list of blocks to decay in Limbo. Probably because you updated versions, in which case this is normal. "); + + } + save.close(); + saveFile.close(); + + + + } + catch(Exception e4) + { + try + { + if(!firstRun) + { + System.out.println("Save data damaged, trying backup..."); + } + World world=FMLCommonHandler.instance().getMinecraftServerInstance().worldServers[0]; + File dataStore =new File( world.getSaveHandler().getMapFileFromName("idcounts").getParentFile().getParent()+"/DimensionalDoorsDataOLD"); + + + saveFile = new FileInputStream(dataStore); + ObjectSaveInputStream save = new ObjectSaveInputStream(saveFile); + HashMap comboSave =((HashMap)save.readObject()); + + try + { + this.interDimLinkList=(HashMap) comboSave.get("interDimLinkList"); + } + catch(Exception e) + { + System.out.println("Could not load Link Signature list. Link Sig items will loose restored locations."); + } + + try + { + this.dimList=(HashMap) comboSave.get("dimList"); + } + catch(Exception e) + { + 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."); + } + + try + { + this.linksForRendering=(ArrayList) comboSave.get("linksForRendering"); + } + catch(Exception e) + { + System.out.println("Could not load link rendering list. Not really a big deal."); + } + + try + { + this.blocksToDecay=(ArrayList) comboSave.get("blocksToDecay"); + } + catch(Exception e) + { + System.out.println("Could not load list of blocks to decay in Limbo. Probably because you updated versions, in which case this is normal. "); + + } + save.close(); + saveFile.close(); + + } + catch(Exception e2) + { + if(!firstRun) + { + e2.printStackTrace(); + System.out.println("Could not read data-- SEVERE"); + } + + + + + } + + + + + } + } + + + + + + + + /** + * gets a link based on coords and a world object + * @param x + * @param y + * @param z + * @param par1World + * @return + */ + public LinkData getLinkDataFromCoords(int x, int y, int z, World par1World) + { + return this.getLinkDataFromCoords(x, y, z, par1World.provider.dimensionId); + } + /** + * gets a link based on coords and a world ID + * @param x + * @param y + * @param z + * @param worldID + * @return + */ + public LinkData getLinkDataFromCoords(int x, int y, int z, int worldID) + { + if(this.dimList.containsKey(worldID)) + { + DimData dimData=this.dimList.get(worldID); + + return dimData.findLinkAtCoords(x, y, z); + + } + + return null; + } + /** + * function called by rift tile entities and the rift remover to find and spread between rifts. Does not actually de-register the rift data, see deleteRift for that. + * @param world + * @param x + * @param y + * @param z + * @param range + * @param player + * @param item + * @return + */ + public static boolean removeRift(World world, int x, int y, int z, int range, EntityPlayer player, ItemStack item) + { + + LinkData nearest=null; + float distance=range+1; + int i=-range; + int j=-range; + int k=-range; + + while (i>4; + int cZ=z >>4; + int cY=y >>4; + Chunk chunk; + 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(); + } + + } + + public void addDimData(DimData dimData) + { + this.dimList.put(dimData.dimID, dimData); + } + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/itemDimDoor.java b/StevenDimDoors/mod_pocketDim/itemDimDoor.java new file mode 100644 index 00000000..c36967d4 --- /dev/null +++ b/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; + + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/itemExitDoor.java b/StevenDimDoors/mod_pocketDim/itemExitDoor.java new file mode 100644 index 00000000..b8adebc9 --- /dev/null +++ b/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"); + + + + } + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/itemLinkSignature.java b/StevenDimDoors/mod_pocketDim/itemLinkSignature.java new file mode 100644 index 00000000..09eeae6c --- /dev/null +++ b/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); + **/ + } + } +} diff --git a/StevenDimDoors/mod_pocketDim/itemRiftRemover.java b/StevenDimDoors/mod_pocketDim/itemRiftRemover.java new file mode 100644 index 00000000..a4567d1e --- /dev/null +++ b/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); + **/ + } + } +} diff --git a/StevenDimDoors/mod_pocketDim/linkDimDoor.java b/StevenDimDoors/mod_pocketDim/linkDimDoor.java new file mode 100644 index 00000000..5016d54f --- /dev/null +++ b/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; + + } + + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/linkExitDoor.java b/StevenDimDoors/mod_pocketDim/linkExitDoor.java new file mode 100644 index 00000000..acd1bf30 --- /dev/null +++ b/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); + } + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/mod_pocketDim.java b/StevenDimDoors/mod_pocketDim/mod_pocketDim.java new file mode 100644 index 00000000..c47ae2fa --- /dev/null +++ b/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 limboSpawnInventory=new ArrayList(); + + public static ArrayList blocksImmuneToRift= new ArrayList(); + public static ArrayList registeredDungeons = new ArrayList(); + + public static ArrayList simpleHalls = new ArrayList(); + + + public static ArrayList complexHalls = new ArrayList(); + + + public static ArrayList deadEnds = new ArrayList(); + + + public static ArrayList hubs = new ArrayList(); + + + public static ArrayList mazes = new ArrayList(); + + + public static ArrayList pistonTraps = new ArrayList(); + + + public static ArrayList exits = new ArrayList(); + + 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(); + + + } + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/pocketDimWorld.java b/StevenDimDoors/mod_pocketDim/pocketDimWorld.java new file mode 100644 index 00000000..e69de29b diff --git a/StevenDimDoors/mod_pocketDim/pocketGenerator.java b/StevenDimDoors/mod_pocketDim/pocketGenerator.java new file mode 100644 index 00000000..29be4448 --- /dev/null +++ b/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; + } + + + + + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDim/pocketProvider.java b/StevenDimDoors/mod_pocketDim/pocketProvider.java new file mode 100644 index 00000000..9a05dbc4 --- /dev/null +++ b/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; + } + + + +} diff --git a/StevenDimDoors/mod_pocketDim/pocketTeleporter.java b/StevenDimDoors/mod_pocketDim/pocketTeleporter.java new file mode 100644 index 00000000..0ff179d0 --- /dev/null +++ b/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) + { + + } +} diff --git a/StevenDimDoors/mod_pocketDimClient/ClientPacketHandler.java b/StevenDimDoors/mod_pocketDimClient/ClientPacketHandler.java new file mode 100644 index 00000000..46088365 --- /dev/null +++ b/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 + +} +} diff --git a/StevenDimDoors/mod_pocketDimClient/ClientProxy.java b/StevenDimDoors/mod_pocketDimClient/ClientProxy.java new file mode 100644 index 00000000..58260f88 --- /dev/null +++ b/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); + } + +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDimClient/ClientTickHandler.java b/StevenDimDoors/mod_pocketDimClient/ClientTickHandler.java new file mode 100644 index 00000000..8561237e --- /dev/null +++ b/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 type, Object... tickData) {} + + @Override + public void tickEnd(EnumSet 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 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 + } +} \ No newline at end of file diff --git a/StevenDimDoors/mod_pocketDimClient/ClosingRiftFX.java b/StevenDimDoors/mod_pocketDimClient/ClosingRiftFX.java new file mode 100644 index 00000000..34efea68 --- /dev/null +++ b/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; + } +} diff --git a/StevenDimDoors/mod_pocketDimClient/GoggleRiftFX.java b/StevenDimDoors/mod_pocketDimClient/GoggleRiftFX.java new file mode 100644 index 00000000..5dcd1379 --- /dev/null +++ b/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; + } +} diff --git a/StevenDimDoors/mod_pocketDimClient/RenderDimDoor.java b/StevenDimDoors/mod_pocketDimClient/RenderDimDoor.java new file mode 100644 index 00000000..f854eb15 --- /dev/null +++ b/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); + } + } +} diff --git a/StevenDimDoors/mod_pocketDimClient/RenderRift.java b/StevenDimDoors/mod_pocketDimClient/RenderRift.java new file mode 100644 index 00000000..e69de29b diff --git a/StevenDimDoors/mod_pocketDimClient/RiftFX.java b/StevenDimDoors/mod_pocketDimClient/RiftFX.java new file mode 100644 index 00000000..a9fe7a21 --- /dev/null +++ b/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; + } +} diff --git a/StevenDimDoors/schematics/azeryuuDungeon.schematic b/StevenDimDoors/schematics/azeryuuDungeon.schematic new file mode 100644 index 00000000..fde476ae Binary files /dev/null and b/StevenDimDoors/schematics/azeryuuDungeon.schematic differ diff --git a/StevenDimDoors/schematics/dungeon.schematic b/StevenDimDoors/schematics/dungeon.schematic new file mode 100644 index 00000000..8a23dd02 Binary files /dev/null and b/StevenDimDoors/schematics/dungeon.schematic differ diff --git a/StevenDimDoors/schematics/dungeon1.schematic b/StevenDimDoors/schematics/dungeon1.schematic new file mode 100644 index 00000000..3f926588 Binary files /dev/null and b/StevenDimDoors/schematics/dungeon1.schematic differ diff --git a/StevenDimDoors/schematics/dungeon2.schematic b/StevenDimDoors/schematics/dungeon2.schematic new file mode 100644 index 00000000..b17c57f2 Binary files /dev/null and b/StevenDimDoors/schematics/dungeon2.schematic differ diff --git a/StevenDimDoors/schematics/dungeon3.schematic b/StevenDimDoors/schematics/dungeon3.schematic new file mode 100644 index 00000000..52f3ba4b Binary files /dev/null and b/StevenDimDoors/schematics/dungeon3.schematic differ diff --git a/StevenDimDoors/schematics/dungeon4.schematic b/StevenDimDoors/schematics/dungeon4.schematic new file mode 100644 index 00000000..d8787e6d Binary files /dev/null and b/StevenDimDoors/schematics/dungeon4.schematic differ diff --git a/StevenDimDoors/schematics/dungeon5.schematic b/StevenDimDoors/schematics/dungeon5.schematic new file mode 100644 index 00000000..8f59c30d Binary files /dev/null and b/StevenDimDoors/schematics/dungeon5.schematic differ diff --git a/StevenDimDoors/schematics/dungeon6.schematic b/StevenDimDoors/schematics/dungeon6.schematic new file mode 100644 index 00000000..9f0dca4f Binary files /dev/null and b/StevenDimDoors/schematics/dungeon6.schematic differ diff --git a/StevenDimDoors/schematics/dungeon7.schematic b/StevenDimDoors/schematics/dungeon7.schematic new file mode 100644 index 00000000..37ff31b7 Binary files /dev/null and b/StevenDimDoors/schematics/dungeon7.schematic differ diff --git a/WARP.png b/WARP.png new file mode 100644 index 00000000..fd8efb2c Binary files /dev/null and b/WARP.png differ diff --git a/dimdoors_logo.png b/dimdoors_logo.png new file mode 100644 index 00000000..6828be8e Binary files /dev/null and b/dimdoors_logo.png differ diff --git a/mcmod.info b/mcmod.info new file mode 100644 index 00000000..92e3868d --- /dev/null +++ b/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" +] +} +] diff --git a/schematics/4WayBasicHall.schematic b/schematics/4WayBasicHall.schematic new file mode 100644 index 00000000..50ac14ae Binary files /dev/null and b/schematics/4WayBasicHall.schematic differ diff --git a/schematics/4WayHallExit.schematic b/schematics/4WayHallExit.schematic new file mode 100644 index 00000000..0adb3e9c Binary files /dev/null and b/schematics/4WayHallExit.schematic differ diff --git a/schematics/azersDungeonO.schematic b/schematics/azersDungeonO.schematic new file mode 100644 index 00000000..9766d121 Binary files /dev/null and b/schematics/azersDungeonO.schematic differ diff --git a/schematics/brokenPillarsO.schematic b/schematics/brokenPillarsO.schematic new file mode 100644 index 00000000..40fa1ad4 Binary files /dev/null and b/schematics/brokenPillarsO.schematic differ diff --git a/schematics/buggyTopEntry1.schematic b/schematics/buggyTopEntry1.schematic new file mode 100644 index 00000000..d82ac2c2 Binary files /dev/null and b/schematics/buggyTopEntry1.schematic differ diff --git a/schematics/collapsedSingleTunnel1.schematic b/schematics/collapsedSingleTunnel1.schematic new file mode 100644 index 00000000..dfbf69a0 Binary files /dev/null and b/schematics/collapsedSingleTunnel1.schematic differ diff --git a/schematics/diamondTowerTemple1.schematic b/schematics/diamondTowerTemple1.schematic new file mode 100644 index 00000000..030299d6 Binary files /dev/null and b/schematics/diamondTowerTemple1.schematic differ diff --git a/schematics/doorTotemRuins.schematic b/schematics/doorTotemRuins.schematic new file mode 100644 index 00000000..32996f57 Binary files /dev/null and b/schematics/doorTotemRuins.schematic differ diff --git a/schematics/dungeon.schematic b/schematics/dungeon.schematic new file mode 100644 index 00000000..8a23dd02 Binary files /dev/null and b/schematics/dungeon.schematic differ diff --git a/schematics/dungeon6.schematic b/schematics/dungeon6.schematic new file mode 100644 index 00000000..9f0dca4f Binary files /dev/null and b/schematics/dungeon6.schematic differ diff --git a/schematics/dungeon7.schematic b/schematics/dungeon7.schematic new file mode 100644 index 00000000..37ff31b7 Binary files /dev/null and b/schematics/dungeon7.schematic differ diff --git a/schematics/exitCube.schematic b/schematics/exitCube.schematic new file mode 100644 index 00000000..411c4eca Binary files /dev/null and b/schematics/exitCube.schematic differ diff --git a/schematics/exitRuinsWithHiddenDoor.schematic b/schematics/exitRuinsWithHiddenDoor.schematic new file mode 100644 index 00000000..eef2733e Binary files /dev/null and b/schematics/exitRuinsWithHiddenDoor.schematic differ diff --git a/schematics/fakeTNTTrap.schematic b/schematics/fakeTNTTrap.schematic new file mode 100644 index 00000000..d2811b0e Binary files /dev/null and b/schematics/fakeTNTTrap.schematic differ diff --git a/schematics/fallingTrapO.schematic b/schematics/fallingTrapO.schematic new file mode 100644 index 00000000..b631bf96 Binary files /dev/null and b/schematics/fallingTrapO.schematic differ diff --git a/schematics/fortRuins.schematic b/schematics/fortRuins.schematic new file mode 100644 index 00000000..f67c75c7 Binary files /dev/null and b/schematics/fortRuins.schematic differ diff --git a/schematics/hallwayHiddenTreasure.schematic b/schematics/hallwayHiddenTreasure.schematic new file mode 100644 index 00000000..f088af77 Binary files /dev/null and b/schematics/hallwayHiddenTreasure.schematic differ diff --git a/schematics/hallwayPitFallTrap.schematic b/schematics/hallwayPitFallTrap.schematic new file mode 100644 index 00000000..a292fd63 Binary files /dev/null and b/schematics/hallwayPitFallTrap.schematic differ diff --git a/schematics/hallwayTrapRooms1.schematic b/schematics/hallwayTrapRooms1.schematic new file mode 100644 index 00000000..192207c9 Binary files /dev/null and b/schematics/hallwayTrapRooms1.schematic differ diff --git a/schematics/hiddenStaircaseO.schematic b/schematics/hiddenStaircaseO.schematic new file mode 100644 index 00000000..82b1c984 Binary files /dev/null and b/schematics/hiddenStaircaseO.schematic differ diff --git a/schematics/lavaPyramid.schematic b/schematics/lavaPyramid.schematic new file mode 100644 index 00000000..fdf741f5 Binary files /dev/null and b/schematics/lavaPyramid.schematic differ diff --git a/schematics/lavaTrapO.schematic b/schematics/lavaTrapO.schematic new file mode 100644 index 00000000..bee6b2aa Binary files /dev/null and b/schematics/lavaTrapO.schematic differ diff --git a/schematics/lockingExitHall.schematic b/schematics/lockingExitHall.schematic new file mode 100644 index 00000000..5adbe706 Binary files /dev/null and b/schematics/lockingExitHall.schematic differ diff --git a/schematics/longDoorHallway.schematic b/schematics/longDoorHallway.schematic new file mode 100644 index 00000000..86d815d1 Binary files /dev/null and b/schematics/longDoorHallway.schematic differ diff --git a/schematics/mediumPillarStairs.schematic b/schematics/mediumPillarStairs.schematic new file mode 100644 index 00000000..499f0b36 Binary files /dev/null and b/schematics/mediumPillarStairs.schematic differ diff --git a/schematics/pistonFallRuins.schematic b/schematics/pistonFallRuins.schematic new file mode 100644 index 00000000..198d5291 Binary files /dev/null and b/schematics/pistonFallRuins.schematic differ diff --git a/schematics/pistonFloorHall.schematic b/schematics/pistonFloorHall.schematic new file mode 100644 index 00000000..523dc929 Binary files /dev/null and b/schematics/pistonFloorHall.schematic differ diff --git a/schematics/pistonHallway.schematic b/schematics/pistonHallway.schematic new file mode 100644 index 00000000..7606995e Binary files /dev/null and b/schematics/pistonHallway.schematic differ diff --git a/schematics/pistonSmasherHall.schematic b/schematics/pistonSmasherHall.schematic new file mode 100644 index 00000000..6b83a346 Binary files /dev/null and b/schematics/pistonSmasherHall.schematic differ diff --git a/schematics/pitStairs.schematic b/schematics/pitStairs.schematic new file mode 100644 index 00000000..653f09f8 Binary files /dev/null and b/schematics/pitStairs.schematic differ diff --git a/schematics/raceTheTNTHall.schematic b/schematics/raceTheTNTHall.schematic new file mode 100644 index 00000000..5e689a46 Binary files /dev/null and b/schematics/raceTheTNTHall.schematic differ diff --git a/schematics/randomTree.schematic b/schematics/randomTree.schematic new file mode 100644 index 00000000..e6b0edb2 Binary files /dev/null and b/schematics/randomTree.schematic differ diff --git a/schematics/ruinsO.schematic b/schematics/ruinsO.schematic new file mode 100644 index 00000000..d5ad2095 Binary files /dev/null and b/schematics/ruinsO.schematic differ diff --git a/schematics/simpleDropHall.schematic b/schematics/simpleDropHall.schematic new file mode 100644 index 00000000..70fa7657 Binary files /dev/null and b/schematics/simpleDropHall.schematic differ diff --git a/schematics/simpleSmallT1.schematic b/schematics/simpleSmallT1.schematic new file mode 100644 index 00000000..a8bc35e0 Binary files /dev/null and b/schematics/simpleSmallT1.schematic differ diff --git a/schematics/simpleStairsDown.schematic b/schematics/simpleStairsDown.schematic new file mode 100644 index 00000000..63659d28 Binary files /dev/null and b/schematics/simpleStairsDown.schematic differ diff --git a/schematics/simpleStairsUp.schematic b/schematics/simpleStairsUp.schematic new file mode 100644 index 00000000..965c2cf9 Binary files /dev/null and b/schematics/simpleStairsUp.schematic differ diff --git a/schematics/singleStraightHall1.schematic b/schematics/singleStraightHall1.schematic new file mode 100644 index 00000000..7f9f11c8 Binary files /dev/null and b/schematics/singleStraightHall1.schematic differ diff --git a/schematics/smallBranchWithExit.schematic b/schematics/smallBranchWithExit.schematic new file mode 100644 index 00000000..acc9cd44 Binary files /dev/null and b/schematics/smallBranchWithExit.schematic differ diff --git a/schematics/smallDesert.schematic b/schematics/smallDesert.schematic new file mode 100644 index 00000000..6fded48b Binary files /dev/null and b/schematics/smallDesert.schematic differ diff --git a/schematics/smallExitPrison.schematic b/schematics/smallExitPrison.schematic new file mode 100644 index 00000000..bb7a7ef3 Binary files /dev/null and b/schematics/smallExitPrison.schematic differ diff --git a/schematics/smallHiddenTowerO.schematic b/schematics/smallHiddenTowerO.schematic new file mode 100644 index 00000000..e75cc10c Binary files /dev/null and b/schematics/smallHiddenTowerO.schematic differ diff --git a/schematics/smallMaze1.schematic b/schematics/smallMaze1.schematic new file mode 100644 index 00000000..c32d95f1 Binary files /dev/null and b/schematics/smallMaze1.schematic differ diff --git a/schematics/smallMultilevelMaze.schematic b/schematics/smallMultilevelMaze.schematic new file mode 100644 index 00000000..5866b055 Binary files /dev/null and b/schematics/smallMultilevelMaze.schematic differ diff --git a/schematics/smallPond.schematic b/schematics/smallPond.schematic new file mode 100644 index 00000000..ccb790a5 Binary files /dev/null and b/schematics/smallPond.schematic differ diff --git a/schematics/smallRotundaWithExit.schematic b/schematics/smallRotundaWithExit.schematic new file mode 100644 index 00000000..56deba25 Binary files /dev/null and b/schematics/smallRotundaWithExit.schematic differ diff --git a/schematics/smallSilverfishRoom.schematic b/schematics/smallSilverfishRoom.schematic new file mode 100644 index 00000000..46ddfda5 Binary files /dev/null and b/schematics/smallSilverfishRoom.schematic differ diff --git a/schematics/smallSimpleLeft.schematic b/schematics/smallSimpleLeft.schematic new file mode 100644 index 00000000..5a9d50a5 Binary files /dev/null and b/schematics/smallSimpleLeft.schematic differ diff --git a/schematics/smallSimpleRight.schematic b/schematics/smallSimpleRight.schematic new file mode 100644 index 00000000..3aedb166 Binary files /dev/null and b/schematics/smallSimpleRight.schematic differ diff --git a/schematics/tntTrapO.schematic b/schematics/tntTrapO.schematic new file mode 100644 index 00000000..5d0d4240 Binary files /dev/null and b/schematics/tntTrapO.schematic differ diff --git a/schematics/wallFallcomboPistonHall.schematic b/schematics/wallFallcomboPistonHall.schematic new file mode 100644 index 00000000..d2d9453e Binary files /dev/null and b/schematics/wallFallcomboPistonHall.schematic differ