Added Vector class.

2 files changed, 356 insertions, 0 deletions

diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
index 69329cd3..cb4ba1ce 100644
--- a/src/main/java/org/bukkit/Location.java
+++ b/src/main/java/org/bukkit/Location.java
@@ -179,6 +179,10 @@ public class Location implements Cloneable {
     public String toString() {
         return "Location{" + "world=" + world + "x=" + x + "y=" + y + "z=" + z + "pitch=" + pitch + "yaw=" + yaw + '}';
     }
+    
+    public Vector toVector() {
+        return new Vector(x, y, z);
+    }
 
     @Override
     protected Location clone() {
diff --git a/src/main/java/org/bukkit/Vector.java b/src/main/java/org/bukkit/Vector.java
new file mode 100644
index 00000000..dc319b10
--- /dev/null
+++ b/src/main/java/org/bukkit/Vector.java
@@ -0,0 +1,352 @@
+package org.bukkit;

+

+/**

+ * Represents a mutable vector.

+ * 

+ * @author sk89q

+ */

+public class Vector implements Cloneable {

+    private static final long serialVersionUID = -2657651106777219169L;

+    

+    private double x;

+    private double y;

+    private double z;

+    

+    public Vector(int x, int y, int z) {

+        this.x = x;

+        this.y = y;

+        this.z = z;

+    }

+    

+    public Vector(double x, double y, double z) {

+        this.x = x;

+        this.y = y;

+        this.z = z;

+    }

+    

+    public Vector(float x, float y, float z) {

+        this.x = x;

+        this.y = y;

+        this.z = z;

+    }

+

+    /**

+     * Adds the vector by another.

+     * 

+     * @param vec

+     * @return the same vector

+     */

+    public Vector add(Vector vec) {

+        x += vec.x;

+        y += vec.y;

+        z += vec.z;

+        return this;

+    }

+

+    /**

+     * Subtracts the vector by another.

+     * 

+     * @param vec

+     * @return the same vector

+     */

+    public Vector subtract(Vector vec) {

+        x -= vec.x;

+        y -= vec.y;

+        z -= vec.z;

+        return this;

+    }

+

+    /**

+     * Multiplies the vector by another.

+     * 

+     * @param vec

+     * @return the same vector

+     */

+    public Vector multiply(Vector vec) {

+        x *= vec.x;

+        y *= vec.y;

+        z *= vec.z;

+        return this;

+    }

+    

+    /**

+     * Divides the vector by another.

+     * 

+     * @param vec

+     * @return the same vector

+     */

+    public Vector divide(Vector vec) {

+        x /= vec.x;

+        y /= vec.y;

+        z /= vec.z;

+        return this;

+    }

+    

+    /**

+     * Gets the magnitude of the vector, defined as sqrt(x^2+y^2+z^2). The value

+     * of this method is not cached and uses a costly square-root function, so

+     * do not repeatedly call this method to get the vector's magnitude.

+     * 

+     * @return the magnitude

+     */

+    public double length() {

+        return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2) + Math.pow(z, 2));

+    }

+    

+    /**

+     * Get the distance between this vector and another.  The value

+     * of this method is not cached and uses a costly square-root function, so

+     * do not repeatedly call this method to get the vector's magnitude.

+     * 

+     * @return the distance

+     */

+    public double distance(Vector o) {

+        return Math.sqrt(Math.pow(x - o.x, 2) + Math.pow(y - o.y, 2)

+                + Math.pow(z - o.z, 2));

+    }

+    

+    /**

+     * Performs scalar multiplication, multiplying all components with a scalar.

+     * 

+     * @param m

+     * @return the same vector

+     */

+    public Vector multiply(int m) {

+        x *= m;

+        y *= m;

+        z *= m;

+        return this;

+    }

+    

+    /**

+     * Performs scalar multiplication, multiplying all components with a scalar.

+     * 

+     * @param m

+     * @return the same vector

+     */

+    public Vector multiply(double m) {

+        x *= m;

+        y *= m;

+        z *= m;

+        return this;

+    }

+    

+    /**

+     * Performs scalar multiplication, multiplying all components with a scalar.

+     * 

+     * @param m

+     * @return the same vector

+     */

+    public Vector multiply(float m) {

+        x *= m;

+        y *= m;

+        z *= m;

+        return this;

+    }

+    

+    /**

+     * Calculates the dot product of this vector with another. The dot product

+     * is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar.

+     * 

+     * @param other

+     * @return dot product

+     */

+    public double getDotProduct(Vector other) {

+        return x * other.x + y * other.y + z * other.z;

+    }

+    

+    /**

+     * Calculates the cross product of this vector with another. The cross

+     * product is defined as:

+     * 

+     * x = y1 * z2 - y2 * z1<br/>

+     * y = z1 * x2 - z2 * x1<br/>

+     * z = x1 * y2 - x2 * y1

+     * 

+     * @param o

+     * @return the same vector

+     */

+    public Vector crossProduct(Vector o) {

+        double newX = y * o.z - o.y * z;

+        double newY = z * o.x - o.z * x;

+        double newZ = x * o.y - o.x * y;

+        x = newX;

+        y = newY;

+        z = newZ;

+        return this;

+    }

+    

+    /**

+     * Converts this vector to a unit vector (a vector with length of 1).

+     * 

+     * @return the same vector

+     */

+    public Vector unitVector() {

+        double length = length();

+        

+        x /= length;

+        y /= length;

+        z /= length;

+        

+        return this;

+    }

+    

+    /**

+     * Gets a unit vector of this vector. This vector will not be chagned.

+     * 

+     * @return a brand new vector

+     */

+    public Vector getUnitVector() {

+        double length = length();

+        return new Vector(x / length, y / length, z / length);

+    }

+    

+    /**

+     * Returns whether this vector is in a cuboid. The minimum and maximum

+     * vectors given must be truly the minimum and maximum X, Y and Z

+     * components.

+     * 

+     * @param min

+     * @param max

+     * @return whether this vector is in the cuboid

+     */

+    public boolean isInCuboid(Vector min, Vector max) {

+        return x >= min.x && x <= max.x

+                && y >= min.y && y <= max.y

+                && z >= min.z && z <= max.z;

+    }

+    

+    /**

+     * Returns whether this vector is within a sphere.

+     * 

+     * @param origin

+     * @param radius

+     * @return whether this vector is in the sphere

+     */

+    public boolean isInSphere(Vector origin, double radius) {

+        return origin.clone().subtract(this).length() <= radius;

+    }

+    

+    public double getX() {

+        return x;

+    }

+    

+    public double getY() {

+        return y;

+    }

+    

+    public double getZ() {

+        return z;

+    }

+    

+    public Vector setX(int x) {

+        this.x = x;

+        return this;

+    }

+    

+    public Vector setX(double x) {

+        this.x = x;

+        return this;

+    }

+    

+    public Vector setX(float x) {

+        this.x = x;

+        return this;

+    }

+    

+    public Vector setY(int y) {

+        this.y = y;

+        return this;

+    }

+    

+    public Vector setY(double y) {

+        this.y = y;

+        return this;

+    }

+    

+    public Vector setY(float y) {

+        this.y = y;

+        return this;

+    }

+    

+    public Vector setZ(int z) {

+        this.z = z;

+        return this;

+    }

+    

+    public Vector setZ(double z) {

+        this.z = z;

+        return this;

+    }

+    

+    public Vector setZ(float z) {

+        this.z = z;

+        return this;

+    }

+

+    @Override

+    public boolean equals(Object obj) {

+        if (!(obj instanceof Vector)) {

+            return false;

+        }

+        

+        Vector other = (Vector)obj;

+        

+        return Double.doubleToLongBits(x) == Double.doubleToLongBits(other.x)

+            && Double.doubleToLongBits(y) == Double.doubleToLongBits(other.y)

+            && Double.doubleToLongBits(z) == Double.doubleToLongBits(other.z);

+    }

+

+    @Override

+    public int hashCode() {

+        return ((int)Double.doubleToLongBits(x) >> 13) ^

+                ((int)Double.doubleToLongBits(y) >> 7) ^

+                (int)Double.doubleToLongBits(z);

+    }

+

+    @Override

+    public Vector clone() {

+        return new Vector(x, y, z);

+    }

+

+    @Override

+    public String toString() {

+        return x + "," + y + "," + z;

+    }

+    

+    public Location toLocation(World world) {

+        return new Location(world, x, y, z);

+    }

+    

+    public Location toLocation(World world, float yaw, float pitch) {

+        return new Location(world, x, y, z, yaw, pitch);

+    }

+    

+    /**

+     * Gets the minimum components of two vectors.

+     * 

+     * @param v1

+     * @param v2

+     * @return minimum

+     */

+    public static Vector getMinimum(Vector v1, Vector v2) {

+        return new Vector(

+                Math.min(v1.x, v2.x),

+                Math.min(v1.y, v2.y),

+                Math.min(v1.z, v2.z));

+    }

+    

+    /**

+     * Gets the maximum components of two vectors.

+     * 

+     * @param v1

+     * @param v2

+     * @return maximum

+     */

+    public static Vector getMaximum(Vector v1, Vector v2) {

+        return new Vector(

+                Math.max(v1.x, v2.x),

+                Math.max(v1.y, v2.y),

+                Math.max(v1.z, v2.z));

+    }

+}