From 428c401f9c1053f7e13ffe641758dfb72791d8dc Mon Sep 17 00:00:00 2001 From: Kelly Rauchenberger Date: Fri, 26 Jun 2015 19:59:28 -0400 Subject: Player now moves --- CMakeLists.txt | 8 +- src/components/animatable.cpp | 27 ++++++ src/components/animatable.h | 31 +++++++ src/components/controllable.cpp | 71 +++++++++++++++ src/components/controllable.h | 36 ++++++++ src/components/droppable.cpp | 11 +++ src/components/droppable.h | 15 ++++ src/components/ponderable.cpp | 41 +++++++++ src/components/ponderable.h | 24 +++++ src/components/sprite_renderable.cpp | 27 ------ src/components/sprite_renderable.h | 25 ------ src/consts.h | 3 + src/direction.h | 11 +++ src/game.cpp | 75 ++++++++++++++++ src/game.h | 24 +++++ src/main.cpp | 25 +----- src/system.h | 10 ++- src/system_manager.h | 37 ++++++++ src/systems/controlling.cpp | 168 +++++++++++++++++++++++++++++++++++ src/systems/controlling.h | 26 ++++++ src/systems/pondering.cpp | 23 +++++ src/systems/pondering.h | 14 +++ src/systems/rendering.cpp | 12 +-- src/systems/rendering.h | 5 +- 24 files changed, 665 insertions(+), 84 deletions(-) create mode 100644 src/components/animatable.cpp create mode 100644 src/components/animatable.h create mode 100644 src/components/controllable.cpp create mode 100644 src/components/controllable.h create mode 100644 src/components/droppable.cpp create mode 100644 src/components/droppable.h create mode 100644 src/components/ponderable.cpp create mode 100644 src/components/ponderable.h delete mode 100644 src/components/sprite_renderable.cpp delete mode 100644 src/components/sprite_renderable.h create mode 100644 src/direction.h create mode 100644 src/game.cpp create mode 100644 src/game.h create mode 100644 src/system_manager.h create mode 100644 src/systems/controlling.cpp create mode 100644 src/systems/controlling.h create mode 100644 src/systems/pondering.cpp create mode 100644 src/systems/pondering.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 2bfde77..9e4ac25 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -50,9 +50,15 @@ add_executable(Aromatherapy src/renderer.cpp src/muxer.cpp src/entity_manager.cpp - src/components/sprite_renderable.cpp + src/game.cpp src/components/transformable.cpp + src/components/droppable.cpp + src/components/controllable.cpp + src/components/ponderable.cpp + src/components/animatable.cpp src/systems/rendering.cpp + src/systems/controlling.cpp + src/systems/pondering.cpp ) target_link_libraries(Aromatherapy ${ALL_LIBS}) install(TARGETS Aromatherapy RUNTIME DESTINATION ${BIN_DIR}) diff --git a/src/components/animatable.cpp b/src/components/animatable.cpp new file mode 100644 index 0000000..fcd277c --- /dev/null +++ b/src/components/animatable.cpp @@ -0,0 +1,27 @@ +#include "animatable.h" + +AnimatableComponent::AnimatableComponent(const char* filename, int frame_width, int frame_height, int frames_across) + : texture(filename), frame_width(frame_width), frame_height(frame_height), frames_across(frames_across) +{ + +} + +int AnimatableComponent::getFrame() const +{ + return frame; +} + +void AnimatableComponent::setFrame(int frame) +{ + this->frame = frame; +} + +const Texture& AnimatableComponent::getTexture() const +{ + return texture; +} + +Rectangle AnimatableComponent::getFrameRect() const +{ + return {frame_width * (frame % frames_across), frame_height * (frame / frames_across), frame_width, frame_height}; +} diff --git a/src/components/animatable.h b/src/components/animatable.h new file mode 100644 index 0000000..cf6ee54 --- /dev/null +++ b/src/components/animatable.h @@ -0,0 +1,31 @@ +#ifndef SPRITE_RENDERABLE_H_D3AACBBF +#define SPRITE_RENDERABLE_H_D3AACBBF + +#include "component.h" +#include "renderer.h" +#include "direction.h" + +class AnimatableComponent : public Component { + public: + AnimatableComponent(const char* filename, int frame_width, int frame_height, int frames_across); + + int getFrame() const; + void setFrame(int frame); + + const Texture& getTexture() const; + Rectangle getFrameRect() const; + + void setDirection(Direction dir) {}; + void setWalking(bool w) {}; + void setJumping(bool w) {}; + void setCrouching(bool w) {}; + + private: + Texture texture; + int frame_width; + int frame_height; + int frames_across; + int frame = 0; +}; + +#endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */ diff --git a/src/components/controllable.cpp b/src/components/controllable.cpp new file mode 100644 index 0000000..a4d45f2 --- /dev/null +++ b/src/components/controllable.cpp @@ -0,0 +1,71 @@ +#include "controllable.h" + +int ControllableComponent::getLeftKey() const +{ + return leftKey; +} + +void ControllableComponent::setLeftKey(int k) +{ + leftKey = k; +} + +int ControllableComponent::getRightKey() const +{ + return rightKey; +} + +void ControllableComponent::setRightKey(int k) +{ + rightKey = k; +} + +int ControllableComponent::getJumpKey() const +{ + return jumpKey; +} + +void ControllableComponent::setJumpKey(int k) +{ + jumpKey = k; +} + +int ControllableComponent::getDropKey() const +{ + return dropKey; +} + +void ControllableComponent::setDropKey(int k) +{ + dropKey = k; +} + +bool ControllableComponent::isFrozen() const +{ + return frozen; +} + +void ControllableComponent::setFrozen(bool f) +{ + frozen = f; +} + +bool ControllableComponent::isHoldingLeft() const +{ + return holdingLeft; +} + +void ControllableComponent::setHoldingLeft(bool f) +{ + holdingLeft = f; +} + +bool ControllableComponent::isHoldingRight() const +{ + return holdingRight; +} + +void ControllableComponent::setHoldingRight(bool f) +{ + holdingRight = f; +} diff --git a/src/components/controllable.h b/src/components/controllable.h new file mode 100644 index 0000000..317d68d --- /dev/null +++ b/src/components/controllable.h @@ -0,0 +1,36 @@ +#ifndef CONTROLLABLE_H_4E0B85B4 +#define CONTROLLABLE_H_4E0B85B4 + +#include "component.h" +#include "renderer.h" + +class ControllableComponent : public Component { + public: + int getLeftKey() const; + void setLeftKey(int k); + int getRightKey() const; + void setRightKey(int k); + int getJumpKey() const; + void setJumpKey(int k); + int getDropKey() const; + void setDropKey(int k); + + bool isFrozen() const; + void setFrozen(bool f); + bool isHoldingLeft() const; + void setHoldingLeft(bool f); + bool isHoldingRight() const; + void setHoldingRight(bool f); + + private: + int leftKey = GLFW_KEY_LEFT; + int rightKey = GLFW_KEY_RIGHT; + int jumpKey = GLFW_KEY_UP; + int dropKey = GLFW_KEY_DOWN; + + bool frozen = false; + bool holdingLeft = false; + bool holdingRight = false; +}; + +#endif /* end of include guard: CONTROLLABLE_H_4E0B85B4 */ diff --git a/src/components/droppable.cpp b/src/components/droppable.cpp new file mode 100644 index 0000000..534fd9a --- /dev/null +++ b/src/components/droppable.cpp @@ -0,0 +1,11 @@ +#include "droppable.h" + +void DroppableComponent::setDroppable(bool can) +{ + droppable = can; +} + +bool DroppableComponent::isDroppable() const +{ + return droppable; +} diff --git a/src/components/droppable.h b/src/components/droppable.h new file mode 100644 index 0000000..1f5608b --- /dev/null +++ b/src/components/droppable.h @@ -0,0 +1,15 @@ +#ifndef DROPPABLE_H_5DB254EF +#define DROPPABLE_H_5DB254EF + +#include "component.h" + +class DroppableComponent : public Component { + public: + void setDroppable(bool can); + bool isDroppable() const; + + private: + bool droppable = false; +}; + +#endif /* end of include guard: DROPPABLE_H_5DB254EF */ diff --git a/src/components/ponderable.cpp b/src/components/ponderable.cpp new file mode 100644 index 0000000..2cfa6a6 --- /dev/null +++ b/src/components/ponderable.cpp @@ -0,0 +1,41 @@ +#include "ponderable.h" + +double PonderableComponent::getVelocityX() const +{ + return velocityX; +} + +void PonderableComponent::setVelocityX(double v) +{ + velocityX = v; +} + +double PonderableComponent::getVelocityY() const +{ + return velocityY; +} + +void PonderableComponent::setVelocityY(double v) +{ + velocityY = v; +} + +double PonderableComponent::getAccelX() const +{ + return accelX; +} + +void PonderableComponent::setAccelX(double v) +{ + accelX = v; +} + +double PonderableComponent::getAccelY() const +{ + return accelY; +} + +void PonderableComponent::setAccelY(double v) +{ + accelY = v; +} diff --git a/src/components/ponderable.h b/src/components/ponderable.h new file mode 100644 index 0000000..5aab4b3 --- /dev/null +++ b/src/components/ponderable.h @@ -0,0 +1,24 @@ +#ifndef TANGIBLE_H_746DB3EE +#define TANGIBLE_H_746DB3EE + +#include "component.h" + +class PonderableComponent : public Component { + public: + double getVelocityX() const; + void setVelocityX(double v); + double getVelocityY() const; + void setVelocityY(double v); + double getAccelX() const; + void setAccelX(double v); + double getAccelY() const; + void setAccelY(double v); + + private: + double velocityX = 0.0; + double velocityY = 0.0; + double accelX = 0.0; + double accelY = 0.0; +}; + +#endif /* end of include guard: TANGIBLE_H_746DB3EE */ diff --git a/src/components/sprite_renderable.cpp b/src/components/sprite_renderable.cpp deleted file mode 100644 index 4c61111..0000000 --- a/src/components/sprite_renderable.cpp +++ /dev/null @@ -1,27 +0,0 @@ -#include "sprite_renderable.h" - -SpriteRenderableComponent::SpriteRenderableComponent(const char* filename, int frame_width, int frame_height, int frames_across) - : texture(filename), frame_width(frame_width), frame_height(frame_height), frames_across(frames_across) -{ - -} - -int SpriteRenderableComponent::getFrame() const -{ - return frame; -} - -void SpriteRenderableComponent::setFrame(int frame) -{ - this->frame = frame; -} - -const Texture& SpriteRenderableComponent::getTexture() const -{ - return texture; -} - -Rectangle SpriteRenderableComponent::getFrameRect() const -{ - return {frame_width * (frame % frames_across), frame_height * (frame / frames_across), frame_width, frame_height}; -} diff --git a/src/components/sprite_renderable.h b/src/components/sprite_renderable.h deleted file mode 100644 index b4465c3..0000000 --- a/src/components/sprite_renderable.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef SPRITE_RENDERABLE_H_D3AACBBF -#define SPRITE_RENDERABLE_H_D3AACBBF - -#include "component.h" -#include "renderer.h" - -class SpriteRenderableComponent : public Component { - public: - SpriteRenderableComponent(const char* filename, int frame_width, int frame_height, int frames_across); - - int getFrame() const; - void setFrame(int frame); - - const Texture& getTexture() const; - Rectangle getFrameRect() const; - - private: - Texture texture; - int frame_width; - int frame_height; - int frames_across; - int frame = 0; -}; - -#endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */ diff --git a/src/consts.h b/src/consts.h index 804c761..4595719 100644 --- a/src/consts.h +++ b/src/consts.h @@ -11,4 +11,7 @@ const int MAP_HEIGHT = GAME_HEIGHT/TILE_HEIGHT - 1; const int FRAMES_PER_SECOND = 60; const double SECONDS_PER_FRAME = 1.0 / FRAMES_PER_SECOND; +#define JUMP_VELOCITY(h, l) (-2 * (h) / (l)) +#define JUMP_GRAVITY(h, l) (2 * ((h) / (l)) / (l)) + #endif diff --git a/src/direction.h b/src/direction.h new file mode 100644 index 0000000..32d6b41 --- /dev/null +++ b/src/direction.h @@ -0,0 +1,11 @@ +#ifndef DIRECTION_H_9C49EAFD +#define DIRECTION_H_9C49EAFD + +enum class Direction { + Left, + Right, + Up, + Down +}; + +#endif /* end of include guard: DIRECTION_H_9C49EAFD */ diff --git a/src/game.cpp b/src/game.cpp new file mode 100644 index 0000000..b3fa9a8 --- /dev/null +++ b/src/game.cpp @@ -0,0 +1,75 @@ +#include "game.h" +#include "components/animatable.h" +#include "components/transformable.h" +#include "components/controllable.h" +#include "components/droppable.h" +#include "components/ponderable.h" +#include "systems/rendering.h" +#include "systems/controlling.h" +#include "systems/pondering.h" + +void key_callback(GLFWwindow* window, int key, int, int action, int) +{ + Game& game = *((Game*) glfwGetWindowUserPointer(window)); + + if ((action == GLFW_PRESS) && (key == GLFW_KEY_ESCAPE)) + { + game.shouldQuit = true; + + return; + } + + game.systemManager.getSystem().input(key, action); +} + +Game::Game(GLFWwindow* window) : window(window) +{ + systemManager.emplaceSystem(*this); + systemManager.emplaceSystem(*this); + systemManager.emplaceSystem(*this); + + int player = entityManager.emplaceEntity(); + entityManager.emplaceComponent(player, "res/Starla.png", 10, 12, 6); + entityManager.emplaceComponent(player, 203, 44, 10, 12); + entityManager.emplaceComponent(player); + entityManager.emplaceComponent(player); + entityManager.emplaceComponent(player); + + glfwSwapInterval(1); + glfwSetWindowUserPointer(window, this); + glfwSetKeyCallback(window, key_callback); +} + +void Game::execute() +{ + double lastTime = glfwGetTime(); + const double dt = 0.01; + double accumulator = 0.0; + + while (!(shouldQuit || glfwWindowShouldClose(window))) + { + double currentTime = glfwGetTime(); + double frameTime = currentTime - lastTime; + lastTime = currentTime; + + glfwPollEvents(); + + accumulator += frameTime; + while (accumulator >= dt) + { + systemManager.getSystem().tick(dt); + systemManager.getSystem().tick(dt); + + accumulator -= dt; + } + + systemManager.getSystem().tick(frameTime); + } +} + +EntityManager& Game::getEntityManager() +{ + return entityManager; +} + + diff --git a/src/game.h b/src/game.h new file mode 100644 index 0000000..3822700 --- /dev/null +++ b/src/game.h @@ -0,0 +1,24 @@ +#ifndef GAME_H_1014DDC9 +#define GAME_H_1014DDC9 + +#include "renderer.h" +#include "entity_manager.h" +#include "system_manager.h" + +class Game { + public: + Game(GLFWwindow* window); + + void execute(); + EntityManager& getEntityManager(); + + friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods); + + private: + EntityManager entityManager; + SystemManager systemManager; + GLFWwindow* const window; + bool shouldQuit = false; +}; + +#endif /* end of include guard: GAME_H_1014DDC9 */ diff --git a/src/main.cpp b/src/main.cpp index dcf8d87..35749f5 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -3,10 +3,7 @@ #include #include "renderer.h" #include "muxer.h" -#include "entity_manager.h" -#include "components/sprite_renderable.h" -#include "components/transformable.h" -#include "systems/rendering.h" +#include "game.h" int main() { @@ -19,24 +16,8 @@ int main() // Put this in a block so game goes out of scope before we destroy the renderer { - EntityManager manager; - - int player = manager.emplaceEntity(); - manager.emplaceComponent(player, "res/Starla.png", 10, 12, 6); - manager.emplaceComponent(player, 203, 44, 10, 12); - - std::list> loop; - loop.push_back(std::unique_ptr(new RenderingSystem())); - - while (!glfwWindowShouldClose(window)) - { - for (auto& sys : loop) - { - sys->tick(manager, 1.0); - } - - glfwPollEvents(); - } + Game game {window}; + game.execute(); } destroyMuxer(); diff --git a/src/system.h b/src/system.h index 85415f0..e08db0a 100644 --- a/src/system.h +++ b/src/system.h @@ -1,11 +1,17 @@ #ifndef SYSTEM_H_B61A8CEA #define SYSTEM_H_B61A8CEA -class EntityManager; +class Game; class System { public: - virtual void tick(EntityManager& manager, float dt) = 0; + System(Game& game) + : game(game) {} + + virtual void tick(double dt) = 0; + + protected: + Game& game; }; #endif /* end of include guard: SYSTEM_H_B61A8CEA */ diff --git a/src/system_manager.h b/src/system_manager.h new file mode 100644 index 0000000..8f76db2 --- /dev/null +++ b/src/system_manager.h @@ -0,0 +1,37 @@ +#ifndef SYSTEM_MANAGER_H_544E6056 +#define SYSTEM_MANAGER_H_544E6056 + +#include +#include +#include +#include +#include "system.h" + +class SystemManager { + private: + std::list> loop; + std::map systems; + + public: + template + void emplaceSystem(Game& game, Args&&... args) + { + std::unique_ptr ptr = std::unique_ptr(new T(game, std::forward(args)...)); + std::type_index systemType = typeid(T); + + systems[systemType] = ptr.get(); + loop.push_back(std::move(ptr)); + } + + template + T& getSystem() + { + std::type_index systemType = typeid(T); + + assert(systems.count(systemType) == 1); + + return *((T*)systems[systemType]); + } +}; + +#endif /* end of include guard: SYSTEM_MANAGER_H_544E6056 */ diff --git a/src/systems/controlling.cpp b/src/systems/controlling.cpp new file mode 100644 index 0000000..b1e73ad --- /dev/null +++ b/src/systems/controlling.cpp @@ -0,0 +1,168 @@ +#include "controlling.h" +#include "game.h" +#include "components/controllable.h" +#include "components/ponderable.h" +#include "components/animatable.h" +#include "components/droppable.h" +#include "direction.h" +#include "muxer.h" +#include "consts.h" + +void ControllingSystem::tick(double dt) +{ + while (!actions.empty()) + { + int key = actions.front().first; + int action = actions.front().second; + + auto entities = game.getEntityManager().getEntitiesWithComponents(); + for (auto entity : entities) + { + auto& controllable = game.getEntityManager().getComponent(entity); + + if (action == GLFW_PRESS) + { + if (key == controllable.getLeftKey()) + { + controllable.setHoldingLeft(true); + + if (!controllable.isFrozen()) + { + walkLeft(entity); + } + } else if (key == controllable.getRightKey()) + { + controllable.setHoldingRight(true); + + if (!controllable.isFrozen()) + { + walkRight(entity); + } + } else if (key == controllable.getJumpKey()) + { + if (!controllable.isFrozen()) + { + jump(entity); + } + } else if (key == controllable.getDropKey()) + { + if (!controllable.isFrozen()) + { + drop(entity, true); + } + } + } else if (action == GLFW_RELEASE) + { + if (key == controllable.getLeftKey()) + { + controllable.setHoldingLeft(false); + + if (!controllable.isFrozen()) + { + if (controllable.isHoldingRight()) + { + walkRight(entity); + } else { + stopWalking(entity); + } + } + } else if (key == controllable.getRightKey()) + { + controllable.setHoldingRight(false); + + if (!controllable.isFrozen()) + { + if (controllable.isHoldingRight()) + { + walkLeft(entity); + } else { + stopWalking(entity); + } + } + } else if (key == controllable.getDropKey()) + { + if (!controllable.isFrozen()) + { + drop(entity, false); + } + } else if (key == controllable.getJumpKey()) + { + if (!controllable.isFrozen()) + { + stopJumping(entity); + } + } + } + } + + actions.pop(); + } +} + +void ControllingSystem::input(int key, int action) +{ + actions.push(std::make_pair(key, action)); +} + +void ControllingSystem::walkLeft(int entity) +{ + auto& ponderable = game.getEntityManager().getComponent(entity); + auto& animatable = game.getEntityManager().getComponent(entity); + + ponderable.setVelocityX(-90); + + animatable.setDirection(Direction::Left); + animatable.setWalking(true); +} + +void ControllingSystem::walkRight(int entity) +{ + auto& ponderable = game.getEntityManager().getComponent(entity); + auto& animatable = game.getEntityManager().getComponent(entity); + + ponderable.setVelocityX(90); + + animatable.setDirection(Direction::Right); + animatable.setWalking(true); +} + +void ControllingSystem::stopWalking(int entity) +{ + auto& ponderable = game.getEntityManager().getComponent(entity); + auto& animatable = game.getEntityManager().getComponent(entity); + + ponderable.setVelocityX(0); + + animatable.setWalking(false); +} + +void ControllingSystem::jump(int entity) +{ + auto& ponderable = game.getEntityManager().getComponent(entity); + auto& animatable = game.getEntityManager().getComponent(entity); + + playSound("res/Randomize87.wav", 0.25); + + ponderable.setVelocityY(JUMP_VELOCITY(TILE_HEIGHT*4.5, 0.3)); + ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*4.5, 0.3)); + + animatable.setJumping(true); +} + +void ControllingSystem::stopJumping(int entity) +{ + auto& ponderable = game.getEntityManager().getComponent(entity); + auto& animatable = game.getEntityManager().getComponent(entity); + + ponderable.setAccelY(JUMP_GRAVITY(TILE_HEIGHT*3.5, 0.233)); + animatable.setJumping(false); +} + +void ControllingSystem::drop(int entity, bool start) +{ + auto& animatable = game.getEntityManager().getComponent(entity); + auto& droppable = game.getEntityManager().getComponent(entity); + + droppable.setDroppable(start); + animatable.setCrouching(start); +} diff --git a/src/systems/controlling.h b/src/systems/controlling.h new file mode 100644 index 0000000..61f86eb --- /dev/null +++ b/src/systems/controlling.h @@ -0,0 +1,26 @@ +#ifndef CONTROLLING_H_80B1BB8D +#define CONTROLLING_H_80B1BB8D + +#include "system.h" +#include + +class ControllingSystem : public System { + public: + ControllingSystem(Game& game) + : System(game) {} + + void tick(double dt); + void input(int key, int action); + + private: + void walkLeft(int entity); + void walkRight(int entity); + void stopWalking(int entity); + void jump(int entity); + void stopJumping(int entity); + void drop(int entity, bool start); + + std::queue> actions; +}; + +#endif /* end of include guard: CONTROLLING_H_80B1BB8D */ diff --git a/src/systems/pondering.cpp b/src/systems/pondering.cpp new file mode 100644 index 0000000..96775d0 --- /dev/null +++ b/src/systems/pondering.cpp @@ -0,0 +1,23 @@ +#include "pondering.h" +#include "game.h" +#include "components/ponderable.h" +#include "components/transformable.h" + +void PonderingSystem::tick(double dt) +{ + auto entities = game.getEntityManager().getEntitiesWithComponents(); + + for (auto entity : entities) + { + auto& transformable = game.getEntityManager().getComponent(entity); + auto& ponderable = game.getEntityManager().getComponent(entity); + + // Accelerate + ponderable.setVelocityX(ponderable.getVelocityX() + ponderable.getAccelX() * dt); + ponderable.setVelocityY(ponderable.getVelocityY() + ponderable.getAccelY() * dt); + + // Move + transformable.setX(transformable.getX() + ponderable.getVelocityX() * dt); + transformable.setY(transformable.getY() + ponderable.getVelocityY() * dt); + } +} diff --git a/src/systems/pondering.h b/src/systems/pondering.h new file mode 100644 index 0000000..ad01a22 --- /dev/null +++ b/src/systems/pondering.h @@ -0,0 +1,14 @@ +#ifndef PONDERING_H_F2530E0E +#define PONDERING_H_F2530E0E + +#include "system.h" + +class PonderingSystem : public System { + public: + PonderingSystem(Game& game) + : System(game) {} + + void tick(double dt); +}; + +#endif /* end of include guard: PONDERING_H_F2530E0E */ diff --git a/src/systems/rendering.cpp b/src/systems/rendering.cpp index 0034dc3..251c2bc 100644 --- a/src/systems/rendering.cpp +++ b/src/systems/rendering.cpp @@ -1,17 +1,17 @@ #include "rendering.h" -#include "entity_manager.h" -#include "components/sprite_renderable.h" +#include "game.h" +#include "components/animatable.h" #include "components/transformable.h" -void RenderingSystem::tick(EntityManager& manager, float dt) +void RenderingSystem::tick(double dt) { texture.fill(texture.entirety(), 0, 0, 0); - std::set spriteEntities = manager.getEntitiesWithComponents(); + std::set spriteEntities = game.getEntityManager().getEntitiesWithComponents(); for (int entity : spriteEntities) { - auto& sprite = manager.getComponent(entity); - auto& transform = manager.getComponent(entity); + auto& sprite = game.getEntityManager().getComponent(entity); + auto& transform = game.getEntityManager().getComponent(entity); Rectangle dstrect {(int) transform.getX(), (int) transform.getY(), transform.getW(), transform.getH()}; texture.blit(sprite.getTexture(), sprite.getFrameRect(), dstrect); diff --git a/src/systems/rendering.h b/src/systems/rendering.h index 80ea79e..9b6e27e 100644 --- a/src/systems/rendering.h +++ b/src/systems/rendering.h @@ -7,7 +7,10 @@ class RenderingSystem : public System { public: - void tick(EntityManager& manager, float dt); + RenderingSystem(Game& game) + : System(game) {} + + void tick(double dt); private: Texture texture {GAME_WIDTH, GAME_HEIGHT}; -- cgit 1.4.1