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; }
};
 
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 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, 20> GetAllDoorTypes() {
  return {{
      DoorType::NormalDoor,
      DoorType::NormalDoorLower,
      DoorType::CaveExit,
      DoorType::DoubleSidedShutter,
      DoorType::EyeWatchDoor,
      DoorType::SmallKeyDoor,
      DoorType::BigKeyDoor,
      DoorType::SmallKeyStairsUp,
      DoorType::SmallKeyStairsDown,
      DoorType::DashWall,
      DoorType::BombableDoor,
      DoorType::ExplodingWall,
      DoorType::CurtainDoor,
      DoorType::BottomSidedShutter,
      DoorType::TopSidedShutter,
      DoorType::FancyDungeonExit,
      DoorType::WaterfallDoor,
      DoorType::ExitMarker,
      DoorType::LayerSwapMarker,
      DoorType::DungeonSwapMarker,
  }};
}
 
}  // namespace zelda3
}  // namespace yaze
 
#endif  // YAZE_ZELDA3_DUNGEON_DOOR_TYPES_H