201 lines
4.8 KiB
C++
Executable file
201 lines
4.8 KiB
C++
Executable file
/*
|
|
* Sprite.cpp
|
|
*
|
|
* Created on: 11.08.2012
|
|
* Author: Felix
|
|
*/
|
|
|
|
#include "Sprite.h"
|
|
|
|
#include <Thor/Vectors.hpp>
|
|
|
|
#include "../util/Loader.h"
|
|
#include "../util/Log.h"
|
|
#include "../util/ResourceManager.h"
|
|
#include "../util/Yaml.h"
|
|
|
|
const std::string Sprite::KEY_SIZE = "size";
|
|
const std::string Sprite::KEY_RADIUS = "radius";
|
|
const std::string Sprite::KEY_TEXTURE = "texture";
|
|
|
|
/**
|
|
* 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),
|
|
mDelete(false) {
|
|
std::string texture = config.get<std::string>(KEY_TEXTURE, "");
|
|
if (texture == "") {
|
|
LOG_E("Failed to read texture from YAML file " << config.getFilename());
|
|
}
|
|
mTexture = ResourceManager::i().acquire(Loader::i()
|
|
.fromFile<sf::Texture>(texture));
|
|
|
|
float radius = config.get(KEY_RADIUS, 0.0f);
|
|
sf::Vector2f size = config.get(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()) {
|
|
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)));
|
|
}
|
|
else {
|
|
LOG_E("Could not read size or radius from " << config.getFilename());
|
|
}
|
|
|
|
mShape.shape->setTexture(&*mTexture, false);
|
|
|
|
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, const sf::Vector2f& direction,
|
|
Category category, unsigned short mask) :
|
|
position(position),
|
|
direction(direction),
|
|
category(category),
|
|
mask(mask) {
|
|
}
|
|
|
|
/**
|
|
* Returns the position of the sprite (center).
|
|
*/
|
|
sf::Vector2f
|
|
Sprite::getPosition() const {
|
|
return mShape.shape->getPosition();
|
|
}
|
|
|
|
/**
|
|
* Returns the movement speed of the sprite.
|
|
*/
|
|
sf::Vector2f
|
|
Sprite::getSpeed() const {
|
|
return mSpeed;
|
|
}
|
|
|
|
/**
|
|
* Returns the angle of the sprite.
|
|
*/
|
|
sf::Vector2f
|
|
Sprite::getDirection() const {
|
|
return thor::rotatedVector(sf::Vector2f(1, 0), mShape.shape->getRotation());
|
|
}
|
|
|
|
/**
|
|
* Returns true if this object should be deleted.
|
|
*/
|
|
bool
|
|
Sprite::getDelete() const {
|
|
return mDelete;
|
|
}
|
|
|
|
/**
|
|
* Returns the Category of this object.
|
|
*/
|
|
Sprite::Category
|
|
Sprite::getCategory() const {
|
|
return mCategory;
|
|
}
|
|
|
|
/**
|
|
* Returns the size of the sprite as a vector (bottom left to top right),
|
|
* does not consider rotation.
|
|
*/
|
|
sf::Vector2f
|
|
Sprite::getSize() const {
|
|
sf::FloatRect bounds = mShape.shape->getLocalBounds();
|
|
return sf::Vector2f(bounds.width, bounds.height);
|
|
}
|
|
|
|
void
|
|
Sprite::draw(sf::RenderTarget& target, sf::RenderStates states) const {
|
|
target.draw(*mShape.shape, states);
|
|
}
|
|
|
|
/**
|
|
* Returns true if collisions with that category are enabled through mask.
|
|
*/
|
|
bool
|
|
Sprite::collisionEnabled(Category category) const {
|
|
return (category & mMask) != 0;
|
|
}
|
|
|
|
/**
|
|
* Called when a collision with another Sprite occured. Override this method
|
|
* to manage collision events.
|
|
*
|
|
* @param other The other Sprite in the collision.
|
|
*/
|
|
void
|
|
Sprite::onCollide(std::shared_ptr<Sprite> other) {
|
|
}
|
|
|
|
/**
|
|
* Set to true to mark this object for deletion from the world.
|
|
*/
|
|
void
|
|
Sprite::setDelete(bool value) {
|
|
mDelete = value;
|
|
}
|
|
|
|
/**
|
|
* Sets movement speed and direction of the Sprite. Set either value to zero to stop movement.
|
|
*
|
|
* @param direction The direction the Sprite moves in, does not have to be normalized.
|
|
* @param speed Movement speed in pixels per second.
|
|
*/
|
|
void
|
|
Sprite::setSpeed(sf::Vector2f direction, float speed) {
|
|
if (direction != sf::Vector2f()) {
|
|
thor::setLength(direction, speed);
|
|
}
|
|
mSpeed = direction;
|
|
}
|
|
|
|
void
|
|
Sprite::setDirection(const sf::Vector2f& direction) {
|
|
if (direction != sf::Vector2f()) {
|
|
mShape.shape->setRotation(thor::polarAngle(direction) + 90);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the position of thr Sprite.
|
|
*/
|
|
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();
|
|
}
|