/* Copyright (C) 2023 Wildfire Games. * This file is part of 0 A.D. * * 0 A.D. 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 2 of the License, or * (at your option) any later version. * * 0 A.D. 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 0 A.D. If not, see . */ // INCLUDES #include "precompiled.h" #include "FSM.h" // DECLARATIONS //----------------------------------------------------------------------------- // Name: CFsmEvent() // Desc: Constructor //----------------------------------------------------------------------------- CFsmEvent::CFsmEvent(unsigned int type) { m_Type = type; m_Param = nullptr; } //----------------------------------------------------------------------------- // Name; ~CFsmEvent() // Desc: Destructor //----------------------------------------------------------------------------- CFsmEvent::~CFsmEvent() { m_Param = nullptr; } //----------------------------------------------------------------------------- // Name: SetParamRef() // Desc: Sets the parameter for the event //----------------------------------------------------------------------------- void CFsmEvent::SetParamRef(void* pParam) { m_Param = pParam; } //----------------------------------------------------------------------------- // Name: CFsmTransition() // Desc: Constructor //----------------------------------------------------------------------------- CFsmTransition::CFsmTransition(unsigned int state) { m_CurrState = state; } //----------------------------------------------------------------------------- // Name: ~CFsmTransition() // Desc: Destructor //----------------------------------------------------------------------------- CFsmTransition::~CFsmTransition() { m_Actions.clear(); m_Conditions.clear(); } //----------------------------------------------------------------------------- // Name: RegisterAction() // Desc: Adds action that will be executed when the transition will occur //----------------------------------------------------------------------------- void CFsmTransition::RegisterAction(void* pAction, void* pContext) { CallbackFunction callback; // Add action at the end of actions list callback.pFunction = pAction; callback.pContext = pContext; m_Actions.push_back(callback); } //----------------------------------------------------------------------------- // Name: AddCondition() // Desc: Adds condition which will be evaluated when the transition will occurs //----------------------------------------------------------------------------- void CFsmTransition::RegisterCondition(void* pCondition, void* pContext) { CallbackFunction callback; // Add condition at the end of conditions list callback.pFunction = pCondition; callback.pContext = pContext; m_Conditions.push_back(callback); } //----------------------------------------------------------------------------- // Name: SetEvent() // Desc: Set event for which transition will occur //----------------------------------------------------------------------------- void CFsmTransition::SetEvent(CFsmEvent* pEvent) { m_Event = pEvent; } //----------------------------------------------------------------------------- // Name: SetNextState() // Desc: Set next state the transition will switch the system to //----------------------------------------------------------------------------- void CFsmTransition::SetNextState(unsigned int nextState) { m_NextState = nextState; } //----------------------------------------------------------------------------- // Name: ApplyConditions() // Desc: Evaluate conditions for the transition // Note: If there are no conditions, assume true //----------------------------------------------------------------------------- bool CFsmTransition::ApplyConditions() const { bool eval = true; CallbackList::const_iterator it = m_Conditions.begin(); for (; it != m_Conditions.end(); ++it) { if (it->pFunction) { // Evaluate condition CONDITION Condition = (CONDITION)it->pFunction; eval &= Condition(it->pContext); } } return eval; } //----------------------------------------------------------------------------- // Name: RunActions() // Desc: Execute actions for the transition // Note: If there are no actions, assume true //----------------------------------------------------------------------------- bool CFsmTransition::RunActions() const { bool result = true; CallbackList::const_iterator it = m_Actions.begin(); for (; it != m_Actions.end(); ++it) { if (it->pFunction) { // Run action ACTION Action = (ACTION)it->pFunction; result &= Action(it->pContext, m_Event); } } return result; } //----------------------------------------------------------------------------- // Name: CFsm() // Desc: Constructor //----------------------------------------------------------------------------- CFsm::CFsm() { m_Done = false; m_FirstState = FSM_INVALID_STATE; m_CurrState = FSM_INVALID_STATE; m_NextState = FSM_INVALID_STATE; } //----------------------------------------------------------------------------- // Name: ~CFsm() // Desc: Destructor //----------------------------------------------------------------------------- CFsm::~CFsm() { Shutdown(); } //----------------------------------------------------------------------------- // Name: Setup() // Desc: Setup events, actions and state transitions //----------------------------------------------------------------------------- void CFsm::Setup() { // Does nothing by default } //----------------------------------------------------------------------------- // Name: Reset() // Desc: Shuts down the state machine and releases any resources //----------------------------------------------------------------------------- void CFsm::Shutdown() { // Release transitions TransitionList::iterator itTransition = m_Transitions.begin(); for (; itTransition < m_Transitions.end(); ++itTransition) delete *itTransition; // Release events EventMap::iterator itEvent = m_Events.begin(); for (; itEvent != m_Events.end(); ++itEvent) delete itEvent->second; m_States.clear(); m_Events.clear(); m_Transitions.clear(); m_Done = false; m_FirstState = FSM_INVALID_STATE; m_CurrState = FSM_INVALID_STATE; m_NextState = FSM_INVALID_STATE; } //----------------------------------------------------------------------------- // Name: AddState() // Desc: Adds the specified state to the internal list of states // Note: If a state with the specified ID exists, the state is not added //----------------------------------------------------------------------------- void CFsm::AddState(unsigned int state) { m_States.insert(state); } //----------------------------------------------------------------------------- // Name: AddEvent() // Desc: Adds the specified event to the internal list of events // Note: If an eveny with the specified ID exists, the event is not added //----------------------------------------------------------------------------- CFsmEvent* CFsm::AddEvent(unsigned int eventType) { CFsmEvent* pEvent = nullptr; // Lookup event by type EventMap::iterator it = m_Events.find(eventType); if (it != m_Events.end()) { pEvent = it->second; } else { pEvent = new CFsmEvent(eventType); // Store new event into internal map m_Events[eventType] = pEvent; } return pEvent; } //----------------------------------------------------------------------------- // Name: AddTransition() // Desc: Adds a new transistion to the state machine //----------------------------------------------------------------------------- CFsmTransition* CFsm::AddTransition(unsigned int state, unsigned int eventType, unsigned int nextState ) { // Make sure we store the current state AddState(state); // Make sure we store the next state AddState(nextState); // Make sure we store the event CFsmEvent* pEvent = AddEvent(eventType); if (!pEvent) return nullptr; // Create new transition CFsmTransition* pNewTransition = new CFsmTransition(state); // Setup new transition pNewTransition->SetEvent(pEvent); pNewTransition->SetNextState(nextState); // Store new transition m_Transitions.push_back(pNewTransition); return pNewTransition; } //----------------------------------------------------------------------------- // Name: AddTransition() // Desc: Adds a new transition to the state machine //----------------------------------------------------------------------------- CFsmTransition* CFsm::AddTransition(unsigned int state, unsigned int eventType, unsigned int nextState, void* pAction, void* pContext) { CFsmTransition* pTransition = AddTransition(state, eventType, nextState); if (!pTransition) return nullptr; // If action specified, register it if (pAction) pTransition->RegisterAction(pAction, pContext); return pTransition; } //----------------------------------------------------------------------------- // Name: GetTransition() // Desc: Lookup transition given the state, event and next state to transition //----------------------------------------------------------------------------- CFsmTransition* CFsm::GetTransition(unsigned int state, unsigned int eventType) const { // Valid state? if (!IsValidState(state)) return nullptr; // Valid event? if (!IsValidEvent(eventType)) return nullptr; // Loop through the list of transitions TransitionList::const_iterator it = m_Transitions.begin(); for (; it != m_Transitions.end(); ++it) { CFsmTransition* pCurrTransition = *it; if (!pCurrTransition) continue; CFsmEvent* pCurrEvent = pCurrTransition->GetEvent(); if (!pCurrEvent) continue; // Is it our transition? if (pCurrTransition->GetCurrState() == state && pCurrEvent->GetType() == eventType) return pCurrTransition; } // No transition found return nullptr; } //----------------------------------------------------------------------------- // Name: SetFirstState() // Desc: Set initial state for FSM //----------------------------------------------------------------------------- void CFsm::SetFirstState(unsigned int firstState) { m_FirstState = firstState; } //----------------------------------------------------------------------------- // Name: SetCurrState() // Desc: Set current state and update last state to current state //----------------------------------------------------------------------------- void CFsm::SetCurrState(unsigned int state) { m_CurrState = state; } //----------------------------------------------------------------------------- // Name: IsFirstTime() // Desc: Verifies if the state machine has been already updated //----------------------------------------------------------------------------- bool CFsm::IsFirstTime() const { return (m_CurrState == FSM_INVALID_STATE); } //----------------------------------------------------------------------------- // Name: Update() // Desc: Updates state machine and retrieves next state //----------------------------------------------------------------------------- bool CFsm::Update(unsigned int eventType, void* pEventParam) { // Valid event? if (!IsValidEvent(eventType)) return false; // First time update? if (IsFirstTime()) m_CurrState = m_FirstState; // Lookup transition CFsmTransition* pTransition = GetTransition(m_CurrState, eventType); if (!pTransition) return false; // Setup event parameter EventMap::iterator it = m_Events.find(eventType); if (it != m_Events.end()) { CFsmEvent* pEvent = it->second; if (pEvent) pEvent->SetParamRef(pEventParam); } // Valid transition? if (!pTransition->ApplyConditions()) return false; // Save the default state transition (actions might call SetNextState // to override this) SetNextState(pTransition->GetNextState()); // Run transition actions if (!pTransition->RunActions()) return false; // Switch state SetCurrState(GetNextState()); // Reset the next state since it's no longer valid SetNextState(FSM_INVALID_STATE); return true; } //----------------------------------------------------------------------------- // Name: IsDone() // Desc: Tests whether the state machine has finished its work // Note: This is state machine specific //----------------------------------------------------------------------------- bool CFsm::IsDone() const { // By default the internal flag m_Done is tested return m_Done; } //----------------------------------------------------------------------------- // Name: IsValidState() // Desc: Verifies whether the specified state is managed by FSM //----------------------------------------------------------------------------- bool CFsm::IsValidState(unsigned int state) const { StateSet::const_iterator it = m_States.find(state); if (it == m_States.end()) return false; return true; } //----------------------------------------------------------------------------- // Name: IsValidEvent() // Desc: Verifies whether the specified event is managed by FSM //----------------------------------------------------------------------------- bool CFsm::IsValidEvent(unsigned int eventType) const { EventMap::const_iterator it = m_Events.find(eventType); if (it == m_Events.end()) return false; return true; }