dungeon_coordinates.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_DUNGEON_DUNGEON_COORDINATES_H_
#define YAZE_APP_EDITOR_DUNGEON_DUNGEON_COORDINATES_H_
 
#include <cstdint>
#include <utility>
 
namespace yaze {
namespace editor {
 
namespace dungeon_coords {
 
// Room constants
constexpr int kTileSize = 8;           // Dungeon tiles are 8x8 pixels
constexpr int kRoomTileWidth = 64;     // Room width in tiles
constexpr int kRoomTileHeight = 64;    // Room height in tiles
constexpr int kRoomPixelWidth = 512;   // 64 * 8
constexpr int kRoomPixelHeight = 512;  // 64 * 8
constexpr int kRoomCount = 0x128;      // 296 rooms total
constexpr int kEntranceCount = 0x8C;   // 140 entrances total
 
// Sprite coordinate system uses 16-pixel units
constexpr int kSpriteTileSize = 16;
constexpr int kSpriteGridMax = 31;  // 0-31 range for sprites
 
// Camera/World coordinate constants
constexpr uint16_t kCameraBaseOffset = 0x1000;  // Base offset for dungeon camera
constexpr int kDungeonGridWidth = 16;           // Rooms per row in dungeon grid
 
inline std::pair<int, int> RoomToCanvas(int room_x, int room_y) {
  return {room_x * kTileSize, room_y * kTileSize};
}
 
inline std::pair<int, int> CanvasToRoom(int canvas_x, int canvas_y) {
  return {canvas_x / kTileSize, canvas_y / kTileSize};
}
 
inline std::pair<int, int> ScreenToCanvas(int screen_x, int screen_y,
                                          float scale) {
  if (scale <= 0.0f) scale = 1.0f;
  return {static_cast<int>(screen_x / scale),
          static_cast<int>(screen_y / scale)};
}
 
inline std::pair<int, int> CanvasToScreen(int canvas_x, int canvas_y,
                                          float scale) {
  return {static_cast<int>(canvas_x * scale),
          static_cast<int>(canvas_y * scale)};
}
 
inline bool IsWithinBounds(int canvas_x, int canvas_y, int margin = 0) {
  return canvas_x >= -margin && canvas_y >= -margin &&
         canvas_x < kRoomPixelWidth + margin &&
         canvas_y < kRoomPixelHeight + margin;
}
 
inline std::pair<int, int> ClampToRoom(int room_x, int room_y) {
  if (room_x < 0) room_x = 0;
  if (room_x >= kRoomTileWidth) room_x = kRoomTileWidth - 1;
  if (room_y < 0) room_y = 0;
  if (room_y >= kRoomTileHeight) room_y = kRoomTileHeight - 1;
  return {room_x, room_y};
}
 
inline bool IsValidRoomId(int room_id) {
  return room_id >= 0 && room_id < kRoomCount;
}
 
// ============================================================================
// Camera/World Coordinate System
// ============================================================================
 
inline std::pair<int, int> RoomIdToGridPosition(int room_id) {
  return {room_id % kDungeonGridWidth, room_id / kDungeonGridWidth};
}
 
inline uint16_t CalculateCameraX(int room_id, int local_pixel_x) {
  auto [col, row] = RoomIdToGridPosition(room_id);
  return kCameraBaseOffset + (col * kRoomPixelWidth) + local_pixel_x;
}
 
inline uint16_t CalculateCameraY(int room_id, int local_pixel_y) {
  auto [col, row] = RoomIdToGridPosition(room_id);
  return kCameraBaseOffset + (row * kRoomPixelWidth) + local_pixel_y;
}
 
inline std::pair<uint16_t, uint16_t> TileToCameraCoords(int room_id, 
                                                         int tile_x, 
                                                         int tile_y) {
  int pixel_x = tile_x * kTileSize;
  int pixel_y = tile_y * kTileSize;
  return {CalculateCameraX(room_id, pixel_x), 
          CalculateCameraY(room_id, pixel_y)};
}
 
struct CameraToLocalResult {
  int room_id;
  int local_pixel_x;
  int local_pixel_y;
  int local_tile_x;
  int local_tile_y;
};
 
inline CameraToLocalResult CameraToLocalCoords(uint16_t camera_x, 
                                                uint16_t camera_y) {
  // Remove base offset
  int world_x = camera_x - kCameraBaseOffset;
  int world_y = camera_y - kCameraBaseOffset;
  
  // Calculate grid position
  int col = world_x / kRoomPixelWidth;
  int row = world_y / kRoomPixelHeight;
  
  // Calculate local position
  int local_x = world_x % kRoomPixelWidth;
  int local_y = world_y % kRoomPixelHeight;
  
  // Handle negative values (shouldn't happen normally)
  if (world_x < 0) { col = 0; local_x = 0; }
  if (world_y < 0) { row = 0; local_y = 0; }
  
  return {
    row * kDungeonGridWidth + col,  // room_id
    local_x,                         // local_pixel_x
    local_y,                         // local_pixel_y
    local_x / kTileSize,            // local_tile_x
    local_y / kTileSize             // local_tile_y
  };
}
 
inline std::pair<uint16_t, uint16_t> SpriteToCameraCoords(int room_id,
                                                           int sprite_x,
                                                           int sprite_y) {
  int pixel_x = sprite_x * kSpriteTileSize;
  int pixel_y = sprite_y * kSpriteTileSize;
  return {CalculateCameraX(room_id, pixel_x),
          CalculateCameraY(room_id, pixel_y)};
}
 
}  // namespace dungeon_coords
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_DUNGEON_DUNGEON_COORDINATES_H_