const-correct for graphics::manager.

Add some wave data to levels.

include/danmaku/actor.hpp

@@ -15,6 +15,7 @@ namespace danmaku {
   struct actor : public engine::entity {
     virtual ~actor() = default;
     virtual void update(float delta) = 0;
-    virtual std::shared_ptr<class level> level() const = 0;
+    virtual void level(class level *) = 0;
+    virtual class level * level() const = 0;
   };
 }

include/danmaku/bullet_pattern.hpp

@@ -34,7 +34,8 @@ namespace danmaku {
 
   using bullet_pattern_factory =
       objects::prototype::factory<std::shared_ptr<bullet_pattern>, actor *,
-                                  Json::Value const &, graphics::manager &>;
+                                  Json::Value const &,
+                                  graphics::manager const &>;
 }
 
 #define BIND_BULLET_PATTERN(name, function)                                    \

include/danmaku/level.hpp

@@ -10,22 +10,36 @@
 
 #include "game/engine/scene.hpp"
 
+#include <deque>
+#include <json/forwards.h>
+#include <memory>
+#include <vector>
+
 namespace danmaku {
   class actor;
   class bullet;
   class player;
   class level : public engine::scene {
   public:
-    level();
+    level(Json::Value const & json, std::shared_ptr<engine::game_dispatch>);
     ~level();
     void update(float delta) override;
     void render(graphics::renderer & renderer) override;
 
     void add_bullet(bullet b);
 
+  public:
+    void update_waves(float delta);
+
   private:
     player * player_;
     std::vector<std::unique_ptr<actor>> actors_;
     std::vector<std::unique_ptr<bullet>> bullets_;
+
+    struct {
+      float const interval;
+      float remainder{0.f};
+    } wave_timer_;
+    std::deque<std::vector<std::unique_ptr<actor>>> waves_;
   };
 }

include/danmaku/player.hpp

@@ -16,6 +16,7 @@ namespace danmaku {
   public:
     void hit(bullet const & b);
     void update(float delta) override;
-    std::shared_ptr<class level> level() const override;
+    void level(class level *) override;
+    class level * level() const override;
   };
 }

src/level.cxx

@@ -8,6 +8,8 @@
 
 #include "danmaku/level.hpp"
 
+#include <json/json.h>
+
 #include "danmaku/actor.hpp"
 #include "danmaku/bullet.hpp"
 #include "danmaku/player.hpp"
@@ -16,7 +18,30 @@
 
 using namespace danmaku;
 
-level::level() : engine::scene(""), player_() {}
+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) {
+    // TODO
+    out.emplace_back(nullptr);
+  }
+  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));
+  }
+  return out;
+}
+
+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())) {}
 
 level::~level() {}
 
@@ -26,6 +51,7 @@ void level::add_bullet(bullet b) {
 }
 
 void level::update(float delta) {
+
   for (auto & a : actors_) {
     a->update(delta);
   }
@@ -41,6 +67,17 @@ void level::update(float delta) {
   }
 }
 
+void level::update_waves(float delta) {
+  if (waves_.empty()) { return; }
+  if ((wave_timer_.remainder -= delta) <= 0.f) {
+    for (auto & actor : waves_.front()) {
+      actor->level(this);
+      actors_.emplace_back(std::move(actor));
+    }
+    waves_.pop_front();
+  }
+}
+
 void level::render(graphics::renderer & renderer) {
   for (auto & a : actors_) {
     renderer.draw(a->render_info());

src/pattern/burstshot_pattern.cxx

@@ -25,7 +25,7 @@ using shot = std::pair<math::vec2, float>;
 
 struct burstshot : public danmaku::bullet_pattern {
   static std::shared_ptr<burstshot>
-  create(danmaku::actor *, Json::Value const &, graphics::manager &);
+  create(danmaku::actor *, Json::Value const &, graphics::manager const &);
 
   burstshot(danmaku::actor *, float shot_interval, std::vector<shot> shots,
             bullet bullet);
@@ -64,13 +64,14 @@ burstshot::burstshot(danmaku::actor * actor, float shot_interval,
     : actor(actor), shot_timer{shot_interval}, shots(shots), bullet_proto(blt) {
 }
 
-bullet make_bullet(Json::Value const & json, graphics::manager & manager) {
+bullet make_bullet(Json::Value const & json,
+                   graphics::manager const & manager) {
   return bullet(json["damage"].asInt(), {}, engine::to_object(json, manager));
 }
 
-std::shared_ptr<burstshot> burstshot::create(danmaku::actor * actor,
-                                             Json::Value const & json,
-                                             graphics::manager & manager) {
+std::shared_ptr<burstshot>
+burstshot::create(danmaku::actor * actor, Json::Value const & json,
+                  graphics::manager const & manager) {
   return std::make_shared<burstshot>(
       actor, json["timeBetweenBullets"].asFloat(),
       shot_vector(json["bulletsPerWave"].asUInt(),