DoorComponent.cs

using MPewsey.Common.Mathematics;
using MPewsey.ManiaMap;
using System.Collections.Generic;
using UnityEngine;
 
namespace MPewsey.ManiaMapUnity
{
    public class DoorComponent : CellChild
    {
        private static Dictionary<Uid, LinkedList<DoorComponent>> ActiveDoorsByRoom { get; } = new Dictionary<Uid, LinkedList<DoorComponent>>();
 
        [Header("Door:")]
        [SerializeField]
        private bool _autoAssignDirection = true;
        public bool AutoAssignDirection { get => _autoAssignDirection; set => _autoAssignDirection = value; }
 
        [SerializeField]
        private DoorDirection _direction;
        public DoorDirection Direction { get => _direction; set => _direction = value; }
 
        [SerializeField]
        private DoorType _type;
        public DoorType Type { get => _type; set => _type = value; }
 
        [SerializeField]
        private DoorCode _code;
        public DoorCode Code { get => _code; set => _code = value; }
 
        public DoorConnection Connection { get; private set; }
 
        public bool DoorExists()
        {
            return Connection != null;
        }
 
        public Uid ToRoomId()
        {
            if (!DoorExists())
                return new Uid(-1, -1, -1);
 
            return Connection.GetConnectingRoom(Room.RoomLayout.Id);
        }
 
        protected override void OnDestroy()
        {
            base.OnDestroy();
            RemoveFromActiveDoors();
        }
 
        protected override void Initialize()
        {
            if (!IsInitialized)
            {
                IsInitialized = true;
                AddToActiveDoors();
                Connection = FindDoorConnection();
                OnInitialize.Invoke();
            }
        }
 
        public static DoorComponent FindDoor(Uid roomId, DoorConnection connection)
        {
            if (connection != null && ActiveDoorsByRoom.TryGetValue(roomId, out var doors))
            {
                foreach (var door in doors)
                {
                    if (door.Connection == connection)
                        return door;
                }
            }
 
            return null;
        }
 
        private void AddToActiveDoors()
        {
            var id = Room.RoomLayout.Id;
 
            if (!ActiveDoorsByRoom.TryGetValue(id, out var doors))
            {
                doors = new LinkedList<DoorComponent>();
                ActiveDoorsByRoom.Add(id, doors);
            }
 
            doors.AddLast(this);
        }
 
        private void RemoveFromActiveDoors()
        {
            if (Room.IsInitialized && ActiveDoorsByRoom.TryGetValue(Room.RoomLayout.Id, out var doors))
                doors.Remove(this);
        }
 
        private DoorConnection FindDoorConnection()
        {
            var roomId = Room.RoomLayout.Id;
            var position = new Vector2DInt(Row, Column);
            return Room.LayoutPack.FindDoorConnection(roomId, position, Direction);
        }
 
        public override void AutoAssign(RoomComponent room)
        {
            base.AutoAssign(room);
 
            if (AutoAssignDirection)
                Direction = room.FindClosestDoorDirection(Row, Column, transform.position);
        }
 
        public Door GetMMDoor()
        {
            return new Door(Type, Code);
        }
    }
}