MapActions.hpp

Go to the documentation of this file.

#ifndef EDITOR_COMPONENTS_MAPACTIONS_HPP
#define EDITOR_COMPONENTS_MAPACTIONS_HPP
 
#include <Editor/Components/EditMap.hpp>
 
namespace editor
{
namespace component
{
class EditMap::SetTileAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, unsigned int layer,
                                       const sf::Vector2i& pos, bool isAnim,
                                       core::map::Tile::IdType value, const EditMap& map);
 
    virtual ~SetTileAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const unsigned int layer;
    const sf::Vector2i position;
    const core::map::Tile::IdType prev;
    const bool wasAnim;
    const core::map::Tile::IdType updated;
    const bool isAnim;
 
    SetTileAction(unsigned int level, unsigned int layer, const sf::Vector2i& pos,
                  core::map::Tile::IdType prev, bool wasAnim, core::map::Tile::IdType value,
                  bool isAnim);
};
 
class EditMap::SetTileAreaAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, unsigned int layer,
                                       const sf::IntRect& area, bool isAnim,
                                       core::map::Tile::IdType value, const EditMap& map);
 
    virtual ~SetTileAreaAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const unsigned int layer;
    const sf::IntRect area;
    const bl::ctr::Vector2D<core::map::Tile::IdType> prev;
    const bl::ctr::Vector2D<std::uint8_t> wasAnim;
    const core::map::Tile::IdType updated;
    const bool isAnim;
    const int w;
    const int h;
 
    SetTileAreaAction(unsigned int level, unsigned int layer, const sf::IntRect& area,
                      bl::ctr::Vector2D<core::map::Tile::IdType>&& prev,
                      bl::ctr::Vector2D<std::uint8_t>&& wasAnim,
                      core::map::Tile::IdType value, bool isAnim, int w, int h);
};
 
class EditMap::FillTileAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int level, unsigned int layer, const sf::Vector2i& pos,
                              core::map::Tile::IdType id, bool isAnim, EditMap& map);
 
    virtual ~FillTileAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    struct FillTile {
        sf::Vector2i position;
        core::map::Tile::IdType id;
        bool isAnim;
 
        FillTile(const sf::Vector2i& pos, const core::map::Tile& tile)
        : position(pos)
        , id(tile.id())
        , isAnim(tile.isAnimation()) {}
    };
 
    const unsigned int level;
    const unsigned int layer;
    const core::map::Tile::IdType id;
    const bool isAnim;
    const std::vector<FillTile> set;
 
    FillTileAction(unsigned int level, unsigned int layer, core::map::Tile::IdType id, bool isAnim,
                   std::vector<FillTile>&& set);
};
 
class EditMap::SetCollisionAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, const sf::Vector2i& pos,
                                       core::map::Collision value, const EditMap& map);
 
    virtual ~SetCollisionAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const sf::Vector2i pos;
    const core::map::Collision value;
    const core::map::Collision ogVal;
 
    SetCollisionAction(unsigned int level, const sf::Vector2i& pos, core::map::Collision value,
                       core::map::Collision ogVal);
};
 
class EditMap::FillCollisionAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int level, const sf::Vector2i& pos, core::map::Collision col,
                              EditMap& map);
 
    virtual ~FillCollisionAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const core::map::Collision col;
    const std::vector<std::pair<sf::Vector2i, core::map::Collision>> set;
 
    FillCollisionAction(unsigned int level, core::map::Collision col,
                        std::vector<std::pair<sf::Vector2i, core::map::Collision>>&& set);
};
 
class EditMap::SetCollisionAreaAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, const sf::IntRect& area,
                                       core::map::Collision value, const EditMap& map);
 
    virtual ~SetCollisionAreaAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const sf::IntRect area;
    const core::map::Collision value;
    const bl::ctr::Vector2D<core::map::Collision> ogVals;
 
    SetCollisionAreaAction(unsigned int level, const sf::IntRect& area, core::map::Collision value,
                           bl::ctr::Vector2D<core::map::Collision>&& ogcols);
};
 
class EditMap::SetCatchAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, const sf::Vector2i& pos,
                                       std::uint8_t value, const EditMap& map);
 
    virtual ~SetCatchAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const sf::Vector2i pos;
    const std::uint8_t value;
    const std::uint8_t ogVal;
 
    SetCatchAction(unsigned int level, const sf::Vector2i& pos, std::uint8_t value,
                   std::uint8_t ogVal);
};
 
class EditMap::SetCatchAreaAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, const sf::IntRect& area,
                                       std::uint8_t value, const EditMap& map);
 
    virtual ~SetCatchAreaAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const sf::IntRect area;
    const std::uint8_t value;
    const bl::ctr::Vector2D<std::uint8_t> ogVals;
 
    SetCatchAreaAction(unsigned int level, const sf::IntRect& area, std::uint8_t value,
                       bl::ctr::Vector2D<std::uint8_t>&& ogcols);
};
 
class EditMap::FillCatchAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int level, const sf::Vector2i& pos, std::uint8_t id,
                              EditMap& map);
 
    virtual ~FillCatchAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const std::uint8_t id;
    const std::vector<std::pair<sf::Vector2i, std::uint8_t>> set;
 
    FillCatchAction(unsigned int level, std::uint8_t id,
                    std::vector<std::pair<sf::Vector2i, std::uint8_t>>&& set);
};
 
class EditMap::SetPlaylistAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(const std::string& playlist, const EditMap& editMap);
 
    virtual ~SetPlaylistAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::string orig;
    const std::string playlist;
 
    SetPlaylistAction(const std::string& orig, const std::string& playlist);
};
 
class EditMap::SetNameAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(const std::string& name, const EditMap& editMap);
 
    virtual ~SetNameAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::string orig;
    const std::string name;
 
    SetNameAction(const std::string& orig, const std::string& name);
};
 
class EditMap::SetWeatherAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(core::map::Weather::Type type, const EditMap& map);
 
    virtual ~SetWeatherAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::Weather::Type type;
    const core::map::Weather::Type orig;
 
    SetWeatherAction(core::map::Weather::Type type, core::map::Weather::Type orig);
};
 
class EditMap::AppendLayerAction : public EditMap::Action {
public:
    enum Location { Bottom, YSort, Top };
 
    static EditMap::Action::Ptr create(unsigned int level, Location location);
 
    virtual ~AppendLayerAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const Location location;
 
    AppendLayerAction(unsigned int level, Location location);
};
 
class EditMap::RemoveLayerAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, unsigned int layer, const EditMap& map);
 
    virtual ~RemoveLayerAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const unsigned int layer;
    const core::map::TileLayer removedLayer;
 
    RemoveLayerAction(unsigned int level, unsigned int layer,
                      const core::map::TileLayer& removedLayer);
};
 
class EditMap::ShiftLayerAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, unsigned int layer, bool up);
 
    virtual ~ShiftLayerAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const unsigned int layer;
    const bool up;
 
    ShiftLayerAction(unsigned int level, unsigned int layer, bool up);
};
 
class EditMap::ShiftLevelAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(unsigned int level, bool up);
 
    virtual ~ShiftLevelAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const bool up;
 
    ShiftLevelAction(unsigned int level, bool up);
};
 
class EditMap::AppendLevelAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create();
 
    virtual ~AppendLevelAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    AppendLevelAction() = default;
};
 
class EditMap::SetScriptAction : public EditMap::Action {
public:
    static EditMap::Action::Ptr create(bool load, const std::string& s, const std::string& p);
 
    virtual ~SetScriptAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const bool load;
    const std::string s;
    const std::string p;
 
    SetScriptAction(bool load, const std::string& s, const std::string& p);
};
 
class EditMap::AddEventAction : public EditMap::Action {
public:
    static Action::Ptr create(const core::map::Event& e, unsigned int i);
 
    virtual ~AddEventAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::Event event;
    const unsigned int i;
 
    AddEventAction(const core::map::Event& e, unsigned int i);
};
 
class EditMap::EditEventAction : public EditMap::Action {
public:
    static Action::Ptr create(const core::map::Event& orig, const core::map::Event& val,
                              unsigned int i);
 
    virtual ~EditEventAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::Event orig;
    const core::map::Event val;
    const unsigned int i;
 
    EditEventAction(const core::map::Event& orig, const core::map::Event& val, unsigned int i);
};
 
class EditMap::RemoveEventAction : public EditMap::Action {
public:
    static Action::Ptr create(const core::map::Event& e, unsigned int i);
 
    virtual ~RemoveEventAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::Event event;
    const unsigned int i;
 
    RemoveEventAction(const core::map::Event& orig, unsigned int i);
};
 
class EditMap::AddSpawnAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int lvl, const sf::Vector2i& pos, unsigned int id,
                              bl::tmap::Direction dir);
 
    virtual ~AddSpawnAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int level;
    const sf::Vector2i pos;
    const unsigned int id;
    const bl::tmap::Direction dir;
 
    AddSpawnAction(unsigned int lvl, const sf::Vector2i& pos, unsigned int id,
                   bl::tmap::Direction dir);
};
 
class EditMap::RotateSpawnAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int id);
 
    virtual ~RotateSpawnAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int id;
 
    RotateSpawnAction(unsigned int id);
};
 
class EditMap::RemoveSpawnAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int id, const core::map::Spawn& spawn);
 
    virtual ~RemoveSpawnAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int id;
    const core::map::Spawn spawn;
 
    RemoveSpawnAction(unsigned int id, const core::map::Spawn& spawn);
};
 
class EditMap::AddNpcSpawnAction : public EditMap::Action {
public:
    static Action::Ptr create(const core::map::CharacterSpawn& s, unsigned int i);
 
    virtual ~AddNpcSpawnAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::CharacterSpawn spawn;
    const unsigned int i;
 
    AddNpcSpawnAction(const core::map::CharacterSpawn& s, unsigned int i);
};
 
class EditMap::EditNpcSpawnAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int i, const core::map::CharacterSpawn& orig,
                              const core::map::CharacterSpawn& s);
 
    virtual ~EditNpcSpawnAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int i;
    const core::map::CharacterSpawn orig;
    const core::map::CharacterSpawn value;
 
    EditNpcSpawnAction(unsigned int i, const core::map::CharacterSpawn& orig,
                       const core::map::CharacterSpawn& s);
};
 
class EditMap::RemoveNpcSpawnAction : public EditMap::Action {
public:
    static Action::Ptr create(const core::map::CharacterSpawn& orig, unsigned int i);
 
    virtual ~RemoveNpcSpawnAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::CharacterSpawn orig;
    const unsigned int i;
 
    RemoveNpcSpawnAction(const core::map::CharacterSpawn& orig, unsigned int i);
};
 
class EditMap::AddOrEditItemAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int i, unsigned int level, const sf::Vector2i& pos,
                              core::item::Id item, bool visible, const core::map::Item& orig,
                              bool add);
 
    virtual ~AddOrEditItemAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int i;
    const unsigned int level;
    const sf::Vector2i position;
    const core::item::Id item;
    const bool visible;
    const core::map::Item orig;
    const bool add;
 
    AddOrEditItemAction(unsigned int i, unsigned int level, const sf::Vector2i& pos,
                        core::item::Id item, bool visible, const core::map::Item& orig, bool add);
};
 
class EditMap::RemoveItemAction : public EditMap::Action {
public:
    static Action::Ptr create(unsigned int i, unsigned int level, const sf::Vector2i& pos,
                              const core::map::Item& orig);
 
    virtual ~RemoveItemAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const unsigned int i;
    const unsigned int level;
    const sf::Vector2i position;
    const core::map::Item orig;
 
    RemoveItemAction(unsigned int i, unsigned int level, const sf::Vector2i& pos,
                     const core::map::Item& orig);
};
 
class EditMap::SetLightAction : public EditMap::Action {
public:
    static Action::Ptr create(const sf::Vector2i& pos, unsigned int radius,
                              const core::map::Light& orig);
 
    virtual ~SetLightAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::Light value;
    const core::map::Light orig;
    bool spawned;
 
    SetLightAction(const sf::Vector2i& pos, unsigned int radius, const core::map::Light& orig);
};
 
class EditMap::RemoveLightAction : public EditMap::Action {
public:
    static Action::Ptr create(const core::map::Light& orig);
 
    virtual ~RemoveLightAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const core::map::Light orig;
 
    RemoveLightAction(const core::map::Light& orig);
};
 
class EditMap::AddCatchRegionAction : public EditMap::Action {
public:
    static Action::Ptr create();
 
    virtual ~AddCatchRegionAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    AddCatchRegionAction() = default;
};
 
class EditMap::EditCatchRegionAction : public EditMap::Action {
public:
    static Action::Ptr create(std::uint8_t index, const core::map::CatchRegion& value,
                              const core::map::CatchRegion& orig);
 
    virtual ~EditCatchRegionAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::uint8_t index;
    const core::map::CatchRegion value;
    const core::map::CatchRegion orig;
 
    EditCatchRegionAction(std::uint8_t index, const core::map::CatchRegion& value,
                          const core::map::CatchRegion& orig);
};
 
class EditMap::RemoveCatchRegionAction : public EditMap::Action {
public:
    static Action::Ptr create(std::uint8_t index, const core::map::CatchRegion& orig);
 
    virtual ~RemoveCatchRegionAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::uint8_t index;
    const core::map::CatchRegion orig;
    std::vector<std::pair<unsigned int, sf::Vector2i>> cleared;
 
    RemoveCatchRegionAction(std::uint8_t index, const core::map::CatchRegion& orig);
};
 
class EditMap::SetAmbientLightAction : public EditMap::Action {
public:
    static Action::Ptr create(bool sunlight, std::uint8_t upper, std::uint8_t lower,
                              const core::map::LightingSystem& lighting);
 
    virtual ~SetAmbientLightAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const bool sunlight;
    const bool origSunlight;
    const std::uint8_t origLower;
    const std::uint8_t lower;
    const std::uint8_t origUpper;
    const std::uint8_t upper;
 
    SetAmbientLightAction(bool sun, std::uint8_t upper, std::uint8_t lower,
                          const core::map::LightingSystem& lighting);
};
 
class EditMap::AddTownAction : public EditMap::Action {
public:
    static Action::Ptr create();
 
    virtual ~AddTownAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    AddTownAction() = default;
};
 
class EditMap::EditTownAction : public EditMap::Action {
public:
    static Action::Ptr create(std::uint8_t i, const core::map::Town& orig,
                              const core::map::Town& town);
 
    virtual ~EditTownAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::uint8_t i;
    const core::map::Town orig;
    const core::map::Town val;
 
    EditTownAction(std::uint8_t i, const core::map::Town& orig, const core::map::Town& town);
};
 
class EditMap::RemoveTownAction : public EditMap::Action {
public:
    static Action::Ptr create(std::uint8_t i, const core::map::Town& orig);
 
    virtual ~RemoveTownAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::uint8_t i;
    const core::map::Town orig;
    std::vector<sf::Vector2i> tiles;
 
    RemoveTownAction(std::uint8_t i, const core::map::Town& orig);
};
 
class EditMap::SetTownTileAction : public EditMap::Action {
public:
    static Action::Ptr create(const sf::Vector2i& pos, std::uint8_t id, std::uint8_t orig);
 
    virtual ~SetTownTileAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const sf::Vector2i pos;
    const std::uint8_t id;
    const std::uint8_t orig;
 
    SetTownTileAction(const sf::Vector2i& pos, std::uint8_t id, std::uint8_t orig);
};
 
class EditMap::SetTownTileAreaAction : public EditMap::Action {
public:
    static Action::Ptr create(const sf::IntRect& area, std::uint8_t id, EditMap& map);
 
    virtual ~SetTownTileAreaAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const sf::IntRect area;
    const std::uint8_t id;
    const bl::ctr::Vector2D<std::uint8_t> orig;
 
    SetTownTileAreaAction(const sf::IntRect& area, std::uint8_t id,
                          bl::ctr::Vector2D<std::uint8_t>&& orig);
};
 
class EditMap::FillTownTileAction : public EditMap::Action {
public:
    static Action::Ptr create(const sf::Vector2i& pos, std::uint8_t id, EditMap& map);
 
    virtual ~FillTownTileAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const std::vector<std::pair<sf::Vector2i, std::uint8_t>> set;
    const std::uint8_t id;
 
    FillTownTileAction(std::uint8_t id, std::vector<std::pair<sf::Vector2i, std::uint8_t>>&& set);
};
 
class EditMap::SetLevelTileAction : public EditMap::Action {
public:
    static Action::Ptr create(const sf::Vector2i& pos, core::map::LevelTransition lt,
                              core::map::LevelTransition orig);
 
    virtual ~SetLevelTileAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const sf::Vector2i pos;
    const core::map::LevelTransition lt;
    const core::map::LevelTransition orig;
 
    SetLevelTileAction(const sf::Vector2i& pos, core::map::LevelTransition lt,
                       core::map::LevelTransition orig);
};
 
class EditMap::SetLevelTileAreaAction : public EditMap::Action {
public:
    static Action::Ptr create(const sf::IntRect& area, core::map::LevelTransition id, EditMap& map);
 
    virtual ~SetLevelTileAreaAction() = default;
    virtual bool apply(EditMap& map) override;
    virtual bool undo(EditMap& map) override;
    virtual const char* description() const override;
 
private:
    const sf::IntRect area;
    const core::map::LevelTransition lt;
    const bl::ctr::Vector2D<core::map::LevelTransition> orig;
 
    SetLevelTileAreaAction(const sf::IntRect& area, core::map::LevelTransition lt,
                           bl::ctr::Vector2D<core::map::LevelTransition>&& orig);
};
 
} // namespace component
} // namespace editor
 
#endif