Merge branch 'feature/actors' into nikola/lighthouse

Author: NikolaJelic

src/EnemyColliderInfo.hpp

@@ -0,0 +1,9 @@
+#pragma once
+#include <glm/vec2.hpp>
+
+namespace miracle {
+struct CollisionParams {
+	glm::vec2 pos;
+	float diameter;
+};
+} // namespace miracle

src/enemy.cpp

@@ -1,6 +1,5 @@
 #include <enemy.hpp>
 #include <algorithm>
-#include <utility>
 #include "enemy_params.hpp"
 #include "glm/geometric.hpp"
 #include "glm/vec2.hpp"
@@ -28,7 +27,7 @@ void Enemy::translate(kvf::Seconds const dt) {
 	m_sprite.transform.position += movement;
 }
 
-std::pair<glm::vec2, float> Enemy::get_pos_diameter() const { return {m_sprite.transform.position, m_diameter}; }
+CollisionParams Enemy::get_collision_params() const { return {.pos = m_sprite.transform.position, .diameter = m_diameter}; }
 void Enemy::take_damage(std::size_t dmg) {
 	can_render = true;
 	m_health = (dmg >= m_health) ? 0 : (m_health - dmg);

src/enemy.hpp

@@ -8,6 +8,7 @@
 #include <le2d/service_locator.hpp>
 #include <cstddef>
 #include <optional>
+#include "EnemyColliderInfo.hpp"
 #include "enemy_params.hpp"
 #include "glm/vec2.hpp"
 #include "le2d/texture.hpp"
@@ -21,7 +22,7 @@ class Enemy {
 	void translate(kvf::Seconds dt);
 	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;
+	[[nodiscard]] CollisionParams get_collision_params() const;
 	bool can_render{false};
 
   private:

src/game.cpp

@@ -2,6 +2,8 @@
 #include <glm/gtx/norm.hpp>
 #include <le2d/context.hpp>
 #include <cstddef>
+#include <format>
+#include <iterator>
 #include <string>
 #include <vector>
 #include "enemy.hpp"
@@ -15,8 +17,7 @@
 #include "util/random.hpp"
 
 namespace miracle {
-Game::Game(gsl::not_null<le::ServiceLocator const*> services)
-	: m_services(services), m_lighthouse(services), m_light(services), m_score_text(le::drawable::Text()) {
+Game::Game(gsl::not_null<le::ServiceLocator const*> services) : m_services(services), m_lighthouse(services), m_light(services) {
 	spawn_wave();
 	auto const& data_loader = services->get<le::IDataLoader>();
 	auto const& context = services->get<le::Context>();
@@ -45,13 +46,12 @@ void Game::tick([[maybe_unused]] kvf::Seconds const dt) {
 	for (auto& enemy : m_enemies) {
 		m_light.check_enemy_collision(enemy);
 		m_lighthouse.check_visibility_range(enemy);
-		set_health_text();
+		update_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);
-
+	update_score(static_cast<int>(res * 10));
 	m_light.set_position(m_cursor_pos);
 	m_lighthouse.rotate_towards_cursor(m_cursor_pos);
 }
@@ -76,15 +76,14 @@ void Game::spawn_wave() {
 	m_enemies.insert(m_enemies.end(), std::make_move_iterator(new_wave.begin()), std::make_move_iterator(new_wave.end()));
 }
 
-void Game::increase_score(std::size_t points) {
+void Game::update_score(int points) {
+	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;
 	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);
+	m_score_str.clear();
+	std::format_to(std::back_inserter(m_score_str), "Score: {}", m_score);
+	m_score_text.set_string(m_font, m_score_str);
 }
+void Game::update_health_text() {}
 
 } // namespace miracle

src/game.hpp

@@ -20,8 +20,8 @@ class Game {
 
 	void tick(kvf::Seconds dt);
 	void render(le::Renderer& renderer) const;
-	void increase_score(std::size_t points);
-	void set_health_text();
+	void update_score(int points);
+	void update_health_text();
 	void spawn_wave();
 
   private:
@@ -32,13 +32,14 @@ class Game {
 	le::Font m_font{};
 	le::drawable::Text m_score_text{};
 	le::drawable::Text m_health_text{};
+	int m_score{};
+	std::string m_score_str;
 
 	glm::vec2 m_cursor_pos{};
 	std::size_t m_wave_count{};
 	bool m_running{true};
 	kvf::Seconds m_wave_interval{};
 	kvf::Seconds m_time_since_last_wave_spawn{};
 	std::vector<Enemy> m_enemies{};
-	std::size_t m_score{};
 };
 } // namespace miracle

src/light.cpp

@@ -5,8 +5,8 @@ namespace miracle {
 Light::Light(gsl::not_null<le::ServiceLocator const*> services) : m_services(services), m_diameter(100) { m_sprite.create(150.0f, kvf::white_v); }
 
 void Light::check_enemy_collision(Enemy& enemy) {
-	auto [pos, diameter] = enemy.get_pos_diameter();
-	if (glm::distance(pos, m_sprite.transform.position) < (diameter + m_diameter)) {
+	auto const [pos, diameter] = enemy.get_collision_params();
+	if (glm::distance(pos, m_sprite.transform.position) < (diameter + m_diameter) / 2) {
 		enemy.take_damage(1);
 	} else {
 		enemy.can_render = false;

src/lighthouse.cpp

@@ -1,5 +1,4 @@
 #include <lighhouse.hpp>
-#include <cstddef>
 #include "glm/geometric.hpp"
 #include "le2d/asset_loader.hpp"
 #include "le2d/data_loader.hpp"
@@ -26,15 +25,15 @@ void Lighthouse::rotate_towards_cursor(glm::vec2 cursor_pos) {
 	}
 }
 void Lighthouse::check_visibility_range(Enemy& enemy) {
-	auto [enemy_pos, enemy_diameter] = enemy.get_pos_diameter();
+	auto [enemy_pos, enemy_diameter] = enemy.get_collision_params();
 	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();
+	auto [enemy_pos, enemy_diameter] = enemy.get_collision_params();
 	if (glm::distance(m_sprite.transform.position, enemy_pos) < (m_hitbog_diameter + enemy_diameter) / 2.0f) {
 		take_damage(enemy_diameter / 200);
 	} // magic numbers