Reworked tile generation, removed map, redone colour scheme, v1.2.0

Assets/Scripts/ContentGenerator.cs

@@ -28,6 +28,14 @@ public class ContentGenerator : MonoBehaviour
                 return generateStoneTileContent();
             case "TreeTile":
                 return generateTreeTileContent();
+            case "RiverTile1":
+                return generateRiverTileContent();
+            case "RiverTile2":
+                return generateRiverTileContent();
+            case "RiverTile3":
+                return generateRiverTileContent();
+            case "LakeTile":
+                return generateLakeTileContent();
         }
         return null;
     }
@@ -41,7 +49,7 @@ public class ContentGenerator : MonoBehaviour
         }
         else if (chance >= 50 && chance < 90)
         {
-            if (rand.Next(0,trees.Length) == 0)
+            if (rand.Next(0,2) == 0)
             {
                 return trees[rand.Next(0, trees.Length)];
             }
@@ -101,4 +109,53 @@ public class ContentGenerator : MonoBehaviour
             return boss;
         }
     }
+
+    public GameObject generateRiverTileContent()
+    {
+        int chance = rand.Next(1, 101);
+        if (chance < 50)
+        {
+            return null;
+        }
+        else if (chance >= 50 && chance < 90)
+        {
+            if (rand.Next(0, 2) == 0)
+            {
+                return trees[rand.Next(0, trees.Length)];
+            }
+            else
+            {
+                return stones[rand.Next(0, stones.Length)];
+            }
+        }
+        else if (chance >= 90 && chance < 99)
+        {
+            return generateEnemy();
+        }
+        else
+        {
+            return boss;
+        }
+    }
+
+    public GameObject generateLakeTileContent()
+    {
+        int chance = rand.Next(1, 101);
+        if (chance < 75)
+        {
+            return null;
+        }
+        else if (chance >= 75 && chance < 90)
+        {
+            return stones[rand.Next(0, stones.Length)];
+        }
+        else if (chance >= 90 && chance < 99)
+        {
+            return generateEnemy();
+        }
+        else
+        {
+            return boss;
+        }
+    }
 }

Assets/Scripts/Controls.cs

@@ -41,12 +41,7 @@ public class Controls : MonoBehaviour
         if (uihandler.canPlayerMove())
         {
             player.GetComponent<Player>().move();
-            if (Input.GetKeyDown(KeyCode.M))
-            {
-                worldGen.GetComponent<WorldGenerator>().prepareMap();
-                uihandler.switchMap();
-            }
-            else if (Input.GetKeyDown(KeyCode.E))
+            if (Input.GetKeyDown(KeyCode.E))
             {
                 GameObject target = playerCam.GetComponent<PlayerCamera>().interactWithObject();
                 if (target != null)

Assets/Scripts/Map.cs

@@ -1,88 +0,0 @@
-using Assets.Scripts;
-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEngine.UI;
-
-public class Map : MonoBehaviour
-{
-    public Image city;
-    public Image plains;
-    public Image forest;
-    public Image stone;
-    public Image spawn;
-    public Image lake;
-    public Image river;
-    public Image[] mapTiles;
-
-    public void prepare(Dictionary<Vector3, GameObject> tiles, GameObject currentTile)
-    {
-        destroyMap();
-        generateMap(tiles, currentTile);
-    }
-
-    private void destroyMap()
-    {
-        for (int i = 0; i < mapTiles.Length; i++)
-        {
-            mapTiles[i].color = Color.white;
-        }
-    }
-
-    private void generateMap(Dictionary<Vector3, GameObject> tiles, GameObject currentTile)
-    {
-        Vector3 current = currentTile.GetComponent<Tile>().getPosition();
-
-        Vector3 position;
-        Color color;
-
-        int posX = (int)current.x - 2;
-        int posZ = (int)current.z + 2;
-        for (int i = 0; i < mapTiles.Length; i++)
-        {
-            if (i == 5 || i == 10 || i == 15 || i == 20)
-            {
-                posX = (int)current.x - 2;
-                posZ--;
-            }
-
-            position = new Vector3(posX, 0, posZ);
-
-            if (tiles.ContainsKey(position))
-            {
-                switch (tiles[position].name.Split('_')[0])
-                {
-                    case "StoneTile":
-                        color = stone.color;
-                        break;
-                    case "CityTile":
-                        color = city.color;
-                        break;
-                    case "Tile":
-                        color = plains.color;
-                        break;
-                    case "TreeTile":
-                        color = forest.color;
-                        break;
-                    case "RiverTile1":
-                        color = river.color;
-                        break;
-                    case "RiverTile2":
-                        color = river.color;
-                        break;
-                    case "RiverTile3":
-                        color = river.color;
-                        break;
-                    case "LakeTile":
-                        color = lake.color;
-                        break;
-                    default:
-                        color = spawn.color;
-                        break;
-                }
-                mapTiles[i].color = color;
-            }
-            posX++;
-        }
-    }
-}

Assets/Scripts/NewTileScript.cs

@@ -0,0 +1,203 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class NewTileScript : MonoBehaviour
+{
+    Vector3 position;
+    float borderNorth;
+    float borderEast;
+    float borderSouth;
+    float borderWest;
+    System.Random rand = new System.Random();
+    string tilename;
+    GameObject contentGenerator;
+
+    List<GameObject> aliveEnemies = new List<GameObject>();
+    List<GameObject> deadEnemies = new List<GameObject>();
+
+    public void generateTile(Vector3 pos, string name)
+    {
+        tilename = name;
+        //contentGenerator = GameObject.Find("ContentGenerator");
+        setPosition(pos);
+        setBorders();
+        //generateContent();
+    }
+
+    public void setBorders()
+    {
+        borderNorth = position.z * 100 + 50;
+        borderEast = position.x * 100 + 50;
+        borderSouth = position.z * 100 - 50;
+        borderWest = position.x * 100 - 50;
+    }
+
+    public void generateContent()
+    {
+        if (!tilename.ToLower().Equals("City"))
+        {
+            foreach (Vector3 position in getSpawnLocations())
+            {
+                spawnObject(position);
+            }
+        }
+    }
+
+    public List<Vector3> getSpawnLocations()
+    {
+        List<Vector3> list = new List<Vector3>();
+        int xChange = 0;
+        int zChange = 0;
+        for (float i = borderNorth - 10; i >= borderSouth + 10; i = i - 10)
+        {
+            for (float j = borderWest + 10; j <= borderEast - 10; j = j + 10)
+            {
+                xChange = rand.Next(-4, +4);
+                zChange = rand.Next(-4, +4);
+                list.Add(new Vector3(j + xChange, 5, i + zChange));
+            }
+        }
+        return list;
+    }
+
+    public void spawnObject(Vector3 position)
+    {
+        int chance = rand.Next(1, 101);
+        if (chance >= 50)
+        {
+            GameObject content = contentGenerator.GetComponent<ContentGenerator>().generateContent(tilename);
+            if (content != null)
+            {
+                GameObject obj = Instantiate(content, position, Quaternion.identity);
+                obj.transform.parent = gameObject.transform;
+                if (obj.tag.Contains("Enemy"))
+                {
+                    aliveEnemies.Add(obj);
+                }
+            }
+        }
+    }
+
+    public void setPosition(Vector3 position)
+    {
+        this.position = position;
+    }
+
+    public Vector3 getPosition()
+    {
+        return position;
+    }
+
+    public bool leftTile(float playerX, float playerZ)
+    {
+        bool result = false;
+        if (playerX >= borderEast + 10 || playerX <= borderWest - 10 || playerZ >= borderNorth + 10 || playerZ <= borderSouth - 10)
+        {
+            changeRenderer();
+            result = true;
+        }
+        return result;
+    }
+
+    public void changeRenderer()
+    {
+        foreach (Rigidbody rigid in gameObject.GetComponentsInChildren<Rigidbody>())
+        {
+            if (!deadEnemies.Contains(rigid.gameObject))
+            {
+                rigid.useGravity = !rigid.useGravity;
+            }
+        }
+
+        foreach (Renderer rend in gameObject.GetComponentsInChildren<Renderer>())
+        {
+            if (!deadEnemies.Contains(rend.gameObject))
+            {
+                rend.enabled = !rend.enabled;
+            }
+        }
+
+        foreach (Collider col in gameObject.GetComponentsInChildren<Collider>())
+        {
+            if (!deadEnemies.Contains(col.gameObject))
+            {
+                col.enabled = !col.enabled;
+            }
+        }
+    }
+
+    public void resetSpawn()
+    {
+        foreach (Rigidbody rigid in gameObject.GetComponentsInChildren<Rigidbody>())
+        {
+            rigid.useGravity = true;
+        }
+
+        foreach (Renderer rend in gameObject.GetComponentsInChildren<Renderer>())
+        {
+            rend.enabled = true;
+        }
+
+        foreach (Collider col in gameObject.GetComponentsInChildren<Collider>())
+        {
+            col.enabled = true;
+        }
+    }
+
+    public bool enteredTile(float playerX, float playerZ)
+    {
+        bool result = false;
+        if (playerX <= borderEast && playerX >= borderWest && playerZ <= borderNorth && playerZ >= borderSouth)
+        {
+            result = true;
+        }
+        return result;
+    }
+
+    public Vector3 needConnectedTile(float playerX, float playerZ)
+    {
+        Vector3 result = new Vector3(position.x, 1, position.z);
+        if (playerX >= borderEast - 10)
+        {
+            result.x = result.x + 1;
+            result.y = 0;
+        }
+        else if (playerX <= borderWest + 10)
+        {
+            result.x = result.x - 1;
+            result.y = 0;
+        }
+
+        if (playerZ >= borderNorth - 10)
+        {
+            result.z = result.z + 1;
+            result.y = 0;
+        }
+        else if (playerZ <= borderSouth + 10)
+        {
+            result.z = result.z - 1;
+            result.y = 0;
+        }
+        return result;
+    }
+
+    public bool removeConnectedTiles(float playerX, float playerZ)
+    {
+        bool result = false;
+        if (playerX <= borderEast - 10 && playerX >= borderWest + 10 && playerZ <= borderNorth - 10 && playerZ >= borderSouth + 10)
+        {
+            result = true;
+        }
+        return result;
+    }
+
+    public void enemyKilled(GameObject enemy)
+    {
+        deadEnemies.Add(enemy);
+        enemy.GetComponent<Rigidbody>().useGravity = false;
+        enemy.GetComponent<Renderer>().enabled = false;
+        enemy.GetComponent<Collider>().enabled = false;
+        aliveEnemies.Remove(enemy);
+    }
+}

Assets/Scripts/NewTileScript.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 3a168312b9f89044eac3b72d87cde0ac
+guid: 4d53b2b3bfaa3874885a1bc9b08093dc
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Scripts/NoiseGenerator.cs

@@ -4,94 +4,193 @@ using UnityEngine;
 
 public class NoiseGenerator
 {
-    public void applyTileNoise(GameObject tile)
+    System.Random rand = new System.Random();
+    public void applyNoise(GameObject tile)
     {
+        //resetMesh(tile);
         Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
         Vector3[] vertices = mesh.vertices;
-        float[] samples = calculateSamples(tile, 0.5f);
+        float[] samples;
+        Color32[] colors;
+        Color32 low;
+        Color32 high;
+        int chance = rand.Next(1, 101);
+        if (chance > 85 && chance <= 100)
+        {
+            samples = calculateSamplesForest(tile);
+            low = new Color32(0, 150, 0, 255);
+            high = new Color32(0, 110, 20, 255);
+        }
+        else if (chance > 70 && chance <= 85)
+        {
+            samples = calculateSamplesMountain(tile);
+            low = new Color32(0, 150, 0, 255);
+            high = new Color32(140, 140, 140, 255);
+        }
+        else if (chance > 55 && chance <= 70)
+        {
+            samples = calculateSamplesLake(tile);
+            low = new Color32(30, 110, 190, 255);
+            high = new Color32(0, 150, 0, 255);
+        }
+        else if (chance > 40 && chance <= 55)
+        {
+            samples = calculateSamplesRiver(tile);
+            low = new Color32(30, 160, 190, 255);
+            high = new Color32(0, 150, 0, 255);
+        }
+        else
+        {
+            samples = calculateSamplesPlane(tile);
+            low = new Color32(0, 150, 0, 255);
+            high = new Color32(0, 185, 0, 255);
+        }
+
+        float lowestValue = 10;
+        float highestValue = 0;
+
         for (int i = 0; i < samples.Length; i++)
         {
-            vertices[i].y = samples[i] * 5;
+            if (lowestValue > samples[i])
+            {
+                lowestValue = samples[i];
+            }
+            if (highestValue < samples[i])
+            {
+                highestValue = samples[i];
+            }
         }
-        applyMesh(tile, vertices, mesh);
-    }
 
-    public void applyStoneTileNoise(GameObject tile)
-    {
-        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
-        Vector3[] vertices = mesh.vertices;
-        float[] samples = calculateSamples(tile, 0.5f);
+        float modifier = highestValue - lowestValue;
+        if (lowestValue < 0)
+        {
+            lowestValue = lowestValue * -1;
+        }
+
+        colors = new Color32[samples.Length];
         for (int i = 0; i < samples.Length; i++)
         {
-            vertices[i].y = samples[i] * 10;
+            colors[i] = Color32.Lerp(low, high, (samples[i] * modifier) + lowestValue);
         }
-        applyMesh(tile, vertices, mesh);
-    }
 
-    public void applyTreeTileNoise(GameObject tile)
-    {
-        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
-        Vector3[] vertices = mesh.vertices;
-        float[] samples = calculateSamples(tile, 0.5f);
         for (int i = 0; i < samples.Length; i++)
         {
-            vertices[i].y = samples[i] * 7.5f;
+            vertices[i].y = samples[i] * 3;
         }
-        applyMesh(tile, vertices, mesh);
+        applyMesh(tile, vertices, mesh, colors);
     }
 
-    public void applyRiverTileNoise(GameObject tile)
+    private void resetMesh(GameObject tile)
     {
-        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Mesh mesh = tile.GetComponent<MeshCollider>().sharedMesh;
         Vector3[] vertices = mesh.vertices;
-        float[] samples = calculateSamples(tile, 0.5f);
-        for (int i = 0; i < samples.Length; i++)
+        for (int i = 0; i < vertices.Length; i++)
         {
-            vertices[i].y = samples[i] * 7.5f;
+            vertices[i].y = 0;
         }
-        applyMesh(tile, vertices, mesh);
+        mesh.vertices = vertices;
+        mesh.RecalculateBounds();
+        mesh.RecalculateNormals();
+        tile.GetComponent<MeshCollider>().sharedMesh = mesh;
     }
 
-    public void applyLakeTileNoise(GameObject tile)
+    private float[] calculateBasicSamples(GameObject tile)
     {
         Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
         Vector3[] vertices = mesh.vertices;
-        float[] samples = calculateSamples(tile, 1.5f);
-        for (int i = 0; i < samples.Length; i++)
-        {
-            vertices[i].y = samples[i] * 2;
-        }
-        applyMesh(tile, vertices, mesh);
-    }
-
-    public void applyCityTileNoise(GameObject tile)
-    {
-        //Currently no noise. (Objects floating)
-    }
-
-    private float[] calculateSamples(GameObject tile, float modifier)
-    {
-        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
-        Vector3[] vertices = mesh.vertices;
-        float[] samples = new float[vertices.Length - 1];
+        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) - modifier;
+                float sample = Mathf.PerlinNoise(xCord, yCord);
                 samples[i] = sample;
             }
         }
         return samples;
     }
 
-    private void applyMesh(GameObject tile, Vector3[] vertices, Mesh mesh)
+    private float[] calculateSamplesPlane(GameObject tile)
+    {
+        float[] samples = calculateBasicSamples(tile);
+        Debug.Log("Plane");
+        return samples;
+    }
+
+    private float[] calculateSamplesForest(GameObject tile)
+    {
+        float[] samples = calculateBasicSamples(tile);
+        Debug.Log("Forest");
+        return samples;
+    }
+
+    private float[] calculateSamplesMountain(GameObject tile)
+    {
+        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Vector3[] vertices = mesh.vertices;
+        float[] samples = calculateBasicSamples(tile);
+
+        int amount = rand.Next(1, 5);
+        int index = 0;
+        for (int i = 0; i < amount; i++)
+        {
+            do
+            {
+                index = rand.Next(0, samples.Length);
+                if (vertices[index].x != 5 && vertices[index].z != 5 && vertices[index].x != -5 && vertices[index].z != -5)
+                {
+                    samples[index] = 3;
+                    break;
+                }
+            } while (true);
+        }
+        Debug.Log("Mountain");
+        return samples;
+    }
+
+    private float[] calculateSamplesRiver(GameObject tile)
+    {
+        float[] samples = calculateBasicSamples(tile);
+        Debug.Log("River");
+        return samples;
+    }
+
+    private float[] calculateSamplesLake(GameObject tile)
+    {
+        Mesh mesh = tile.GetComponent<MeshFilter>().mesh;
+        Vector3[] vertices = mesh.vertices;
+        float[] samples = calculateBasicSamples(tile);
+
+        int randX = rand.Next(-4, 5);
+        int randZ = rand.Next(-4, 5);
+
+        for (int i = -1; i < 2; i++)
+        {
+            for (int j = -1; j < 2; j++)
+            {
+                for (int k = 0; k < vertices.Length; k++)
+                {
+                    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);
+                        break;
+                    }
+                }
+            }
+        }
+        Debug.Log("Lake");
+        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;
     }
 }

Assets/Scripts/UIHandler.cs

@@ -10,7 +10,6 @@ namespace Assets.Scripts
 {
     public class UIHandler : MonoBehaviour
     {
-        public GameObject map;
         public GameObject compass;
         public GameObject information;
         public GameObject fight;
@@ -141,18 +140,6 @@ namespace Assets.Scripts
             GameObject.Find("Player").GetComponent<Player>().generatePlayer(playerRace, playerClass, name, GameObject.Find("dropDifficulty").GetComponent<Dropdown>().value);
         }
 
-        public void switchMap()
-        {
-            if (state == UIState.MAP)
-            {
-                closeMap();
-            }
-            else
-            {
-                openMap();
-            }
-        }
-
         public void switchCharactersheet()
         {
             if (state == UIState.CHARACTER)
@@ -223,20 +210,6 @@ namespace Assets.Scripts
             state = UIState.GAME;
         }
 
-        public void openMap()
-        {
-            hideOtherElements(map);
-            map.transform.localScale = new Vector3(1, 1, 1);
-            state = UIState.MAP;
-        }
-
-        public void closeMap()
-        {
-            map.transform.localScale = new Vector3(0, 0, 0);
-            showHUD();
-            state = UIState.GAME;
-        }
-
         public void openFight()
         {
             GameObject.Find("txtRounds").GetComponent<Text>().text = "-1";

Assets/Scripts/WorldGenerator.cs

@@ -7,10 +7,8 @@ using UnityEngine.UI;
 public class WorldGenerator : MonoBehaviour
 {
     public GameObject player;
-    public GameObject[] prefabsHighProbability; // 50%
-    public GameObject[] prefabsMiddleProbability; // 35%
-    public GameObject[] prefabsLowProbability; // 10%
-    public GameObject[] prefabsLowestProbability; // 5%
+    public GameObject city;
+    public GameObject tile;
     Dictionary<Vector3, GameObject> tiles;
     GameObject currentTile;
     List<GameObject> renderedTiles;
@@ -65,11 +63,6 @@ public class WorldGenerator : MonoBehaviour
         resetPlayer();
     }
 
-    public void prepareMap()
-    {
-        GameObject.Find("Map").GetComponent<Map>().prepare(tiles, currentTile);
-    }
-
     void resetPlayer()
     {
         if (player.transform.position.y <= -5)
@@ -84,37 +77,28 @@ public class WorldGenerator : MonoBehaviour
         Vector3 pos = currentTile.GetComponent<Tile>().needConnectedTile(playerX, playerZ);
         if (!tiles.ContainsKey(pos) && pos.y == 0)
         {
-            int chance = rand.Next(1,101);
-            GameObject[] usedArray;
-            if (chance > 50)
+            GameObject newTile;
+            string name;
+            int chance = rand.Next(1,11);
+            Vector3 mapPos = new Vector3(pos.x * 100, 0, pos.z * 100);
+            if (chance == 1)
             {
-                usedArray = prefabsHighProbability;
-            }
-            else if (chance > 15 && chance <= 50)
-            {
-                usedArray = prefabsMiddleProbability;
-            }
-            else if (chance > 5 && chance <= 15)
-            {
-                usedArray = prefabsLowProbability;
+                newTile = Instantiate(city, mapPos, Quaternion.identity);
+                name = city.name;
             }
             else
             {
-                usedArray = prefabsLowestProbability;
+                newTile = Instantiate(tile, mapPos, Quaternion.identity);
+                name = tile.name;
+                noise.applyNoise(newTile);
             }
 
-            int index = rand.Next(0, usedArray.Length);
-
-            Vector3 mapPos = new Vector3(pos.x * 100, 0, pos.z * 100);
-            GameObject newTile = Instantiate(usedArray[index], mapPos, Quaternion.identity);
-            string name = usedArray[index].name;
             if (name.Contains("_"))
             {
                 name = name.Split('_')[0];
             }
             newTile.name = name + "_" + tiles.Count;
             newTile.GetComponent<Tile>().generateTile(pos, name);
-            applyNoise(newTile, name.Split('_')[0]);
             tiles.Add(pos, newTile);
             renderedTiles.Add(newTile);
         }
@@ -131,37 +115,6 @@ public class WorldGenerator : MonoBehaviour
         }
     }
 
-    private void applyNoise(GameObject tile, string type)
-    {
-        switch (type.ToLower())
-        {
-            case "tile":
-                noise.applyTileNoise(tile);
-                break;
-            case "stonetile":
-                noise.applyStoneTileNoise(tile);
-                break;
-            case "treetile":
-                noise.applyTreeTileNoise(tile);
-                break;
-            case "citytile":
-                noise.applyCityTileNoise(tile);
-                break;
-            case "rivertile1":
-                noise.applyRiverTileNoise(tile);
-                break;
-            case "rivertile2":
-                noise.applyRiverTileNoise(tile);
-                break;
-            case "rivertile3":
-                noise.applyRiverTileNoise(tile);
-                break;
-            case "laketile":
-                noise.applyLakeTileNoise(tile);
-                break;
-        }
-    }
-
     public void hideTile(float playerX, float playerZ)
     {
         if (currentTile.GetComponent<Tile>().leftTile(playerX, playerZ))