Level.h

Go to the documentation of this file.

 
#pragma once
 
#include "KatanaEngine.h"
#include "PlayerShip.h"
#include "CollisionManager.h"
#include "Explosion.h"
 
using namespace KatanaEngine;
 
class GameplayScreen;
 
class Level
{
 
public:
 
    Level();
    virtual ~Level();
 
    virtual void LoadContent(ResourceManager& resourceManager);
 
    virtual void UnloadContent() { };
 
    virtual void HandleInput(const InputState& input);
 
    virtual void Update(const GameTime& gameTime);
 
    virtual void Draw(SpriteBatch& spriteBatch);
 
    virtual void AddGameObject(GameObject* pGameObject) { m_gameObjects.push_back(pGameObject); }
 
    virtual void UpdateSectorPosition(GameObject* pGameObject);
 
    virtual void SetGameplayScreen(GameplayScreen* pGameplayScreen) { m_pGameplayScreen = pGameplayScreen; }
 
    virtual void SpawnExplosion(GameObject* pExplodingObject);
 
    virtual void SetBackground(Texture* pBackground) { m_pBackground = pBackground; }
 
    virtual float GetAlpha() const;
 
    virtual bool IsScreenTransitioning() const { return GetAlpha() < 1; }
 
    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 CollisionManager* GetCollisionManager() { return m_pCollisionManager; }
 
    virtual GameplayScreen* GetGameplayScreen() const { return m_pGameplayScreen; }
 
    virtual void SetBackgroundAudio(AudioSample* pAudio) { m_pAudio = pAudio; }
 
    virtual AudioSample* GetBackgroundAudio() { return m_pAudio; }
 
private:
 
    static std::vector<Explosion *> s_explosions;
    std::vector<Explosion *>::iterator m_explosionIt;
 
    CollisionManager* m_pCollisionManager = nullptr;
 
    GameplayScreen* m_pGameplayScreen = nullptr;
 
    AudioSample* m_pAudio = nullptr;
 
    Texture* m_pBackground = nullptr;
 
    std::vector<GameObject*>* m_pSectors;
 
    Vector2 m_sectorCount;
    Vector2 m_sectorSize;
 
    unsigned int m_totalSectorCount = 0;
 
    std::vector<GameObject*> m_gameObjects;
    std::vector<GameObject*>::iterator m_gameObjectIt;
 
    PlayerShip* m_pPlayerShip;
    std::vector<Projectile*> m_projectiles;
 
    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; }
 
};