Improve Lighthouse

- Add visibility radius in which enemies are revealed
- Lighthouse takes damage with enemy contact
- Stop game when Lighthouse HP reaches 0
- Add Health text

Author: NikolaJelic

src/enemy.cpp

@@ -19,7 +19,7 @@ Enemy::Enemy(gsl::not_null<le::ServiceLocator const*> services, EnemyParams cons
 }
 
 void Enemy::render(le::Renderer& renderer) const {
-	if (m_can_render) { m_sprite.draw(renderer); }
+	if (can_render) { m_sprite.draw(renderer); }
 }
 
 void Enemy::translate(kvf::Seconds const dt) {
@@ -30,7 +30,7 @@ void Enemy::translate(kvf::Seconds const dt) {
 
 std::pair<glm::vec2, float> Enemy::get_pos_diameter() const { return {m_sprite.transform.position, m_diameter}; }
 void Enemy::take_damage(std::size_t dmg) {
-	m_can_render = true;
+	can_render = true;
 	m_health = (dmg >= m_health) ? 0 : (m_health - dmg);
 }
 

src/enemy.hpp

@@ -22,7 +22,7 @@ class Enemy {
 	void take_damage(std::size_t dmg);
 	[[nodiscard]] std::size_t get_health() const { return m_health; }
 	[[nodiscard]] std::pair<glm::vec2, float> get_pos_diameter() const;
-	bool m_can_render{false};
+	bool can_render{false};
 
   private:
 	gsl::not_null<le::ServiceLocator const*> m_services;

src/game.cpp

@@ -6,6 +6,7 @@
 #include <vector>
 #include "enemy.hpp"
 #include "enemy_params.hpp"
+#include "glm/ext/vector_float2.hpp"
 #include "kvf/time.hpp"
 #include "le2d/asset_loader.hpp"
 #include "le2d/data_loader.hpp"
@@ -22,8 +23,9 @@ Game::Game(gsl::not_null<le::ServiceLocator const*> services)
 	auto const asset_loader = le::AssetLoader{&data_loader, &context};
 	m_font = asset_loader.load_font("fonts/specialElite.ttf");
 	auto const framebuffer_size = m_services->get<le::Context>().framebuffer_size();
-
-	m_score_text.transform.position.y = static_cast<float>(framebuffer_size.y) / 2.0f - 50.0f;
+	auto const y = (static_cast<float>(framebuffer_size.y) / 2.0f) - 50.0f;
+	m_score_text.transform.position.y = y;
+	m_health_text.transform.position = glm::vec2{(static_cast<float>(framebuffer_size.y) / 2.0f) - 50.0f, y};
 }
 
 void Game::on_cursor_pos(le::event::CursorPos const& cursor_pos) {
@@ -32,19 +34,24 @@ void Game::on_cursor_pos(le::event::CursorPos const& cursor_pos) {
 }
 
 void Game::tick([[maybe_unused]] kvf::Seconds const dt) {
+	m_running = m_lighthouse.get_health() > 0;
 	if (!m_running) { return; }
+
 	m_time_since_last_wave_spawn += dt;
 	if (m_time_since_last_wave_spawn >= m_wave_interval) {
 		spawn_wave();
 		m_time_since_last_wave_spawn = kvf::Seconds{};
 	}
 	for (auto& enemy : m_enemies) {
 		m_light.check_enemy_collision(enemy);
+		m_lighthouse.check_visibility_range(enemy);
+		set_health_text();
 		enemy.translate(dt);
 	}
 	// Keep track of how many enemies were defeated and calculate score
 	auto res = std::erase_if(m_enemies, [](Enemy const& enemy) { return !enemy.get_health(); });
 	increase_score(res * 10);
+
 	m_light.set_position(m_cursor_pos);
 	m_lighthouse.rotate_towards_cursor(m_cursor_pos);
 }
@@ -54,6 +61,7 @@ void Game::render(le::Renderer& renderer) const {
 	m_lighthouse.render(renderer);
 	for (auto const& enemy : m_enemies) { enemy.render(renderer); }
 	m_score_text.draw(renderer);
+	m_health_text.draw(renderer);
 }
 
 void Game::spawn_wave() {
@@ -72,4 +80,11 @@ void Game::increase_score(std::size_t points) {
 	m_score += points;
 	m_score_text.set_string(m_font, "Score: " + std::to_string(m_score));
 }
+
+void Game::set_health_text() {
+	float const health = m_lighthouse.get_health();
+	std::string text = health > 0 ? "Health: " + std::format("{:.1f}", health) : "Game Over";
+	m_health_text.set_string(m_font, text);
+}
+
 } // namespace miracle

src/game.hpp

@@ -21,7 +21,7 @@ class Game {
 	void tick(kvf::Seconds dt);
 	void render(le::Renderer& renderer) const;
 	void increase_score(std::size_t points);
-	[[nodiscard]] std::string get_score_string() const;
+	void set_health_text();
 	void spawn_wave();
 
   private:
@@ -31,6 +31,8 @@ class Game {
 
 	le::Font m_font{};
 	le::drawable::Text m_score_text{};
+	le::drawable::Text m_health_text{};
+
 	glm::vec2 m_cursor_pos{};
 	std::size_t m_wave_count{};
 	bool m_running{true};

src/lighhouse.hpp

@@ -6,7 +6,9 @@
 #include <le2d/event.hpp>
 #include <le2d/renderer.hpp>
 #include <le2d/service_locator.hpp>
+#include <cstddef>
 #include <optional>
+#include "enemy.hpp"
 #include "le2d/texture.hpp"
 
 namespace miracle {
@@ -16,10 +18,17 @@ class Lighthouse {
 
 	void rotate_towards_cursor(glm::vec2 cursor_pos);
 	void render(le::Renderer& renderer) const;
+	void check_visibility_range(Enemy& enemy);
+	void check_damage_taken(Enemy& enemy);
+	void take_damage(float dmg);
+	[[nodiscard]] float get_health() const;
 
   private:
 	gsl::not_null<le::ServiceLocator const*> m_services;
+	float m_hitbog_diameter{150.0f};
+	float m_visibility_diameter{250.0f};
 	std::optional<le::Texture> m_texture;
 	le::drawable::Circle m_sprite{};
+	float m_health{100};
 };
 } // namespace miracle

src/light.cpp

@@ -9,7 +9,7 @@ void Light::check_enemy_collision(Enemy& enemy) {
 	if (glm::distance(pos, m_sprite.transform.position) < (diameter + m_diameter)) {
 		enemy.take_damage(1);
 	} else {
-		enemy.m_can_render = false;
+		enemy.can_render = false;
 	}
 }
 void Light::render(le::Renderer& renderer) const { m_sprite.draw(renderer); }

src/lighthouse.cpp

@@ -1,10 +1,12 @@
 #include <lighhouse.hpp>
+#include <cstddef>
+#include "glm/geometric.hpp"
 #include "le2d/asset_loader.hpp"
 #include "le2d/data_loader.hpp"
 
 namespace miracle {
 Lighthouse::Lighthouse(gsl::not_null<le::ServiceLocator const*> services) : m_services(services) {
-	m_sprite.create(200.0f);
+	m_sprite.create(m_hitbog_diameter);
 	auto const& data_loader = services->get<le::IDataLoader>();
 	auto const& context = services->get<le::Context>();
 	auto const asset_loader = le::AssetLoader{&data_loader, &context};
@@ -23,6 +25,23 @@ void Lighthouse::rotate_towards_cursor(glm::vec2 cursor_pos) {
 		m_sprite.transform.orientation = cursor_pos.x > 0.0f ? -angle : angle;
 	}
 }
+void Lighthouse::check_visibility_range(Enemy& enemy) {
+	auto [enemy_pos, enemy_diameter] = enemy.get_pos_diameter();
+	if (glm::distance(m_sprite.transform.position, enemy_pos) < (m_visibility_diameter + enemy_diameter) / 2.0f) {
+		enemy.can_render = true;
+		// No need to check for damage taken if enemy isn't already in visibility radius
+		check_damage_taken(enemy);
+	}
+}
+void Lighthouse::check_damage_taken(Enemy& enemy) {
+	auto [enemy_pos, enemy_diameter] = enemy.get_pos_diameter();
+	if (glm::distance(m_sprite.transform.position, enemy_pos) < (m_hitbog_diameter + enemy_diameter) / 2.0f) {
+		take_damage(enemy_diameter / 200);
+	} // magic numbers
+}
+
+void Lighthouse::take_damage(float dmg) { m_health -= dmg; }
 
+float Lighthouse::get_health() const { return m_health; }
 void Lighthouse::render(le::Renderer& renderer) const { m_sprite.draw(renderer); }
 } // namespace miracle