TalesOfNovariel/Assets/Scripts/Tile.cs

using Assets.Scripts;
using Newtonsoft.Json.Linq;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class Tile : MonoBehaviour
{
    Vector3 position;
    float borderNorth;
    float borderEast;
    float borderSouth;
    float borderWest;
    System.Random rand = new System.Random();
    string tiletype;
    GameObject contentGenerator;

    List<GameObject> aliveEnemies = new List<GameObject>();
    List<GameObject> deadEnemies = new List<GameObject>();

    public void generateTile(Vector3 pos, string type)
    {
        if (tiletype == null)
        {
            tiletype = type;
        }
        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 (!tiletype.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(tiletype);
            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 void setType(string tiletype)
    {
        this.tiletype = tiletype;
    }

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

    public string getTileType()
    {
        return tiletype;
    }

    public void saveTile(string path)
    {
        string result = "{\r\n";
        GameObject obj;
        result = result + FileHandler.generateJSON("tiletype", "\"" + tiletype + "\"") + ",\r\n";
        result = result + FileHandler.generateJSON("position", "\"" + position.x + "/" + position.y + "/" + position.z + "\"") + ",\r\n";
        result = result + "\"objects\": {\r\n";
        for (int i = 0; i < gameObject.transform.childCount; i++)
        {
            obj = gameObject.transform.GetChild(i).gameObject;
            result = result + "\"object" + i + "\": {\r\n";
            result = result + FileHandler.generateJSON("position", "\"" + obj.transform.position.x + "/" + obj.transform.position.y + "/" + obj.transform.position.z + "\"") + ",\r\n";
            if (obj.tag.Contains("Enemy"))
            {
                result = result + obj.GetComponent<Enemy>().saveEnemy() + "\r\n}";
            }
            else
            {
                result = result + FileHandler.generateJSON("objectname", "\"" + obj.name + "\"") + "\r\n}";
            }
            if (i < gameObject.transform.childCount - 1)
            {
                result = result + ",\r\n";
            }
        }
        result = result + "\r\n},";
        FileHandler.saveTile(result, path);
    }

    public string saveCurrent()
    {
        string result = "";
        result = result + "\"" + position.x + "/" + position.y + "/" + position.z + "\"";
        return result;
    }

    public void loadTile(JToken json, Vector3 pos)
    {
        var jsonData = JObject.Parse(json["objects"].ToString()).Children();
        List<JToken> tokens = jsonData.Children().ToList();
        contentGenerator = GameObject.Find("ContentGenerator");
        GameObject spawnedObject;
        Vector3 position;
        foreach (JToken obj in tokens)
        {
            if (obj["objectname"] != null)
            {
                if (obj["objectname"].ToString() != "pnlWater")
                {
                    spawnedObject = contentGenerator.GetComponent<ContentGenerator>().loadObject(obj);
                }
                else
                {
                    spawnedObject = null;
                }
            }
            else
            {
                spawnedObject = contentGenerator.GetComponent<ContentGenerator>().loadEnemy(obj);
            }
            if (spawnedObject != null)
            {
                position = new Vector3(float.Parse(obj["position"].ToString().Split('/')[0]), float.Parse(obj["position"].ToString().Split('/')[1]), float.Parse(obj["position"].ToString().Split('/')[2]));
                spawnedObject = Instantiate(spawnedObject, position, Quaternion.identity);
                spawnedObject.transform.parent = gameObject.transform;
                if (spawnedObject.tag.Contains("Enemy"))
                {
                    aliveEnemies.Add(spawnedObject);
                    if (obj["health"] != null)
                    {
                        spawnedObject.GetComponent<Enemy>().loadEnemy(obj);
                    }
                }
            }
        }
        tiletype = json["tiletype"].ToString();
        setPosition(pos);
        setBorders();
    }
}