GameObject.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

using namespace KatanaEngine;

namespace ShooterLibrary
{

    class Level;
    class GameObject;

    typedef void(*OnDeactivate)(GameObject *pGameObject);
    
    class GameObject
    {
        friend class Game;

    public:
        
        GameObject();
        virtual ~GameObject() { s_count--; }

        
        static void SetCurrentLevel(Level *pLevel) { s_pCurrentLevel = pLevel; }

        static Level *GetCurrentLevel() { return s_pCurrentLevel; }

        virtual void SetDeactivateCallback(OnDeactivate callback) { m_onDeactivate = callback; }

        virtual void Update(const GameTime *pGameTime);

        virtual void Draw(SpriteBatch *pSpriteBatch) = 0;

        virtual bool IsActive() const { return m_isActive; }

        virtual void Activate() { m_isActive = true; }

        virtual void Deactivate();

        virtual Vector2 &GetPosition() { return m_position; }

        virtual Vector2 &GetPreviousPosition() { return m_previousPosition; }

        virtual std::string ToString() const = 0;

        virtual Vector2 GetHalfDimensions() const;

        virtual uint32_t GetIndex() const { return m_index; }

        virtual CollisionType GetCollisionType() const = 0;

        virtual float GetCollisionRadius() const { return m_collisionRadius; }

        virtual void Hit(const float damage) { }

        virtual bool HasMask(CollisionType mask) const { return mask.Contains(GetCollisionType()); }

        virtual bool IsMask(CollisionType mask) const { return (GetCollisionType() == mask); }


        virtual bool IsDrawnByLevel() const { return true; }


    protected:
        
        virtual void SetCollisionRadius(const int radius) { m_collisionRadius = radius; }

        virtual void SetPosition(const float x, const float y);

        virtual void SetPosition(const Vector2 &position);

        virtual void TranslatePosition(const float x, const float y);

        virtual void TranslatePosition(const Vector2 &offset);

        virtual bool IsOnScreen() const;


    private:

        static Level *s_pCurrentLevel;
        static uint32_t s_count;

        OnDeactivate m_onDeactivate;

        uint32_t m_index;

        bool m_isActive;

        Vector2 m_position;
        Vector2 m_previousPosition;

        float m_collisionRadius;

    };
}