make customizable base classes

CMakeLists.txt

@@ -27,7 +27,9 @@ set(GAME_OBJECTS
         GameObjects/BasicObjects/Entities/Towers/TowerSlots/test_tower_slot.cpp
         GameObjects/BasicObjects/Entities/Towers/test_tower.cpp
         GameObjects/BasicObjects/Entities/Projectiles/autoguided_projectile.cpp
-        GameObjects/BasicObjects/Entities/Projectiles/test_projectile.cpp)
+        GameObjects/BasicObjects/Entities/Projectiles/test_projectile.cpp
+        GameObjects/BasicObjects/Interface/graphics_item.cpp
+        GameObjects/BasicObjects/Entities/Projectiles/projectile.cpp)
 
 set(UTILITIES
         Utilities/damage.cpp
@@ -45,6 +47,8 @@ add_executable(Game
         ${UTILITIES}
         main.cpp
         main_window.cpp
-        Controller/controller.cpp game_view.cpp game_view.h constants.cpp)
+        Controller/controller.cpp
+        game_view.cpp
+        constants.cpp game_scene.cpp game_scene.h)
 
 target_link_libraries(Game Qt::Core Qt::Gui Qt::Widgets)

Controller/controller.cpp

@@ -12,7 +12,7 @@
 Controller* Controller::instance;
 
 Controller::Controller() :
-  scene_(new QGraphicsScene(kSceneRect)),
+  scene_(new GameScene(kSceneRect)),
   view_(new GameView(scene_)),
   tick_timer_(new QTimer(this)) {
   SetupScene();
@@ -23,6 +23,10 @@ GameView* Controller::GetView() const {
   return view_;
 }
 
+GameScene* Controller::GetScene() const {
+  return scene_;
+}
+
 void Controller::SetupScene() {
   {  // temporary code
     QPushButton* close_button = new QPushButton();

Controller/controller.h

@@ -6,13 +6,15 @@
 
 #include "GameObjects/BasicObjects/Interface/entity.h"
 #include "game_view.h"
+#include "game_scene.h"
 
 class Controller : public QObject {
   Q_OBJECT
  public:
   static Controller* Instance();
 
   [[nodiscard]] GameView* GetView() const;
+  [[nodiscard]] GameScene* GetScene() const;
 
  public slots:
   void TickAllTickables();
@@ -25,7 +27,7 @@ class Controller : public QObject {
   void SetupScene();
   void LaunchTickTimer();
 
-  QGraphicsScene* scene_;
+  GameScene* scene_;
   GameView* view_;
   QTimer* tick_timer_;
 };

GameObjects/BasicObjects/Entities/Mobs/Basis/mob.h

@@ -1,17 +1,17 @@
 #pragma once
 
+#include <QPixmap>
+
 #include "GameObjects/BasicObjects/Interface/entity.h"
 #include "Utilities/vector_f.h"
 #include "Utilities/route.h"
 
-#include <QPixmap>
-
 class Mob : public Entity {
  public:
   Mob(const VectorF& coordinates,
       QPixmap* pixmap,
       int health,
-      qreal speed = 20);
+      qreal speed = 0);
   [[nodiscard]] qreal GetSpeed() const;
   void SetSpeed(qreal speed);
 

GameObjects/BasicObjects/Entities/Projectiles/autoguided_projectile.cpp

@@ -8,7 +8,7 @@ AutoguidedProjectile::AutoguidedProjectile(
     Entity* target,
     qreal speed,
     Damage damage)
-    : Entity(coordinates, pixmap),
+    : Projectile(coordinates, pixmap),
     target_(target), speed_(speed), damage_(damage) {}
 
 void AutoguidedProjectile::Tick(Time delta) {

GameObjects/BasicObjects/Entities/Projectiles/autoguided_projectile.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "GameObjects/BasicObjects/Interface/entity.h"
+#include "GameObjects/BasicObjects/Entities/Projectiles/projectile.h"
 
-class AutoguidedProjectile : public Entity {
+class AutoguidedProjectile : public Projectile {
  public:
   AutoguidedProjectile(const VectorF& coordinates,
                        QPixmap* pixmap,

GameObjects/BasicObjects/Entities/Projectiles/projectile.cpp

@@ -0,0 +1,4 @@
+#include "projectile.h"
+
+Projectile::Projectile(const VectorF& coordinates, QPixmap* pixmap)
+    : Entity(coordinates, pixmap) {}

GameObjects/BasicObjects/Entities/Projectiles/projectile.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "GameObjects/BasicObjects/Interface/entity.h"
+
+class Projectile : public Entity {
+ public:
+  Projectile(const VectorF& coordinates, QPixmap* pixmap);
+};
+
+

GameObjects/BasicObjects/Interface/entity.cpp

@@ -4,7 +4,7 @@ Entity::Entity(
     const VectorF& coordinates,
     QPixmap* pixmap,
     int health)
-    : Damageable(health), QGraphicsItem(),
+    : Damageable(health), GraphicsItem(),
     pixmap(pixmap) {
   setPos(coordinates);
   setFlag(ItemSendsGeometryChanges);
@@ -23,7 +23,3 @@ void Entity::paint(QPainter* painter,
   painter->drawPixmap(Entity::boundingRect().toRect(), *pixmap);
   painter->restore();
 }
-
-void Entity::MoveBy(const VectorF& delta) {
-  setPos(pos() + delta);
-}

GameObjects/BasicObjects/Interface/entity.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <QGraphicsItem>
 #include <QPainter>
 #include <QGraphicsSceneMouseEvent>
 #include <QKeyEvent>
@@ -11,12 +10,13 @@
 #include "tickable.h"
 #include "damageable.h"
 #include "Utilities/vector_f.h"
+#include "GameObjects/BasicObjects/Interface/graphics_item.h"
 
 class Entity
     : public QObject,
       public Tickable,
       public Damageable,
-      public QGraphicsItem {
+      public GraphicsItem {
   Q_OBJECT
  public:
   Entity(
@@ -29,8 +29,6 @@ class Entity
              const QStyleOptionGraphicsItem* option,
              QWidget* widget) override;
 
-  void MoveBy(const VectorF& delta);
-
  protected:
   QPixmap* pixmap;
 };

GameObjects/BasicObjects/Interface/graphics_item.cpp

@@ -0,0 +1,17 @@
+#include "graphics_item.h"
+
+GraphicsItem::GraphicsItem(QGraphicsItem* parent) : QGraphicsItem(parent) {}
+
+GameScene* GraphicsItem::scene() {
+  auto result = dynamic_cast<GameScene*>(QGraphicsItem::scene());
+  assert(result != nullptr);
+  return result;
+}
+
+GameView* GraphicsItem::view() {
+  return scene()->view();
+}
+
+void GraphicsItem::MoveBy(const VectorF& delta) {
+  setPos(pos() + delta);
+}

GameObjects/BasicObjects/Interface/graphics_item.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "QGraphicsItem"
+
+#include "Utilities/vector_f.h"
+#include "game_scene.h"
+#include "game_view.h"
+
+class GraphicsItem : public QGraphicsItem {
+ public:
+  explicit GraphicsItem(QGraphicsItem* parent = nullptr);
+
+  GameScene* scene();
+  GameView* view();
+
+  void MoveBy(const VectorF& delta);
+};
+
+

game_scene.cpp

@@ -0,0 +1,94 @@
+#include "game_scene.h"
+
+#include "GameObjects/BasicObjects/Interface/graphics_item.h"
+#include "game_view.h"
+#include "GameObjects/BasicObjects/Entities/Mobs/Basis/mob.h"
+#include "GameObjects/BasicObjects/Entities/Towers/tower.h"
+#include "GameObjects/BasicObjects/Entities/Towers/TowerSlots/tower_slot.h"
+#include "GameObjects/BasicObjects/Entities/Projectiles/projectile.h"
+
+GameScene::GameScene(const QRectF& scene_rect, QObject* parent)
+    : QGraphicsScene(scene_rect, parent),
+    mobs_(std::set<Mob*>()),
+    towers_(std::set<Tower*>()),
+    tower_slots_(std::set<TowerSlot*>()),
+    projectiles_(std::set<Projectile*>()) {}
+
+GameView* GameScene::view() {
+  auto result = dynamic_cast<GameView*>(QGraphicsScene::views().at(0));
+  assert(result != nullptr);
+  return result;
+}
+
+void GameScene::removeItem(GraphicsItem* item) {
+  auto mob = dynamic_cast<Mob*>(item);
+  if (mob != nullptr) {
+    mobs_.erase(mob);
+  }
+
+  auto tower = dynamic_cast<Tower*>(item);
+  if (tower != nullptr) {
+    towers_.erase(tower);
+  }
+
+  auto tower_slot = dynamic_cast<TowerSlot*>(item);
+  if (tower_slot != nullptr) {
+    tower_slots_.erase(tower_slot);
+  }
+
+  auto projectile = dynamic_cast<Projectile*>(item);
+  if (projectile != nullptr) {
+    projectiles_.erase(projectile);
+  }
+
+  QGraphicsScene::removeItem(item);
+}
+
+void GameScene::clear() {
+  mobs_.clear();
+  towers_.clear();
+  tower_slots_.clear();
+  projectiles_.clear();
+
+  QGraphicsScene::clear();
+}
+
+void GameScene::addItem(GraphicsItem* item) {
+  auto mob = dynamic_cast<Mob*>(item);
+  if (mob != nullptr) {
+    mobs_.erase(mob);
+  }
+
+  auto tower = dynamic_cast<Tower*>(item);
+  if (tower != nullptr) {
+    towers_.erase(tower);
+  }
+
+  auto tower_slot = dynamic_cast<TowerSlot*>(item);
+  if (tower_slot != nullptr) {
+    tower_slots_.erase(tower_slot);
+  }
+
+  auto projectile = dynamic_cast<Projectile*>(item);
+  if (projectile != nullptr) {
+    projectiles_.erase(projectile);
+  }
+
+  QGraphicsScene::addItem(item);
+}
+
+const std::set<Mob*>& GameScene::Mobs() const {
+  return mobs_;
+}
+
+const std::set<Tower*>& GameScene::Towers() const {
+  return towers_;
+}
+
+const std::set<TowerSlot*>& GameScene::TowerSlots() const {
+  return tower_slots_;
+}
+
+const std::set<Projectile*>& GameScene::Projectiles() const {
+  return projectiles_;
+}

game_scene.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <set>
+
+#include <QGraphicsScene>
+#include <QList>
+
+class GraphicsItem;
+class GameView;
+class Mob;
+class Tower;
+class TowerSlot;
+class Projectile;
+
+class GameScene : public QGraphicsScene {
+ public:
+  explicit GameScene(const QRectF& scene_rect, QObject* parent = nullptr);
+
+  GameView* view();
+
+  void removeItem(GraphicsItem* item);
+  void clear();
+  void addItem(GraphicsItem* item);
+
+  [[nodiscard]] const std::set<Mob*>& Mobs() const;
+  [[nodiscard]] const std::set<Tower*>& Towers() const;
+  [[nodiscard]] const std::set<TowerSlot*>& TowerSlots() const;
+  [[nodiscard]] const std::set<Projectile*>& Projectiles() const;
+
+ private:
+  std::set<Mob*> mobs_;
+  std::set<Tower*> towers_;
+  std::set<TowerSlot*> tower_slots_;
+  std::set<Projectile*> projectiles_;
+};

game_view.cpp

@@ -18,3 +18,9 @@ GameView::GameView(QGraphicsScene* scene, QWidget* parent)
 
   centerOn(0, 0);
 }
+
+GameScene* GameView::scene() {
+  auto result = dynamic_cast<GameScene*>(QGraphicsView::scene());
+  assert(result != nullptr);
+  return result;
+}

game_view.h

@@ -2,7 +2,11 @@
 
 #include <QGraphicsView>
 
+#include "game_scene.h"
+
 class GameView : public QGraphicsView {
  public:
   explicit GameView(QGraphicsScene* scene, QWidget* parent = nullptr);
+
+  GameScene* scene();
 };