private void GenerateLocations()
        {
            LocationGenerator locationGenerator = new LocationGenerator(map, locationsMap, objectsMap, random);

            int minX = (int)(objectsMap.Width * 0.05), maxX = (int)(objectsMap.Width * 0.95);
            int minY = (int)(objectsMap.Height * 0.05), maxY = (int)(objectsMap.Height * 0.95);

            for (int i = minY; i < maxY; ++i)
            {
                for (int j = minX; j < maxX; ++j)
                {
                    BiomModel biom = map[i, j].GetBiomModel();

                    if (biom.Locations.Any() &&
                        locationsMap.CanGenerateIn(new Vector2Int(j, i)) &&
                        random.Next(10000) / 100f < biom.LocationsIntensity)
                    {
                        LocationModel locationDataModel = rouletteWheelSelector.RouletteWheelSelection(biom.Locations);

                        LocationInstance location = locationGenerator.GenerateLocation(locationDataModel, new Vector2Int(j, i));
                        if (location != null)
                        {
                            awaitingObjects.AddRange(location.BigObjects);
                            awaitingObjects.AddRange(location.Objects);
                            awaitingObjects.AddRange(location.Fence);

                            locationsMap.MarkLocation(location);
                        }
                    }
                }
            }
        }
        private void SmoothBlock(Vector2Int pos)
        {
            List <Vector2Int> neighbourPos = new List <Vector2Int>();
            int countOfNeighbourBlock      = 0;
            int countOfNeighbourEmpty      = 0;
            int countOfNeighbour           = 0;

            for (int i = pos.Y - 1; i <= pos.Y + 1; ++i)
            {
                for (int j = pos.X - 1; j <= pos.X + 1; ++j)
                {
                    if (i != pos.Y || j != pos.X)
                    {
                        if (locationsMap.IsOnMap(new Vector2Int(j, i)))
                        {
                            if (locationShapeMap[i, j])
                            {
                                countOfNeighbourBlock++;
                                if ((i - pos.Y + 1 == j - pos.X) || (j - pos.X + 1 == i - pos.Y))
                                {
                                    countOfNeighbour++;
                                }
                            }
                            else
                            {
                                countOfNeighbourEmpty++;
                            }

                            neighbourPos.Add(new Vector2Int(j, i));
                        }
                    }
                }
            }

            if (countOfNeighbourEmpty == 5 && locationShapeMap[pos.Y, pos.X]) //Delete corner block
            {
                locationShapeMap[pos.Y, pos.X] = false;
                neighbourPos.ForEach(x => blockPosToCheck.Push(x));
            }
            else if (countOfNeighbourBlock == 5 && !locationShapeMap[pos.Y, pos.X]) //Add corner block
            {
                locationShapeMap[pos.Y, pos.X] = true;
                neighbourPos.ForEach(x => blockPosToCheck.Push(x));
            }
            else if (countOfNeighbour < 2 && locationShapeMap[pos.Y, pos.X])
            {
                locationShapeMap[pos.Y, pos.X] = false;
                neighbourPos.ForEach(x => blockPosToCheck.Push(x));
            }
            else if (countOfNeighbour > 2 && !locationShapeMap[pos.Y, pos.X] && locationsMap.CanGenerateIn(pos))
            {
                locationShapeMap[pos.Y, pos.X] = true;
                neighbourPos.ForEach(x => blockPosToCheck.Push(x));
            }
        }
        private void AddNeighbors(bool[,] placeShape, Vector2Int pos)
        {
            if (IsOnMap(new Vector2Int(-1, 0) + pos) && locationsMap.CanGenerateIn(new Vector2Int(pos.X - 1, pos.Y)) && !placeShape[pos.Y, pos.X - 1])
            {
                AddOrUpdateNeighbor(new Vector2Int(-1, 0) + pos);
            }

            if (IsOnMap(new Vector2Int(1, 0) + pos) && locationsMap.CanGenerateIn(new Vector2Int(pos.X + 1, pos.Y)) && !placeShape[pos.Y, pos.X + 1])
            {
                AddOrUpdateNeighbor(new Vector2Int(1, 0) + pos);
            }

            if (IsOnMap(new Vector2Int(0, -1) + pos) && locationsMap.CanGenerateIn(new Vector2Int(pos.X, pos.Y - 1)) && !placeShape[pos.Y - 1, pos.X])
            {
                AddOrUpdateNeighbor(new Vector2Int(0, -1) + pos);
            }

            if (IsOnMap(new Vector2Int(0, 1) + pos) && locationsMap.CanGenerateIn(new Vector2Int(pos.X, pos.Y + 1)) && !placeShape[pos.Y + 1, pos.X])
            {
                AddOrUpdateNeighbor(new Vector2Int(0, 1) + pos);
            }
        }