Génération d'une carte de tuiles

Je programme un jeu basé sur des tuiles et j'ai quelques tuiles de base (herbe, terre, etc.), mais je ne sais pas comment faire une bonne génération de carte aléatoire, parce que quand je fais une sélection vraiment aléatoire, si la tuile devrait être de l'herbe / de la saleté, je reçois ceci:

Je comprends pourquoi cela se produit, mais ce que je veux, c'est créer des zones continues aléatoires d'herbe ou de saleté. Quelque chose qui aurait plus de sens, comme ceci:

Ce que vous pourriez faire, c'est générer aléatoirement une carte Voronoi comme ceci:

1. Cueillir au hasard center points(voir les points noirs) et décider au hasard s'il s'agit d'herbe ou de saleté.
2. Ensuite, pour toutes les tuiles, vérifiez si elle est la plus proche d'une center pointterre ou d'une herbe.
3. Terminé!

Si ce que vous avez fait précédemment est de «lancer une pièce» pour chaque tuile (bruit), la génération d'un diagramme de Voronoi fournira un bien meilleur résultat.

Vous pouvez améliorer cela en divisant le center pointsen islandsun algorithme qui:

1. Choisit un petit groupe de centers pointset les désigne comme leaders.
2. Ajoute itérativement un point central adjacent indécis aléatoire à chaque tour.
3. Terminé!

Vous pouvez utiliser le bruit perlin, qui est normalement utilisé pour la génération de la carte de hauteur. Bruit de Perlin dans les jeux

Ensuite, vous pouvez utiliser les hauteurs en tant que conseiller, à quel point le risque d'herbe / saleté se produisant dans une région de la carte est élevé.

Exemple (valeurs de bruit Perlin de 0 à 256): Si la valeur est supérieure à 200, la probabilité que l'herbe soit placée est de 80% (saleté 20%). Si la valeur est comprise entre 100 et 200, la probabilité que l'herbe soit placée est de 50% (la saleté aussi 50%). Si la valeur est inférieure à 100, la probabilité que l'herbe soit placée est de 20% (saleté 80%).

http://gamedevelopment.tutsplus.com/tutorials/generate-random-cave-levels-using-cellular-automata--gamedev-9664

voici ma version de la méthode des automates cellulaires commencez par remplir la grille avec aléatoire puis exécutez ces règles d'automates cullular dessus quelques fois

• Si une cellule vivante a moins de deux voisins vivants, elle meurt.
• Si une cellule vivante a deux ou trois voisins vivants, elle reste en vie.
• Si une cellule vivante a plus de trois voisins vivants, elle meurt.
• Si une cellule morte a exactement trois voisins vivants, elle devient vivante.

et ça finit par ressembler à une grotte

l'index peut être converti en position x & y et inversement avec ce code

public int TileIndex(int x, int y)
{
    return y * Generator.Instance.Width + x;
}
public Vector2 TilePosition(int index)
{
    float y = index / Generator.Instance.Width;
    float x = index - Generator.Instance.Width * y;
    return new Vector2(x, y);
}

Je retourne juste une liste de bools parce que j'utilise cette liste pour beaucoup de choses: grottes, arbres, fleurs, herbe, brouillard, eau, vous pouvez même combiner plusieurs listes de différentes manières ici, je supprime d'abord toutes les grottes plus petites, puis réunissez deux listes aléatoires

private int GetAdjacentCount(List<bool> list, Vector2 p)
{
    int count = 0;
    for (int y = -1; y <= 1; y++)
    {
        for (int x = -1; x <= 1; x++)
        {
            if (!((x == 0) && (y == 0)))
            {
                Vector2 point = new Vector2(p.x + x, p.y + y);
                if (PathFinder.Instance.InsideMap(point))
                {
                    int index = PathFinder.Instance.TileIndex(point);
                    if (list[index])
                    {
                        count++;
                    }
                }
                else
                {
                    count++;
                }
            }
        }
    }
    return count;
}
private List<bool> GetCellularList(int steps, float chance, int birth, int death)
{
    int count = _width * _height;
    List<bool> list = Enumerable.Repeat(false, count).ToList();
    for (int y = 0; y < _height; y++)
    {
        for (int x = 0; x < _width; x++)
        {
            Vector2 p = new Vector2(x, y);
            int index = PathFinder.Instance.TileIndex(p);
            list[index] = Utility.RandomPercent(chance);
        }
    }
    for (int i = 0; i < steps; i++)
    {
        var temp = Enumerable.Repeat(false, count).ToList();
        for (int y = 0; y < _height; y++)
        {
            for (int x = 0; x < _width; x++)
            {
                Vector2 p = new Vector2(x, y);
                int index = PathFinder.Instance.TileIndex(p);
                if (index == -1) Debug.Log(index);
                int adjacent = GetAdjacentCount(list, p);
                bool set = list[index];
                if (set)
                {
                    if (adjacent < death)
                        set = false;
                }
                else
                {
                    if (adjacent > birth)
                        set = true;
                }
                temp[index] = set;
            }
        }
        list = temp;
    }
    if ((steps > 0) && Utility.RandomBool())
        RemoveSmall(list);
    return list;
}

Sélectionnez un point sur la carte. Placez le type de tuile souhaité avec une valeur de base telle que 40. Gardez une trace de l'endroit où vous avez placé votre nouvelle tuile désirée. Ajoutez le point de départ à une liste.

Pour chaque point de cette liste, vous visitez tous les voisins. Tant qu'il vous reste assez de puissance (à partir de 40), ajoutez la tuile souhaitée et ajoutez-la à la liste à visiter. Donnez moins de puissance à la nouvelle tuile, déterminée par vous. Plus facile = abaissement aléatoire. Après avoir visité la vignette de la liste, supprimez-la. Recommencez en visitant toutes les tuiles non visitées mais créées.