GeneralsZeroHour/Generals/Code/GameEngine/Include/GameClient/AnimateWindowManager.h

/*
**	Command & Conquer Generals(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

////////////////////////////////////////////////////////////////////////////////
//																																						//
//  (c) 2001-2003 Electronic Arts Inc.																				//
//																																						//
////////////////////////////////////////////////////////////////////////////////

// FILE: AnimateWindowManager.h /////////////////////////////////////////////////
//-----------------------------------------------------------------------------
//                                                                          
//                       Electronic Arts Pacific.                          
//                                                                          
//                       Confidential Information                           
//                Copyright (C) 2002 - All Rights Reserved                  
//                                                                          
//-----------------------------------------------------------------------------
//
//	created:	Mar 2002
//
//	Filename: AnimateWindowManager.h
//
//	author:		Chris Huybregts
//	
//	purpose:	The Animate Window class will be used by registering a window with
//						the manager with stating what kind of animation to do. Then on every
//						update, we'll move the windows.
//
//-----------------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef __ANIMATEWINDOWMANAGER_H_
#define __ANIMATEWINDOWMANAGER_H_

//-----------------------------------------------------------------------------
// SYSTEM INCLUDES ////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// USER INCLUDES //////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
#include "Lib/BaseType.h"
#include "Common/SubsystemInterface.h"
#include "Common/GameMemory.h"

//-----------------------------------------------------------------------------
// FORWARD REFERENCES /////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
class GameWindow;
class ProcessAnimateWindowSlideFromBottom;
class ProcessAnimateWindowSlideFromBottomTimed;
class ProcessAnimateWindowSlideFromTop;
class ProcessAnimateWindowSlideFromLeft;
class ProcessAnimateWindowSlideFromRight;
class ProcessAnimateWindowSlideFromRightFast;
class ProcessAnimateWindowSpiral;
class ProcessAnimateWindowSlideFromTopFast;
class ProcessAnimateWindowSideSelect;
class ProcessAnimateWindow;

//-----------------------------------------------------------------------------
// TYPE DEFINES ///////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------

enum AnimTypes
{
	WIN_ANIMATION_NONE = 0,
	WIN_ANIMATION_SLIDE_RIGHT,
	WIN_ANIMATION_SLIDE_RIGHT_FAST,
	WIN_ANIMATION_SLIDE_LEFT,
	WIN_ANIMATION_SLIDE_TOP,
	WIN_ANIMATION_SLIDE_BOTTOM,
	WIN_ANIMATION_SPIRAL,
	WIN_ANIMATION_SLIDE_BOTTOM_TIMED,
	WIN_ANIMATION_SLIDE_TOP_FAST,
	WIN_ANIMATION_COUNT
} ;

//-----------------------------------------------------------------------------
class AnimateWindow : public MemoryPoolObject
{
	MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE(AnimateWindow, "AnimateWindow")		
public:
	AnimateWindow( void );
	//~AnimateWindow( void );
	
	void setAnimData( ICoord2D startPos, ICoord2D endPos, ICoord2D curPos, ICoord2D restPos, Coord2D vel, UnsignedInt startTime, UnsignedInt endTime);

	ICoord2D		getStartPos( void );							///< Get the Start Position 2D coord
	ICoord2D		getCurPos( void );								///< Get the Current Position 2D coord
	ICoord2D		getEndPos( void );								///< Get the End Position 2D coord
	ICoord2D		getRestPos( void );								///< Get the Rest Position 2D coord
	GameWindow *getGameWindow( void );						///< Get the GameWindow that will be animating
	AnimTypes		getAnimType( void );							///< Get the Animation type
	UnsignedInt	getDelay( void );									///< Get the Time Delay
	Coord2D			getVel( void );										///< Get the Velocity Position 2D coord
	UnsignedInt getStartTime( void );							///< Get the start time of the time-based anim
	UnsignedInt getEndTime( void );								///< Get the end time of the time-based anim

	void	setStartPos( ICoord2D starPos);					///< Set the Start Position 2D coord
	void	setCurPos( ICoord2D curPos);						///< Set the Current Position 2D coord
	void	setEndPos( ICoord2D endPos);						///< Set the End Position 2D coord
	void	setRestPos( ICoord2D restPos);					///< Set the Rest Position 2D coord
	void	setGameWindow( GameWindow *win);				///< Set the GameWindow that will be animating
	void	setAnimType( AnimTypes animType);				///< Set the Animation type
	void	setDelay( UnsignedInt delay);						///< Set the Time Delay
	void	setVel( Coord2D vel);										///< Set the Velocity Position 2D coord
	void	setStartTime( UnsignedInt t);						///< Set the start time of the time-based anim
	void	setEndTime( UnsignedInt t);							///< Set the end time of the time-based anim

	void setFinished(Bool finished);							///< Set if the animation has finished
	Bool isFinished( void );											///< Return if the animation has finished or not.
	void setNeedsToFinish( Bool needsToFinish);		///< set if we need this animation to finish for the manager to return true
	Bool needsToFinish( void );										///< set if the animation has finished

private:
	UnsignedInt m_delay;													///< Holds the delay time in which the animation will start (in milliseconds)
	ICoord2D m_startPos;													///< Holds the starting position of the animation 
																								///<(usuall is also the end position of the animation when the animation is reversed)
	ICoord2D m_endPos;														///< Holds the target End Position (usually is the same as the rest position)
	ICoord2D m_curPos;														///< It's Current Position
	ICoord2D m_restPos;														///< When the Manager Resets, It sets the window's position to this position
	GameWindow *m_win;														///< the window that this animation is happening on
	Coord2D m_vel;																///< the Velocity of the animation
	UnsignedInt m_startTime;											///< time we started the time-based anim
	UnsignedInt m_endTime;												///< time we should end the time-based anim
	AnimTypes m_animType;													///< The type of animation that will happen
	Bool m_needsToFinish;													///< Flag to tell the manager if we need to finish before it's done with it's animation
	Bool m_isFinished;														///< We're finished
};



//-----------------------------------------------------------------------------
typedef	std::list<AnimateWindow *>	AnimateWindowList;

//-----------------------------------------------------------------------------
class AnimateWindowManager : public SubsystemInterface
{
public:
	AnimateWindowManager( void );
	~AnimateWindowManager( void );

	// Inhertited from subsystem ====================================================================
	virtual void init( void );			
	virtual void reset( void );			
	virtual void update( void );		
	//===============================================================================================

	void registerGameWindow(GameWindow *win, AnimTypes animType, Bool needsToFinish, UnsignedInt ms = 0, UnsignedInt delayMs = 0);			// Registers a new window to animate.
	Bool isFinished( void );										///< Are all the animations that need to be finished, finished?
	void reverseAnimateWindow( void );					///< tell each animation type to setup the windows to run in reverse
	void resetToRestPosition( void );						///< Reset all windows to their rest position
	Bool isReversed( void );										///< Returns whether or not we're in our reversed state.
	Bool isEmpty( void );
private:
	AnimateWindowList	m_winList;								///< A list of AnimationWindows that we don't care if their finished animating
	AnimateWindowList m_winMustFinishList;			///< A list of AnimationWindows that we do care about
	Bool m_needsUpdate;													///< If we're done animating all our monitored windows, then this will be false
	Bool m_reverse;															///< Are we in a reverse state?
	ProcessAnimateWindowSlideFromRight *m_slideFromRight;			///< Holds the process in which the windows slide from the right
	ProcessAnimateWindowSlideFromRightFast *m_slideFromRightFast;
	ProcessAnimateWindowSlideFromTop *m_slideFromTop;					///< Holds the process in which the windows slide from the Top
	ProcessAnimateWindowSlideFromLeft *m_slideFromLeft;				///< Holds the process in which the windows slide from the Left
	ProcessAnimateWindowSlideFromBottom *m_slideFromBottom;		///< Holds the process in which the windows slide from the Bottom
	ProcessAnimateWindowSpiral *m_spiral;											///< Holds the process in which the windows Spiral onto the screen
	ProcessAnimateWindowSlideFromBottomTimed *m_slideFromBottomTimed;		///< Holds the process in which the windows slide from the Bottom in a time-based fashion
	ProcessAnimateWindowSlideFromTopFast *m_slideFromTopFast;			///< holds the process in wich the windows slide from the top,fast
	ProcessAnimateWindow *getProcessAnimate( AnimTypes animType);		///< returns the process for the kind of animation we need.
	
};

//-----------------------------------------------------------------------------
// INLINING ///////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
	inline ICoord2D			AnimateWindow::getStartPos( void )	{ return m_startPos; };
	inline ICoord2D			AnimateWindow::getCurPos( void )		{ return m_curPos; };
	inline ICoord2D			AnimateWindow::getEndPos( void )		{ return m_endPos; };
	inline ICoord2D			AnimateWindow::getRestPos( void )		{ return m_restPos; };
	inline GameWindow  *AnimateWindow::getGameWindow( void ){ return m_win; };
	inline AnimTypes		AnimateWindow::getAnimType( void )	{ return m_animType; };
	inline UnsignedInt	AnimateWindow::getDelay( void )			{ return m_delay; };
	inline Coord2D			AnimateWindow::getVel( void )				{ return m_vel; };
	inline UnsignedInt	AnimateWindow::getStartTime( void )	{ return m_startTime; };
	inline UnsignedInt	AnimateWindow::getEndTime( void )		{ return m_endTime; };

	inline void	AnimateWindow::setStartPos( ICoord2D startPos)		{ m_startPos = startPos; };
	inline void	AnimateWindow::setCurPos( ICoord2D curPos)				{ m_curPos = curPos; };
	inline void	AnimateWindow::setEndPos( ICoord2D endPos)				{ m_endPos = endPos; };
	inline void	AnimateWindow::setRestPos( ICoord2D restPos)			{ m_restPos = restPos; };
	inline void	AnimateWindow::setGameWindow( GameWindow *win)		{ m_win = win; };
	inline void	AnimateWindow::setAnimType( AnimTypes animType)		{ m_animType = animType; };
	inline void	AnimateWindow::setDelay( UnsignedInt delay)				{ m_delay = delay; };
	inline void	AnimateWindow::setVel( Coord2D vel)								{ m_vel = vel; };
	inline void	AnimateWindow::setStartTime( UnsignedInt t )			{ m_startTime = t; }
	inline void	AnimateWindow::setEndTime( UnsignedInt t )				{ m_endTime = t; }

	inline void	AnimateWindow::setFinished( Bool finished)				{ m_isFinished = finished; };
	inline Bool	AnimateWindow::isFinished( void )									{ return m_isFinished; };
	inline void	AnimateWindow::setNeedsToFinish( Bool needsToFinish)		{ m_needsToFinish = needsToFinish; };
	inline Bool	AnimateWindow::needsToFinish( void )							{ return m_needsToFinish; };
	
	inline Bool AnimateWindowManager::isFinished( void )					{ return !m_needsUpdate;	};
	inline Bool AnimateWindowManager::isReversed( void )						{ return m_reverse;	};
	inline Bool AnimateWindowManager::isEmpty( void ){return (m_winList.size() == 0 && m_winMustFinishList.size() == 0);	}
//-----------------------------------------------------------------------------
// EXTERNALS //////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------

#endif // __ANIMATEWINDOWMANAGER_H_