game/mario/blocks.hpp

#ifndef BLOCKS_H
#define BLOCKS_H

#include "../sdlpp/sdlpp_rectrenderer.hpp"
#include <SDL2/SDL_rect.h>
#include <memory>

struct LandType {
    enum Value { OVERWORLD = 0, UNDERWORLD = 1, WATER = 2, BOWSER = 4 };
};

class MarioBlock : public SDLPP::RectangleRender {
public:
    MarioBlock(int x, int y, const std::shared_ptr<SDLPP::Renderer> &renderer,
               std::shared_ptr<SDLPP::Texture> texture, SDL_Rect src,
               bool can_be_destroyed = false, bool destructible = false);
    void visit(SDLPP::Visitor &visitor) override;
    void setTool(bool tool = true);
    void setTerrain(bool terrain = true);
    void bounce();
    void travelToPos(const SDLPP::Vec2D<double> &target);
    void custom_move(int ticks) override;
    void setType(LandType::Value type);
    LandType::Value getType() const;
    virtual void onScrollUp() {}
    virtual void onScrollDown() {}
    virtual uint8_t getData() const {
        return 0;
    }
    virtual void setData(uint8_t /*UNUSED*/) {}
    // handle own visitor
    virtual void handleVisitor(SDLPP::Visitor &visitor) {}
    bool hasCoin();
    bool hasMushroom();
    bool hasTeleport();
    void removeCoin();
    void removeMushroom();
    void addMushroom();
    void setCoinCount(int coins);
    void setTeleportLevel(const std::string &level);
    void setDestructible(bool destructible = true);
    void ensureCollision();
    bool isBouncing() const;
    bool isTraveling() const;
    void setBaseRect(SDL_Rect rect);
    void checkVisibility(double rightmost_x);
    bool wasVisible() const;
    void harden();
    const std::string &getTeleportLevel();

protected:
    double bounce_speed = 0.5;
    int bounce_ticks = 100;
    double travel_speed = bounce_speed;
    void gravity(int ticks);
    void setOnGround(bool on_ground = true) {
        _on_ground = on_ground;
        if (on_ground) {
            setMovement(getMovement().getX(), 0);
        }
    }
    bool isOnGround() const {
        return _on_ground;
    }
    void setGravityTicks(int ticks) {
        _base_gravity_ticks = ticks;
    }

    virtual void setWorldTypeSrc(LandType::Value world);

    bool isBouncable() {
        return _bouncable;
    }

    void setBouncable(bool bouncable = true) {
        _bouncable = bouncable;
    }

private:
    bool _tool = false;
    bool _terrain = true;
    bool _destructible = false;
    bool _can_be_destroyed = false;
    bool _bouncing = false;
    bool _traveling = false;
    int _coins = 0;
    bool _mushroom = false;
    std::string _teleport_level = "";
    bool _release_coin = false;
    int ticks_to_bounce = 0;
    SDLPP::Vec2D<double> og_pos = {};
    LandType::Value _type;
    SDL_Rect _base_src;
    SDLPP::Vec2D<double> _target = { 0, 0 };

    bool _on_ground = true;
    int _base_gravity_ticks = 1000 / 60;
    int _ticks_till_gravity = 0;
    double _gravity_acceleration = 1.0 / (64.0 / 7.0);
    bool _was_visible = false;
    bool _bouncable = true;
};

extern const std::vector<uint64_t> possibleBlocks;
extern const std::vector<uint64_t> possibleMods;
extern const std::vector<uint64_t> possibleCharacters;
extern const std::vector<LandType::Value> possibleLands;

struct BlockRole {
    enum Value {
        TERRAIN,
        MODIFIER,
        CHARACTER,
        MARIO,
    };
};

std::shared_ptr<MarioBlock>
createTerrainBlock(uint64_t block_id, LandType::Value type,
                   std::shared_ptr<SDLPP::Renderer> &renderer,
                   bool destructible = false, bool editor = false);
std::shared_ptr<MarioBlock>
createTerrainBlock(uint64_t block_id, LandType::Value type,
                   std::shared_ptr<SDLPP::Renderer> &renderer, int x, int y,
                   bool destructible = false, bool editor = false);
std::shared_ptr<MarioBlock>
createMario(LandType::Value type, std::shared_ptr<SDLPP::Renderer> &renderer,
            int x, int y, bool editor = false);

enum BlockRole::Value getBlockRole(uint64_t id);

#endif