Map.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Result.h"
#include "map/TileLayer.h"
#include "map/MapObject.h"
#include "map/Pathfinder.h"
#include "map/Fov.h"
#include "map/TileCollision.h"
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::graphics {
class Graphics;
}
 
namespace eve::map {
 
class EVENGINE_API_WORLD Map : public Module {
public:
    Module_REG(Map);
    Map();
    ~Map() override = default;
 
    TileLayer *newLayer(int mapW, int mapH, float tileW = 32.f, float tileH = 32.f);
 
    Pathfinder *newPathfinder(TileLayer *layer);
    Pathfinder *newPathfinderSize(int mapW, int mapH);
 
    Fov *newFov(TileLayer *layer);
    Fov *newFovSize(int mapW, int mapH);
    Fov *newFovVolume(int mapW, int mapH, int depth);
 
    TileLayer *newLayerFromFile(const std::string &path);
 
    int loadFromFile(const std::string &path);
 
    [[nodiscard]] eve::Result<int> loadFromFileWithObjectContract(const std::string &path,
                                                                  std::string_view contractJson);
 
    [[nodiscard]] eve::Result<int> loadFromTextWithObjectContract(std::string_view mapJson,
                                                                  std::string_view contractJson);
 
    void update(float dt);
    void render(graphics::Graphics *gfx);
    int pollConfigs();
    int getLastVisibleTileCount() const;
    int getLastCustomVisualCount() const;
    int getLastAtlasCount() const;
    int getLastVisitedChunkCount() const;
    int getLastVisitedCellCount() const;
 
    int publishCollision(TileLayer *layer);
    int getCollisionRectCount() const;
    float getCollisionRectX(int index) const;
    float getCollisionRectY(int index) const;
    float getCollisionRectWidth(int index) const;
    float getCollisionRectHeight(int index) const;
 
    int getLayerCount() const;
    TileLayer *getLayer(int index) const;
 
    int getObjectCount() const;
    std::string getObjectName(int i) const;
    std::string getObjectType(int i) const;
    float getObjectX(int i) const;
    float getObjectY(int i) const;
    float getObjectWidth(int i) const;
    float getObjectHeight(int i) const;
    int getObjectGid(int i) const;
 
    int getObjectPropertyCount(int objectIndex) const;
 
    std::string getObjectPropertyName(int objectIndex, int propertyIndex) const;
 
    [[nodiscard]] bool hasObjectProperty(int objectIndex, std::string_view name) const;
 
    [[nodiscard]] std::string getObjectProperty(int objectIndex, std::string_view name,
                                                std::string defaultValue = {}) const;
 
    [[nodiscard]] std::optional<std::size_t> findObjectByName(std::string_view name) const;
 
    [[nodiscard]] std::optional<std::size_t> findObjectAt(float x, float y,
                                                          std::string_view type = {}) const;
 
    void setObjects(std::vector<MapObject> objects);
 
    bool resolveDualGrid(TileLayer *logic, TileLayer *display);
    bool resolveDualGridFilled(TileLayer *logic, TileLayer *display, int filledGid);
    int dualGridMaskAt(TileLayer *logic, int dx, int dy, int filledGid);
    int dualGridFrame(int mask);
    float dualGridOffsetX(TileLayer *logic);
    float dualGridOffsetY(TileLayer *logic);
    std::string lastDualGridError() const;
 
private:
    std::vector<MapObject> objects_;
    std::vector<TileLayer *> loadedLayers_;
    std::string dualGridError_;
    std::vector<TileCollisionRect> collisionRects_;
};
 
}  // namespace eve::map