public void ReplaceRoom(GameObject roomToReplace, DungeonDoor.DoorDirection entranceDirection, List <GameObject> staticOptions = null)
    {
        BaseRoom.RoomTypes backupType       = roomToReplace.GetComponent <BaseRoom>().type;
        GameObject         backupParentDoor = roomToReplace.GetComponent <BaseRoom>().entranceDoor.GetComponent <DungeonDoor>().parentDoor;
        GameObject         backupParent     = roomToReplace.GetComponent <BaseRoom>().parentRoom;

        print("DESTROYED " + roomToReplace);
        roomToReplace.GetComponent <BaseRoom>().OnDestroyed();
        DestroyImmediate(roomToReplace);

        List <GameObject> possibleAvailableOptions = new List <GameObject>();

        if (staticOptions != null)
        {
            possibleAvailableOptions = staticOptions;
        }
        else
        {
            if (backupType == BaseRoom.RoomTypes.Hallway)
            {
                possibleAvailableOptions = hallways;
            }
            else
            {
                possibleAvailableOptions = rooms;
            }
        }

        List <GameObject> availableOptions = new List <GameObject>();

        foreach (GameObject option in possibleAvailableOptions)
        {
            foreach (GameObject door in option.GetComponent <BaseRoom>().availableDoors)
            {
                if (door.GetComponent <DungeonDoor>().direction == entranceDirection)
                {
                    availableOptions.Add(option);
                    break;
                }
            }
        }

        GameObject finalRoom      = null;
        GameObject selectedDoor   = null;
        int        selectedDoorId = 0;

        foreach (GameObject option in availableOptions)
        {
            List <GameObject> availableDoors = new List <GameObject>();
            foreach (GameObject door in option.GetComponent <BaseRoom>().availableDoors)
            {
                if (door.GetComponent <DungeonDoor>().direction == entranceDirection)
                {
                    availableDoors.Add(door);
                }
            }
            selectedDoor   = availableDoors[Random.Range(0, availableDoors.Count)];
            selectedDoorId = selectedDoor.GetComponent <DungeonDoor>().id;

            finalRoom = Instantiate(option, GetLocationData(option.transform, selectedDoor.transform, backupParentDoor.transform), Quaternion.identity);

            for (int i = 0; i < finalRoom.GetComponent <BaseRoom>().availableDoors.Count; i++)
            {
                GameObject thisDoor = finalRoom.GetComponent <BaseRoom>().availableDoors[i];
                if (thisDoor.GetComponent <DungeonDoor>().id == selectedDoorId)
                {
                    selectedDoor = thisDoor;
                    break;
                }
            }

            finalRoom.GetComponent <BaseRoom>().Initialize(this, backupParent, selectedDoor);
            finalRoom.GetComponent <BaseRoom>().entranceDoor.GetComponent <DungeonDoor>().parentDoor = backupParentDoor;
            if (finalRoom.GetComponent <BaseRoom>().HasCollision(true))
            {
                finalRoom.GetComponent <BaseRoom>().OnDestroyed();
                DestroyImmediate(finalRoom);
                finalRoom = null;
                continue;
            }
            else
            {
                //print("THIS ONE DID NOT COLLIDE C:");
                break;
            }
        }
        if (finalRoom != null)
        {
            print("FOUND NEW ROOM");
            finalRoom.GetComponent <BaseRoom>().replaced = true;
            StartCoroutine(finalRoom.GetComponent <BaseRoom>().SpawnNextRoom());
        }
        else
        {
            RemoveDoor(backupParentDoor);
            if (openProcesses <= 0)
            {
                CheckRoomCount();
            }
        }
    }
    public void SpawnDungeonPartAlt(List <GameObject> allRooms, DungeonDoor.DoorDirection requiredDirection, GameObject parentRoom, Transform doorPoint, BaseRoom.RoomTypes roomType)
    {
        if (roomCount < maxRoomCount)
        {
            if (roomType == BaseRoom.RoomTypes.Normal)
            {
                List <GameObject> shouldReplace = ReplaceWithSpecialRoom(parentRoom);

                if (shouldReplace != null)
                {
                    allRooms = shouldReplace;
                }
            }

            List <GameObject> possibleRooms = new List <GameObject>();

            foreach (GameObject room in allRooms)
            {
                foreach (GameObject door in room.GetComponent <BaseRoom>().availableDoors)
                {
                    if (door.GetComponent <DungeonDoor>().direction == requiredDirection)
                    {
                        possibleRooms.Add(room);
                        break;
                    }
                }
            }

            GameObject       roomToSpawn    = possibleRooms[Random.Range(0, possibleRooms.Count)];
            List <Transform> availableDoors = new List <Transform>();
            for (int i = 0; i < roomToSpawn.GetComponent <BaseRoom>().availableDoors.Count; i++)
            {
                GameObject thisDoor = roomToSpawn.GetComponent <BaseRoom>().availableDoors[i];
                if (thisDoor.GetComponent <DungeonDoor>().direction == requiredDirection)
                {
                    availableDoors.Add(thisDoor.transform);
                }
            }
            Transform  selectedDoor   = availableDoors[Random.Range(0, availableDoors.Count)];
            int        selectedDoorId = selectedDoor.GetComponent <DungeonDoor>().id;
            GameObject spawnedRoom    = Instantiate(roomToSpawn, GetLocationData(roomToSpawn.transform, selectedDoor, doorPoint), Quaternion.identity);
            for (int i = 0; i < spawnedRoom.GetComponent <BaseRoom>().availableDoors.Count; i++)
            {
                Transform thisDoor = spawnedRoom.GetComponent <BaseRoom>().availableDoors[i].transform;
                if (thisDoor.GetComponent <DungeonDoor>().id == selectedDoorId)
                {
                    selectedDoor = thisDoor;
                    break;
                }
            }

            spawnedRoom.GetComponent <BaseRoom>().Initialize(this, parentRoom, selectedDoor.gameObject);
            spawnedRoom.GetComponent <BaseRoom>().entranceDoor.GetComponent <DungeonDoor>().parentDoor = doorPoint.gameObject;
            CheckPartCollision(spawnedRoom, selectedDoor.GetComponent <DungeonDoor>().direction);
        }
        else
        {
            RemoveDoor(doorPoint.gameObject);
            if (openProcesses == 0)
            {
                CheckRoomCount();
            }
        }
    }