예제 #1
0
    public void GenerateMap()
    {
        float[,] noiseMap = Noise.GenNoiseMap(mapChunkSize, mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity, offset);

        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;
                    }
                }
            }

            MapDisplay display = FindObjectOfType <MapDisplay> ();
            if (drawMode == DrawMode.NoiseMap)
            {
                display.DrawTexture(TextureGen.TextureFromHeightMap(noiseMap));
            }
            else if (drawMode == DrawMode.ColorMap)
            {
                display.DrawTexture(TextureGen.TextureFromColorMap(colormap, mapChunkSize, mapChunkSize));
            }
            else if (drawMode == DrawMode.Mesh)
            {
                display.DrawMesh(MeshGen.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, MeshHeightCurve, levelOfDetail), TextureGen.TextureFromColorMap(colormap, mapChunkSize, mapChunkSize));
            }
        }
    }
예제 #2
0
 MapData GenerateMapData(Vector2 center)
 {
     float[,] noiseMap = Noise.GenNoiseMap(mapChunkSize, mapChunkSize, seed, noiseScale, numOctaives, persistance, lacunarity, center + offset);
     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;
                 }
             }
         }
     }
     return(new MapData(noiseMap, colorMap));
 }
예제 #3
0
    public void GenMap()
    {
        mapChunkSize = (int)texRenderer.gameObject.transform.localScale.x * 10;

        float[,] noiseMap = Noise.GenNoiseMap(mapChunkSize, mapChunkSize, noiseScale, seed, octaves, persistance, lacunarity, offset);

        Color[] colourMap = new Color[mapChunkSize * mapChunkSize];

        Unit.InitializeWalkableMap(mapChunkSize);

        for (int z = 0; z < mapChunkSize; z++)
        {
            for (int x = 0; x < mapChunkSize; x++)
            {
                float currentHeight = noiseMap[x, z];
                for (int i = 0; i < regions.Length; i++)
                {
                    if (currentHeight <= regions[i].height)
                    {
                        colourMap[z * mapChunkSize + x] = regions[i].colour;
                        Unit.walkableMap[x, z]          = i;
                        break;
                    }
                }
            }
        }

        Texture2D tex = new Texture2D(mapChunkSize, mapChunkSize);

        tex.filterMode = FilterMode.Point;
        tex.wrapMode   = TextureWrapMode.Clamp;
        tex.SetPixels(colourMap);
        tex.Apply();

        texRenderer.sharedMaterial.mainTexture = tex;
    }
    public void GenerateMap()
    {
        float[,] noiseMap = Noise.GenNoiseMap(mapWidth, mapHeight, seed, noiseScale, octaves, persistance, lacunarity);
        BorderMap();
        Color[] colorMap = new Color[mapWidth * mapHeight];

        for (int y = 0; y < mapHeight; y++)
        {
            for (int x = 0; x < mapWidth; x++)
            {
                if (borderStyle == BorderStyle.IsleMap)
                {
                    noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - borderMap[x, y]);
                }
                else if (borderStyle == BorderStyle.ClosedMap)
                {
                    noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] + borderMap[x, y]);
                }

                float currentHeight = noiseMap[x, y];
                for (int i = 0; i < regions.Length; i++)
                {
                    if (currentHeight <= regions[i].height)
                    {
                        colorMap[y * mapWidth + x] = regions[i].color;
                        break;
                    }
                }
            }
        }

        MapDisplay display = FindObjectOfType <MapDisplay>();

        if (drawMode == DrawMode.NoiseMap)
        {
            display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
        }
        else if (drawMode == DrawMode.ColorMap)
        {
            display.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, mapWidth, mapHeight));
        }
        else if (drawMode == DrawMode.Mesh)
        {
            display.DrawMesh(MashGenerator.GenerateTerrainMesh(noiseMap, meshGeightMultiplier, meshHeightCurve), TextureGenerator.TextureFromColorMap(colorMap, mapWidth, mapHeight));
        }
        else if (drawMode == DrawMode.IsleMap)
        {
            display.DrawTexture(TextureGenerator.TextureFromHeightMap(IslMapGenerator.GenerateIslMap(mapWidth, mapHeight)));
        }
        else if (drawMode == DrawMode.ClosedMap)
        {
            display.DrawTexture(TextureGenerator.TextureFromHeightMap(IslMapGenerator.GenerateIslMap(mapWidth, mapHeight)));
        }

        #region Check (Проверка на входящие данные)

        if (mapWidth < 1)
        {
            mapWidth = 1;
        }
        if (mapHeight < 1)
        {
            mapHeight = 1;
        }
        if (lacunarity < 1)
        {
            lacunarity = 1;
        }
        if (octaves < 0)
        {
            octaves = 0;
        }
        if (noiseScale < 1)
        {
            noiseScale = 1;
        }
        if (seed < 0)
        {
            seed = 0;
        }

        #endregion Validate
    }