canvas_coordinate_sync_test.cc

Go to the documentation of this file.

#include "app/gui/canvas.h"
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include "testing.h"
 
namespace yaze {
namespace test {
 
using ::testing::Eq;
using ::testing::FloatEq;
using ::testing::Ne;
 
class CanvasCoordinateSyncTest : public ::testing::Test {
 protected:
  void SetUp() override {
    // Create a test canvas with known dimensions (4096x4096 for overworld)
    canvas_ = std::make_unique<gui::Canvas>("OverworldCanvas", ImVec2(4096, 4096),
                                             gui::CanvasGridSize::k16x16);
    canvas_->set_global_scale(1.0f);
  }
 
  std::unique_ptr<gui::Canvas> canvas_;
};
 
// ============================================================================
// Hover Position Tests (hover_mouse_pos)
// ============================================================================
 
TEST_F(CanvasCoordinateSyncTest, HoverMousePos_InitialState) {
  // Hover position should start at (0,0) or invalid state
  auto hover_pos = canvas_->hover_mouse_pos();
 
  // Initial state may be (0,0) - this is valid
  EXPECT_GE(hover_pos.x, 0.0f);
  EXPECT_GE(hover_pos.y, 0.0f);
}
 
TEST_F(CanvasCoordinateSyncTest, HoverMousePos_IndependentFromDrawnPos) {
  // Hover position and drawn tile position are independent
  // hover_mouse_pos() tracks continuous mouse movement
  // drawn_tile_position() only updates during painting
 
  auto hover_pos = canvas_->hover_mouse_pos();
  auto drawn_pos = canvas_->drawn_tile_position();
 
  // These may differ - hover tracks all movement, drawn only tracks paint
  // We just verify both are valid (non-negative or expected sentinel values)
  EXPECT_TRUE(hover_pos.x >= 0.0f || hover_pos.x == -1.0f);
  EXPECT_TRUE(drawn_pos.x >= 0.0f || drawn_pos.x == -1.0f);
}
 
// ============================================================================
// Coordinate Space Tests
// ============================================================================
 
TEST_F(CanvasCoordinateSyncTest, CoordinateSpace_WorldNotScreen) {
  // REGRESSION TEST: Verify hover_mouse_pos() returns world coordinates
  // not screen coordinates. The bug was using ImGui::GetIO().MousePos
  // which is in screen space and doesn't account for scrolling/canvas offset.
 
  // Simulate scrolling the canvas
  canvas_->set_scrolling(ImVec2(100, 100));
 
  // The hover position should be in canvas/world space, not affected by
  // the canvas's screen position. This is tested by ensuring the method
  // exists and returns a coordinate that could be used for map calculations.
  auto hover_pos = canvas_->hover_mouse_pos();
 
  // Valid world coordinates should be usable for map index calculations
  // For a 512x512 map size (kOverworldMapSize = 512):
  // map_x = hover_pos.x / 512
  // map_y = hover_pos.y / 512
 
  int map_x = static_cast<int>(hover_pos.x) / 512;
  int map_y = static_cast<int>(hover_pos.y) / 512;
 
  // Map indices should be within valid range for 8x8 overworld grid
  EXPECT_GE(map_x, 0);
  EXPECT_GE(map_y, 0);
  EXPECT_LT(map_x, 64);  // 8x8 grid = 64 maps max
  EXPECT_LT(map_y, 64);
}
 
TEST_F(CanvasCoordinateSyncTest, MapCalculation_SmallMaps) {
  // Test map index calculation for standard 512x512 maps
  const int kOverworldMapSize = 512;
 
  // Simulate hover at different world positions
  std::vector<ImVec2> test_positions = {
    ImVec2(0, 0),       // Map (0, 0)
    ImVec2(512, 0),     // Map (1, 0)
    ImVec2(0, 512),     // Map (0, 1)
    ImVec2(512, 512),   // Map (1, 1)
    ImVec2(1536, 1024), // Map (3, 2)
  };
 
  std::vector<std::pair<int, int>> expected_maps = {
    {0, 0}, {1, 0}, {0, 1}, {1, 1}, {3, 2}
  };
 
  for (size_t i = 0; i < test_positions.size(); ++i) {
    ImVec2 pos = test_positions[i];
    int map_x = pos.x / kOverworldMapSize;
    int map_y = pos.y / kOverworldMapSize;
 
    EXPECT_EQ(map_x, expected_maps[i].first);
    EXPECT_EQ(map_y, expected_maps[i].second);
  }
}
 
TEST_F(CanvasCoordinateSyncTest, MapCalculation_LargeMaps) {
  // Test map index calculation for ZSCustomOverworld v3 large maps (1024x1024)
  const int kLargeMapSize = 1024;
 
  // Large maps should span multiple standard map coordinates
  std::vector<ImVec2> test_positions = {
    ImVec2(0, 0),         // Large map (0, 0)
    ImVec2(1024, 0),      // Large map (1, 0)
    ImVec2(0, 1024),      // Large map (0, 1)
    ImVec2(2048, 2048),   // Large map (2, 2)
  };
 
  std::vector<std::pair<int, int>> expected_large_maps = {
    {0, 0}, {1, 0}, {0, 1}, {2, 2}
  };
 
  for (size_t i = 0; i < test_positions.size(); ++i) {
    ImVec2 pos = test_positions[i];
    int map_x = pos.x / kLargeMapSize;
    int map_y = pos.y / kLargeMapSize;
 
    EXPECT_EQ(map_x, expected_large_maps[i].first);
    EXPECT_EQ(map_y, expected_large_maps[i].second);
  }
}
 
// ============================================================================
// Scale Invariance Tests
// ============================================================================
 
TEST_F(CanvasCoordinateSyncTest, HoverPosition_ScaleInvariant) {
  // REGRESSION TEST: Hover position should be in world space regardless of scale
  // The bug was scale-dependent because it used screen coordinates
 
  auto test_hover_at_scale = [&](float scale) {
    canvas_->set_global_scale(scale);
    auto hover_pos = canvas_->hover_mouse_pos();
 
    // Hover position should be in world coordinates, not affected by scale
    // World coordinates are always in the range [0, canvas_size)
    EXPECT_GE(hover_pos.x, 0.0f);
    EXPECT_GE(hover_pos.y, 0.0f);
    EXPECT_LE(hover_pos.x, 4096.0f);
    EXPECT_LE(hover_pos.y, 4096.0f);
  };
 
  test_hover_at_scale(0.25f);
  test_hover_at_scale(0.5f);
  test_hover_at_scale(1.0f);
  test_hover_at_scale(2.0f);
  test_hover_at_scale(4.0f);
}
 
// ============================================================================
// Overworld Editor Integration Tests
// ============================================================================
 
TEST_F(CanvasCoordinateSyncTest, OverworldMapHighlight_UsesHoverNotDrawn) {
  // CRITICAL REGRESSION TEST
  // This verifies the fix for overworld_editor.cc:1041
  // CheckForCurrentMap() must use hover_mouse_pos() not ImGui::GetIO().MousePos
 
  // The pattern used in DrawOverworldEdits (line 664) for painting:
  auto drawn_pos = canvas_->drawn_tile_position();
 
  // The pattern that SHOULD be used in CheckForCurrentMap (line 1041) for highlighting:
  auto hover_pos = canvas_->hover_mouse_pos();
 
  // These are different methods for different purposes:
  // - drawn_tile_position(): Only updates during active painting (mouse drag)
  // - hover_mouse_pos(): Updates continuously during hover
 
  // Verify both methods exist and return valid (or sentinel) values
  EXPECT_TRUE(drawn_pos.x >= 0.0f || drawn_pos.x == -1.0f);
  EXPECT_TRUE(hover_pos.x >= 0.0f || hover_pos.x == -1.0f);
}
 
TEST_F(CanvasCoordinateSyncTest, OverworldMapIndex_From8x8Grid) {
  // Simulate the exact calculation from OverworldEditor::CheckForCurrentMap
  const int kOverworldMapSize = 512;
 
  // Test all three worlds (Light, Dark, Special)
  struct TestCase {
    ImVec2 hover_pos;
    int current_world;  // 0=Light, 1=Dark, 2=Special
    int expected_map_index;
  };
 
  std::vector<TestCase> test_cases = {
    // Light World (0x00 - 0x3F)
    {ImVec2(0, 0), 0, 0},              // Map 0 (Light World)
    {ImVec2(512, 0), 0, 1},            // Map 1
    {ImVec2(1024, 512), 0, 10},        // Map 10 = 2 + 1*8
 
    // Dark World (0x40 - 0x7F)
    {ImVec2(0, 0), 1, 0x40},           // Map 0x40 (Dark World)
    {ImVec2(512, 0), 1, 0x41},         // Map 0x41
    {ImVec2(1024, 512), 1, 0x4A},      // Map 0x4A = 0x40 + 10
 
    // Special World (0x80+)
    {ImVec2(0, 0), 2, 0x80},           // Map 0x80 (Special World)
    {ImVec2(512, 512), 2, 0x89},       // Map 0x89 = 0x80 + 9
  };
 
  for (const auto& tc : test_cases) {
    int map_x = tc.hover_pos.x / kOverworldMapSize;
    int map_y = tc.hover_pos.y / kOverworldMapSize;
    int hovered_map = map_x + map_y * 8;
 
    if (tc.current_world == 1) {
      hovered_map += 0x40;
    } else if (tc.current_world == 2) {
      hovered_map += 0x80;
    }
 
    EXPECT_EQ(hovered_map, tc.expected_map_index)
        << "Failed for world " << tc.current_world
        << " at position (" << tc.hover_pos.x << ", " << tc.hover_pos.y << ")";
  }
}
 
// ============================================================================
// Boundary Condition Tests
// ============================================================================
 
TEST_F(CanvasCoordinateSyncTest, MapBoundaries_512x512) {
  // Test coordinates exactly at map boundaries
  const int kOverworldMapSize = 512;
 
  // Boundary coordinates (edges of maps)
  std::vector<ImVec2> boundary_positions = {
    ImVec2(511, 0),      // Right edge of map 0
    ImVec2(512, 0),      // Left edge of map 1
    ImVec2(0, 511),      // Bottom edge of map 0
    ImVec2(0, 512),      // Top edge of map 8
    ImVec2(511, 511),    // Corner of map 0
    ImVec2(512, 512),    // Corner of map 9
  };
 
  for (const auto& pos : boundary_positions) {
    int map_x = pos.x / kOverworldMapSize;
    int map_y = pos.y / kOverworldMapSize;
    int map_index = map_x + map_y * 8;
 
    // Verify map indices are within valid range
    EXPECT_GE(map_index, 0);
    EXPECT_LT(map_index, 64);  // 8x8 grid = 64 maps
  }
}
 
TEST_F(CanvasCoordinateSyncTest, MapBoundaries_1024x1024) {
  // Test large map boundaries (ZSCustomOverworld v3)
  const int kLargeMapSize = 1024;
 
  std::vector<ImVec2> boundary_positions = {
    ImVec2(1023, 0),     // Right edge of large map 0
    ImVec2(1024, 0),     // Left edge of large map 1
    ImVec2(0, 1023),     // Bottom edge of large map 0
    ImVec2(0, 1024),     // Top edge of large map 4 (0,1 in 4x4 grid)
  };
 
  for (const auto& pos : boundary_positions) {
    int map_x = pos.x / kLargeMapSize;
    int map_y = pos.y / kLargeMapSize;
    int map_index = map_x + map_y * 4;  // 4x4 grid for large maps
 
    // Verify map indices are within valid range for large maps
    EXPECT_GE(map_index, 0);
    EXPECT_LT(map_index, 16);  // 4x4 grid = 16 large maps
  }
}
 
}  // namespace test
}  // namespace yaze