Map.hpp

Go to the documentation of this file.

//
// Created by Tom Augier on 5/26/21.
// Edited by Benjamin Henry on 5/26/21.
//
 
 
#pragma once
 
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <random>
#include <map>
#include <tuple>
#include <algorithm>
#include "Component/Renderer/Drawable3DComponent.hpp"
#include "Scene/Scene.hpp"
#include "Model/Model.hpp"
#include "Component/Component.hpp"
#include "Component/Position/PositionComponent.hpp"
#include "Component/Health/HealthComponent.hpp"
#include "Component/Collision/CollisionComponent.hpp"
#include "Component/Movable/MovableComponent.hpp"
#include <chrono>
#include <Items/Bonus.hpp>
 
 
namespace BBM
{
 
    class MapGenerator
    {
    public:
        enum BlockType
        {
            NOTHING,
            BREAKABLE,
            HOLE,
            UPPERFLOOR,
            BUMPER,
            SPAWNER,
            UNBREAKABLE,
            INVISIBLE
        };
 
        using MapBlock = std::map<std::tuple<int, int, int>, BlockType>;
 
        static void createBonus(WAL::Entity &entity, Vector3f position, Bonus::BonusType bonusType);
 
        static void wallCollision(WAL::Entity &entity,
                                  const WAL::Entity &wall,
                                  CollisionComponent::CollidedAxis collidedAxis);
        static void wallCollided(WAL::Entity &entity,
                                 const WAL::Entity &wall,
                                 CollisionComponent::CollidedAxis collidedAxis);
        static void wallDestroyed(WAL::Entity &entity, WAL::Wal &wal);
 
        static void holeCollide(WAL::Entity &entity,
                                const WAL::Entity &wall,
                                CollisionComponent::CollidedAxis collidedAxis);
 
        static void bumperCollide(WAL::Entity &entity,
                                  const WAL::Entity &wall,
                                  CollisionComponent::CollidedAxis collidedAxis);
 
 
 
        static MapBlock createMap(int width, int height, bool isHeight = false, bool isNotClassic = false);
 
        static void loadMap(int width, int height, MapBlock map, const std::shared_ptr<WAL::Scene> &scene);
 
        static void createElement(Vector3f coords, std::shared_ptr<WAL::Scene> scene, BlockType blockType);
    private:
 
        using MapElem = std::function<void(Vector3f coords, std::shared_ptr<WAL::Scene> scene)>;
 
        static BlockType getRandomBlockType(bool = false);
 
        static bool isCloseToBlockType(std::map<std::tuple<int, int, int>, BlockType> map,
                                       int x, int y, int z,
                                       BlockType blockType);
 
        static void generateUnbreakableBlock(int width, int height, std::shared_ptr<WAL::Scene> scene);
 
        static void generateWall(int width, int height, std::shared_ptr<WAL::Scene> scene);
 
        static void generateFloor(MapBlock map, int width, int height, std::shared_ptr<WAL::Scene> scene);
 
        static void createBreakable(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
        static void createUnbreakable(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
        static void createHole(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
        static void createBumper(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
        static void createUpperFloor(Vector3f coords, std::shared_ptr<WAL::Scene> scene);
 
        static void generateHeightCollision(MapBlock map, int width, int height, 
                                            std::shared_ptr<WAL::Scene> scene);
 
        static MapBlock createClassicUnbreakable(MapBlock map, int width, int height);
        
        static MapBlock createLongClassicUnbreakable(MapBlock map, int width, int height);
        
        static MapBlock createSpawner(MapBlock map, int width, int height);
 
        static MapBlock createHeight(MapBlock map, int width, int height);
 
        static MapBlock cleanBreakable(MapBlock map, int width, int height);
 
 
        static const std::string assetsPath;
 
        static const std::string wallAssetsPath;
 
        static const std::string imageExtension;
 
        static const std::string objExtension;
 
        static const std::string unbreakableWallPath;
 
        static const std::string outerWallPath;
 
        static const std::string breakableWallPath;
 
        static const std::string floorPath;
 
        static const std::string stairsPath;
 
        static const std::string bumperPath;
 
        static const std::string secondFloorPath;
 
        static const std::string holePath;
 
        static const std::string secondFloorHolePath;
    };
} // namespace BBM