//Function called from GenerateSpokeRegion to expand the borders of each region
    private void ExpandRegionBorders(TileInfo startTile_)
    {
        //We find the list of tiles along the edge of the city tile's region
        List <TileInfo> edgeTiles = PathfindingAlgorithms.FindRegionEdgeTiles(startTile_);

        //And then we have the region step outward based on the size of the region's boarders
        Vector2 minMaxSteps = new Vector2();

        minMaxSteps.x = edgeTiles.Count * this.minMaxStepPercent.x;
        minMaxSteps.y = edgeTiles.Count * this.minMaxStepPercent.y;
        PathfindingAlgorithms.StepOutRegionEdge(edgeTiles, minMaxSteps, this.absoluteMinimumSteps);
    }
    //Function called from StartMapCreation to expand the borders of each region
    private void ExpandRegionBorders()
    {
        //Making a list of each index for the number of total cities
        List <int> numCities = new List <int>();

        for (int r = 0; r < TileMapManager.globalReference.cityTiles.Count; ++r)
        {
            numCities.Add(r);
        }

        //Creating a separate list to randomize the order of the city indexes
        List <int> randCityOrder = new List <int>();

        for (int c = 0; c < TileMapManager.globalReference.cityTiles.Count; ++c)
        {
            //Getting a random index from the numCities list
            int randIndex = Random.Range(0, TileMapManager.globalReference.cityTiles.Count);
            //Adding the city index to our list of random city orders
            randCityOrder.Add(numCities[randIndex]);
        }

        //Looping through each city in our randomized order
        foreach (int index in randCityOrder)
        {
            //We get the tile reference for the given index's city
            TileInfo cityTile = TileMapManager.globalReference.cityTiles[index];

            //We find the list of tiles along the edge of the city tile's region
            List <TileInfo> edgeTiles = PathfindingAlgorithms.FindRegionEdgeTiles(cityTile);

            //And then we have the region step outward based on the size of the region's boarders
            Vector2 minMaxSteps = new Vector2();
            minMaxSteps.x = edgeTiles.Count * this.minMaxStepPercent.x;
            minMaxSteps.y = edgeTiles.Count * this.minMaxStepPercent.y;
            PathfindingAlgorithms.StepOutRegionEdge(edgeTiles, minMaxSteps, this.absoluteMinimumSteps);
        }

        //Making a list of each index for the number of total dungeons
        List <int> numDungeons = new List <int>();

        for (int d = 0; d < TileMapManager.globalReference.dungeonTiles.Count; ++d)
        {
            numDungeons.Add(d);
        }

        //Creating a separate list to randomize the order of the dungeon indexes
        List <int> randDungeonOrder = new List <int>();

        for (int c = 0; c < TileMapManager.globalReference.dungeonTiles.Count; ++c)
        {
            //Getting a random index from the numDungeons list
            int randIndex = Random.Range(0, TileMapManager.globalReference.dungeonTiles.Count);
            //Adding the dungeon index to our list of random dungeon orders
            randDungeonOrder.Add(numDungeons[randIndex]);
        }

        //Looping through each dungeon in our randomized order
        foreach (int index in randDungeonOrder)
        {
            //We get the tile reference for the given index's dungeon
            TileInfo dungeonTile = TileMapManager.globalReference.dungeonTiles[index];

            //We find the list of tiles along the edge of the dungeon tile's region
            List <TileInfo> edgeTiles = PathfindingAlgorithms.FindRegionEdgeTiles(dungeonTile);

            //And then we have the region step outward based on the size of the region's boarders
            Vector2 minMaxSteps = new Vector2();
            minMaxSteps.x = edgeTiles.Count * this.minMaxStepPercent.x;
            minMaxSteps.y = edgeTiles.Count * this.minMaxStepPercent.y;
            PathfindingAlgorithms.StepOutRegionEdge(edgeTiles, minMaxSteps, this.absoluteMinimumSteps);
        }
    }