Exemple #1
0
        public void CreateWaterMap(Object stateInfo)
        {
            PerlinNoise perlinNoise = new PerlinNoise(rndPerlinOne);

            waterMap           = perlinNoise.GenerateNoiseMap(waterSmoothPasses, scatteredWater, 10f, false, loadingInfo, true, rndPerlinOne, worldWidth, worldHeight);
            perlinOneCompleted = true;
        }
    public void WipeMap()
    {
        foreach (var hex in _hexes)
        {
            if (hex != null)
            {
                Destroy(hex.gameObject);
            }
        }

        _hexes      = new DraftHexPrefab[HexCountX, HexCountY];
        _waterHexes = new List <DraftHexPrefab>();
        _landHexes  = new List <DraftHexPrefab>();
        _mountains  = new List <DraftHexPrefab>();
        _springs    = new List <DraftHexPrefab>();


        _rndPerlin = PerlinNoise.GenerateNoiseMap(HexCountX * HexCountY, 1, Seed, NoiseScale, Octaves, Persistance, Lacunarity, Offset);

        HexContainer.ResetScale();
        //CameraController.ResetCamera();

        _mapIsGenerated            = false;
        _invertSwap                = false;
        SubContainerLeft.position  = _leftPartPos;
        SubContainerRight.position = _rightPartPos;
    }
Exemple #3
0
        public void CreateRiverMap(Object stateInfo)
        {
            PerlinNoise perlinNoise = new PerlinNoise(rndPerlinTwo);

            treeMap            = perlinNoise.GenerateNoiseMap(treeSmoothPasses, scatteredTrees, 10f, false, loadingInfo, false, rndPerlinTwo, worldWidth, worldHeight);
            perlinTwoCompleted = true;
        }
Exemple #4
0
 public override float[,] GenerateHeightMap(int resolution)
 {
     float[,] heightMap = PerlinNoise.GenerateNoiseMap(resolution, resolution,
                                                       this.octaves, this.persistence, this.lacunarity, Random.Range(0, 10000), new Vector2(0, 0), scale);
     LerpHeightMap(heightMap);
     return(heightMap);
 }
Exemple #5
0
    public MapData GenerateMapData()
    {
        if (RNG == null)
        {
            RNG = new RandomNumberGenerator(Seed);             // used for editor
        }
        RNG = new RandomNumberGenerator(Seed);
        float[,] noiseMap = PerlinNoise.GenerateNoiseMap(MapChunkSize, RNG, NoiseScale, Octaves, Persistance, Lacunarity, Offset);

        // Apply region colors to noise map
        Color[] colorMap = new Color[MapChunkSize * MapChunkSize];
        for (int y = 0; y < MapChunkSize; y++)
        {
            for (int x = 0; x < MapChunkSize; x++)
            {
                float currentHeight = noiseMap[x, y];

                for (int i = 0; i < Regions.Length; i++)
                {
                    if (currentHeight <= Regions[i].Height)
                    {
                        colorMap[y * MapChunkSize + x] = Regions[i].Color;
                        break;
                    }
                }
            }
        }

        MapData mapData = new MapData(noiseMap, colorMap);

        return(mapData);
    }
Exemple #6
0
 private float[,] GenerateLand(int resolution)
 {
     float[,] heightMap = PerlinNoise.GenerateNoiseMap(resolution, resolution,
                                                       4, 0.4f, 0.6f, Random.Range(0, 10000), new Vector2(0, 0), 2f);
     LerpHeightMap(heightMap);
     return(heightMap);
 }
Exemple #7
0
 void GenerateIsland()
 {
     float[,] noiseMap = PerlinNoise.GenerateNoiseMap(width, height, seed, scale, octaves, persistance, lacunarity);
     for (int x = 0; x < width; x++)
     {
         for (int y = 0; y < height; y++)
         {
             if (noiseMap[x, y] < waterFrequency)
             {
                 water.SetTile(new Vector3Int(x - width / 2, y - height / 2, 0), tiles[2]);
             }
             else if (noiseMap[x, y] < waterFrequency + 0.05f)
             {
                 map.SetTile(new Vector3Int(x - width / 2, y - height / 2, 0), tiles[1]);
             }
             else if (noiseMap[x, y] > 0.80f)
             {
                 collision.SetTile(new Vector3Int(x - width / 2, y - height / 2, 0), tiles[4]);
             }
             else if (noiseMap[x, y] > 0.60f)
             {
                 collision.SetTile(new Vector3Int(x - width / 2, y - height / 2, 0), tiles[3]);
             }
             else
             {
                 map.SetTile(new Vector3Int(x - width / 2, y - height / 2, 0), tiles[0]);
             }
         }
     }
 }
    private void BlendEdges()
    {
        if (BlendingValue == 0)
        {
            return;
        }

        int edge = BlendingValue / 2;
        int j    = 0;

        DraftHexPrefab[,] edgeHexes = new DraftHexPrefab[HexCountY, BlendingValue];
        float[,] edgeHeights        = new float[HexCountY, BlendingValue];

        float[] avg = new float[HexCountY];
        float[,] rndMap = PerlinNoise.GenerateNoiseMap(HexCountY, BlendingValue, Seed, NoiseScale / 833, Octaves, Persistance, Lacunarity, Offset);
        for (int i = 0; i < HexCountY; i++)
        {
            for (int g = 0; g < BlendingValue; g++)
            {
                rndMap[i, g] = Mathf.Lerp(5, 10, rndMap[i, g]); // => Random.Range(5, 10)
            }
        }
        for (int i = 0; i < HexCountY; i++)
        {
            for (int k = 0; k < BlendingValue; k++)
            {
                if (k < edge)
                {
                    j = k;
                }
                else
                {
                    j = HexCountX + edge - k - 1;
                }

                edgeHexes[i, k]   = _hexes[j, i];
                edgeHeights[i, k] = _heights[j, i];
                avg[i]           += _heights[j, i];
            }
        }

        for (int x = 0; x < HexCountY; x++)
        {
            for (int y = 0; y < BlendingValue; y++)
            {
                avg[y] = avg[y] / BlendingValue;
                float height = edgeHeights[x, y];
                height -= (height - avg[y]) / rndMap[x, y];
                edgeHexes[x, y].Height.text = (height * 1000).ToString("0");

                var color = edgeHexes[x, y].BGImage.color;
                color.a = LerpAlpha(height);
                edgeHexes[x, y].BGImage.color = color;
                //edgeHexes[x, y].BGImage.color = new Color(0, 0, 0, 1); ///debug
            }
        }
    }
Exemple #9
0
    /// <summary>
    /// Initializes a new instance of the <see cref="World"/> class.
    /// Not directly done in World constructor, so that the 'load from world' World constructer can use the same function.
    /// </summary>
    /// <param name="width">Width in number of tiles</param>
    /// <param name="height">Height in number of tiles</param>
    void SetUpWorld(int width, int height)
    {
        jobQueue         = new JobQueue();
        characters       = new List <Character>();
        installedObjects = new List <InstalledObject>();
        rooms            = new List <Room>();
        inventoryManager = new InventoryManager();
        // Add the 'world' room
        rooms.Add(new Room());

        // Set width & height
        Width  = width;
        Height = height;

        // Create new tile array. Default size: 100 * 100 = 10,000 tiles
        tiles = new Tile[width, height];

        // Get Perlin noise map
        float[,] noiseMap = PerlinNoise.GenerateNoiseMap(width, height, 0, 25, 5, 0.5f, 5, new Vector2(0, 0));

        // Instantiate tiles and adding them to the tiles array
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                tiles[x, y] = new Tile(this, x, y);

                // Add bodies of water to the world
                if (noiseMap[x, y] <= 0.075f)
                {
                    tiles[x, y].Type = TileType.Oil;
                }
                else if (noiseMap[x, y] <= 0.25f)
                {
                    tiles[x, y].Type = TileType.Water;
                }
                else if (noiseMap[x, y] <= 0.3f)
                {
                    tiles[x, y].Type = TileType.Sand;
                }

                tiles[x, y].RegisterTileTypeChangedCallback(OnTileChanged);
                // Add tile to room number 0 (the world itself)
                tiles[x, y].room = rooms[0];
            }
        }
        Debug.Log("World created with: " + width * height + " tiles -- width: " + width + ", height: " + height);

        // Create new dictionary of baseInstalledObjects
        installedBaseObjects    = new Dictionary <string, InstalledObject>();
        installedJobBaseObjects = new Dictionary <string, Job>();
        CreateBaseInstalledObjects();
    }
Exemple #10
0
    public void GenerateMap()
    {
        int minSize = Mathf.Min(mapWidth, mapHeight); //Get the smaller size for the FalloffGenerator

        float[,] noiseMap = PerlinNoise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset);
        Color[] colourMap = new Color[mapWidth * mapHeight];
        falloffMap = FalloffGenerator.GenerateFalloffMap(minSize);

        //Loop through the map and apply heights
        for (int x = 0; x < mapWidth; x++)
        {
            for (int y = 0; y < mapHeight; y++)
            {
                if (useFalloff) //If using Falloff to create islands, subtract the falloff map and clamp between 0-1 values
                {
                    noiseMap[x, y] = Mathf.Clamp(noiseMap[x, y] - falloffMap[x, y], 0, 1);
                }

                float height = noiseMap[x, y];

                //Loop through the Biomes
                for (int i = 0; i < biomes.Length; i++)
                {
                    if (height <= biomes[i].height)
                    {
                        colourMap[y * mapWidth + x] = biomes[i].colour;
                        break;
                    }
                }
            }
        }

        if (renderMode == RenderMode.Noise)
        {
            terrainMap.RenderMap(TextureMaker.TextureFromHeightMap(noiseMap));
        }
        else if (renderMode == RenderMode.Colour)
        {
            terrainMap.RenderMap(TextureMaker.TextureFromColourMap(colourMap, mapWidth, mapHeight));
        }
        else if (renderMode == RenderMode.Mesh)
        {
            terrainMap.RenderMesh(TerrainMeshGenerator.GenerateTerrainMesh(noiseMap, heightMultiplier), TextureMaker.TextureFromColourMap(colourMap, mapWidth, mapHeight));
        }


        GeneratePlants(800);
    }
    public void GenerateMap()
    {
        float[,] noiseMap = PerlinNoise.GenerateNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity, offset);

        // Create colormap => one color for each point in the noise map
        Color[] colorMap = new Color[mapWidth * mapHeight];

        // Loop through all values in the noise map
        for (int y = 0; y < mapHeight; y++)
        {
            for (int x = 0; x < mapWidth; x++)
            {
                // Store the current height value at this point/coordinate
                float currentHeight = noiseMap[x, y];

                // Loop through all different regions
                for (int i = 0; i < regions.Length; i++)
                {
                    // If the current height value belongs to a region => set the color equal to that region's color
                    if (currentHeight <= regions[i].height)
                    {
                        // Save the color
                        colorMap[y * mapWidth + x] = regions[i].color;
                        break;
                    }
                }
            }
        }

        // Get reference of the MapDisplay
        MapDisplay mapDisplay = FindObjectOfType <MapDisplay>();

        // Display the perlin noise map or color map => depending on the drawmode selected
        if (drawMode == DrawMode.NoiseMap)
        {
            mapDisplay.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
        }
        else if (drawMode == DrawMode.ColorMap)
        {
            mapDisplay.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, mapWidth, mapHeight));
        }
    }
Exemple #12
0
    MapData GenerateMapData(Vector2 centre)
    {
        float[,] noiseMap = PerlinNoise.GenerateNoiseMap(mapChunkSize + 2, mapChunkSize + 2, seed, noiseScale, octaves, persistance, lacunarity, centre + offset, normalizeMode);

        /*
         * if (!useFalloff)
         * {
         *  noiseMap = PerlinNoise.GenerateNoiseMap(mapChunkSize + 2, mapChunkSize + 2, seed, noiseScale, octaves, persistance, lacunarity, centre + offset, normalizeMode);
         * }
         * else
         * {
         *  //mapChunkSize = 241;
         *  noiseMap = PerlinNoise.GenerateNoiseMap(mapChunkSize, mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity, centre + offset, normalizeMode);
         * }
         */
        Color[] colourMap = new Color[mapChunkSize * mapChunkSize];
        for (int y = 0; y < mapChunkSize; y++)
        {
            for (int x = 0; x < mapChunkSize; x++)
            {
                if (useFalloff)
                {
                    noiseMap [x, y] = Mathf.Clamp01(noiseMap [x, y] - falloffMap [x, y]);
                }
                float currentHeight = noiseMap [x, y];
                for (int i = 0; i < regions.Length; i++)
                {
                    if (currentHeight >= regions [i].height)
                    {
                        colourMap [y * mapChunkSize + x] = regions [i].colour;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }


        return(new MapData(noiseMap, colourMap));
    }
    private void GenerateForest()
    {
        var   forestMap = PerlinNoise.GenerateNoiseMap(HexCountX, HexCountY, Seed, NoiseScale / 10, Octaves, Persistance, Lacunarity * 20, Offset * 4);
        float forestP   = 0.5f;
        float forestP2  = 0.6f;

        for (int i = 0; i < HexCountY; i += 3)
        {
            for (int j = 0; j < HexCountX; j += 3)
            {
                var hex     = _hexes[j, i];
                var hexInfo = hex.InfoScript;

                if (hexInfo.Biome == "grass")
                {
                    if (forestMap[j, i] <= forestP)
                    {
                        hexInfo.IsForest = true;
                        hex.Forest.SetActive(true);

                        foreach (var neighbor in hexInfo.Neighbors)
                        {
                            var neighborInfo = neighbor.InfoScript;
                            int x            = neighborInfo.X;
                            int y            = neighborInfo.Y;

                            if (neighborInfo.Biome == "grass")
                            {
                                if (forestMap[x, y] <= forestP2)
                                {
                                    neighborInfo.IsForest = true;
                                    neighbor.Forest.SetActive(true);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    /// <summary>
    /// Drawing the perlin noise map to a mesh and instantiating trees to specific pixel colour ranges.
    /// </summary>
    /// <param name="treeTypeIndex"></param>
    public void DrawNoiseMap(int index)
    {
        float[,] perlinNoise = PerlinNoise.GenerateNoiseMap(meshWidth, meshLength, seed, noiseScale, octaves, persistance, lacunarity, offset);

        int width  = perlinNoise.GetLength(0);
        int length = perlinNoise.GetLength(1);

        Texture2D texture = new Texture2D(width, length);

        Color[] colourMap = new Color[width * length];

        for (int y = 0; y < length; y++)
        {
            for (int x = 0; x < width; x++)
            {
                colourMap[y * width + x] = Color.Lerp(Color.black, Color.white, perlinNoise[x, y]);

                float currentRange = perlinNoise[x, y];

                if (currentRange >= Trees[index].startRange && currentRange <= Trees[index].endRange)
                {
                    GameObject tree = Instantiate(Trees[index].tree, new Vector3(((x - (meshWidth / 2)) * (meshWidth / 5)), 1, ((y - (meshLength / 2))) * (meshLength / 5)), Trees[index].tree.transform.rotation);
                    Trees[index].spawnedTrees.Add(tree);
                    if (Trees[index].spawnedTrees.Count > 0)
                    {
                        tree.transform.parent = Trees[index].spawnedTrees[0].transform;
                    }
                }
            }
        }
        texture.filterMode = FilterMode.Point;
        texture.wrapMode   = TextureWrapMode.Clamp;
        texture.SetPixels(colourMap);
        texture.Apply();

        textureRenderer.sharedMaterial.mainTexture = texture;
        textureRenderer.transform.localScale       = new Vector3(width, 1, length);
    }
Exemple #15
0
    public void GenerateMap()
    {
        if (newSeed)
        {
            seed = Random.Range(0, 100000);
        }

        float[,] noiseMap = PerlinNoise.GenerateNoiseMap(seed, chunkSize, chunkSize, scale, octaves, persistance, lacunarity, offset);

        switch (drawMode)
        {
        case DrawType.heightMap:
            FindObjectOfType <NoiseDisplay>().DrawHeightMap(noiseMap);
            break;

        case DrawType.colorMap:
            FindObjectOfType <NoiseDisplay>().DrawColorMap(noiseMap, regions);
            break;

        case DrawType.terrain:
            FindObjectOfType <NoiseDisplay>().DrawMesh(TerrainMeshGenerator.CreateTerrain(noiseMap, heightMultiplier, meshHeightCurve, LOD), noiseMap, regions);
            break;
        }
    }
Exemple #16
0
 private float[,] GenerateBiomeMap(int mapSize, PerlinNoise perlinNoise)
 {
     return(perlinNoise.GenerateNoiseMap(mapSize));
 }
    public void Generate()
    {
        WipeMap();
        HexContainer.ResetScale();

        _temperaturesRnd  = PerlinNoise.GenerateNoiseMap(HexCountX, HexCountY, Seed, NoiseScale / 8, Octaves, Persistance, Lacunarity * 8, Offset * 2);
        _humidity         = PerlinNoise.GenerateNoiseMap(HexCountX, HexCountY, Seed, NoiseScale / 15, Octaves, Persistance, Lacunarity * 15, Offset * 3);
        _heights          = PerlinNoise.GenerateNoiseMap(HexCountX, HexCountY, Seed, NoiseScale, Octaves, Persistance, Lacunarity, Offset);
        _heightsForMedian = new List <float>();

        float HexHeight = _hexWidth * Mathf.Sqrt(3) / 2;

        _mountainsLevel = (1 - MountainsPercent) * 1000;

        for (int i = 0; i < HexCountY; i++)
        {
            for (int j = 0; j < HexCountX; j++)
            {
                var hex = Instantiate(HexPrefab, Vector3.zero, Quaternion.identity);
                hex.gameObject.name = "HEX " + i + "." + j;

                _heightsForMedian.Add(_heights[j, i] * 1000);

                hex.InfoScript.Height = _heights[j, i] * 1000;
                hex.Height.text       = string.Format("{0:0}", _heights[j, i] * 1000);
                if (hex.Height.text == "1000") ///
                {
                    hex.Height.text = "999";
                }

                float t = GenerateTemperature(j, i);
                hex.InfoScript.Temperature = t;
                hex.Temperature.text       = t.ToString("0.00");

                float hum = _humidity[j, i];
                hex.InfoScript.Humidity = hum;
                hex.Humidity.text       = hum.ToString("0.00");

                CreateBiome(hex);

                Vector3 pos = FirstHexPos.position;
                pos.x += j * _hexWidth + 0.5f * _hexWidth * (i % 2);
                pos.y -= i * HexHeight;

                hex.transform.position = pos;

                if (j < HexCountX / 2)
                {
                    hex.transform.SetParent(SubContainerLeft);
                }
                else
                {
                    hex.transform.SetParent(SubContainerRight);
                }

                hex.InfoScript.X = j;
                hex.InfoScript.Y = i;

                _hexes[j, i] = hex;
            }
        }

        BlendEdges();
        FindNeighbors();
        GenerateOcean();
        DetectIslands();
        GenerateShelves();
        TweakMountains();
        GenerateHills();
        GenerateForest();
        //GenerateSprings();
        //GenerateRivers();


        ScaleMap();
        _mapIsGenerated = true;
    }