diff --git a/src/main/java/mekanism/api/Coord4D.java b/src/main/java/mekanism/api/Coord4D.java index 388fb4e4f..1a0f7e4d5 100644 --- a/src/main/java/mekanism/api/Coord4D.java +++ b/src/main/java/mekanism/api/Coord4D.java @@ -1,7 +1,7 @@ package mekanism.api; -import java.util.ArrayList; - +import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint; +import io.netty.buffer.ByteBuf; import net.minecraft.block.Block; import net.minecraft.entity.Entity; import net.minecraft.init.Blocks; @@ -15,9 +15,8 @@ import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraft.world.chunk.Chunk; import net.minecraftforge.common.util.ForgeDirection; -import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint; -import io.netty.buffer.ByteBuf; +import java.util.ArrayList; /** * Coord4D - an integer-based way to keep track of and perform operations on blocks in a Minecraft-based environment. This also takes @@ -178,6 +177,18 @@ public class Coord4D return this; } + + /** + * Translates this Coord4D by the defined Coord4D's coordinates, regardless of dimension. + * @param coord - coordinates to translate by + * @return translated Coord4D + */ + public Coord4D translate(Coord4D coord) + { + translate(coord.xCoord, coord.yCoord, coord.zCoord); + + return this; + } /** * Creates and returns a new Coord4D translated to the defined offsets of the side. diff --git a/src/main/java/mekanism/api/Pos3D.java b/src/main/java/mekanism/api/Pos3D.java index 1e22afcdd..75f83a048 100644 --- a/src/main/java/mekanism/api/Pos3D.java +++ b/src/main/java/mekanism/api/Pos3D.java @@ -1,9 +1,11 @@ package mekanism.api; import net.minecraft.entity.Entity; +import net.minecraft.nbt.NBTTagCompound; 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.minecraftforge.common.util.ForgeDirection; @@ -29,6 +31,13 @@ public class Pos3D yPos = vec.yCoord; zPos = vec.zCoord; } + + public Pos3D(MovingObjectPosition mop) + { + xPos = mop.blockX; + yPos = mop.blockY; + zPos = mop.blockZ; + } public Pos3D(double x, double y, double z) { @@ -61,6 +70,30 @@ public class Pos3D { this(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); } + + /** + * Returns a new Pos3D from a tag compound. + * @param tag - tag compound to read from + * @return the Pos3D from the tag compound + */ + public static Pos3D read(NBTTagCompound tag) + { + return new Pos3D(tag.getDouble("x"), tag.getDouble("y"), tag.getDouble("z")); + } + + /** + * Writes this Pos3D's data to an NBTTagCompound. + * @param nbtTags - tag compound to write to + * @return the tag compound with this Pos3D's data + */ + public NBTTagCompound write(NBTTagCompound nbtTags) + { + nbtTags.setDouble("x", xPos); + nbtTags.setDouble("y", yPos); + nbtTags.setDouble("z", zPos); + + return nbtTags; + } /** * Creates and returns a Pos3D with values representing the difference between this and the Pos3D in the parameters. @@ -75,13 +108,23 @@ public class Pos3D /** * Creates a new Pos3D from the motion of an entity. * @param entity - * @return + * @return Pos3D representing the motion of the given entity */ public static Pos3D fromMotion(Entity entity) { return new Pos3D(entity.motionX, entity.motionY, entity.motionZ); } + /** + * Creates a new Coord4D representing this Pos3D in the provided dimension. + * @param dimensionId - the dimension this Pos3D is in + * @return Coord4D representing this Pos3D + */ + public Coord4D getCoord(int dimensionId) + { + return new Coord4D((int)xPos, (int)yPos, (int)zPos, dimensionId); + } + /** * Centres a block-derived Pos3D */ @@ -188,19 +231,25 @@ public class Pos3D public Pos3D rotate(double yaw, double pitch) { - double yawRadians = Math.toRadians(yaw); - double pitchRadians = Math.toRadians(pitch); - - double x = xPos; - double y = yPos; - double z = zPos; - - xPos = x * Math.cos(yawRadians) - z * Math.sin(yawRadians); - yPos = y * Math.cos(pitchRadians) - z * Math.sin(pitchRadians); - zPos = (z * Math.cos(yawRadians) + x * Math.sin(yawRadians)) * (z * Math.cos(pitchRadians) + y * Math.sin(pitchRadians)); - - return this; + return rotate(yaw, pitch, 0); } + + public Pos3D rotate(double yaw, double pitch, double roll) + { + double yawRadians = Math.toRadians(yaw); + double pitchRadians = Math.toRadians(pitch); + double rollRadians = Math.toRadians(roll); + + double x = xPos; + double y = yPos; + double z = zPos; + + xPos = x * Math.cos(yawRadians) * Math.cos(pitchRadians) + z * (Math.cos(yawRadians) * Math.sin(pitchRadians) * Math.sin(rollRadians) - Math.sin(yawRadians) * Math.cos(rollRadians)) + y * (Math.cos(yawRadians) * Math.sin(pitchRadians) * Math.cos(rollRadians) + Math.sin(yawRadians) * Math.sin(rollRadians)); + zPos = x * Math.sin(yawRadians) * Math.cos(pitchRadians) + z * (Math.sin(yawRadians) * Math.sin(pitchRadians) * Math.sin(rollRadians) + Math.cos(yawRadians) * Math.cos(rollRadians)) + y * (Math.sin(yawRadians) * Math.sin(pitchRadians) * Math.cos(rollRadians) - Math.cos(yawRadians) * Math.sin(rollRadians)); + yPos = -x * Math.sin(pitchRadians) + z * Math.cos(pitchRadians) * Math.sin(rollRadians) + y * Math.cos(pitchRadians) * Math.cos(rollRadians); + + return this; + } public Pos3D multiply(Pos3D pos) { @@ -236,6 +285,133 @@ public class Pos3D { return scale(scale, scale, scale); } + + public Pos3D rotate(float angle, Pos3D axis) + { + return translateMatrix(getRotationMatrix(angle, axis), this); + } + + public double[] getRotationMatrix(float angle) + { + double[] matrix = new double[16]; + Pos3D axis = clone().normalize(); + + double x = axis.xPos; + double y = axis.yPos; + double z = axis.zPos; + + angle *= 0.0174532925D; + + float cos = (float)Math.cos(angle); + float ocos = 1.0F - cos; + float sin = (float)Math.sin(angle); + + matrix[0] = (x * x * ocos + cos); + matrix[1] = (y * x * ocos + z * sin); + matrix[2] = (x * z * ocos - y * sin); + matrix[4] = (x * y * ocos - z * sin); + matrix[5] = (y * y * ocos + cos); + matrix[6] = (y * z * ocos + x * sin); + matrix[8] = (x * z * ocos + y * sin); + matrix[9] = (y * z * ocos - x * sin); + matrix[10] = (z * z * ocos + cos); + matrix[15] = 1.0F; + + return matrix; + } + + public static Pos3D translateMatrix(double[] matrix, Pos3D translation) + { + double x = translation.xPos * matrix[0] + translation.yPos * matrix[1] + translation.zPos * matrix[2] + matrix[3]; + double y = translation.xPos * matrix[4] + translation.yPos * matrix[5] + translation.zPos * matrix[6] + matrix[7]; + double z = translation.xPos * matrix[8] + translation.yPos * matrix[9] + translation.zPos * matrix[10] + matrix[11]; + + translation.xPos = x; + translation.yPos = y; + translation.zPos = z; + + return translation; + } + + public static double[] getRotationMatrix(float angle, Pos3D axis) + { + return axis.getRotationMatrix(angle); + } + + public double anglePreNorm(Pos3D pos2) + { + return Math.acos(dotProduct(pos2)); + } + + public static double anglePreNorm(Pos3D pos1, Pos3D pos2) + { + return Math.acos(pos1.clone().dotProduct(pos2)); + } + + public double dotProduct(Pos3D pos) + { + return xPos * pos.xPos + yPos * pos.yPos + zPos * pos.zPos; + } + + public Pos3D crossProduct(Pos3D compare) + { + return clone().toCrossProduct(compare); + } + + public Pos3D toCrossProduct(Pos3D compare) + { + double newX = yPos * compare.zPos - zPos * compare.yPos; + double newY = zPos * compare.xPos - xPos * compare.zPos; + double newZ = xPos * compare.yPos - yPos * compare.xPos; + + xPos = newX; + yPos = newY; + zPos = newZ; + + return this; + } + + public Pos3D xCrossProduct() + { + return new Pos3D(0.0D, zPos, -yPos); + } + + public Pos3D zCrossProduct() + { + return new Pos3D(-yPos, xPos, 0.0D); + } + + public Pos3D getPerpendicular() + { + if(zPos == 0) + { + return zCrossProduct(); + } + + return xCrossProduct(); + } + + public Pos3D floor() + { + return new Pos3D(Math.floor(xPos), Math.floor(yPos), Math.floor(zPos)); + } + + public double getMagnitude() + { + return Math.sqrt(xPos * xPos + yPos * yPos + zPos * zPos); + } + + public Pos3D normalize() + { + double d = getMagnitude(); + + if (d != 0) + { + this.scale(1 / d); + } + + return this; + } public static AxisAlignedBB getAABB(Pos3D pos1, Pos3D pos2) { diff --git a/src/main/java/mekanism/common/inventory/container/ContainerNull.java b/src/main/java/mekanism/common/inventory/container/ContainerNull.java index fcb31a793..ec45c9280 100644 --- a/src/main/java/mekanism/common/inventory/container/ContainerNull.java +++ b/src/main/java/mekanism/common/inventory/container/ContainerNull.java @@ -13,8 +13,16 @@ public class ContainerNull extends Container { tileEntity = tile; - tileEntity.open(player); - tileEntity.openInventory(); + if(tileEntity != null) + { + tileEntity.open(player); + tileEntity.openInventory(); + } + } + + public ContainerNull(TileEntityContainerBlock tile) + { + tileEntity = tile; } public ContainerNull() {} diff --git a/src/main/java/mekanism/common/inventory/slot/SlotSpecific.java b/src/main/java/mekanism/common/inventory/slot/SlotSpecific.java new file mode 100644 index 000000000..c516f3f84 --- /dev/null +++ b/src/main/java/mekanism/common/inventory/slot/SlotSpecific.java @@ -0,0 +1,24 @@ +package mekanism.common.inventory.slot; + +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class SlotSpecific extends Slot +{ + private Class itemClass; + + public SlotSpecific(IInventory inventory, int index, int x, int y, Class c) + { + super(inventory, index, x, y); + + itemClass = c; + } + + @Override + public boolean isItemValid(ItemStack itemstack) + { + return itemClass.equals(itemstack.getItem().getClass()) || itemClass.isInstance(itemstack.getItem()); + } +}