// Update is called once per frame
    void Update()
    {
        transform.Translate(Vector3.forward * Time.deltaTime * Speed);

        if (transform.position.z >= 2 + float.Epsilon && !go)
        {
            go = true;
            GameObject terrain;
            TerrainData _terraindata = new TerrainData();
            TerrainData t = gameObject.GetComponent<Terrain>().terrainData;
            terrain = Terrain.CreateTerrainGameObject(t);

            GameObject ingameTerrainGameObject = (GameObject)Instantiate(terrain, StartPos, Quaternion.identity);
            //GenerateHeights(gameObject.GetComponent<Terrain>(), 2f);
            ingameTerrainGameObject.AddComponent<MoveTerrain>();

            Destroy(terrain);

            Destroy(gameObject);

        }

        /*if (transform.position.z > 20 + float.Epsilon)
            Destroy(gameObject);*/
    }

	private void getTerrain (){
		if(Terrain.activeTerrain != null){
			r_Terrain = Terrain.activeTerrain;
			r_TerrainData = r_Terrain.terrainData;
			r_TerrainPos = r_Terrain.transform.position;
		}
	}

	/// <summary>
	/// Creates terrain data from heights.
	/// </summary>
	/// <param name="heightPercents">Terrain height percentages ranging from 0 to 1.</param>
	/// <param name="maxHeight">The maximum height of the terrain, corresponding to a height percentage of 1.</param>
	/// <param name="heightSampleDistance">The horizontal/vertical distance between height samples.</param>
	/// <param name="splatPrototypes">The textures used by the terrain.</param>
	/// <param name="alphaMap">Texture blending information.</param>
	/// <returns>A TerrainData instance.</returns>
	public static TerrainData CreateTerrainData(float[,] heightPercents, float maxHeight, float heightSampleDistance, SplatPrototype[] splatPrototypes, float[,,] alphaMap)
	{
		Debug.Assert((heightPercents.GetLength(0) == heightPercents.GetLength(1)) && (maxHeight >= 0) && (heightSampleDistance >= 0));

		// Create the TerrainData.
		var terrainData = new TerrainData();
		terrainData.heightmapResolution = heightPercents.GetLength(0);

		var terrainWidth = (terrainData.heightmapResolution - 1) * heightSampleDistance;

		// If maxHeight is 0, leave all the heights in terrainData at 0 and make the vertical size of the terrain 1 to ensure valid AABBs.
		if(!Mathf.Approximately(maxHeight, 0))
		{
			terrainData.size = new Vector3(terrainWidth, maxHeight, terrainWidth);

			terrainData.SetHeights(0, 0, heightPercents);
		}
		else
		{
			terrainData.size = new Vector3(terrainWidth, 1, terrainWidth);
		}

		// Texture the terrain.
		if((splatPrototypes != null) && (alphaMap != null))
		{
			Debug.Assert(alphaMap.GetLength(0) == alphaMap.GetLength(1));

			terrainData.alphamapResolution = alphaMap.GetLength(0);
			terrainData.splatPrototypes = splatPrototypes;
			terrainData.SetAlphamaps(0, 0, alphaMap);
		}

		return terrainData;
	}

    void OnGUI()
    {
        tWidth = EditorGUILayout.IntField("Terrain Width", tWidth);
        tHeight = EditorGUILayout.IntField("Terrain Height", tHeight);
        tDepth = EditorGUILayout.IntField("Terrain Depth", tDepth);

        EditorGUILayout.Separator();

        cellWidth = EditorGUILayout.IntSlider("Cell Width", cellWidth, 1, 512);
        cellDepth = EditorGUILayout.IntSlider("Cell Depth", cellDepth, 1, 512);
        cliffLevel = EditorGUILayout.FloatField("Cliff Height", cliffLevel);

        EditorGUILayout.Separator();

        if (GUILayout.Button("Create"))
        {
            TerrainData terData = new TerrainData() { size = new Vector3(tWidth, tHeight, tDepth), name = "Map Terrain", heightmapResolution = 512, baseMapResolution = 1024 };
            GameObject ter = Terrain.CreateTerrainGameObject(terData);
            ter.name = "Map";
            Gridmap gmap = ter.AddComponent<Gridmap>();
            gmap.cellWidth = cellWidth;
            gmap.cellDepth = cellDepth;
            gmap.cliffHeight = cliffLevel;
            isVisible = false;
            this.Close();
        }
        else if (GUILayout.Button("Cancel"))
        {
            isVisible = false;
            this.Close();
        }
    }

 private static TextureData GetTerrainTextures(TerrainData terrainData)
 {
     return new TextureData
            {
                SplatMaps = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight),
                ControlTextureResolution = terrainData.alphamapResolution
            };
 }

    public static void UpdateControlTextureResolution(TerrainData terrainData, int newResolution)
    {
        var existingData = GetTerrainTextures(terrainData);

        terrainData.alphamapResolution = newResolution;

        ApplyTexturesToNewTerrain(terrainData, existingData);
    }

    /// <summary>
    /// </summary>
    /// <param name="terrainData"></param>
    /// <param name="position">Location in the XZ plane (not the XY plane!)</param>
    /// <param name="sphereRadius"></param>
    /// <returns></returns>
    private static Vector3 AdjustSpawnPositionForTerrainShape(TerrainData terrainData, Vector2 position, float sphereRadius)
    {
        var height = terrainData.GetInterpolatedHeight(position.x, position.y);
        var normal = terrainData.GetInterpolatedNormal(position.x, position.y);

        var offsetAlongNormal = normal * sphereRadius;
        var positionOnTerrain = new Vector3(position.x, height, position.y);
        return positionOnTerrain + offsetAlongNormal;
    }

 private TerrainData CreateTerrain()
 {
     TerrainData terrainData = new TerrainData ();
     terrainData.size = terrainPrefab.terrainData.size;
     terrainData.heightmapResolution = terrainPrefab.terrainData.heightmapHeight;
     terrainData.baseMapResolution = terrainPrefab.terrainData.baseMapResolution;
     terrainData.SetDetailResolution (terrainPrefab.terrainData.detailResolution, 1);
     return terrainData;
 }

 void CopyTerrainDataFromTo(TerrainData tDataFrom, ref TerrainData tDataTo)
 {
     tDataTo.SetDetailResolution(tDataFrom.detailResolution, 8);
     tDataTo.heightmapResolution = tDataFrom.heightmapResolution;
     tDataTo.alphamapResolution = tDataFrom.alphamapResolution;
     tDataTo.baseMapResolution = tDataFrom.baseMapResolution;
     tDataTo.size = tDataFrom.size;
     tDataTo.splatPrototypes = tDataFrom.splatPrototypes;
 }

    private static void ApplyTexturesToNewTerrain(TerrainData terrainData, TextureData data)
    {
        if (data.ControlTextureResolution != terrainData.alphamapResolution)
        {
            data.AdjustSplatMapResolution(terrainData.alphamapResolution);
        }

        terrainData.SetAlphamaps(0, 0, data.SplatMaps);
    }

 public Area(TerrainData owner, Block[] blocks)
 {
     m_owner = owner;
     
     foreach (Block point in blocks)
     {
         AddPoint(point);
     }
 }

    public static string[] GetTerrainSplatNames(TerrainData d)
    {
        List<string> l = new List<string>();

        for (int i = 0; i < d.splatPrototypes.Length; ++i) {
            l.Add(d.splatPrototypes[i].texture.name);
        }

        return l.ToArray();
    }

    public TerrainTile(Terrain terrain, TerrainData tData, Vector3 index)
    {
        Terrain = terrain;
        TData = tData;
        TCollider = terrain.GetComponent<TerrainCollider>();
        Index = index;
        InUse = false;

        Terrain.terrainData = TData;
        TCollider.terrainData = TData;
    }

    public static Mesh createMesh(TerrainData t, Vector3 terrainPosition)
    {
        Mesh m = new Mesh();

        int w = t.heightmapWidth;
        int h = t.heightmapHeight;
        Vector3 meshScale = t.size;
        int tRes = 2;
        meshScale = new Vector3(meshScale.x / (w - 1) * tRes, meshScale.y, meshScale.z / (h - 1) * tRes);

        float[,] tData = t.GetHeights(0, 0, w, h);

        w = (w - 1) / tRes + 1;
        h = (h - 1) / tRes + 1;

        Vector3[] tVertices = new Vector3[w * h];

        int[] tPolys;

        tPolys = new int[(w - 1) * (h - 1) * 6];

        // Build vertices
        for (int y = 0; y < h; y++)
        {
            for (int x = 0; x < w; x++)
            {
                tVertices[y * w + x] = Vector3.Scale(meshScale, new Vector3(-y, tData[x * tRes, y * tRes], x)) + terrainPosition;
            }
        }

        int index = 0;

        // Build triangle indices: 3 indices into vertex array for each triangle
        for (int y = 0; y < h - 1; y++)
        {
            for (int x = 0; x < w - 1; x++)
            {
                // For each grid cell output two triangles
                tPolys[index++] = (y * w) + x;
                tPolys[index++] = ((y + 1) * w) + x;
                tPolys[index++] = (y * w) + x + 1;

                tPolys[index++] = ((y + 1) * w) + x;
                tPolys[index++] = ((y + 1) * w) + x + 1;
                tPolys[index++] = (y * w) + x + 1;
            }
        }

        m.vertices = tVertices;
        m.triangles = tPolys;
        m.subMeshCount = 1;

        return m;
    }

 private void _generateNoise(System.Random rng, TerrainData data)
 {
     int width = data.Width;
     int height = data.Height;
     for (int y = 0; y < height; y++)
     {
         for(int x = 0; x < width; x++)
         {
             data.SetValue(x, y, rng.NextDouble() < m_randomFillChance ? 1 : 0);
         }
     }
 }

    private void Awake()
    {
        var terrain = GetComponent<Terrain>();

        var map = ReadMap(Filename);
        //var map = ReadMap(string.Format("{0}_{1}", 0, 0));
        //var map = GetRandomizedMap(33, 33, 0.2f);

        var data = new TerrainData { size = new Vector3(100f, 100f, 100f), heightmapResolution = 33 };

        terrain.terrainData = data;
        terrain.terrainData.SetHeights(0, 0, map);
    }

	public void GenerateTerrain(TerrainData terrainData, float tileSize)
	{
		if(disableProceduralTerrain)
			return;

		_heightMap = new float[terrainData.heightmapWidth, terrainData.heightmapHeight];

		float width_2 = terrainData.heightmapWidth*0.5f;
		float height_2 = terrainData.heightmapHeight*0.5f;

		float aW = MathHelpers.RandomFromVec2(aWMinMax);
		float bW = MathHelpers.RandomFromVec2(bWMinMax);
		float cW = MathHelpers.RandomFromVec2(cWMinMax);
		float dW = MathHelpers.RandomFromVec2(dWMinMax);
		
		float bH = MathHelpers.RandomFromVec2(bHMinMax);
		float cH = MathHelpers.RandomFromVec2(cHMinMax);
	

		for (int i = 0; i < terrainData.heightmapWidth; i++)
		{
			for (int k = 0; k < terrainData.heightmapHeight; k++)
			{
				float xW = (float)(i - width_2);
				float xH = (float)(k - height_2);
				float heightAdjustW = aW*Mathf.Exp(- (Mathf.Pow((xW -bW),2)/(2*Mathf.Pow(cW,2)) + Mathf.Pow((xH-bH),2)/(2*Mathf.Pow(cH,2)))) + dW;

				_heightMap[i, k] = heightAdjustW +  MathHelpers.RandomFromVec2( perlinNoiseAmpMinMax )*Mathf.PerlinNoise(((float)i / (float)terrainData.heightmapWidth) * tileSize, ((float)k / (float)terrainData.heightmapHeight) * tileSize);
			}
		}

		terrainData.SetHeights(0, 0, _heightMap);

		SplatPrototype groundProto = new SplatPrototype();
		groundProto.texture = terrainTexture;
		groundProto.tileOffset = new Vector2(0f,0f);
		groundProto.tileSize = new Vector2(10f,10f);

		SplatPrototype snowProto = new SplatPrototype();
		snowProto.texture = snowTexture;
		snowProto.tileOffset = new Vector2(0f,0f);
		snowProto.tileSize = new Vector2(10f,10f);

		SplatPrototype[] prototypes = new SplatPrototype[2];
		prototypes[0] = groundProto;
		prototypes[1] = snowProto;
		terrainData.splatPrototypes = prototypes;

		_terrainTransform.localPosition = new Vector3( -0.5f*terrainData.size.x,0f,-0.5f*terrainData.size.z );

	}

    public override void Construct(TerrainData data)
    {
        Vector3 position = transform.position;

        for (int y = 0; y < data.Height; y++)
        {
            for (int x = 0; x < data.Width; x++)
            {
                if (data.GetData(x, y) > 0)
                {
                    float worldX = x * m_blockSize + position.x;
                    float worldZ = y * m_blockSize + position.z;
                    float worldY = position.y;

                    GameObject newBlock = (GameObject) Instantiate(m_blocks[data.GetData(x, y) - 1], new Vector3(worldX, worldY, worldZ),
                        Quaternion.identity);
                }
            }
        }

        List<EmptyTerrainBlock> emptyTerrain = new List<EmptyTerrainBlock>(FindObjectsOfType<EmptyTerrainBlock>());

        int bodyBlock = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_bodyItems[Random.Range(0, m_bodyItems.Length)], emptyTerrain[bodyBlock].transform.position + Vector3.up * m_blockSize * 0.5f + Vector3.up * m_itemOffset, Quaternion.identity);
        emptyTerrain.RemoveAt(bodyBlock);

        int headBlock = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_headItems[Random.Range(0, m_headItems.Length)], emptyTerrain[headBlock].transform.position + Vector3.up * m_blockSize * 0.5f + Vector3.up * m_itemOffset, Quaternion.identity);
        emptyTerrain.RemoveAt(headBlock);

        int leftArm = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_armItems[Random.Range(0, m_armItems.Length)], emptyTerrain[leftArm].transform.position + Vector3.up * m_blockSize * 0.5f + Vector3.up * m_itemOffset, Quaternion.identity);
        emptyTerrain.RemoveAt(leftArm);

        int rightArm = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_armItems[Random.Range(0, m_armItems.Length)], emptyTerrain[rightArm].transform.position + Vector3.up * m_blockSize * 0.5f + Vector3.up * m_itemOffset, Quaternion.identity);
        emptyTerrain.RemoveAt(rightArm);

        int leftLeg = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_legItems[Random.Range(0, m_legItems.Length)], emptyTerrain[leftLeg].transform.position + Vector3.up * m_blockSize * 0.5f + Vector3.up * m_itemOffset, Quaternion.identity);
        emptyTerrain.RemoveAt(leftLeg);

        int rightLeg = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_legItems[Random.Range(0, m_legItems.Length)], emptyTerrain[rightLeg].transform.position + Vector3.up * m_blockSize * 0.5f + Vector3.up * m_itemOffset, Quaternion.identity);
        emptyTerrain.RemoveAt(rightLeg);

        int startBlock = Random.Range(0, emptyTerrain.Count);
        Instantiate(m_startArea, emptyTerrain[bodyBlock].transform.position + Vector3.up * m_blockSize * 0.5f,
            Quaternion.identity);
        emptyTerrain.RemoveAt(startBlock);
    }

    void Awake()
    {
        Debug.Log("Awake WorldMap");
        MapTile tempMapTile;
        BitMapDecoder bmd = new BitMapDecoder(heightmap);
        terrainData = terrain.terrainData;
        int heighMapWidth = terrainData.heightmapWidth;
        int heighMapHeight = terrainData.heightmapHeight;
        float[,] tempFloat = terrainData.GetHeights(0, 0, heighMapWidth, heighMapHeight);
        tilesDictionary = new Dictionary<string, MapTile>();

        for (int z = 0; z < mapSizeZ; z++ ) {
            for (int x = 0; x < mapSizeX; x++) {
                tempMapTile = new MapTile(x,z);
                int height = BitMapDecoder.getHeightPos(x, z);
                tempMapTile.setY(height);
                //tempFloat[x*2+1, z*2+1] = height / 5;
                tempFloat[x * 2, z*2 * 2] = (float)height / 10;
                //tempFloat[x*2, z * 2+1] = height / 5;
                //tempFloat[x * 2 + 1, z * 2] = height / 5;

                tilesDictionary.Add(("x" + x.ToString() + "z" + z.ToString()), tempMapTile);
            }
        }
        terrain.terrainData.SetHeights(0, 0, tempFloat);
    }

 void Start()
 {
     tData = myTerrain.terrainData;
     xResolution = tData.heightmapWidth;
     zResolution = tData.heightmapHeight;
     heights = tData.GetHeights(0, 0, xResolution, zResolution);
 }