Merge branch 'master' into window-dimensions-constant

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(
@@ -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/controller.cc

@@ -156,7 +156,7 @@ absl::Status Controller::CreateWindow() {
                          SDL_WINDOWPOS_UNDEFINED,      // initial y position
                          kScreenWidth,                 // width, 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("Redo", "Ctrl+Y") {}
+    MENU_ITEM2("Undo", "Ctrl+Z") { status_ = overworld_editor_.Undo(); }
+    MENU_ITEM2("Redo", "Ctrl+Y") { status_ = overworld_editor_.Redo(); }
     ImGui::Separator();
-    MENU_ITEM2("Cut", "Ctrl+X") {}
-    MENU_ITEM2("Copy", "Ctrl+C") {}
-    MENU_ITEM2("Paste", "Ctrl+V") {}
+    MENU_ITEM2("Cut", "Ctrl+X") { status_ = overworld_editor_.Cut(); }
+    MENU_ITEM2("Copy", "Ctrl+C") { status_ = overworld_editor_.Copy(); }
+    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.h

@@ -116,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/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,55 +102,8 @@ void OverworldMap::LoadAreaInfo() {
   }
 }
 
-void OverworldMap::BuildMap(int count, int game_state, uchar* map_parent,
-                            uchar* ow_blockset, OWMapTiles& map_tiles) {
-  if (large_map_) {
-    parent_ = map_parent[index_];
-    if (parent_ != index_ && !initialized_) {
-      if (index_ >= 0x80 && index_ <= 0x8A && index_ != 0x88) {
-        area_graphics_ = rom_[core::overworldSpecialGFXGroup + (parent_ - 128)];
-        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_ < 128 && index_ >= 64) {
-  //   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) {
+absl::Status OverworldMap::BuildMap(int count, int game_state,
+                                    uchar* map_parent) {
   if (large_map_) {
     parent_ = map_parent[index_];
     if (parent_ != index_ && !initialized_) {
@@ -174,12 +127,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_ < 128 && index_ >= 64) {
-  //   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();
@@ -246,40 +212,7 @@ absl::Status OverworldMap::BuildTileset(int game_state) {
   return absl::OkStatus();
 }
 
-void OverworldMap::BuildTiles16Gfx(int count, uchar* ow_blockset) {
-  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 >= 128) {
-      yy += 2048;
-      xx = 0;
-    }
-  }
-}
-
-absl::Status OverworldMap::BuildTiles16GfxV2(int count) {
+absl::Status OverworldMap::BuildTiles16Gfx(int count) {
   auto gfx_tile8_data = nullptr;  // rom_.GetMasterGraphicsBin();
 
   int offsets[] = {0, 8, 1024, 1032};
@@ -354,33 +287,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,
-                uchar* ow_blockset, OWMapTiles& map_tiles);
-
-  absl::Status BuildMapV2(int count, int game_state, uchar* map_parent);
+  absl::Status BuildMap(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

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