Cleanup

src/enemy.cpp

@@ -1,13 +1,11 @@
 #include <enemy.hpp>
 #include <algorithm>
-#include "enemy_params.hpp"
 #include "glm/geometric.hpp"
-#include "glm/vec2.hpp"
 #include "kvf/color.hpp"
 #include "util/random.hpp"
 
 namespace miracle {
-Enemy::Enemy(gsl::not_null<le::ServiceLocator const*> services, EnemyParams const& params)
+Enemy::Enemy(gsl::not_null<le::ServiceLocator const*> services, Params const& params)
 	: m_services(services), m_target_pos(params.target_pos), m_move_speed(params.move_speed), m_diameter(util::random_range(40.0f, 60.0f)) {
 	m_sprite.create(m_diameter, kvf::red_v);
 	auto const framebuffer_size = m_services->get<le::Context>().framebuffer_size();
@@ -27,7 +25,8 @@ void Enemy::translate(kvf::Seconds const dt) {
 	m_sprite.transform.position += movement;
 }
 
-CollisionParams Enemy::get_collision_params() const { return {.pos = m_sprite.transform.position, .diameter = m_diameter}; }
+auto Enemy::get_collision_info() const -> CollisionInfo { 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,21 +8,29 @@
 #include <le2d/service_locator.hpp>
 #include <cstddef>
 #include <optional>
-#include "EnemyColliderInfo.hpp"
-#include "enemy_params.hpp"
 #include "glm/vec2.hpp"
 #include "le2d/texture.hpp"
 
 namespace miracle {
 class Enemy {
   public:
-	explicit Enemy(gsl::not_null<le::ServiceLocator const*> services, EnemyParams const& params);
+	struct Params {
+		glm::vec2 target_pos{};
+		float move_speed{};
+	};
+
+	struct CollisionInfo {
+		glm::vec2 pos{};
+		float diameter{};
+	};
+
+	explicit Enemy(gsl::not_null<le::ServiceLocator const*> services, Params const& params);
 
 	void render(le::Renderer& renderer) const;
 	void translate(kvf::Seconds dt);
 	void take_damage(std::size_t dmg);
 	[[nodiscard]] std::size_t get_health() const { return m_health; }
-	[[nodiscard]] CollisionParams get_collision_params() const;
+	[[nodiscard]] CollisionInfo get_collision_info() const;
 	bool can_render{false};
 
   private:

src/game.cpp

@@ -1,19 +1,18 @@
 #include <game.hpp>
 #include <glm/gtx/norm.hpp>
 #include <le2d/context.hpp>
+#include <algorithm>
 #include <cstddef>
 #include <format>
 #include <iterator>
 #include <string>
 #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"
 #include "le2d/drawable/text.hpp"
-#include "lighhouse.hpp"
+#include "lighthouse.hpp"
 #include "util/random.hpp"
 
 namespace miracle {
@@ -63,13 +62,15 @@ void Game::render(le::Renderer& renderer) const {
 void Game::spawn_wave() {
 	++m_wave_count;
 	m_wave_interval += kvf::Seconds{5};
-	std::vector<Enemy> new_wave;
-	std::size_t const wave_size = m_wave_count * 3;
-	new_wave.reserve(wave_size);
-	for (std::size_t i = 0; i < wave_size; ++i) {
-		new_wave.emplace_back(m_services, EnemyParams{.target_pos = glm::vec2{0.0f, 0.0f}, .move_speed = util::random_range(35.0f, 65.0f)});
+	std::vector<Enemy> new_wave{};
+	int wave_size = m_wave_count * 3;
+	new_wave.reserve(static_cast<std::size_t>(wave_size));
+	for (; wave_size > 0; --wave_size) {
+		auto const params = Enemy::Params{.target_pos = glm::vec2{0.0f, 0.0f}, .move_speed = util::random_range(35.0f, 65.0f)};
+		new_wave.emplace_back(m_services, params);
 	}
-	m_enemies.insert(m_enemies.end(), std::make_move_iterator(new_wave.begin()), std::make_move_iterator(new_wave.end()));
+	m_enemies.reserve(m_enemies.size() + new_wave.size());
+	std::ranges::move(new_wave, std::back_inserter(m_enemies));
 }
 
 void Game::update_score(int points) {

src/game.hpp

@@ -8,8 +8,8 @@
 #include "enemy.hpp"
 #include "le2d/drawable/text.hpp"
 #include "le2d/font.hpp"
-#include "lighhouse.hpp"
 #include "light.hpp"
+#include "lighthouse.hpp"
 
 namespace miracle {
 class Game {
@@ -36,7 +36,7 @@ class Game {
 	std::string m_score_str;
 	std::string m_health_str;
 	glm::vec2 m_cursor_pos{};
-	std::size_t m_wave_count{};
+	int m_wave_count{};
 	bool m_running{true};
 	kvf::Seconds m_wave_interval{};
 	kvf::Seconds m_time_since_last_wave_spawn{};

src/light.cpp

@@ -5,7 +5,7 @@ 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 const [pos, diameter] = enemy.get_collision_params();
+	auto const [pos, diameter] = enemy.get_collision_info();
 	if (glm::distance(pos, m_sprite.transform.position) < (diameter + m_diameter) / 2) {
 		enemy.take_damage(1);
 	} else {

src/lighthouse.cpp

@@ -1,5 +1,6 @@
-#include <lighhouse.hpp>
-#include "glm/geometric.hpp"
+#include <glm/gtc/matrix_transform.hpp>
+#include <lighthouse.hpp>
+#include "glm/gtx/norm.hpp"
 #include "le2d/asset_loader.hpp"
 #include "le2d/data_loader.hpp"
 
@@ -24,23 +25,25 @@ 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_collision_params();
-	if (glm::distance(m_sprite.transform.position, enemy_pos) < (m_visibility_diameter + enemy_diameter) / 2.0f) {
+	auto [enemy_pos, enemy_diameter] = enemy.get_collision_info();
+	auto const dist_sq = glm::length2(m_sprite.transform.position - enemy_pos);
+	auto const viz_dist = (m_visibility_diameter + enemy_diameter) * 0.5f;
+	if (dist_sq < viz_dist * viz_dist) {
 		enemy.can_render = true;
 		// No need to check for damage taken if enemy isn't already in visibility radius
-		check_damage_taken(enemy);
+		check_damage_taken(enemy_diameter, dist_sq);
 	}
 }
-void Lighthouse::check_damage_taken(Enemy& enemy) {
-	auto [enemy_pos, enemy_diameter] = enemy.get_collision_params();
-	if (glm::distance(m_sprite.transform.position, enemy_pos) < (m_hitbox_diameter + enemy_diameter) / 2.0f) {
-		take_damage(enemy_diameter / 200);
-	} // magic numbers
+void Lighthouse::check_damage_taken(float const enemy_diameter, float const dist_sq) {
+	auto const hitbox_dist = (m_hitbox_diameter + enemy_diameter) * 0.5f;
+	if (dist_sq < hitbox_dist * hitbox_dist) { take_damage(enemy_diameter * 0.005f); } // 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

src/lighhouse.hpp → src/lighthouse.hpp

@@ -19,7 +19,7 @@ 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 check_damage_taken(float enemy_diameter, float dist_sq);
 	void take_damage(float dmg);
 	[[nodiscard]] float get_health() const;