Merge pull request #7 from hatkirby/es-rewrite

The ECS rewrite exceeds the original branch in functionality, so it is time to merge it in.

1 files changed, 50 insertions, 150 deletions

@@ -1,178 +1,78 @@
 #include "game.h"
-#include <cstdlib>
-#include "renderer.h"
-#include "muxer.h"
-#include "map.h"
-#include "components/user_movement.h"
-#include "components/player_physics.h"
-#include "components/player_sprite.h"
-#include "components/map_render.h"
-#include "components/map_collision.h"
+#include "systems/controlling.h"
+#include "systems/pondering.h"
+#include "systems/animating.h"
+#include "systems/mapping.h"
+#include "systems/orienting.h"
+#include "systems/playing.h"
+#include "systems/scheduling.h"
+#include "systems/realizing.h"
+#include "systems/scripting.h"
 #include "consts.h"
 
-Game::Game(const char* mapfile) : world(mapfile)
-{ 
-  // Set up entities
-  player = std::make_shared<Entity>();
-  player->position = world.getStartingPosition();
-  player->size = std::make_pair(10.0,12.0);
-  
-  auto player_input = std::make_shared<UserMovementComponent>();
-  player->addComponent(player_input);
-  
-  auto player_physics = std::make_shared<PlayerPhysicsComponent>();
-  player->addComponent(player_physics);
-  
-  auto player_anim = std::make_shared<PlayerSpriteComponent>();
-  player->addComponent(player_anim);
-  
-  const Map& startingMap = world.getStartingMap();
-  save = {&startingMap, player->position};
-  
-  loadMap(startingMap, player->position);
-}
-
 void key_callback(GLFWwindow* window, int key, int, int action, int)
 {
-  Game* game = (Game*) glfwGetWindowUserPointer(window);
-  
-  if ((key == GLFW_KEY_ESCAPE) && (action == GLFW_PRESS))
-  {
-    game->shouldQuit = true;
-  }
-  
-  for (auto entity : game->entities)
+  Game& game = *static_cast<Game*>(glfwGetWindowUserPointer(window));
+
+  if ((action == GLFW_PRESS) && (key == GLFW_KEY_ESCAPE))
   {
-    entity->input(*game, key, action);
+    game.shouldQuit_ = true;
+
+    return;
   }
+
+  game.systemManager_.input(key, action);
 }
 
-void Game::execute(GLFWwindow* window)
+Game::Game(std::mt19937& rng) : rng_(rng)
 {
+  systemManager_.emplaceSystem<PlayingSystem>(*this);
+  systemManager_.emplaceSystem<SchedulingSystem>(*this);
+  systemManager_.emplaceSystem<ControllingSystem>(*this);
+  systemManager_.emplaceSystem<ScriptingSystem>(*this);
+  systemManager_.emplaceSystem<OrientingSystem>(*this);
+  systemManager_.emplaceSystem<PonderingSystem>(*this);
+  systemManager_.emplaceSystem<MappingSystem>(*this);
+  systemManager_.emplaceSystem<AnimatingSystem>(*this);
+
+  systemManager_.emplaceSystem<RealizingSystem>(*this,
+    "res/maps.xml",
+    "res/entities.xml");
+
+  systemManager_.getSystem<PlayingSystem>().initPlayer();
+
   glfwSwapInterval(1);
-  glfwSetWindowUserPointer(window, this);
-  glfwSetKeyCallback(window, key_callback);
-  
-  Texture buffer(GAME_WIDTH, GAME_HEIGHT);
+  glfwSetWindowUserPointer(renderer_.getWindow().getHandle(), this);
+  glfwSetKeyCallback(renderer_.getWindow().getHandle(), key_callback);
+}
 
+void Game::execute()
+{
   double lastTime = glfwGetTime();
   const double dt = 0.01;
   double accumulator = 0.0;
-  
-  while (!(shouldQuit || glfwWindowShouldClose(window)))
+  Texture texture(GAME_WIDTH, GAME_HEIGHT);
+
+  while (!(shouldQuit_ ||
+    glfwWindowShouldClose(renderer_.getWindow().getHandle())))
   {
     double currentTime = glfwGetTime();
     double frameTime = currentTime - lastTime;
     lastTime = currentTime;
-    
-    // Should we load a new world?
-    if (newWorld)
-    {
-      newWorld = false;
-      entities.clear();
-      entities = std::move(nextEntities);
-      
-      player->position = nextPosition;
-    }
-    
-    // Handle input
+
     glfwPollEvents();
-    
-    // Tick!
+
     accumulator += frameTime;
     while (accumulator >= dt)
     {
-      for (auto entity : entities)
-      {
-        entity->tick(*this, dt);
-      }
-      
+      systemManager_.tick(dt);
+
       accumulator -= dt;
     }
-    
-    // Do any scheduled tasks
-    for (auto& task : scheduled)
-    {
-      task.first -= frameTime;
-      
-      if (task.first <= 0)
-      {
-        task.second();
-      }
-    }
-    
-    scheduled.remove_if([] (std::pair<double, std::function<void ()>> value) { return value.first <= 0; });
-  
-    // Do rendering
-    buffer.fill(buffer.entirety(), 0, 0, 0);
-    for (auto entity : entities)
-    {
-      entity->render(*this, buffer);
-    }
 
-    buffer.renderScreen();
+    // Render
+    renderer_.fill(texture, texture.entirety(), 0, 0, 0);
+    systemManager_.render(texture);
+    renderer_.renderScreen(texture);
   }
 }
-
-void Game::loadMap(const Map& map, std::pair<double, double> position)
-{
-  auto mapEn = std::make_shared<Entity>();
-  
-  auto map_render = std::make_shared<MapRenderComponent>(map);
-  mapEn->addComponent(map_render);
-  
-  auto map_collision = std::make_shared<MapCollisionComponent>(map);
-  mapEn->addComponent(map_collision);
-  
-  // Map in the back, player on top, rest of entities in between
-  nextEntities.clear();
-  nextEntities.push_back(mapEn);
-  map.createEntities(nextEntities);
-  nextEntities.push_back(player);
-  
-  newWorld = true;
-  
-  currentMap = &map;
-  nextPosition = position;
-}
-
-void Game::detectCollision(Entity& collider, std::pair<double, double> old_position)
-{
-  for (auto entity : entities)
-  {
-    entity->detectCollision(*this, collider, old_position);
-  }
-}
-
-void Game::saveGame()
-{
-  save = {currentMap, player->position};
-}
-
-void Game::schedule(double time, std::function<void ()> callback)
-{
-  scheduled.emplace_front(time, std::move(callback));
-}
-
-void Game::playerDie()
-{
-  player->send(*this, Message::Type::die);
-  
-  playSound("res/Hit_Hurt5.wav", 0.25);
-  
-  schedule(0.75, [&] () {
-    if (*currentMap != *save.map)
-    {
-      loadMap(*save.map, save.position);
-    } else {
-      player->position = save.position;
-    }
-    
-    player->send(*this, Message::Type::stopDying);
-  });
-}
-
-const World& Game::getWorld() const
-{
-  return world;
-}