Merge branch 'master' into rom-test-hex-nums

CMakeLists.txt

@@ -22,6 +22,21 @@ set(ABSL_PROPAGATE_CXX_STD ON)
 set(ABSL_CXX_STANDARD 17)
 set(ABSL_USE_GOOGLETEST_HEAD ON)
 set(ABSL_ENABLE_INSTALL ON)
+set(
+  ABSL_TARGETS   
+  absl::strings
+  absl::flags
+  absl::status
+  absl::statusor
+  absl::examine_stack
+  absl::stacktrace
+  absl::base
+  absl::config
+  absl::core_headers
+  absl::raw_logging_internal
+  absl::failure_signal_handler
+  absl::flat_hash_map
+)
 
 # Video Libraries -------------------------------------------------------------
 find_package(PNG REQUIRED)

docs/dev-setup-windows.md

@@ -0,0 +1,17 @@
+
+For VSCode users, use the following CMake extensions with MinGW-w64
+
+https://marketplace.visualstudio.com/items?itemName=twxs.cmake
+https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools
+
+https://www.msys2.org/
+
+Add to environment variables `C:\msys64\mingw64\bin`
+
+Install the following packages using `pacman -S <package-name>`
+
+`mingw-w64-x86_64-gcc`
+`mingw-w64-x86_64-gcc-libs`
+`mingw-w64-x86_64-cmake`
+`mingw-w64-x86_64-glew`
+`mingw-w64-x86_64-lib-png`

src/CMakeLists.txt

@@ -36,6 +36,11 @@ set(
 
 # Asar Assembly ---------------------------------------------------------------
 add_subdirectory(lib/asar/src)
+set(ASAR_GEN_EXE  OFF)
+set(ASAR_GEN_DLL  ON)
+set(ASAR_GEN_LIB OFF)
+set(ASAR_GEN_EXE_TEST OFF)
+set(ASAR_GEN_DLL_TEST OFF)
 
 # yaze source files -----------------------------------------------------------
 set(
@@ -84,7 +89,7 @@ set(
 
 add_executable(
   yaze
-  yaze.cc
+  app/yaze.cc
   app/rom.cc
   ${YAZE_APP_ASM_SRC}
   ${YAZE_APP_CORE_SRC}
@@ -108,22 +113,6 @@ target_include_directories(
   lib/asar/src/asar-dll-bindings/c
 )
 
-set(
-  ABSL_TARGETS   
-  absl::strings
-  absl::flags
-  absl::status
-  absl::statusor
-  absl::examine_stack
-  absl::stacktrace
-  absl::base
-  absl::config
-  absl::core_headers
-  absl::raw_logging_internal
-  absl::failure_signal_handler
-  absl::flat_hash_map
-)
-
 set(SDL_TARGETS SDL2::SDL2)
 
 if(WIN32 OR MINGW)
@@ -137,7 +126,8 @@ target_link_libraries(
   ${SDL_TARGETS}
   ${PNG_LIBRARIES}
   ${GLEW_LIBRARIES}
-  ${OPENGL_LIBRARIES} 
+  ${OPENGL_LIBRARIES}
+  ${CMAKE_DL_LIBS}
   ImGui
 )
 

src/app/asm/script.cc

@@ -12,6 +12,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "app/core/common.h"
 #include "app/core/constants.h"
 #include "app/rom.h"
 
@@ -19,15 +20,6 @@ namespace yaze {
 namespace app {
 namespace snes_asm {
 
-static auto string_replace(std::string &str, const std::string &from,
-                           const std::string &to) -> bool {
-  size_t start = str.find(from);
-  if (start == std::string::npos) return false;
-
-  str.replace(start, from.length(), to);
-  return true;
-}
-
 std::string GenerateBytePool(char mosaic_tiles[core::kNumOverworldMaps]) {
   std::string to_return = "";
   int column = 0;
@@ -64,6 +56,10 @@ std::string GenerateBytePool(char mosaic_tiles[core::kNumOverworldMaps]) {
 }
 
 absl::Status Script::ApplyPatchToROM(ROM &rom) {
+  if (patch_contents_.empty() || patch_filename_.empty()) {
+    return absl::InvalidArgumentError("No patch loaded!");
+  }
+
   char *data = (char *)rom.data();
   int size = rom.GetSize();
   int count = 0;
@@ -76,7 +72,8 @@ absl::Status Script::ApplyPatchToROM(ROM &rom) {
 }
 
 absl::Status Script::GenerateMosaicChangeAssembly(
-    ROM &rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset) {
+    ROM &rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset,
+    int hook_offset) {
   std::fstream file("assets/asm/mosaic_change.asm",
                     std::ios::out | std::ios::in);
   if (!file.is_open()) {
@@ -89,12 +86,13 @@ absl::Status Script::GenerateMosaicChangeAssembly(
   file.close();
 
   auto assembly_string = assembly.str();
-  if (!string_replace(assembly_string, "<HOOK>", kMosaicChangeOffset)) {
+
+  if (!core::StringReplace(assembly_string, "<HOOK>", kMosaicChangeOffset)) {
     return absl::InternalError(
         "Mosaic template did not have proper `<HOOK>` to replace.");
   }
 
-  if (!string_replace(
+  if (!core::StringReplace(
           assembly_string, "<EXPANDED_SPACE>",
           absl::StrFormat("$%x", routine_offset + kSNESToPCOffset))) {
     return absl::InternalError(
@@ -102,6 +100,7 @@ absl::Status Script::GenerateMosaicChangeAssembly(
   }
 
   assembly_string += GenerateBytePool(mosaic_tiles);
+  patch_contents_ = assembly_string;
   patch_filename_ = "assets/asm/mosaic_change_generated.asm";
   std::ofstream new_file(patch_filename_, std::ios::out);
   if (new_file.is_open()) {

src/app/asm/script.h

@@ -23,16 +23,24 @@ namespace snes_asm {
 const std::string kMosaicChangeOffset = "$02AADB";
 constexpr int kSNESToPCOffset = 0x138000;
 
-class Script {
+class ScriptTemplate {
+ public:
+  virtual absl::Status ApplyPatchToROM(ROM& rom) = 0;
+  virtual absl::Status GenerateMosaicChangeAssembly(
+      ROM& rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset,
+      int hook_offset = 0) = 0;
+};
+
+class Script : public ScriptTemplate {
  public:
   Script() { asar_init_with_dll_path("assets/libasar.dll"); }
 
+  absl::Status ApplyPatchToROM(ROM& rom) override;
   absl::Status GenerateMosaicChangeAssembly(
-      ROM& rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset);
+      ROM& rom, char mosaic_tiles[core::kNumOverworldMaps], int routine_offset,
+      int hook_offset = 0) override;
 
  private:
-  absl::Status ApplyPatchToROM(ROM& rom);
-
   int64_t patch_size_;
   std::string patch_filename_;
   std::string patch_contents_;

src/app/core/common.cc

@@ -1,6 +1,7 @@
 #include "common.h"
 
 #include <cstdint>
+#include <string>
 
 namespace yaze {
 namespace app {
@@ -19,7 +20,7 @@ int AddressFromBytes(uint8_t addr1, uint8_t addr2, uint8_t addr3) {
 }
 
 // hextodec has been imported from SNESDisasm to parse hex numbers
-int HexToDec(char* input, int length) {
+int HexToDec(char *input, int length) {
   int result = 0;
   int value;
   int ceiling = length - 1;
@@ -48,6 +49,15 @@ int HexToDec(char* input, int length) {
   return result;
 }
 
+bool StringReplace(std::string &str, const std::string &from,
+                   const std::string &to) {
+  size_t start = str.find(from);
+  if (start == std::string::npos) return false;
+
+  str.replace(start, from.length(), to);
+  return true;
+}
+
 }  // namespace core
 }  // namespace app
 }  // namespace yaze

src/app/core/common.h

@@ -2,6 +2,7 @@
 #define YAZE_CORE_COMMON_H
 
 #include <cstdint>
+#include <string>
 
 namespace yaze {
 namespace app {
@@ -10,6 +11,8 @@ namespace core {
 unsigned int SnesToPc(unsigned int addr);
 int AddressFromBytes(uint8_t addr1, uint8_t addr2, uint8_t addr3);
 int HexToDec(char *input, int length);
+bool StringReplace(std::string &str, const std::string &from,
+                   const std::string &to);
 
 }  // namespace core
 }  // namespace app

src/app/core/constants.h

@@ -26,8 +26,8 @@
 #define MENU_ITEM2(w, v) if (ImGui::MenuItem(w, v))
 
 #define CHECK_STATUS(w) \
-  if (!w.ok()) {            \
+  if (!w.ok()) {        \
-    return w;               \
+    return w;           \
   }
 
 using ushort = unsigned short;
@@ -39,9 +39,16 @@ namespace yaze {
 namespace app {
 namespace core {
 
-//===========================================================================================
+// ============================================================================
+// Window Variables
+// ============================================================================
+
+constexpr int kScreenWidth = 1200;
+constexpr int kScreenHeight = 800;
+
+// ============================================================================
 // 65816 LanguageDefinition
-//===========================================================================================
+// ============================================================================
 
 static const char *const kKeywords[] = {
     "ADC", "AND", "ASL", "BCC", "BCS", "BEQ",   "BIT",   "BMI",       "BNE",
@@ -66,9 +73,9 @@ static const char *const kIdentifiers[] = {
     "srand",   "strcat",  "strcmp",  "strerror", "time",    "tolower",
     "toupper"};
 
-//===========================================================================================
+// ============================================================================
 // Magic numbers
-//===========================================================================================
+// ============================================================================
 
 /// Bit set for object priority
 constexpr ushort TilePriorityBit = 0x2000;
@@ -96,9 +103,9 @@ constexpr int NumberOfMap32 = Map32PerScreen * kNumOverworldMaps;
 constexpr int NumberOfOWSprites = 352;
 constexpr int NumberOfColors = 3143;
 
-// ===========================================================================================
+// ============================================================================
-//  gfx
+//  Game Graphics
-// ===========================================================================================
+// ============================================================================
 
 constexpr int tile_address = 0x1B52;           // JP = Same
 constexpr int tile_address_floor = 0x1B5A;     // JP = Same
@@ -107,8 +114,9 @@ constexpr int subtype2_tiles = 0x83F0;         // JP = Same
 constexpr int subtype3_tiles = 0x84F0;         // JP = Same
 constexpr int gfx_animated_pointer = 0x10275;  // JP 0x10624 //long pointer
 constexpr int overworldgfxGroups2 = 0x6073;    // 0x60B3
-constexpr int gfx_1_pointer =
+
-    0x6790;  // 2byte pointer bank 00 pc -> 0x4320  CF80  ; 004F80
+// 2 byte pointer bank 00 pc -> 0x4320
+constexpr int gfx_1_pointer = 0x6790;  // CF80 ; 004F80
 constexpr int gfx_2_pointer = 0x6795;  // D05F ; 00505F
 constexpr int gfx_3_pointer = 0x679A;  // D13E ; 00513E
 constexpr int hud_palettes = 0xDD660;
@@ -118,9 +126,9 @@ constexpr int kTilesheetWidth = 128;
 constexpr int kTilesheetHeight = 32;
 constexpr int kTilesheetDepth = 8;
 
-// ===========================================================================================
+// ============================================================================
 //  Overworld Related Variables
-// ===========================================================================================
+// ============================================================================
 
 constexpr int compressedAllMap32PointersHigh = 0x1794D;
 constexpr int compressedAllMap32PointersLow = 0x17B2D;
@@ -157,7 +165,6 @@ constexpr int overlayPointersBank = 0x0E;
 constexpr int overworldTilesType = 0x71459;
 constexpr int overworldMessages = 0x3F51D;
 
-// TODO:
 constexpr int overworldMusicBegining = 0x14303;
 constexpr int overworldMusicZelda = 0x14303 + 0x40;
 constexpr int overworldMusicMasterSword = 0x14303 + 0x80;
@@ -167,10 +174,11 @@ constexpr int overworldMusicDW = 0x14403;
 constexpr int overworldEntranceAllowedTilesLeft = 0xDB8C1;
 constexpr int overworldEntranceAllowedTilesRight = 0xDB917;
 
-constexpr int overworldMapSize = 0x12844;  // 0x00 = small maps, 0x20 = large
+// 0x00 = small maps, 0x20 = large maps
-                                           // maps
+constexpr int overworldMapSize = 0x12844;
-constexpr int overworldMapSizeHighByte =
+
-    0x12884;  // 0x01 = small maps, 0x03 = large maps
+// 0x01 = small maps, 0x03 = large maps
+constexpr int overworldMapSizeHighByte = 0x12884;
 
 // relative to the WORLD + 0x200 per map
 // large map that are not == parent id = same position as their parent!
@@ -184,9 +192,9 @@ constexpr int overworldTransitionPositionX = 0x12944;
 
 constexpr int overworldScreenSize = 0x1788D;
 
-//===========================================================================================
+// ============================================================================
 // Overworld Exits/Entrances Variables
-//===========================================================================================
+// ============================================================================
 constexpr int OWExitRoomId = 0x15D8A;  // 0x15E07 Credits sequences
 // 105C2 Ending maps
 // 105E2 Sprite Group Table for Ending
@@ -226,9 +234,10 @@ constexpr int OWExitUnk1Whirlpool = 0x16BF5;     //    JP = ;016E91
 constexpr int OWExitUnk2Whirlpool = 0x16C17;     //    JP = ;016EB3
 constexpr int OWWhirlpoolPosition = 0x16CF8;     //    JP = ;016F94
 
-//===========================================================================================
+// ============================================================================
 // Dungeon Related Variables
-//===========================================================================================
+// ============================================================================
+
 // That could be turned into a pointer :
 constexpr int dungeons_palettes_groups = 0x75460;           // JP 0x67DD0
 constexpr int dungeons_main_bg_palette_pointers = 0xDEC4B;  // JP Same
@@ -275,7 +284,6 @@ constexpr int doorPointers = 0xF83C0;
 
 // doors
 constexpr int door_gfx_up = 0x4D9E;
-//
 constexpr int door_gfx_down = 0x4E06;
 constexpr int door_gfx_cavexit_down = 0x4E06;
 constexpr int door_gfx_left = 0x4E66;
@@ -293,14 +301,17 @@ constexpr int text_data2 = 0x75F40;
 constexpr int pointers_dictionaries = 0x74703;
 constexpr int characters_width = 0x74ADF;
 
-//===========================================================================================
+// ============================================================================
 // Dungeon Entrances Related Variables
-//===========================================================================================
+// ============================================================================
-constexpr int entrance_room = 0x14813;  // 0x14577 //word value for each room
+
+// 0x14577 word value for each room
+constexpr int entrance_room = 0x14813;
+
 // 8 bytes per room, HU, FU, HD, FD, HL, FL, HR, FR
 constexpr int entrance_scrolledge = 0x1491D;       // 0x14681
-constexpr int entrance_yscroll = 0x14D45;          // 0x14AA9 //2bytes each room
+constexpr int entrance_yscroll = 0x14D45;          // 0x14AA9 2 bytes each room
-constexpr int entrance_xscroll = 0x14E4F;          // 0x14BB3 //2bytes
+constexpr int entrance_xscroll = 0x14E4F;          // 0x14BB3 2 bytes
 constexpr int entrance_yposition = 0x14F59;        // 0x14CBD 2bytes
 constexpr int entrance_xposition = 0x15063;        // 0x14DC7 2bytes
 constexpr int entrance_camerayposition = 0x1516D;  // 0x14ED1 2bytes
@@ -311,15 +322,17 @@ constexpr int entrance_blockset = 0x15381;  // 0x150E5 1byte
 constexpr int entrance_floor = 0x15406;     // 0x1516A 1byte
 constexpr int entrance_dungeon = 0x1548B;   // 0x151EF 1byte (dungeon id)
 constexpr int entrance_door = 0x15510;      // 0x15274 1byte
-// 1 byte, ---b ---a b = bg2, a = need to check -_-
+
+// 1 byte, ---b ---a b = bg2, a = need to check
 constexpr int entrance_ladderbg = 0x15595;        // 0x152F9
-constexpr int entrance_scrolling = 0x1561A;       // 0x1537E //1byte --h- --v-
+constexpr int entrance_scrolling = 0x1561A;       // 0x1537E 1byte --h- --v-
 constexpr int entrance_scrollquadrant = 0x1569F;  // 0x15403 1byte
-constexpr int entrance_exit = 0x15724;            // 0x15488 //2byte word
+constexpr int entrance_exit = 0x15724;            // 0x15488 2byte word
 constexpr int entrance_music = 0x1582E;           // 0x15592
 
 // word value for each room
 constexpr int startingentrance_room = 0x15B6E;  // 0x158D2
+
 // 8 bytes per room, HU, FU, HD, FD, HL, FL, HR, FR
 constexpr int startingentrance_scrolledge = 0x15B7C;  // 0x158E0
 constexpr int startingentrance_yscroll = 0x15BB4;  // 0x14AA9 //2bytes each room
@@ -335,7 +348,7 @@ constexpr int startingentrance_dungeon = 0x15C16;  // 0x151EF 1byte (dungeon id)
 
 constexpr int startingentrance_door = 0x15C2B;  // 0x15274 1byte
 
-// 1 byte, ---b ---a b = bg2, a = need to check -_-
+// 1 byte, ---b ---a b = bg2, a = need to check
 constexpr int startingentrance_ladderbg = 0x15C1D;  // 0x152F9
 // 1byte --h- --v-
 constexpr int startingentrance_scrolling = 0x15C24;       // 0x1537E
@@ -365,24 +378,23 @@ constexpr int dungeons_endrooms = 0x792D;
 constexpr int dungeons_bossrooms = 0x10954;  // short value
 
 // Bed Related Values (Starting location)
-
 constexpr int bedPositionX = 0x039A37;  // short value
 constexpr int bedPositionY = 0x039A32;  // short value
 
 // short value (on 2 different bytes)
 constexpr int bedPositionResetXLow = 0x02DE53;
-constexpr int bedPositionResetXHigh = 0x02DE58;  //^^^^^^
+constexpr int bedPositionResetXHigh = 0x02DE58;
 
 // short value (on 2 different bytes)
 constexpr int bedPositionResetYLow = 0x02DE5D;
-constexpr int bedPositionResetYHigh = 0x02DE62;  //^^^^^^
+constexpr int bedPositionResetYHigh = 0x02DE62;
 
 constexpr int bedSheetPositionX = 0x0480BD;  // short value
 constexpr int bedSheetPositionY = 0x0480B8;  // short value
 
-//===========================================================================================
+// ============================================================================
 // Gravestones related variables
-//===========================================================================================
+// ============================================================================
 
 constexpr int GravesYTilePos = 0x49968;    // short (0x0F entries)
 constexpr int GravesXTilePos = 0x49986;    // short (0x0F entries)
@@ -396,9 +408,9 @@ constexpr int GravesCountOnY = 0x499E0;  // Byte 0x09 entries
 constexpr int GraveLinkSpecialHole = 0x46DD9;    // short
 constexpr int GraveLinkSpecialStairs = 0x46DE0;  // short
 
-//===========================================================================================
+// ============================================================================
 // Palettes Related Variables - This contain all the palettes of the game
-//===========================================================================================
+// ============================================================================
 constexpr int overworldPaletteMain = 0xDE6C8;
 constexpr int overworldPaletteAuxialiary = 0xDE86C;
 constexpr int overworldPaletteAnimated = 0xDE604;
@@ -420,19 +432,23 @@ constexpr int hardcodedGrassLW = 0x5FEA9;
 constexpr int hardcodedGrassDW = 0x05FEB3;  // 0x7564F
 constexpr int hardcodedGrassSpecial = 0x75640;
 
-//===========================================================================================
+// ============================================================================
 // Dungeon Map Related Variables
-//===========================================================================================
+// ============================================================================
+
 constexpr int dungeonMap_rooms_ptr = 0x57605;  // 14 pointers of map data
 constexpr int dungeonMap_floors = 0x575D9;     // 14 words values
 
 constexpr int dungeonMap_gfx_ptr = 0x57BE4;  // 14 pointers of gfx data
+
 // data start for floors/gfx MUST skip 575D9 to 57621 (pointers)
 constexpr int dungeonMap_datastart = 0x57039;
+
 // IF Byte = 0xB9 dungeon maps are not expanded
 constexpr int dungeonMap_expCheck = 0x56652;
 constexpr int dungeonMap_tile16 = 0x57009;
 constexpr int dungeonMap_tile16Exp = 0x109010;
+
 // 14 words values 0x000F = no boss
 constexpr int dungeonMap_bossrooms = 0x56807;
 constexpr int triforceVertices = 0x04FFD2;  // group of 3, X, Y ,Z
@@ -440,9 +456,10 @@ constexpr int TriforceFaces = 0x04FFE4;     // group of 5
 
 constexpr int crystalVertices = 0x04FF98;
 
-//===========================================================================================
+// ============================================================================
 // Names
-//===========================================================================================
+// ============================================================================
+
 static const absl::string_view RoomEffect[] = {"Nothing",
                                                "Nothing",
                                                "Moving Floor",

src/app/core/controller.cc

@@ -154,9 +154,9 @@ absl::Status Controller::CreateWindow() {
         SDL_CreateWindow("Yet Another Zelda3 Editor",  // window title
                          SDL_WINDOWPOS_UNDEFINED,      // initial x position
                          SDL_WINDOWPOS_UNDEFINED,      // initial y position
-                         1200,                         // width, in pixels
+                         kScreenWidth,                 // width, in pixels
-                         800,                          // height, in pixels
+                         kScreenHeight,                // height, in pixels
-                         SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL),
+                         SDL_WINDOW_RESIZABLE),
         sdl_deleter());
     if (window_ == nullptr) {
       return absl::InternalError(

src/app/editor/dungeon_editor.cc

@@ -8,7 +8,10 @@ namespace editor {
 
 void DungeonEditor::Update() {
   DrawToolset();
-  canvas_.Update();
+  canvas_.DrawBackground();
+  canvas_.UpdateContext();
+  canvas_.DrawGrid();
+  canvas_.DrawOverlay();
 }
 
 void DungeonEditor::DrawToolset() {

src/app/editor/master_editor.cc

@@ -188,12 +188,12 @@ void MasterEditor::DrawFileMenu() const {
 
 void MasterEditor::DrawEditMenu() {
   if (ImGui::BeginMenu("Edit")) {
-    MENU_ITEM2("Undo", "Ctrl+Z") {}
+    MENU_ITEM2("Undo", "Ctrl+Z") { status_ = overworld_editor_.Undo(); }
-    MENU_ITEM2("Redo", "Ctrl+Y") {}
+    MENU_ITEM2("Redo", "Ctrl+Y") { status_ = overworld_editor_.Redo(); }
     ImGui::Separator();
-    MENU_ITEM2("Cut", "Ctrl+X") {}
+    MENU_ITEM2("Cut", "Ctrl+X") { status_ = overworld_editor_.Cut(); }
-    MENU_ITEM2("Copy", "Ctrl+C") {}
+    MENU_ITEM2("Copy", "Ctrl+C") { status_ = overworld_editor_.Copy(); }
-    MENU_ITEM2("Paste", "Ctrl+V") {}
+    MENU_ITEM2("Paste", "Ctrl+V") { status_ = overworld_editor_.Paste(); }
     ImGui::Separator();
     MENU_ITEM2("Find", "Ctrl+F") {}
     ImGui::Separator();

src/app/editor/overworld_editor.h

@@ -41,8 +41,11 @@ class OverworldEditor {
  public:
   void SetupROM(ROM &rom);
   absl::Status Update();
-
   absl::Status Undo() { return absl::UnimplementedError("Undo"); }
+  absl::Status Redo() { return absl::UnimplementedError("Redo"); }
+  absl::Status Cut() { return absl::UnimplementedError("Cut"); }
+  absl::Status Copy() { return absl::UnimplementedError("Copy"); }
+  absl::Status Paste() { return absl::UnimplementedError("Paste"); }
 
  private:
   absl::Status DrawToolset();

src/app/editor/palette_editor.cc

@@ -14,7 +14,6 @@ namespace editor {
 absl::Status PaletteEditor::Update() {
   for (const auto &name : kPaletteCategoryNames) {
     if (ImGui::TreeNode(name.data())) {
-
       ImGui::SameLine();
       if (ImGui::SmallButton("button")) {
       }

src/app/editor/screen_editor.h

@@ -23,8 +23,8 @@ static int overworldCustomMosaicArray = 0x1301F0;
 
 class ScreenEditor {
  public:
-  void SetupROM(ROM &rom) { rom_ = rom; }
   ScreenEditor();
+  void SetupROM(ROM &rom) { rom_ = rom; }
   void Update();
 
  private:

src/app/rom.cc

@@ -576,6 +576,7 @@ absl::Status ROM::LoadFromFile(const absl::string_view& filename) {
     return absl::InternalError(
         absl::StrCat("Could not open ROM file: ", filename));
   }
+
   size_ = std::filesystem::file_size(filename);
   rom_data_.resize(size_);
   for (auto i = 0; i < size_; ++i) {
@@ -583,9 +584,12 @@ absl::Status ROM::LoadFromFile(const absl::string_view& filename) {
     file.read(&byte_to_read, sizeof(char));
     rom_data_[i] = byte_to_read;
   }
+
+  // copy ROM title
+  memcpy(title, rom_data_.data() + kTitleStringOffset, kTitleStringLength);
+
   file.close();
   is_loaded_ = true;
-  memcpy(title, rom_data_.data() + 32704, 20);  // copy ROM title
   return absl::OkStatus();
 }
 

src/app/rom.h

@@ -36,6 +36,8 @@ constexpr int kMaxLengthCompression = 1024;
 constexpr int kNintendoMode1 = 0;
 constexpr int kNintendoMode2 = 1;
 constexpr int kTile32Num = 4432;
+constexpr int kTitleStringOffset = 0x7FC0;
+constexpr int kTitleStringLength = 20;
 constexpr uchar kGraphicsBitmap[8] = {0x80, 0x40, 0x20, 0x10,
                                       0x08, 0x04, 0x02, 0x01};
 
@@ -114,9 +116,9 @@ class ROM {
 
  private:
   long size_ = 0;
-  std::string filename_;
   uchar title[21] = "ROM Not Loaded";
   bool is_loaded_ = false;
+  std::string filename_;
 
   Bytes rom_data_;
   std::shared_ptr<SDL_Renderer> renderer_;

src/app/yaze.cc

@@ -1,4 +1,6 @@
-#include "yaze.h"
+#if defined(_WIN32)
+#define main SDL_main
+#endif
 
 #include "absl/debugging/failure_signal_handler.h"
 #include "absl/debugging/symbolize.h"

src/app/zelda3/overworld.cc

@@ -26,7 +26,7 @@ absl::Status Overworld::Load(ROM &rom, uchar *ow_blockset) {
   auto size = tiles16.size();
   for (int i = 0; i < core::kNumOverworldMaps; ++i) {
     auto map_status =
-        overworld_maps_[i].BuildMapV2(size, game_state_, map_parent_);
+        overworld_maps_[i].BuildMap(size, game_state_, map_parent_);
     if (!map_status.ok()) {
       return map_status;
     }

src/app/zelda3/overworld_map.cc

@@ -102,56 +102,8 @@ void OverworldMap::LoadAreaInfo() {
   }
 }
 
-void OverworldMap::BuildMap(int count, int game_state, uchar* map_parent,
+absl::Status OverworldMap::BuildMap(int count, int game_state,
-                            uchar* ow_blockset, OWMapTiles& map_tiles) {
+                                    uchar* map_parent) {
-  if (large_map_) {
-    parent_ = map_parent[index_];
-    if (parent_ != index_ && !initialized_) {
-      if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
-        area_graphics_ =
-            rom_[core::overworldSpecialGFXGroup + (parent_ - 0x80)];
-        area_palette_ = rom_[core::overworldSpecialPALGroup + 1];
-      } else if (index_ == 0x88) {
-        area_graphics_ = 81;
-        area_palette_ = 0;
-      } else {
-        area_graphics_ = rom_[core::mapGfx + parent_];
-        area_palette_ = rom_[core::overworldMapPalette + parent_];
-      }
-
-      initialized_ = true;
-    }
-  }
-
-  if (!BuildTileset(game_state).ok()) {
-    std::cout << "BuildTileset failed" << std::endl;
-  }
-  BuildTiles16Gfx(count, ow_blockset);  // build on GFX.mapgfx16Ptr
-
-  // int world = 0;
-  // if (index_ < 64) {
-  //   map_tiles_ = map_tiles.light_world;
-  // } else if (index_ < 0x80 && index_ >= 0x40) {
-  //   map_tiles_ = map_tiles.dark_world;
-  //   world = 1;
-  // } else {
-  //   map_tiles_ = map_tiles.special_world;
-  //   world = 2;
-  // }
-
-  // int superY = ((index_ - (world * 64)) / 8);
-  // int superX = index_ - (world * 64) - (superY * 8);
-  // for (int y = 0; y < 32; y++) {
-  //   for (int x = 0; x < 32; x++) {
-  //     auto xt = x + (superX * 32);
-  //     auto yt = y + (superY * 32);
-  //     CopyTile8bpp16((x * 16), (y * 16), map_tiles_[xt][yt], ow_blockset);
-  //   }
-  // }
-}
-
-absl::Status OverworldMap::BuildMapV2(int count, int game_state,
-                                      uchar* map_parent) {
   if (large_map_) {
     parent_ = map_parent[index_];
     if (parent_ != index_ && !initialized_) {
@@ -176,12 +128,25 @@ absl::Status OverworldMap::BuildMapV2(int count, int game_state,
     return tileset_status;
   }
 
+  // int world = 0;
   // if (index_ < 64) {
-  //   world_ = 0;
+  //   map_tiles_ = map_tiles.light_world;
   // } else if (index_ < 0x80 && index_ >= 0x40) {
-  //   world_ = 1;
+  //   map_tiles_ = map_tiles.dark_world;
+  //   world = 1;
   // } else {
-  //   world_ = 2;
+  //   map_tiles_ = map_tiles.special_world;
+  //   world = 2;
+  // }
+
+  // int superY = ((index_ - (world * 64)) / 8);
+  // int superX = index_ - (world * 64) - (superY * 8);
+  // for (int y = 0; y < 32; y++) {
+  //   for (int x = 0; x < 32; x++) {
+  //     auto xt = x + (superX * 32);
+  //     auto yt = y + (superY * 32);
+  //     CopyTile8bpp16((x * 16), (y * 16), map_tiles_[xt][yt], ow_blockset);
+  //   }
   // }
 
   return absl::OkStatus();
@@ -248,40 +213,7 @@ absl::Status OverworldMap::BuildTileset(int game_state) {
   return absl::OkStatus();
 }
 
-void OverworldMap::BuildTiles16Gfx(int count, uchar* ow_blockset) {
+absl::Status OverworldMap::BuildTiles16Gfx(int count) {
-  auto gfx_tile16_data = ow_blockset;
-  auto gfx_tile8_data = nullptr;  // rom_.GetMasterGraphicsBin();
-
-  int offsets[] = {0, 8, 1024, 1032};
-  auto yy = 0;
-  auto xx = 0;
-
-  // number of tiles16 3748?
-  for (auto i = 0; i < count; i++) {
-    // 8x8 tile draw
-    // gfx8 = 4bpp so everyting is /2F
-    auto tiles = tiles16_[i];
-
-    for (auto tile = 0; tile < 4; tile++) {
-      gfx::TileInfo info = tiles16_[i].tiles_info[tile];
-      int offset = offsets[tile];
-
-      for (auto y = 0; y < 8; y++) {
-        for (auto x = 0; x < 4; x++) {
-          CopyTile(x, y, xx, yy, offset, info, gfx_tile16_data, gfx_tile8_data);
-        }
-      }
-    }
-
-    xx += 16;
-    if (xx >= 0x80) {
-      yy += 2048;
-      xx = 0;
-    }
-  }
-}
-
-absl::Status OverworldMap::BuildTiles16GfxV2(int count) {
   auto gfx_tile8_data = nullptr;  // rom_.GetMasterGraphicsBin();
 
   int offsets[] = {0, 8, 1024, 1032};
@@ -356,33 +288,6 @@ void OverworldMap::CopyTile8bpp16(int x, int y, int tile, uchar* ow_blockset) {
   }
 }
 
-// EXPERIMENTAL ----------------------------------------------------------------
-
-// map,current
-void OverworldMap::CopyTileToMap(int x, int y, int xx, int yy, int offset,
-                                 gfx::TileInfo tile, uchar* gfx16Pointer,
-                                 uchar* gfx8Pointer) {
-  int mx = x;
-  int my = y;
-  uchar r = 0;
-
-  if (tile.horizontal_mirror_ != 0) {
-    mx = 3 - x;
-    r = 1;
-  }
-
-  if (tile.vertical_mirror_ != 0) {
-    my = 7 - y;
-  }
-
-  int tx = ((tile.id_ / 16) * 512) + ((tile.id_ - ((tile.id_ / 16) * 16)) * 4);
-  auto index = xx + (yy * 512) + offset + (mx * 2) + (my * 512);
-  auto pixel = gfx8Pointer[tx + (y * 64) + x];
-
-  gfx16Pointer[index + r ^ 1] = (uchar)((pixel & 0x0F) + tile.palette_ * 16);
-  gfx16Pointer[index + r] = (uchar)(((pixel >> 4) & 0x0F) + tile.palette_ * 16);
-}
-
 }  // namespace zelda3
 }  // namespace app
 }  // namespace yaze

src/app/zelda3/overworld_map.h

@@ -24,10 +24,7 @@ class OverworldMap {
  public:
   OverworldMap(int index, ROM& rom, const std::vector<gfx::Tile16>& tiles16);
 
-  void BuildMap(int count, int game_state, uchar* map_parent,
+  absl::Status BuildMap(int count, int game_state, uchar* map_parent);
-                uchar* ow_blockset, OWMapTiles& map_tiles);
-
-  absl::Status BuildMapV2(int count, int game_state, uchar* map_parent);
 
   auto GetBitmap() { return bitmap_; }
   auto GetCurrentGraphicsSet() { return current_graphics_sheet_set; }
@@ -36,21 +33,15 @@ class OverworldMap {
 
  private:
   void LoadAreaInfo();
-  void BuildTiles16Gfx(int count, uchar* ow_blockset);
 
   absl::Status BuildTileset(int game_state);
-  absl::Status BuildTiles16GfxV2(int count);
+  absl::Status BuildTiles16Gfx(int count);
 
+  // TODO: Find the SDL_Surface way to do this.
   void CopyTile(int x, int y, int xx, int yy, int offset, gfx::TileInfo tile,
                 uchar* gfx16Pointer, uchar* gfx8Pointer);
-
   void CopyTile8bpp16(int x, int y, int tile, uchar* ow_blockset);
 
-  void CopyTileToMap(int x, int y, int xx, int yy, int offset,
-                     gfx::TileInfo tile, uchar* gfx16Pointer,
-                     uchar* gfx8Pointer);
-  void CopyTile8bpp16From8(int xP, int yP, int tileID, uchar* destbmpPtr);
-
   int parent_ = 0;
   int index_ = 0;
   int world_ = 0;

src/gui/canvas.cc

@@ -8,89 +8,6 @@
 namespace yaze {
 namespace gui {
 
-void Canvas::Update() {
-  ImVec2 canvas_p0 = ImGui::GetCursorScreenPos();
-  if (!custom_canvas_size_) canvas_sz_ = ImGui::GetContentRegionAvail();
-
-  auto canvas_p1 =
-      ImVec2(canvas_p0.x + canvas_sz_.x, canvas_p0.y + canvas_sz_.y);
-
-  // Draw border and background color
-  const ImGuiIO &io = ImGui::GetIO();
-  ImDrawList *draw_list = ImGui::GetWindowDrawList();
-  draw_list->AddRectFilled(canvas_p0, canvas_p1, IM_COL32(32, 32, 32, 255));
-  draw_list->AddRect(canvas_p0, canvas_p1, IM_COL32(255, 255, 255, 255));
-
-  // This will catch our interactions
-  ImGui::InvisibleButton(
-      "canvas", canvas_sz_,
-      ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonRight);
-  const bool is_hovered = ImGui::IsItemHovered();  // Hovered
-  const bool is_active = ImGui::IsItemActive();    // Held
-  const ImVec2 origin(canvas_p0.x + scrolling_.x,
-                      canvas_p0.y + scrolling_.y);  // Lock scrolled origin
-  const ImVec2 mouse_pos_in_canvas(io.MousePos.x - origin.x,
-                                   io.MousePos.y - origin.y);
-
-  // Add first and second point
-  if (is_hovered && !dragging_select_ &&
-      ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
-    points_.push_back(mouse_pos_in_canvas);
-    points_.push_back(mouse_pos_in_canvas);
-    dragging_select_ = true;
-  }
-  if (dragging_select_) {
-    points_.back() = mouse_pos_in_canvas;
-    if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) dragging_select_ = false;
-  }
-
-  // Pan (we use a zero mouse threshold when there's no context menu)
-  const float mouse_threshold_for_pan = enable_context_menu_ ? -1.0f : 0.0f;
-  if (is_active &&
-      ImGui::IsMouseDragging(ImGuiMouseButton_Right, mouse_threshold_for_pan)) {
-    scrolling_.x += io.MouseDelta.x;
-    scrolling_.y += io.MouseDelta.y;
-  }
-
-  // Context menu (under default mouse threshold)
-  ImVec2 drag_delta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Right);
-  if (enable_context_menu_ && drag_delta.x == 0.0f && drag_delta.y == 0.0f)
-    ImGui::OpenPopupOnItemClick("context", ImGuiPopupFlags_MouseButtonRight);
-  if (ImGui::BeginPopup("context")) {
-    if (dragging_select_) points_.resize(points_.size() - 2);
-    dragging_select_ = false;
-    if (ImGui::MenuItem("Remove all", nullptr, false, points_.Size > 0)) {
-      points_.clear();
-    }
-    ImGui::EndPopup();
-  }
-
-  // Draw grid + all lines in the canvas
-  draw_list->PushClipRect(canvas_p0, canvas_p1, true);
-  if (enable_grid_) {
-    const float GRID_STEP = 64.0f;
-    for (float x = fmodf(scrolling_.x, GRID_STEP); x < canvas_sz_.x;
-         x += GRID_STEP)
-      draw_list->AddLine(ImVec2(canvas_p0.x + x, canvas_p0.y),
-                         ImVec2(canvas_p0.x + x, canvas_p1.y),
-                         IM_COL32(200, 200, 200, 40));
-    for (float y = fmodf(scrolling_.y, GRID_STEP); y < canvas_sz_.y;
-         y += GRID_STEP)
-      draw_list->AddLine(ImVec2(canvas_p0.x, canvas_p0.y + y),
-                         ImVec2(canvas_p1.x, canvas_p0.y + y),
-                         IM_COL32(200, 200, 200, 40));
-  }
-
-  for (int n = 0; n < points_.Size; n += 2) {
-    draw_list->AddRect(
-        ImVec2(origin.x + points_[n].x, origin.y + points_[n].y),
-        ImVec2(origin.x + points_[n + 1].x, origin.y + points_[n + 1].y),
-        IM_COL32(255, 255, 255, 255), 1.0f);
-  }
-
-  draw_list->PopClipRect();
-}
-
 void Canvas::DrawBackground(ImVec2 canvas_size) {
   canvas_p0_ = ImGui::GetCursorScreenPos();
   if (!custom_canvas_size_) canvas_sz_ = ImGui::GetContentRegionAvail();

src/gui/canvas.h

@@ -15,8 +15,6 @@ class Canvas {
   Canvas(ImVec2 canvas_size)
       : custom_canvas_size_(true), canvas_sz_(canvas_size) {}
 
-  void Update();
-
   void DrawBackground(ImVec2 canvas_size = ImVec2(0, 0));
   void UpdateContext();
   void DrawGrid(float grid_step = 64.0f);

src/gui/input.cc

@@ -21,5 +21,5 @@ bool InputHexShort(const char* label, int* data) {
                             ImGuiInputTextFlags_CharsHexadecimal);
 }
 
-}  // namespace Gui
+}  // namespace gui
 }  // namespace yaze

src/gui/input.h

@@ -13,7 +13,7 @@ namespace gui {
 IMGUI_API bool InputHex(const char* label, int* data);
 IMGUI_API bool InputHexShort(const char* label, int* data);
 
-}  // namespace Gui
+}  // namespace gui
 }  // namespace yaze
 
 #endif

src/yaze.h

@@ -1,12 +0,0 @@
-#ifndef YAZE_H
-#define YAZE_H
-
-#if defined(_WIN32)
-#define main SDL_main
-#endif
-
-#include "absl/debugging/failure_signal_handler.h"
-#include "absl/debugging/symbolize.h"
-#include "app/core/controller.h"
-
-#endif /* YAZE_H */

test/CMakeLists.txt

@@ -14,37 +14,30 @@ add_executable(
   yaze_test
   yaze_test.cc
   rom_test.cc
+  asm_test.cc
   ../src/app/rom.cc
   ../src/app/asm/script.cc
   ../src/app/gfx/bitmap.cc
   ../src/app/gfx/snes_tile.cc
   ../src/app/gfx/snes_palette.cc
   ../src/app/core/common.cc
+  ../src/lib/asar/src/asar-dll-bindings/c/asardll.c
 )
 
 target_include_directories(
   yaze_test PUBLIC
-  ../src/lib/
   ../src/
+  ../src/lib/
+  ../src/lib/asar/src/asar-dll-bindings/c
   ${SDL_INCLUDE_DIRS}
 )
 
 target_link_libraries(
   yaze_test
-  absl::strings
-  absl::flags
-  absl::status
-  absl::statusor
-  absl::failure_signal_handler
-  absl::examine_stack
-  absl::stacktrace
-  absl::base
-  absl::config
-  absl::core_headers
-  absl::raw_logging_internal
   SDL2::SDL2
+  ${ABSL_TARGETS}
   ${OPENGL_LIBRARIES}
-  asar-static
+  ${CMAKE_DL_LIBS}
   gmock_main
   gmock
   gtest_main

test/asm_test.cc

@@ -0,0 +1,66 @@
+#include <asardll.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cstdint>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "app/asm/script.h"
+#include "app/core/constants.h"
+#include "app/rom.h"
+
+namespace yaze_test {
+namespace asm_test {
+
+using yaze::app::ROM;
+using yaze::app::snes_asm::Script;
+
+using ::testing::_;
+using ::testing::ElementsAreArray;
+using ::testing::Eq;
+using ::testing::Return;
+
+class MockScript : public Script {
+ public:
+  MOCK_METHOD(absl::Status, ApplyPatchToROM, (ROM & rom));
+  MOCK_METHOD(absl::Status, GenerateMosaicChangeAssembly,
+              (ROM & rom, char mosaic_tiles[yaze::app::core::kNumOverworldMaps],
+               int routine_offset, int hook_offset));
+};
+
+TEST(ASMTest, ApplyMosaicChangePatchOk) {
+  ROM rom;
+  MockScript script;
+  char mosaic_tiles[yaze::app::core::kNumOverworldMaps];
+
+  EXPECT_CALL(script, GenerateMosaicChangeAssembly(_, Eq(mosaic_tiles),
+                                                   Eq(0x1301D0 + 0x138000), 0))
+      .WillOnce(Return(absl::OkStatus()));
+
+  EXPECT_CALL(script, ApplyPatchToROM(_)).WillOnce(Return(absl::OkStatus()));
+
+  EXPECT_THAT(script.GenerateMosaicChangeAssembly(rom, mosaic_tiles,
+                                                  0x1301D0 + 0x138000, 0),
+              absl::OkStatus());
+  EXPECT_THAT(script.ApplyPatchToROM(rom), absl::OkStatus());
+}
+
+TEST(ASMTest, NoPatchLoadedError) {
+  ROM rom;
+  MockScript script;
+  EXPECT_CALL(script, ApplyPatchToROM(_))
+      .WillOnce(Return(absl::InvalidArgumentError("No patch loaded!")));
+
+  EXPECT_THAT(script.ApplyPatchToROM(rom),
+              absl::InvalidArgumentError("No patch loaded!"));
+}
+
+}  // namespace asm_test
+}  // namespace yaze_test