tbx_effects_behaviors.hpp

#ifndef TurtleBrains_EffectsBehaviors_hpp
#define TurtleBrains_EffectsBehaviors_hpp

#include <turtle_brains/game/tb_entity_behavior_interface.hpp>
#include <turtle_brains/game/tb_game_timer.hpp>
#include <turtle_brains/graphics/tb_animated_sprite.hpp>
#include <turtle_brains/graphics/tb_camera.hpp>

namespace TurtleBrainsExpress
{
    namespace Behaviors
    {

        class PlayAnimationBehavior : public tbGame::EntityBehaviorInterface
        {
        public:
            explicit PlayAnimationBehavior(tbGame::Entity& entity, tbGraphics::AnimatedSprite& animatedSprite,
                const tbCore::tbString& sequenceName, bool isLooping = false, bool isForward = true);

            virtual ~PlayAnimationBehavior(void);

            virtual void OnResume(void) override;

            virtual void OnSimulate(void) override;

        private:
            const tbCore::tbString mSequenceName;
            tbGraphics::AnimatedSprite& mAnimatedSprite;
            const bool mIsLooping;
            const bool mIsForward;
        };

//-------------------------------------------------------------------------------------------------------------------//

        class PlaySoundBehavior : public tbGame::EntityBehaviorInterface
        {
        public:
            explicit PlaySoundBehavior(tbGame::Entity& entity, const tbCore::tbString& eventTableName, const tbCore::tbString& eventName);

            virtual ~PlaySoundBehavior(void);

            virtual void OnResume(void) override;

            virtual void OnSimulate(void) override;

        private:
            const tbCore::tbString mEventTableName;
            const tbCore::tbString mEventName;
        };

        class ShakeScreenBehavior : public tbGame::EntityBehaviorInterface
        {
        public:
            explicit ShakeScreenBehavior(tbGame::Entity& entity, const tbGraphics::Camera::IntensityLevel& shakeIntensity, float shakeDuration = -1.0f);

            virtual ~ShakeScreenBehavior(void);

            virtual void OnResume(void) override;

            virtual void OnSimulate(void) override;

        private:
            const tbGraphics::Camera::IntensityLevel mShakeIntensity;
            const float mShakeDuration; //negative will default to a duration for the intensity.
        };

        class FadeColorBehavior : public tbGame::EntityBehaviorInterface
        {
        public:
            explicit FadeColorBehavior(tbGame::Entity& entity, tbGraphics::Graphic& graphic, const tbGraphics::Color& desiredColor, const tbGame::GameTimer& time);

            virtual ~FadeColorBehavior(void);

            virtual void OnResume(void) override;

            virtual void OnSimulate(void) override;

        private:
            const tbGraphics::Color mDesiredColor;
            tbGraphics::Color mOriginalColor;
            const tbGame::GameTimer mMaximumTime;
            tbGame::GameTimer mTimer;
            tbGraphics::Graphic& mGraphic;
        };


    }; /* namespace Behaviors */
}; /* namespace TurtleBrainsExpress */

namespace tbxBehaviors = TurtleBrainsExpress::Behaviors;

#endif /* TurtleBrains_EffectsBehaviors_hpp */