dungeon_map.cc

Go to the documentation of this file.

#include "dungeon_map.h"
 
#include <algorithm>
#include <fstream>
#include <vector>
 
#include "absl/strings/str_format.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/tilemap.h"
#include "app/gfx/resource/arena.h"
#include "app/gfx/types/snes_tile.h"
#include "app/platform/window.h"
#include "rom/snes.h"
#include "rom/transaction.h"
#include "util/file_util.h"
#include "util/hex.h"
#include "zelda3/game_data.h"
 
namespace yaze::zelda3 {
 
absl::StatusOr<std::vector<DungeonMap>> LoadDungeonMaps(
    Rom& rom, DungeonMapLabels& dungeon_map_labels) {
  std::vector<DungeonMap> dungeon_maps;
  std::vector<std::array<uint8_t, kNumRooms>> current_floor_rooms_d;
  std::vector<std::array<uint8_t, kNumRooms>> current_floor_gfx_d;
  int total_floors_d;
  uint8_t nbr_floor_d;
  uint8_t nbr_basement_d;
 
  for (int d = 0; d < kNumDungeons; d++) {
    current_floor_rooms_d.clear();
    current_floor_gfx_d.clear();
    ASSIGN_OR_RETURN(int ptr, rom.ReadWord(kDungeonMapRoomsPtr + (d * 2)));
    ASSIGN_OR_RETURN(int ptr_gfx, rom.ReadWord(kDungeonMapGfxPtr + (d * 2)));
    ptr |= 0x0A0000;                     // Add bank to the short ptr
    ptr_gfx |= 0x0A0000;                 // Add bank to the short ptr
    int pc_ptr = SnesToPc(ptr);          // Contains data for the next 25 rooms
    int pc_ptr_gfx = SnesToPc(ptr_gfx);  // Contains data for the next 25 rooms
 
    ASSIGN_OR_RETURN(uint16_t boss_room_d,
                     rom.ReadWord(kDungeonMapBossRooms + (d * 2)));
 
    ASSIGN_OR_RETURN(nbr_basement_d, rom.ReadByte(kDungeonMapFloors + (d * 2)));
    nbr_basement_d &= 0x0F;
 
    ASSIGN_OR_RETURN(nbr_floor_d, rom.ReadByte(kDungeonMapFloors + (d * 2)));
    nbr_floor_d &= 0xF0;
    nbr_floor_d = nbr_floor_d >> 4;
 
    total_floors_d = nbr_basement_d + nbr_floor_d;
 
    // for each floor in the dungeon
    for (int i = 0; i < total_floors_d; i++) {
      dungeon_map_labels[d].emplace_back();
 
      std::array<uint8_t, kNumRooms> rdata;
      std::array<uint8_t, kNumRooms> gdata;
 
      // for each room on the floor
      for (int j = 0; j < kNumRooms; j++) {
        gdata[j] = 0xFF;
        rdata[j] = rom.data()[pc_ptr + j + (i * kNumRooms)];  // Set the rooms
 
        gdata[j] = rdata[j] == 0x0F ? 0xFF : rom.data()[pc_ptr_gfx++];
 
        std::string label = util::HexByte(rdata[j]);
        dungeon_map_labels[d][i][j] = label;
      }
 
      current_floor_gfx_d.push_back(gdata);    // Add new floor gfx data
      current_floor_rooms_d.push_back(rdata);  // Add new floor data
    }
 
    dungeon_maps.emplace_back(boss_room_d, nbr_floor_d, nbr_basement_d,
                              current_floor_rooms_d, current_floor_gfx_d);
  }
 
  return dungeon_maps;
}
 
absl::StatusOr<DungeonMapWritePlan> BuildDungeonMapWritePlan(
    const std::vector<DungeonMap>& dungeon_maps, size_t rom_size,
    bool relocated_tile16) {
  // Repacking a prefix would overwrite streams owned by omitted maps.
  if (dungeon_maps.size() != kNumDungeons) {
    return absl::InvalidArgumentError(
        "A full set of 14 dungeon maps is required");
  }
  std::array<uint16_t, kNumDungeons> boss_floors;
  boss_floors.fill(0xFFFF);
  for (size_t d = 0; d < dungeon_maps.size(); ++d) {
    const auto& map = dungeon_maps[d];
    const size_t count = map.nbr_of_floor + map.nbr_of_basement;
    if (map.nbr_of_floor > 0x0F || map.nbr_of_basement > 0x0F ||
        map.floor_rooms.size() != count || map.floor_gfx.size() != count) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Invalid floor dimensions for dungeon %d", d));
    }
    if (map.boss_room == 0x000F || map.boss_room == 0xFFFF)
      continue;
    if (map.boss_room > 0xFF) {
      return absl::InvalidArgumentError(
          absl::StrFormat("Boss room cannot fit a map cell for dungeon %d", d));
    }
    for (size_t f = 0; f < count; ++f) {
      const auto& rooms = map.floor_rooms[f];
      if (std::find(rooms.begin(), rooms.end(), map.boss_room) != rooms.end()) {
        // The game uses a signed LOW byte, but FF in the HIGH byte means no
        // boss. In particular B1 must be 00FF, never sign-extended to FFFF.
        boss_floors[d] =
            static_cast<uint8_t>(static_cast<int>(f) - map.nbr_of_basement);
        break;  // Preserve the existing first-occurrence selection.
      }
    }
    if (boss_floors[d] == 0xFFFF) {
      return absl::NotFoundError(
          absl::StrFormat("Boss room not found for dungeon %d", d));
    }
  }
 
  DungeonMapWritePlan plan;
  // The room pointer/floor block AND the GFX pointer block are fixed owners.
  // A stream must fit contiguously in one remaining interval; loaders cannot
  // skip a table in the middle of a room or graphics stream.
  constexpr std::array<std::pair<int, int>, 3> regions = {{
      {kDungeonMapDataStart, kDungeonMapDataReservedStart},
      {kDungeonMapDataReservedEnd + 1, kDungeonMapGfxPtr},
      {kDungeonMapGfxPtr + 2 * kNumDungeons, kDungeonMapDataLimit},
  }};
  int cursor =
      relocated_tile16 ? kDungeonMapDataStart : kDungeonMapDataReservedEnd + 1;
  auto allocate = [&](std::vector<uint8_t> bytes) -> absl::StatusOr<uint16_t> {
    // Empty streams have a valid bank0A pointer but consume no storage.
    int start = relocated_tile16 ? kDungeonMapDataStart
                                 : kDungeonMapDataReservedEnd + 1;
    if (!bytes.empty()) {
      bool found = false;
      for (const auto& [begin, end] : regions) {
        start = std::max(cursor, begin);
        if (start < end && bytes.size() <= static_cast<size_t>(end - start)) {
          found = true;
          break;
        }
      }
      if (!found) {
        return absl::OutOfRangeError(
            "Dungeon map streams exceed safe capacity");
      }
    }
    const int snes = PcToSnes(start);
    const int last =
        start + static_cast<int>(bytes.empty() ? 0 : bytes.size() - 1);
    if ((snes >> 16) != 0x0A || (snes & 0xFFFF) < 0x8000 ||
        (PcToSnes(last) >> 16) != 0x0A ||
        static_cast<size_t>(last) >= rom_size) {
      return absl::OutOfRangeError(
          "Dungeon map stream violates ROM/bank bounds");
    }
    if (!bytes.empty()) {
      cursor = start + bytes.size();
      plan.writes.push_back({start, std::move(bytes)});
    }
    return static_cast<uint16_t>(snes);
  };
  auto word = [&](int address, uint16_t value) {
    plan.writes.push_back(
        {address,
         {static_cast<uint8_t>(value), static_cast<uint8_t>(value >> 8)}});
  };
  std::array<std::vector<uint8_t>, kNumDungeons> room_streams, gfx_streams;
  std::array<uint16_t, kNumDungeons> room_pointers, gfx_pointers;
  for (int d = 0; d < kNumDungeons; ++d) {
    const auto& map = dungeon_maps[d];
    for (size_t f = 0; f < map.floor_rooms.size(); ++f) {
      for (int r = 0; r < kNumRooms; ++r) {
        room_streams[d].push_back(map.floor_rooms[f][r]);
        if (map.floor_rooms[f][r] != 0x0F)
          gfx_streams[d].push_back(map.floor_gfx[f][r]);
      }
    }
  }
  // Vanilla fills the room-data interval before its separate graphics interval.
  // Keep that ordering so interleaving cannot fragment an otherwise valid fit.
  for (int d = 0; d < kNumDungeons; ++d) {
    ASSIGN_OR_RETURN(room_pointers[d], allocate(std::move(room_streams[d])));
  }
  for (int d = 0; d < kNumDungeons; ++d) {
    ASSIGN_OR_RETURN(gfx_pointers[d], allocate(std::move(gfx_streams[d])));
  }
  for (int d = 0; d < kNumDungeons; ++d) {
    const auto& map = dungeon_maps[d];
    word(kDungeonMapRoomsPtr + 2 * d, room_pointers[d]);
    word(kDungeonMapGfxPtr + 2 * d, gfx_pointers[d]);
    word(kDungeonMapFloors + 2 * d,
         (map.nbr_of_floor << 4) | map.nbr_of_basement);
    word(kDungeonMapBossRooms + 2 * d, map.boss_room);
    word(kDungeonMapBossFloors + 2 * d, boss_floors[d]);
  }
  // Validate the complete output, including fixed tables, without touching ROM.
  std::vector<std::pair<int, int>> extents;
  for (const auto& write : plan.writes) {
    const int end = write.pc_address + write.data.size();
    if (write.pc_address < 0 || static_cast<size_t>(end) > rom_size ||
        (PcToSnes(write.pc_address) >> 16) != 0x0A ||
        (PcToSnes(end - 1) >> 16) != 0x0A) {
      return absl::OutOfRangeError(
          "Dungeon map write violates ROM/bank bounds");
    }
    extents.emplace_back(write.pc_address, end);
  }
  std::sort(extents.begin(), extents.end());
  for (size_t i = 1; i < extents.size(); ++i) {
    if (extents[i].first < extents[i - 1].second)
      return absl::InternalError("Overlapping dungeon map write plan");
  }
  return plan;
}
 
absl::StatusOr<DungeonMapWritePlan> BuildDungeonMapWritePlan(
    Rom& rom, const std::vector<DungeonMap>& dungeon_maps) {
  ASSIGN_OR_RETURN(auto marker, rom.ReadByte(kDungeonMapExpCheck));
  if (marker != 0xB9 && marker != 0x20) {
    return absl::FailedPreconditionError(
        "Unsupported dungeon map Tile16 layout");
  }
  const bool relocated_tile16 = marker == 0x20;
  const int tile16 = GetDungeonMapTile16Expanded();
  const int64_t tile16_end =
      static_cast<int64_t>(tile16) + kNumDungeonMapTile16 * 8;
  if (relocated_tile16) {
    if (tile16 < 0 || tile16_end > rom.size() ||
        (tile16 < kDungeonMapDataLimit && tile16_end > kDungeonMapDataStart)) {
      return absl::FailedPreconditionError(
          "Invalid relocated dungeon map Tile16 extent");
    }
  }
  ASSIGN_OR_RETURN(auto plan, BuildDungeonMapWritePlan(dungeon_maps, rom.size(),
                                                       relocated_tile16));
  if (relocated_tile16) {
    for (const auto& write : plan.writes) {
      const int64_t write_end = static_cast<int64_t>(write.pc_address) +
                                static_cast<int64_t>(write.data.size());
      if ((write.pc_address < tile16_end) && (write_end > tile16)) {
        return absl::FailedPreconditionError(
            "Dungeon map write overlaps relocated Tile16 artwork");
      }
    }
  }
  return plan;
}
 
absl::Status SaveDungeonMaps(Rom& rom, std::vector<DungeonMap>& dungeon_maps) {
  ASSIGN_OR_RETURN(auto plan, BuildDungeonMapWritePlan(rom, dungeon_maps));
  ScopedRomTransaction transaction(rom);
  for (const auto& write : plan.writes) {
    RETURN_IF_ERROR(rom.WriteVector(write.pc_address, write.data));
  }
  transaction.Commit();
  return absl::OkStatus();
}
 
absl::Status LoadDungeonMapTile16(gfx::Tilemap& tile16_blockset, Rom& rom,
                                  GameData* game_data,
                                  const std::vector<uint8_t>& gfx_data,
                                  bool bin_mode) {
  tile16_blockset.tile_size = {16, 16};
  tile16_blockset.map_size = {186, 186};
  tile16_blockset.atlas.Create(256, 192, 8,
                               std::vector<uint8_t>(256 * 192, 0x00));
 
  for (int i = 0; i < kNumDungeonMapTile16; i++) {
    int addr = kDungeonMapTile16;
    if (rom.data()[kDungeonMapExpCheck] != 0xB9) {
      addr = GetDungeonMapTile16Expanded();
    }
 
    ASSIGN_OR_RETURN(auto tl, rom.ReadWord(addr + (i * 8)));
    gfx::TileInfo t1 = gfx::WordToTileInfo(tl);  // Top left
 
    ASSIGN_OR_RETURN(auto tr, rom.ReadWord(addr + 2 + (i * 8)));
    gfx::TileInfo t2 = gfx::WordToTileInfo(tr);  // Top right
 
    ASSIGN_OR_RETURN(auto bl, rom.ReadWord(addr + 4 + (i * 8)));
    gfx::TileInfo t3 = gfx::WordToTileInfo(bl);  // Bottom left
 
    ASSIGN_OR_RETURN(auto br, rom.ReadWord(addr + 6 + (i * 8)));
    gfx::TileInfo t4 = gfx::WordToTileInfo(br);  // Bottom right
 
    int sheet_offset = 212;
    if (bin_mode) {
      sheet_offset = 0;
    }
    ComposeTile16(tile16_blockset, gfx_data, t1, t2, t3, t4, sheet_offset);
  }
 
  if (game_data) {
    tile16_blockset.atlas.SetPalette(
        *game_data->palette_groups.dungeon_main.mutable_palette(3));
  }
 
  // Queue texture creation via Arena's deferred system
  gfx::Arena::Get().QueueTextureCommand(gfx::Arena::TextureCommandType::CREATE,
                                        &tile16_blockset.atlas);
 
  return absl::OkStatus();
}
 
absl::Status SaveDungeonMapTile16(gfx::Tilemap& tile16_blockset, Rom& rom) {
  for (int i = 0; i < kNumDungeonMapTile16; i++) {
    int addr = kDungeonMapTile16;
    if (rom.data()[kDungeonMapExpCheck] != 0xB9) {
      addr = GetDungeonMapTile16Expanded();
    }
 
    gfx::TileInfo t1 = tile16_blockset.tile_info[i][0];
    gfx::TileInfo t2 = tile16_blockset.tile_info[i][1];
    gfx::TileInfo t3 = tile16_blockset.tile_info[i][2];
    gfx::TileInfo t4 = tile16_blockset.tile_info[i][3];
 
    auto tl = gfx::TileInfoToWord(t1);
    RETURN_IF_ERROR(rom.WriteWord(addr + (i * 8), tl));
 
    auto tr = gfx::TileInfoToWord(t2);
    RETURN_IF_ERROR(rom.WriteWord(addr + 2 + (i * 8), tr));
 
    auto bl = gfx::TileInfoToWord(t3);
    RETURN_IF_ERROR(rom.WriteWord(addr + 4 + (i * 8), bl));
 
    auto br = gfx::TileInfoToWord(t4);
    RETURN_IF_ERROR(rom.WriteWord(addr + 6 + (i * 8), br));
  }
  return absl::OkStatus();
}
 
absl::Status LoadDungeonMapGfxFromBinary(Rom& rom, GameData* game_data,
                                         gfx::Tilemap& tile16_blockset,
                                         std::array<gfx::Bitmap, 4>& sheets,
                                         std::vector<uint8_t>& gfx_bin_data) {
  std::string bin_file = util::FileDialogWrapper::ShowOpenFileDialog();
  if (bin_file.empty()) {
    return absl::InternalError("No file selected");
  }
 
  std::ifstream file(bin_file, std::ios::binary);
  if (!file.is_open()) {
    return absl::InternalError("Failed to open file");
  }
 
  // Read the gfx data into a buffer
  std::vector<uint8_t> bin_data((std::istreambuf_iterator<char>(file)),
                                std::istreambuf_iterator<char>());
  auto converted_bin = gfx::SnesTo8bppSheet(bin_data, 4, 4);
  gfx_bin_data = converted_bin;
  if (LoadDungeonMapTile16(tile16_blockset, rom, game_data, converted_bin, true)
          .ok()) {
    std::vector<std::vector<uint8_t>> gfx_sheets;
    for (int i = 0; i < 4; i++) {
      gfx_sheets.emplace_back(converted_bin.begin() + (i * 0x1000),
                              converted_bin.begin() + ((i + 1) * 0x1000));
      sheets[i] = gfx::Bitmap(128, 32, 8, gfx_sheets[i]);
      if (game_data) {
        sheets[i].SetPalette(
            *game_data->palette_groups.dungeon_main.mutable_palette(3));
      }
 
      // Queue texture creation via Arena's deferred system
      gfx::Arena::Get().QueueTextureCommand(
          gfx::Arena::TextureCommandType::CREATE, &sheets[i]);
    }
  }
  file.close();
 
  return absl::OkStatus();
}
 
}  // namespace yaze::zelda3