source/network/FSM.cpp

   1 /* Copyright (C) 2023 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)
  23 {
  24         m_Type = type;
  25         m_Param = nullptr;
  26 }
  27
  28 CFsmEvent::~CFsmEvent()
  29 {
  30         m_Param = nullptr;
  31 }
  32
  33 void CFsmEvent::SetParamRef(void* pParam)
  34 {
  35         m_Param = pParam;
  36 }
  37
  38 CFsmTransition::CFsmTransition(unsigned int state)
  39 {
  40         m_CurrState = state;
  41 }
  42
  43 CFsmTransition::~CFsmTransition()
  44 {
  45         m_Actions.clear();
  46         m_Conditions.clear();
  47 }
  48
  49 void CFsmTransition::RegisterAction(void* pAction, void* pContext)
  50 {
  51         CallbackFunction callback;
  52
  53         // Add action at the end of actions list
  54         callback.pFunction = pAction;
  55         callback.pContext = pContext;
  56
  57         m_Actions.push_back(callback);
  58 }
  59
  60 void CFsmTransition::RegisterCondition(void* pCondition, void* pContext)
  61 {
  62         CallbackFunction callback;
  63
  64         // Add condition at the end of conditions list
  65         callback.pFunction = pCondition;
  66         callback.pContext = pContext;
  67
  68         m_Conditions.push_back(callback);
  69 }
  70
  71 void CFsmTransition::SetEvent(CFsmEvent* pEvent)
  72 {
  73         m_Event = pEvent;
  74 }
  75
  76 void CFsmTransition::SetNextState(unsigned int nextState)
  77 {
  78         m_NextState = nextState;
  79 }
  80
  81 bool CFsmTransition::ApplyConditions() const
  82 {
  83         bool eval = true;
  84
  85         CallbackList::const_iterator it = m_Conditions.begin();
  86         for (; it != m_Conditions.end(); ++it)
  87         {
  88                 if (it->pFunction)
  89                 {
  90                         // Evaluate condition
  91                         Condition* condition = reinterpret_cast<Condition*>(it->pFunction);
  92                         eval &= condition(it->pContext);
  93                 }
  94         }
  95
  96         return eval;
  97 }
  98
  99 bool CFsmTransition::RunActions() const
 100 {
 101         bool result = true;
 102
 103         CallbackList::const_iterator it = m_Actions.begin();
 104         for (; it != m_Actions.end(); ++it)
 105         {
 106                 if (it->pFunction)
 107                 {
 108                         // Run action
 109                         Action* action = reinterpret_cast<Action*>(it->pFunction);
 110                         result &= action(it->pContext, m_Event);
 111                 }
 112         }
 113
 114         return result;
 115 }
 116
 117 CFsm::CFsm()
 118 {
 119         m_Done = false;
 120         m_FirstState = FSM_INVALID_STATE;
 121         m_CurrState = FSM_INVALID_STATE;
 122         m_NextState = FSM_INVALID_STATE;
 123 }
 124
 125 CFsm::~CFsm()
 126 {
 127         Shutdown();
 128 }
 129
 130 void CFsm::Setup()
 131 {
 132         // Does nothing by default
 133 }
 134
 135 void CFsm::Shutdown()
 136 {
 137         // Release transitions
 138         TransitionList::iterator itTransition = m_Transitions.begin();
 139         for (; itTransition < m_Transitions.end(); ++itTransition)
 140                 delete *itTransition;
 141
 142         // Release events
 143         EventMap::iterator itEvent = m_Events.begin();
 144         for (; itEvent != m_Events.end(); ++itEvent)
 145                 delete itEvent->second;
 146
 147         m_States.clear();
 148         m_Events.clear();
 149         m_Transitions.clear();
 150
 151         m_Done = false;
 152         m_FirstState = FSM_INVALID_STATE;
 153         m_CurrState = FSM_INVALID_STATE;
 154         m_NextState = FSM_INVALID_STATE;
 155 }
 156
 157 void CFsm::AddState(unsigned int state)
 158 {
 159         m_States.insert(state);
 160 }
 161
 162 CFsmEvent* CFsm::AddEvent(unsigned int eventType)
 163 {
 164         CFsmEvent* pEvent = nullptr;
 165
 166         // Lookup event by type
 167         EventMap::iterator it = m_Events.find(eventType);
 168         if (it != m_Events.end())
 169         {
 170                 pEvent = it->second;
 171         }
 172         else
 173         {
 174                 pEvent = new CFsmEvent(eventType);
 175
 176                 // Store new event into internal map
 177                 m_Events[eventType] = pEvent;
 178         }
 179
 180         return pEvent;
 181 }
 182
 183 CFsmTransition* CFsm::AddTransition(unsigned int state, unsigned int eventType, unsigned int nextState )
 184 {
 185         // Make sure we store the current state
 186         AddState(state);
 187
 188         // Make sure we store the next state
 189         AddState(nextState);
 190
 191         // Make sure we store the event
 192         CFsmEvent* pEvent = AddEvent(eventType);
 193         if (!pEvent)
 194                 return nullptr;
 195
 196         // Create new transition
 197         CFsmTransition* pNewTransition = new CFsmTransition(state);
 198
 199         // Setup new transition
 200         pNewTransition->SetEvent(pEvent);
 201         pNewTransition->SetNextState(nextState);
 202
 203         // Store new transition
 204         m_Transitions.push_back(pNewTransition);
 205
 206         return pNewTransition;
 207 }
 208
 209 CFsmTransition* CFsm::AddTransition(unsigned int state, unsigned int eventType, unsigned int nextState,
 210         void* pAction, void* pContext)
 211 {
 212         CFsmTransition* pTransition = AddTransition(state, eventType, nextState);
 213         if (!pTransition)
 214                 return nullptr;
 215
 216         // If action specified, register it
 217         if (pAction)
 218                 pTransition->RegisterAction(pAction, pContext);
 219
 220         return pTransition;
 221 }
 222
 223 CFsmTransition* CFsm::GetTransition(unsigned int state, unsigned int eventType) const
 224 {
 225         if (!IsValidState(state))
 226                 return nullptr;
 227
 228         if (!IsValidEvent(eventType))
 229                 return nullptr;
 230
 231         TransitionList::const_iterator it = m_Transitions.begin();
 232         for (; it != m_Transitions.end(); ++it)
 233         {
 234                 CFsmTransition* pCurrTransition = *it;
 235                 if (!pCurrTransition)
 236                         continue;
 237
 238                 CFsmEvent* pCurrEvent = pCurrTransition->GetEvent();
 239                 if (!pCurrEvent)
 240                         continue;
 241
 242                 // Is it our transition?
 243                 if (pCurrTransition->GetCurrState() == state &&  pCurrEvent->GetType() == eventType)
 244                         return pCurrTransition;
 245         }
 246
 247         // No transition found
 248         return nullptr;
 249 }
 250
 251 void CFsm::SetFirstState(unsigned int firstState)
 252 {
 253         m_FirstState = firstState;
 254 }
 255
 256 void CFsm::SetCurrState(unsigned int state)
 257 {
 258         m_CurrState = state;
 259 }
 260
 261 bool CFsm::IsFirstTime() const
 262 {
 263         return (m_CurrState == FSM_INVALID_STATE);
 264 }
 265
 266 bool CFsm::Update(unsigned int eventType, void* pEventParam)
 267 {
 268         if (!IsValidEvent(eventType))
 269                 return false;
 270
 271         if (IsFirstTime())
 272                 m_CurrState = m_FirstState;
 273
 274         // Lookup transition
 275         CFsmTransition* pTransition = GetTransition(m_CurrState, eventType);
 276         if (!pTransition)
 277                 return false;
 278
 279         // Setup event parameter
 280         EventMap::iterator it = m_Events.find(eventType);
 281         if (it != m_Events.end())
 282         {
 283                 CFsmEvent* pEvent = it->second;
 284                 if (pEvent)
 285                         pEvent->SetParamRef(pEventParam);
 286         }
 287
 288         // Valid transition?
 289         if (!pTransition->ApplyConditions())
 290                 return false;
 291
 292         // Save the default state transition (actions might call SetNextState
 293         // to override this)
 294         SetNextState(pTransition->GetNextState());
 295
 296         if (!pTransition->RunActions())
 297                 return false;
 298
 299         SetCurrState(GetNextState());
 300
 301         // Reset the next state since it's no longer valid
 302         SetNextState(FSM_INVALID_STATE);
 303
 304         return true;
 305 }
 306
 307 bool CFsm::IsDone() const
 308 {
 309         // By default the internal flag m_Done is tested
 310         return m_Done;
 311 }
 312
 313 bool CFsm::IsValidState(unsigned int state) const
 314 {
 315         StateSet::const_iterator it = m_States.find(state);
 316         if (it == m_States.end())
 317                 return false;
 318
 319         return true;
 320 }
 321
 322 bool CFsm::IsValidEvent(unsigned int eventType) const
 323 {
 324         EventMap::const_iterator it = m_Events.find(eventType);
 325         if (it == m_Events.end())
 326                 return false;
 327
 328         return true;
 329 }