gather-and-defend/Assets/Scripts/LevelManager/LevelManagerScript.cs

using System.Collections.Generic;
using System.Linq;
using Unity.Plastic.Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Tilemaps;
using GatherAndDefend.LevelEditor;
using Unity.VisualScripting.YamlDotNet.Core.Tokens;

#region [custom inspector]
#if UNITY_EDITOR
using UnityEditor;

[CustomEditor(typeof(LevelManagerScript))]
public class LevelManagerEditor : Editor
{
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();
        if (GUILayout.Button("Save"))
        {
            LevelManager.Instance.SaveFile();
        }
        if (GUILayout.Button("Load"))
        {
            LevelManager.Instance.LoadFile();
        }
    }
}
#endif
#endregion

#region [singleton level manager]
public class LevelManager : Singleton<LevelManager>
{
    public delegate void LevelAction(ILevelObject levelObject);
    public delegate bool LevelPredicate<T>(T levelObject) where T : ILevelObject;
    public event LevelAction Added;
    public event LevelAction Removed;

    private readonly List<ILevelObject> _toAdd;
    private readonly List<ILevelObject> _toRemove;
    private readonly List<ILevelObject> _levelObjects;

    public Level _currentLevel;

    public Transform LevelTransform
    {
        get;private set;
    }
    public LevelManager()
{
        _toAdd = new List<ILevelObject>();
        _toRemove = new List<ILevelObject>();
        _levelObjects = new List<ILevelObject>();

        var mgrScript = Object.FindObjectOfType<LevelManagerScript>();
        if (!mgrScript) mgrScript = new GameObject(nameof(LevelManager)).AddComponent<LevelManagerScript>();
        LevelTransform = mgrScript.transform;
    }

    #region [~CRUD~]
    public void Add(ILevelObject levelObject)
    {
        _toAdd.Add(levelObject);
    }
    public void Remove(ILevelObject levelObject)
    {
        _toRemove.Add(levelObject);
    }
    public void Clear()
    {
        _toAdd.Clear();
        _toRemove.Clear();
        _levelObjects.Clear();
    }
    public T Get<T>(LevelPredicate<T> predicate = null) where T : ILevelObject
    {
        if (predicate == null) predicate = (generic) => true;
        return (T)_levelObjects.Find(levelObject => levelObject is T generic && predicate(generic));
    }
    public List<T> GetAll<T>(LevelPredicate<T> predicate = null) where T : ILevelObject
    {
        if (predicate == null) predicate = (generic) => true;
        List<T> ret = new();
        foreach (var levelObject in _levelObjects) if (levelObject is T generic && predicate(generic)) ret.Add(generic);
        return ret;
    }
    public int Count<T>(LevelPredicate<T> predicate = null) where T : ILevelObject
    {
        return GetAll(predicate).Count;
    }
    public bool Has<T>(LevelPredicate<T> predicate = null) where T : ILevelObject
    {
        if (predicate == null) predicate = (generic) => true;
        return _levelObjects.Exists(levelObject => levelObject is T generic && predicate(generic));
    }
    #endregion

    #region [Level management]
    public void UpdateLevel()
    {
        _levelObjects.ForEach(levelObject => levelObject.LevelUpdate());

        var toAdd = new List<ILevelObject>(this._toAdd);
        toAdd.ForEach(addedObject =>
        {
            this._toAdd.Remove(addedObject);
            _levelObjects.Add(addedObject);
            Added?.Invoke(addedObject);
            addedObject.LevelStart();
        });

        var toRemove = new List<ILevelObject>(this._toRemove);
        toRemove.ForEach(removedObject =>
        {
            this._toRemove.Remove(removedObject);
            _levelObjects.Remove(removedObject);
            Removed?.Invoke(removedObject);
            removedObject.LevelDestroy();
        });
        toRemove.Clear();
    }

    private string saved;

    public void ClearLevel()
    {
        foreach (var obj in _levelObjects)
        {
            obj.RemoveFromLevel();
        }
        Clear();
    }
    public void SaveFile()
    {
        var list = _levelObjects.Select(obj => obj.ToDictionary()).ToList();
        list.Add(new Dictionary<string, object>()
        {
            {Database.TYPE, "Level" },
            {"Name", _currentLevel.name }
        });
        saved = JsonConvert.SerializeObject(list);

        Debug.Log("game saved successfully");
    }

    public void LoadLevel(Level level, bool clear = false)
    {
        if (clear)
        {
            ClearLevel();
        }

        _currentLevel = level;
        Grid grid = Object.FindObjectOfType<Grid>();
        //create new grid if there is none
        if (!grid)
        {
            grid = new GameObject("Grid").AddComponent<Grid>();
        }
        //remove all tilemaps if there is a grid
        else
        {
            foreach (Transform child in grid.transform)
            {
                Object.Destroy(child.gameObject);
            }
        }

        //generate all tilemaps
        foreach (TilemapData tilemapData in _currentLevel)
        {
            var tilemap = new GameObject(tilemapData.Key).AddComponent<Tilemap>();
            tilemap.gameObject.AddComponent<TilemapRenderer>();
            tilemapData.LoadToTilemap(tilemap);
            tilemap.transform.SetParent(grid.transform);
        }
        Debug.Log("level loaded successfully");
    }
    public void LoadLevel(string levelName, bool clear = false)
    {
        if (clear)
        {
            ClearLevel();
}

//fetch level from database
        _currentLevel = Database.Instance.ScriptableObjects[levelName] as Level;

        LoadLevel(_currentLevel, clear);
    }
    public void LoadFile()
    {
        ClearLevel();

        var dicts = JsonConvert.DeserializeObject<List<Dictionary<string, object>>>(saved);

        var prefabDicts = dicts.FindAll(x => x[Database.TYPE].ToString() == nameof(Database.Prefabs));
        foreach (var prefabDict in prefabDicts) CreatePrefab(prefabDict);

        var tileDicts = dicts.FindAll(x => x[Database.TYPE].ToString() == nameof(Database.ScriptableObjects));
        foreach (var tileDict in tileDicts) CreateTile(tileDict);

        Debug.Log("game loaded successfully");
    }
    private void CreatePrefab(Dictionary<string, object> dict)
    {
        var name = dict["Name"].ToString();
        var prefab = Database.Instance.Prefabs[name];
        var instance = prefab.Create(Vector3.zero, parent: LevelTransform);
        var comp = instance.GetComponent<LevelObject>();
        comp.LoadDictionary(dict);
    }
    private void CreateTile(Dictionary<string, object> dict)
    {
        var name = dict["Name"].ToString();

        var tile = Object.Instantiate(Database.Instance.ScriptableObjects[name]) as LevelTile;
        tile.Instantiated = true;
        tile.LoadDictionary(dict);
        tile.AddToLevel();
    }
    #endregion
}
#endregion

#region [mono behaviour]
public class LevelManagerScript : MonoBehaviour
{
    public Level firstLevel;
    private static LevelManagerScript _instance;

    void Awake()
    {
        if (!_instance) _instance = this;
        else Destroy(gameObject);

        DontDestroyOnLoad(gameObject);
        LevelManager.Instance.LoadLevel(firstLevel.name, true);
    }
    void Update()
    {
        LevelManager.Instance.UpdateLevel();
    }
}
#endregion