File GridObject.h

File List > GridObject.h

Go to the documentation of this file

#ifndef GRID_PLUS_PLUS_GRID_OBJECT_H_
#define GRID_PLUS_PLUS_GRID_OBJECT_H_

#include <string>
#include <utility>

#include "raylib.h"

namespace gridpp {

class GridEngine;

class GridObject {
public:
    GridObject() = default;
    GridObject(std::string asset_name, int x, int y);
    GridObject(const GridObject& other);
    GridObject& operator=(const GridObject& other) = delete;
    virtual ~GridObject() = default;

    virtual void OnSpawn();

    virtual void OnUpdate();

    virtual void OnCollide(GridObject* other);

    virtual void Render(GridEngine* engine);

    int x() const;
    int y() const;
    void set_x(int x);
    void set_y(int y);
    void Move(int dx, int dy);

    const std::string& asset_name() const;
    void set_asset_name(const std::string& asset_name);

    const std::string& tag() const;
    void set_tag(const std::string& tag);

    int direction() const;
    void set_direction(int direction);

    Color tint() const;
    void set_tint(Color tint);

    int z_index() const;
    void set_z_index(int z_index);

    bool visible() const;
    void set_visible(bool visible);

    GridEngine* engine() const;

private:
    friend class GridEngine;

    void set_engine(GridEngine* engine);

    int grid_x_ = 0;
    int grid_y_ = 0;

    std::string asset_name_;
    std::string tag_;

    int direction_ = 0;
    Color tint_ = WHITE;
    int z_index_ = 0;
    bool visible_ = true;

    GridEngine* engine_ = nullptr;
};

class CallbackGridObject : public GridObject {
public:
    using UpdateFn = void (*)(GridObject* self);
    using CollideFn = void (*)(GridObject* self, GridObject* other);

    CallbackGridObject(std::string asset_name, int x, int y, UpdateFn update, CollideFn collide = nullptr);

    void OnUpdate() override;
    void OnCollide(GridObject* other) override;

private:
    UpdateFn update_;
    CollideFn collide_;
};

// Inline definitions

inline GridObject::GridObject(std::string asset_name, int x, int y)
    : grid_x_(x), grid_y_(y), asset_name_(std::move(asset_name)) {}

inline GridObject::GridObject(const GridObject& other)
    : grid_x_(other.grid_x_),
      grid_y_(other.grid_y_),
      asset_name_(other.asset_name_),
      tag_(other.tag_),
      direction_(other.direction_),
      tint_(other.tint_),
      z_index_(other.z_index_),
      visible_(other.visible_),
      engine_(nullptr) {}

inline void GridObject::OnSpawn() {}

inline void GridObject::OnUpdate() {}

inline void GridObject::OnCollide(GridObject* other) { (void)other; }

inline int GridObject::x() const { return grid_x_; }

inline int GridObject::y() const { return grid_y_; }

inline void GridObject::set_x(int x) { grid_x_ = x; }

inline void GridObject::set_y(int y) { grid_y_ = y; }

inline void GridObject::Move(int dx, int dy) {
    grid_x_ += dx;
    grid_y_ += dy;
}

inline const std::string& GridObject::asset_name() const { return asset_name_; }

inline void GridObject::set_asset_name(const std::string& asset_name) { asset_name_ = asset_name; }

inline const std::string& GridObject::tag() const { return tag_; }

inline void GridObject::set_tag(const std::string& tag) { tag_ = tag; }

inline int GridObject::direction() const { return direction_; }

inline void GridObject::set_direction(int direction) { direction_ = ((direction % 4) + 4) % 4; }

inline Color GridObject::tint() const { return tint_; }

inline void GridObject::set_tint(Color tint) { tint_ = tint; }

inline int GridObject::z_index() const { return z_index_; }

inline void GridObject::set_z_index(int z_index) { z_index_ = z_index; }

inline bool GridObject::visible() const { return visible_; }

inline void GridObject::set_visible(bool visible) { visible_ = visible; }

inline GridEngine* GridObject::engine() const { return engine_; }

inline void GridObject::set_engine(GridEngine* engine) { engine_ = engine; }

inline CallbackGridObject::CallbackGridObject(std::string asset_name, int x, int y, UpdateFn update, CollideFn collide)
    : GridObject(std::move(asset_name), x, y), update_(update), collide_(collide) {}

inline void CallbackGridObject::OnUpdate() {
    if (update_ != nullptr) update_(this);
}

inline void CallbackGridObject::OnCollide(GridObject* other) {
    if (collide_ != nullptr) collide_(this, other);
}

}  // namespace gridpp

#endif  // GRID_PLUS_PLUS_GRID_OBJECT_H_