TalesOfNovariel/Assets/Scripts/Tile.cs

using Assets.Scripts;
using Newtonsoft.Json.Linq;
using System;
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();
    TileType tiletype;
    GameObject contentGenerator;

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

    public void generateTile(Vector3 pos, TileType type)
    {
        tiletype = type;
        SteamWorksHandler.getForestAchievement(type.ToString());
        contentGenerator = GameObject.Find("ContentGenerator");
        setPosition(pos);
        setBorders();
        generateContent();
    }

    public void Update()
    {
        
    }

    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()
    {
        foreach (Vector3 position in getSpawnLocations())
        {
            spawnObject(position);
        }
    }

    public List<Vector3> getSpawnLocations()
    {
        List<Vector3> list = new List<Vector3>();
        int xChange = 0;
        int zChange = 0;
        int sideLimiter = 0;
        if(tiletype == TileType.CITY){
            sideLimiter = 20;
        }
        else{
            sideLimiter = 10;
        }
        for (float i = borderNorth - sideLimiter; i >= borderSouth + sideLimiter; i = i - sideLimiter)
        {
            for (float j = borderWest + sideLimiter; j <= borderEast - sideLimiter; j = j + sideLimiter)
            {
                xChange = rand.Next(-2, +2);
                zChange = rand.Next(-2, +2);
                if(tiletype == TileType.CITY){
                    list.Add(new Vector3(j + xChange, 0, i + zChange));
                }
                else{
                    list.Add(new Vector3(j + xChange, 5, i + zChange));
                }
                
            }
        }
        return list;
    }

    public void spawnObject(Vector3 position)
    {
        int chance = rand.Next(1, 101);
        if (chance >= 25)
        {
            GameObject content = contentGenerator.GetComponent<ContentGenerator>().generateContent(tiletype.ToString());
            if (content != null)
            {
                if(tiletype == TileType.CITY && (content.tag.ToLower().Contains("npc") || content.tag.ToLower().Contains("tree") || content.tag.ToLower().Contains("stone") || content.tag.ToLower().Contains("ore"))){
                    position.y = 5;
                }
                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(TileType 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)
        {
            result = true;
        }
        return result;
    }

    public void changeRenderer()
    {
        foreach (Rigidbody rigid in gameObject.GetComponentsInChildren<Rigidbody>())
        {
            rigid.useGravity = !rigid.useGravity;
        }

        foreach (Renderer rend in gameObject.GetComponentsInChildren<Renderer>())
        {
            rend.enabled = !rend.enabled;
        }

        foreach (Collider col in gameObject.GetComponentsInChildren<Collider>())
        {
            col.enabled = !col.enabled;
        }
    }

    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)
    {
        aliveEnemies.Remove(enemy);
        Destroy(enemy);
    }

    public TileType 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 if(obj.name.ToLower().Contains("house")){
                result = result + obj.transform.Find("Door").GetComponent<Door>().saveHouse() + "\r\n}";
            }
            else if(obj.name.ToLower().Contains("npc")){
                result = result + obj.GetComponent<NPC>().saveNPC() + "\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);
                    }
                }
                else if(spawnedObject.name.ToLower().Contains("house")){
                    spawnedObject.transform.Find("Door").GetComponent<Door>().loadHouse(obj);
                }
                else if(spawnedObject.tag.ToLower().Contains("npc")){
                    spawnedObject.GetComponent<NPC>().loadQuest(obj["receivedQuest"].ToString());
                }
            }
        }
        tiletype = (TileType)Enum.Parse(typeof(TileType), json["tiletype"].ToString());
        setPosition(pos);
        setBorders();
    }

    public List<TileType> getPossibleNeighbours(){
        return TileTypeMethods.getPossibleNeighbours(tiletype);
    }
}