Implemented very basic linear move-to-dest component

2 files changed, 76 insertions, 4 deletions

diff --git a/battles/src/BaseBattle.cpp b/battles/src/BaseBattle.cpp
index a9ac45c..8527a56 100644
--- a/battles/src/BaseBattle.cpp
+++ b/battles/src/BaseBattle.cpp
@@ -28,6 +28,8 @@ BaseBattle::BaseBattle(const Scenario& scenario) :
 		_registry.emplace<universe::ShipType>(entity, ship.type);
 		_registry.emplace<Team>(entity, ship.team);
 		_registry.emplace<Transform>(entity, spawner.get(ship.team));
+		_registry.emplace<FloatingMovement>(entity, 0.4);
+		_registry.emplace<AIState>(entity, Point{0.0, 0.0});
 	}
 }
 
@@ -42,10 +44,15 @@ BaseBattle::registry()
 void
 BaseBattle::update(const float dt)
 {
-	auto view = _registry.view<Transform>();
-	for (auto&& [entity, transform] : view.each()) {
-		transform.position.x += 0.1 * dt * std::cos(transform.angle);
-		transform.position.y += 0.1 * dt * std::sin(transform.angle);
+	auto view = _registry.view<Transform, AIState, FloatingMovement>();
+	for (auto&& [entity, transform, state, movement] : view.each()) {
+		const double speed = movement.speed * dt;
+		const Point diff = (state.destination - transform.position);
+		if (diff.magnitude() > speed) {
+			const Point eff = diff.normalized().scale(speed);
+			transform.position.x += eff.x;
+			transform.position.y += eff.y;
+		}
 	}
 }
 
diff --git a/battles/src/Point.cpp b/battles/src/Point.cpp
new file mode 100644
index 0000000..9ffa81c
--- /dev/null
+++ b/battles/src/Point.cpp
@@ -0,0 +1,65 @@
+#include <kurator/battles/Point.h>
+
+#include <cmath>
+
+
+namespace kurator
+{
+namespace battles
+{
+
+
+double
+Point::magnitude() const
+{
+	return std::sqrt(std::pow(x, 2) + std::pow(y, 2));
+}
+
+
+double
+Point::distance(const Point& other) const
+{
+	return std::sqrt(std::pow(other.x - x, 2) + std::pow(other.y - y, 2));
+}
+
+
+Point
+Point::rotate(const double angle) const
+{
+	return {
+		x * std::cos(angle) - y * std::sin(angle),
+		x * std::sin(angle) + y * std::cos(angle),
+	};
+}
+
+
+Point
+Point::scale(const double _scale) const
+{
+	return {x * _scale, y * _scale};
+}
+
+
+Point
+Point::normalized() const
+{
+	return scale(1.0 / magnitude());
+}
+
+
+Point
+Point::operator-(const Point& other) const
+{
+	return {x - other.x, y - other.y};
+}
+
+
+Point
+Point::operator+(const Point& other) const
+{
+	return {x + other.x, y + other.y};
+}
+
+
+}  // namespace battles
+}  // namespace kurator