예제 #1
0
 // find all spaces where it is possible to go to from current node
 public LinkedList<FieldNode> findSons(FieldNode node)
 {
     LinkedList<FieldNode> sons = new LinkedList<FieldNode>();
     int x = node.x;
     int y = node.y;
     if (x >= sizeX || y >= sizeY || x < 0 || y < 0)
         return null;
     if (y + 1 < sizeY && map[x, y + 1] <= 0)
         sons.AddLast(new FieldNode(x, y + 1));
     if (x + 1 < sizeX && y + 1 < sizeY && map[x + 1, y + 1] <= 0)
         sons.AddLast(new FieldNode(x + 1, y + 1));
     if (x + 1 < sizeX && map[x + 1, y] <= 0)
         sons.AddLast(new FieldNode(x + 1, y));
     if (x + 1 < sizeX && y - 1 >= 0 && map[x + 1, y - 1] <= 0)
         sons.AddLast(new FieldNode(x + 1, y - 1));
     if (y - 1 >= 0 && map[x, y - 1] <= 0)
         sons.AddLast(new FieldNode(x, y - 1));
     if (x - 1 >= 0 && y - 1 >= 0 && map[x - 1, y - 1] <= 0)
         sons.AddLast(new FieldNode(x - 1, y - 1));
     if (x - 1 >= 0 && map[x - 1, y] <= 0)
         sons.AddLast(new FieldNode(x - 1, y));
     if (x - 1 >= 0 && y + 1 < sizeY && map[x - 1, y + 1] <= 0)
         sons.AddLast(new FieldNode(x - 1, y + 1));
     return sons;
 }
예제 #2
0
 public static LinkedList<Direction> FindPath(FieldMap map, FieldNode start, FieldNode goal)
 {
     LinkedList<FieldNode> path = new LinkedList<FieldNode>();
     Stack<FieldNode> stack = new Stack<FieldNode>();
     stack.Push(start);
     while (stack.Count > 0)
     {
         FieldNode node = stack.Pop();
         //AddToPath(path, node);
         if (node.Equals(goal))
             return TranslateToDirections(path);
         LinkedList<FieldNode> sons = map.findSons(node);
         //Iterator<Node> iter = sons.descendingIterator();
         foreach (FieldNode son in sons)
         {
             if (!stack.Contains(son) && !path.Contains(son))
                 stack.Push(son);
         }
     }
     return null;
 }
예제 #3
0
 // find first available space to move to
 public FieldNode firstSon(FieldNode node)
 {
     int x = node.x;
     int y = node.y;
     if (x >= sizeX || y >= sizeY || x < 0 || y < 0)
         return null;
     if (y + 1 < sizeY && map[x, y + 1] <= 0)
         return new FieldNode(x, y + 1);
     if (x + 1 < sizeX && y + 1 < sizeY && map[x + 1, y + 1] <= 0)
         return new FieldNode(x + 1, y + 1);
     if (x + 1 < sizeX && map[x + 1, y] <= 0)
         return new FieldNode(x + 1, y);
     if (x + 1 < sizeX && y - 1 >= 0 && map[x + 1, y - 1] <= 0)
         return new FieldNode(x + 1, y - 1);
     if (y - 1 >= 0 && map[x, y - 1] <= 0)
         return new FieldNode(x, y - 1);
     if (x - 1 >= 0 && y - 1 >= 0 && map[x - 1, y - 1] <= 0)
         return new FieldNode(x - 1, y - 1);
     if (x - 1 >= 0 && map[x - 1, y] <= 0)
         return new FieldNode(x - 1, y);
     if (x - 1 >= 0 && y + 1 < sizeY && map[x - 1, y + 1] <= 0)
         return new FieldNode(x - 1, y + 1);
     return null;
 }
예제 #4
0
 // find the neighbor where the Seeker has been least recently
 public FieldNode findBestNotSeen(FieldNode node, int[,] seenMap)
 {
     if (seenMap.GetLength(0) != sizeX || seenMap.GetLength(1) != sizeY)
         return null;
     LinkedList<FieldNode> sons = new LinkedList<FieldNode>();
     int x = node.x;
     int y = node.y;
     if (x >= sizeX || y >= sizeY || x < 0 || y < 0)
         return null;
     //if there is a neighbor which hasn't been seen recently, return it
     if (y + 1 < sizeY && map[x, y + 1] <= 0 && seenMap[x, y + 1] == 0)
         return new FieldNode(x, y + 1);
     if (x + 1 < sizeX && y + 1 < sizeY && map[x + 1, y + 1] <= 0 && seenMap[x + 1, y + 1] == 0)
         return new FieldNode(x + 1, y + 1);
     if (x + 1 < sizeX && map[x + 1, y] <= 0 && seenMap[x + 1, y] == 0)
         return new FieldNode(x + 1, y);
     if (x + 1 < sizeX && y - 1 >= 0 && map[x + 1, y - 1] <= 0 && seenMap[x + 1, y - 1] == 0)
         return new FieldNode(x + 1, y - 1);
     if (y - 1 >= 0 && map[x, y - 1] <= 0 && seenMap[x, y - 1] == 0)
         return new FieldNode(x, y - 1);
     if (x - 1 >= 0 && y - 1 >= 0 && map[x - 1, y - 1] <= 0 && seenMap[x - 1, y - 1] == 0)
         return new FieldNode(x - 1, y - 1);
     if (x - 1 >= 0 && map[x - 1, y] <= 0 && seenMap[x - 1, y] == 0)
         return new FieldNode(x - 1, y);
     if (x - 1 >= 0 && y + 1 < sizeY && map[x - 1, y + 1] <= 0 && seenMap[x - 1, y+1] == 0)
         return new FieldNode(x - 1, y + 1);
     FieldNode best = null;
     int bestVal = 101;
     // go through all neighbors and find the one that has been seen least recently
     if (y + 1 < sizeY && map[x, y + 1] <= 0)
     {
         FieldNode next = new FieldNode(x, y + 1);
         int val = seenMap[x, y + 1];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x + 1 < sizeX && y + 1 < sizeY && map[x + 1, y + 1] <= 0)
     {
         FieldNode next = new FieldNode(x + 1, y + 1);
         int val = seenMap[x + 1, y + 1];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x + 1 < sizeX && map[x + 1, y] <= 0)
     {
         FieldNode next = new FieldNode(x + 1, y);
         int val = seenMap[x + 1, y];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x + 1 < sizeX && y - 1 >= 0 && map[x + 1, y - 1] <= 0)
     {
         FieldNode next = new FieldNode(x + 1, y - 1);
         int val = seenMap[x + 1, y - 1];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (y - 1 >= 0 && map[x, y - 1] <= 0)
     {
         FieldNode next = new FieldNode(x, y - 1);
         int val = seenMap[x, y - 1];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x - 1 >= 0 && y - 1 >= 0 && map[x - 1, y - 1] <= 0)
     {
         FieldNode next = new FieldNode(x - 1, y - 1);
         int val = seenMap[x - 1, y - 1];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x - 1 >= 0 && map[x - 1, y] <= 0)
     {
         FieldNode next = new FieldNode(x - 1, y);
         int val = seenMap[x - 1, y];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x - 1 >= 0 && y + 1 < sizeY && map[x - 1, y + 1] <= 0)
     {
         FieldNode next = new FieldNode(x - 1, y + 1);
         int val = seenMap[x - 1, y + 1];
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     //return the neighbor which has been seen least recently
     return best;
 }
예제 #5
0
 //lower count of objects in a certain space
 internal void removeBlock(FieldNode fieldNode)
 {
     map[fieldNode.x, fieldNode.y]--;
 }
예제 #6
0
 //returns whether location is in conflict with one of the items
 internal bool isConflict(Vector3 location, FieldNode fieldNode)
 {
     List<Item> items = itemMap[fieldNode.x, fieldNode.y];
     if (items == null)
         return false;
     foreach (Item item in items)
         if (item.isConflict(location))
             return true;
     return false;
 }
예제 #7
0
 //check if space on map is still available
 internal bool isAvailable(FieldNode fieldNode)
 {
     return (map[fieldNode.x, fieldNode.y] == 0);
 }
예제 #8
0
 //find best space to go to while racing to tree
 internal FieldNode findRunSpace(FieldNode node)
 {
     if (node == null)
         return null;
     int x = node.x;
     int y = node.y;
     //if possible, go to the nodes which are closer to the tree (meaning a smaller y value)
     if (y - 1 >= 0 && map[x, y - 1] == 0)
         return new FieldNode(x, y - 1);
     if (y - 1 >= 0 && x - 1 >= 0 && map[x - 1, y - 1] == 0)
         return new FieldNode(x - 1, y - 1);
     if (y - 1 >= 0 && x + 1 < sizeX && map[x + 1, y - 1] == 0)
         return new FieldNode(x + 1, y - 1);
     //otherwise, go sideways (equal y value)
     if (x - 1 >= 0 && map[x - 1, y] == 0)
         return new FieldNode(x - 1, y);
     if (x + 1 < sizeX && map[x + 1, y] == 0)
         return new FieldNode(x + 1, y);
     //if none of the above nodes are available, go to nodes which are farther away from the tree (larger y value)
     if (y + 1 < sizeY && x - 1 >= 0 && map[x - 1, y + 1] == 0)
         return new FieldNode(x - 1, y + 1);
     if (y + 1 < sizeY && map[x, y + 1] == 0)
         return new FieldNode(x, y + 1);
     if (y + 1 < sizeY && x + 1 < sizeX && map[x + 1, y + 1] == 0)
         return new FieldNode(x + 1, y + 1);
     return null;
 }
예제 #9
0
 //notify map that someone moved from [x,y] to [z,w]
 public void moveSomeone(FieldNode node1, FieldNode node2)
 {
     if (node1 != null && node1.x >= 0 && node1.y >= 0)
         map[node1.x, node1.y]--;
     if (node2 != null && node2.x >= 0 && node2.y >= 0)
         map[node2.x, node2.y]++;
 }
예제 #10
0
 //returns available node which is closest to goal (using manhattan distance)
 public FieldNode getClosestNext(FieldNode node, FieldNode goal)
 {
     //if the goal is a neighbor
     if (Math.Abs(node.x - goal.x) == 1 || Math.Abs(node.y - goal.y) == 1)
     {
         //if the only item in the goal space is the hiding spot, return it
         if (map[goal.x, goal.y] == 1)
             return goal;
         //otherwise, need to find a new hiding spot
         else
             throw new SpotTakenException();
     }
     int x = node.x;
     int y = node.y;
     if (x >= sizeX || y >= sizeY || x < 0 || y < 0)
         return null;
     //go through all neighbors and find the one which is closest to the hiding spot, using Manhattan distancea
     FieldNode best = null;
     double bestVal = 300;
     if (y + 1 < sizeY && map[x, y + 1] <= 0)
     {
         FieldNode next = new FieldNode(x, y + 1);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x + 1 < sizeX && y + 1 < sizeY && map[x + 1, y + 1] <= 0)
     {
         FieldNode next = new FieldNode(x + 1, y + 1);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x + 1 < sizeX && map[x + 1, y] <= 0)
     {
         FieldNode next = new FieldNode(x + 1, y);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x + 1 < sizeX && y - 1 >= 0 && map[x + 1, y - 1] <= 0)
     {
         FieldNode next = new FieldNode(x + 1, y - 1);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (y - 1 >= 0 && map[x, y - 1] <= 0)
     {
         FieldNode next = new FieldNode(x, y - 1);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x - 1 >= 0 && y - 1 >= 0 && map[x - 1, y - 1] <= 0)
     {
         FieldNode next = new FieldNode(x - 1, y - 1);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x - 1 >= 0 && map[x - 1, y] <= 0)
     {
         FieldNode next = new FieldNode(x - 1, y);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     if (x - 1 >= 0 && y + 1 < sizeY && map[x - 1, y + 1] <= 0)
     {
         FieldNode next = new FieldNode(x - 1, y + 1);
         double val = next.EuclideanDist(goal);
         if (val < bestVal)
         {
             bestVal = val;
             best = next;
         }
     }
     return best;
 }
예제 #11
0
 // convert node to 3D location
 public float[] nodeToLoc(FieldNode node)
 {
     float[] res = new float[4];
     res[0] = node.x * squareSize + borders[1].X;
     res[1] = -node.y * squareSize;
     res[2] = (node.x + 1) * squareSize + borders[1].X;
     res[3] = -(node.y + 1) * squareSize;
     return res;
 }
예제 #12
0
 //calculate distance between to spaces
 public double EuclideanDist(FieldNode other)
 {
     //return Math.Abs(x - other.x) + Math.Abs(y - other.y);
     return Math.Sqrt((x-other.x)*(x-other.x)+(y-other.y)*(y-other.y));
 }
예제 #13
0
 // convert node to 3D location
 public float[] nodeToLoc(FieldNode node)
 {
     if (node == null || node.x < 0 || node.y < 0)
         return null;
     float[] res = new float[4];
     res[0] = node.x * squareSize + borders[1].X;
     res[1] = -node.y * squareSize;
     res[2] = (node.x + 1) * squareSize + borders[1].X;
     res[3] = -(node.y + 1) * squareSize;
     return res;
 }
예제 #14
0
        /// <summary>
        /// Allows the game component to perform any initialization it needs to before starting
        /// to run.  This is where it can query for any required services and load content.
        /// </summary>
        public override void Initialize()
        {
            //initialize game space borders
            borders = new Vector3[4];
            borders[0] = new Vector3(20, 0, 0);
            borders[1] = new Vector3(-20, 0, 0);
            borders[2] = new Vector3(20, 0, -2000);
            borders[3] = new Vector3(-20, 0, -2000);

            //create map
            int sizeX = (int)Math.Abs(borders[0].X - borders[3].X) / squareSize;
            int sizeY = (int)(Math.Abs(borders[0].Z - borders[3].Z) / squareSize);
            map = new FieldMap(sizeX, sizeY);

            //if game is a real game and not a practice
            if (gameType == GameType.Hide || gameType == GameType.Seek)
            {
                Random rand = new Random(10);
                items = new Item[numOfItems];
                for (int i = 0; i < numOfItems; i++)
                {
                    //choose space on map which has no item in it yet
                    FieldNode node = null;
                    int x;
                    int y;
                    do
                    {
                        x = rand.Next(sizeX);
                        y = rand.Next(sizeY);
                        node = new FieldNode(x, y);
                    } while (!map.isAvailable(node));
                    //find optimal location in space for item
                    Vector3 loc = Rock.findBestLoc(nodeToLoc(node), ItemType.Rock);
                    items[i] = new Rock(Game, loc, new Vector3(0.4f, 0.4f, 0.4f), 0, i);
                    map.addItem(items[i], x, y);
                }
            }

            hiders = new Hider[numOfHiders];
            //if human player is a hider
            if (gameType == GameType.Hide)
            {
                //create human hider
                humanPlayer = new HumanHider(Game, new Vector3(0, 0, 0), 5, 10, 0);
                hiders[0] = (Hider)humanPlayer;
                //create rest of hiders to be virtual players
                for (int i = 1; i < numOfHiders; i++)
                    hiders[i] = new VirtualHider(Game, new Vector3(10 * i, 0, 0) + borders[1], 5, 10, i + 1);
                //create virtual seeker
                seeker = new VirtualSeeker(Game, new Vector3(5, 0, 0), 5, 10, 1, countNum);
            }
            //if human player is a seeker
            else if (gameType == GameType.Seek)
            {
                //create human seeker
                humanPlayer = new HumanSeeker(Game, new Vector3(0, 0, 0), 5, 10, 0, countNum);
                seeker = (Seeker)humanPlayer;
                //create all hiders to be virtual players
                for (int i = 0; i < numOfHiders; i++)
                    hiders[i] = new VirtualHider(Game, new Vector3(5 * i, 0, 0), 5, 10, i + 1);
            }
            if (gameType == GameType.HidePractice)
            {
                numOfItems = 1;
                numOfHiders = 1;
                items = new Item[1];
                items[0] = new Rock(Game, new Vector3(0, 0, -20), new Vector3(1f, 1f, 1f), 0, 1);
                Console.WriteLine("only item: " + items[0]);
                hiders = new Hider[1];
                humanPlayer = new HumanHider(Game, new Vector3(0, 0, 0), 5, 10, 0);
                hiders[0] = (Hider)humanPlayer;
                seeker = null;
            }
            else if (gameType == GameType.SeekPractice)
            {
                numOfItems = 2;
                numOfHiders = 1;
                items = new Item[2];

            //TODO: is this the right place for intialization?
            //      if so, get the missing parameters to here,
            //      or alternatively, put Tree & Billboard intialization elsewhere!

                //BillboardSystem bbs = BillboardSystem.factory(2, graphicsDevice, BasicEffect);
                items[0] = new /*Tree*/Rock(Game, new Vector3(20, 0, -20), new Vector3(0.4f, 0.4f, 0.4f), 0, 1);
                items[1] = new /*Tree*/Rock(Game, new Vector3(-20, 0, -20), new Vector3(0.4f, 0.4f, 0.4f), 0, 2);

                hiders = new Hider[1];
                hiders[0] = new VirtualHider(Game, new Vector3(10, 0, 0), 5, 10, 2);
                seeker = new HumanSeeker(Game, new Vector3(0, 0, 0), 5, 10, 1, 0);
                humanPlayer = (HumanPlayer)seeker;
                Random rand = new Random();
                int i = rand.Next(2);
                ((VirtualHider)hiders[0]).skipSearch(items[i]);
                ((HumanSeeker)seeker).skipCounting();
            }
            else
            {
                //tell map that locations of all players are off-limits
                for (int i = 0; i < numOfHiders; i++)
                    map.addBlock((int)Math.Abs(hiders[i].Location.X - borders[1].X) / squareSize, (int)-(hiders[i].Location.Z / squareSize));
                map.addBlock((int)Math.Abs((seeker.Location.X - borders[1].X)) / squareSize, (int)-seeker.Location.Z / squareSize);
            }
            base.Initialize();
        }