nutomic/dungeon-gunner
Archived
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Changed sprites to always render as rectangle.

Browse source 
Also created Rectangle/Circle subclasses for sprite to handle
collision detection and moved collision detection from World to
CollisionModel (static methods).
This commit is contained in:
Felix Ableitner 2013-05-08 00:00:05 +02:00
parent 22bcd8cf13
commit aa6df65e97
20 changed files with 367 additions and 260 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

116
source/World.cpp
View file

@ -70,18 +70,18 @@ World::step(int elapsed) {
for (auto v = mDrawables.begin(); v != mDrawables.end(); v++) {
for (auto it = v->second.begin(); it != v->second.end(); it++) {
auto& spriteA = *it;
sf::Vector2f speed = spriteA->getSpeed() * (elapsed / 1000.0f);
if (spriteA->getDelete()) {
v->second.erase(it);
it--;
}
// Apply movement for movable sprites.
else if (spriteA->getSpeed() != sf::Vector2f() &&
!doesOverlap(spriteA, elapsed))
else if (spriteA->getSpeed() != sf::Vector2f()) {
sf::Vector2f speed = spriteA->getSpeed() * (elapsed / 1000.0f);
if (!doesOverlap(spriteA, elapsed))
spriteA->setPosition(spriteA->getPosition() + speed);
}
}
}
}
/**
* Tests spriteA for overlap with every other sprite (considering collision
@ -97,7 +97,7 @@ World::doesOverlap(std::shared_ptr<Sprite> spriteA, int elapsed) {
if (!spriteA->collisionEnabled(spriteB->getCategory()) ||
!spriteB->collisionEnabled(spriteA->getCategory()))
continue;
if (testCollision(spriteA, spriteB, elapsed)) {
if (spriteA->testCollision(spriteB, elapsed)) {
spriteA->onCollide(spriteB);
spriteB->onCollide(spriteA);
return true;
@ -128,112 +128,6 @@ World::think(int elapsed) {
}
}
/**
* Tests for collisions using Seperating Axis Theorem (SAT).
*
* http://www.metanetsoftware.com/technique/tutorialA.html
*
* @param spriteA, spriteB Pair of sprites which to test for collision/overlapping.
* @param elapsed Time elapsed in this step.
* @return True if both sprites will be overlapping after their current movement.
*/
bool
World::testCollision(std::shared_ptr<Sprite> spriteA,
std::shared_ptr<Sprite> spriteB, int elapsed) const {
// circle-circle collision
if ((spriteA->mShape.type == Sprite::Shape::Type::CIRCLE) &&
(spriteB->mShape.type == Sprite::Shape::Type::CIRCLE)) {
sf::Vector2f axis = spriteA->getPosition() - spriteB->getPosition();
// If both objects are at the exact same position, allow any movement for unstucking.
if (axis == sf::Vector2f())
return true;
axis = thor::unitVector(axis);
float centerA = thor::dotProduct(axis, spriteA->getPosition());
float radiusA = spriteA->getRadius();
float movementA = thor::dotProduct(axis, spriteA->getSpeed() * (elapsed / 1000.0f));
float centerB = thor::dotProduct(axis, spriteB->getPosition());
float radiusB = spriteB->getRadius();
float movementB = thor::dotProduct(axis, spriteB->getSpeed() * (elapsed / 1000.0f));
// Allow movement if sprites are moving apart.
return Interval::IntervalFromRadius(centerA, radiusA).getOverlap(
Interval::IntervalFromRadius(centerB, radiusB)).getLength() <
Interval::IntervalFromRadius(centerA + movementA, radiusA).getOverlap(
Interval::IntervalFromRadius(centerB + movementB, radiusB)).getLength();
}
// circle-rect collision
if (((spriteA->mShape.type == Sprite::Shape::Type::CIRCLE) &&
(spriteB->mShape.type == Sprite::Shape::Type::RECTANGLE)) ||
((spriteA->mShape.type == Sprite::Shape::Type::RECTANGLE) &&
(spriteB->mShape.type == Sprite::Shape::Type::CIRCLE))) {
std::shared_ptr<Sprite> circle = spriteA;
std::shared_ptr<Sprite> rect = spriteB;
if (circle->mShape.type != Sprite::Shape::Type::CIRCLE)
std::swap(circle, rect);
float radius = circle->getRadius();
sf::Vector2f halfsize = rect->getSize() / 2.0f;
sf::Vector2f circlePos = circle->getPosition();
sf::Vector2f rectPos = rect->getPosition();
// Only circle movement as rectangles don't move.
sf::Vector2f circleMovement = circle->getSpeed() * (elapsed / 1000.0f);
// We assume that rectangles are always axis aligned.
float overlapNoMovementX = Interval::IntervalFromRadius(circlePos.x, radius)
.getOverlap(Interval::IntervalFromRadius(rectPos.x, halfsize.x)).getLength();
float overlapMovementX = Interval::IntervalFromRadius(circlePos.x + circleMovement.x, radius)
.getOverlap(Interval::IntervalFromRadius(rectPos.x, halfsize.x)).getLength();
float overlapNoMovementY = Interval::IntervalFromRadius(circlePos.y, radius)
.getOverlap(Interval::IntervalFromRadius(rectPos.y, halfsize.y)).getLength();
float overlapMovementY = Interval::IntervalFromRadius(circlePos.y + circleMovement.y, radius)
.getOverlap(Interval::IntervalFromRadius(rectPos.y, halfsize.y)).getLength();
bool xyCollisionResult = (((overlapNoMovementX < overlapMovementX) &&
(overlapNoMovementY > 0)) ||
((overlapNoMovementY < overlapMovementY) && (overlapNoMovementX > 0)));
// If circle center is overlapping rectangle on x or y axis, we can take xyCollisionResult.
if (Interval::IntervalFromRadius(rectPos.x, halfsize.x).isInside(circlePos.x) ||
Interval::IntervalFromRadius(rectPos.y, halfsize.y).isInside(circlePos.y))
return xyCollisionResult;
// Test if the circle is colliding with a corner of the rectangle.
else if (xyCollisionResult) {
// This is the same as circle-circle collision.
sf::Vector2f axis = circle->getPosition() - rect->getPosition();
// If both objects are at the exact same position, allow any
// movement for unstucking.
if (axis == sf::Vector2f())
return true;
axis = thor::unitVector(axis);
float circlePosProjected = thor::dotProduct(axis, circlePos);
float movementProjected = thor::dotProduct(axis, circleMovement);
float rectPosProjected = thor::dotProduct(axis, rectPos);
// For corner projections, those on the same line with the rect
// center are equal by value, so we only need one on each axis
// and take the maximum.
float rectHalfWidthProjected = std::max(
abs(thor::dotProduct(axis, halfsize)),
abs(thor::dotProduct(axis,
sf::Vector2f(halfsize.x, -halfsize.y))));
// Allow movement if sprites are moving apart.
return Interval::IntervalFromRadius(circlePosProjected, radius)
.getOverlap(Interval::IntervalFromRadius(rectPosProjected,
rectHalfWidthProjected))
.getLength() <
Interval::IntervalFromRadius(circlePosProjected + movementProjected, radius)
.getOverlap(Interval::IntervalFromRadius(rectPosProjected,
rectHalfWidthProjected))
.getLength();
}
// If there is no collision on x and y axis, there can't be one at all.
else {
return false;
}
}
// Rectangles can't move and thus not collide.
return false;
}
/**
* Draws all elements in the group.
*/

7
source/abstract/Character.cpp
View file

@ -21,9 +21,10 @@ const float Character::VISION_DISTANCE = 500.0f;
/**
* Saves pointer to this instance in static var for think().
*/
Character::Character(World& world, Pathfinder& pathfinder, const Data& data,
const Yaml& config) :
Sprite(data, config),
Character::Character(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config, World& world,
Pathfinder& pathfinder) :
Circle(position, category, mask, config),
mWorld(world),
mPathfinder(pathfinder),
mMaxHealth(config.get(YAML_KEY::HEALTH, YAML_DEFAULT::HEALTH)),

9
source/abstract/Character.h
View file

@ -8,7 +8,7 @@
#ifndef DG_ACTOR_H_
#define DG_ACTOR_H_
#include "Sprite.h"
#include "Circle.h"
class Pathfinder;
class World;
@ -18,10 +18,11 @@ class Yaml;
/**
* Provides think function for AI, manages health, drops body on death.
*/
class Character : public Sprite {
class Character : public Circle {
public:
explicit Character(World& world, Pathfinder& pathfinder, const Data& data,
const Yaml& config);
explicit Character(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config, World& world,
Pathfinder& pathfinder);
virtual ~Character() = 0;
void onDamage(int damage);

46
source/abstract/Circle.cpp Normal file
View file

@ -0,0 +1,46 @@
/*
* Circle.cpp
*
* Created on: 04.05.2013
* Author: Felix
*/
#include "Circle.h"
#include "Rectangle.h"
#include "../util/Yaml.h"
Circle::Circle(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config,
const sf::Vector2f& direction) :
Sprite(position, category, mask,
sf::Vector2f(config.get(YAML_KEY::RADIUS, 0.0f),
config.get(YAML_KEY::RADIUS, 0.0f)) * 2.0f,
config.get(YAML_KEY::TEXTURE, std::string()), direction) {
}
/**
* Returns true if a collision between this and other occured. It does not
* matter which object is this or other.
*/
bool
Circle::testCollision(std::shared_ptr<Sprite> other, int elapsed) {
Rectangle* rect = dynamic_cast<Rectangle*>(other.get());
Circle* circle = dynamic_cast<Circle*>(other.get());
if (circle != nullptr)
return CollisionModel::testCollision(*this, *circle, elapsed);
else if (rect != nullptr)
return CollisionModel::testCollision(*this, *rect, elapsed);
else {
assert(false);
return false;
}
}
/**
* Returns the radius of the circle used as a collision model for this object.
*/
float
Circle::getRadius() const {
return getSize().x / 2;
}

30
source/abstract/Circle.h Normal file
View file

@ -0,0 +1,30 @@
/*
* Circle.h
*
* Created on: 04.05.2013
* Author: Felix
*/
#ifndef DG_CIRCLE_H_
#define DG_CIRCLE_H_
#include "CollisionModel.h"
#include "Sprite.h"
class Yaml;
/**
* Shape that uses a circle as collision model.
*/
class Circle : public CollisionModel, public Sprite {
public:
explicit Circle(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config,
const sf::Vector2f& direction = sf::Vector2f(0, 0));
virtual ~Circle() = default;
bool testCollision(std::shared_ptr<Sprite> other, int elapsed);
float getRadius() const;
};
#endif /* DG_CIRCLE_H_ */

127
source/abstract/CollisionModel.cpp Normal file
View file

@ -0,0 +1,127 @@
/*
* CollisionModel.cpp
*
* Created on: 07.05.2013
* Author: Felix
*/
#include "CollisionModel.h"
#include <SFML/System.hpp>
#include <Thor/Vectors.hpp>
#include "Circle.h"
#include "Rectangle.h"
#include "../util/Interval.h"
CollisionModel::~CollisionModel() {
}
/**
* Tests for collision between rectangle and circle.
*
* @return True if a collision occured.
*/
bool
CollisionModel::testCollision(const Circle& circle, const Rectangle& rect,
int elapsed) {
sf::Vector2f halfsize = rect.getSize() / 2.0f;
sf::Vector2f circlePos = circle.getPosition();
sf::Vector2f rectPos = rect.getPosition();
// Only circle movement as rectangles don't move.
sf::Vector2f circleMovement = circle.getSpeed() * (elapsed / 1000.0f);
// We assume that rectangles are always axis aligned.
float overlapNoMovementX = Interval::IntervalFromRadius(circlePos.x, circle.getRadius())
.getOverlap(Interval::IntervalFromRadius(rectPos.x, halfsize.x)).getLength();
float overlapMovementX = Interval::IntervalFromRadius(circlePos.x + circleMovement.x, circle.getRadius())
.getOverlap(Interval::IntervalFromRadius(rectPos.x, halfsize.x)).getLength();
float overlapNoMovementY = Interval::IntervalFromRadius(circlePos.y, circle.getRadius())
.getOverlap(Interval::IntervalFromRadius(rectPos.y, halfsize.y)).getLength();
float overlapMovementY = Interval::IntervalFromRadius(circlePos.y + circleMovement.y, circle.getRadius())
.getOverlap(Interval::IntervalFromRadius(rectPos.y, halfsize.y)).getLength();
bool xyCollisionResult = (((overlapNoMovementX < overlapMovementX) &&
(overlapNoMovementY > 0)) ||
((overlapNoMovementY < overlapMovementY) && (overlapNoMovementX > 0)));
// If circle center is overlapping rectangle on x or y axis, we can take xyCollisionResult.
if (Interval::IntervalFromRadius(rectPos.x, halfsize.x).isInside(circlePos.x) ||
Interval::IntervalFromRadius(rectPos.y, halfsize.y).isInside(circlePos.y))
return xyCollisionResult;
// Test if the circle is colliding with a corner of the rectangle.
else if (xyCollisionResult) {
// This is the same as circle-circle collision.
sf::Vector2f axis = circlePos - rectPos;
// If both objects are at the exact same position, allow any
// movement for unstucking.
if (axis == sf::Vector2f())
return true;
axis = thor::unitVector(axis);
float circlePosProjected = thor::dotProduct(axis, circlePos);
float movementProjected = thor::dotProduct(axis, circleMovement);
float rectPosProjected = thor::dotProduct(axis, rectPos);
// For corner projections, those on the same line with the rect
// center are equal by value, so we only need one on each axis
// and take the maximum.
float rectHalfWidthProjected = std::max(
abs(thor::dotProduct(axis, halfsize)),
abs(thor::dotProduct(axis,
sf::Vector2f(halfsize.x, -halfsize.y))));
// Allow movement if sprites are moving apart.
return Interval::IntervalFromRadius(circlePosProjected, circle.getRadius())
.getOverlap(Interval::IntervalFromRadius(rectPosProjected,
rectHalfWidthProjected))
.getLength() <
Interval::IntervalFromRadius(circlePosProjected + movementProjected, circle.getRadius())
.getOverlap(Interval::IntervalFromRadius(rectPosProjected,
rectHalfWidthProjected))
.getLength();
}
// If there is no collision on x and y axis, there can't be one at all.
else {
return false;
}
}
/**
* Tests for collision between two circles.
*
* @return True if a collision occured.
*/
bool
CollisionModel::testCollision(const Circle& first, const Circle& second,
int elapsed) {
sf::Vector2f axis = first.getPosition() - second.getPosition();
// If both objects are at the exact same position, allow any movement for unstucking.
if (axis == sf::Vector2f())
return true;
axis = thor::unitVector(axis);
float centerA = thor::dotProduct(axis, first.getPosition());
float radiusA = first.getRadius();
float movementA = thor::dotProduct(axis, first.getSpeed() * (elapsed / 1000.0f));
float centerB = thor::dotProduct(axis, second.getPosition());
float radiusB = second.getRadius();
float movementB = thor::dotProduct(axis, second.getSpeed() * (elapsed / 1000.0f));
// Allow movement if sprites are moving apart.
return Interval::IntervalFromRadius(centerA, radiusA).getOverlap(
Interval::IntervalFromRadius(centerB, radiusB)).getLength() <
Interval::IntervalFromRadius(centerA + movementA, radiusA).getOverlap(
Interval::IntervalFromRadius(centerB + movementB, radiusB)).getLength();
}
/**
* Tests for collision between two rectangles. Not implemented as these can't
* occur (rectangles can't move).
*
* @return True if a collision occured.
*/
bool
CollisionModel::testCollision(const Rectangle& first, const Rectangle& second,
int elapsed) {
return false;
}

29
source/abstract/CollisionModel.h Normal file
View file

@ -0,0 +1,29 @@
/*
* CollisionModel.h
*
* Created on: 07.05.2013
* Author: Felix
*/
#ifndef DG_COLLISIONMODEL_H_
#define DG_COLLISIONMODEL_H_
class Circle;
class Rectangle;
/**
* Abstract class providing helper functions to test for collisions between shapes.
*/
class CollisionModel {
public:
virtual ~CollisionModel() = 0;
static bool testCollision(const Circle& circle, const Rectangle& rect,
int elapsed);
static bool testCollision(const Circle& first, const Circle& second,
int elapsed);
static bool testCollision(const Rectangle& first, const Rectangle& second,
int elapsed);
};
#endif /* DG_COLLISIONMODEL_H_ */

37
source/abstract/Rectangle.cpp Normal file
View file

@ -0,0 +1,37 @@
/*
* Rectangle.cpp
*
* Created on: 04.05.2013
* Author: Felix
*/
#include "Rectangle.h"
#include "Circle.h"
#include "../util/Yaml.h"
Rectangle::Rectangle(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config,
const sf::Vector2f& direction) :
Sprite(position, category, mask, config.get(YAML_KEY::SIZE, sf::Vector2f()),
config.get(YAML_KEY::TEXTURE, std::string()), direction) {
}
/**
* Returns true if a collision between this and other occured. It does not
* matter which object is this or other.
*/
bool
Rectangle::testCollision(std::shared_ptr<Sprite> other, int elapsed) {
Rectangle* rect = dynamic_cast<Rectangle*>(other.get());
Circle* circle = dynamic_cast<Circle*>(other.get());
if (circle != nullptr)
return CollisionModel::testCollision(*circle, *this, elapsed);
else if (rect != nullptr)
return CollisionModel::testCollision(*rect, *this, elapsed);
else {
assert(false);
return false;
}
}

29
source/abstract/Rectangle.h Normal file
View file

@ -0,0 +1,29 @@
/*
* Rectangle.h
*
* Created on: 04.05.2013
* Author: Felix
*/
#ifndef DG_RECTANGLE_H_
#define DG_RECTANGLE_H_
#include "CollisionModel.h"
#include "Sprite.h"
class Yaml;
/**
* Shape that uses an axis aligned Rectangle as a collision model.
*/
class Rectangle : public CollisionModel, public Sprite {
public:
explicit Rectangle(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config,
const sf::Vector2f& direction = sf::Vector2f(0, 0));
virtual ~Rectangle() = default;
bool testCollision(std::shared_ptr<Sprite> other, int elapsed);
};
#endif /* DG_RECTANGLE_H_ */

102
source/abstract/Sprite.cpp
View file

@ -12,86 +12,35 @@
#include "../util/Loader.h"
#include "../util/Log.h"
#include "../util/ResourceManager.h"
#include "../util/Yaml.h"
/**
* Initializes sprite data.
*
* @param data Container holding construction parameters.
* @param config Additional construction parameters
*/
Sprite::Sprite(const Data& data, const Yaml& config) :
mCategory(data.category),
mMask(data.mask),
Sprite::Sprite(const sf::Vector2f& position, Category category,
unsigned short mask, const sf::Vector2f& size,
const std::string& texture, const sf::Vector2f& direction) :
mCategory(category),
mMask(mask),
mDelete(false) {
// Init shape
float radius = config.get(YAML_KEY::RADIUS, 0.0f);
sf::Vector2f size = config.get(YAML_KEY::SIZE, sf::Vector2f());
if (radius != 0.0f) {
mShape.type = Shape::Type::CIRCLE;
mShape.shape = std::unique_ptr<sf::Shape>(new sf::CircleShape(radius));
mShape.shape->setOrigin(radius, radius);
mShape.shape->setTextureRect(sf::IntRect(sf::Vector2i(0, 0),
sf::Vector2i(radius * 2, radius * 2)));
}
else if (size == sf::Vector2f()) {
LOG_E("Failed to read size or radius from " << config.getFilename() <<
", using texture size.");
size = sf::Vector2f(mTexture->getSize());
}
else if (size != sf::Vector2f()) {
mShape.type = Shape::Type::RECTANGLE;
mShape.shape = std::unique_ptr<sf::Shape>(new sf::RectangleShape(size));
mShape.shape->setOrigin(size / 2.0f);
mShape.shape->setTextureRect(sf::IntRect(sf::Vector2i(0, 0), sf::Vector2i(size)));
}
// Init texture
std::string texture = config.get<std::string>(YAML_KEY::TEXTURE, "");
if (texture != "") {
mShape.setSize(size);
mShape.setOrigin(size / 2.0f);
mShape.setTextureRect(sf::IntRect(sf::Vector2i(), sf::Vector2i(size)));
setPosition(position);
setDirection(direction);
try {
mTexture = ResourceManager::i().acquire(Loader::i()
.fromFile<sf::Texture>(texture));
mShape.shape->setTexture(&*mTexture, false);
mShape.setTexture(&*mTexture, false);
}
catch (thor::ResourceLoadingException&) {
LOG_W("Failed to load texture " << texture << ", coloring red.");
mShape.shape->setFillColor(sf::Color(255, 0, 0));
mShape.setFillColor(sf::Color(255, 0, 0));
}
}
else {
LOG_W("Failed to read texture file name from YAML file " <<
config.getFilename() << ", coloring red.");
mShape.shape->setFillColor(sf::Color(255, 0, 0));
}
setPosition(data.position);
setDirection(data.direction);
}
/**
* Used to make this class pure virtual without any pure virtual function.
*/
Sprite::~Sprite() {
}
/**
* Initializes container.
*/
Sprite::Data::Data(const sf::Vector2f& position, Category category,
unsigned short mask, const sf::Vector2f& direction) :
position(position),
direction(direction),
category(category),
mask(mask) {
}
/**
* Returns the position of the sprite (center).
*/
sf::Vector2f
Sprite::getPosition() const {
return mShape.shape->getPosition();
return mShape.getPosition();
}
/**
@ -107,7 +56,7 @@ Sprite::getSpeed() const {
*/
sf::Vector2f
Sprite::getDirection() const {
return thor::rotatedVector(sf::Vector2f(1, 0), mShape.shape->getRotation());
return thor::rotatedVector(sf::Vector2f(1, 0), mShape.getRotation());
}
/**
@ -132,13 +81,13 @@ Sprite::getCategory() const {
*/
sf::Vector2f
Sprite::getSize() const {
sf::FloatRect bounds = mShape.shape->getLocalBounds();
sf::FloatRect bounds = mShape.getLocalBounds();
return sf::Vector2f(bounds.width, bounds.height);
}
void
Sprite::draw(sf::RenderTarget& target, sf::RenderStates states) const {
target.draw(*mShape.shape, states);
target.draw(mShape, states);
}
/**
@ -151,7 +100,7 @@ Sprite::collisionEnabled(Category category) const {
bool
Sprite::isInside(const sf::FloatRect& rect) const {
return rect.intersects(mShape.shape->getGlobalBounds());
return rect.intersects(mShape.getGlobalBounds());
}
/**
* Called when a collision with another Sprite occured. Override this method
@ -187,7 +136,7 @@ Sprite::setSpeed(sf::Vector2f direction, float speed) {
void
Sprite::setDirection(const sf::Vector2f& direction) {
if (direction != sf::Vector2f())
mShape.shape->setRotation(thor::polarAngle(direction) + 90);
mShape.setRotation(thor::polarAngle(direction) + 90);
}
/**
@ -195,18 +144,5 @@ Sprite::setDirection(const sf::Vector2f& direction) {
*/
void
Sprite::setPosition(const sf::Vector2f& position) {
mShape.shape->setPosition(position);
}
/**
* Returns the radius of this sprite. Will fail if this is not a circle.
*
* @return The radius of this sprite.
*/
float
Sprite::getRadius() const {
std::shared_ptr<sf::CircleShape> circleShape =
std::dynamic_pointer_cast<sf::CircleShape>(mShape.shape);
assert(circleShape);
return circleShape->getRadius();
mShape.setPosition(position);
}

39
source/abstract/Sprite.h
View file

@ -12,8 +12,6 @@
#include <SFML/Graphics.hpp>
class Yaml;
/**
* An sprite that is rendered in the world.
*/
@ -30,21 +28,6 @@ public:
CATEGORY_ACTOR = 1 << 4
};
/**
* Container that carries all data required to construct an object of
* this class.
*/
class Data {
public:
explicit Data(const sf::Vector2f& position,
Category category, unsigned short mask,
const sf::Vector2f& direction = sf::Vector2f(0, 0));
const sf::Vector2f& position;
const sf::Vector2f& direction;
Category category;
unsigned short mask;
};
/**
* Common collision masking values.
*/
@ -55,8 +38,10 @@ public:
// Public functions.
public:
explicit Sprite(const Data& data, const Yaml& config);
virtual ~Sprite() = 0;
explicit Sprite(const sf::Vector2f& position, Category category,
unsigned short mask, const sf::Vector2f& size,
const std::string& texture, const sf::Vector2f& direction);
virtual ~Sprite() = default;
sf::Vector2f getPosition() const;
sf::Vector2f getSpeed() const;
@ -68,6 +53,7 @@ public:
bool collisionEnabled(Category category) const;
bool isInside(const sf::FloatRect& rect) const;
virtual bool testCollision(std::shared_ptr<Sprite> other, int elapsed) = 0;
virtual void onCollide(std::shared_ptr<Sprite> other);
protected:
@ -75,24 +61,11 @@ protected:
void setSpeed(sf::Vector2f direction, float speed);
void setDirection(const sf::Vector2f& direction);
void setPosition(const sf::Vector2f& position);
float getRadius() const;
private:
class Shape {
public:
enum class Type {
CIRCLE,
RECTANGLE
};
Type type;
std::shared_ptr<sf::Shape> shape;
};
private:
friend class World;
Shape mShape;
sf::RectangleShape mShape;
std::shared_ptr<sf::Texture> mTexture;
sf::Vector2f mSpeed;
Category mCategory;

6
source/effects/Bullet.cpp
View file

@ -22,12 +22,12 @@
*/
Bullet::Bullet(const sf::Vector2f& position, Sprite& shooter,
sf::Vector2f direction, const Yaml& config) :
Particle(config, Data(position, CATEGORY_PARTICLE, ~CATEGORY_PARTICLE,
thor::rotatedVector(direction, -90.0f))),
Particle(position, CATEGORY_PARTICLE, ~CATEGORY_PARTICLE,
config, thor::rotatedVector(direction, -90.0f)),
mShooter(shooter),
mDamage(config.get(YAML_KEY::DAMAGE, YAML_DEFAULT::DAMAGE)),
mSpeed(config.get(YAML_KEY::SPEED, YAML_DEFAULT::SPEED)) {
setSpeed(direction, mSpeed);
setSpeed(thor::rotatedVector(direction, -90.0f), mSpeed);
}
/**

6
source/particle/Particle.cpp
View file

@ -7,8 +7,10 @@
#include "Particle.h"
Particle::Particle(const Yaml& config, const Data& data) :
Sprite(data, config) {
Particle::Particle(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config,
const sf::Vector2f& direction) :
Circle(position, category, mask, config, direction) {
}
Particle::~Particle() {

8
source/particle/Particle.h
View file

@ -8,16 +8,18 @@
#ifndef DG_PARTICLE_H_
#define DG_PARTICLE_H_
#include "../abstract/Sprite.h"
#include "../abstract/Circle.h"
class Yaml;
/**
* Prototype for a particle.
*/
class Particle : public Sprite {
class Particle : public Circle {
public:
explicit Particle(const Yaml& config, const Data& data);
explicit Particle(const sf::Vector2f& position, Category category,
unsigned short mask, const Yaml& config,
const sf::Vector2f& direction);
virtual ~Particle();
};

2
source/sprites/Corpse.cpp
View file

@ -12,6 +12,6 @@
const std::string Corpse::CONFIG = "corpse.yaml";
Corpse::Corpse(const sf::Vector2f& position) :
Sprite(Data(position, CATEGORY_NONSOLID, MASK_NONE), Yaml(CONFIG)) {
Circle(position, CATEGORY_NONSOLID, MASK_NONE, Yaml(CONFIG)) {
}

4
source/sprites/Corpse.h
View file

@ -8,9 +8,9 @@
#ifndef DG_CORPSE_H_
#define DG_CORPSE_H_
#include "../abstract/Sprite.h"
#include "../abstract/Circle.h"
class Corpse : public Sprite {
class Corpse : public Circle {
public:
explicit Corpse(const sf::Vector2f& position);

4
source/sprites/Enemy.cpp
View file

@ -15,8 +15,8 @@ const std::string Enemy::CONFIG = "enemy.yaml";
Enemy::Enemy(World& world, Pathfinder& pathfinder,
const sf::Vector2f& position) :
Character(world, pathfinder, Data(position, CATEGORY_ACTOR, MASK_ALL),
Yaml(CONFIG)) {
Character(position, CATEGORY_ACTOR, MASK_ALL, Yaml(CONFIG), world,
pathfinder) {
}
void

4
source/sprites/Player.cpp
View file

@ -18,8 +18,8 @@ const std::string Player::CONFIG = "player.yaml";
*/
Player::Player(World& world, Pathfinder& pathfinder,
const sf::Vector2f& position) :
Character(world, pathfinder,
Data(position, CATEGORY_ACTOR, MASK_ALL), Yaml(CONFIG)),
Character(position, CATEGORY_ACTOR, MASK_ALL, Yaml(CONFIG), world,
pathfinder),
mDirection(0) {
}

4
source/sprites/Tile.cpp
View file

@ -24,8 +24,8 @@ const sf::Vector2i Tile::TILE_SIZE = sf::Vector2i(75, 75);
* @param world Box2D world object.
*/
Tile::Tile(Type type, int x, int y) :
Sprite(Data(sf::Vector2f(x * TILE_SIZE.x, y * TILE_SIZE.y),
CATEGORY_WORLD, (isSolid(type)) ? 0xffff : 0),
Rectangle(sf::Vector2f(x * TILE_SIZE.x, y * TILE_SIZE.y),
CATEGORY_WORLD, (isSolid(type)) ? 0xffff : 0,
Yaml(getConfig(type))),
mType(type) {
}

4
source/sprites/Tile.h
View file

@ -8,12 +8,12 @@
#ifndef DG_TILE_H_
#define DG_TILE_H_
#include "../abstract/Sprite.h"
#include "../abstract/Rectangle.h"
/**
* Holds information about a single tile.
*/
class Tile : public Sprite {
class Tile : public Rectangle {
public:
enum class Type : char {
FLOOR,