Region2D

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using Newtonsoft.Json;

namespace Movement2D
{
    public delegate void Triggering(Region2D other);

    public class Region2D : MonoBehaviour
    {
        public static string[] Tags
        {
            get
            {
                return Region2DSerialization.Tags;
            }

            set
            {
                TagsArray ta = new TagsArray()
                {
                    tags = value
                };

                Region2DSerialization.SerializeArray(ta, "tags");
                Region2DSerialization.Tags = null;
            }
        }

        public static bool[][] Collisions
        {
            get
            {
                return Region2DSerialization.Collisions;
            }

            set
            {
                string[][] arr = new string[value.Length][];

                for (int i = 0; i < arr.Length; i++)
                {
                    arr[i] = new string[arr.Length];
                    for (int j = 0; j < arr[i].Length; j++)
                    {
                        arr[i][j] = value[i][j].ToString();
                    }
                }

                CollisionsArray ca = new CollisionsArray()
                {
                    collisions = arr
                };

                Region2DSerialization.SerializeArray(ca, "collisions");
                Region2DSerialization.Collisions = null;
            }
        }

        public bool isStatic = true;
        public bool isTrigger = false;
        public int regionTag;
        public Vector2Int size = Vector2Int.one;
        public bool respectScale;
        public bool showWhenNotSelected = true;

        public event Triggering TriggerEnter;
        public event Triggering TriggerExit;
        public event Triggering TriggerStay;

        private Vector2Int Size
        {
            get
            {
                return size * (respectScale ? Vector2Int.RoundToInt(transform.localScale) : Vector2Int.one);
            }
        }

        private Vector3 prevPos;
        private Vector3 prevScale;
        private List<Tile> tilesOccupied;
        private List<Region2D> regions_lastFrame = new List<Region2D>();

        private void OnDrawGizmosSelected()
        {
            float i = isStatic ? 160f : 230f;
            Gizmos.color = isTrigger ? new Color(0, 0, i / 255f) : new Color(0, i / 255f, 0);
            Gizmos.DrawLine(transform.position, transform.position + Size.y * Vector3.up);
            Gizmos.DrawLine(transform.position, transform.position + Size.x * Vector3.right);
            Gizmos.DrawLine(transform.position + Size.y * Vector3.up, transform.position + Size.y * Vector3.up + Size.x * Vector3.right);
            Gizmos.DrawLine(transform.position + Size.x * Vector3.right, transform.position + Size.x * Vector3.right + Size.y * Vector3.up);
        }

        private void OnDrawGizmos()
        {
            if (!showWhenNotSelected) return;

            float i = isStatic ? 160f : 230f;
            Gizmos.color = isTrigger ? new Color(0, 0, i / 255f, 0.2f) : new Color(0, i / 255f, 0, 0.2f);
            Gizmos.DrawLine(transform.position, transform.position + Size.y * Vector3.up);
            Gizmos.DrawLine(transform.position, transform.position + Size.x * Vector3.right);
            Gizmos.DrawLine(transform.position + Size.y * Vector3.up, transform.position + Size.y * Vector3.up + Size.x * Vector3.right);
            Gizmos.DrawLine(transform.position + Size.x * Vector3.right, transform.position + Size.x * Vector3.right + Size.y * Vector3.up);
        }

        private void Start()
        {
            prevPos = transform.position;
            prevScale = transform.lossyScale;
            tilesOccupied = new List<Tile>();

            OccupyTiles();
        }

        private void Update()
        {
            if (prevPos != transform.position || prevScale != transform.lossyScale)
            {
                if (!isStatic) OccupyTiles();
                else Debug.LogWarning(String.Format("Static Region2D moved ({0}).", name));
            }

            prevPos = transform.position;
            prevScale = transform.lossyScale;
        }

        private void FixedUpdate()
        {
            UpdateRegions();
        }

        private void UpdateRegions()
        {
            List<Region2D> regions_current = new List<Region2D>();

            for (int i = 0; i < tilesOccupied.Count; i++)
                for (int j = 0; j < tilesOccupied[i].regionsInMe.Count; j++)
                    if (tilesOccupied[i].regionsInMe[j] != this && !regions_current.Contains(tilesOccupied[i].regionsInMe[j]))
                        regions_current.Add(tilesOccupied[i].regionsInMe[j]);

            List<Region2D> commons;
            List<Region2D> differences;
            GetCommonsAndDifferences(regions_current, regions_lastFrame, out commons, out differences);

            if (differences.Count > 0)
            {
                if (regions_lastFrame.Count < regions_current.Count)
                {
                    foreach (Region2D region in differences)
                        if (TriggerEnter != null) TriggerEnter(region);
                }
                else if (regions_lastFrame.Count > regions_current.Count)
                {
                    foreach (Region2D region in differences)
                        if (TriggerExit != null) TriggerExit(region);
                }
            }
            else if (differences.Count == 0 && regions_lastFrame.Count != 0 && regions_current.Count != 0)
            {
                foreach (Region2D region in regions_current)
                    if (TriggerStay != null) TriggerStay(region);
            }

            regions_lastFrame = regions_current;
        }

        private Tile[] OccupyTiles()
        {
            Vector2 pos = transform.localPosition;

            UnoccupyTiles();

            for (int i = 0; i < Size.x; i++)
                for (int j = 0; j < Size.y; j++)
                {
                    Tile occupied = World2D.ciop.GetTile((int)pos.x + i, (int)pos.y + j);

                    occupied.TileEntered(this);

                    tilesOccupied.Add(occupied);
                }

            return tilesOccupied.ToArray();
        }

        private void UnoccupyTiles()
        {
            if (tilesOccupied.Count == 0) return;

            foreach (Tile tile in tilesOccupied)
                tile.TileExited(this);

            tilesOccupied.Clear();
        }

        public static void GetCommonsAndDifferences(List<Region2D> regions1, List<Region2D> regions2, out List<Region2D> commons, out List<Region2D> differences)
        {
            commons = new List<Region2D>();

            for (int i = 0; i < regions1.Count; i++)
                for (int j = 0; j < regions2.Count; j++)
                    if (regions1[i] == regions2[j]) commons.Add(regions1[i]);

            differences = new List<Region2D>();

            for (int i = 0; i < regions1.Count; i++)
                if (!differences.Contains(regions1[i]) && !commons.Contains(regions1[i])) differences.Add(regions1[i]);

            for (int i = 0; i < regions2.Count; i++)
                if (!differences.Contains(regions2[i]) && !commons.Contains(regions2[i])) differences.Add(regions2[i]);
        }
    }

    public static class Region2DSerialization
    {
        private static string[] tags;
        public static string[] Tags
        {
            get
            {
                if (tags == null)
                {
                    tags = (GetArray<TagsArray>("tags")).tags;
                }

                return tags;
            }

            set
            {
                tags = value;
            }
        }

        private static string[][] collisions;
        public static bool[][] Collisions
        {
            get
            {
                bool[][] arr = null;
                if (collisions == null)
                {
                    collisions = (GetArray<CollisionsArray>("collisions")).collisions;
                }

                arr = new bool[collisions.Length][];

                for (int i = 0; i < arr.Length; i++)
                {
                    arr[i] = new bool[arr.Length];
                    for (int j = 0; j < arr[i].Length; j++)
                    {
                        arr[i][j] =
                            collisions[i][j] == "True";
                    }
                }

                return arr;
            }

            set
            {
                if (value == null)
                {
                    collisions = null;
                    return;
                }

                string[][] arr = new string[value.Length][];

                for (int i = 0; i < arr.Length; i++)
                {
                    arr[i] = new string[arr.Length];
                    for (int j = 0; j < arr[i].Length; j++)
                    {
                        arr[i][j] = value[i][j].ToString();
                    }
                }

                collisions = arr;
            }
        }

        private static T GetArray<T>(string jsonFileName)
        {
            string json = File.ReadAllText(String.Format("Assets/Plugins/Movement2D/JSONs/{0}.txt", jsonFileName));
            T t = JsonConvert.DeserializeObject<T>(json);

            return t;
        }

        public static void SerializeArray(object arrayObject, string jsonFileName)
        {
            string json = JsonConvert.SerializeObject(arrayObject);
            File.WriteAllText(String.Format("Assets/Plugins/Movement2D/JSONs/{0}.txt", jsonFileName), json);
        }
    }

    [Serializable]
    public class TagsArray
    {
        public string[] tags;
    }

    [Serializable]
    public class CollisionsArray
    {
        public string[][] collisions;
    }

    [Serializable]
    public class CollisionsArray2
    {
        public string[][] collisions;
    }
}