Map.hpp

Go to the documentation of this file.

#ifndef CORE_MAPS_MAP_HPP
#define CORE_MAPS_MAP_HPP
 
#include <Core/Events/EntityMoved.hpp>
#include <Core/Maps/CatchRegion.hpp>
#include <Core/Maps/CharacterSpawn.hpp>
#include <Core/Maps/Event.hpp>
#include <Core/Maps/Item.hpp>
#include <Core/Maps/LayerSet.hpp>
#include <Core/Maps/LevelTransition.hpp>
#include <Core/Maps/LightingSystem.hpp>
#include <Core/Maps/RenderLevel.hpp>
#include <Core/Maps/Spawn.hpp>
#include <Core/Maps/Tileset.hpp>
#include <Core/Maps/Town.hpp>
#include <Core/Maps/Weather.hpp>
 
#include <BLIB/Audio.hpp>
#include <BLIB/ECS.hpp>
#include <BLIB/Events.hpp>
#include <BLIB/Resources.hpp>
#include <BLIB/Scripts.hpp>
#include <BLIB/Serialization.hpp>
#include <functional>
#include <unordered_map>
#include <vector>
 
namespace core
{
namespace system
{
class Systems;
}
 
namespace map
{
class Map : public bl::event::Listener<event::EntityMoved> {
public:
    Map();
 
    virtual ~Map();
 
    static std::string getMapFile(const std::string& partialFile);
 
    bool loadDev(std::istream& input);
 
    bool loadProd(bl::serial::binary::InputStream& input);
 
    bool save(const std::string& file);
 
    bool saveBundle(bl::serial::binary::OutputStream& output,
                    bl::resource::bundle::FileHandlerContext& ctx) const;
 
    bool enter(system::Systems& systems, std::uint16_t spawnId, const std::string& prevMap,
               const bl::tmap::Position& prevPlayerPos);
 
    void exit(system::Systems& systems, const std::string& newMap);
 
    void setupCamera(system::Systems& systems);
 
    const std::string& name() const;
 
    Weather& weatherSystem();
 
    LightingSystem& lightingSystem();
 
    const sf::Vector2i& sizeTiles() const;
 
    sf::Vector2f sizePixels() const;
 
    std::uint8_t levelCount() const;
 
    void update(float dt);
 
    bool contains(const bl::tmap::Position& position) const;
 
    bl::tmap::Position adjacentTile(const bl::tmap::Position& pos, bl::tmap::Direction dir) const;
 
    bool movePossible(const bl::tmap::Position& position, bl::tmap::Direction dir) const;
 
    bool isLedgeHop(const bl::tmap::Position& position, bl::tmap::Direction dir) const;
 
    virtual void observe(const event::EntityMoved& moveEvent) override;
 
    bool interact(bl::ecs::Entity interactor, const bl::tmap::Position& interactPos);
 
    const CatchRegion* getCatchRegion(const bl::tmap::Position& position) const;
 
    static const std::vector<Town>& FlyMapTowns();
 
    bool canFlyFromHere() const;
 
    const bl::tmap::Position* getSpawnPosition(unsigned int spawnId) const;
 
    const std::string& getLocationName(const bl::tmap::Position& pos) const;
 
    float getDepthForPosition(unsigned int level, unsigned int y, int layer = -1) const;
 
    float getMinDepth() const;
 
    bl::rc::SceneRef getScene() { return scene; }
 
    bl::rc::lgt::Scene2DLighting& getSceneLighting() {
        return static_cast<bl::rc::scene::Scene2D*>(scene.get())->getLighting();
    }
 
    void setupEntityPosition(bl::ecs::Entity entity);
 
protected:
    std::string nameField;
    std::string loadScriptField;
    std::string unloadScriptField;
    std::string playlistField;
    Weather::Type weatherField;
    std::vector<LayerSet> levels;
    std::string tilesetField;
    std::unordered_map<std::uint16_t, Spawn> spawns;
    std::vector<CharacterSpawn> characterField;
    std::vector<Item> itemsField;
    std::vector<Event> eventsField;
    LightingSystem lighting;
    std::vector<CatchRegion> catchRegionsField;
    bl::ctr::Vector2D<LevelTransition> transitionField;
    std::vector<Town> towns;
    bl::ctr::Vector2D<std::uint8_t> townTiles;
 
    system::Systems* systems;
    Town defaultTown;
    Town* currentTown;
    sf::Vector2i size;
    bl::resource::Ref<Tileset> tileset;
    Weather weather;
    std::unique_ptr<bl::script::Script> onEnterScript;
    std::unique_ptr<bl::script::Script> onExitScript;
    bl::ctr::Grid<const Event*> eventRegions;
    bool isWorldMap;
    bl::audio::AudioSystem::Handle playlistHandle;
    bool activated; // for weather continuity
 
    bl::rc::SceneRef scene;
    std::list<RenderLevel> renderLevels;
 
    void clear();
    void finishLoad();
    void triggerAnimation(const bl::tmap::Position& position);
    Town* getTown(const glm::i32vec2& pos);
    void enterTown(Town* town);
 
    void prepareRender();
    void cleanupRender();
    void setupLevel(unsigned int level);
    void setupLayer(unsigned int level, unsigned int layer);
    void setupTile(unsigned int level, unsigned int layer, const sf::Vector2u& pos);
 
    static std::vector<Town> flymapTowns;
    static void loadFlymapTowns();
 
    friend struct bl::serial::SerializableObject<Map>;
};
 
} // namespace map
} // namespace core
 
namespace bl
{
namespace serial
{
template<>
struct SerializableObject<core::map::Map> : public SerializableObjectBase {
    using M = core::map::Map;
 
    SerializableField<1, M, std::string> nameField;
    SerializableField<2, M, std::string> loadScriptField;
    SerializableField<3, M, std::string> unloadScriptField;
    SerializableField<4, M, std::string> playlistField;
    SerializableField<5, M, core::map::Weather::Type> weatherField;
    SerializableField<6, M, std::vector<core::map::LayerSet>> levels;
    SerializableField<7, M, std::string> tilesetField;
    SerializableField<8, M, std::unordered_map<std::uint16_t, core::map::Spawn>> spawnField;
    SerializableField<9, M, std::vector<core::map::CharacterSpawn>> characterField;
    SerializableField<10, M, std::vector<core::map::Item>> itemsField;
    SerializableField<11, M, std::vector<core::map::Event>> eventsField;
    SerializableField<12, M, core::map::LightingSystem> lighting; // 13 was catch zones
    SerializableField<14, M, bl::ctr::Vector2D<core::map::LevelTransition>> transitionField;
    SerializableField<15, M, std::vector<core::map::CatchRegion>> catchRegionsField;
    SerializableField<16, M, std::vector<core::map::Town>> townsField;
    SerializableField<17, M, bl::ctr::Vector2D<std::uint8_t>> townTiles;
 
    SerializableObject()
    : SerializableObjectBase("Map")
    , nameField("name", *this, &M::nameField, SerializableFieldBase::Required{})
    , loadScriptField("loadScript", *this, &M::loadScriptField, SerializableFieldBase::Required{})
    , unloadScriptField("unloadScript", *this, &M::unloadScriptField,
                        SerializableFieldBase::Required{})
    , playlistField("playlist", *this, &M::playlistField, SerializableFieldBase::Required{})
    , weatherField("weather", *this, &M::weatherField, SerializableFieldBase::Required{})
    , levels("levels", *this, &M::levels, SerializableFieldBase::Required{})
    , tilesetField("tileset", *this, &M::tilesetField, SerializableFieldBase::Required{})
    , spawnField("spawns", *this, &M::spawns, SerializableFieldBase::Required{})
    , characterField("characters", *this, &M::characterField, SerializableFieldBase::Required{})
    , itemsField("items", *this, &M::itemsField, SerializableFieldBase::Required{})
    , eventsField("events", *this, &M::eventsField, SerializableFieldBase::Required{})
    , lighting("lighting", *this, &M::lighting, SerializableFieldBase::Required{})
    , transitionField("transitions", *this, &M::transitionField, SerializableFieldBase::Required{})
    , catchRegionsField("catchZones", *this, &M::catchRegionsField,
                        SerializableFieldBase::Required{})
    , townsField("towns", *this, &M::towns, SerializableFieldBase::Required{})
    , townTiles("townTiles", *this, &M::townTiles, SerializableFieldBase::Required{}) {}
};
 
} // namespace serial
} // namespace bl
 
#endif