miepzerino
2025-04-02 f0315bea6acee2316665d6ca5c945da84f22c1ee
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.Tilemaps;
using UnityEngine.UIElements;
 
//[Serializable]
//public class Ore
//{
//    public string name;
//    /// <summary>
//    /// The lower the numer the higher the amount of ores that will spawn
//    /// Higher number means less ore
//    /// </summary>
//    [Tooltip("The lower the numer the higher the amount of ores that will spawn. Higher number means less ore.")]
//    [Range(1, 100000)]
//    public int weight;
//    /// <summary>
//    /// The lower the number the more dense the ore will spawn (big clusters
//    /// Higher number means little clusters (more spread)
//    /// </summary>
//    [Tooltip("The lower the number the more dense the ore will spawn (big clusters. Higher number means little clusters (more spread).")]
//    [Range(10, 100000)]
//    public int clusterWeight;
//    public CustomRuleTile tile;
//    public int maxSpawnHeight;
//    public int minSpawnHeight;
//}
 
public class GenerateTileMap : MonoBehaviour
{
    public int? seed;
    public static int maxWidth = 256;
    public static int maxHeight = 384;
    public static int maxGroundHeight = 256;
    private float scale;
    private float offsetX;
    private float offsetY;
    Tilemap tilemap;
    public CustomRuleTile forestRuleTile;
    public TileBase borderTile;
    public List<Generateable> generateables;
    //public List<TileBase> tiles;
 
    private void Awake()
    {
        tilemap = GetComponent<Tilemap>();
#if DEBUG
        seed = 0123456789;
#endif
        if (seed == null)
        {
            seed = GenerateSeed(9);
        }
 
        SetSettingsFromSeed(seed.Value);
 
        transform.position = new Vector3((maxWidth / 2) * -1, (maxGroundHeight + 1) * -1, transform.position.z);
    }
 
    public void SetSettingsFromSeed(int seed)
    {
        UnityEngine.Random.State randomState = UnityEngine.Random.state;
 
        UnityEngine.Random.InitState(seed);
        scale = UnityEngine.Random.Range(17f, 23f);
        offsetX = UnityEngine.Random.Range(-10000f, 10000f);
        offsetY = UnityEngine.Random.Range(-10000f, 10000f);
 
        UnityEngine.Random.state = randomState;
 
    }
 
    private int GenerateSeed(int size)
    {
        System.Random rand = new System.Random();
        string seedNumbers = "0123456789";
        char[] chars = new char[size];
        for (int i = 0; i < size; i++)
        {
            chars[i] = seedNumbers[rand.Next(seedNumbers.Length)];
        }
        return int.Parse(new string(chars));
    }
 
    public IEnumerator GenerateTiles(Action finishedCallback, List<Vector3Int> destroyedTiles)
    {
        // generate ground
        for (int x = 1; x < maxWidth; x++)
        {
            for (int y = 1; y < maxGroundHeight; y++)
            {
                float xPerlin = ((float)x / maxWidth) * scale + offsetX;
                float yPerlin = ((float)y / maxHeight) * scale + offsetY;
                float perlinNoise = Mathf.PerlinNoise(xPerlin, yPerlin);
 
                if (perlinNoise <= 0.7f)
                {
                    Vector3Int tileSpawnCoord = new Vector3Int(x, y);
                    if (!destroyedTiles.Contains(tileSpawnCoord))
                    {
                        tilemap.SetTile(tileSpawnCoord, forestRuleTile);
                    }
                }
 
            }
 
            // Update UI every 8 lines
            if ((x % 8) == 0)
            {
                yield return null;
            }
        }
 
        if (generateables != null)
        {
            foreach (Generateable generateable in generateables)
            {
                for (int x = 0; x < maxWidth; x++)
                {
                    for (int y = generateable.minSpawnHeight; y < generateable.maxSpawnHeight; y++)
                    {
                        float xPerlin = ((float)x / maxWidth) * (float)generateable.clusterWeight + offsetX;
                        float yPerlin = ((float)y / maxHeight) * (float)generateable.clusterWeight + offsetY;
                        float perlinNoise = Mathf.PerlinNoise(xPerlin, yPerlin);
 
                        if (perlinNoise <= (1f / (float)generateable.weight))
                        {
                            Vector3Int tileSpawnCoord = new Vector3Int(x, y);
                            if (!destroyedTiles.Contains(tileSpawnCoord) && tilemap.HasTile(tileSpawnCoord))
                            {
                                tilemap.SetTile(tileSpawnCoord, generateable.tile);
                            }
                        }
 
                    }
 
                    // Update UI every 8 lines
                    if ((x % 8) == 0)
                    {
                        yield return null;
                    }
                }
            }
        }
 
        // generate borders
        for (int x = 0; x <= maxWidth; x += maxWidth)
        {
            for (int y = 0; y <= maxHeight; y++)
            {
                tilemap.SetTile(new Vector3Int(x, y), borderTile);
            }
 
        }
        yield return null;
        for (int y = 0; y <= maxHeight; y += maxHeight)
        {
            for (int x = 1; x <= maxWidth; x++)
            {
                tilemap.SetTile(new Vector3Int(x, y), borderTile);
            }
 
        }
        yield return null;
        finishedCallback();
    }
}