RoomTemplateDatabase.cs

using Godot;
using MPewsey.ManiaMap;
using MPewsey.ManiaMap.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
 
namespace MPewsey.ManiaMapGodot
{
    [GlobalClass]
    public partial class RoomTemplateDatabase : Resource
    {
        [Export] public TemplateGroup[] TemplateGroups { get; set; } = Array.Empty<TemplateGroup>();
 
        private Dictionary<int, RoomTemplateResource> RoomTemplates { get; } = new Dictionary<int, RoomTemplateResource>();
 
        public bool IsDirty { get; private set; } = true;
 
        public IReadOnlyDictionary<int, RoomTemplateResource> GetRoomTemplates()
        {
            PopulateIfDirty();
            return RoomTemplates;
        }
 
        public void SetDirty()
        {
            IsDirty = true;
        }
 
        private void PopulateIfDirty()
        {
            if (IsDirty)
            {
                PopulateRoomTemplates();
                IsDirty = false;
            }
        }
 
        private void PopulateRoomTemplates()
        {
            RoomTemplates.Clear();
 
            foreach (var group in TemplateGroups)
            {
                foreach (var entry in group.Entries)
                {
                    var id = entry.RoomTemplate.Id;
 
                    if (!RoomTemplates.TryGetValue(id, out var template))
                        RoomTemplates.Add(id, entry.RoomTemplate);
                    else if (template != entry.RoomTemplate)
                        throw new DuplicateIdException($"Duplicate room template ID: {id}.");
                }
            }
        }
 
        public RoomTemplateResource GetRoomTemplate(int id)
        {
            PopulateIfDirty();
            return RoomTemplates[id];
        }
 
        public RoomTemplateResource GetRoomTemplate(Uid id, LayoutPack layoutPack)
        {
            var room = layoutPack.Layout.Rooms[id];
            return GetRoomTemplate(room.Template.Id);
        }
 
        private async Task<Dictionary<int, PackedScene>> LoadScenesAsync(IEnumerable<Room> rooms, bool useSubThreads = false)
        {
            var tasks = new Dictionary<int, Task<PackedScene>>();
 
            foreach (var room in rooms)
            {
                var id = room.Template.Id;
 
                if (!tasks.ContainsKey(id))
                    tasks.Add(id, GetRoomTemplate(id).LoadSceneAsync(useSubThreads));
            }
 
            await Task.WhenAll(tasks.Values);
            var result = new Dictionary<int, PackedScene>(tasks.Count);
 
            foreach (var pair in tasks)
            {
                result.Add(pair.Key, pair.Value.Result);
            }
 
            return result;
        }
 
        public async Task<List<RoomNode2D>> CreateRoom2DInstancesAsync(Node parent, LayoutPack layoutPack, int? z = null, bool useSubThreads = false)
        {
            z ??= layoutPack.Layout.Rooms.Values.Select(x => x.Position.Z).First();
            var rooms = layoutPack.Layout.Rooms.Values.Where(x => x.Position.Z == z).ToList();
            var scenes = await LoadScenesAsync(rooms, useSubThreads);
            var result = new List<RoomNode2D>(rooms.Count);
 
            foreach (var room in rooms)
            {
                var scene = scenes[room.Template.Id];
                result.Add(RoomNode2D.CreateInstance(room.Id, layoutPack, scene, parent, true));
            }
 
            return result;
        }
 
        public async Task<List<RoomNode3D>> CreateRoom3DInstancesAsync(Node parent, LayoutPack layoutPack, bool useSubThreads = false)
        {
            var rooms = layoutPack.Layout.Rooms.Values.ToList();
            var scenes = await LoadScenesAsync(rooms, useSubThreads);
            var result = new List<RoomNode3D>(rooms.Count);
 
            foreach (var room in rooms)
            {
                var scene = scenes[room.Template.Id];
                result.Add(RoomNode3D.CreateInstance(room.Id, layoutPack, scene, parent, true));
            }
 
            return result;
        }
 
        public List<RoomNode2D> CreateRoom2DInstances(Node parent, LayoutPack layoutPack, int? z = null)
        {
            z ??= layoutPack.Layout.Rooms.Values.Select(x => x.Position.Z).First();
            var result = new List<RoomNode2D>();
 
            foreach (var room in layoutPack.Layout.Rooms.Values)
            {
                if (room.Position.Z == z)
                {
                    var template = GetRoomTemplate(room.Template.Id);
                    result.Add(RoomNode2D.CreateInstance(room.Id, layoutPack, template.LoadScene(), parent, true));
                }
            }
 
            return result;
        }
 
        public List<RoomNode3D> CreateRoom3DInstances(Node parent, LayoutPack layoutPack)
        {
            var result = new List<RoomNode3D>();
 
            foreach (var room in layoutPack.Layout.Rooms.Values)
            {
                var template = GetRoomTemplate(room.Template.Id);
                result.Add(RoomNode3D.CreateInstance(room.Id, layoutPack, template.LoadScene(), parent, true));
            }
 
            return result;
        }
 
        public async Task<RoomNode2D> CreateRoom2DInstanceAsync(Uid id, LayoutPack layoutPack, Node parent, bool assignLayoutPosition = false, bool useSubThreads = false)
        {
            var scene = await GetRoomTemplate(id, layoutPack).LoadSceneAsync(useSubThreads);
            return RoomNode2D.CreateInstance(id, layoutPack, scene, parent, assignLayoutPosition);
        }
 
        public async Task<RoomNode3D> CreateRoom3DInstanceAsync(Uid id, LayoutPack layoutPack, Node parent, bool assignLayoutPosition = false, bool useSubThreads = false)
        {
            var scene = await GetRoomTemplate(id, layoutPack).LoadSceneAsync(useSubThreads);
            return RoomNode3D.CreateInstance(id, layoutPack, scene, parent, assignLayoutPosition);
        }
 
        public RoomNode2D CreateRoom2DInstance(Uid id, LayoutPack layoutPack, Node parent, bool assignLayoutPosition = false)
        {
            var scene = GetRoomTemplate(id, layoutPack).LoadScene();
            return RoomNode2D.CreateInstance(id, layoutPack, scene, parent, assignLayoutPosition);
        }
 
        public RoomNode3D CreateRoom3DInstance(Uid id, LayoutPack layoutPack, Node parent, bool assignLayoutPosition = false)
        {
            var scene = GetRoomTemplate(id, layoutPack).LoadScene();
            return RoomNode3D.CreateInstance(id, layoutPack, scene, parent, assignLayoutPosition);
        }
    }
}