Add getInitialPosition() method to Monitor

Author: adazem009

include/scratchcpp/monitor.h

@@ -4,11 +4,14 @@
 
 #include <scratchcpp/entity.h>
 
+#include <vector>
+
 namespace libscratchcpp
 {
 
 class Block;
 class Sprite;
+class Rect;
 class MonitorPrivate;
 
 /*! \brief The Monitor class represents a stage monitor. */
@@ -60,6 +63,8 @@ class LIBSCRATCHCPP_EXPORT Monitor : public Entity
         bool discrete() const;
         void setDiscrete(bool discrete);
 
+        static Rect getInitialPosition(const std::vector<std::shared_ptr<Monitor>> &other, int monitorWidth, int monitorHeight);
+
     private:
         spimpl::unique_impl_ptr<MonitorPrivate> impl;
 };

src/scratch/monitor.cpp

@@ -3,11 +3,18 @@
 #include <scratchcpp/monitor.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/rect.h>
 
 #include "monitor_p.h"
+#include "engine/internal/randomgenerator.h"
 
 using namespace libscratchcpp;
 
+static const int PADDING = 5;
+static const int SCREEN_WIDTH = 400;
+static const int SCREEN_HEIGHT = 300;
+static const int SCREEN_EDGE_BUFFER = 40;
+
 /*! Constructs Monitor. */
 Monitor::Monitor(const std::string &id, const std::string &opcode) :
     Entity(id),
@@ -146,3 +153,16 @@ void Monitor::setDiscrete(bool discrete)
 {
     impl->discrete = discrete;
 }
+
+/*! Returns the initial position of a monitor. */
+Rect Monitor::getInitialPosition(const std::vector<std::shared_ptr<Monitor>> &other, int monitorWidth, int monitorHeight)
+{
+    // TODO: Implement this like Scratch has: https://github.com/scratchfoundation/scratch-gui/blob/010e27937ecff531f23bfcf3c711cd6e565cc7f9/src/reducers/monitor-layout.js#L161-L243
+    // Place the monitor randomly
+    if (!MonitorPrivate::rng)
+        MonitorPrivate::rng = RandomGenerator::instance().get();
+
+    const double randX = std::ceil(MonitorPrivate::rng->randintDouble(0, SCREEN_WIDTH / 2.0));
+    const double randY = std::ceil(MonitorPrivate::rng->randintDouble(0, SCREEN_HEIGHT - SCREEN_EDGE_BUFFER));
+    return Rect(randX, randY, randX + monitorWidth, randY + monitorHeight);
+}

src/scratch/monitor_p.cpp

@@ -6,6 +6,8 @@
 
 using namespace libscratchcpp;
 
+IRandomGenerator *MonitorPrivate::rng = nullptr;
+
 MonitorPrivate::MonitorPrivate(const std::string &opcode) :
     block(std::make_shared<Block>("", opcode))
 {

src/scratch/monitor_p.h

@@ -8,6 +8,7 @@ namespace libscratchcpp
 {
 
 class Block;
+class IRandomGenerator;
 
 struct MonitorPrivate
 {
@@ -24,6 +25,7 @@ struct MonitorPrivate
         double sliderMin = 0;
         double sliderMax = 0;
         bool discrete = false;
+        static IRandomGenerator *rng;
 };
 
 } // namespace libscratchcpp

test/scratch_classes/CMakeLists.txt

@@ -227,7 +227,9 @@ add_executable(
 target_link_libraries(
   monitor_test
   GTest::gtest_main
+  GTest::gmock_main
   scratchcpp
+  scratchcpp_mocks
 )
 
 gtest_discover_tests(monitor_test)

test/scratch_classes/monitor_test.cpp

@@ -1,11 +1,21 @@
 #include <scratchcpp/monitor.h>
 #include <scratchcpp/block.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/rect.h>
+#include <scratch/monitor_p.h>
+#include <randomgeneratormock.h>
 
 #include "../common.h"
 
 using namespace libscratchcpp;
 
+using ::testing::Return;
+
+static const int PADDING = 5;
+static const int SCREEN_WIDTH = 400;
+static const int SCREEN_HEIGHT = 300;
+static const int SCREEN_EDGE_BUFFER = 40;
+
 TEST(MonitorTest, Constructors)
 {
     Monitor monitor("abc", "test");
@@ -141,3 +151,37 @@ TEST(MonitorTest, Discrete)
     monitor.setDiscrete(false);
     ASSERT_FALSE(monitor.discrete());
 }
+
+TEST(MonitorTest, GetInitialPosition)
+{
+    std::vector<std::shared_ptr<Monitor>> monitors;
+    const int width = 100;
+    const int height = 200;
+
+    auto monitor1 = std::make_shared<Monitor>("", "");
+    monitor1->setWidth(PADDING);
+    monitor1->setHeight(height);
+    monitor1->setX(100);
+    monitor1->setY(0);
+    monitors.push_back(monitor1);
+
+    auto monitor2 = std::make_shared<Monitor>("", "");
+    monitor2->setWidth(width);
+    monitor2->setHeight(height + PADDING - 100);
+    monitor2->setX(0);
+    monitor2->setY(100);
+    monitors.push_back(monitor2);
+
+    RandomGeneratorMock rng;
+    MonitorPrivate::rng = &rng;
+
+    EXPECT_CALL(rng, randintDouble(0, SCREEN_WIDTH / 2.0)).WillOnce(Return(SCREEN_WIDTH / 4.5));
+    EXPECT_CALL(rng, randintDouble(0, SCREEN_HEIGHT - SCREEN_EDGE_BUFFER)).WillOnce(Return(SCREEN_HEIGHT - SCREEN_EDGE_BUFFER * 2.3));
+    Rect rect = Monitor::getInitialPosition(monitors, width, height);
+    ASSERT_EQ(rect.left(), std::ceil(SCREEN_WIDTH / 4.5));
+    ASSERT_EQ(rect.top(), std::ceil(SCREEN_HEIGHT - SCREEN_EDGE_BUFFER * 2.3));
+    ASSERT_EQ(rect.width(), width);
+    ASSERT_EQ(rect.height(), height);
+
+    MonitorPrivate::rng = nullptr;
+}