Changed sprites to always render as rectangle.
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:
parent
22bcd8cf13
commit
aa6df65e97
20 changed files with 367 additions and 260 deletions
116
source/World.cpp
116
source/World.cpp
|
@ -70,17 +70,17 @@ 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -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.
|
||||
*/
|
||||
|
|
|
@ -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)),
|
||||
|
|
|
@ -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
46
source/abstract/Circle.cpp
Normal 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
30
source/abstract/Circle.h
Normal 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
127
source/abstract/CollisionModel.cpp
Normal 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
29
source/abstract/CollisionModel.h
Normal 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
37
source/abstract/Rectangle.cpp
Normal 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
29
source/abstract/Rectangle.h
Normal 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_ */
|
|
@ -12,78 +12,27 @@
|
|||
#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) {
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -91,7 +40,7 @@ Sprite::Data::Data(const sf::Vector2f& position, Category category,
|
|||
*/
|
||||
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);
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
@ -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,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();
|
||||
};
|
||||
|
||||
|
|
|
@ -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)) {
|
||||
}
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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) {
|
||||
}
|
||||
|
||||
|
|
|
@ -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) {
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
|
|
Reference in a new issue