game/mario/blocks/simpleblocks.hpp

#ifndef SIMPLE_BLOCKS_HPP
#define SIMPLE_BLOCKS_HPP

#include "../blocks.hpp"

class FloorBlock : public MarioBlock {
public:
    FloorBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class HillInclineBlock : public MarioBlock {
public:
    HillInclineBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class HillDeclineBlock : public MarioBlock {
public:
    HillDeclineBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class HillDotsRightBlock : public MarioBlock {
public:
    HillDotsRightBlock(int x, int y,
                       std::shared_ptr<SDLPP::Renderer> &renderer);
};

class HillDotsLeftBlock : public MarioBlock {
public:
    HillDotsLeftBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class HillFillBlock : public MarioBlock {
public:
    HillFillBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class HillTopBlock : public MarioBlock {
public:
    HillTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class BushLeftBlock : public MarioBlock {
public:
    BushLeftBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class BushMiddleBlock : public MarioBlock {
public:
    BushMiddleBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class BushRightBlock : public MarioBlock {
public:
    BushRightBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CloudLeftBottomBlock : public MarioBlock {
public:
    CloudLeftBottomBlock(int x, int y,
                         std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CloudMiddleBottomBlock : public MarioBlock {
public:
    CloudMiddleBottomBlock(int x, int y,
                           std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CloudRightBottomBlock : public MarioBlock {
public:
    CloudRightBottomBlock(int x, int y,
                          std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CloudLeftTopBlock : public MarioBlock {
public:
    CloudLeftTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CloudMiddleTopBlock : public MarioBlock {
public:
    CloudMiddleTopBlock(int x, int y,
                        std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CloudRightTopBlock : public MarioBlock {
public:
    CloudRightTopBlock(int x, int y,
                       std::shared_ptr<SDLPP::Renderer> &renderer);
};

class PipeLeftBottomBlock : public MarioBlock {
public:
    PipeLeftBottomBlock(int x, int y,
                        std::shared_ptr<SDLPP::Renderer> &renderer);
};

class PipeRightBottomBlock : public MarioBlock {
public:
    PipeRightBottomBlock(int x, int y,
                         std::shared_ptr<SDLPP::Renderer> &renderer);
};

class PipeLeftTopBlock : public MarioBlock {
public:
    PipeLeftTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class PipeRightTopBlock : public MarioBlock {
public:
    PipeRightTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CastleLeftBlock : public MarioBlock {
public:
    CastleLeftBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CastleRightBlock : public MarioBlock {
public:
    CastleRightBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CastleBlackBlock : public MarioBlock {
public:
    CastleBlackBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CastleEntryBlock : public MarioBlock {
public:
    CastleEntryBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CastleTowerBlock : public MarioBlock {
public:
    CastleTowerBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CastleTowerFilledBlock : public MarioBlock {
public:
    CastleTowerFilledBlock(int x, int y,
                           std::shared_ptr<SDLPP::Renderer> &renderer);
};

class VineTopBlock : public MarioBlock {
public:
    VineTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class VineBottomBlock : public MarioBlock {
public:
    VineBottomBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class PoleTopBlock : public MarioBlock {
public:
    PoleTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class PoleBottomBlock : public MarioBlock {
public:
    PoleBottomBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class FlagBlock : public MarioBlock {
public:
    FlagBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class StepBlock : public MarioBlock {
public:
    StepBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class BrickBlock : public MarioBlock {
public:
    BrickBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class BrickTopBlock : public MarioBlock {
public:
    BrickTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class SidewayPipeEndTopBlock : public MarioBlock {
public:
    SidewayPipeEndTopBlock(int x, int y,
                           std::shared_ptr<SDLPP::Renderer> &renderer);
};

class SidewayPipeEndBottomBlock : public MarioBlock {
public:
    SidewayPipeEndBottomBlock(int x, int y,
                              std::shared_ptr<SDLPP::Renderer> &renderer);
};

class SidewayPipeMiddleTopBlock : public MarioBlock {
public:
    SidewayPipeMiddleTopBlock(int x, int y,
                              std::shared_ptr<SDLPP::Renderer> &renderer);
};

class SidewayPipeMiddleBottomBlock : public MarioBlock {
public:
    SidewayPipeMiddleBottomBlock(int x, int y,
                                 std::shared_ptr<SDLPP::Renderer> &renderer);
};

class SidewayPipeConnectorTopBlock : public MarioBlock {
public:
    SidewayPipeConnectorTopBlock(int x, int y,
                                 std::shared_ptr<SDLPP::Renderer> &renderer);
};

class SidewayPipeConnectorBottomBlock : public MarioBlock {
public:
    SidewayPipeConnectorBottomBlock(int x, int y,
                                    std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreePlatformTopLeftBlock : public MarioBlock {
public:
    TreePlatformTopLeftBlock(int x, int y,
                             std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreePlatformTopMiddleBlock : public MarioBlock {
public:
    TreePlatformTopMiddleBlock(int x, int y,
                               std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreePlatformTopRightBlock : public MarioBlock {
public:
    TreePlatformTopRightBlock(int x, int y,
                              std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreePlatformBarkBlock : public MarioBlock {
public:
    TreePlatformBarkBlock(int x, int y,
                          std::shared_ptr<SDLPP::Renderer> &renderer);
};

class WaterTopBlock : public MarioBlock {
public:
    WaterTopBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class WaterFillBlock : public MarioBlock {
public:
    WaterFillBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class MushroomPlatformTopLeftBlock : public MarioBlock {
public:
    MushroomPlatformTopLeftBlock(int x, int y,
                                 std::shared_ptr<SDLPP::Renderer> &renderer);
};

class MushroomPlatformTopMiddleBlock : public MarioBlock {
public:
    MushroomPlatformTopMiddleBlock(int x, int y,
                                   std::shared_ptr<SDLPP::Renderer> &renderer);
};

class MushroomPlatformTopRightBlock : public MarioBlock {
public:
    MushroomPlatformTopRightBlock(int x, int y,
                                  std::shared_ptr<SDLPP::Renderer> &renderer);
};

class MushroomPlatformBarkTopBlock : public MarioBlock {
public:
    MushroomPlatformBarkTopBlock(int x, int y,
                                 std::shared_ptr<SDLPP::Renderer> &renderer);
};

class MushroomPlatformBarkBottomBlock : public MarioBlock {
public:
    MushroomPlatformBarkBottomBlock(int x, int y,
                                    std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreeBarkBlock : public MarioBlock {
public:
    TreeBarkBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreeLeavesSmallBlock : public MarioBlock {
public:
    TreeLeavesSmallBlock(int x, int y,
                         std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreeLeavesTopBlock : public MarioBlock {
public:
    TreeLeavesTopBlock(int x, int y,
                       std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TreeLeavesBottomBlock : public MarioBlock {
public:
    TreeLeavesBottomBlock(int x, int y,
                          std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CannonTowerBlock : public MarioBlock {
public:
    CannonTowerBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CannonPedestalBlock : public MarioBlock {
public:
    CannonPedestalBlock(int x, int y,
                        std::shared_ptr<SDLPP::Renderer> &renderer);
};

class CannonBlock : public MarioBlock {
public:
    CannonBlock(int x, int y, std::shared_ptr<SDLPP::Renderer> &renderer);
};

//------------------ MODS------------------------------------------------------
class DestructibleModifierBlock : public MarioBlock {
public:
    DestructibleModifierBlock(int x, int y,
                              std::shared_ptr<SDLPP::Renderer> &renderer);
};

class BackgroundModifierBlock : public MarioBlock {
public:
    BackgroundModifierBlock(int x, int y,
                            std::shared_ptr<SDLPP::Renderer> &renderer);
};

class MushroomModifierBlock : public MarioBlock {
public:
    MushroomModifierBlock(int x, int y,
                          std::shared_ptr<SDLPP::Renderer> &renderer);
};

class TeleportModifierBlock : public MarioBlock {
public:
    TeleportModifierBlock(int x, int y,
                          std::shared_ptr<SDLPP::Renderer> &renderer);
};

#endif