Added a basic collision detection algorithm (AABB)

Author: Martin Pelak

Begin.cpp

@@ -0,0 +1 @@
+#include "Beginning.h"

Begin.h

@@ -0,0 +1,92 @@
+#pragma once
+#include "GameComponents.h"
+#include "Slide.h"
+#include "Text.h"
+
+class Beginning : public Slide
+{
+private:
+    Text text = { "welcome", sprites.alphabet, Position(300, 30) };
+public:
+    void tick(const Time currentTime) override
+    {
+        text.tick(currentTime);
+    }
+};
+
+class End : public Slide
+{
+private:
+    Text text = { "end", sprites.alphabet, Position(300, 30) };
+public:
+    void tick(const Time currentTime) override
+    {
+        text.tick(currentTime);
+    }
+};
+
+class Level01 : public Slide
+{
+private:
+    Text text = { "space invaders 2d", sprites.alphabet, Position(80, 30) };
+public:
+    Level01()
+    {
+        auto& [player, bullets, enemies] = GameComponents::get().getAllComponents();
+
+        // 1 player
+        player.position = Position(400, 550);
+        player.size = Size(50, 50);
+
+        // 10 bullets
+        bullets.emplace_back_multiple(10, sprites.bullet, Size(10, 10));
+
+        // 50 enemies
+        enemies.emplace_back_multiple(50, sprites.enemy);
+    }
+
+    void tick(const Time currentTime) override
+    {
+        auto& [player, bullets, enemies] = GameComponents::get().getAllComponents();
+
+        player.tick(currentTime);
+
+        for (auto& bullet : bullets)
+        {
+            bullet.tick(currentTime);
+        }
+
+        for (auto& enemy : enemies)
+        {
+            enemy.tick(currentTime);
+        }
+
+        text.tick(currentTime);
+
+        // Detect colitions
+        for (auto& bullet : bullets)
+        {
+            if (bullet.visible)
+            {
+                const auto& [min01, max01] = bullet.getBoundingBox();
+
+                for (auto& enemy : enemies)
+                {
+                    if (enemy.visible)
+                    {
+                        const auto& [min02, max02] = enemy.getBoundingBox();
+
+                        // Colision detected
+                        if (max01.x > min02.x && min01.x < max02.x && max01.y > min01.y && min01.y < max02.y)
+                        {
+                            bullet.visible = false;
+                            enemy.visible = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+};
+

Beginning.cpp

@@ -1 +1,32 @@
 #include "Bullet.h"
+
+
+Bullet::Bullet(const Sprite& sprite, const Size size) noexcept : GameComponent(sprite)
+{
+    this->size = size;
+}
+
+void Bullet::setDirection(const Direction direction)
+{
+    this->direction = direction;
+    this->angle = direction.getAngle();
+}
+
+void Bullet::setPosition(const Position position)
+{
+    this->position = position;
+}
+
+void Bullet::tick(const Time currentTime)
+{
+    if (this->visible)
+    {
+        constexpr float speed = 5.f;
+        this->position -= this->direction * speed;
+
+        // Compute bounding box
+        this->recomputeBoundingBox();
+
+        this->draw();
+    }
+}

Beginning.h

@@ -1,30 +1,13 @@
 #pragma once
 #include "GameComponent.h"
+#include "Sprite.h"
 
 class Bullet : public GameComponent
 {
 public:
-    const Sprite& sprite;
-    Bullet(const Sprite& sprite, const Size size) noexcept : sprite(sprite)
-    {
-        this->size = size;
-    }
+    Bullet(const Sprite& sprite, const Size size) noexcept;
 
-    void draw()
-    {
-        DrawSprite(sprite, position.x, position.y, size.width, size.height, angle, 0xffffffff);
-    }
-
-    void setPosition(const Position position)
-    {
-        this->position = position;
-    }
-
-    void tick(const Time currentTime)
-    {
-        this->position.y -= 4;
-        this->angle += 0.1f;
-
-        this->draw();
-    }
+    void setDirection(const Direction direction);
+    void setPosition(const Position position);
+    void tick(const Time currentTime) override;
 };

Bullet.cpp

@@ -0,0 +1 @@
+#include "Container.h"

Bullet.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <deque>
+
+template <typename T>
+class Container : public std::deque<T>
+{
+	using iterator = typename std::deque<T>::iterator;
+	using size_type = typename std::deque<T>::size_type;
+	using parent = std::deque<T>;
+
+public:
+	Container() = default;
+
+	iterator begin() noexcept
+	{
+		return parent::begin();
+	}
+
+	iterator end() noexcept
+	{
+		return parent::end();
+	}
+
+	void next(iterator& iterator)
+	{
+		iterator = std::next(iterator);
+		if (iterator == parent::end())
+		{
+			iterator = parent::begin();
+		}
+	}
+
+	template<class... Args>
+	T& emplace_back(Args&&... args)
+	{
+		return parent::emplace_back(std::forward<Args>(args)...);
+	}
+
+	template<class... Args>
+	void emplace_back_multiple(const size_type count, Args&&... args)
+	{
+		for (size_type i = 0; i < count; ++i)
+		{
+			parent::emplace_back(std::forward<Args>(args)...);
+		}
+	}
+};

Container.cpp

@@ -1,4 +1,60 @@
 #include "Enemy.h"
 
+int Enemy::s_seed = 0;
 
-int Enemy::s_seed = 0;
+
+Enemy::Enemy(const Sprite& sprite) noexcept : GameComponent(sprite)
+{
+	this->init();
+}
+
+Enemy::Enemy(const Enemy& copy) noexcept : GameComponent(copy.sprite)
+{
+	this->init();
+}
+
+
+void Enemy::init() noexcept
+{
+	this->seed = Enemy::s_seed;
+	this->basePosition = { (seed % 10) * 60 + 120.f, (seed / 10) * 60 + 70.f };
+	this->size = { (10 + ((seed) % 17)), (10 + ((seed) % 17)) };
+
+	++Enemy::s_seed;
+}
+
+void Enemy::tick(const Time time)
+{
+	if (!this->visible)
+	{
+		return;
+	}
+
+	int dx = 0, dy = 0;
+	const int n1 = time + seed * seed + seed * seed * seed;
+	const int n2 = time + seed + seed * seed + seed * seed * seed * 3;
+	constexpr float twoPi = 2 * std::numbers::pi;
+	if (((n1 >> 6) & 0x7) == 0x7)
+	{
+		const int radius = 20 + ((seed * seed) % 9);
+		const float angle = (n1 & 0x7f) / 64.0f * twoPi;
+
+		dx = radius * (1 - cos(angle));
+		dy = radius * sin(angle);
+	}
+
+	if (((n2 >> 8) & 0xf) == 0xf)
+	{
+		const int distance = 150 + ((seed * seed) % 9);
+		const float angle = (n2 & 0xff) / 256.0f * twoPi;
+
+		dy += distance * (1 - cos(angle));
+	}
+
+	this->position = this->basePosition + Position(dx, dy);
+
+	// Compute bounding box
+	this->recomputeBoundingBox();
+
+	this->draw();
+}

Container.h

@@ -1,57 +1,20 @@
-#pragma once
-#include "GameComponent.h"
+#pragma once
+
 #include <numbers>
 
+#include "GameComponent.h"
+
 class Enemy : public GameComponent
 {
 private:
 	static int s_seed;
 	Seed seed;
 
-	void init() noexcept
-	{
-		this->seed = Enemy::s_seed;
-		this->basePosition = { (seed % 10) * 60 + 120, (seed / 10) * 60 + 70 };
-		this->size = { (10 + ((seed) % 17)), (10 + ((seed) % 17)) };
-
-		++Enemy::s_seed;
-	}
+	void init() noexcept;
 
 public:
-	const Sprite& sprite;
-	Enemy(const Sprite& sprite) noexcept : sprite(sprite)
-	{
-		this->init();
-	}
-
-	Enemy(const Enemy& copy) noexcept : sprite(copy.sprite)
-	{
-		this->init();
-	}
-
-	void draw()
-	{
-		DrawSprite(sprite, position.x, position.y, size.width, size.height, angle, 0xffffffff);
-	}
-
-	void tick(const Time time)
-	{
-		int dx = 0, dy = 0;
-		const int n1 = time + seed * seed + seed * seed * seed;
-		const int n2 = time + seed + seed * seed + seed * seed * seed * 3;
-		if (((n1 >> 6) & 0x7) == 0x7)
-		{
-			dx = (1 - cos((n1 & 0x7f) / 64.0f * 2.f * std::numbers::pi)) * (20 + ((seed * seed) % 9));
-			dy = (sin((n1 & 0x7f) / 64.0f * 2.f * std::numbers::pi)) * (20 + ((seed * seed) % 9));
-		}
-
-		if (((n2 >> 8) & 0xf) == 0xf)
-		{
-			dy += (1 - cos((n2 & 0xff) / 256.0f * 2.f * 3.141592)) * (150 + ((seed * seed) % 9));
-		}
-
-		this->position = this->basePosition + Position(dx, dy);
+	Enemy(const Sprite& sprite) noexcept;
+	Enemy(const Enemy& copy) noexcept;
 
-		this->draw();
-	}
+	void tick(const Time time);
 };

Drawable.cpp

@@ -1 +1,11 @@
 #include "GameComponent.h"
+
+GameComponent::GameComponent(const Sprite& sprite) : sprite(sprite)
+{
+
+}
+
+void GameComponent::draw()
+{
+    DrawSprite(sprite, position.x, position.y, size.width, size.height, angle, 0xffffffff);
+}