door_types.h

Go to the documentation of this file.

#ifndef YAZE_ZELDA3_DUNGEON_DOOR_TYPES_H
#define YAZE_ZELDA3_DUNGEON_DOOR_TYPES_H
 
#include <array>
#include <cstdint>
#include <string_view>
 
namespace yaze {
namespace zelda3 {
 
enum class DoorDirection : uint8_t {
  North = 0,  
  South = 1,  
  West = 2,   
  East = 3    
};
 
enum class DoorType : uint8_t {
  // Standard doors (0x00-0x06)
  NormalDoor = 0x00,       
  NormalDoorLower = 0x02,  
  ExitLower = 0x04,        
  UnusedCaveExit = 0x06,   
 
  // Cave/dungeon exits (0x08-0x10)
  WaterfallDoor = 0x08,          
  FancyDungeonExit = 0x0A,       
  FancyDungeonExitLower = 0x0C,  
  CaveExit = 0x0E,               
  LitCaveExitLower = 0x10,       
 
  // Markers (0x12-0x16)
  ExitMarker = 0x12,         
  DungeonSwapMarker = 0x14,  
  LayerSwapMarker = 0x16,    
 
  // Key doors and shutters (0x18-0x26)
  DoubleSidedShutter = 0x18,     
  EyeWatchDoor = 0x1A,           
  SmallKeyDoor = 0x1C,           
  BigKeyDoor = 0x1E,             
  SmallKeyStairsUp = 0x20,       
  SmallKeyStairsDown = 0x22,     
  SmallKeyStairsUpLower = 0x24,  
  SmallKeyStairsDownLower =
      0x26,  
 
  // Destructible doors (0x28-0x30)
  DashWall = 0x28,              
  BombableCaveExit = 0x2A,      
  UnopenableBigKeyDoor = 0x2C,  
  BombableDoor = 0x2E,          
  ExplodingWall = 0x30,         
 
  // Special doors (0x32-0x40)
  CurtainDoor = 0x32,            
  UnusableBottomShutter = 0x34,  
  BottomSidedShutter = 0x36,     
  TopSidedShutter = 0x38,        
  UnusableNormalDoor3A = 0x3A,   
  UnusableNormalDoor3C = 0x3C,   
  UnusableNormalDoor3E = 0x3E,   
  NormalDoorOneSidedShutter =
      0x40,  
 
  // Additional shutters (0x42-0x4A)
  UnusedDoubleSidedShutter = 0x42,  
  DoubleSidedShutterLower = 0x44,   
  ExplicitRoomDoor = 0x46,          
  BottomShutterLower = 0x48,        
  TopShutterLower = 0x4A,           
 
  // Unusable/glitchy doors (0x4C-0x66)
  UnusableNormalDoor4C = 0x4C,     
  UnusableNormalDoor4E = 0x4E,     
  UnusableNormalDoor50 = 0x50,     
  UnusableBombedDoor = 0x52,       
  UnusableGlitchyDoor54 = 0x54,    
  UnusableGlitchyDoor56 = 0x56,    
  UnusableNormalDoor58 = 0x58,     
  UnusableGlitchyStairs5A = 0x5A,  
  UnusableGlitchyStairs5C = 0x5C,  
  UnusableGlitchyStairs5E = 0x5E,  
  UnusableGlitchyStairs60 = 0x60,  
  UnusableGlitchyStairsDown62 =
      0x62,  
  UnusableGlitchyStairs64 = 0x64,  
  UnusableGlitchyStairsDown66 =
      0x66  
};
 
constexpr std::string_view GetDoorTypeName(DoorType type) {
  switch (type) {
    // Standard doors
    case DoorType::NormalDoor:
      return "Normal Door";
    case DoorType::NormalDoorLower:
      return "Normal Door (Lower)";
    case DoorType::ExitLower:
      return "Exit (Lower)";
    case DoorType::UnusedCaveExit:
      return "Unused Cave Exit";
    // Cave/dungeon exits
    case DoorType::WaterfallDoor:
      return "Waterfall Door";
    case DoorType::FancyDungeonExit:
      return "Fancy Dungeon Exit";
    case DoorType::FancyDungeonExitLower:
      return "Fancy Exit (Lower)";
    case DoorType::CaveExit:
      return "Cave Exit";
    case DoorType::LitCaveExitLower:
      return "Lit Cave Exit (Lower)";
    // Markers
    case DoorType::ExitMarker:
      return "Exit Marker";
    case DoorType::DungeonSwapMarker:
      return "Dungeon Swap Marker";
    case DoorType::LayerSwapMarker:
      return "Layer Swap Marker";
    // Key doors and shutters
    case DoorType::DoubleSidedShutter:
      return "Double-Sided Shutter";
    case DoorType::EyeWatchDoor:
      return "Eye Watch Door";
    case DoorType::SmallKeyDoor:
      return "Small Key Door";
    case DoorType::BigKeyDoor:
      return "Big Key Door";
    case DoorType::SmallKeyStairsUp:
      return "Small Key Stairs (Up)";
    case DoorType::SmallKeyStairsDown:
      return "Small Key Stairs (Down)";
    case DoorType::SmallKeyStairsUpLower:
      return "Key Stairs Up (Lower)";
    case DoorType::SmallKeyStairsDownLower:
      return "Key Stairs Down (Lower)";
    // Destructible
    case DoorType::DashWall:
      return "Dash Wall";
    case DoorType::BombableCaveExit:
      return "Bombable Cave Exit";
    case DoorType::UnopenableBigKeyDoor:
      return "Unopenable Big Key Door";
    case DoorType::BombableDoor:
      return "Bombable Door";
    case DoorType::ExplodingWall:
      return "Exploding Wall";
    // Special
    case DoorType::CurtainDoor:
      return "Curtain Door";
    case DoorType::UnusableBottomShutter:
      return "Unusable Bottom Shutter";
    case DoorType::BottomSidedShutter:
      return "Bottom-Sided Shutter";
    case DoorType::TopSidedShutter:
      return "Top-Sided Shutter";
    case DoorType::UnusableNormalDoor3A:
      return "Unusable Door 0x3A";
    case DoorType::UnusableNormalDoor3C:
      return "Unusable Door 0x3C";
    case DoorType::UnusableNormalDoor3E:
      return "Unusable Door 0x3E";
    case DoorType::NormalDoorOneSidedShutter:
      return "Normal Door (One-Sided)";
    // Additional shutters
    case DoorType::UnusedDoubleSidedShutter:
      return "Unused Double Shutter";
    case DoorType::DoubleSidedShutterLower:
      return "Double Shutter (Lower)";
    case DoorType::ExplicitRoomDoor:
      return "Explicit Room Door";
    case DoorType::BottomShutterLower:
      return "Bottom Shutter (Lower)";
    case DoorType::TopShutterLower:
      return "Top Shutter (Lower)";
    // Unusable/glitchy
    default:
      return "Unknown/Glitchy Door";
  }
}
 
constexpr std::string_view GetDoorDirectionName(DoorDirection dir) {
  switch (dir) {
    case DoorDirection::North:
      return "North";
    case DoorDirection::South:
      return "South";
    case DoorDirection::West:
      return "West";
    case DoorDirection::East:
      return "East";
  }
  return "Unknown";
}
 
struct DoorDimensions {
  int width_tiles;   
  int height_tiles;  
 
  int width_pixels() const { return width_tiles * 8; }
  int height_pixels() const { return height_tiles * 8; }
};
 
struct DoorFootprint {
  int offset_x_tiles;
  int offset_y_tiles;
  int width_tiles;
  int height_tiles;
 
  constexpr DoorDimensions dimensions() const {
    return {width_tiles, height_tiles};
  }
};
 
constexpr DoorDimensions GetDoorDimensions(DoorDirection dir) {
  switch (dir) {
    case DoorDirection::North:
    case DoorDirection::South:
      return {4, 3};  // 32x24 pixels
    case DoorDirection::West:
    case DoorDirection::East:
      return {3, 4};  // 24x32 pixels
  }
  return {4, 3};
}
 
constexpr DoorFootprint GetEditorDoorFootprint(DoorDirection dir,
                                               DoorType type) {
  if (dir == DoorDirection::South) {
    switch (type) {
      case DoorType::FancyDungeonExit:
      case DoorType::FancyDungeonExitLower:
        return {-3, -4, 10, 8};
      case DoorType::ExitLower:
      case DoorType::CaveExit:
      case DoorType::LitCaveExitLower:
        return {0, 0, 4, 4};
      default:
        return {0, 1, 4, 3};
    }
  }
 
  if (dir == DoorDirection::North && type == DoorType::CurtainDoor) {
    return {0, 0, 4, 4};
  }
 
  switch (dir) {
    case DoorDirection::North:
      return {0, 0, 4, 3};
    case DoorDirection::West:
      return {0, 0, 3, 4};
    case DoorDirection::East:
      return {1, 0, 3, 4};
    case DoorDirection::South:
      break;
  }
  return {0, 0, 4, 3};
}
 
constexpr DoorDimensions GetEditorDoorDimensions(DoorDirection dir,
                                                 DoorType type) {
  return GetEditorDoorFootprint(dir, type).dimensions();
}
 
constexpr bool IsExitDoorType(DoorType type) {
  switch (type) {
    case DoorType::FancyDungeonExit:
    case DoorType::FancyDungeonExitLower:
    case DoorType::CaveExit:
    case DoorType::LitCaveExitLower:
    case DoorType::ExitLower:
    case DoorType::UnusedCaveExit:
    case DoorType::BombableCaveExit:
    case DoorType::WaterfallDoor:
    case DoorType::ExitMarker:
      return true;
    default:
      return false;
  }
}
 
constexpr bool IsRoomConnectionDoorType(DoorType type) {
  if (IsExitDoorType(type)) {
    return false;
  }
  return type != DoorType::DungeonSwapMarker &&
         type != DoorType::LayerSwapMarker;
}
 
constexpr DoorType DoorTypeFromRaw(uint8_t raw_type) {
  return static_cast<DoorType>(raw_type);
}
 
constexpr DoorDirection DoorDirectionFromRaw(uint8_t raw_dir) {
  return static_cast<DoorDirection>(raw_dir & 0x03);
}
 
constexpr std::array<DoorType, 32> GetPlaceableDoorTypes() {
  return {{
      DoorType::NormalDoor,
      DoorType::NormalDoorLower,
      DoorType::ExitLower,
      DoorType::WaterfallDoor,
      DoorType::FancyDungeonExit,
      DoorType::FancyDungeonExitLower,
      DoorType::CaveExit,
      DoorType::LitCaveExitLower,
      DoorType::ExitMarker,
      DoorType::DungeonSwapMarker,
      DoorType::LayerSwapMarker,
      DoorType::DoubleSidedShutter,
      DoorType::EyeWatchDoor,
      DoorType::SmallKeyDoor,
      DoorType::BigKeyDoor,
      DoorType::SmallKeyStairsUp,
      DoorType::SmallKeyStairsDown,
      DoorType::SmallKeyStairsUpLower,
      DoorType::SmallKeyStairsDownLower,
      DoorType::DashWall,
      DoorType::BombableCaveExit,
      DoorType::UnopenableBigKeyDoor,
      DoorType::BombableDoor,
      DoorType::ExplodingWall,
      DoorType::CurtainDoor,
      DoorType::BottomSidedShutter,
      DoorType::TopSidedShutter,
      DoorType::NormalDoorOneSidedShutter,
      DoorType::DoubleSidedShutterLower,
      DoorType::ExplicitRoomDoor,
      DoorType::BottomShutterLower,
      DoorType::TopShutterLower,
  }};
}
 
// Compatibility alias for callers that used the former 20-item UI subset.
constexpr std::array<DoorType, 32> GetAllDoorTypes() {
  return GetPlaceableDoorTypes();
}
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_ZELDA3_DUNGEON_DOOR_TYPES_H