Add Enemy health bars. (#30)

* Balance weapon damage a bit.

* Refactor progress bar.

Use rounded corners for background, shrinking quad as progress.

* Data drive creep initial health, set to 2.

* Add enemy health bars.

* Use orange RGBA for enemy health bars.

* Remove test code.

Author: karnkaul

assets/styles.json

@@ -31,10 +31,16 @@
   },
   "progress_bars": {
     "default": {
-      "background": "#ffffffff",
-      "fill": "#9f2b68ff",
-      "outline": "#702963ff",
-      "outline_width": 5
+      "background": "#9f2b68ff",
+      "fill": "#ffffffff",
+      "corner_ratio": 0.5,
+      "padding": 10
+    },
+    "enemy": {
+      "background": "#f75c03ff",
+      "fill": "#ffffffff",
+      "corner_ratio": 0.5,
+      "padding": 5
     }
   },
   "loading_screen": {
@@ -50,7 +56,7 @@
       "n_width": 0.800000,
       "height": 50.000000,
       "bottom_offset": 300.000000,
-      "outline_width": 10
+      "padding": 20
     }
   }
-}
+}

assets/worlds/playground.json

@@ -13,6 +13,7 @@
         "milk"
       ],
       "spawn_rate": 2,
+      "initial_health": 2,
       "death_emitter": "particles/explode.json"
     }
   ]

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

@@ -17,6 +17,7 @@ BasicCreepFactory::BasicCreepFactory(NotNull<Services const*> services, NotNull<
 	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())};
+	initial_health = json["initial_health"].as<float>(initial_health);
 }
 
 auto BasicCreepFactory::spawn_enemy() -> std::unique_ptr<Enemy> {
@@ -25,6 +26,7 @@ auto BasicCreepFactory::spawn_enemy() -> std::unique_ptr<Enemy> {
 		auto const& rgbas = m_services->get<Styles>().rgbas;
 		auto const tint_index = random_in_range(std::size_t{}, tints.size() - 1);
 		ret->shape.tint = rgbas[tints.at(tint_index)];
+		ret->health = initial_health;
 	}
 	return ret;
 }

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

@@ -18,6 +18,7 @@ class BasicCreepFactory : public IEnemyFactory {
 	std::vector<std::string> tints{};
 	bave::ParticleEmitter death_emitter{};
 	bave::Seconds spawn_rate{2s};
+	float initial_health{1.0f};
 
   private:
 	void do_inspect() final;

src/spaced/spaced/game/enemies/creep.cpp

@@ -4,6 +4,7 @@ namespace spaced {
 using bave::Seconds;
 
 void Creep::tick(Seconds const dt) {
+	Enemy::tick(dt);
 	shape.transform.position.x -= x_speed * dt.count();
 	if (shape.transform.position.x < -0.5f * (get_layout().get_world_space().x + shape.get_shape().size.x)) { set_destroyed(); }
 }

src/spaced/spaced/game/enemy.cpp

@@ -1,19 +1,25 @@
 #include <bave/core/random.hpp>
 #include <bave/imgui/im_text.hpp>
 #include <spaced/game/enemy.hpp>
+#include <spaced/services/services.hpp>
+#include <spaced/services/styles.hpp>
 
 namespace spaced {
 using bave::im_text;
 using bave::random_in_range;
 using bave::RoundedQuad;
+using bave::Seconds;
+using bave::Shader;
 
 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) {
+	: health_bar(services), 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;
 	auto const y_max = play_area.lt.y - 0.5f * init_size_v.y;
 	setup(init_size_v, random_in_range(y_min, y_max));
+
+	health_bar.set_style(services.get<Styles>().progress_bars["enemy"]);
 }
 
 auto Enemy::take_damage(float const damage) -> bool {
@@ -23,6 +29,19 @@ auto Enemy::take_damage(float const damage) -> bool {
 	return true;
 }
 
+void Enemy::tick(Seconds const dt) {
+	health_bar.position = shape.transform.position;
+	health_bar.position.y += 0.5f * shape.get_shape().size.y + 20.0f;
+	health_bar.size = {shape.get_shape().size.x, 10.0f};
+	health_bar.set_progress(health.get_hit_points() / health.get_total_hit_points());
+	health_bar.tick(dt);
+}
+
+void Enemy::draw(Shader& shader) const {
+	shape.draw(shader);
+	health_bar.draw(shader);
+}
+
 void Enemy::setup(glm::vec2 max_size, float y_position) {
 	auto rounded_quad = RoundedQuad{};
 	rounded_quad.size = max_size;

src/spaced/spaced/game/enemy.hpp

@@ -7,6 +7,7 @@
 #include <spaced/game/health.hpp>
 #include <spaced/services/layout.hpp>
 #include <spaced/services/services.hpp>
+#include <spaced/ui/progress_bar.hpp>
 
 namespace spaced {
 class Enemy : public IDamageable, public bave::IDrawable {
@@ -20,8 +21,8 @@ class Enemy : public IDamageable, public bave::IDrawable {
 	[[nodiscard]] auto is_destroyed() const -> bool { return is_dead() || m_destroyed; }
 	void set_destroyed() { m_destroyed = true; }
 
-	virtual void tick(bave::Seconds dt) = 0;
-	void draw(bave::Shader& shader) const override { shape.draw(shader); }
+	virtual void tick(bave::Seconds dt);
+	void draw(bave::Shader& shader) const override;
 
 	void setup(glm::vec2 max_size, float y_position);
 
@@ -33,6 +34,7 @@ class Enemy : public IDamageable, public bave::IDrawable {
 	}
 
 	bave::RoundedQuadShape shape{};
+	ui::ProgressBar health_bar;
 	Health health{};
 	std::int64_t points{10};
 

src/spaced/spaced/game/health.cpp

@@ -5,21 +5,21 @@
 #include <algorithm>
 
 namespace spaced {
-void Health::inflict_damage(float const amount) { set_hit_points(m_hit_points - amount); }
+void Health::inflict_damage(float const amount) { set_hit_points(m_current_hp - amount); }
 
-bool Health::is_dead() const { return m_hit_points <= 0.f; }
+bool Health::is_dead() const { return m_current_hp <= 0.f; }
 
-float Health::get_hit_points() const { return m_hit_points; }
+float Health::get_hit_points() const { return m_current_hp; }
 
-void Health::set_hit_points(float const hit_points) { m_hit_points = std::max(hit_points, 0.0f); }
+void Health::set_hit_points(float const hit_points) { m_current_hp = std::max(hit_points, 0.0f); }
 
 void Health::do_inspect() {
 	if constexpr (bave::imgui_v) {
 		if (ImGui::TreeNode("health")) {
-			bave::im_text("health: {:.2f}", m_hit_points);
+			bave::im_text("health: {:.2f}", m_current_hp);
 			bave::im_text("dead: {}", is_dead() ? "yes" : "no");
 			if (ImGui::Button("inflict 10 damage")) { inflict_damage(10.f); }
-			ImGui::SliderFloat("health", &m_hit_points, 0.f, 100.f, "%.2f");
+			ImGui::SliderFloat("health", &m_current_hp, 0.f, 100.f, "%.2f");
 			ImGui::TreePop();
 		}
 	}

src/spaced/spaced/game/health.hpp

@@ -6,11 +6,12 @@ class Health {
   public:
 	static constexpr auto hit_points_v{1.0f};
 
-	/*implicit*/ Health(float const hit_points = hit_points_v) : m_hit_points(hit_points) {}
+	/*implicit*/ Health(float const hit_points = hit_points_v) : m_total_hp(hit_points), m_current_hp(hit_points) {}
 
 	void inflict_damage(float amount);
 	[[nodiscard]] bool is_dead() const;
 	[[nodiscard]] float get_hit_points() const;
+	[[nodiscard]] float get_total_hit_points() const { return m_total_hp; }
 	void set_hit_points(float hit_points);
 
 	operator float() const { return get_hit_points(); }
@@ -22,6 +23,7 @@ class Health {
   private:
 	void do_inspect();
 
-	float m_hit_points{};
+	float m_total_hp{};
+	float m_current_hp{};
 };
 } // namespace spaced

src/spaced/spaced/game/weapons/gun_beam.hpp

@@ -9,7 +9,7 @@ class GunBeam final : public Weapon {
 		bave::Seconds fire_duration{2s};
 		bave::Seconds reload_delay{1s};
 		bave::Rgba beam_tint{bave::red_v};
-		float dps{1.0f};
+		float dps{10.0f};
 	};
 
 	explicit GunBeam(Services const& services);