LayoutPack.cs

using Godot;
using MPewsey.Common.Mathematics;
using MPewsey.ManiaMap;
using System;
using System.Collections.Generic;
 
namespace MPewsey.ManiaMapGodot
{
    public class LayoutPack
    {
        public Layout Layout { get; }
 
        public LayoutState LayoutState { get; }
 
        public ManiaMapSettings Settings { get; }
 
        private Dictionary<Uid, List<DoorConnection>> RoomConnections { get; } = new Dictionary<Uid, List<DoorConnection>>();
 
        private Dictionary<int, List<Room>> RoomsByLayer { get; } = new Dictionary<int, List<Room>>();
 
        private Dictionary<Uid, List<DoorPosition>> RoomDoors { get; } = new Dictionary<Uid, List<DoorPosition>>();
 
        public LayoutPack(Layout layout, LayoutState state, string settingsPath)
            : this(layout, state, ResourceLoader.Load<ManiaMapSettings>(settingsPath))
        {
 
        }
 
        public LayoutPack(Layout layout, LayoutState state, ManiaMapSettings settings = null)
        {
            ArgumentNullException.ThrowIfNull(layout, nameof(layout));
            ArgumentNullException.ThrowIfNull(state, nameof(state));
 
            if (layout.Id != state.Id)
                throw new ArgumentException($"Layout and layout state ID's do not match: (Layout ID = {layout.Id}, Layout State ID = {state.Id})");
 
            Layout = layout;
            LayoutState = state;
            Settings = settings;
            RoomConnections = layout.GetRoomConnections();
            RoomsByLayer = layout.GetRoomsByLayer();
            RoomDoors = layout.GetRoomDoors();
        }
 
        public IReadOnlyList<DoorConnection> GetDoorConnections(Uid id)
        {
            if (RoomConnections.TryGetValue(id, out var connections))
                return connections;
            return Array.Empty<DoorConnection>();
        }
 
        public IReadOnlyList<Room> GetRoomsInLayer(int z)
        {
            if (RoomsByLayer.TryGetValue(z, out var rooms))
                return rooms;
            return Array.Empty<Room>();
        }
 
        public IReadOnlyList<DoorPosition> GetRoomDoors(Uid id)
        {
            if (RoomDoors.TryGetValue(id, out var doors))
                return doors;
            return Array.Empty<DoorPosition>();
        }
 
        public bool DoorExists(Uid id, Vector2DInt position, DoorDirection direction)
        {
            foreach (var door in GetRoomDoors(id))
            {
                if (door.Matches(position, direction))
                    return true;
            }
 
            return false;
        }
 
        public IEnumerable<int> GetLayerCoordinates()
        {
            return RoomsByLayer.Keys;
        }
 
        public DoorConnection FindDoorConnection(Uid id, Vector2DInt position, DoorDirection direction)
        {
            foreach (var connection in GetDoorConnections(id))
            {
                if (connection.ContainsDoor(id, position, direction))
                    return connection;
            }
 
            return null;
        }
    }
}