7 files changed, 284 insertions, 4 deletions

diff --git a/src/crepe/system/AISystem.cpp b/src/crepe/system/AISystem.cpp
new file mode 100644
index 0000000..3c3fd93
--- /dev/null
+++ b/src/crepe/system/AISystem.cpp
@@ -0,0 +1,186 @@
+#include <algorithm>
+#include <cmath>
+
+#include "api/LoopTimer.h"
+#include "manager/ComponentManager.h"
+#include "manager/Mediator.h"
+
+#include "AISystem.h"
+
+using namespace crepe;
+
+void AISystem::fixed_update() {
+	const Mediator & mediator = this->mediator;
+	ComponentManager & mgr = mediator.component_manager;
+	LoopTimer & timer = mediator.timer;
+	RefVector<AI> ai_components = mgr.get_components_by_type<AI>();
+
+	//TODO: Use fixed loop dt (this is not available at master at the moment)
+	double dt = timer.get_delta_time();
+
+	// Loop through all AI components
+	for (AI & ai : ai_components) {
+		if (!ai.active) {
+			continue;
+		}
+
+		RefVector<Rigidbody> rigidbodies
+			= mgr.get_components_by_id<Rigidbody>(ai.game_object_id);
+		if (rigidbodies.empty()) {
+			throw std::runtime_error(
+				"AI component must be attached to a GameObject with a Rigidbody component");
+		}
+		Rigidbody & rigidbody = rigidbodies.front().get();
+		if (!rigidbody.active) {
+			continue;
+		}
+		if (rigidbody.data.mass <= 0) {
+			throw std::runtime_error("Mass must be greater than 0");
+		}
+
+		// Calculate the force to apply to the entity
+		vec2 force = this->calculate(ai, rigidbody);
+		// Calculate the acceleration (using the above calculated force)
+		vec2 acceleration = force / rigidbody.data.mass;
+		// Finally, update Rigidbody's velocity
+		rigidbody.data.linear_velocity += acceleration * dt;
+	}
+}
+
+vec2 AISystem::calculate(AI & ai, const Rigidbody & rigidbody) {
+	const Mediator & mediator = this->mediator;
+	ComponentManager & mgr = mediator.component_manager;
+	RefVector<Transform> transforms = mgr.get_components_by_id<Transform>(ai.game_object_id);
+	Transform & transform = transforms.front().get();
+
+	vec2 force;
+
+	// Run all the behaviors that are on, and stop if the force gets too high
+	if (ai.on(AI::BehaviorTypeMask::FLEE)) {
+		vec2 force_to_add = this->flee(ai, rigidbody, transform);
+
+		if (!this->accumulate_force(ai, force, force_to_add)) {
+			return force;
+		}
+	}
+	if (ai.on(AI::BehaviorTypeMask::ARRIVE)) {
+		vec2 force_to_add = this->arrive(ai, rigidbody, transform);
+
+		if (!this->accumulate_force(ai, force, force_to_add)) {
+			return force;
+		}
+	}
+	if (ai.on(AI::BehaviorTypeMask::SEEK)) {
+		vec2 force_to_add = this->seek(ai, rigidbody, transform);
+
+		if (!this->accumulate_force(ai, force, force_to_add)) {
+			return force;
+		}
+	}
+	if (ai.on(AI::BehaviorTypeMask::PATH_FOLLOW)) {
+		vec2 force_to_add = this->path_follow(ai, rigidbody, transform);
+
+		if (!this->accumulate_force(ai, force, force_to_add)) {
+			return force;
+		}
+	}
+
+	return force;
+}
+
+bool AISystem::accumulate_force(const AI & ai, vec2 & running_total, vec2 & force_to_add) {
+	float magnitude = running_total.length();
+	float magnitude_remaining = ai.max_force - magnitude;
+
+	if (magnitude_remaining <= 0.0f) {
+		// If the force is already at/above the max force, return false
+		return false;
+	}
+
+	float magnitude_to_add = force_to_add.length();
+	if (magnitude_to_add < magnitude_remaining) {
+		// If the force to add is less than the remaining force, add it
+		running_total += force_to_add;
+	} else {
+		// If the force to add is greater than the remaining force, add a fraction of it
+		force_to_add.normalize();
+		running_total += force_to_add * magnitude_remaining;
+	}
+
+	return true;
+}
+
+vec2 AISystem::seek(const AI & ai, const Rigidbody & rigidbody,
+					const Transform & transform) const {
+	// Calculate the desired velocity
+	vec2 desired_velocity = ai.seek_target - transform.position;
+	desired_velocity.normalize();
+	desired_velocity *= rigidbody.data.max_linear_velocity;
+
+	return desired_velocity - rigidbody.data.linear_velocity;
+}
+
+vec2 AISystem::flee(const AI & ai, const Rigidbody & rigidbody,
+					const Transform & transform) const {
+	// Calculate the desired velocity if the entity is within the panic distance
+	vec2 desired_velocity = transform.position - ai.flee_target;
+	if (desired_velocity.length_squared() > ai.square_flee_panic_distance) {
+		return vec2{0, 0};
+	}
+	desired_velocity.normalize();
+	desired_velocity *= rigidbody.data.max_linear_velocity;
+
+	return desired_velocity - rigidbody.data.linear_velocity;
+}
+
+vec2 AISystem::arrive(const AI & ai, const Rigidbody & rigidbody,
+					  const Transform & transform) const {
+	// Calculate the desired velocity (taking into account the deceleration rate)
+	vec2 to_target = ai.arrive_target - transform.position;
+	float distance = to_target.length();
+	if (distance > 0.0f) {
+		if (ai.arrive_deceleration <= 0.0f) {
+			throw std::runtime_error("Deceleration rate must be greater than 0");
+		}
+
+		float speed = distance / ai.arrive_deceleration;
+		speed = std::min(speed, rigidbody.data.max_linear_velocity.length());
+		vec2 desired_velocity = to_target * (speed / distance);
+
+		return desired_velocity - rigidbody.data.linear_velocity;
+	}
+
+	return vec2{0, 0};
+}
+
+vec2 AISystem::path_follow(AI & ai, const Rigidbody & rigidbody, const Transform & transform) {
+	if (ai.path.empty()) {
+		return vec2{0, 0};
+	}
+
+	// Get the target node
+	vec2 target = ai.path.at(ai.path_index);
+	// Calculate the force to apply to the entity
+	vec2 to_target = target - transform.position;
+	if (to_target.length_squared() > ai.path_node_distance * ai.path_node_distance) {
+		// If the entity is not close enough to the target node, seek it
+		ai.seek_target = target;
+		ai.arrive_target = target;
+	} else {
+		// If the entity is close enough to the target node, move to the next node
+		ai.path_index++;
+		if (ai.path_index >= ai.path.size()) {
+			if (ai.path_loop) {
+				// If the path is looping, reset the path index
+				ai.path_index = 0;
+			} else {
+				// If the path is not looping, arrive at the last node
+				ai.path_index = ai.path.size() - 1;
+				return this->arrive(ai, rigidbody, transform);
+			}
+		}
+	}
+
+	// Seek the target node
+	return this->seek(ai, rigidbody, transform);
+}
diff --git a/src/crepe/system/AISystem.h b/src/crepe/system/AISystem.h
new file mode 100644
index 0000000..04807cf
--- /dev/null
+++ b/src/crepe/system/AISystem.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "api/AI.h"
+#include "api/Rigidbody.h"
+
+#include "System.h"
+#include "api/Transform.h"
+#include "types.h"
+
+namespace crepe {
+
+/**
+ * \brief The AISystem is used to control the movement of entities using AI.
+ *
+ * The AISystem is used to control the movement of entities using AI. The AISystem can be used to
+ * implement different behaviors such as seeking, fleeing, arriving, and path following.
+ */
+class AISystem : public System {
+public:
+	using System::System;
+
+	//! Update the AI system
+	void fixed_update() override;
+
+private:
+	/**
+	 * \brief Calculate the total force to apply to the entity
+	 *
+	 * \param ai The AI component
+	 * \param rigidbody The Rigidbody component
+	 */
+	vec2 calculate(AI & ai, const Rigidbody & rigidbody);
+	/**
+	 * \brief Accumulate the force to apply to the entity
+	 *
+	 * \param ai The AI component
+	 * \param running_total The running total of the force
+	 * \param force_to_add The force to add
+	 * \return true if the force was added, false otherwise
+	 */
+	bool accumulate_force(const AI & ai, vec2 & running_total, vec2 & force_to_add);
+
+	/**
+	 * \brief Calculate the seek force
+	 *
+	 * \param ai The AI component
+	 * \param rigidbody The Rigidbody component
+	 * \param transform The Transform component
+	 * \return The seek force
+	 */
+	vec2 seek(const AI & ai, const Rigidbody & rigidbody, const Transform & transform) const;
+	/**
+	 * \brief Calculate the flee force
+	 *
+	 * \param ai The AI component
+	 * \param rigidbody The Rigidbody component
+	 * \param transform The Transform component
+	 * \return The flee force
+	 */
+	vec2 flee(const AI & ai, const Rigidbody & rigidbody, const Transform & transform) const;
+	/**
+	 * \brief Calculate the arrive force
+	 *
+	 * \param ai The AI component
+	 * \param rigidbody The Rigidbody component
+	 * \param transform The Transform component
+	 * \return The arrive force
+	 */
+	vec2 arrive(const AI & ai, const Rigidbody & rigidbody, const Transform & transform) const;
+	/**
+	 * \brief Calculate the path follow force
+	 *
+	 * \param ai The AI component
+	 * \param rigidbody The Rigidbody component
+	 * \param transform The Transform component
+	 * \return The path follow force
+	 */
+	vec2 path_follow(AI & ai, const Rigidbody & rigidbody, const Transform & transform);
+};
+
+} // namespace crepe
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 8d6d8fa..02647f1 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -21,7 +21,7 @@ void AnimatorSystem::frame_update() {
 
 		int last_frame = ctx.row;
 
-		int cycle_end = (ctx.cycle_end == -1) ? a.max_rows : ctx.cycle_end;
+		int cycle_end = (ctx.cycle_end == -1) ? a.grid_size.x : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
diff --git a/src/crepe/system/AudioSystem.cpp b/src/crepe/system/AudioSystem.cpp
index 9b86069..d4e8b9f 100644
--- a/src/crepe/system/AudioSystem.cpp
+++ b/src/crepe/system/AudioSystem.cpp
@@ -30,8 +30,7 @@ void AudioSystem::diff_update(AudioSource & component, Sound & resource) {
 			context.stop(component.voice);
 			return;
 		}
-		if (component.play_on_awake)
-			component.oneshot_play = true;
+		if (component.play_on_awake) component.oneshot_play = true;
 	}
 	if (!component.active) return;
 
diff --git a/src/crepe/system/CMakeLists.txt b/src/crepe/system/CMakeLists.txt
index 1336114..3473876 100644
--- a/src/crepe/system/CMakeLists.txt
+++ b/src/crepe/system/CMakeLists.txt
@@ -10,6 +10,7 @@ target_sources(crepe PUBLIC
 	InputSystem.cpp
 	EventSystem.cpp
 	ReplaySystem.cpp
+	AISystem.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -22,4 +23,5 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	AnimatorSystem.h
 	InputSystem.h
 	EventSystem.h
+	AISystem.h
 )
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index b31bd34..7796b47 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -1,6 +1,8 @@
 #include "../api/Button.h"
 #include "../manager/ComponentManager.h"
 #include "../manager/EventManager.h"
+#include "facade/SDLContext.h"
+#include "util/Log.h"
 
 #include "InputSystem.h"
 
@@ -9,7 +11,8 @@ using namespace crepe;
 void InputSystem::fixed_update() {
 	ComponentManager & mgr = this->mediator.component_manager;
 	EventManager & event_mgr = this->mediator.event_manager;
-	std::vector<SDLContext::EventData> event_list = SDLContext::get_instance().get_events();
+	SDLContext & context = this->mediator.sdl_context;
+	std::vector<SDLContext::EventData> event_list = context.get_events();
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
 	RefVector<Camera> cameras = mgr.get_components_by_type<Camera>();
 	OptionalRef<Camera> curr_cam_ref;
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index e147b9f..7e9dfc6 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -10,7 +10,9 @@
 #include "../api/Sprite.h"
 #include "../api/Transform.h"
 #include "../facade/SDLContext.h"
+#include "../facade/Texture.h"
 #include "../manager/ComponentManager.h"
+#include "../manager/ResourceManager.h"
 
 #include "RenderSystem.h"
 
@@ -72,6 +74,8 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 
 	ComponentManager & mgr = this->mediator.component_manager;
 	SDLContext & ctx = this->mediator.sdl_context;
+	ResourceManager & resource_manager = this->mediator.resource_manager;
+	Texture & res = resource_manager.get<Texture>(sprite.source);
 
 	vector<reference_wrapper<ParticleEmitter>> emitters
 		= mgr.get_components_by_id<ParticleEmitter>(sprite.game_object_id);
@@ -88,6 +92,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 
 			ctx.draw(SDLContext::RenderContext{
 				.sprite = sprite,
+				.texture = res,
 				.cam = cam,
 				.pos = p.position,
 				.angle = p.angle,
@@ -100,8 +105,12 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
 								 const Transform & tm) {
 	SDLContext & ctx = this->mediator.sdl_context;
+	ResourceManager & resource_manager = this->mediator.resource_manager;
+	const Texture & res = resource_manager.get<Texture>(sprite.source);
+
 	ctx.draw(SDLContext::RenderContext{
 		.sprite = sprite,
+		.texture = res,
 		.cam = cam,
 		.pos = tm.position,
 		.angle = tm.rotation,