Node.cs

Go to the documentation of this file.

#region #Usings

using System;
using System.Collections.Generic;
using Britbot.PriorityQueue;
using Pirates;

#endregion

namespace Britbot
{
    internal static partial class Navigator
    {
        #region Fields & Properies

        internal class Node : PriorityQueueNode
        {
            #region Static Fields & Consts

            public const double Infinity = 100;

            public static Node[,] Map = new Node[Bot.Game.GetRows(), Bot.Game.GetCols()];

            #endregion

            #region Fields & Properies

            public double G;

            public double H;

            public bool IsEvaluated;

            public Location Loc;

            public double Weight;

            #endregion

            #region Constructors & Initializers

            static Node()
            {
                for (int y = 0; y < Node.Map.GetLength(0); y++)
                {
                    for (int x = 0; x < Node.Map.GetLength(1); x++)
                    {
                        Node.Map[y, x] = new Node();

                        //set locations
                        Node.Map[y, x].Loc = new Location(y, x);
                    }
                }
            }

            #endregion

            public static void UpdateMap(Group group)
            {
                //reading board size
                int cols = Bot.Game.GetCols();
                int rows = Bot.Game.GetRows();

                //get the radius of the group

                //go over the entire map, set locations and their wight
                for (int x = 0; x < cols; x++)
                {
                    for (int y = 0; y < rows; y++)
                    {
                        //check if this is passable
                        //if (!Bot.Game.IsPassableEnough(Node.Map[y, x].Loc, groupRadius))
                        if (!Bot.Game.IsPassableEnough(Node.Map[y, x].Loc, group))
                        {
                            //set the weight of the node to "infinity"
                            Node.Map[y, x].Weight = Node.Infinity;

                            //if so then we are finished here, move to next Node
                            continue;
                        }

                        // Node.Map[y, x].Weight = Node.CalcEnemyFactor(Node.Map[y, x].Loc, groupStrength);
                        Node.Map[y, x].Weight = 1;
                        //now set the wight based on enemyGroups
                        //double enemyFactor = Node.CalcEnemyFactor(Node.Map[y, x].Loc, groupStrength);
                    }
                }
                //update enemy threat

                Node.CalculateEnemyWeight(group.FightCount());

                //TODO: update also friendly location
            }

            public static void CalculateEnemyWeight(int strength)
            {
                Logger.BeginTime("CalculateEnemyWeight");
                //---------------#Magic_Numbers--------------------
                //Important constants of the functions
                //the radious under wich to define locations in danget of enemy groups
                //the higher it is, the performence are worse
                //int DangerRadious = 9 * Bot.Game.GetAttackRadius();

                //going over enemy fleets and giving their location negative scores
                foreach (EnemyGroup eGroup in Enemy.Groups)
                {
                    if (eGroup.GetMaxFightPower() >= strength)
                    {
                        foreach (int p in eGroup.EnemyPirates)
                            Node.BlockLocation(Bot.Game.GetEnemyPirate(p).Loc, Magic.DangerZone, eGroup.GetHeading());
                    }
                }
                Logger.StopTime("CalculateEnemyWeight");
            }

            private static void BlockLocation(Location loc, double radSquared, HeadingVector heading)
            {
                //---------------#Magic_Numbers--------------------
                //important constants:
                //this determines how much we consider the heading of the danger, meaning how elipsy the 
                //danger zone will be
                const double headingFactor = 0.25;

                //reading some important parameters
                int rad = (int) Math.Sqrt(radSquared);
                int maxX = Bot.Game.GetCols() - 1;
                int maxY = Bot.Game.GetRows() - 1;

                //going over a square centered at loc
                for (int x = Math.Max(loc.Col - rad, 0); x <= Math.Min(loc.Col + rad, maxX); x++)
                {
                    for (int y = Math.Max(loc.Row - rad, 0); y <= Math.Min(loc.Row + rad, maxY); y++)
                    {
                        //the current location
                        Location currLoc = new Location(y, x);

                        //blocking stuff according to their radious and direction
                        HeadingVector diffVector = HeadingVector.CalcDifference(loc, currLoc);

                        //calculate the distance considering the heading of the danger
                        //if the current location is straight in the direction of the danger we add by proportion to headingFactor
                        //if it is in the opposite direction we subtract according to headingFactor
                        double distandeSquare = Bot.Game.EuclidianDistanceSquared(new Location(y, x), loc) +
                                                headingFactor * heading.Normalize() * diffVector;
                        if (distandeSquare <= radSquared)
                            Node.Map[y, x].Weight += Node.Infinity * (radSquared - distandeSquare) / radSquared;
                    }
                }
            }

            public static void SetUpCalculation(Location target)
            {
                Logger.BeginTime("SetUpCalculation");
                //going over all the cells in the Map updating their heuristic value to be 
                //distance from target
                for (int y = 0; y < Bot.Game.GetRows(); y++)
                {
                    for (int x = 0; x < Bot.Game.GetCols(); x++)
                    {
                        Node.Map[y, x].H = Node.HuristicFunction(Node.Map[y, x].Loc, target);

                        //set the calculated G parameter to -1
                        Node.Map[y, x].G = -1;

                        Node.Map[y, x].IsEvaluated = false;
                    }
                }
                Logger.StopTime("SetUpCalculation");
            }

            public static double HuristicFunction(Location loc1, Location loc2)
            {
                //if we chose euclidian huristic
                if (Magic.EuclidianHuristic)
                    return Bot.Game.EuclidianDistanceSquared(loc1, loc2);
                // Manhatten huristic
                return Bot.Game.Distance(loc1, loc2);
            }

            public static Node GetLocationNodeFromMap(Location loc)
            {
                return Node.Map[loc.Row, loc.Col];
            }

            public double F()
            {
                return (this.H + this.G);
            }

            public bool IsPassable()
            {
                return this.Weight < Node.Infinity;
            }

            public static void DebugPasses()
            {
                string line = "";
                for (int i = 0; i < Node.Map.GetLength(0); i++)
                {
                    for (int j = 0; j < Node.Map.GetLength(1); j++)
                    {
                        if (Node.Map[i, j].G == -1 && Node.Map[i, j].Weight < 3)
                            line += "*";
                        else if (Node.Map[i, j].H == 0)
                            line += "O";
                        else if (Node.Map[i, j].Weight >= 3)
                            line += "X";
                        else
                            line += "-";
                    }
                    Logger.Write(line);
                    line = "";
                }
            }

            public List<Node> GetNeighbors()
            {
                //allocating a new list
                List<Node> neighbors = new List<Node>();

                //array to help iterating over the four neighbors
                int[] coeff = {-1, 1};

                //read X and Y from this.loc
                int X = this.Loc.Col;
                int Y = this.Loc.Row;


                //going over neighbors
                for (int delata = 0; delata < 2; delata++)
                {
                    //get the iterated neighbor coordinates
                    int neighborX = X + coeff[delata];
                    int neighborY = Y;

                    //check if out of bounderie, if so, continue to next iteration
                    if ((neighborX < 0) || (neighborX >= Bot.Game.GetCols()) ||
                        (neighborY < 0) || (neighborY >= Bot.Game.GetRows()))
                        continue;

                    //check if impassable, if so, continue to next iteration
                    /*if (!Node.Map[neighborY, neighborX].IsPassable())
                        continue;*/

                    //if we are here it means that the neighbor is ok, so add him to the list
                    neighbors.Add(Node.Map[neighborY, neighborX]);
                }
                for (int delata = 0; delata < 2; delata++)
                {
                    //get the iterated neighbor coordinates
                    int neighborX = X;
                    int neighborY = Y + coeff[delata];

                    //check if out of bounderie, if so, continue to next iteration
                    if ((neighborX < 0) || (neighborX >= Bot.Game.GetCols()) ||
                        (neighborY < 0) || (neighborY >= Bot.Game.GetRows()))
                        continue;

                    //check if impassable, if so, continue to next iteration
                    /* if (!Node.Map[neighborY, neighborX].IsPassable())
                        continue;*/

                    //if we are here it means that the neighbor is ok, so add him to the list
                    neighbors.Add(Node.Map[neighborY, neighborX]);
                }
                return neighbors;
            }
        }

        #endregion
    }
}