LuaMap.hpp

Go to the documentation of this file.

//
//
//
 
#pragma once
#include <lua.hpp>
#include "LuaGate.hpp"
#include "Models/Vector2.hpp"
#include <vector>
 
namespace BBM
{
    class LuaMap {
        public:
            LuaMap();
 
            ~LuaMap();
 
            void clearDanger(void);
 
            bool setDanger(int xpos, int ypos, int dangerLevel);
 
            void setPlayer(Vector3f pos);
 
            std::vector<Vector2f> pathfind(Vector2f root, Vector2f target, bool throughBreakable) const;
 
            Vector2f findSafeSpace(const std::vector<std::vector<int>> &dangerMap) const;
 
            static int getMap(lua_State *L);
 
            static int getDanger(lua_State *L);
 
            static int getPath(lua_State *L);
 
            static int getPlayer(lua_State *L);
 
            static int getPlayerRound(lua_State *L);
 
            static int getClosestSafeSpace(lua_State *L);
 
            static int getDangerLevelPlayer(lua_State *L);
 
            static int getDangerLevel(lua_State *L);
 
            static int getBlockType(lua_State *L);
 
            static int canPutBomb(lua_State *L);
 
            static int getRadius(lua_State *L);
 
            static int getEnemies(lua_State *L);
 
            static int getEnemiesRound(lua_State *L);
 
            std::vector<std::vector<int>> _map;
 
            std::vector<std::vector<int>> _danger;
 
            Vector2f _player;
 
            std::vector<Vector2f> _enemies;
 
            Vector2f _roundedPlayer;
 
            int currRadius;
        private:
            std::vector<Vector2f> fillPath(std::vector<Vector2f> &path, 
            std::unordered_map<Vector2f, Vector2f> &cameFrom, Vector2f node) const;
 
            std::vector<Vector2f> getNeighbors(Vector2f node, bool throughBreakable) const;
 
            std::vector<Vector2f> _dirs = {
                Vector2f(1, 0), Vector2f(-1, 0), Vector2f(0, 1), Vector2f(0, -1)
            };
 
    };
}
 
namespace std
{
    template<>
    struct hash<BBM::Vector2f>
    {
        typedef BBM::Vector2f argument_type;
        typedef std::size_t result_type;
        result_type operator()(argument_type const &in) const
        {
            union {
                float vector[2];
                result_type hashed;
            } hasher;
            hasher.vector[0] = in.x;
            hasher.vector[1] = in.y;
            return hasher.hashed;
        }
    };
}