Level.h

/*      .                         ,'`.       .                         
   .                  .."    _.-;' ⁄‚ `.              .           `      
              _.-"`.##%"_.--" ,' ⁄`     `.           "#"     ___,,od000
           ,'"-_ _.-.--"\   ,'            `-_       '%#%',,/00000000000
         ,'     |_.'     )`/-     __..--""`-_`-._    J L/00000000000000
 . +   ,'   _.-"        / /   _-""           `-._`-_/___\///0000   000M
     .'_.-""      '    :_/_.-'                 _,`-/__V__\0000    00MMM
 . _-""                         .        '   _,/000\  |  /000    0MMMMM
_-"   .       '     .              .        ,/   000\ | /000000000MMMMM
       `       Shooter Library       '     ,/     000\|/000000000MMMMMM
.       © 2017 - Shuriken Studios LLC     ,/0    00000|0000000000MMMMMM */

#pragma once

namespace ShooterLibrary
{
    class GameObject;

    class Level
    {

    public:

        Level();
        virtual ~Level();

        virtual void LoadContent(ResourceManager *pResourceManager);

        virtual void UnloadContent();

        virtual void Update(const GameTime *pGameTime);

        virtual void Draw(SpriteBatch *pSpriteBatch);

        virtual void AddGameObject(GameObject *pGameObject) { m_gameObjects.push_back(pGameObject); }

        virtual void Complete() { }

        virtual void UpdateSectorPosition(GameObject *pGameObject);

        template <typename T>
        T *GetClosestObject(const Vector2 position, const float range)
        {
            float squaredRange = range * range;
            if (range <= 0)
            {
                int w = Game::GetScreenWidth();
                int h = Game::GetScreenHeight();
                squaredRange = w * w + h * h;
            }
            float squaredDistance;

            std::vector<GameObject *>::iterator m_it = m_gameObjects.begin();
            T *pClosest = nullptr;

            for (; m_it != m_gameObjects.end(); m_it++)
            {
                GameObject *pGameObject = *m_it;
                if (!pGameObject->IsActive()) continue;

                squaredDistance = (position - pGameObject->GetPosition()).LengthSquared();
                if (squaredDistance < squaredRange)
                {
                    T *pObject = dynamic_cast<T *>(pGameObject);
                    if (pObject)
                    {
                        pClosest = pObject;
                        squaredRange = squaredDistance;
                    }
                }
            }

            return pClosest;
        }


    protected:

        virtual void InitializeCollisionManager() { m_pCollisionManager = new CollisionManager(); }

        virtual CollisionManager *GetCollisionManager() { return m_pCollisionManager; }

        virtual ParticleManager *GetParticleManager() const = 0;

        virtual void AddProjectilePool(ProjectilePool *pProjectilePool) { m_pProjectilePools.push_back(pProjectilePool); }

        virtual void SetBackground(Background *pBackground) { m_pBackground = pBackground; }

    private:

        CollisionManager *m_pCollisionManager = nullptr;;

        std::vector<GameObject *> *m_pSectors;

        Vector2 m_sectorCount;
        Vector2 m_sectorSize;

        unsigned int m_totalSectorCount;

        std::vector<GameObject *> m_gameObjects;
        std::vector<GameObject *>::iterator m_gameObjectIt;

        ALLEGRO_SAMPLE *m_pSample;
        ALLEGRO_SAMPLE_ID m_sampleID;

        std::vector<ProjectilePool *> m_pProjectilePools;
        
        Background *m_pBackground;

        void CheckCollisions(std::vector<GameObject *> &sector);

        virtual Vector2 GetSectorCount() const { return m_sectorCount; }

        virtual Vector2 GetSectorSize() const { return m_sectorSize; }

        virtual unsigned int GetTotalSectorCount() const { return m_totalSectorCount; }

        virtual std::vector<GameObject *> *GetSectors() { return m_pSectors; }
                
    };
}