model: split object impl into seperate files

Author: Netdex

twinhook/model/aabb.cpp

@@ -0,0 +1,76 @@
+#include "aabb.h"
+
+#include <sstream>
+
+#include "polygon.h"
+
+vec2 aabb::com() const
+{
+	return position + size / 2;
+}
+
+std::shared_ptr<entity> aabb::translate(vec2 delta) const
+{
+	auto c = std::make_shared<aabb>(*this);
+	c->position += delta;
+	return c;
+}
+
+std::shared_ptr<entity> aabb::withVelocity(vec2 newVelocity) const
+{
+	auto c = std::make_shared<aabb>(*this);
+	c->velocity = newVelocity;
+	return c;
+}
+
+std::shared_ptr<aabb> aabb::boundingBox() const
+{
+	return std::make_shared<aabb>(*this);
+}
+
+float aabb::willExit(const entity& o) const
+{
+	switch (o.type)
+	{
+	case AABB: {
+		const auto& a = dynamic_cast<const aabb&>(o);
+		float t = vec2::willExitAABB(a.position, position,
+			a.size, size, a.velocity, velocity);
+		return t;
+	}
+	default: return -1.f;
+	}
+}
+
+float aabb::willCollideWith(const entity& o) const
+{
+	switch (o.type)
+	{
+	case AABB: {
+		const auto& a = dynamic_cast<const aabb&>(o);
+		return vec2::willCollideAABB(position, a.position,
+			size, a.size, velocity, a.velocity);
+	}
+	case Polygon: {
+		const auto& a = dynamic_cast<const polygon&>(o);
+		const auto poly = this->toPolygon();
+		return poly.willCollideWith(a);
+	}
+	default: return -1.f;
+	}
+}
+
+polygon aabb::toPolygon() const
+{
+	return polygon{ {
+		position, position + vec2(size.w, 0),
+		position + size, position + vec2(0, size.h)
+	}, velocity };
+}
+
+std::ostream& aabb::serialize(std::ostream& os) const
+{
+	os << "aabb p" << position << " v" << velocity << " s" << size;
+	return os;
+}
+

twinhook/model/aabb.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "entity.h"
+
+class aabb : public entity
+{
+public:
+	vec2 position;
+	vec2 size;
+
+	aabb(const vec2& position = vec2(), const vec2& velocity = vec2(), const vec2& size = vec2(1, 1))
+		: entity(AABB, velocity),
+		position(position), size(size) {}
+
+
+	aabb(const aabb& other)
+		: entity{other}, position{other.position}, size{other.size} {}
+
+	vec2 com() const override;
+	std::shared_ptr<entity> translate(vec2 delta) const override;
+	std::shared_ptr<entity> withVelocity(vec2 newVelocity) const override;
+	std::shared_ptr<aabb> boundingBox() const override;
+
+	float willExit(const entity& o) const override;
+	float willCollideWith(const entity& o) const override;
+
+	polygon toPolygon() const;
+
+	std::ostream& serialize(std::ostream& os) const override;
+};

twinhook/model/circle.cpp

@@ -0,0 +1,59 @@
+#include "stdafx.h"
+#include "circle.h"
+#include "aabb.h"
+
+vec2 circle::com() const
+{
+	return center;
+}
+
+std::shared_ptr<entity> circle::translate(vec2 delta) const
+{
+	auto c = std::make_shared<circle>(*this);
+	c->center += delta;
+	return c;
+}
+
+std::shared_ptr<entity> circle::withVelocity(vec2 newVelocity) const
+{
+	auto c = std::make_shared<circle>(*this);
+	c->velocity = newVelocity;
+	return c;
+}
+
+std::shared_ptr<aabb> circle::boundingBox() const
+{
+	return std::make_shared<aabb>(center - vec2(radius),
+		velocity, vec2(radius) * 2);
+}
+
+float circle::willExit(const entity& o) const
+{
+	switch (o.type)
+	{
+	case AABB: {
+		// Use bounding box of circle
+		return this->boundingBox()->willExit(o);
+	}
+	default: return -1.f;
+	}
+}
+
+float circle::willCollideWith(const entity& o) const
+{
+	switch (o.type)
+	{
+	case Circle: {
+		const auto& a = dynamic_cast<const circle&>(o);
+		return vec2::willCollideCircle(center, a.center,
+			radius, a.radius, velocity, a.velocity);
+	}
+	default: return -1.f;
+	}
+}
+
+std::ostream& circle::serialize(std::ostream& os) const
+{
+	os << "circle c" << center << " v" << velocity << " r" << radius;
+	return os;
+}

twinhook/model/circle.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "util/vec2.h"
+#include "entity.h"
+
+class aabb;
+
+class circle : public entity
+{
+public:
+	vec2 center;
+	float radius;
+
+	circle(const vec2& center = vec2(), const vec2& velocity = vec2(), float radius = 1)
+		:entity(Circle, velocity), center(center), radius(radius) {}
+
+	vec2 com() const override;
+	std::shared_ptr<entity> translate(vec2 delta) const override;
+	std::shared_ptr<entity> withVelocity(vec2 newVelocity) const override;
+	std::shared_ptr<aabb> boundingBox() const override;
+
+	float willExit(const entity& o) const override;
+	float willCollideWith(const entity& o) const override;
+
+	std::ostream& serialize(std::ostream& os) const override;
+
+};

twinhook/model/entity.cpp

@@ -0,0 +1,21 @@
+#include "entity.h"
+
+std::shared_ptr<entity> entity::entityAtCollision(const entity& o) const
+{
+	float t = this->willCollideWith(o);
+	if (t < 0)
+		return nullptr;
+	return this->translate(t * this->velocity);
+}
+
+std::ostream& operator<<(std::ostream& os, const entity& o)
+{
+	return o.serialize(os);
+}
+
+void swap(entity& lhs, entity& rhs) noexcept
+{
+	using std::swap;
+	swap(lhs.type, rhs.type);
+	swap(lhs.velocity, rhs.velocity);
+}

twinhook/model/entity.h

@@ -0,0 +1,77 @@
+#pragma once
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <iosfwd>
+
+#include "util/vec2.h"
+
+class polygon;
+class aabb;
+
+class entity
+{
+public:
+	enum entity_type
+	{
+		AABB,
+		Circle,
+		Polygon
+	};
+protected:
+	entity(entity_type type, vec2 velocity = vec2())
+		: type(type), velocity(velocity) {}
+
+	entity(const entity& other) = default;
+	entity& operator=(const entity& other) = default;
+
+public:
+	entity_type type;
+	vec2 velocity;
+
+	virtual ~entity() = default;
+
+	friend void swap(entity& lhs, entity& rhs) noexcept;
+
+	friend std::ostream& operator<<(std::ostream& os, const entity& o);
+	virtual std::ostream& serialize(std::ostream& os) const = 0;
+
+
+	/**
+	 * \brief Center of mass function
+	 * \return Center of mass of entity
+	 */
+	virtual vec2 com() const = 0;
+
+	virtual std::shared_ptr<aabb> boundingBox() const = 0;
+
+	/**
+	 * \brief Get translated entity
+	 * \param delta Translation delta
+	 * \return Entity translated by delta
+	 */
+	virtual std::shared_ptr<entity> translate(vec2 delta) const = 0;
+	/**
+	 * \brief Get entity with new velocity
+	 * \param newVelocity The new velocity
+	 * \return Entity with new velocity
+	 */
+	virtual std::shared_ptr<entity> withVelocity(vec2 newVelocity) const = 0;
+
+	/**
+	 * \brief Predict time until collision between this entity and another
+	 * \param o The other entity
+	 * \return Result of the vector collision predictor (frames until collision)
+	 */
+	virtual float willCollideWith(const entity& o) const = 0;
+	/**
+	 * \brief Predict time until entity leaves another's bounds
+	 * \param o The other entity
+	 * \return Result of the vector exit predictor (frames until exit)
+	 */
+	virtual float willExit(const entity& o) const = 0;
+
+	std::shared_ptr<entity> entityAtCollision(const entity& o) const;
+
+};

twinhook/model/entiy.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "util/vec2.h"
+
+class polygon;
+class aabb;
+
+class entity
+{
+public:
+	enum entity_type
+	{
+		AABB,
+		Circle,
+		Polygon
+	};
+protected:
+	entity(entity_type type, vec2 velocity = vec2())
+		: type(type), velocity(std::move(velocity)) {}
+
+	entity& operator=(const entity& o) = default;
+
+public:
+	entity_type type;
+	vec2 velocity;
+
+	virtual ~entity() = default;
+
+	/**
+	 * \brief Center of mass function
+	 * \return Center of mass of entity
+	 */
+	virtual vec2 com() const = 0;
+
+	virtual std::shared_ptr<aabb> boundingBox() const = 0;
+
+	/**
+	 * \brief Get translated entity
+	 * \param delta Translation delta
+	 * \return Entity translated by delta
+	 */
+	virtual std::shared_ptr<entity> translate(vec2 delta) const = 0;
+	/**
+	 * \brief Get entity with new velocity
+	 * \param newVelocity The new velocity
+	 * \return Entity with new velocity
+	 */
+	virtual std::shared_ptr<entity> withVelocity(vec2 newVelocity) const = 0;
+
+	/**
+	 * \brief Predict time until collision between this entity and another
+	 * \param o The other entity
+	 * \return Result of the vector collision predictor (frames until collision)
+	 */
+	virtual float willCollideWith(const entity& o) const = 0;
+	/**
+	 * \brief Predict time until entity leaves another's bounds
+	 * \param o The other entity
+	 * \return Result of the vector exit predictor (frames until exit)
+	 */
+	virtual float willExit(const entity& o) const = 0;
+
+	std::shared_ptr<entity> entityAtCollision(const entity& o) const;
+
+	virtual std::string serialize() const = 0;
+
+	friend void swap(entity& lhs, entity& rhs) noexcept;
+};

twinhook/model/game_object.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "model/object.h"
-
+#include <utility>
 
+#include "model/object.h"
 
 class game_object
 {
@@ -16,10 +16,7 @@ class game_object
 		Enemy
 	};
 
-	game_object(game_object_type type, std::shared_ptr<entity> obj) : type(type)
-	{
-		this->obj = obj;
-	}
+	game_object(game_object_type type, std::shared_ptr<entity> obj) : type(type), obj(std::move(obj)) {}
 public:
 	game_object_type type;
 	std::shared_ptr<entity> obj;