Add powerups and their probabilistic spawning. (#27)

* Setup powerup framework.

* Add `EnemyDeathListener`.

This consolidates death events from multiple sources (`EnemySpawner`s) into a single sink (`World`), which can then decide whether to spawn a powerup there.

* Cleanup.

Author: karnkaul

src/spaced/spaced/game/enemies/basic_creep_factory.cpp

@@ -12,15 +12,15 @@ using bave::ParticleEmitter;
 using bave::random_in_range;
 using bave::Seconds;
 
-BasicCreepFactory::BasicCreepFactory(NotNull<Services const*> services, NotNull<IScorer*> scorer, dj::Json const& json)
-	: m_services(services), m_scorer(scorer) {
+BasicCreepFactory::BasicCreepFactory(NotNull<Services const*> services, NotNull<IEnemyDeathListener*> listener, dj::Json const& json)
+	: m_services(services), m_listener(listener) {
 	for (auto const& tint : json["tints"].array_view()) { tints.push_back(tint.as<std::string>()); }
 	if (auto const in_death_emitter = services->get<Resources>().get<ParticleEmitter>(json["death_emitter"].as_string())) { death_emitter = *in_death_emitter; }
 	spawn_rate = Seconds{json["spawn_rate"].as<float>(spawn_rate.count())};
 }
 
 auto BasicCreepFactory::spawn_enemy() -> std::unique_ptr<Enemy> {
-	auto ret = std::make_unique<Creep>(*m_services, m_scorer);
+	auto ret = std::make_unique<Creep>(*m_services, m_listener);
 	if (!tints.empty()) {
 		auto const& rgbas = m_services->get<Styles>().rgbas;
 		auto const tint_index = random_in_range(std::size_t{}, tints.size() - 1);

src/spaced/spaced/game/enemies/basic_creep_factory.hpp

@@ -7,7 +7,7 @@ class BasicCreepFactory : public IEnemyFactory {
   public:
 	static constexpr std::string_view type_v{"BasicCreepFactory"};
 
-	explicit BasicCreepFactory(bave::NotNull<Services const*> services, bave::NotNull<IScorer*> scorer, dj::Json const& json);
+	explicit BasicCreepFactory(bave::NotNull<Services const*> services, bave::NotNull<IEnemyDeathListener*> listener, dj::Json const& json);
 
 	[[nodiscard]] auto get_type_name() const -> std::string_view final { return type_v; }
 	[[nodiscard]] auto spawn_enemy() -> std::unique_ptr<Enemy> final;
@@ -23,7 +23,7 @@ class BasicCreepFactory : public IEnemyFactory {
 	void do_inspect() final;
 
 	bave::NotNull<Services const*> m_services;
-	bave::NotNull<IScorer*> m_scorer;
+	bave::NotNull<IEnemyDeathListener*> m_listener;
 	bave::Seconds m_elapsed{};
 };
 } // namespace spaced

src/spaced/spaced/game/enemies/creep.hpp

@@ -4,7 +4,7 @@
 namespace spaced {
 class Creep : public Enemy {
   public:
-	explicit Creep(Services const& services, bave::NotNull<IScorer*> scorer) : Enemy(services, scorer, "Creep") {}
+	explicit Creep(Services const& services, bave::NotNull<IEnemyDeathListener*> listener) : Enemy(services, listener, "Creep") {}
 
 	void tick(bave::Seconds dt) override;
 

src/spaced/spaced/game/enemy.cpp

@@ -7,8 +7,8 @@ using bave::im_text;
 using bave::random_in_range;
 using bave::RoundedQuad;
 
-Enemy::Enemy(Services const& services, bave::NotNull<IScorer*> scorer, std::string_view const type)
-	: m_layout(&services.get<ILayout>()), m_scorer(scorer), m_type(type) {
+Enemy::Enemy(Services const& services, bave::NotNull<IEnemyDeathListener*> listener, std::string_view const type)
+	: m_layout(&services.get<ILayout>()), m_listener(listener), m_type(type) {
 	static constexpr auto init_size_v = glm::vec2{100.0f};
 	auto const play_area = m_layout->get_play_area();
 	auto const y_min = play_area.rb.y + 0.5f * init_size_v.y;
@@ -19,7 +19,7 @@ Enemy::Enemy(Services const& services, bave::NotNull<IScorer*> scorer, std::stri
 auto Enemy::take_damage(float const damage) -> bool {
 	if (is_destroyed()) { return false; }
 	health.inflict_damage(damage);
-	if (health.is_dead()) { m_scorer->add_score(points); }
+	if (health.is_dead()) { m_listener->on_death(EnemyDeath{.position = shape.transform.position, .points = points}); }
 	return true;
 }
 

src/spaced/spaced/game/enemy.hpp

@@ -3,15 +3,15 @@
 #include <bave/graphics/shape.hpp>
 #include <bave/platform.hpp>
 #include <spaced/game/damageable.hpp>
+#include <spaced/game/enemy_death.hpp>
 #include <spaced/game/health.hpp>
-#include <spaced/game/scorer.hpp>
 #include <spaced/services/layout.hpp>
 #include <spaced/services/services.hpp>
 
 namespace spaced {
 class Enemy : public IDamageable, public bave::IDrawable {
   public:
-	explicit Enemy(Services const& services, bave::NotNull<IScorer*> scorer, std::string_view type);
+	explicit Enemy(Services const& services, bave::NotNull<IEnemyDeathListener*> listener, std::string_view type);
 
 	[[nodiscard]] auto get_bounds() const -> bave::Rect<> override { return shape.get_bounds(); }
 	auto take_damage(float damage) -> bool override;
@@ -26,7 +26,7 @@ class Enemy : public IDamageable, public bave::IDrawable {
 	void setup(glm::vec2 max_size, float y_position);
 
 	[[nodiscard]] auto get_layout() const -> ILayout const& { return *m_layout; }
-	[[nodiscard]] auto get_scorer() const -> IScorer& { return *m_scorer; }
+	[[nodiscard]] auto get_death_listener() const -> IEnemyDeathListener& { return *m_listener; }
 
 	void inspect() {
 		if constexpr (bave::debug_v) { do_inspect(); }
@@ -40,7 +40,7 @@ class Enemy : public IDamageable, public bave::IDrawable {
 	virtual void do_inspect();
 
 	bave::NotNull<ILayout const*> m_layout;
-	bave::NotNull<IScorer*> m_scorer;
+	bave::NotNull<IEnemyDeathListener*> m_listener;
 	std::string_view m_type{};
 	bool m_destroyed{};
 };

src/spaced/spaced/game/enemy_death.hpp

@@ -0,0 +1,16 @@
+#pragma once
+#include <bave/core/polymorphic.hpp>
+#include <glm/vec2.hpp>
+#include <cstdint>
+
+namespace spaced {
+struct EnemyDeath {
+	glm::vec2 position{};
+	std::int64_t points{};
+};
+
+class IEnemyDeathListener : public bave::Polymorphic {
+  public:
+	virtual void on_death(EnemyDeath const& death) = 0;
+};
+} // namespace spaced

src/spaced/spaced/game/enemy_factory_builder.cpp

@@ -4,18 +4,19 @@
 namespace spaced {
 using bave::NotNull;
 
-EnemyFactoryBuilder::EnemyFactoryBuilder(NotNull<Services const*> services, NotNull<IScorer*> scorer) : m_services(services), m_scorer(scorer) {}
+EnemyFactoryBuilder::EnemyFactoryBuilder(NotNull<Services const*> services, NotNull<IEnemyDeathListener*> listener)
+	: m_services(services), m_listener(listener) {}
 
 auto EnemyFactoryBuilder::build(dj::Json const& json) const -> std::unique_ptr<IEnemyFactory> {
 	auto const type_name = json["type_name"].as_string();
 
-	if (type_name == BasicCreepFactory::type_v) { return std::make_unique<BasicCreepFactory>(m_services, m_scorer, json); }
+	if (type_name == BasicCreepFactory::type_v) { return std::make_unique<BasicCreepFactory>(m_services, m_listener, json); }
 
 	return build_default();
 }
 
 auto EnemyFactoryBuilder::build_default() const -> std::unique_ptr<IEnemyFactory> {
-	auto ret = std::make_unique<BasicCreepFactory>(m_services, m_scorer, dj::Json{});
+	auto ret = std::make_unique<BasicCreepFactory>(m_services, m_listener, dj::Json{});
 	ret->tints = {"orange", "milk"};
 	return ret;
 }

src/spaced/spaced/game/enemy_factory_builder.hpp

@@ -5,14 +5,14 @@
 namespace spaced {
 class EnemyFactoryBuilder {
   public:
-	explicit EnemyFactoryBuilder(bave::NotNull<Services const*> services, bave::NotNull<IScorer*> scorer);
+	explicit EnemyFactoryBuilder(bave::NotNull<Services const*> services, bave::NotNull<IEnemyDeathListener*> listener);
 
 	[[nodiscard]] auto build(dj::Json const& json) const -> std::unique_ptr<IEnemyFactory>;
 
 	[[nodiscard]] auto build_default() const -> std::unique_ptr<IEnemyFactory>;
 
   private:
 	bave::NotNull<Services const*> m_services;
-	bave::NotNull<IScorer*> m_scorer;
+	bave::NotNull<IEnemyDeathListener*> m_listener;
 };
 } // namespace spaced

src/spaced/spaced/game/player.cpp

@@ -9,8 +9,6 @@
 #include <spaced/game/weapons/gun_beam.hpp>
 
 namespace spaced {
-using bave::im_text;
-using bave::NotNull;
 using bave::ParticleEmitter;
 using bave::PointerMove;
 using bave::PointerTap;
@@ -26,15 +24,19 @@ void Player::on_move(PointerMove const& pointer_move) { m_controller->on_move(po
 
 void Player::on_tap(PointerTap const& pointer_tap) { m_controller->on_tap(pointer_tap); }
 
-void Player::tick(std::span<NotNull<IDamageable*> const> targets, Seconds const dt) {
+void Player::tick(State const& state, Seconds const dt) {
 	auto const y_position = m_controller->tick(dt);
 	set_y(y_position);
 
-	auto const round_state = IWeaponRound::State{.targets = targets, .muzzle_position = get_muzzle_position()};
+	auto const round_state = IWeaponRound::State{.targets = state.targets, .muzzle_position = get_muzzle_position()};
 	m_arsenal.tick(round_state, m_controller->is_firing(), dt);
 
 	m_exhaust.set_position(get_exhaust_position());
 	m_exhaust.tick(dt);
+
+	for (auto const& powerup : state.powerups) {
+		if (is_intersecting(powerup->get_bounds(), ship.get_bounds())) { powerup->activate(*this); }
+	}
 }
 
 void Player::draw(Shader& shader) const {

src/spaced/spaced/game/player.hpp

@@ -5,18 +5,24 @@
 #include <spaced/game/arsenal.hpp>
 #include <spaced/game/controller.hpp>
 #include <spaced/game/health.hpp>
+#include <spaced/game/powerup.hpp>
 #include <spaced/game/world_spec.hpp>
 
 namespace spaced {
 class Player : public bave::IDrawable {
   public:
+	struct State {
+		std::span<bave::NotNull<IDamageable*> const> targets{};
+		std::span<bave::NotNull<IPowerup*> const> powerups{};
+	};
+
 	explicit Player(Services const& services, std::unique_ptr<IController> controller);
 
 	void on_focus(bave::FocusChange const& focus_change);
 	void on_move(bave::PointerMove const& pointer_move);
 	void on_tap(bave::PointerTap const& pointer_tap);
 
-	void tick(std::span<bave::NotNull<IDamageable*> const> targets, bave::Seconds dt);
+	void tick(State const& state, bave::Seconds dt);
 	void draw(bave::Shader& shader) const final;
 
 	void setup(WorldSpec::Player const& spec);

src/spaced/spaced/game/powerup.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <bave/core/polymorphic.hpp>
+#include <bave/core/time.hpp>
+#include <bave/graphics/drawable.hpp>
+#include <bave/graphics/rect.hpp>
+
+namespace spaced {
+class Player;
+
+class IPowerup : public bave::IDrawable {
+  public:
+	[[nodiscard]] virtual auto get_bounds() const -> bave::Rect<> = 0;
+	virtual void activate(Player& player) = 0;
+
+	[[nodiscard]] virtual auto is_destroyed() const -> bool = 0;
+
+	virtual void tick(bave::Seconds dt) = 0;
+};
+} // namespace spaced

src/spaced/spaced/game/powerups/pu_base.cpp

@@ -0,0 +1,24 @@
+#include <spaced/game/powerups/pu_base.hpp>
+
+namespace spaced {
+using bave::Circle;
+using bave::Seconds;
+using bave::Shader;
+
+PUBase::PUBase(Services const& services, std::string_view const name) : m_services(&services), m_layout(&services.get<ILayout>()), m_name(name) {
+	auto circle = Circle{.diameter = 50.0f};
+	shape.set_shape(circle);
+}
+
+void PUBase::tick(Seconds const dt) {
+	shape.transform.position.x -= speed * dt.count();
+	if (shape.transform.position.x < m_layout->get_play_area().lt.x - 0.5f * shape.get_shape().diameter) { m_destroyed = true; }
+}
+
+void PUBase::draw(Shader& shader) const { shape.draw(shader); }
+
+void PUBase::activate(Player& player) {
+	do_activate(player);
+	m_destroyed = true;
+}
+} // namespace spaced

src/spaced/spaced/game/powerups/pu_base.hpp

@@ -0,0 +1,32 @@
+#pragma once
+#include <bave/core/time.hpp>
+#include <bave/graphics/shape.hpp>
+#include <spaced/game/powerup.hpp>
+#include <spaced/services/layout.hpp>
+#include <spaced/services/services.hpp>
+
+namespace spaced {
+class PUBase : public IPowerup {
+  public:
+	explicit PUBase(Services const& services, std::string_view name);
+
+	void tick(bave::Seconds dt) final;
+	void draw(bave::Shader& shader) const final;
+
+	[[nodiscard]] auto get_bounds() const -> bave::Rect<> final { return shape.get_bounds(); }
+	void activate(Player& player) final;
+
+	[[nodiscard]] auto is_destroyed() const -> bool final { return m_destroyed; }
+
+	float speed{300.0f};
+	bave::CircleShape shape{};
+
+  protected:
+	virtual void do_activate(Player& player) = 0;
+
+	bave::NotNull<Services const*> m_services;
+	bave::NotNull<ILayout const*> m_layout;
+	std::string_view m_name{};
+	bool m_destroyed{};
+};
+} // namespace spaced

src/spaced/spaced/game/powerups/pu_beam.cpp

@@ -0,0 +1,14 @@
+#include <spaced/game/player.hpp>
+#include <spaced/game/powerups/pu_beam.hpp>
+#include <spaced/game/weapons/gun_beam.hpp>
+#include <spaced/services/styles.hpp>
+
+namespace spaced {
+PUBeam::PUBeam(Services const& services, int rounds) : PUBase(services, "Beam"), m_rounds(rounds) { shape.tint = services.get<Styles>().rgbas["gun_beam"]; }
+
+void PUBeam::do_activate(Player& player) {
+	auto beam = std::make_unique<GunBeam>(*m_services);
+	beam->rounds = m_rounds;
+	player.set_special_weapon(std::move(beam));
+}
+} // namespace spaced

src/spaced/spaced/game/powerups/pu_beam.hpp

@@ -0,0 +1,14 @@
+#pragma once
+#include <spaced/game/powerups/pu_base.hpp>
+
+namespace spaced {
+class PUBeam : public PUBase {
+  public:
+	explicit PUBeam(Services const& services, int rounds = 2);
+
+  private:
+	void do_activate(Player& player) final;
+
+	int m_rounds{};
+};
+} // namespace spaced

src/spaced/spaced/game/weapons/gun_kinetic.hpp

@@ -8,7 +8,7 @@ class GunKinetic final : public Weapon {
 	explicit GunKinetic(Services const& services);
 
 	auto fire(glm::vec2 muzzle_position) -> std::unique_ptr<Round> final;
-	[[nodiscard]] auto is_idle() const -> bool final { return m_reload_remain >= 0s; }
+	[[nodiscard]] auto is_idle() const -> bool final { return m_reload_remain <= 0s; }
 
 	void tick(bave::Seconds dt) final;