0ad/source/network/FSM.cpp

/* 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 <http://www.gnu.org/licenses/>.
 */

// 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;
}