HeadingVector.cs

Go to the documentation of this file.

#region #Usings

using System;
using Pirates;

#endregion

namespace Britbot
{
    public class HeadingVector
    {
        #region Fields & Properies

        public double X { get; private set; }

        public double Y { get; private set; }

        #endregion

        #region Constructors & Initializers

        public HeadingVector(Direction d = Direction.NOTHING)
        {
            switch (d)
            {
                case Direction.NORTH:
                    X = 0;
                    Y = -1;
                    break;
                case Direction.EAST:
                    X = 1;
                    Y = 0;
                    break;
                case Direction.SOUTH:
                    X = 0;
                    Y = 1;
                    break;
                case Direction.WEST:
                    X = -1;
                    Y = 0;
                    break;
                default:
                    X = 0;
                    Y = 0;
                    break;
            }
        }

        public HeadingVector(HeadingVector toCopy)
        {
            this.X = toCopy.X;
            this.Y = toCopy.Y;
        }

        public HeadingVector(double x, double y)
        {
            this.X = x;
            this.Y = y;
        }

        #endregion

        public override int GetHashCode()
        {
            unchecked
            {
                return (this.X.GetHashCode() * 397) ^ this.Y.GetHashCode();
            }
        }

        public void SetCoordinates(double x = 0, double y = 0)
        {
            this.X = x;
            this.Y = y;
        }

        public void SetCoordinates(HeadingVector hv)
        {
            this.X = hv.X;
            this.Y = hv.Y;
        }

        public static double operator *(HeadingVector hv1, HeadingVector hv2)
        {
            return hv1.X * hv2.X + hv1.Y * hv2.Y;
        }

        public static HeadingVector adjustHeading(HeadingVector hv1, HeadingVector hv2)
        {
            //defining the result
            HeadingVector newHv = new HeadingVector(hv1);


            //if dot product is negative it means that the angle is bigger
            // then 90 so it implies change in direction: reset count
            //otherwise normal vector addition
            //WOW math is useful
            //I thought you HATED the applied math department
            if (hv1 * hv2 < 0)
            {
                newHv = hv2;
            } //also check that new direction isn't nothing
            else if (hv2.Norm() == 0)
            {
                newHv = hv2;
            }
            else
            {
                newHv.X += hv2.X;
                newHv.Y += hv2.Y;
            }
            //return the new heading vector
            return newHv;
        }

        public static HeadingVector adjustHeading(HeadingVector hv1, Direction dir)
        {
            return HeadingVector.adjustHeading(hv1, new HeadingVector(dir));
        }

        public HeadingVector adjustHeading(HeadingVector Dir)
        {
            //just use the existing function
            this.SetCoordinates(HeadingVector.adjustHeading(this, Dir));

            //return this for a+b+c calculations
            return this;
        }

        public HeadingVector adjustHeading(Direction Dir)
        {
            //just use the existing function
            this.SetCoordinates(HeadingVector.adjustHeading(this, new HeadingVector(Dir)));

            //return this for a+b+c calculations
            return this;
        }

        public static HeadingVector CalcDifference(Location source, Location target)
        {
            //assigning new variable
            return new HeadingVector(target.Col - source.Col, target.Row - source.Row);
        }

        public static Location AddvanceByVector(Location loc, HeadingVector hv)
        {
            //calculate new col
            int col = loc.Col + (int) hv.X;
            int row = loc.Row + (int) hv.Y;

            //check if out of boundries
            //first check negative valuse
            col = Math.Max(col, 0);
            row = Math.Max(row, 0);

            //check to big boundries
            col = Math.Min(col, Bot.Game.GetCols() - 1);
            row = Math.Min(row, Bot.Game.GetRows() - 1);

            //return new location
            return new Location(row, col);
        }

        public HeadingVector Orthogonal()
        {
            //like multiplying by -1
            return new HeadingVector {X = this.Y, Y = -this.X};
        }

        //------------NORMS------------

        public double NormSquared()
        {
            return X * X + Y * Y;
        }

        public double Norm()
        {
            return Math.Sqrt(NormSquared());
        }

        public HeadingVector Normalize()
        {
            return (1 / this.Norm()) * this;
        }

        public double Norm1()
        {
            return Math.Abs(X) + Math.Abs(Y);
        }

        public override string ToString()
        {
            return "(" + X + ", " + Y + ")";
        }

        protected bool Equals(HeadingVector other)
        {
            return X == other.X && Y == other.Y;
        }

        public override bool Equals(object obj)
        {
            if (object.ReferenceEquals(null, obj))
                return false;
            if (object.ReferenceEquals(this, obj))
                return true;
            if (obj.GetType() != this.GetType())
                return false;
            return Equals((HeadingVector) obj);
        }

        public static bool operator ==(HeadingVector hv1, HeadingVector hv2)
        {
            return hv1.X == hv2.X && hv1.Y == hv2.Y;
        }

        public static bool operator !=(HeadingVector hv1, HeadingVector hv2)
        {
            return !(hv1 == hv2);
        }

        public static HeadingVector operator +(HeadingVector hv1, HeadingVector hv2)
        {
            //defining the result
            HeadingVector newHv = new HeadingVector(hv1);

            //adding up
            newHv.X += hv2.X;
            newHv.Y += hv2.Y;

            return newHv;
        }

        public static HeadingVector operator -(HeadingVector hv1, HeadingVector hv2)
        {
            //defining the result
            HeadingVector newHv = new HeadingVector(hv1);

            //Substraction
            newHv.X -= hv2.X;
            newHv.Y -= hv2.Y;

            return newHv;
        }

        public static HeadingVector operator *(double scalar, HeadingVector hv)
        {
            //defining the result
            HeadingVector newHv = new HeadingVector(scalar * hv.X, scalar * hv.Y);

            return newHv;
        }
    }
}