Subversion Repositories AndroidProjects

//////////////////////////////////////////////////////////////////////////
//                              LevelupEffect.h
//
//      Does the level up effect, from the bouncing "LEVEL UP!" text to
//      the stats display and weird transition effects.
//////////////////////////////////////////////////////////////////////////


#ifndef __LEVELUP_EFFECT_H__
#define __LEVELUP_EFFECT_H__

#include "SexyAppFramework/Common.h"
#include "SexyAppFramework/Rect.h"

namespace Sexy
{

        class Graphics;


//////////////////////////////////////////////////////////////////////////
//      Represents a letter that bounces, used for the "LEVEL UP!" text.
//////////////////////////////////////////////////////////////////////////
struct BouncyChar
{
        SexyString              mChar;                          // The character bouncing
        bool                    mDone;                          // Completed bouncing yet?
        float                   mX, mY;                        
        float                   mBounceSpeed;           // How fast up or down it's bouncing, affected by "gravity"
        float                   mOldBounceSpeed;        // The base value that mBounceSpeed started at. Gets reduced over time.

        BouncyChar(SexyString t, float x, float y, float s)
        {mChar = t; mX = x; mY = y; mBounceSpeed = mOldBounceSpeed = s; mDone = false;}
};

//////////////////////////////////////////////////////////////////////////
//      Contains stat info to display after completing a level.
//////////////////////////////////////////////////////////////////////////
struct LevelupStats
{
        int             mPopulationEaten;
        int             mPercentComplete;
        int             mLevelCompleted;

        // Always 3 strings per planet:
        // Planet name, exports, population (comma delimited)
        std::vector<SexyString> mPlanetsEaten;
       
};

class LevelupEffect
{

        private:

                // States that the level up effect goes through
                enum
                {
                        LEVELUP_TEXT,                   // Displaying the bouncy LEVEL UP! text
                        CURTAIN_IN,                             // Moving the black "curtain" inward to cover up the level
                        CURTAIN_OUT,                    // Moving the red "curtain" out after above to reveal the stats
                        SHOWING_STATS,                  // Displaying level stats
                        COVERING_STATS,                 // Doing the weird transitionary cover-up screen after clicking to continue
                        FADE_OUT_STATS                  // Fading out the above screen
                };
               
                std::vector<BouncyChar> mText;                  // The letters that spell LEVEL UP!, as BouncyChar structures
                LevelupStats    mStats;                                 // Stat info to display
                bool                    mActive;                                // If true, means we're doing the level up sequence
                bool                    mDone;                                  // If done, means all finished and the next level can actually begin
                bool                    mStartNextLevel;                // When true, indicates that the board should set up the next level so that it'll be there when we fade out

                int                             mHue;                                   // For hue/saturation/luminence crazy weird flashing effect
                int                             mCurtainX;                              // X location of the black/red curtain edge (for the left curtain, the right is the same size)
                int                             mState;                                 // One of the above nums

                // When doing the COVERING_STATS phase, this is how wide 1/2 of the filled in part of the screen is. The other half
                // is the same size.
                int                             mCoverWidth;                   
                int                             mStripHeight;                   // For the above, we make strips quickly appear, alternating up/down filling

                // Indicates whether the strips are increasing Y (so strip comes from top) or decreasing
                // (so strip comes from bottom)
                int                             mStripSizeChange;
                int                             mFadeOutAlpha;                  // Alpha amount for the final fade out effect

                //////////////////////////////////////////////////////////////////////////
                //      Function: Init
                //
                //      Purpose: Sets up and initializes/resets all variables.
                //////////////////////////////////////////////////////////////////////////             
                void    Init();

        public:

                LevelupEffect();

                //////////////////////////////////////////////////////////////////////////
                //      Function: Update
                //      Parameters:
                //              theFrac -       Value from Board::UpdateF, used for smooth motion
                //
                //////////////////////////////////////////////////////////////////////////             
                void    Update(float theFrac);

                //////////////////////////////////////////////////////////////////////////
                //      Draw
                //////////////////////////////////////////////////////////////////////////             
                void    Draw(Graphics* g);

                //////////////////////////////////////////////////////////////////////////
                //      Function: Activate
                //      Parameters:
                //              ls      -       A stat structure containing the info for the past level
                //
                //      Purpose: Begins the level up sequence
                //////////////////////////////////////////////////////////////////////////             
                void    Activate(LevelupStats ls);

                //////////////////////////////////////////////////////////////////////////
                //      Function: DoneViewingStats
                //
                //      Purpose: Called by Board when the user clicks the mouse button,
                //      indicating that they want the stats screen to go away and have the
                //      next level begin.
                //////////////////////////////////////////////////////////////////////////             
                void    DoneViewingStats();

                //////////////////////////////////////////////////////////////////////////
                //      Function: StartNextLevel
                //      Returns: true or false, indicating if the next level can be started.
                //
                //      Purpose: Called by the Board's Update method, this returns true
                //      when the board should initialize the next level, so that when the
                //      level up effect fades out, the next level will appear underneath it.
                //      When the function returns true, it automatically sets internal variables
                //      so that the next time the function is called, it will return false,
                //      preventing the Board from accidentally initializing the same level
                //      multiple times. After the next call to Activate, it is allowed to
                //      return true again.
                //
                //      Once the screen is totally filled after closing the stats display,
                //      the Board is allowed to init the next level.
                //////////////////////////////////////////////////////////////////////////             
                bool    StartNextLevel();

                //////////////////////////////////////////////////////////////////////////
                //      Function: IsDone
                //      Returns: true or false indicating if the entire sequence is done
                //
                //      Purpose: Used to let the board know when playing of the next level
                //      can begin.
                //////////////////////////////////////////////////////////////////////////             
                bool    IsDone()                {return mDone;}

                //////////////////////////////////////////////////////////////////////////
                //      Function: IsActive
                //      Returns: true or false indicating if the sequence is running or not
                //////////////////////////////////////////////////////////////////////////             
                bool    IsActive()              {return mActive;}

                //////////////////////////////////////////////////////////////////////////
                //      Function: ShowingStats
                //      Returns: true or false indicating if the stats display is visible
                //////////////////////////////////////////////////////////////////////////
                bool    ShowingStats()  {return mState == SHOWING_STATS;}              

                //////////////////////////////////////////////////////////////////////////
                //      Function: HideBoard
                //      Returns: true or false indicating whether or not the board should
                //      hide all of its display stuff, except for the starfield which always
                //      displays.
                //////////////////////////////////////////////////////////////////////////             
                bool    HideBoard()             {return (mState == SHOWING_STATS) || (mState == CURTAIN_OUT) || (mState == COVERING_STATS);}

                //////////////////////////////////////////////////////////////////////////
                //      Function: HidePlanets
                //      Returns: true or false indicating if just the planets should be
                //      hidden.
                //
                //      Purpose: Used to hide the planets but still allow the rest of the
                //      game board to display. Used during the transtion to the stats
                //      display screen.
                //////////////////////////////////////////////////////////////////////////             
                bool    HidePlanets()   {return IsActive() && (HideBoard() || (mState == LEVELUP_TEXT) || (mState == CURTAIN_IN));}
};


}

#endif //__LEVELUP_EFFECT_H__