public Grid(GridLocation[,] locations, int sizeX, int sizeY)
 {
     this.sizeX = sizeX;
     this.sizeY = sizeY;
     this.locations = locations;
     this.zeroNeighbors = new List<GridLocation>();
     this.oneNeighbor = new List<GridLocation>();
     this.originalOneNeighbor = new List<GridLocation>();
     this.removalList = new List<GridLocation>();
 }
        //Returns true if it does not result in a dead-end
        public bool DecrementAdjacentNeighbors(GridLocation location)
        {
            bool good = true;
            Location loc = location.Location;
            GridLocation currentLoc = locations[loc.x - 1, loc.y];
            for (int i = 0; i < 4; i++)
            {
                if (good)
                {
                    if (i == 0)
                        currentLoc = locations[loc.x - 1, loc.y];
                    else if (i == 1)
                        currentLoc = locations[loc.x + 1, loc.y];
                    else if (i == 2)
                        currentLoc = locations[loc.x, loc.y - 1];
                    else if (i == 3)
                        currentLoc = locations[loc.x, loc.y + 1];

                    if (!DecrementNeighborCount(currentLoc))
                    {
                        if (BrokenGrid(currentLoc))
                        {
                            good = false;
                            while (i >= 0)
                            {
                                if (i == 0)
                                    currentLoc = locations[loc.x - 1, loc.y];
                                else if (i == 1)
                                    currentLoc = locations[loc.x + 1, loc.y];
                                else if (i == 2)
                                    currentLoc = locations[loc.x, loc.y - 1];
                                else if (i == 3)
                                    currentLoc = locations[loc.x, loc.y + 1];
                                IncrementNeighborCount(currentLoc);
                                i--;
                            }
                        }
                    }
                }
            }
            return good;
        }
 //Returns true if it does not result in a dead-end
 private bool DecrementNeighborCount(GridLocation loc)
 {
     if(loc.Status != GridLocationStatus.StaticWall)
     {
         if (--loc.NeighborCount < 2)
             return false;
     }
     return true;
 }
        private void IncrementNeighborCount(GridLocation loc)
        {
            bool b;
            if (loc.Location.x == 15 && loc.Location.y == 14)
            {
                b = true;
            }

            if (loc.Status != GridLocationStatus.StaticWall)
                if (++loc.NeighborCount == 2)
                    oneNeighbor.Remove(loc);
        }
 //Returns true if valid
 public bool StepOver(GridLocation loc)
 {
     Location l = loc.Location;
     return DecrementNeighborCount(locations[l.x + 1, l.y]);
 }
        //Checks if the new dead end breaks the grid
        //Returns false if grid is not broken
        //Returns true if grid is broken
        private bool BrokenGrid(GridLocation location)
        {
            removalList.Clear();
            for(int i = 0; i < oneNeighbor.Count; i++)
            {
                if (oneNeighbor[i].Status != GridLocationStatus.FreeSquare)
                {
                    removalList.Add(oneNeighbor[i]);
                }
            }
            foreach (GridLocation removal in removalList)
            {
                oneNeighbor.Remove(removal);
            }

            if (oneNeighbor.Count < maxDeadEnd)
            {
                if (!oneNeighbor.Contains(location))
                {
                    oneNeighbor.Add(location);
                }
                return false;
            }
            else
            {
                if (location.Status == GridLocationStatus.FreeSquare)
                {
                    return true;
                }
                return false;
            }
        }
        public void IncrementAdjacentNeighbors(GridLocation location)
        {
            Location loc = location.Location;

            IncrementNeighborCount(locations[loc.x - 1, loc.y]);
            IncrementNeighborCount(locations[loc.x + 1, loc.y]);
            IncrementNeighborCount(locations[loc.x, loc.y - 1]);
            IncrementNeighborCount(locations[loc.x, loc.y + 1]);
        }
 private void IncrementNeighborCount(GridLocation loc)
 {
     if (loc.Status != GridLocationStatus.StaticWall)
         if (++loc.NeighborCount == 2)
             oneNeighbor.Remove(loc);
 }
        //Returns false and does not move if wall is hit
        //Returns true and makes a single step in that direction if possible
        bool TryStep(int direction, out GridLocation newLocation)
        {
            newLocation = null;
            /*
            if (currentMoveList.Count > 0 && currentMoveList.Peek.x == 8 && currentMoveList.Peek.y == 3)
            {
                solved = true;
                return false;
            }
            */
            switch(direction)
            {
                case 0:
                    if (levelDataArray[CurrentX - 1, CurrentY] == 1)
                    {
                        CurrentX--;
                        Step(out newLocation);
                        return true;
                    }
                    return false;
                case 1:
                    if (levelDataArray[CurrentX + 1, CurrentY] == 1)
                    {
                        CurrentX++;
                        Step(out newLocation);
                        return true;
                    }
                    return false;
                case 2:
                    if (levelDataArray[CurrentX, CurrentY + 1] == 1)
                    {
                        CurrentY++;
                        Step(out newLocation);
                        return true;
                    }
                    return false;
                case 3:
                    if (levelDataArray[CurrentX, CurrentY - 1] == 1)
                    {
                        CurrentY--;
                        Step(out newLocation);
                        return true;
                    }
                    return false;
                default:
                    return false;

            }
        }
        //Returns true if the step does not create a second dead-end
        private bool Step(out GridLocation newLocation)
        {
            newLocation = grid.Locations[CurrentX, CurrentY];
            newLocation.Status = GridLocationStatus.CurrentMoverLocation;

            levelDataArray[CurrentX, CurrentY] = nextFootPrint++;
            currentMoveList.PushStep(newLocation.Location);
            greenCount++;

            return true;
               // grid.DecrementAdjacentNeighbors();

            /*
            grid.Locations[loc.Location.x + 1, loc.Location.y].NeighborCount--;
            grid.Locations[loc.Location.x - 1, loc.Location.y].NeighborCount--;
            grid.Locations[loc.Location.x, loc.Location.y + 1].NeighborCount--;
            grid.Locations[loc.Location.x, loc.Location.y - 1].NeighborCount--;
             * */
        }
 /// <summary>
 /// Defines a location in the grid as passable or impassable.
 /// Creates a graphical representation of the location.
 /// Should only be used during the initial level creation.
 /// </summary>
 /// <param name="x">The horizontal offset to define in the grid</param>
 /// <param name="y">The vertical offset to define in the grid (Zero is the bottom-most position)</param>
 /// <param name="barrier">True if the location represents an impassable barrier</param>
 private void SetWall(int x, int y, bool barrier)
 {
     Texture2D texture;
     if(barrier)
     {
         levelDataArray[x, y] = 2;
         gridLocations[x, y] = new GridLocation(new Location(x, y));
         gridLocations[x, y].Status = GridLocationStatus.StaticWall;
         texture = greenBox;
     }
     else
     {
         levelDataArray[x,y] = 1;
         gridLocations[x, y] = new GridLocation(new Location(x, y));
         gridLocations[x, y].Status = GridLocationStatus.FreeSquare;
         texture = greyBox;
     }
     testGrid.AddSprite(new FACE_System.Rectangle((float)x, (float)x + boxSizeX, (float)y, (float)y + boxSizeY), texture);
     originalLevelDataArray[x, y] = levelDataArray[x, y];
 }