Properly bind the player to the level.

include/danmaku/level.hpp

@@ -28,6 +28,7 @@ namespace danmaku {
     void update(float delta) override;
     void render(graphics::renderer & renderer) override;
 
+    void set_player(player * p) { player_ = p; }
     void add_bullet(bullet b);
 
   public:

src/level.cxx

@@ -16,39 +16,53 @@
 #include "danmaku/serial.hpp"
 #include "game/graphics/renderer.hpp"
 #include "game/math/common.hpp"
+#include "game/util/env.hpp"
 #include "resource_factory/prototype_factory.hpp"
 
 using namespace danmaku;
 
-std::vector<std::unique_ptr<actor>>
-get_wave(Json::Value const & json, graphics::manager const & manager) {
-  std::vector<std::unique_ptr<actor>> out;
-  for (int i = 0; i < json.size(); ++i) {
-    out.emplace_back(to_actor(json, manager));
+struct wave_helper {
+  using wave_t = std::vector<std::unique_ptr<actor>>;
+
+  wave_t get_wave(Json::Value const & json) {
+    wave_t out;
+    for (int i = 0; i < json.size(); ++i) {
+      std::string file = mappings[json[i]["id"].asString()].asString();
+      std::string path = env::resource_file("scripts/entity/" + file);
+      Json::Value actor = engine::read_file(path);
+      actor["position"] = json[i]["position"];
+      out.emplace_back(to_actor(actor, manager));
+    }
+    return out;
   }
-  return out;
-}
 
-std::deque<std::vector<std::unique_ptr<actor>>>
-get_waves(Json::Value const & json, graphics::manager const & manager) {
-  std::deque<std::vector<std::unique_ptr<actor>>> out;
-  for (int i = 0; i < json.size(); ++i) {
-    out.emplace_back(get_wave(json[i], manager));
+  std::deque<wave_t> operator()() {
+    std::deque<wave_t> out;
+    for (int i = 0; i < waves.size(); ++i) {
+      out.emplace_back(get_wave(waves[i]));
+    }
+    return out;
   }
-  return out;
-}
+
+  wave_helper(Json::Value const & json, graphics::manager const & mgr)
+      : waves(json["waves"]), mappings(json["mappings"]), manager(mgr) {}
+
+  Json::Value const & waves;
+  Json::Value const & mappings;
+  graphics::manager const & manager;
+};
 
 level::level(Json::Value const & json,
              std::shared_ptr<engine::game_dispatch> dispatch)
     : engine::scene(json["id"].asString(), dispatch),
       player_(), wave_timer_{json["timeBetweenWaves"].asFloat()},
-      waves_(get_waves(json["waves"], graphics_manager())) {}
+      waves_(wave_helper{json, graphics_manager()}()) {}
 
 level::level(std::string const & id, Json::Value const & json,
              std::shared_ptr<engine::game_dispatch> dispatch)
     : engine::scene(id, dispatch),
       player_(), wave_timer_{json["timeBetweenWaves"].asFloat()},
-      waves_(get_waves(json["waves"], graphics_manager())) {}
+      waves_(wave_helper{json, graphics_manager()}()) {}
 
 level::~level() {}
 
@@ -60,6 +74,7 @@ void level::add_bullet(bullet b) {
 
 void level::update(float delta) {
   update_waves(delta);
+  player_->update(delta);
   for (auto & a : actors_) {
     a->update(delta);
   }
@@ -79,6 +94,7 @@ void level::update(float delta) {
 void level::update_waves(float delta) {
   if (waves_.empty()) { return; }
   if ((wave_timer_.remainder -= delta) <= 0.f) {
+    wave_timer_.remainder = wave_timer_.interval;
     for (auto & actor : waves_.front()) {
       actor->level(this);
       actors_.emplace_back(std::move(actor));
@@ -88,6 +104,7 @@ void level::update_waves(float delta) {
 }
 
 void level::render(graphics::renderer & renderer) {
+  renderer.draw(player_->render_info());
   for (auto & a : actors_) {
     renderer.draw(a->render_info());
   }

src/world.cxx

@@ -34,18 +34,27 @@ world::world(std::shared_ptr<engine::game_dispatch> game,
              std::unique_ptr<player> player,
              std::vector<std::shared_ptr<level>> levels)
     : engine::scene("world", game), player_(std::move(player)),
-      levels_(levels) {}
+      levels_(levels) {
+  for (auto & l : levels_) {
+    l->set_player(player_.get());
+    game->register_scene(l);
+  }
+}
 
 world::~world() {}
 
 std::shared_ptr<world>
 world::load_world(std::string const & path,
                   std::shared_ptr<engine::game_dispatch> game) {
-  std::string const directory = path.substr(0, path.find_last_of('/') + 1);
-  Json::Value const json = engine::read_file(env::resource_file(path));
-  return std::make_shared<world>(
+  std::string const absolute = env::resource_file(path);
+  std::string const directory =
+      absolute.substr(0, absolute.find_last_of('/') + 1);
+  Json::Value const json = engine::read_file(absolute);
+  auto out = std::make_shared<world>(
       game, to_player(player_json("player.json"), game->graphics_manager()),
       to_vector(json["levels"], level_from_path, directory, game));
+  game->register_scene(out);
+  return out;
 }
 
 // to_vector(Json::Value const &, ...)