Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 21, 2009, 10:17:59 PM (15 years ago)
Author:
rgrieder
Message:

Removed GameState template and renamed GameStateBase to GameState.
Moved statistics stuff (fps and tick time) to Game and removed the remaining hacks in GSGraphics and GSRoot.

Location:
code/branches/gui/src/core
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • code/branches/gui/src/core/CorePrereqs.h

    r2710 r2817  
    166166
    167167  // game states
    168   class GameStateBase;
    169   template <class ParentType>
    170168  class GameState;
    171169  class RootGameState;

  • code/branches/gui/src/core/GameState.cc

    r2815 r2817  
    3030@file
    3131@brief
    32     Implementation of GameStateBase class.
     32    Implementation of GameState class.
    3333*/
    3434
    … …  
    4343        Constructor only initialises variables and sets the name permanently.
    4444    */
    45     GameStateBase::GameStateBase(const std::string& name)
     45    GameState::GameState(const std::string& name)
    4646        : name_(name)
    47         //, parent_(0)
     47        , parent_(0)
    4848        , activeChild_(0)
    4949        //, bPausegetParent()(false)
    … …  
    5757        Destructor only checks that we don't delete an active state.
    5858    */
    59     GameStateBase::~GameStateBase()
     59    GameState::~GameState()
    6060    {
    6161        OrxAssert(this->operation_.active == false, "Deleting an active GameState is a very bad idea..");
    … …  
    6969        The state to be added.
    7070    */
    71     void GameStateBase::addChild(GameStateBase* state)
     71    void GameState::addChild(GameState* state)
    7272    {
    7373        if (!state)
    7474            return;
    7575        // check if the state/tree to be added has states in it that already exist in this tree.
    76         for (std::map<std::string, GameStateBase*>::const_iterator it = state->allChildren_.begin();
     76        for (std::map<std::string, GameState*>::const_iterator it = state->allChildren_.begin();
    7777            it != state->allChildren_.end(); ++it)
    7878        {
    … …  
    9696
    9797        // merge the child's children into this tree
    98         for (std::map<std::string, GameStateBase*>::const_iterator it = state->allChildren_.begin();
     98        for (std::map<std::string, GameState*>::const_iterator it = state->allChildren_.begin();
    9999            it != state->allChildren_.end(); ++it)
    100100            this->grandchildAdded(state, it->second);
    … …  
    113113        GameState by instance pointer
    114114    */
    115     void GameStateBase::removeChild(GameStateBase* state)
    116     {
    117         std::map<GameStateBase*, GameStateBase*>::iterator it = this->grandchildrenToChildren_.find(state);
     115    void GameState::removeChild(GameState* state)
     116    {
     117        std::map<GameState*, GameState*>::iterator it = this->grandchildrenToChildren_.find(state);
    118118        if (it != this->grandchildrenToChildren_.end())
    119119        {
    … …  
    127127            else
    128128            {
    129                 for (std::map<GameStateBase*, GameStateBase*>::const_iterator it = state->grandchildrenToChildren_.begin();
     129                for (std::map<GameState*, GameState*>::const_iterator it = state->grandchildrenToChildren_.begin();
    130130                    it != state->grandchildrenToChildren_.end(); ++it)
    131131                    this->grandchildRemoved(it->first);
    … …  
    150150    */
    151151
    152     void GameStateBase::removeChild(const std::string& name)
    153     {
    154         GameStateBase* state = getState(name);
     152    void GameState::removeChild(const std::string& name)
     153    {
     154        GameState* state = getState(name);
    155155        if (state)
    156156        {
    … …  
    173173        The child that has been added.
    174174    */
    175     inline void GameStateBase::grandchildAdded(GameStateBase* child, GameStateBase* grandchild)
     175    inline void GameState::grandchildAdded(GameState* child, GameState* grandchild)
    176176    {
    177177        // fill the two maps correctly.
    178178        this->allChildren_[grandchild->getName()] = grandchild;
    179179        this->grandchildrenToChildren_[grandchild] = child;
    180         if (this->getParentAsBase())
    181             this->getParentAsBase()->grandchildAdded(this, grandchild);
     180        if (this->getParent())
     181            this->getParent()->grandchildAdded(this, grandchild);
    182182    }
    183183
    … …  
    191191        The child that has been removed.
    192192    */
    193     inline void GameStateBase::grandchildRemoved(GameStateBase* grandchild)
     193    inline void GameState::grandchildRemoved(GameState* grandchild)
    194194    {
    195195        // adjust the two maps correctly.
    196196        this->allChildren_.erase(grandchild->getName());
    197197        this->grandchildrenToChildren_.erase(grandchild);
    198         if (this->getParentAsBase())
    199             this->getParentAsBase()->grandchildRemoved(grandchild);
     198        if (this->getParent())
     199            this->getParent()->grandchildRemoved(grandchild);
    200200    }
    201201
    … …  
    206206        Remember that the every node has a map with all its child nodes.
    207207    */
    208     GameStateBase* GameStateBase::getState(const std::string& name)
    209     {
    210         if (this->getParentAsBase())
    211             return this->getParentAsBase()->getState(name);
     208    GameState* GameState::getState(const std::string& name)
     209    {
     210        if (this->getParent())
     211            return this->getParent()->getState(name);
    212212        else
    213213        {
    … …  
    216216                return this;
    217217            // Search in the map. If there is no entry, we can be sure the state doesn't exist.
    218             std::map<std::string, GameStateBase*>::const_iterator it = this->allChildren_.find(name);
     218            std::map<std::string, GameState*>::const_iterator it = this->allChildren_.find(name);
    219219            return (it!= this->allChildren_.end() ? it->second : 0);
    220220        }
    … …  
    225225        Returns the root node of the tree.
    226226    */
    227     GameStateBase* GameStateBase::getRoot()
    228     {
    229         if (this->getParentAsBase())
    230             return this->getParentAsBase()->getRoot();
     227    GameState* GameState::getRoot()
     228    {
     229        if (this->getParent())
     230            return this->getParent()->getRoot();
    231231        else
    232232            return this;
    … …  
    240240        have active children itself. Many states can be active at once.
    241241    */
    242     GameStateBase* GameStateBase::getCurrentState()
     242    GameState* GameState::getCurrentState()
    243243    {
    244244        if (this->operation_.active)
    … …  
    251251        else
    252252        {
    253             if (this->getParentAsBase())
    254                 return this->getParentAsBase()->getCurrentState();
     253            if (this->getParent())
     254                return this->getParent()->getCurrentState();
    255255            else
    256256                return 0;
    … …  
    262262        Determines whether 'state' is in this subtree, including this node.
    263263    */
    264     bool GameStateBase::isInSubtree(GameStateBase* state) const
     264    bool GameState::isInSubtree(GameState* state) const
    265265    {
    266266        return (grandchildrenToChildren_.find(state) != grandchildrenToChildren_.end()
    … …  
    275275        The state to be entered, has to exist in the tree.
    276276    */
    277     void GameStateBase::requestState(const std::string& name)
     277    void GameState::requestState(const std::string& name)
    278278    {
    279279        assert(getRoot());
    … …  
    286286        the method can assume certain things to be granted (like 'this' is always active).
    287287    */
    288     void GameStateBase::makeTransition(GameStateBase* source, GameStateBase* destination)
    289     {
    290         if (source == this->getParentAsBase())
     288    void GameState::makeTransition(GameState* source, GameState* destination)
     289    {
     290        if (source == this->getParent())
    291291        {
    292292            // call is from the parent
    … …  
    308308
    309309        // Check for 'destination' in the children map first
    310         std::map<GameStateBase*, GameStateBase*>::const_iterator it
     310        std::map<GameState*, GameState*>::const_iterator it
    311311            = this->grandchildrenToChildren_.find(destination);
    312312        if (it != this->grandchildrenToChildren_.end())
    … …  
    319319        {
    320320            // parent. We can be sure of this.
    321             assert(this->getParentAsBase() != 0);
     321            assert(this->getParent() != 0);
    322322
    323323            this->deactivate();
    324             this->getParentAsBase()->makeTransition(this, destination);
     324            this->getParent()->makeTransition(this, destination);
    325325        }
    326326    }
    … …  
    330330        Activates the state. Only sets bActive_ to true and notifies the parent.
    331331    */
    332     void GameStateBase::activate()
     332    void GameState::activate()
    333333    {
    334334        this->operation_.active = true;
    … …  
    341341        Activates the state. Only sets bActive_ to false and notifies the parent.
    342342    */
    343     void GameStateBase::deactivate()
     343    void GameState::deactivate()
    344344    {
    345345        this->operation_.leaving = true;
    … …  
    358358        This method is not virtual! You cannot override it therefore.
    359359    */
    360     void GameStateBase::tick(const Clock& time)
     360    void GameState::tick(const Clock& time)
    361361    {
    362362        this->operation_.running = true;

  • code/branches/gui/src/core/GameState.h

    r2815 r2817  
    6060        Then Bar stores Foo in map by its name. The other one then maps Foo to Foofoo.
    6161    */
    62     class _CoreExport GameStateBase
     62    class _CoreExport GameState
    6363    {
    6464        friend class RootGameState;
    65         template <class ParentType>
    66         friend class GameState;
    6765        // Hack
    6866        friend class Game;
    … …  
    8381
    8482    public:
    85         virtual ~GameStateBase();
     83        GameState(const std::string& name);
     84        virtual ~GameState();
    8685
    8786        const std::string& getName() const { return name_; }
    8887        const Operations getOperation() const { return this->operation_; }
    89         bool isInSubtree(GameStateBase* state) const;
     88        bool isInSubtree(GameState* state) const;
    9089
    91         GameStateBase* getState(const std::string& name);
    92         GameStateBase* getRoot();
     90        GameState* getState(const std::string& name);
     91        GameState* getRoot();
    9392        //! Returns the currently active game state
    94         virtual GameStateBase* getCurrentState();
     93        virtual GameState* getCurrentState();
    9594
    9695        virtual void requestState(const std::string& name);
    9796
    98         void addChild(GameStateBase* state);
    99         void removeChild(GameStateBase* state);
     97        void addChild(GameState* state);
     98        void removeChild(GameState* state);
    10099        void removeChild(const std::string& name);
    101100
    … …  
    105104        virtual void ticked(const Clock& time) = 0;
    106105
    107         GameStateBase* getActiveChild() { return this->activeChild_; }
     106        GameState* getActiveChild() { return this->activeChild_; }
    108107
    109108        void tickChild(const Clock& time) { if (this->getActiveChild()) this->getActiveChild()->tick(time); }
    110109
    111         virtual GameStateBase* getParentAsBase() const = 0;
    112         virtual void setParent(GameStateBase* state) = 0;
     110        GameState* getParent() const     { return this->parent_; }
     111        void setParent(GameState* state) { this->parent_ = state; }
    113112
    114113    private:
    115         // Making the constructor private ensures that game states
    116         // are always derivates of GameState<T>. Note the friend declaration above.
    117         GameStateBase(const std::string& name);
     114        //! Performs a transition to 'destination'
     115        virtual void makeTransition(GameState* source, GameState* destination);
    118116
    119         //! Performs a transition to 'destination'
    120         virtual void makeTransition(GameStateBase* source, GameStateBase* destination);
    121 
    122         void grandchildAdded(GameStateBase* child, GameStateBase* grandchild);
    123         void grandchildRemoved(GameStateBase* grandchild);
     117        void grandchildAdded(GameState* child, GameState* grandchild);
     118        void grandchildRemoved(GameState* grandchild);
    124119
    125120        void tick(const Clock& time);
    … …  
    129124        const std::string                        name_;
    130125        Operations                               operation_;
    131         GameStateBase*                           activeChild_;
     126        GameState*                               parent_;
     127        GameState*                               activeChild_;
    132128        //bool                                     bPauseParent_;
    133         std::map<std::string, GameStateBase*>    allChildren_;
    134         std::map<GameStateBase*, GameStateBase*> grandchildrenToChildren_;
    135     };
    136 
    137 
    138     template <class ParentType>
    139     class GameState : public GameStateBase
    140     {
    141     public:
    142         GameState(const std::string& name)
    143             : GameStateBase(name)
    144             , parent_(0)
    145         { }
    146         virtual ~GameState() { }
    147 
    148         GameStateBase* getParentAsBase() const
    149             { return parent_; }
    150 
    151         ParentType* getParent() const
    152             { return parent_; }
    153 
    154     protected:
    155         void setParent(GameStateBase* state)
    156         {
    157             assert(dynamic_cast<ParentType*>(state) != 0);
    158             this->parent_ = dynamic_cast<ParentType*>(state);
    159         }
    160 
    161     private:
    162         ParentType* parent_;
     129        std::map<std::string, GameState*>        allChildren_;
     130        std::map<GameState*, GameState*>         grandchildrenToChildren_;
    163131    };
    164132}

  • code/branches/gui/src/core/RootGameState.cc

    r2815 r2817  
    3636{
    3737    RootGameState::RootGameState(const std::string& name)
    38         : GameState<GameStateBase>(name)
     38        : GameState(name)
    3939        , stateRequest_("")
    4040    {
    … …  
    5050        the method can assume certain things to be granted (like 'this' is always active).
    5151    */
    52     void RootGameState::makeTransition(GameStateBase* source, GameStateBase* destination)
     52    void RootGameState::makeTransition(GameState* source, GameState* destination)
    5353    {
    5454        if (source != 0)
    … …  
    6565
    6666        // Check for 'destination' in the children map first
    67         std::map<GameStateBase*, GameStateBase*>::const_iterator it
     67        std::map<GameState*, GameState*>::const_iterator it
    6868            = this->grandchildrenToChildren_.find(destination);
    6969        if (it != this->grandchildrenToChildren_.end())
    7070        {
    71             OrxAssert(static_cast<GameStateBase*>(it->second) != 0,
     71            OrxAssert(static_cast<GameState*>(it->second) != 0,
    7272                "There was a mix with RootGameState and GameState, could not cast.");
    73             GameStateBase* child = static_cast<GameStateBase*>(it->second);
     73            GameState* child = static_cast<GameState*>(it->second);
    7474            // child state. Don't use 'state', might be a grandchild!
    7575            this->activeChild_ = child;
    … …  
    8585    void RootGameState::gotoState(const std::string& name)
    8686    {
    87         GameStateBase* request = getState(name);
     87        GameState* request = getState(name);
    8888        if (request)
    8989        {
    90             GameStateBase* current = getCurrentState();
     90            GameState* current = getCurrentState();
    9191            if (current)
    9292            {

  • code/branches/gui/src/core/RootGameState.h

    r2805 r2817  
    3535namespace orxonox
    3636{
    37     class _CoreExport RootGameState : public GameState<GameStateBase>
     37    class _CoreExport RootGameState : public GameState
    3838    {
    3939        // Hack!
    … …  
    4747
    4848    private:
    49         void makeTransition(GameStateBase* source, GameStateBase* destination);
     49        void makeTransition(GameState* source, GameState* destination);
    5050        void gotoState(const std::string& name);
    5151
Note: See TracChangeset for help on using the changeset viewer.