pastemyst

(untitled)

(at edit #0)

present

(untitled)

C#copy raw

using System;
using System.Collections;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEditor;
using UnityEngine;
using UnityEngine.Tilemaps;
using UnityEngine.UIElements;

public class MapGenerator : MonoBehaviour
{
    public Tilemap tileMap;
    public TileBase waterPrefab;
    public TileBase grassPrefab;
    public TileBase sandPrefab;
    public TileBase forestPrefab;
    public TileBase mountainPrefab;

public GameObject player;

public int width;
    public int height;
    public int[,] map;
    float[,] noiseMap;
    float noiseValue;

[Range(0, 100)]
    public int randomFillPercentage;

public float seed;
    public bool useRandomSeed;
    public float scale;

private void Start()
    {
        GenerateMap();
    }

void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            GenerateMap();
        }
    }
    void GenerateMap()
    {
        map = new int[height, width];

for(int x = 0; x < width; x++)
            for(int y = 0; y < height; y++)
            {
                proceduralGen(x, y);
                for (int i = 0; i < 5; i++)
                {
                    SmoothMap(x, y);
                }
                AddTerrainTypes(x, y);
                DrawTiles(x, y);
            }
    }
    void proceduralGen(int x, int y)
    {
        noiseMap = new float[height, width];

// Checking if useRandomSeed Boolean is true in the inspector
        if (useRandomSeed)
        {
            seed = UnityEngine.Random.Range(0, 1000000);
        }
        System.Random pseudoRandom = new System.Random((int)seed);
        float xCoord = (float)x / width * scale + seed;
        float yCoord = (float)y / height * scale + seed;
        noiseMap[x, y] = Mathf.PerlinNoise(xCoord, yCoord);

// Edge of the map is water
        if (x == 0 || x == width - 1 || y == 0 || y == height - 1)
                {
            map[x, y] = 0;

}
        else
        {
            map[x, y] = (pseudoRandom.Next(0, 100) < randomFillPercentage) ? 0 : 1;
            Debug.Log(pseudoRandom.Next(0, 100));
        }         
    }
    void AddTerrainTypes(int x, int y)
    {

if (map[x, y] == 0)
                {
                    int terrainType;
                    noiseValue = noiseMap[x, y];

if (noiseValue < 0.1f)
                    {
                        terrainType = 2; // Mountains
                    }
                    else if (noiseValue < 0.4f)
                    {
                        terrainType = 3; // Forests
                    }
                    else
                    {
                        terrainType = 4; // savanna
                    }
                    // Add random variations to terrain types
                    switch (terrainType)
                    {
                        case 2: // Mountains
                            map[x, y] = 2;
                            break;
                        case 3: // Forests
                            map[x, y] = 3;
                            break;
                        case 4: // Savanna
                            map[x, y] = 4;
                            break;
                        default: // Water
                            map[x, y] = 1;
                            break;
                    }
                }
    }

void DrawTiles(int x, int y)
    {
        if (map != null)
        {
                    Vector3Int pos = new Vector3Int(-width / 2 + x, -height / 2 + y, 0);
                    tileMap.SetTile(pos, map[x, y] == 1 ? grassPrefab : waterPrefab);

switch (map[x, y])
                    {
                        case 2:
                            tileMap.SetTile(pos, mountainPrefab);
                            break;
                        case 3:
                            tileMap.SetTile(pos, forestPrefab);
                            break;
                        case 4:
                            tileMap.SetTile(pos, sandPrefab);
                            break;
                        default:
                            tileMap.SetTile(pos, waterPrefab);
                            break;
                    }
        }
    }

void SmoothMap(int x, int y)
    {
                int neighbourWallTile = GetSurroundingWallCount(x, y);

if (neighbourWallTile > 4)
                {
                    map[x, y] = 1;
                }
                else if (neighbourWallTile < 4)
                {
                    map[x, y] = 0;
                }

}
    int GetSurroundingWallCount(int gridX, int gridY)
    {
        int wallCount = 0;
        for (int neighbourX = gridX - 1; neighbourX <= gridX + 1; neighbourX++)
        {
            for (int neighbourY = gridY - 1; neighbourY <= gridY + 1; neighbourY++)
            {
                if (neighbourX >= 0 && neighbourX < width && neighbourY >= 0 && neighbourY < height)
                {
                    if (neighbourX != gridX || neighbourY != gridY)
                    {
                        wallCount += map[neighbourX, neighbourY];
                    }
                }
                else
                {
                    wallCount++;
                }
            }
        }

return wallCount;
    }

}

created at:

stats: 191 lines, 511 words, 5.37kb