Initial commit of Command & Conquer Generals and Command & Conquer Generals Zero Hour source code.
This commit is contained in:
LFeenanEA
parent
2e338c00cb
commit
3d0ee53a05
6072 changed files with 2283311 additions and 0 deletions
|
|
@ -0,0 +1,228 @@
|
|||
/*
|
||||
** Command & Conquer Generals Zero Hour(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_
|
||||
Reference in a new issue