diff --git a/src/app/zelda3/overworld/overworld.cc b/src/app/zelda3/overworld/overworld.cc
index a63c0288..cba42d4c 100644
--- a/src/app/zelda3/overworld/overworld.cc
+++ b/src/app/zelda3/overworld/overworld.cc
@@ -18,20 +18,18 @@ absl::Status Overworld::Load(Rom &rom) {
   rom_ = rom;
 
   RETURN_IF_ERROR(AssembleMap32Tiles());
-  AssembleMap16Tiles();
-  RETURN_IF_ERROR(DecompressAllMapTiles())
+  RETURN_IF_ERROR(AssembleMap16Tiles());
+  DecompressAllMapTiles();
 
-  const bool load_custom_overworld =
-      core::ExperimentFlags::get().overworld.kLoadCustomOverworld;
   for (int map_index = 0; map_index < kNumOverworldMaps; ++map_index)
-    overworld_maps_.emplace_back(map_index, rom_, load_custom_overworld);
+    overworld_maps_.emplace_back(map_index, rom_);
 
   FetchLargeMaps();
   LoadEntrances();
   RETURN_IF_ERROR(LoadExits());
   RETURN_IF_ERROR(LoadItems());
   RETURN_IF_ERROR(LoadSprites());
-  RETURN_IF_ERROR(LoadOverworldMaps())
+  RETURN_IF_ERROR(LoadOverworldMaps());
 
   is_loaded_ = true;
   return absl::OkStatus();
@@ -154,7 +152,7 @@ absl::Status Overworld::AssembleMap32Tiles() {
   return absl::OkStatus();
 }
 
-void Overworld::AssembleMap16Tiles() {
+absl::Status Overworld::AssembleMap16Tiles() {
   int tpos = kMap16Tiles;
   int num_tile16 = kNumTile16Individual;
   if (rom()->data()[kMap16ExpandedFlagPos] != 0x0F &&
@@ -165,16 +163,21 @@ void Overworld::AssembleMap16Tiles() {
   }
 
   for (int i = 0; i < num_tile16; i += 1) {
-    gfx::TileInfo t0 = gfx::GetTilesInfo(rom()->toint16(tpos));
+    ASSIGN_OR_RETURN(auto t0_data, rom()->ReadWord(tpos));
+    gfx::TileInfo t0 = gfx::GetTilesInfo(t0_data);
     tpos += 2;
-    gfx::TileInfo t1 = gfx::GetTilesInfo(rom()->toint16(tpos));
+    ASSIGN_OR_RETURN(auto t1_data, rom()->ReadWord(tpos));
+    gfx::TileInfo t1 = gfx::GetTilesInfo(t1_data);
     tpos += 2;
-    gfx::TileInfo t2 = gfx::GetTilesInfo(rom()->toint16(tpos));
+    ASSIGN_OR_RETURN(auto t2_data, rom()->ReadWord(tpos));
+    gfx::TileInfo t2 = gfx::GetTilesInfo(t2_data);
     tpos += 2;
-    gfx::TileInfo t3 = gfx::GetTilesInfo(rom()->toint16(tpos));
+    ASSIGN_OR_RETURN(auto t3_data, rom()->ReadWord(tpos));
+    gfx::TileInfo t3 = gfx::GetTilesInfo(t3_data);
     tpos += 2;
     tiles16_.emplace_back(t0, t1, t2, t3);
   }
+  return absl::OkStatus();
 }
 
 void Overworld::AssignWorldTiles(int x, int y, int sx, int sy, int tpos,
@@ -196,9 +199,9 @@ void Overworld::OrganizeMapTiles(std::vector<uint8_t> &bytes,
     for (int x = 0; x < 16; x++) {
       auto tidD = (uint16_t)((bytes2[ttpos] << 8) + bytes[ttpos]);
       if (int tpos = tidD; tpos < tiles32_unique_.size()) {
-        if (i < 64) {
+        if (i < kDarkWorldMapIdStart) {
           AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.light_world);
-        } else if (i < 128 && i >= 64) {
+        } else if (i < kSpecialWorldMapIdStart && i >= kDarkWorldMapIdStart) {
           AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.dark_world);
         } else {
           AssignWorldTiles(x, y, sx, sy, tpos, map_tiles_.special_world);
@@ -209,7 +212,7 @@ void Overworld::OrganizeMapTiles(std::vector<uint8_t> &bytes,
   }
 }
 
-absl::Status Overworld::DecompressAllMapTiles() {
+void Overworld::DecompressAllMapTiles() {
   const auto get_ow_map_gfx_ptr = [this](int index, uint32_t map_ptr) {
     int p = (rom()->data()[map_ptr + 2 + (3 * index)] << 16) +
             (rom()->data()[map_ptr + 1 + (3 * index)] << 8) +
@@ -257,7 +260,6 @@ absl::Status Overworld::DecompressAllMapTiles() {
       c = 0;
     }
   }
-  return absl::OkStatus();
 }
 
 absl::Status Overworld::LoadOverworldMaps() {
@@ -265,9 +267,9 @@ absl::Status Overworld::LoadOverworldMaps() {
   std::vector<std::future<absl::Status>> futures;
   for (int i = 0; i < kNumOverworldMaps; ++i) {
     int world_type = 0;
-    if (i >= 64 && i < 0x80) {
+    if (i >= kDarkWorldMapIdStart && i < kSpecialWorldMapIdStart) {
       world_type = 1;
-    } else if (i >= 0x80) {
+    } else if (i >= kSpecialWorldMapIdStart) {
       world_type = 2;
     }
     auto task_function = [this, i, size, world_type]() {
@@ -641,9 +643,7 @@ absl::Status Overworld::SaveOverworldMaps() {
     return absl::AbortedError("Too many maps data " + std::to_string(pos));
   }
 
-  // Save large maps
   RETURN_IF_ERROR(SaveLargeMaps())
-
   return absl::OkStatus();
 }
 
@@ -685,9 +685,11 @@ absl::Status Overworld::SaveLargeMaps() {
         RETURN_IF_ERROR(rom()->WriteByte(
             kOverworldScreenSizeForLoading + i + offset, 0x04));
         RETURN_IF_ERROR(rom()->WriteByte(
-            kOverworldScreenSizeForLoading + i + offset + 64, 0x04));
-        RETURN_IF_ERROR(rom()->WriteByte(
-            kOverworldScreenSizeForLoading + i + offset + 128, 0x04));
+            kOverworldScreenSizeForLoading + i + offset + kDarkWorldMapIdStart,
+            0x04));
+        RETURN_IF_ERROR(rom()->WriteByte(kOverworldScreenSizeForLoading + i +
+                                             offset + kSpecialWorldMapIdStart,
+                                         0x04));
       }
 
       // Check 5 and 6
@@ -871,10 +873,10 @@ absl::Status Overworld::SaveLargeMaps() {
 
       RETURN_IF_ERROR(
           rom()->WriteByte(kOverworldScreenSizeForLoading + i, 0x02));
-      RETURN_IF_ERROR(
-          rom()->WriteByte(kOverworldScreenSizeForLoading + i + 64, 0x02));
-      RETURN_IF_ERROR(
-          rom()->WriteByte(kOverworldScreenSizeForLoading + i + 128, 0x02));
+      RETURN_IF_ERROR(rom()->WriteByte(
+          kOverworldScreenSizeForLoading + i + kDarkWorldMapIdStart, 0x02));
+      RETURN_IF_ERROR(rom()->WriteByte(
+          kOverworldScreenSizeForLoading + i + kSpecialWorldMapIdStart, 0x02));
 
       RETURN_IF_ERROR(rom()->WriteShort(
           kOverworldScreenTileMapChangeByScreen1 + (i * 2), 0x0060));
@@ -974,9 +976,9 @@ std::vector<uint64_t> GetAllTile16(OverworldMapTiles &map_tiles_) {
   int c = 0;
   OverworldBlockset tiles_used;
   for (int i = 0; i < kNumOverworldMaps; i++) {
-    if (i < 64) {
+    if (i < kDarkWorldMapIdStart) {
       tiles_used = map_tiles_.light_world;
-    } else if (i < 128 && i >= 64) {
+    } else if (i < kSpecialWorldMapIdStart && i >= kDarkWorldMapIdStart) {
       tiles_used = map_tiles_.dark_world;
     } else {
       tiles_used = map_tiles_.special_world;
@@ -1353,7 +1355,18 @@ absl::Status Overworld::SaveMap16Tiles() {
 
 absl::Status Overworld::SaveEntrances() {
   core::logf("Saving Entrances");
-  for (int i = 0; i < 129; i++) {
+  int ow_entrance_map_ptr = kOverworldEntranceMap;
+  int ow_entrance_pos_ptr = kOverworldEntrancePos;
+  int ow_entrance_id_ptr = kOverworldEntranceEntranceId;
+  int num_entrances = kNumOverworldEntrances;
+  if (expanded_entrances_) {
+    ow_entrance_map_ptr = kOverworldEntranceMapExpanded;
+    ow_entrance_pos_ptr = kOverworldEntrancePosExpanded;
+    ow_entrance_id_ptr = kOverworldEntranceEntranceIdExpanded;
+    expanded_entrances_ = true;
+  }
+
+  for (int i = 0; i < kNumOverworldEntrances; i++) {
     RETURN_IF_ERROR(rom()->WriteShort(kOverworldEntranceMap + (i * 2),
                                       all_entrances_[i].map_id_))
     RETURN_IF_ERROR(rom()->WriteShort(kOverworldEntrancePos + (i * 2),
@@ -1362,7 +1375,7 @@ absl::Status Overworld::SaveEntrances() {
                                      all_entrances_[i].entrance_id_))
   }
 
-  for (int i = 0; i < 0x13; i++) {
+  for (int i = 0; i < kNumOverworldHoles; i++) {
     RETURN_IF_ERROR(
         rom()->WriteShort(kOverworldHoleArea + (i * 2), all_holes_[i].map_id_))
     RETURN_IF_ERROR(
@@ -1376,7 +1389,7 @@ absl::Status Overworld::SaveEntrances() {
 
 absl::Status Overworld::SaveExits() {
   core::logf("Saving Exits");
-  for (int i = 0; i < 0x4F; i++) {
+  for (int i = 0; i < kNumOverworldExits; i++) {
     RETURN_IF_ERROR(
         rom()->WriteShort(OWExitRoomId + (i * 2), all_exits_[i].room_id_));
     RETURN_IF_ERROR(rom()->Write(OWExitMapId + i, all_exits_[i].map_id_));
@@ -1408,7 +1421,6 @@ absl::Status Overworld::SaveExits() {
 }
 
 namespace {
-
 bool CompareItemsArrays(std::vector<OverworldItem> item_array1,
                         std::vector<OverworldItem> item_array2) {
   if (item_array1.size() != item_array2.size()) {
@@ -1435,13 +1447,13 @@ bool CompareItemsArrays(std::vector<OverworldItem> item_array1,
 
   return true;
 }
-
 }  // namespace
 
 absl::Status Overworld::SaveItems() {
-  std::vector<std::vector<OverworldItem>> room_items(128);
+  std::vector<std::vector<OverworldItem>> room_items(
+      kNumOverworldMapItemPointers);
 
-  for (int i = 0; i < 128; i++) {
+  for (int i = 0; i < kNumOverworldMapItemPointers; i++) {
     room_items[i] = std::vector<OverworldItem>();
     for (const OverworldItem &item : all_items_) {
       if (item.room_map_id_ == i) {
@@ -1455,10 +1467,10 @@ absl::Status Overworld::SaveItems() {
   }
 
   int data_pos = kOverworldItemsPointers + 0x100;
-  int item_pointers[128];
-  int item_pointers_reuse[128];
+  int item_pointers[kNumOverworldMapItemPointers];
+  int item_pointers_reuse[kNumOverworldMapItemPointers];
   int empty_pointer = 0;
-  for (int i = 0; i < 128; i++) {
+  for (int i = 0; i < kNumOverworldMapItemPointers; i++) {
     item_pointers_reuse[i] = -1;
     for (int ci = 0; ci < i; ci++) {
       if (room_items[i].empty()) {
@@ -1478,7 +1490,7 @@ absl::Status Overworld::SaveItems() {
     }
   }
 
-  for (int i = 0; i < 128; i++) {
+  for (int i = 0; i < kNumOverworldMapItemPointers; i++) {
     if (item_pointers_reuse[i] == -1) {
       item_pointers[i] = data_pos;
       for (const OverworldItem &item : room_items[i]) {
@@ -1519,40 +1531,48 @@ absl::Status Overworld::SaveItems() {
 
 absl::Status Overworld::SaveMapProperties() {
   core::logf("Saving Map Properties");
-  for (int i = 0; i < 64; i++) {
+  for (int i = 0; i < kDarkWorldMapIdStart; i++) {
     RETURN_IF_ERROR(rom()->WriteByte(kAreaGfxIdPtr + i,
                                      overworld_maps_[i].area_graphics()));
     RETURN_IF_ERROR(rom()->WriteByte(kOverworldMapPaletteIds + i,
                                      overworld_maps_[i].area_palette()));
     RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + i,
                                      overworld_maps_[i].sprite_graphics(0)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 64 + i,
-                                     overworld_maps_[i].sprite_graphics(1)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 128 + i,
-                                     overworld_maps_[i].sprite_graphics(2)));
+    RETURN_IF_ERROR(
+        rom()->WriteByte(kOverworldSpriteset + kDarkWorldMapIdStart + i,
+                         overworld_maps_[i].sprite_graphics(1)));
+    RETURN_IF_ERROR(
+        rom()->WriteByte(kOverworldSpriteset + kSpecialWorldMapIdStart + i,
+                         overworld_maps_[i].sprite_graphics(2)));
     RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + i,
                                      overworld_maps_[i].sprite_palette(0)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 64 + i,
-                                     overworld_maps_[i].sprite_palette(1)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 128 + i,
-                                     overworld_maps_[i].sprite_palette(2)));
+    RETURN_IF_ERROR(
+        rom()->WriteByte(kOverworldSpritePaletteIds + kDarkWorldMapIdStart + i,
+                         overworld_maps_[i].sprite_palette(1)));
+    RETURN_IF_ERROR(rom()->WriteByte(
+        kOverworldSpritePaletteIds + kSpecialWorldMapIdStart + i,
+        overworld_maps_[i].sprite_palette(2)));
   }
 
-  for (int i = 64; i < 128; i++) {
+  for (int i = kDarkWorldMapIdStart; i < kSpecialWorldMapIdStart; i++) {
     RETURN_IF_ERROR(rom()->WriteByte(kAreaGfxIdPtr + i,
                                      overworld_maps_[i].area_graphics()));
     RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + i,
                                      overworld_maps_[i].sprite_graphics(0)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 64 + i,
-                                     overworld_maps_[i].sprite_graphics(1)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpriteset + 128 + i,
-                                     overworld_maps_[i].sprite_graphics(2)));
+    RETURN_IF_ERROR(
+        rom()->WriteByte(kOverworldSpriteset + kDarkWorldMapIdStart + i,
+                         overworld_maps_[i].sprite_graphics(1)));
+    RETURN_IF_ERROR(
+        rom()->WriteByte(kOverworldSpriteset + kSpecialWorldMapIdStart + i,
+                         overworld_maps_[i].sprite_graphics(2)));
     RETURN_IF_ERROR(rom()->WriteByte(kOverworldMapPaletteIds + i,
                                      overworld_maps_[i].area_palette()));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 64 + i,
-                                     overworld_maps_[i].sprite_palette(0)));
-    RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 128 + i,
-                                     overworld_maps_[i].sprite_palette(1)));
+    RETURN_IF_ERROR(
+        rom()->WriteByte(kOverworldSpritePaletteIds + kDarkWorldMapIdStart + i,
+                         overworld_maps_[i].sprite_palette(0)));
+    RETURN_IF_ERROR(rom()->WriteByte(
+        kOverworldSpritePaletteIds + kSpecialWorldMapIdStart + i,
+        overworld_maps_[i].sprite_palette(1)));
     RETURN_IF_ERROR(rom()->WriteByte(kOverworldSpritePaletteIds + 192 + i,
                                      overworld_maps_[i].sprite_palette(2)));
   }
diff --git a/src/app/zelda3/overworld/overworld.h b/src/app/zelda3/overworld/overworld.h
index 2ba5daaf..e5fab6e5 100644
--- a/src/app/zelda3/overworld/overworld.h
+++ b/src/app/zelda3/overworld/overworld.h
@@ -5,11 +5,8 @@
 
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
-#include "app/core/common.h"
-#include "app/core/constants.h"
 #include "app/gfx/snes_tile.h"
 #include "app/rom.h"
-#include "app/zelda3/common.h"
 #include "app/zelda3/overworld/overworld_entrance.h"
 #include "app/zelda3/overworld/overworld_exit.h"
 #include "app/zelda3/overworld/overworld_item.h"
@@ -222,13 +219,13 @@ class Overworld : public SharedRom {
                                               int dimension,
                                               const uint32_t *map32address);
   absl::Status AssembleMap32Tiles();
-  void AssembleMap16Tiles();
+  absl::Status AssembleMap16Tiles();
   void AssignWorldTiles(int x, int y, int sx, int sy, int tpos,
                         OverworldBlockset &world);
   void OrganizeMapTiles(std::vector<uint8_t> &bytes,
                         std::vector<uint8_t> &bytes2, int i, int sx, int sy,
                         int &ttpos);
-  absl::Status DecompressAllMapTiles();
+  void DecompressAllMapTiles();
 
   Rom rom_;
 
diff --git a/src/app/zelda3/overworld/overworld_entrance.h b/src/app/zelda3/overworld/overworld_entrance.h
index da3c9947..ef7e219e 100644
--- a/src/app/zelda3/overworld/overworld_entrance.h
+++ b/src/app/zelda3/overworld/overworld_entrance.h
@@ -10,6 +10,9 @@
 namespace yaze {
 namespace zelda3 {
 
+constexpr int kNumOverworldEntrances = 129;
+constexpr int kNumOverworldHoles = 0x13;
+
 constexpr int kOverworldEntranceMap = 0xDB96F;
 constexpr int kOverworldEntrancePos = 0xDBA71;
 constexpr int kOverworldEntranceEntranceId = 0xDBB73;
diff --git a/src/app/zelda3/overworld/overworld_exit.h b/src/app/zelda3/overworld/overworld_exit.h
index f663b917..b83f3afb 100644
--- a/src/app/zelda3/overworld/overworld_exit.h
+++ b/src/app/zelda3/overworld/overworld_exit.h
@@ -10,6 +10,7 @@
 namespace yaze {
 namespace zelda3 {
 
+constexpr int kNumOverworldExits = 0x4F;
 constexpr int OWExitRoomId = 0x15D8A;  // 0x15E07 Credits sequences
 // 105C2 Ending maps
 // 105E2 Sprite Group Table for Ending
diff --git a/src/app/zelda3/overworld/overworld_item.h b/src/app/zelda3/overworld/overworld_item.h
index e95fb30b..9562fcdc 100644
--- a/src/app/zelda3/overworld/overworld_item.h
+++ b/src/app/zelda3/overworld/overworld_item.h
@@ -12,6 +12,7 @@
 namespace yaze {
 namespace zelda3 {
 
+constexpr int kNumOverworldMapItemPointers = 0x80;
 constexpr int kOverworldItemsPointers = 0xDC2F9;
 constexpr int kOverworldItemsAddress = 0xDC8B9;  // 1BC2F9
 constexpr int kOverworldItemsBank = 0xDC8BF;
diff --git a/src/app/zelda3/overworld/overworld_map.cc b/src/app/zelda3/overworld/overworld_map.cc
index 7c0b3ce8..09505ca7 100644
--- a/src/app/zelda3/overworld/overworld_map.cc
+++ b/src/app/zelda3/overworld/overworld_map.cc
@@ -12,11 +12,11 @@
 namespace yaze {
 namespace zelda3 {
 
-OverworldMap::OverworldMap(int index, Rom& rom, bool load_custom_data)
+OverworldMap::OverworldMap(int index, Rom &rom)
     : index_(index), parent_(index), rom_(rom) {
   LoadAreaInfo();
 
-  if (load_custom_data) {
+  if (core::ExperimentFlags::get().overworld.kLoadCustomOverworld) {
     // If the custom overworld ASM has NOT already been applied, manually set
     // the vanilla values.
     uint8_t asm_version = rom_[OverworldCustomASMHasBeenApplied];
@@ -29,14 +29,16 @@ OverworldMap::OverworldMap(int index, Rom& rom, bool load_custom_data)
 }
 
 absl::Status OverworldMap::BuildMap(int count, int game_state, int world,
-                                    std::vector<gfx::Tile16>& tiles16,
-                                    OverworldBlockset& world_blockset) {
+                                    std::vector<gfx::Tile16> &tiles16,
+                                    OverworldBlockset &world_blockset) {
   game_state_ = game_state;
   world_ = world;
   if (large_map_) {
     if (parent_ != index_ && !initialized_) {
-      if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
-        area_graphics_ = rom_[kOverworldSpecialGfxGroup + (parent_ - 0x80)];
+      if (index_ >= kSpecialWorldMapIdStart && index_ <= 0x8A &&
+          index_ != 0x88) {
+        area_graphics_ = rom_[kOverworldSpecialGfxGroup +
+                              (parent_ - kSpecialWorldMapIdStart)];
         area_palette_ = rom_[kOverworldSpecialPalGroup + 1];
       } else if (index_ == 0x88) {
         area_graphics_ = 0x51;
@@ -60,7 +62,7 @@ absl::Status OverworldMap::BuildMap(int count, int game_state, int world,
 }
 
 void OverworldMap::LoadAreaInfo() {
-  if (index_ != 0x80) {
+  if (index_ != kSpecialWorldMapIdStart) {
     if (index_ <= 128)
       large_map_ = (rom_[kOverworldMapSize + (index_ & 0x3F)] != 0);
     else {
@@ -71,7 +73,7 @@ void OverworldMap::LoadAreaInfo() {
 
   message_id_ = rom_.toint16(kOverworldMessageIds + (parent_ * 2));
 
-  if (index_ < 0x40) {
+  if (index_ < kDarkWorldMapIdStart) {
     area_graphics_ = rom_[kAreaGfxIdPtr + parent_];
     area_palette_ = rom_[kOverworldMapPaletteIds + parent_];
 
@@ -81,24 +83,34 @@ void OverworldMap::LoadAreaInfo() {
     area_music_[3] = rom_[kOverworldMusicAgahnim + parent_];
 
     sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_];
-    sprite_graphics_[1] = rom_[kOverworldSpriteset + parent_ + 0x40];
-    sprite_graphics_[2] = rom_[kOverworldSpriteset + parent_ + 0x80];
+    sprite_graphics_[1] =
+        rom_[kOverworldSpriteset + parent_ + kDarkWorldMapIdStart];
+    sprite_graphics_[2] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
 
     sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_];
-    sprite_palette_[1] = rom_[kOverworldSpritePaletteIds + parent_ + 0x40];
-    sprite_palette_[2] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
-  } else if (index_ < 0x80) {
+    sprite_palette_[1] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kDarkWorldMapIdStart];
+    sprite_palette_[2] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
+  } else if (index_ < kSpecialWorldMapIdStart) {
     area_graphics_ = rom_[kAreaGfxIdPtr + parent_];
     area_palette_ = rom_[kOverworldMapPaletteIds + parent_];
     area_music_[0] = rom_[kOverworldMusicDarkWorld + (parent_ - 64)];
 
-    sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_ + 0x80];
-    sprite_graphics_[1] = rom_[kOverworldSpriteset + parent_ + 0x80];
-    sprite_graphics_[2] = rom_[kOverworldSpriteset + parent_ + 0x80];
+    sprite_graphics_[0] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
+    sprite_graphics_[1] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
+    sprite_graphics_[2] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
 
-    sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
-    sprite_palette_[1] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
-    sprite_palette_[2] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
+    sprite_palette_[0] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
+    sprite_palette_[1] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
+    sprite_palette_[2] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
   } else {
     if (index_ == 0x94) {
       parent_ = 0x80;
@@ -123,10 +135,13 @@ void OverworldMap::LoadAreaInfo() {
       parent_ = 129;
     }
 
-    area_palette_ = rom_[kOverworldSpecialPalGroup + parent_ - 0x80];
-    if ((index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) ||
+    area_palette_ =
+        rom_[kOverworldSpecialPalGroup + parent_ - kSpecialWorldMapIdStart];
+    if ((index_ >= kSpecialWorldMapIdStart && index_ <= 0x8A &&
+         index_ != 0x88) ||
         index_ == 0x94) {
-      area_graphics_ = rom_[kOverworldSpecialGfxGroup + (parent_ - 0x80)];
+      area_graphics_ =
+          rom_[kOverworldSpecialGfxGroup + (parent_ - kSpecialWorldMapIdStart)];
       area_palette_ = rom_[kOverworldSpecialPalGroup + 1];
     } else if (index_ == 0x88) {
       area_graphics_ = 0x51;
@@ -137,23 +152,30 @@ void OverworldMap::LoadAreaInfo() {
       area_palette_ = rom_[kOverworldMapPaletteIds + parent_];
     }
 
-    sprite_graphics_[0] = rom_[kOverworldSpriteset + parent_ + 0x80];
-    sprite_graphics_[1] = rom_[kOverworldSpriteset + parent_ + 0x80];
-    sprite_graphics_[2] = rom_[kOverworldSpriteset + parent_ + 0x80];
+    sprite_graphics_[0] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
+    sprite_graphics_[1] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
+    sprite_graphics_[2] =
+        rom_[kOverworldSpriteset + parent_ + kSpecialWorldMapIdStart];
 
-    sprite_palette_[0] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
-    sprite_palette_[1] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
-    sprite_palette_[2] = rom_[kOverworldSpritePaletteIds + parent_ + 0x80];
+    sprite_palette_[0] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
+    sprite_palette_[1] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
+    sprite_palette_[2] =
+        rom_[kOverworldSpritePaletteIds + parent_ + kSpecialWorldMapIdStart];
   }
 }
 
 void OverworldMap::LoadCustomOverworldData() {
   // Set the main palette values.
-  if (index_ < 0x40) {
+  if (index_ < kDarkWorldMapIdStart) {
     area_palette_ = 0;
-  } else if (index_ >= 0x40 && index_ < 0x80) {
+  } else if (index_ >= kDarkWorldMapIdStart &&
+             index_ < kSpecialWorldMapIdStart) {
     area_palette_ = 1;
-  } else if (index_ >= 0x80 && index_ < 0xA0) {
+  } else if (index_ >= kSpecialWorldMapIdStart && index_ < 0xA0) {
     area_palette_ = 0;
   }
 
@@ -166,31 +188,31 @@ void OverworldMap::LoadCustomOverworldData() {
   }
 
   // Set the mosaic values.
-  mosaic_ = index_ == 0x00 || index_ == 0x40 || index_ == 0x80 ||
-            index_ == 0x81 || index_ == 0x88;
+  mosaic_ = index_ == 0x00 || index_ == kDarkWorldMapIdStart ||
+            index_ == kSpecialWorldMapIdStart || index_ == 0x81 ||
+            index_ == 0x88;
 
-  int indexWorld = 0x20;
+  int index_world = 0x20;
 
-  if (parent_ >= 0x40 && parent_ < 0x80)  // DW
+  if (parent_ >= kDarkWorldMapIdStart &&
+      parent_ < kSpecialWorldMapIdStart)  // DW
   {
-    indexWorld = 0x21;
+    index_world = 0x21;
   } else if (parent_ == 0x88)  // Triforce room
   {
-    indexWorld = 0x24;
+    index_world = 0x24;
   }
 
   const auto overworld_gfx_groups2 =
       rom_.version_constants().kOverworldGfxGroups2;
 
   // Main Blocksets
-
   for (int i = 0; i < 8; i++) {
     custom_gfx_ids_[i] =
-        (uint8_t)rom_[overworld_gfx_groups2 + (indexWorld * 8) + i];
+        (uint8_t)rom_[overworld_gfx_groups2 + (index_world * 8) + i];
   }
 
   const auto overworldgfxGroups = rom_.version_constants().kOverworldGfxGroups1;
-
   // Replace the variable tiles with the variable ones.
   uint8_t temp = rom_[overworldgfxGroups + (area_graphics_ * 4)];
   if (temp != 0) {
@@ -232,7 +254,8 @@ void OverworldMap::LoadCustomOverworldData() {
   subscreen_overlay_ = 0x00FF;
 
   if (index_ == 0x00 ||
-      index_ == 0x40)  // Add fog 2 to the lost woods and skull woods.
+      index_ ==
+          kDarkWorldMapIdStart)  // Add fog 2 to the lost woods and skull woods.
   {
     subscreen_overlay_ = 0x009D;
   } else if (index_ == 0x03 || index_ == 0x05 ||
@@ -271,22 +294,22 @@ void OverworldMap::SetupCustomTileset(uint8_t asm_version) {
 
     animated_gfx_ = rom_[OverworldCustomAnimatedGFXArray + index_];
   } else {
-    int indexWorld = 0x20;
+    int index_world = 0x20;
 
-    if (parent_ >= 0x40 && parent_ < 0x80)  // DW
+    if (parent_ >= kDarkWorldMapIdStart &&
+        parent_ < kSpecialWorldMapIdStart)  // DW
     {
-      indexWorld = 0x21;
+      index_world = 0x21;
     } else if (parent_ == 0x88)  // Triforce room
     {
-      indexWorld = 0x24;
+      index_world = 0x24;
     }
 
     // Main Blocksets
-
     for (int i = 0; i < 8; i++) {
       custom_gfx_ids_[i] =
           (uint8_t)rom_[rom_.version_constants().kOverworldGfxGroups2 +
-                        (indexWorld * 8) + i];
+                        (index_world * 8) + i];
     }
 
     const auto overworldgfxGroups =
@@ -337,9 +360,10 @@ void OverworldMap::SetupCustomTileset(uint8_t asm_version) {
 }
 
 void OverworldMap::LoadMainBlocksetId() {
-  if (parent_ < 0x40) {
+  if (parent_ < kDarkWorldMapIdStart) {
     main_gfx_id_ = 0x20;
-  } else if (parent_ >= 0x40 && parent_ < 0x80) {
+  } else if (parent_ >= kDarkWorldMapIdStart &&
+             parent_ < kSpecialWorldMapIdStart) {
     main_gfx_id_ = 0x21;
   } else if (parent_ == 0x88) {
     main_gfx_id_ = 0x24;
@@ -425,7 +449,7 @@ void OverworldMap::LoadAreaGraphics() {
 
 namespace palette_internal {
 
-absl::Status SetColorsPalette(Rom& rom, int index, gfx::SnesPalette& current,
+absl::Status SetColorsPalette(Rom &rom, int index, gfx::SnesPalette &current,
                               gfx::SnesPalette main, gfx::SnesPalette animated,
                               gfx::SnesPalette aux1, gfx::SnesPalette aux2,
                               gfx::SnesPalette hud, gfx::SnesColor bgrcolor,
@@ -544,9 +568,8 @@ absl::Status SetColorsPalette(Rom& rom, int index, gfx::SnesPalette& current,
 }
 }  // namespace palette_internal
 
-// New helper function to get a palette from the Rom.
 absl::StatusOr<gfx::SnesPalette> OverworldMap::GetPalette(
-    const gfx::PaletteGroup& palette_group, int index, int previous_index,
+    const gfx::PaletteGroup &palette_group, int index, int previous_index,
     int limit) {
   if (index == 255) {
     index = rom_[rom_.version_constants().kOverworldMapPaletteGroup +
@@ -559,9 +582,9 @@ absl::StatusOr<gfx::SnesPalette> OverworldMap::GetPalette(
 }
 
 absl::Status OverworldMap::LoadPalette() {
-  int previousPalId =
+  int previous_pal_id =
       index_ > 0 ? rom_[kOverworldMapPaletteIds + parent_ - 1] : 0;
-  int previousSprPalId =
+  int previous_spr_pal_id =
       index_ > 0 ? rom_[kOverworldSpritePaletteIds + parent_ - 1] : 0;
 
   area_palette_ = std::min((int)area_palette_, 0xA3);
@@ -583,20 +606,21 @@ absl::Status OverworldMap::LoadPalette() {
 
   auto ow_aux_pal_group = rom_.palette_group().overworld_aux;
   ASSIGN_OR_RETURN(gfx::SnesPalette aux1,
-                   GetPalette(ow_aux_pal_group, pal1, previousPalId, 20));
+                   GetPalette(ow_aux_pal_group, pal1, previous_pal_id, 20));
   ASSIGN_OR_RETURN(gfx::SnesPalette aux2,
-                   GetPalette(ow_aux_pal_group, pal2, previousPalId, 20));
+                   GetPalette(ow_aux_pal_group, pal2, previous_pal_id, 20));
 
   // Additional handling of `pal3` and `parent_`
   if (pal3 == 255) {
     pal3 = rom_[rom_.version_constants().kOverworldMapPaletteGroup +
-                (previousPalId * 4) + 2];
+                (previous_pal_id * 4) + 2];
   }
 
-  if (parent_ < 0x40) {
+  if (parent_ < kDarkWorldMapIdStart) {
     pal0 = parent_ == 0x03 || parent_ == 0x05 || parent_ == 0x07 ? 2 : 0;
     ASSIGN_OR_RETURN(bgr, grass_pal_group[0].GetColor(0));
-  } else if (parent_ >= 0x40 && parent_ < 0x80) {
+  } else if (parent_ >= kDarkWorldMapIdStart &&
+             parent_ < kSpecialWorldMapIdStart) {
     pal0 = parent_ == 0x43 || parent_ == 0x45 || parent_ == 0x47 ? 3 : 1;
     ASSIGN_OR_RETURN(bgr, grass_pal_group[0].GetColor(1));
   } else if (parent_ >= 128 && parent_ < kNumOverworldMaps) {
@@ -610,21 +634,21 @@ absl::Status OverworldMap::LoadPalette() {
 
   auto ow_main_pal_group = rom_.palette_group().overworld_main;
   ASSIGN_OR_RETURN(gfx::SnesPalette main,
-                   GetPalette(ow_main_pal_group, pal0, previousPalId, 255));
+                   GetPalette(ow_main_pal_group, pal0, previous_pal_id, 255));
   auto ow_animated_pal_group = rom_.palette_group().overworld_animated;
   ASSIGN_OR_RETURN(gfx::SnesPalette animated,
                    GetPalette(ow_animated_pal_group, std::min((int)pal3, 13),
-                              previousPalId, 14));
+                              previous_pal_id, 14));
 
   auto hud_pal_group = rom_.palette_group().hud;
   gfx::SnesPalette hud = hud_pal_group[0];
 
   ASSIGN_OR_RETURN(gfx::SnesPalette spr,
                    GetPalette(rom_.palette_group().sprites_aux3, pal4,
-                              previousSprPalId, 24));
+                              previous_spr_pal_id, 24));
   ASSIGN_OR_RETURN(gfx::SnesPalette spr2,
                    GetPalette(rom_.palette_group().sprites_aux3, pal5,
-                              previousSprPalId, 24));
+                              previous_spr_pal_id, 24));
 
   RETURN_IF_ERROR(palette_internal::SetColorsPalette(
       rom_, parent_, current_palette_, main, animated, aux1, aux2, hud, bgr,
@@ -638,7 +662,6 @@ absl::Status OverworldMap::LoadPalette() {
   return absl::OkStatus();
 }
 
-// New helper function to process graphics buffer.
 void OverworldMap::ProcessGraphicsBuffer(int index, int static_graphics_offset,
                                          int size) {
   for (int i = 0; i < size; i++) {
@@ -666,7 +689,7 @@ absl::Status OverworldMap::BuildTileset() {
   return absl::OkStatus();
 }
 
-absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16,
+absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16> &tiles16,
                                            int count) {
   if (current_blockset_.size() == 0) current_blockset_.resize(0x100000, 0x00);
 
@@ -712,7 +735,7 @@ absl::Status OverworldMap::BuildTiles16Gfx(std::vector<gfx::Tile16>& tiles16,
   return absl::OkStatus();
 }
 
-absl::Status OverworldMap::BuildBitmap(OverworldBlockset& world_blockset) {
+absl::Status OverworldMap::BuildBitmap(OverworldBlockset &world_blockset) {
   if (bitmap_data_.size() != 0) {
     bitmap_data_.clear();
   }
diff --git a/src/app/zelda3/overworld/overworld_map.h b/src/app/zelda3/overworld/overworld_map.h
index 9575bd68..18c864c7 100644
--- a/src/app/zelda3/overworld/overworld_map.h
+++ b/src/app/zelda3/overworld/overworld_map.h
@@ -10,7 +10,6 @@
 #include "app/gfx/snes_palette.h"
 #include "app/gfx/snes_tile.h"
 #include "app/rom.h"
-#include "app/zelda3/common.h"
 
 namespace yaze {
 namespace zelda3 {
@@ -55,6 +54,9 @@ constexpr int OverworldCustomTileGFXGroupArray = 0x140480;
 // 1 byte, not 0 if enabled
 constexpr int OverworldCustomTileGFXGroupEnabled = 0x140148;
 
+constexpr int kDarkWorldMapIdStart = 0x40;
+constexpr int kSpecialWorldMapIdStart = 0x80;
+
 /**
  * @brief Represents tile32 data for the overworld.
  */
@@ -75,7 +77,7 @@ typedef struct OverworldMapTiles {
 class OverworldMap : public gfx::GfxContext {
  public:
   OverworldMap() = default;
-  OverworldMap(int index, Rom& rom, bool load_custom_data = false);
+  OverworldMap(int index, Rom& rom);
 
   absl::Status BuildMap(int count, int game_state, int world,
                         std::vector<gfx::Tile16>& tiles16,