package d2vector import ( "fmt" "math" "github.com/OpenDiablo2/OpenDiablo2/d2common/d2math" ) // Vector is an implementation of a Euclidean vector using float64 with common vector convenience methods. type Vector struct { x, y float64 } const two float64 = 2 // NewVector creates a new Vector with the given x and y values. func NewVector(x, y float64) *Vector { return &Vector{x, y} } // X returns the x value of this vector. func (v *Vector) X() float64 { return v.x } // Y returns the y value of this vector. func (v *Vector) Y() float64 { return v.y } // Equals returns true if the float64 values of this vector are exactly equal to the given Vector. func (v *Vector) Equals(o *Vector) bool { return v.x == o.x && v.y == o.y } // EqualsApprox returns true if the values of this Vector are approximately equal to those of the given Vector. If the // difference between either of the value pairs is smaller than d2math.Epsilon, they will be considered equal. func (v *Vector) EqualsApprox(o *Vector) bool { return d2math.EqualsApprox(v.x, o.x) && d2math.EqualsApprox(v.y, o.y) } // CompareApprox returns 2 ints describing the difference between the vectors. If the difference between either of the // value pairs is smaller than d2math.Epsilon, they will be considered equal. func (v *Vector) CompareApprox(o *Vector) (x, y int) { return d2math.CompareApprox(v.x, o.x), d2math.CompareApprox(v.y, o.y) } // IsZero returns true if this vector's values are both exactly zero. func (v *Vector) IsZero() bool { return v.x == 0 && v.y == 0 } // Set the vector values to the given float64 values. func (v *Vector) Set(x, y float64) *Vector { v.x = x v.y = y return v } // Clone returns a new a copy of this Vector. func (v *Vector) Clone() *Vector { return NewVector(v.x, v.y) } // Copy sets this vector's values to those of the given vector. func (v *Vector) Copy(o *Vector) *Vector { v.x = o.x v.y = o.y return v } // Floor rounds the vector down to the nearest whole numbers. func (v *Vector) Floor() *Vector { v.x = math.Floor(v.x) v.y = math.Floor(v.y) return v } // Clamp limits the values of v to those of a and b. If the values of v are between those of a and b they will be // unchanged. func (v *Vector) Clamp(a, b *Vector) *Vector { v.x = d2math.Clamp(v.x, a.x, b.x) v.y = d2math.Clamp(v.y, a.y, b.y) return v } // Add the given vector to this vector. func (v *Vector) Add(o *Vector) *Vector { v.x += o.x v.y += o.y return v } // AddScalar the given value to both values of this vector. func (v *Vector) AddScalar(s float64) *Vector { v.x += s v.y += s return v } // Subtract the given vector from this vector. func (v *Vector) Subtract(o *Vector) *Vector { v.x -= o.x v.y -= o.y return v } // Multiply this Vector by the given Vector. func (v *Vector) Multiply(o *Vector) *Vector { v.x *= o.x v.y *= o.y return v } // Scale multiplies both values of this vector by a single given value. func (v *Vector) Scale(s float64) *Vector { v.x *= s v.y *= s return v } // Divide this vector by the given vector. func (v *Vector) Divide(o *Vector) *Vector { v.x /= o.x v.y /= o.y return v } // DivideScalar divides both values of this vector by the given value. func (v *Vector) DivideScalar(s float64) *Vector { v.x /= s v.y /= s return v } // Abs sets the vector to it's absolute (positive) equivalent. func (v *Vector) Abs() *Vector { if v.x < 0 { v.x = -v.x } if v.y < 0 { v.y = -v.y } return v } // Negate multiplies this vector by -1. func (v *Vector) Negate() *Vector { return v.Scale(-1) } // Distance between this Vector's position and that of the given Vector. func (v *Vector) Distance(o *Vector) float64 { delta := o.Clone() delta.Subtract(v) return delta.Length() } // Length (magnitude/quantity) of this Vector. func (v *Vector) Length() float64 { return math.Sqrt(v.Dot(v)) } // SetLength sets the length of this Vector without changing the direction. The length will be exact within // d2math.Epsilon. func (v *Vector) SetLength(length float64) *Vector { v.Normalize() v.Scale(length) return v } // Lerp sets this vector to the linear interpolation between this and the given vector. The interp argument determines // the distance between the two vectors. An interp of 0 will return this vector and 1 will return the given vector. func (v *Vector) Lerp(o *Vector, interp float64) *Vector { v.x = d2math.Lerp(v.x, o.x, interp) v.y = d2math.Lerp(v.y, o.y, interp) return v } // Dot returns the dot product of this Vector and the given Vector. func (v *Vector) Dot(o *Vector) float64 { return v.x*o.x + v.y*o.y } // Cross returns the cross product of this Vector and the given Vector. Note: Cross product is specific to 3D space. // This a not cross product. It is the Z component of a 3D vector cross product calculation. The X and Y components use // the value of z which doesn't exist in 2D. See: // https://stackoverflow.com/questions/243945/calculating-a-2d-vectors-cross-product // // The sign of Cross indicates whether the direction between the points described by vectors v and o around the origin // (0,0) moves clockwise or anti-clockwise. The perspective is from the would-be position of positive Z and the // direction is from v to o. // // Negative = clockwise // Positive = anti-clockwise // 0 = vectors are identical. func (v *Vector) Cross(o *Vector) float64 { return v.x*o.y - v.y*o.x } // Normalize sets the vector length to 1 without changing the direction. The normalized vector may be scaled by the // float64 return value to restore it's original length. func (v *Vector) Normalize() *Vector { if v.IsZero() { return v } v.Scale(1 / v.Length()) return v } // Angle computes the unsigned angle in radians from this vector to the given vector. This angle will never exceed half // a full circle. For angles describing a full circumference use SignedAngle. func (v *Vector) Angle(o *Vector) float64 { if v.IsZero() || o.IsZero() { return 0 } from := v.Clone() from.Normalize() to := o.Clone() to.Normalize() denominator := math.Sqrt(from.Length() * to.Length()) dotClamped := d2math.Clamp(from.Dot(to)/denominator, -1, 1) return math.Acos(dotClamped) } // SignedAngle computes the signed (clockwise) angle in radians from this vector to the given vector. func (v *Vector) SignedAngle(o *Vector) float64 { unsigned := v.Angle(o) sign := d2math.Sign(v.x*o.y - v.y*o.x) if sign > 0 { return d2math.RadFull - unsigned } return unsigned } // Reflect sets this Vector to it's reflection off a line defined by the given normal. The result will be exact within // d2math.Epsilon. func (v *Vector) Reflect(normal *Vector) *Vector { normal.Normalize() v.Normalize() // 1*Dot is the directional (ignoring length) difference between the vector and the normal. Therefore 2*Dot takes // us beyond the normal to the angle with the equivalent distance in the other direction i.e. the reflection. normal.Scale(two * v.Dot(normal)) v.Subtract(normal) return v } // ReflectSurface does the same thing as Reflect, except the given vector describes the surface line, not it's normal. func (v *Vector) ReflectSurface(surface *Vector) *Vector { v.Reflect(surface).Negate() return v } // Rotate moves the vector around it's origin clockwise, by the given angle in radians. The result will be exact within // d2math.Epsilon. See d2math.EqualsApprox. func (v *Vector) Rotate(angle float64) *Vector { a := -angle x := v.x*math.Cos(a) - v.y*math.Sin(a) y := v.x*math.Sin(a) + v.y*math.Cos(a) v.x = x v.y = y return v } // NinetyAnti rotates this vector by 90 degrees anti-clockwise. func (v *Vector) NinetyAnti() *Vector { x := v.x v.x = v.y * -1 v.y = x return v } // NinetyClock rotates this vector by 90 degrees clockwise. func (v *Vector) NinetyClock() *Vector { y := v.y v.y = v.x * -1 v.x = y return v } func (v Vector) String() string { return fmt.Sprintf("Vector{%.3f, %.3f}", v.x, v.y) } // VectorUp returns a new vector (0, 1) func VectorUp() *Vector { return NewVector(0, 1) } // VectorDown returns a new vector (0, -1) func VectorDown() *Vector { return NewVector(0, -1) } // VectorRight returns a new vector (1, 0) func VectorRight() *Vector { return NewVector(1, 0) } // VectorLeft returns a new vector (-1, 0) func VectorLeft() *Vector { return NewVector(-1, 0) } // VectorOne returns a new vector (1, 1) func VectorOne() *Vector { return NewVector(1, 1) } // VectorZero returns a new vector (0, 0) func VectorZero() *Vector { return NewVector(0, 0) }