// sync relevant data to position offset, e.g. bounding, tilemap tile anchor
 public void ConfigureRoomWithOffset(Vector3Int offset)
 {
     bounding_ = new RoomAABB(bounding_.nw_bound_ + offset.y,
                              bounding_.ne_bound_ + offset.x,
                              bounding_.sw_bound_ + offset.x,
                              bounding_.se_bound_ + offset.y,
                              offset.z);
     tilemap_.tileAnchor = new Vector3(offset.x, offset.y, offset.z);
     for (int nw = 0; nw < nw_doors_.Count; nw++)
     {
         nw_doors_[nw] = new Door(nw_doors_[nw].orientation_, nw_doors_[nw].grid_position_ + offset);
     }
     for (int ne = 0; ne < ne_doors_.Count; ne++)
     {
         ne_doors_[ne] = new Door(ne_doors_[ne].orientation_, ne_doors_[ne].grid_position_ + offset);
     }
     for (int sw = 0; sw < sw_doors_.Count; sw++)
     {
         sw_doors_[sw] = new Door(sw_doors_[sw].orientation_, sw_doors_[sw].grid_position_ + offset);
     }
     for (int se = 0; se < se_doors_.Count; se++)
     {
         se_doors_[se] = new Door(se_doors_[se].orientation_, se_doors_[se].grid_position_ + offset);
     }
     world_height_ = offset.z / 2;
     game_object_.transform.GetChild(0).gameObject.GetComponent <TilemapRenderer>().sortingOrder = world_height_;
 }
 public bool IsOverlap(RoomAABB room)
 {
     if (room.ne_bound_ < sw_bound_ ||
         room.nw_bound_ < se_bound_ ||
         room.se_bound_ > nw_bound_ ||
         room.sw_bound_ > ne_bound_ ||
         room.top_bound_ < bottom_bound_ ||
         room.bottom_bound_ > top_bound_)
     {
         return(false);
     }
     return(true);
 }
    // ================================================== //
    // INITIALIZATION FUNCTIONS
    // ================================================== //
    public void InitRoom(GameObject gameobject)
    {
        // setting tilemap variables
        game_object_   = gameobject;
        tilemap_       = game_object_.transform.GetChild(0).gameObject.GetComponent <Tilemap>();
        entity_tilemap = game_object_.transform.GetChild(1).gameObject.GetComponent <Tilemap>();
        // get used area of tilemap and define its dimensions
        tilemap_.CompressBounds();
        BoundsInt temp_bounds = tilemap_.cellBounds;

        x_            = temp_bounds.size.x;
        y_            = temp_bounds.size.y;
        room_origin_  = temp_bounds.min;
        tile_list_    = GetTiles(temp_bounds);
        bounding_     = new RoomAABB(temp_bounds.yMax - 1, temp_bounds.xMax - 1, temp_bounds.xMin, temp_bounds.yMin, layer_height_);
        world_height_ = 0;
    }
    // Returns a list of Room-Door pairs that fit a target door, and get the offset required to transform
    // the position of the prefab clone to designated position
    // Pre  : offsetlist empty
    // Post : offsetlist contains all offsets of room-door pairs
    public List <Vector2Int> FindRoomsThatFitDoor(Room.Door door, List <int> rooms, string orientation, ref List <Vector3Int> offsetlist)
    {
        if (offsetlist.Count > 0)
        {
            offsetlist.Clear();
        }
        List <Vector2Int> room_to_door_pair = new List <Vector2Int>();
        Vector3Int        offset_holder     = new Vector3Int(0, 0, 0);

        if (orientation == "NW")
        {
            foreach (int i in rooms)
            {
                for (int d = 0; d < room_list_[i].nw_doors_.Count; d++)
                {
                    // Get the offset of the room to position room.nw_doors_[d] to door
                    offset_holder = room_list_[i].GetPositionOffset(room_list_[i].nw_doors_[d], door);
                    // Get the temporary bounding box used in calculation with the offset
                    RoomAABB temp_aabb = room_list_[i].GetOffsetBounding(offset_holder);
                    bool     temp_flag = false;
                    // Test if repositioned bounding box intersects with any existing room,
                    // if not, add it to list to be considered a valid room-door combination
                    foreach (Room r in room_clone_list_)
                    {
                        if (r.bounding_.IsOverlap(temp_aabb))
                        {
                            temp_flag = true;
                        }
                    }
                    if (!temp_flag)
                    {
                        room_to_door_pair.Add(new Vector2Int(i, d));
                        offsetlist.Add(offset_holder);
                    }
                }
            }
        }
        else if (orientation == "NE")
        {
            foreach (int i in rooms)
            {
                for (int d = 0; d < room_list_[i].ne_doors_.Count; d++)
                {
                    offset_holder = room_list_[i].GetPositionOffset(room_list_[i].ne_doors_[d], door);
                    RoomAABB temp_aabb = room_list_[i].GetOffsetBounding(offset_holder);
                    bool     temp_flag = false;
                    foreach (Room r in room_clone_list_)
                    {
                        if (r.bounding_.IsOverlap(temp_aabb))
                        {
                            temp_flag = true;
                        }
                    }
                    if (!temp_flag)
                    {
                        room_to_door_pair.Add(new Vector2Int(i, d));
                        offsetlist.Add(offset_holder);
                    }
                }
            }
        }
        else if (orientation == "SW")
        {
            foreach (int i in rooms)
            {
                for (int d = 0; d < room_list_[i].sw_doors_.Count; d++)
                {
                    offset_holder = room_list_[i].GetPositionOffset(room_list_[i].sw_doors_[d], door);
                    RoomAABB temp_aabb = room_list_[i].GetOffsetBounding(offset_holder);
                    bool     temp_flag = false;
                    foreach (Room r in room_clone_list_)
                    {
                        if (r.bounding_.IsOverlap(temp_aabb))
                        {
                            temp_flag = true;
                        }
                    }
                    if (!temp_flag)
                    {
                        room_to_door_pair.Add(new Vector2Int(i, d));
                        offsetlist.Add(offset_holder);
                    }
                }
            }
        }
        else if (orientation == "SE")
        {
            foreach (int i in rooms)
            {
                for (int d = 0; d < room_list_[i].se_doors_.Count; d++)
                {
                    offset_holder = room_list_[i].GetPositionOffset(room_list_[i].se_doors_[d], door);
                    RoomAABB temp_aabb = room_list_[i].GetOffsetBounding(offset_holder);
                    bool     temp_flag = false;
                    foreach (Room r in room_clone_list_)
                    {
                        if (r.bounding_.IsOverlap(temp_aabb))
                        {
                            temp_flag = true;
                        }
                    }
                    if (!temp_flag)
                    {
                        room_to_door_pair.Add(new Vector2Int(i, d));
                        offsetlist.Add(offset_holder);
                    }
                }
            }
        }
        return(room_to_door_pair);
    }