Components class
Some class for components
AnimationComponent || AnimationOneTimeComponent
class AnimationComponent {
public:
AnimationComponent(){}
private:
};
class AnimationOneTimeComponent {
public:
AnimationOneTimeComponent(){}
size_t _frame;
};
Can be used to animate an entity.
MovableComponent
class MovableComponent {
public:
MovableComponent(){}
private:
};
When you add MovableComponent to an entity, it can move. Without this component, your entity cannot move.
ButtonComponent
class ButtonComponent {
public:
ButtonComponent(std::function<void()> callback);
void executeAction();
private:
std::function<void()> _callback;
};
ButtonComponent is used for example to create a button. As you can see, you can give it a function or an anction to do when he's clicked and that's useful for a button.
ControllableComponent
class ControllableComponent {
public:
ControllableComponent(std::initializer_list<sf::Keyboard::Key> controls);
const std::vector<sf::Keyboard::Key> &getControls() const;
int getEvent() const;
void setEvent(int event);
private:
std::vector<sf::Keyboard::Key> _controls;
int _event = 0;
};
You will use this class to set your entity position.
The method
ControllableComponent()
present in this class will be useful to set which keys you want to control your entity. Ex: For our player, we set key up, key down, key right, key left.The method
getControls()
will be useful to get all the keys registered with your entity. Ex: If user press key down, we will be loop on getControls function and check if the key has been pressed (if yes, player will move, otherwise player will not move).The method
getEvent()
can be use to get actual events.The method
setEvent
can set actuel event into an int.
LoadingBarComponent
class LoadingBarComponent {
public:
LoadingBarComponent(float maximumWidth, float textureWidth);
float getMaximumWidth() const;
float getTextureWidth() const;
void setMaximumWidth(float maximumWidth);
void setTextureWidth(float textureWidth);
float calculate(float currentWidth);
private:
float _maximumWidth;
float _textureWidth;
};
LoadingBarComponent is an usefull class to create flexible bar, like a life bar for example.
The method calculate
automatically set the width of your bar using its parameter float currentWidth
.
MusicComponent
class MusicComponent {
public:
MusicComponent(const std::string &musicPath, float volume = 100.0f, bool loop = false): _musicPath(musicPath);
int playMusic();
int pauseMusic();
int stopmusic();
void setLoop(bool loop);
void setVolume(float volume);
sf::SoundSource::Status getStatus();
float getVolume() const;
private:
std::string _musicPath;
std::shared_ptr<sf::Music> _music;
};
MusicComponent as you may guess, is the component that you will use to handle the music behavior in your game. Its simply an encapsulation of the sfml sf::Music class.
ParallaxComponent
class ParallaxComponent {
public:
ParallaxComponent(float scrollSpeed, float backgroundWidth)
float getScrollSpeed() const
float getBackgroundWidth() const
void setScrollSpeed(float scrollSpeed)
private:
float _scrollSpeed;
float _backgroundWidth;
};
If you want to move an entity from left to the right automatically (like a parallax, ex: game's background) you can use the parallax component. This class needs to the size of your sprite sheet and the speed where it will move.
ParticuleComponent
class ParticuleComponent {
public:
ParticuleComponent(const sf::IntRect &rect, const sf::Color &color, const size_t &duration);
std::chrono::system_clock::time_point getTime() const;
sf::IntRect getRect() const;
sf::Color getColor() const;
size_t getDuration() const;
private:
std::chrono::system_clock::time_point _time;
sf::IntRect _rect;
sf::Color _color;
size_t _duration;
};
The ParticuleComponent
can be use to create particule with rectangle using sf::IntRect from SFML graphic library.
You can either set the color of the particule and the duration.
PositionComponent
class PositionComponent {
public:
PositionComponent()
PositionComponent(float x, float y)
void setX(float newX)
void setY(float newY)
float getX() const
float getY() const
private:
float _x;
float _y;
};
This component can be use to set and get the position of an entity who've this component has been added.
At first, you will use this component to set the position of an entity at the. construction
Secondly, with the methods at your disposition, you will be able to change the current position of your entity (in game) "SET" methods.
Finally, you can get the position of your entity using "GET" methods.
RectangleShapeComponent
class RectangleShapeComponent {
public:
RectangleShapeComponent(const sf::Vector2f &size, const sf::Color &color, const sf::Vector2f &pos);
RectangleShapeComponent(const std::shared_ptr<sf::Texture> &texture, const sf::IntRect &rect, const sf::Vector2f &pos);
void setTexture(const std::shared_ptr<sf::Texture> &texture);
void setSize(const sf::Vector2f &size);
void setColor(const sf::Color &color);
void setPosition(const sf::Vector2f &pos);
void setTextureRect(const sf::IntRect &rect);
const sf::IntRect &getTextureRect() const;
const sf::Vector2f &getSize() const;
const sf::Color &getColor() const;
const sf::Vector2f &getPosition() const;
sf::RectangleShape &getRectangleShape();
void setScale(const float &scaleX, const float &scaleY):
private:
sf::RectangleShape _bar;
};
RectangleShapeComponent is the component that we use for the player life we can set which Rect that we want depending on the player life. You will find a lot of methods that are useful to handle the display of one of your entities.
ScaleComponent
class ScaleComponent {
public:
ScaleComponent()
ScaleComponent(const float &scaleX, const float &scaleY)
void setScale(const float &newScaleX, const float &newScaleY)
float getScaleX() const
float getScaleY() const
private:
float _scaleX;
float _scaleY;
};
This component can be use if your entity does'nt fit as you want. Using this component, you can fit your entity as you want.
The first part of this class is useful to set the scale you want for your entity,
The second one will be useful if you want to get the scale set to an entity at his creation.
SoundComponent
class SoundComponent {
public:
SoundComponent(const std::string &soundPath, float volume = 100.0f, bool play = false): _soundPath(soundPath);
int playSound();
int pauseSound();
int stopSound();
void setVolume(float volume);
sf::SoundSource::Status getStatus() const;
float getVolume() const;
private:
std::string _soundPath;
std::shared_ptr<sf::SoundBuffer> _soundBuffer;
std::shared_ptr<sf::Sound> _sound;
};
SoundComponent is the component that we use for the sound created when the player shoots for example. A sound is different than a music because a sound will be shorter than a music. You will use that if you want a short sonore effect when an action has been done for example.
SpriteComponent
This component is use to store the entity's sprite
class SpriteComponent {
public:
SpriteComponent(const std::shared_ptr<sf::Texture> &texture)
void setTexture(const sf::Texture &texture)
void setPosition(const sf::Vector2f &position)
void setScale(const float &scaleX, const float &scaleY)
void setTextureRect(const sf::IntRect &rect)
sf::Sprite &getSprite()
const sf::Sprite &getSprite() const
private:
sf::Sprite _sprite;
};
If you're using this component, you can:
At first, you will create you sprite from a texture (give details/position)
After that's, you have can set the position of your sprite and set scale for your sprite
However, you can also get the sprite used using the getter method.
TextComponent
class TextComponent {
public:
TextComponent(const sf::Font &font, const std::string &str = "", const size_t &size = 20, const sf::Color &color = sf::Color::White, const sf::Text::Style &style = sf::Text::Style::Regular);
void setString(const std::string &str);
void setSize(const size_t &size);
void setColor(const sf::Color &color);
void setStyle(const sf::Text::Style &style);
void setPosition(const float &x, const float &y);
void setPosition(const sf::Vector2f &pos);
void setScale(const float &x, const float &y);
void setScale(const sf::Vector2f &scale);
const sf::Text &getText() const;
private:
sf::Text _text;
};
TextComponent is the component that you have to use if you wantt to write something on your screen. In this one, you can adjust what you want like position, size, color, content or things like that for your text. You're free to write what you wan and above all how you want.
TextureRectComponent
class TextureRectComponent {
public:
TextureRectComponent(int left, int top, int totalWidth, int height, int numFrames, float frameDelay)
sf::IntRect &getTextureRect()
const sf::IntRect &getTextureRect() const
sf::IntRect _textureRect
int _frameWidth
int _numFrames
float _frameDelay
float _timeSinceLastFrameChange
};
TextureRect component is useful to set your sprite correctly. To works normally, it needs to get the right informations about the position of your differents things in your sprite's file.
VelocityComponent
class VelocityComponent {
public:
VelocityComponent(float dx, float dy)
float getInitialDX() const
float getInitialDY() const
float getDX() const
float getDY() const
void setDX(float dx)
void setDY(float dy)
private:
float _initialDx;
float _initialDy;
float _dx;
float _dy;
};
This component is very useful to set the velocity to an entity. It works with de MoveComponent component. To works correctly, it needs to get two mains informations : direction &. speed. Once it's setted, your entity will move depending on params you gave.
Last updated