added shooting ability to players

Author: RiverHillbug

Data/galaga_player_bullet.png

@@ -0,0 +1,28 @@
+#include "Bullet.h"
+#include "GameObject.h"
+#include "Sprite.h"
+#include "SpriteColliderComponent.h"
+
+Bullet::Bullet(Fluffy::GameObject* pOwner, int ownerIndex, const glm::vec2& position, const glm::vec2& speed)
+	: Component(pOwner)
+	, m_OwnerIndex{ ownerIndex }
+	, m_Speed{ speed }
+{
+	Fluffy::Sprite* pSprite{ m_pOwner->AddComponent<Fluffy::Sprite>(ownerIndex == 0 ? "enemyBullet.png" : "galaga_player_bullet.png") };
+	m_pOwner->AddComponent<SpriteColliderComponent>(pSprite->GetTextureSize());
+	m_pOwner->SetActive(true);
+	m_pOwner->SetWorldPosition(position);
+}
+
+void Bullet::Update(const float deltaTime)
+{
+	m_pOwner->SetWorldPosition(m_pOwner->GetWorldPosition() + (m_Speed * deltaTime));
+}
+
+void Bullet::Initialize(int ownerIndex, const glm::vec2& position)
+{
+	m_pOwner->GetComponentOfType<Fluffy::Sprite>()->SetTexture(ownerIndex == 0 ? "enemyBullet.png" : "galaga_player_bullet.png");
+
+	m_pOwner->SetActive(true);
+	m_pOwner->SetWorldPosition(position);
+}

Galaga/Bullet.cpp

@@ -0,0 +1,24 @@
+#pragma once
+#include "Component.h"
+#include <glm/glm.hpp>
+
+namespace Fluffy
+{
+	class GameObject;
+}
+
+class Bullet final : public Fluffy::Component
+{
+public:
+	Bullet(Fluffy::GameObject* pOwner, int ownerIndex, const glm::vec2& position, const glm::vec2& speed = { 0.0f, -100.0f });
+	~Bullet() = default;
+
+	void Update(const float deltaTime) override;
+	std::string GetTypeName() override { return typeid(*this).name(); }
+	void Initialize(int ownerIndex, const glm::vec2& position);
+
+private:
+	int m_OwnerIndex;
+	glm::vec2 m_Speed;
+};
+

Galaga/Bullet.h

@@ -0,0 +1,32 @@
+#include "BulletsManager.h"
+#include "GameObject.h"
+
+void BulletsManager::Shoot(int ownerIndex, const glm::vec2& position)
+{
+	if (!m_BulletsPool.empty())
+	{
+		Bullet* pBullet;
+		pBullet = m_BulletsPool.front();
+		m_ActiveBullets.push_back(pBullet);
+		m_BulletsPool.pop();
+
+		pBullet->Initialize(ownerIndex, position);
+	}
+	else
+	{
+		std::shared_ptr<Fluffy::GameObject> pBulletObject{ std::make_shared<Fluffy::GameObject>(position.x, position.y) };
+		Bullet* pBullet{ pBulletObject->AddComponent<Bullet>(ownerIndex, position) };
+		pBullet->Initialize(ownerIndex, position);
+		m_Scene->Add(pBulletObject);
+	}
+}
+
+void BulletsManager::PoolBullet(int index)	// pool the bullet if it collides with a thing or is out of screen -> add events
+{
+	Bullet* pBullet{ m_ActiveBullets[index] };
+	m_BulletsPool.push(pBullet);
+
+	m_ActiveBullets.erase(m_ActiveBullets.begin() + index);
+
+	pBullet->GetGameObject()->SetActive(false);
+}

Galaga/BulletsManager.cpp

@@ -0,0 +1,27 @@
+#pragma once
+#include "Singleton.h"
+#include "Scene.h"
+#include <glm/glm.hpp>
+#include <queue>
+#include <unordered_map>
+#include "Bullet.h"
+
+namespace Fluffy
+{
+	class GameObject;
+}
+
+class BulletsManager : public Fluffy::Singleton<BulletsManager>
+{
+public:
+	void SetScene(Fluffy::Scene* pScene) { m_Scene = pScene; }
+	void Shoot(int ownerIndex, const glm::vec2& position);
+
+private:
+	Fluffy::Scene* m_Scene;
+	std::queue<Bullet*> m_BulletsPool;
+	std::vector<Bullet*> m_ActiveBullets;
+
+	void PoolBullet(int index);
+};
+

Galaga/BulletsManager.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "ShootCommand.h"
+#include "BulletsManager.h"
+#include "CharactersManager.h"
+#include "PlayerCharacter.h"
+#include "GameObject.h"
+
+ShootCommand::ShootCommand(int playerIndex)
+	: m_PlayerIndex{ playerIndex }
+{
+
+}
+
+void ShootCommand::Execute()
+{
+	const glm::vec2 position{ CharactersManager::GetInstance().GetPlayer(m_PlayerIndex)->GetGameObject()->GetWorldPosition() };
+	BulletsManager::GetInstance().Shoot(m_PlayerIndex, position);
+}

Galaga/ShootCommand.cpp

@@ -0,0 +1,26 @@
+#pragma once
+#include "Command.h"
+#include "glm/glm.hpp"
+
+namespace Fluffy
+{
+	class Command;
+}
+
+class ShootCommand final : public Fluffy::Command
+{
+public:
+	ShootCommand(int playerIndex);
+	~ShootCommand() = default;
+
+	ShootCommand(const ShootCommand& other) = default;
+	ShootCommand& operator=(const ShootCommand& other) = default;
+	ShootCommand(ShootCommand&& other) = default;
+	ShootCommand& operator=(ShootCommand&& other) = default;
+
+	void Execute() override;
+
+private:
+	const int m_PlayerIndex;
+};
+