Merge pull request #12 from teamfisk/PlayerSystem

Player system

include/Engine/Core/EventBroker.h

@@ -17,119 +17,119 @@ class EventBroker;
 
 class BaseEventRelay
 {
-friend class EventBroker;
+    friend class EventBroker;
 
 protected:
-	BaseEventRelay(std::string contextTypeName, std::string eventTypeName)
+    BaseEventRelay(std::string contextTypeName, std::string eventTypeName)
-		: m_ContextTypeName(contextTypeName)
+        : m_ContextTypeName(contextTypeName)
-		, m_EventTypeName(eventTypeName)
+        , m_EventTypeName(eventTypeName)
-		, m_Broker(nullptr) 
+        , m_Broker(nullptr)
-	{ }
+    { }
-	~BaseEventRelay();
+    ~BaseEventRelay();
 
 public:
-	virtual bool Receive(const std::shared_ptr<Event> event) = 0;
+    virtual bool Receive(const std::shared_ptr<Event> event) = 0;
 
 protected:
-	std::string m_ContextTypeName;
+    std::string m_ContextTypeName;
-	std::string m_EventTypeName;
+    std::string m_EventTypeName;
-	EventBroker* m_Broker;
+    EventBroker* m_Broker;
 };
 
 template <typename ContextType, typename EventType>
 class EventRelay : public BaseEventRelay
 {
 public:
-	typedef std::function<bool(const EventType&)> CallbackType;
+    typedef std::function<bool(const EventType&)> CallbackType;
 
-	EventRelay()
+    EventRelay()
-		: m_Callback(nullptr)
+        : m_Callback(nullptr)
-		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) 
+        , BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name())
-	{ }
+    { }
-	EventRelay(CallbackType callback) 
+    EventRelay(CallbackType callback)
-		: m_Callback(callback)
+        : m_Callback(callback)
-		, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) 
+        , BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name())
-	{ }
+    { }
 
 protected:
-	bool Receive(const std::shared_ptr<Event> event) override;
+    bool Receive(const std::shared_ptr<Event> event) override;
 
 private:
-	CallbackType m_Callback;
+    CallbackType m_Callback;
 };
 
 template <typename ContextType, typename EventType>
 bool EventRelay<ContextType, EventType>::Receive(const std::shared_ptr<Event> event)
 {
-	if (m_Callback != nullptr) {
+    if (m_Callback != nullptr) {
-		return m_Callback(*static_cast<const EventType*>(event.get()));
+        return m_Callback(*static_cast<const EventType*>(event.get()));
-	} else {
+    } else {
-		return false;
+        return false;
-	}
+    }
 }
 
 class EventBroker
 {
-template <typename ContextType, typename EventType> friend class EventRelay;
+    template <typename ContextType, typename EventType> friend class EventRelay;
 
 public:
-	EventBroker()
+    EventBroker()
-	{
+    {
-		m_EventQueueRead = std::make_shared<EventQueue_t>();
+        m_EventQueueRead = std::make_shared<EventQueue_t>();
-		m_EventQueueWrite = std::make_shared<EventQueue_t>();
+        m_EventQueueWrite = std::make_shared<EventQueue_t>();
-	}
+    }
 
-	void Subscribe(BaseEventRelay &relay);
+    void Subscribe(BaseEventRelay &relay);
-	template <typename EventType>
+    template <typename EventType>
-	void Publish(const EventType &event);
+    void Publish(const EventType &event);
-	/*
+    /*
-		Process all events in a given context.
+        Process all events in a given context.
-		Returns: Number of events processed
+        Returns: Number of events processed
-	*/
+    */
-	template <typename ContextType>
+    template <typename ContextType>
-	int Process();
+    int Process();
-	int Process(std::string contextTypeName);
+    int Process(std::string contextTypeName);
-	void Swap();
+    void Swap();
-	void Clear();
+    void Clear();
-	void Unsubscribe(BaseEventRelay &relay);
+    void Unsubscribe(BaseEventRelay &relay);
 
 private:
-	bool m_IsProcessing = false;
+    bool m_IsProcessing = false;
 
-	typedef std::string ContextTypeName_t; // typeid(ContextType).name()
+    typedef std::string ContextTypeName_t; // typeid(ContextType).name()
-	typedef std::string EventTypeName_t; // typeid(EventType).name()
+    typedef std::string EventTypeName_t; // typeid(EventType).name()
 
-	typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
+    typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
-	typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
+    typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
-	ContextRelays_t m_ContextRelays;
+    ContextRelays_t m_ContextRelays;
-	std::vector<BaseEventRelay*> m_RelaysToSubscribe;
+    std::vector<BaseEventRelay*> m_RelaysToSubscribe;
-	std::vector<BaseEventRelay*> m_RelaysToUnsubscribe;
+    std::vector<BaseEventRelay*> m_RelaysToUnsubscribe;
 
-	typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
+    typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
-	std::shared_ptr<EventQueue_t> m_EventQueueRead;
+    std::shared_ptr<EventQueue_t> m_EventQueueRead;
-	std::shared_ptr<EventQueue_t> m_EventQueueWrite;
+    std::shared_ptr<EventQueue_t> m_EventQueueWrite;
 
-	void subscribeImmediate(BaseEventRelay& relay);
+    void subscribeImmediate(BaseEventRelay& relay);
-	void unsubscribeImmediate(BaseEventRelay& relay);
+    void unsubscribeImmediate(BaseEventRelay& relay);
 };
 
 template <typename EventType>
 void EventBroker::Publish(const EventType &event)
 {
-	/*auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
+    /*auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
-	for (auto it = itpair.first; it != itpair.second; ++it)
+    for (auto it = itpair.first; it != itpair.second; ++it)
-	{
+    {
-		it->second->Receive(event);
+        it->second->Receive(event);
-	}*/
+    }*/
 
-	m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event))));
+    m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event))));
 }
 
 template <typename ContextType>
 int EventBroker::Process()
 {
-	const std::string contextTypeName = typeid(ContextType).name();
+    const std::string contextTypeName = typeid(ContextType).name();
-	return Process(contextTypeName);
+    return Process(contextTypeName);
 }
 
 #endif

include/Engine/Core/System.h

@@ -10,16 +10,16 @@ class System
     friend class SystemPipeline;
 
 public:
-    System(const EventBroker* eventBroker, std::string componentType)
+    System(EventBroker* eventBroker, std::string componentType)
         : m_EventBroker(eventBroker)
         , m_ComponentType(componentType)
     { }
 
     virtual void Update(World* world, ComponentWrapper& component, double dt) = 0;
 
-private:
+protected:
-    const EventBroker* m_EventBroker;
     std::string m_ComponentType;
+    EventBroker* m_EventBroker;
 };
 
 #endif

include/Engine/Core/SystemPipeline.h

@@ -9,7 +9,7 @@
 class SystemPipeline
 {
 public:
-    SystemPipeline(const EventBroker* eventBroker)
+    SystemPipeline(EventBroker* eventBroker)
         : m_EventBroker(eventBroker)
     { }
     ~SystemPipeline()
@@ -51,7 +51,7 @@ public:
     }
 
 private:
-    const EventBroker* m_EventBroker;
+    EventBroker* m_EventBroker;
     std::unordered_map<std::string, std::vector<System*>> m_Systems;
 };
 

include/Game/Game.h

@@ -13,6 +13,7 @@
 #include "Core/EntityXMLFile.h"
 #include "Core/SystemPipeline.h"
 #include "RaptorCopterSystem.h"
+#include "PlayerSystem.h"
 
 class Game
 {

include/Game/PlayerSystem.h

@@ -0,0 +1,44 @@
+#ifndef PlayerSystem_h__
+#define PlayerSystem_h__
+
+#include <GLFW/glfw3.h>
+#include <glm/common.hpp>
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Core/EventBroker.h"
+#include "Core/EKeyDown.h"
+#include "Core/EKeyUp.h"
+
+struct KeyInput
+{
+    bool Forward = false;
+    bool Left = false;
+    bool Back = false;
+    bool Right = false;
+};
+
+class PlayerSystem : public System
+{
+public:
+    PlayerSystem(EventBroker* eventBroker)
+        : System(eventBroker, "Player")
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &PlayerSystem::OnKeyDown);
+        EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &PlayerSystem::OnKeyUp);
+    }
+
+    virtual void Update(World* world, ComponentWrapper& player, double dt) override;
+
+private:
+    float m_Speed = 5;
+    glm::vec3 m_Direction;
+    KeyInput input;
+
+    EventRelay<PlayerSystem, Events::KeyDown> m_EKeyDown;
+    bool OnKeyDown(const Events::KeyDown &event);
+    EventRelay<PlayerSystem, Events::KeyUp> m_EKeyUp;
+    bool OnKeyUp(const Events::KeyUp &event);
+};
+
+#endif

include/Game/RaptorCopterSystem.h

@@ -4,10 +4,12 @@
 class RaptorCopterSystem : public System
 {
 public:
-    RaptorCopterSystem(const EventBroker* eventBroker)
+    RaptorCopterSystem(EventBroker* eventBroker)
         : System(eventBroker, "RaptorCopter")
     { }
 
+	virtual void Initialize() { }
+
     virtual void Update(World* world, ComponentWrapper& raptorCopter, double dt) override
     {
         ComponentWrapper& transform = world->GetComponent(raptorCopter.EntityID, "Transform");

resources/Schema/Components.xsd

@@ -5,4 +5,5 @@
 	<xs:include schemaLocation="Components/Model.xsd"/>
 	<xs:include schemaLocation="Components/Test.xsd"/>
 	<xs:include schemaLocation="Components/RaptorCopter.xsd"/>
+	<xs:include schemaLocation="Components/Player.xsd"/>
 </xs:schema>

resources/Schema/Components/Player.xml

@@ -0,0 +1,3 @@
+<c:Player>
+	<Velocity X="0" Y="0" Z="0"/>
+</c:Player>

resources/Schema/Components/Player.xsd

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="Player">
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="Velocity" type="t:Vector" minOccurs="0"/>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Entities/Test.xml

@@ -31,6 +31,19 @@
 				</c:Model>
 			</Components>
 		</Entity>
+		<Entity>
+			<Components>
+				<c:Player>
+					<Velocity X="0" Y="0" Z="0"/>
+				</c:Player>
+				<c:Transform>
+					<Position X="2.5"/>
+				</c:Transform>
+				<c:Model>
+					<Resource>Models/Core/UnitCube.obj</Resource>
+				</c:Model>
+			</Components>
+		</Entity>
 		<Entity>
 			<Components>
 				<c:Transform>

resources/Schema/Types/Entity.xsd

@@ -14,6 +14,7 @@
 							<xs:element ref="c:Model" minOccurs="0"/>
 							<xs:element ref="c:Test" minOccurs="0"/>
 							<xs:element ref="c:RaptorCopter" minOccurs="0"/>
+							<xs:element ref="c:Player" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

src/Game/CMakeLists.txt

@@ -19,6 +19,7 @@ file(GLOB SOURCE_FILES
 set(SOURCE_FILES
     ${SOURCE_FILES}
     "Game.cpp"
+	"PlayerSystem.cpp"
 )
 
 set(LIBRARIES

src/Game/Game.cpp

@@ -2,38 +2,38 @@
 
 Game::Game(int argc, char* argv[])
 {
-	ResourceManager::RegisterType<ConfigFile>("ConfigFile");
+    ResourceManager::RegisterType<ConfigFile>("ConfigFile");
-	ResourceManager::RegisterType<Model>("Model");
+    ResourceManager::RegisterType<Model>("Model");
-	ResourceManager::RegisterType<Texture>("Texture");
+    ResourceManager::RegisterType<Texture>("Texture");
     ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile");
 
-	m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
-	LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
+    LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
 
-	// Create the core event broker
+    // Create the core event broker
-	m_EventBroker = new EventBroker();
+    m_EventBroker = new EventBroker();
 
     m_RenderQueueFactory = new RenderQueueFactory();
 
-	// Create the renderer
+    // Create the renderer
-	m_Renderer = new Renderer(m_EventBroker);
+    m_Renderer = new Renderer(m_EventBroker);
-	m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
+    m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
-	m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
+    m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
-	m_Renderer->SetResolution(Rectangle(
+    m_Renderer->SetResolution(Rectangle(
-		0,
+        0,
-		0,
+        0,
-		m_Config->Get<int>("Video.Width", 1280),
+        m_Config->Get<int>("Video.Width", 1280),
-		m_Config->Get<int>("Video.Height", 720)
+        m_Config->Get<int>("Video.Height", 720)
-	));
+        ));
-	m_Renderer->Initialize();
+    m_Renderer->Initialize();
 
-	// Create input manager
+    // Create input manager
-	m_InputManager = new InputManager(m_Renderer->Window(), m_EventBroker);
+    m_InputManager = new InputManager(m_Renderer->Window(), m_EventBroker);
 
-	// Create the root level GUI frame
+    // Create the root level GUI frame
-	m_FrameStack = new GUI::Frame(m_EventBroker);
+    m_FrameStack = new GUI::Frame(m_EventBroker);
-	m_FrameStack->Width = m_Renderer->Resolution().Width;
+    m_FrameStack->Width = m_Renderer->Resolution().Width;
-	m_FrameStack->Height = m_Renderer->Resolution().Height;
+    m_FrameStack->Height = m_Renderer->Resolution().Height;
 
     // Create a world
     m_World = new World();
@@ -45,27 +45,30 @@ Game::Game(int argc, char* argv[])
     // Create system pipeline
     m_SystemPipeline = new SystemPipeline(m_EventBroker);
     m_SystemPipeline->AddSystem<RaptorCopterSystem>();
+    m_SystemPipeline->AddSystem<PlayerSystem>();
 
-	m_LastTime = glfwGetTime();
+
+
+    m_LastTime = glfwGetTime();
 
     testIntialize();
 }
 
 Game::~Game()
 {
-	delete m_FrameStack;
+    delete m_FrameStack;
-	delete m_EventBroker;
+    delete m_EventBroker;
 }
 
 void Game::Tick()
 {
-	double currentTime = glfwGetTime();
+    double currentTime = glfwGetTime();
-	double dt = currentTime - m_LastTime;
+    double dt = currentTime - m_LastTime;
-	m_LastTime = currentTime;
+    m_LastTime = currentTime;
 
-	m_EventBroker->Swap();
+    m_EventBroker->Swap();
-	m_InputManager->Update(dt);
+    m_InputManager->Update(dt);
-	m_EventBroker->Swap();
+    m_EventBroker->Swap();
 
     // Iterate through systems and update world!
     m_SystemPipeline->Update(m_World, dt);
@@ -73,12 +76,12 @@ void Game::Tick()
     m_Renderer->Update(dt);
 
     m_RenderQueueFactory->Update(m_World);
-	m_Renderer->Draw(m_RenderQueueFactory->RenderQueues());
+    m_Renderer->Draw(m_RenderQueueFactory->RenderQueues());
 
-	m_EventBroker->Swap();
+    m_EventBroker->Swap();
-	m_EventBroker->Clear();
+    m_EventBroker->Clear();
 
-	glfwPollEvents();
+    glfwPollEvents();
 }
 
 

src/Game/PlayerSystem.cpp

@@ -0,0 +1,58 @@
+#include "PlayerSystem.h"
+
+
+void PlayerSystem::Update(World * world, ComponentWrapper & player, double dt)
+{
+    if (input.Forward) {
+        m_Direction.z = -1;
+    } else if (input.Back) {
+        m_Direction.z = 1;
+    } else {
+        m_Direction.z = 0;
+    }
+    if (input.Left) {
+        m_Direction.x = -1;
+    } else if (input.Right) {
+        m_Direction.x = 1;
+    } else {
+        m_Direction.x = 0;
+    }
+    m_EventBroker->Process<PlayerSystem>();
+    ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
+    (glm::vec3&)player["Velocity"] = m_Speed * float(dt) * m_Direction;
+    (glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
+}
+
+bool PlayerSystem::OnKeyDown(const Events::KeyDown & event)
+{
+    if (event.KeyCode == GLFW_KEY_W) {
+        input.Forward = true;
+    }
+    if (event.KeyCode == GLFW_KEY_A) {
+        input.Left = true;
+    }
+    if (event.KeyCode == GLFW_KEY_S) {
+        input.Back = true;
+    }
+    if (event.KeyCode == GLFW_KEY_D) {
+        input.Right = true;
+    }
+    return true;
+}
+
+bool PlayerSystem::OnKeyUp(const Events::KeyUp & event)
+{
+    if (event.KeyCode == GLFW_KEY_W) {
+        input.Forward = false;
+    }
+    if (event.KeyCode == GLFW_KEY_A) {
+        input.Left = false;
+    }
+    if (event.KeyCode == GLFW_KEY_S) {
+        input.Back = false;
+    }
+    if (event.KeyCode == GLFW_KEY_D) {
+        input.Right = false;
+    }
+    return false;
+}