room_default_entrance.cc

Go to the documentation of this file.

#include "zelda3/dungeon/room_default_entrance.h"
 
#include <map>
 
#include "rom/rom.h"
#include "zelda3/dungeon/dungeon_rom_addresses.h"
#include "zelda3/dungeon/dungeon_spawn_point.h"
#include "zelda3/dungeon/room_entrance.h"
#include "zelda3/game_data.h"
#include "zelda3/screen/dungeon_map.h"
 
namespace yaze::zelda3 {
namespace {
 
constexpr uint8_t kEmptyMapRoom = 0x0F;
 
}  // namespace
 
int DungeonBackgroundPaletteOffset(uint8_t main_blockset,
                                   int destination_slot) {
  if (destination_slot < 0 || destination_slot >= 8)
    return 0;
  const int runtime_slot = 7 - destination_slot;
  const bool right = main_blockset < 0x20
                         ? runtime_slot >= 4
                         : runtime_slot == 2 || runtime_slot == 3 ||
                               runtime_slot == 4 || runtime_slot == 7;
  return right ? 8 : 0;
}
 
RoomMainBlocksetResolution ResolveRoomMainBlockset(
    int room_id, uint8_t header_blockset, uint8_t requested_main_blockset,
    const GameData& game_data) {
  const auto valid = [&game_data](uint8_t group) {
    return group != 0xFF && group < game_data.main_blockset_ids.size();
  };
  if (valid(requested_main_blockset)) {
    return {requested_main_blockset, RoomMainBlocksetSource::kExplicitPreview};
  }
  if (room_id >= 0 &&
      room_id < static_cast<int>(game_data.room_default_entrances.size())) {
    const auto& entrance = game_data.room_default_entrances[room_id];
    if (valid(entrance.main_blockset)) {
      return {entrance.main_blockset,
              entrance.source == RoomEntranceSource::kDirect
                  ? RoomMainBlocksetSource::kDirectDefault
                  : RoomMainBlocksetSource::kInferredDefault};
    }
  }
  if (valid(header_blockset)) {
    return {header_blockset, RoomMainBlocksetSource::kHeaderFallback};
  }
  return {0, RoomMainBlocksetSource::kZeroFallback};
}
 
std::vector<RoomDefaultEntrance> ComputeRoomDefaultEntrances(Rom& rom) {
  std::vector<RoomDefaultEntrance> result(kNumberOfRooms);
  if (!rom.is_loaded()) {
    return result;
  }
  if (!ResolveEntranceLayout(rom.vector()).ok()) {
    // Do not infer defaults from the populated but inactive legacy tables.
    return result;
  }
 
  struct EntranceInfo {
    int id;
    int room;
    uint8_t main_blockset;
    uint8_t dungeon_id;
  };
  std::vector<EntranceInfo> entrances;
  entrances.reserve(kNumRegularDungeonEntrances);
  for (int id = 0; id < kNumRegularDungeonEntrances; ++id) {
    RoomEntrance entrance(&rom, static_cast<uint8_t>(id), false);
    if (!entrance.load_status().ok()) {
      continue;
    }
    entrances.push_back(
        {id, entrance.room_, entrance.blockset_, entrance.dungeon_id_});
  }
 
  // 1. Direct entrances.
  for (const EntranceInfo& entrance : entrances) {
    if (entrance.room < 0 || entrance.room >= kNumberOfRooms) {
      continue;
    }
    RoomDefaultEntrance& slot = result[static_cast<size_t>(entrance.room)];
    if (slot.source == RoomEntranceSource::kNone) {
      slot = {entrance.id, entrance.main_blockset, RoomEntranceSource::kDirect,
              -1};
    }
  }
 
  // 2. Pause-menu dungeon maps.
  DungeonMapLabels labels;
  auto maps = LoadDungeonMaps(rom, labels);
  if (maps.ok()) {
    for (const DungeonMap& map : *maps) {
      std::vector<int> rooms;
      for (const auto& floor : map.floor_rooms) {
        for (uint8_t room : floor) {
          if (room != kEmptyMapRoom) {
            rooms.push_back(room);
          }
        }
      }
      // Which dungeon ID this map belongs to: the most common one among
      // entrances that lead straight into its rooms.
      std::map<uint8_t, int> votes;
      for (int room : rooms) {
        for (const EntranceInfo& entrance : entrances) {
          if (entrance.room == room && entrance.dungeon_id != 0xFF) {
            ++votes[entrance.dungeon_id];
          }
        }
      }
      if (votes.empty()) {
        continue;
      }
      uint8_t dungeon_id = votes.begin()->first;
      for (const auto& [id, count] : votes) {
        if (count > votes[dungeon_id]) {
          dungeon_id = id;
        }
      }
      const EntranceInfo* representative = nullptr;
      for (const EntranceInfo& entrance : entrances) {
        if (entrance.dungeon_id == dungeon_id) {
          representative = &entrance;
          break;
        }
      }
      if (representative == nullptr) {
        continue;
      }
      for (int room : rooms) {
        RoomDefaultEntrance& slot = result[static_cast<size_t>(room)];
        if (slot.source == RoomEntranceSource::kNone) {
          slot = {representative->id, representative->main_blockset,
                  RoomEntranceSource::kDungeonMap, -1};
        }
      }
    }
  }
 
  // 3. Neighbours in the 16-wide room grid, until nothing changes.
  bool changed = true;
  while (changed) {
    changed = false;
    for (int room = 0; room < kNumberOfRooms; ++room) {
      if (result[static_cast<size_t>(room)].source !=
          RoomEntranceSource::kNone) {
        continue;
      }
      for (int neighbour : {room - 1, room + 1, room - 16, room + 16}) {
        const bool adjacent = neighbour / 16 == room / 16 ||
                              neighbour == room - 16 || neighbour == room + 16;
        if (neighbour < 0 || neighbour >= kNumberOfRooms || !adjacent) {
          continue;
        }
        const RoomDefaultEntrance& from =
            result[static_cast<size_t>(neighbour)];
        if (from.source == RoomEntranceSource::kNone) {
          continue;
        }
        result[static_cast<size_t>(room)] = {
            from.entrance_id, from.main_blockset,
            RoomEntranceSource::kNeighbour, neighbour};
        changed = true;
        break;
      }
    }
  }
  return result;
}
 
}  // namespace yaze::zelda3