//ExecuteTacticsItem
protected void ResetPreviousTacticsItem(ref AllyTacticsItem PreviousExecutionItem,
ref AllyMember PreviousExecutionTarget)
{
//Do not reset current, only past tactics item.
PreviousExecutionItem = null;
PreviousExecutionTarget = null;
}
/// <summary>
/// Compares Current To Previous Tactics Item To Determine If New Tactics Item Was Obtained.
/// If Current Tactics Equal Past Tactics, Condition Will Fail.
/// CheckPreviousNullInstead Boolean Will Check Previous Tactics Instead.
/// </summary>
public bool HasNewTacticsItem(ref AllyTacticsItem CurrentExecutionItem,
ref AllyMember CurrentExecutionTarget,
ref AllyTacticsItem PreviousExecutionItem,
ref AllyMember PreviousExecutionTarget, bool CheckPreviousNullInstead)
{
if (CheckPreviousNullInstead == false)
{
if (CurrentExecutionItem == PreviousExecutionItem &&
CurrentExecutionTarget == PreviousExecutionTarget)
{
return(false);
}
else
{
return(true);
}
}
else
{
if (PreviousExecutionItem != null && PreviousExecutionTarget != null)
{
return(true);
}
return(false);
}
}
/// <summary>
/// Resets Execution Items And Targets, Previous and Current.
/// </summary>
public bool ResetTacticsItems(ref AllyTacticsItem CurrentExecutionItem, ref AllyMember CurrentExecutionTarget,
ref AllyTacticsItem PreviousExecutionItem, ref AllyMember PreviousExecutionTarget)
{
CurrentExecutionItem = null;
CurrentExecutionTarget = null;
PreviousExecutionItem = null;
PreviousExecutionTarget = null;
return(true);
}
protected void ResetCurrentTacticsItem(ref AllyTacticsItem CurrentExecutionItem,
ref AllyMember CurrentExecutionTarget,
ref AllyTacticsItem PreviousExecutionItem,
ref AllyMember PreviousExecutionTarget)
{
//Setting Previous Tactics Item To Current Item
PreviousExecutionItem = CurrentExecutionItem;
PreviousExecutionTarget = CurrentExecutionTarget;
//Resetting Current Tactics Item
CurrentExecutionItem = null;
CurrentExecutionTarget = null;
}
protected virtual AllyTacticsItem EvaluateTacticalConditionOrders(List <AllyTacticsItem> _tactics)
{
int _order = int.MaxValue;
AllyTacticsItem _exeTactic = null;
foreach (var _tactic in _tactics)
{
if (_tactic.order < _order)
{
_order = _tactic.order;
_exeTactic = _tactic;
}
}
return(_exeTactic);
}
//EvaluateTacticsSuccessful
protected (AllyTacticsItem _tacticItem, AllyMember _target) EvaluateTacticalConditionOrders()
{
int _order = int.MaxValue;
AllyTacticsItem _exeTactic = null;
AllyMember _exeTarget = null;
foreach (var _tactic in evalTactics)
{
if (_tactic.Key.order < _order)
{
_order = _tactic.Key.order;
_exeTactic = _tactic.Key;
_exeTarget = _tactic.Value;
}
}
return(_exeTactic, _exeTarget);
}
/// <summary>
/// Executes The Given Tactics Item with Target.
/// StopPerformingTask Determines If Stop Performing Task Should Be Executed Instead.
/// Make Sure The CurrentTacticsItem and Target aren't null when executing an action.
/// If Stopping, make sure previous tactics item isn't null either.
/// Current will be reset if not stopping, and previous will be reset after stopping.
/// </summary>
public bool ExecuteTacticsItem(ref AllyTacticsItem CurrentExecutionItem,
ref AllyMember CurrentExecutionTarget,
ref AllyTacticsItem PreviousExecutionItem,
ref AllyMember PreviousExecutionTarget, bool StopPerformingTask)
{
if (StopPerformingTask == false)
{
if (CurrentExecutionItem != null && CurrentExecutionTarget != null)
{
//Not Stopping, Execute Current Item
CurrentExecutionItem.action.actionToPerform(allyMember, aiController, CurrentExecutionTarget);
ResetCurrentTacticsItem(ref CurrentExecutionItem, ref CurrentExecutionTarget,
ref PreviousExecutionItem, ref PreviousExecutionTarget);
}
else
{
//Resetting Current Tactics Item
CurrentExecutionItem = null;
CurrentExecutionTarget = null;
//Return Failure If Current Item is Null when trying to execute action.
return(false);
}
}
else
{
if (PreviousExecutionItem != null && PreviousExecutionTarget != null)
{
//Use Previous Execution Item To Stop Performing Task
PreviousExecutionItem.action.stopPerformingTask(allyMember, aiController, PreviousExecutionTarget);
ResetPreviousTacticsItem(ref PreviousExecutionItem, ref PreviousExecutionTarget);
}
else
{
ResetPreviousTacticsItem(ref PreviousExecutionItem, ref PreviousExecutionTarget);
//Return Failure If Previous Item is Null when trying to stop execution.
return(false);
}
}
return(true);
}
/// <summary>
/// Returns True if Evaluating Tactics Successfully Returns A Tactics Item.
/// </summary>
public bool EvaluateTacticsSuccessful(ref AllyTacticsItem CurrentExecutionItem, ref AllyMember CurrentExecutionTarget)
{
//Temporary Fix for PartyManager Delaying Initial AllyInCommand Methods
if (allyInCommand == null)
{
CurrentExecutionItem = null;
CurrentExecutionTarget = null;
return(false);
}
evalTactics.Clear();
foreach (var _tactic in AllyTacticsList)
{
//If Condition is True and
//Can Perform The Given Action
var _boolTargetTuple = _tactic.condition.action(allyMember, aiController);
if (_boolTargetTuple._success &&
_tactic.action.canPerformAction(allyMember, aiController, _boolTargetTuple._target))
{
evalTactics.Add(_tactic, _boolTargetTuple._target);
}
}
if (evalTactics.Count > 0)
{
var _currentItem = EvaluateTacticalConditionOrders();
CurrentExecutionItem = _currentItem._tacticItem;
CurrentExecutionTarget = _currentItem._target;
return(true);
}
else
{
CurrentExecutionItem = null;
CurrentExecutionTarget = null;
return(false);
}
}
protected virtual void ExecuteAllyTacticsList()
{
if (!AllyComponentsAreReady)
{
Debug.LogError("Not All Components are Available, cannot execute Tactics.");
UnLoadAndCancelTactics();
UnsubFromEvents();
Destroy(this);
}
// Pause Ally Tactics If Ally Is Paused
// Due to the Game Pausing Or Control Pause Mode
// Is Active
if (myEventHandler.bAllyIsPaused)
{
return;
}
//Don't Want to Execute Tactics While in the
//Middle of an Ability Use
if (myEventHandler.bIsUsingAbility)
{
return;
}
//Temporary Fix for PartyManager Delaying Initial AllyInCommand Methods
if (allyInCommand == null)
{
return;
}
evalTactics.Clear();
foreach (var _tactic in AllyTacticsList)
{
//If Condition is True and
//Can Perform The Given Action
if (_tactic.condition.action(allyMember) &&
_tactic.action.canPerformAction(allyMember))
{
evalTactics.Add(_tactic);
}
}
if (evalTactics.Count > 0)
{
previousExecutionItem = currentExecutionItem;
currentExecutionItem = EvaluateTacticalConditionOrders(evalTactics);
//Execution Item isn't null and Previous Entry Doesn't Equal Current One
//Prevents AddActionItem Event Being Called Constantly
if (currentExecutionItem != null &&
currentExecutionItem.action != null &&
currentExecutionItem.action.actionToPerform != null &&
bCanAddActionItemToQueue
)
{
myEventHandler.CallOnAddActionItemToQueue(currentExecutionItem.action);
}
}
else
{
if (currentExecutionItem != null)
{
myEventHandler.CallOnRemoveAIActionFromQueue();
}
//Setting Previous To Null Is Equivalent To
//A Boolean That Gets Set To True Once an
//Action Gets Added And False When Removing
previousExecutionItem = null;
currentExecutionItem = null;
}
}
