Added noise testing, created connected tiles

Assets/Scripts/NoiseGenerator.cs

@@ -17,7 +17,7 @@ public class NoiseGenerator
         else{
             applyNormalNoise(tile, map);
         }*/
-        applyNormalNoise(tile, map);
+        applyNewNoise(tile, map);
 
     }
 
@@ -46,6 +46,52 @@ public class NoiseGenerator
         tile.GetComponent<Tile>().setType(tiletype);
     }
 
+    private void applyNewNoise(GameObject tile, Dictionary<Vector3, GameObject> map)
+    {
+        //resetMesh(tile);
+        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Vector3[] vertices = mesh.vertices;
+        float[] samples;
+        Color32[] colors;
+        Color32 low;
+        Color32 high;
+        string tiletype = "";
+        samples = calculateBasicSamples(tile);
+
+        low = new Color32(0, 150, 0, 255);
+        high = new Color32(0, 110, 20, 255);
+
+        float lowestValue = 10;
+        float highestValue = 0;
+
+        for (int i = 0; i < samples.Length; i++)
+        {
+            if (lowestValue > samples[i])
+            {
+                lowestValue = samples[i];
+            }
+            if (highestValue < samples[i])
+            {
+                highestValue = samples[i];
+            }
+        }
+
+        float modifier = highestValue - lowestValue;
+
+        colors = new Color32[samples.Length];
+        for (int i = 0; i < samples.Length; i++)
+        {
+            colors[i] = Color32.Lerp(low, high, (1 / modifier) * (samples[i] - lowestValue));
+        }
+
+        for (int i = 0; i < samples.Length; i++)
+        {
+            vertices[i].y = samples[i] * 3;
+        }
+        applyMesh(tile, vertices, mesh, colors);
+        tile.GetComponent<Tile>().setType(tiletype);
+    }
+
     private void applyNormalNoise(GameObject tile, Dictionary<Vector3, GameObject> map)
     {
         //resetMesh(tile);
@@ -92,7 +138,7 @@ public class NoiseGenerator
             high = new Color32(0, 185, 0, 255);
             tiletype = "Plane";
         }
-        
+
 
         float lowestValue = 10;
         float highestValue = 0;
@@ -146,18 +192,16 @@ public class NoiseGenerator
         float[] samples = new float[vertices.Length];
         for (int i = 0; i < vertices.Length; i++)
         {
-            if (vertices[i].x != 5 && vertices[i].z != 5 && vertices[i].x != -5 && vertices[i].z != -5)
-            {
-                float xCord = tile.GetComponent<Tile>().getPosition().x + vertices[i].x / (vertices.Length - 1) * 10;
-                float yCord = tile.GetComponent<Tile>().getPosition().z + vertices[i].z / (vertices.Length - 1) * 10;
-                float sample = Mathf.PerlinNoise(xCord, yCord) - 0.1f * rand.Next(0, 6);
-                samples[i] = sample;
-            }
+            float xCord = tile.GetComponent<Tile>().getPosition().x + vertices[i].x / (vertices.Length - 1) * 10;
+            float yCord = tile.GetComponent<Tile>().getPosition().z + vertices[i].z / (vertices.Length - 1) * 10;
+            float sample = Mathf.PerlinNoise(xCord, yCord) - 0.1f * rand.Next(0, 6);
+            samples[i] = sample;
         }
         return samples;
     }
 
-    private float[] calculateSamplesCity(GameObject tile){
+    private float[] calculateSamplesCity(GameObject tile)
+    {
         Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
         Vector3[] vertices = mesh.vertices;
         float[] samples = new float[vertices.Length];
@@ -209,7 +253,7 @@ public class NoiseGenerator
         Vector3[] vertices = mesh.vertices;
         float[] samples = calculateBasicSamples(tile);
 
-        bool isVertical = (rand.Next(0,2) == 0 ? true : false);
+        bool isVertical = (rand.Next(0, 2) == 0 ? true : false);
         int startX = 0;
         int startZ = 0;
 
@@ -260,9 +304,9 @@ public class NoiseGenerator
             {
                 for (int k = 0; k < vertices.Length; k++)
                 {
-                    if (Mathf.Round(vertices[k].x) == randX+i && Mathf.Round(vertices[k].z) == randZ+j)
+                    if (Mathf.Round(vertices[k].x) == randX + i && Mathf.Round(vertices[k].z) == randZ + j)
                     {
-                        samples[k] = samples[k] - rand.Next(1,3) - 0.25f * rand.Next(0,4);
+                        samples[k] = samples[k] - rand.Next(1, 3) - 0.25f * rand.Next(0, 4);
                         break;
                     }
                 }
@@ -289,7 +333,7 @@ public class NoiseGenerator
         result = result + "\"vertices\": {\r\n";
         for (int i = 0; i < vertices.Length; i++)
         {
-            result = result + FileHandler.generateJSON("vertice"+i, "\"" + vertices[i].x + "/" + vertices[i].y + "/" + vertices[i].z + "\"");
+            result = result + FileHandler.generateJSON("vertice" + i, "\"" + vertices[i].x + "/" + vertices[i].y + "/" + vertices[i].z + "\"");
             if (i < vertices.Length - 1)
             {
                 result = result + ",\r\n";
@@ -318,7 +362,7 @@ public class NoiseGenerator
         Vector3[] vertices = new Vector3[verticeTokens.Count];
         JToken current;
         string[] parts;
-        for(int i = 0; i < colorTokens.Count;i++)
+        for (int i = 0; i < colorTokens.Count; i++)
         {
             current = colorTokens[i];
             parts = current.Value<string>().Split('/');

Assets/Scripts/Testing/NoiseTesting.cs

@@ -0,0 +1,204 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class NoiseTesting : MonoBehaviour
+{
+    System.Random rand = new System.Random();
+    Dictionary<Vector3, GameObject> mapGen;
+    Vector3 current;
+    Vector3 next;
+    public GameObject tilePrefab;
+    // Start is called before the first frame update
+    void Start()
+    {
+        mapGen = new Dictionary<Vector3, GameObject>();
+        current = new Vector3(0, 0, 0);
+        mapGen.Add(current, Instantiate(tilePrefab, current, Quaternion.identity));
+        applyNormalNoise(mapGen[current], mapGen);
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (Input.GetKeyDown(KeyCode.Space))
+        {
+            applyNormalNoise(mapGen[new Vector3(0, 0, 0)], mapGen);
+        }
+
+        if (Input.GetKeyDown(KeyCode.A))
+        {
+            next = current - new Vector3(100, 0, 0);
+        }
+        if (Input.GetKeyDown(KeyCode.W))
+        {
+            next = current - new Vector3(0, 0, -100);
+        }
+        if (Input.GetKeyDown(KeyCode.D))
+        {
+            next = current - new Vector3(-100, 0, 0);
+        }
+        if (Input.GetKeyDown(KeyCode.S))
+        {
+            next = current - new Vector3(0, 0, 100);
+        }
+
+        if (next != current)
+        {
+            current = next;
+            if (!mapGen.ContainsKey(current))
+            {
+                mapGen.Add(current, Instantiate(tilePrefab, current, Quaternion.identity));
+                applyNormalNoise(mapGen[current], mapGen);
+            }
+
+        }
+    }
+
+    private void applyNormalNoise(GameObject tile, Dictionary<Vector3, GameObject> map)
+    {
+        //resetMesh(tile);
+        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Vector3[] vertices = mesh.vertices;
+        //float[] samples = calculateBasicSamples(tile);
+        float[] samples = calculateConnectedSamples(tile);
+
+        Color32[] colors;
+        Color32 low = new Color32(0, 150, 0, 255);
+        Color32 high = new Color32(0, 110, 20, 255);
+        string tiletype = "";
+
+        float lowestValue = 10;
+        float highestValue = 0;
+
+        for (int i = 0; i < samples.Length; i++)
+        {
+            if (lowestValue > samples[i])
+            {
+                lowestValue = samples[i];
+            }
+            if (highestValue < samples[i])
+            {
+                highestValue = samples[i];
+            }
+        }
+
+        float modifier = highestValue - lowestValue;
+
+        colors = new Color32[samples.Length];
+        for (int i = 0; i < samples.Length; i++)
+        {
+            colors[i] = Color32.Lerp(low, high, (1 / modifier) * (samples[i] - lowestValue));
+        }
+
+        for (int i = 0; i < samples.Length; i++)
+        {
+            vertices[i].y = samples[i];// * 3;
+        }
+        applyMesh(tile, vertices, mesh, colors);
+        //tile.GetComponent<Tile>().setType(tiletype);
+    }
+
+    private void resetMesh(GameObject tile)
+    {
+        Mesh mesh = tile.GetComponent<MeshCollider>().sharedMesh;
+        Vector3[] vertices = mesh.vertices;
+        for (int i = 0; i < vertices.Length; i++)
+        {
+            vertices[i].y = 0;
+        }
+        mesh.vertices = vertices;
+        mesh.RecalculateBounds();
+        mesh.RecalculateNormals();
+        tile.GetComponent<MeshCollider>().sharedMesh = mesh;
+    }
+
+    private float[] calculateBasicSamples(GameObject tile)
+    {
+        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Vector3[] vertices = mesh.vertices;
+        float[] samples = new float[vertices.Length];
+        for (int i = 0; i < vertices.Length; i++)
+        {
+            float xCord = vertices[i].x / (vertices.Length - 1) * 10;
+            float zCord = vertices[i].z / (vertices.Length - 1) * 10;
+            float sample = Mathf.PerlinNoise(xCord, zCord) - 0.5f * rand.Next(0, 6);
+            samples[i] = sample;
+        }
+        return samples;
+    }
+
+    private float[] calculateConnectedSamples(GameObject tile)
+    {
+        //Working with "next" as index for tile to be generated
+        //Working with "mapGen" as map Placeholder to check against neighbours
+        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Vector3[] vertices = mesh.vertices;
+        float[] samples = Enumerable.Repeat(-100f, vertices.Length).ToArray();
+        int sideLength = Mathf.RoundToInt(Mathf.Sqrt(vertices.Length));
+        samples = connectSamples(samples, sideLength);
+
+        for (int i = 0; i < vertices.Length; i++)
+        {
+            if (samples[i] == -100)
+            {
+                float xCord = vertices[i].x / (vertices.Length - 1) * 10;
+                float zCord = vertices[i].z / (vertices.Length - 1) * 10;
+                float sample = Mathf.PerlinNoise(xCord, zCord) - 1f * rand.Next(0, 6);
+                samples[i] = sample;
+            }
+        }
+        return samples;
+    }
+
+    private void applyMesh(GameObject tile, Vector3[] vertices, Mesh mesh, Color32[] colors)
+    {
+        mesh.vertices = vertices;
+        mesh.RecalculateBounds();
+        mesh.RecalculateNormals();
+        mesh.colors32 = colors;
+        tile.GetComponent<MeshCollider>().sharedMesh = mesh;
+    }
+
+    private float[] connectSamples(float[] samples, int sideLength)
+    {
+        Mesh mesh;
+        Vector3[] vertices;
+
+        for (int i = 0; i < sideLength; i++)
+        {
+            if (mapGen.ContainsKey(next - new Vector3(100, 0, 0)))
+            { //LINKS
+                mesh = mapGen[next - new Vector3(100, 0, 0)].GetComponent<MeshFilter>().mesh;
+                vertices = mesh.vertices;
+                samples[sideLength - 1 + sideLength * i] = vertices[sideLength * i].y;
+            }
+
+            if (mapGen.ContainsKey(next - new Vector3(-100, 0, 0)))
+            { //RECHTS
+                mesh = mapGen[next - new Vector3(-100, 0, 0)].GetComponent<MeshFilter>().mesh;
+                vertices = mesh.vertices;
+                samples[sideLength * i] = vertices[sideLength - 1 + sideLength * i].y;
+            }
+
+            if (mapGen.ContainsKey(next - new Vector3(0, 0, -100)))
+            { //OBEN
+                mesh = mapGen[next - new Vector3(0, 0, -100)].GetComponent<MeshFilter>().mesh;
+                vertices = mesh.vertices;
+                samples[i] = vertices[(sideLength * sideLength) - (sideLength-i)].y;
+            }
+
+            if (mapGen.ContainsKey(next - new Vector3(0, 0, 100)))
+            { //UNTEN
+                mesh = mapGen[next - new Vector3(0, 0, 100)].GetComponent<MeshFilter>().mesh;
+                vertices = mesh.vertices;
+                samples[(sideLength * sideLength) - (sideLength-i)] = vertices[i].y;
+            }
+        }
+
+        return samples;
+    }
+}

Assets/Scripts/Testing/NoiseTesting.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 21edae6d584d6527bbb87c3393c1274f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Testing/Tile.prefab

@@ -0,0 +1,228 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &1432760222041494230
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1418724594657166519}
+  - component: {fileID: 592371478074520587}
+  - component: {fileID: 1441453626542042980}
+  - component: {fileID: 7385324898674005301}
+  - component: {fileID: 7807969927081444678}
+  m_Layer: 0
+  m_Name: pnlWater
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 4294967295
+  m_IsActive: 1
+--- !u!4 &1418724594657166519
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1432760222041494230}
+  serializedVersion: 2
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: -2, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 7573435787306895636}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &592371478074520587
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1432760222041494230}
+  m_Mesh: {fileID: 10209, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &1441453626542042980
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1432760222041494230}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 52b7d70b1de7c4ce09662b77c14d9fda, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!64 &7385324898674005301
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1432760222041494230}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 1
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 5
+  m_Convex: 1
+  m_CookingOptions: 30
+  m_Mesh: {fileID: 10209, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!114 &7807969927081444678
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1432760222041494230}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0d2f50a8e0bb841a5aaa90ae55db8849, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!1 &7573435787306895624
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 7573435787306895636}
+  - component: {fileID: 7573435787306895637}
+  - component: {fileID: 7573435787306895626}
+  - component: {fileID: 7602326841346784209}
+  m_Layer: 0
+  m_Name: Tile
+  m_TagString: Tile
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 4294967295
+  m_IsActive: 1
+--- !u!4 &7573435787306895636
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7573435787306895624}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -109.4, y: 0, z: 0}
+  m_LocalScale: {x: 10, y: 1, z: 10}
+  m_ConstrainProportionsScale: 0
+  m_Children:
+  - {fileID: 1418724594657166519}
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &7573435787306895637
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7573435787306895624}
+  m_Mesh: {fileID: 10209, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &7573435787306895626
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7573435787306895624}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 8e83d1b6a2b235d4bb5b64e3d386b16c, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!64 &7602326841346784209
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 7573435787306895624}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 5
+  m_Convex: 0
+  m_CookingOptions: 30
+  m_Mesh: {fileID: 10209, guid: 0000000000000000e000000000000000, type: 0}

Assets/Scripts/Testing/Tile.prefab.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a3113b7ce76b2d5c1998c0dadca2acdd
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/WorldGenerator.cs

@@ -51,7 +51,7 @@ public class WorldGenerator : MonoBehaviour
                 Destroy(tile);
             }
         }
-        player.transform.position = new Vector3(0, 1.5f, 0);
+        player.transform.position = new Vector3(0, 4f, 0);
         player.transform.rotation = Quaternion.identity;
         OnEnable();
         this.cityAmount = cityAmount;