game.h

Go to the documentation of this file.

 
 
#ifndef ASW_COMPONENTS_H
#define ASW_COMPONENTS_H
 
#include <string>
 
#include "./color.h"
#include "./draw.h"
#include "./geometry.h"
#include "./util.h"
 
namespace asw::game {
 
class Physics {
public:
    // Velocity in pixels per second
    asw::Vec2<float> velocity;
    // Acceleration in pixels per second squared
    asw::Vec2<float> acceleration;
    // Angular velocity in radians per second
    float angular_velocity { 0.0F };
    // Angular acceleration in radians per second squared
    float angular_acceleration { 0.0F };
};
 
 
class GameObject {
public:
    GameObject() = default;
 
    virtual ~GameObject() = default;
 
    virtual void update(float dt)
    {
        body.velocity += body.acceleration * dt;
        transform.position += body.velocity * dt;
        body.angular_velocity += body.angular_acceleration * dt;
        rotation += body.angular_velocity * dt;
    };
 
    virtual void draw() {
        // Do nothing by default
    };
 
    const asw::Quad<float>& get_transform() const
    {
        return transform;
    }
 
    asw::Quad<float> transform;
 
    float rotation { 0.0F };
 
    int z_index { 0 };
 
    bool active { true };
 
    float alpha { 1.0F };
 
    Physics body;
 
    bool alive { true };
};
 
class Sprite : public GameObject {
public:
    void set_texture(const asw::Texture& texture, bool auto_size = true)
    {
        this->texture_ = texture;
 
        if (auto_size) {
            transform.size = asw::util::get_texture_size(texture_);
        }
    }
 
    void draw() override
    {
        if (texture_ == nullptr) {
            return;
        }
 
        if (alpha < 1.0F) {
            asw::draw::set_alpha(texture_, alpha);
        }
 
        if (rotation != 0.0F) {
            asw::draw::rotate_sprite(texture_, transform.position, rotation);
        } else {
            asw::draw::stretch_sprite(texture_, transform);
        }
 
        if (alpha < 1.0F) {
            asw::draw::set_alpha(texture_, 1.0F);
        }
    }
 
private:
    asw::Texture texture_;
};
 
class Text : public GameObject {
public:
    void set_font(const asw::Font& font)
    {
        this->font_ = font;
    }
 
    void set_text(const std::string_view& text)
    {
        this->text_ = text;
    }
 
    void set_color(const asw::Color& color)
    {
        this->color_ = color;
    }
 
    void set_justify(asw::TextJustify justify)
    {
        this->justify_ = justify;
    }
 
    void draw() override
    {
        asw::draw::text(font_, text_, transform.position, color_, justify_);
    }
 
private:
    std::string text_;
    asw::Font font_;
    asw::Color color_;
    asw::TextJustify justify_ { asw::TextJustify::Left };
};
 
}; // namespace asw::game
 
#endif // ASW_COMPONENTS_H