source/network/FSM.cpp

   1 /* Copyright (C) 2024 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "precompiled.h"
  19 #include "FSM.h"
  20
  21
  22 CFsmEvent::CFsmEvent(unsigned int type, void* pParam)
  23 {
  24         m_Type = type;
  25         m_Param = pParam;
  26 }
  27
  28 CFsmEvent::~CFsmEvent()
  29 {
  30         m_Param = nullptr;
  31 }
  32
  33 CFsm::CFsm()
  34 {
  35         m_Done = false;
  36         m_FirstState = FSM_INVALID_STATE;
  37         m_CurrState = FSM_INVALID_STATE;
  38         m_NextState = FSM_INVALID_STATE;
  39 }
  40
  41 CFsm::~CFsm()
  42 {
  43         Shutdown();
  44 }
  45
  46 void CFsm::Setup()
  47 {
  48         // Does nothing by default
  49 }
  50
  51 void CFsm::Shutdown()
  52 {
  53         m_States.clear();
  54         m_Transitions.clear();
  55
  56         m_Done = false;
  57         m_FirstState = FSM_INVALID_STATE;
  58         m_CurrState = FSM_INVALID_STATE;
  59         m_NextState = FSM_INVALID_STATE;
  60 }
  61
  62 void CFsm::AddState(unsigned int state)
  63 {
  64         m_States.insert(state);
  65 }
  66
  67 void CFsm::AddTransition(unsigned int state, unsigned int eventType, unsigned int nextState,
  68         Action* pAction /* = nullptr */, void* pContext /* = nullptr*/)
  69 {
  70         // Make sure we store the current state
  71         AddState(state);
  72
  73         // Make sure we store the next state
  74         AddState(nextState);
  75
  76         m_Transitions.insert({TransitionKey{state, eventType}, Transition{{pAction, pContext}, nextState}});
  77 }
  78
  79 void CFsm::SetFirstState(unsigned int firstState)
  80 {
  81         m_FirstState = firstState;
  82 }
  83
  84 void CFsm::SetCurrState(unsigned int state)
  85 {
  86         m_CurrState = state;
  87 }
  88
  89 bool CFsm::IsFirstTime() const
  90 {
  91         return (m_CurrState == FSM_INVALID_STATE);
  92 }
  93
  94 bool CFsm::Update(unsigned int eventType, void* pEventParam)
  95 {
  96         if (IsFirstTime())
  97                 m_CurrState = m_FirstState;
  98
  99         if (!IsValidState(m_CurrState))
 100                 return false;
 101
 102         // Lookup transition
 103         auto transitionIterator = m_Transitions.find({m_CurrState, eventType});
 104         if (transitionIterator == m_Transitions.end())
 105                 return false;
 106
 107         CFsmEvent event{eventType, pEventParam};
 108
 109         // Save the default state transition (actions might call SetNextState
 110         // to override this)
 111         SetNextState(transitionIterator->second.nextState);
 112
 113         if (!transitionIterator->second.action(event))
 114                 return false;
 115
 116         SetCurrState(GetNextState());
 117
 118         // Reset the next state since it's no longer valid
 119         SetNextState(FSM_INVALID_STATE);
 120
 121         return true;
 122 }
 123
 124 bool CFsm::IsDone() const
 125 {
 126         // By default the internal flag m_Done is tested
 127         return m_Done;
 128 }
 129
 130 bool CFsm::IsValidState(unsigned int state) const
 131 {
 132         StateSet::const_iterator it = m_States.find(state);
 133         if (it == m_States.end())
 134                 return false;
 135
 136         return true;
 137 }