public override void Execute(FSMBehaviour fsm)
{
//NullReference Bugfix
if (goToState == null) //Nao permite estados nullos
{
return;
}
//StackOverflow Bufix
if (goToState == this) //Não permite eu mesmo como estado
{
return;
}
//StackOverflow Bufix
if (goToState == connectedState) //Não permite que o proximo estado seja o estado em que eu estou conectado.
{
return;
}
//Jump to node
goToState.SetCurrentState();
}
private void ExecuteDecision(FSMBehaviour fsm)
{
foreach (DynamicDecision d in dynamics)
{
d.ExecuteDecisions(fsm);
}
}
public override void Execute(FSMBehaviour fsm)
{
if (action != null)
{
action.Execute(fsm);
}
}
private bool GetDecisionResult(FSMBehaviour fsm)
{
if (intpuPort.ConnectionCount <= 0)
{
return(false);
}
bool result = false;
List <NodePort> connectionPorts = intpuPort.GetConnections();
List <NodeBase_Decision> list = new List <NodeBase_Decision>();
foreach (NodePort p in connectionPorts)
{
list.Add((NodeBase_Decision)p.node);
}
result = !list.Exists(r => r.Execute(fsm) == false);
//Clear garbage
connectionPorts.Clear();
list.Clear();
connectionPorts = null;
list = null;
return(result);
}
public override void Execute(FSMBehaviour fsm)
{
//Executa ações
ExecuteActions(fsm);
//Executa decisões de caso e vai para o proximo estado
ExecuteDecision(fsm);
}
public override bool Execute(FSMBehaviour fsm)
{
if (Application.isEditor && Application.isPlaying == false)
{
return(false);
}
return(CheckDecision((NavMeshAgentFSM)fsm));
}
public override void Execute(FSMBehaviour fsm)
{
//Executa ações
ExecuteActions(fsm);
//Executa decisões e muda de estado
bool decisionResult = ExecuteDecisions(fsm);
GoToNextState(decisionResult);
}
public override bool Execute(FSMBehaviour fsm)
{
foreach (DynamicDecision d in dynamics)
{
d.ExecuteDecisions(fsm);
}
return(false);
}
public override void Execute(FSMBehaviour fsm)
{
NodePort outPort = GetOutputPort("outState");
if (outPort.ConnectionCount > 0)
{
NodeBase_State next = (NodeBase_State)outPort.Connection.node;
next.SetCurrentState();
}
}
/// <summary>
/// Atualiza o <seealso cref="CurrentState"/> para executar ações e decisões. Modifica automaticamente o CurrentState
/// caso haja uma decisão verdadeira e um estado de transição válido
/// </summary>
/// <param name="fsm">Finite State Machine</param>
public void UpdateGraph(FSMBehaviour fsm)
{
if (_currentState == null)
{
return;
}
last_fsm_executed = fsm;
currentState_elapsedTime += Time.deltaTime;
_currentState.Execute(fsm);
}
private void ExecuteActions(FSMBehaviour fsm)
{
List <NodeBase_Action> actions = GetActions();
foreach (NodeBase_Action action in actions)
{
action.Execute(fsm);
}
actions.Clear();
actions = null;
}
public override bool Execute(FSMBehaviour fsm)
{
List <NodeBase_Decision> decisions = GetAllInputDecisions();
List <NodeBase_Decision> orDecisions = GetAllOrInputDecisions();
bool resultA = !decisions.Exists(r => r.Execute(fsm) == false);
bool resultB = !orDecisions.Exists(r => r.Execute(fsm) == false);
bool resultC = dynamics.Count <= 0 ? false : !dynamics.Exists(r => r.GetDecisionResult(fsm) == false);
return(resultA || resultB || resultC);
}
public override bool Execute(FSMBehaviour fsm)
{
CheckReferenceIsValid();
if (aiDecision == null)
{
return(false);
}
bool result = aiDecision.Execute(fsm);
return(result);
}
public override void Execute(FSMBehaviour fsm)
{
NavMeshAgentFSM fsmn = (NavMeshAgentFSM)fsm;
fsmn.navMeshAgent.isStopped = true;
fsmn.navMeshAgent.ResetPath();
fsmn.navMeshAgent.velocity = Vector3.zero;
if (fsmn.rigidBody.isKinematic == false)
{
fsmn.rigidBody.velocity = Vector3.zero;
}
}
/// <summary>
/// Texto del boton de inmortalidad
/// </summary>
//private string InmortalText;
// Use this for initialization
void Start()
{
// Obtengo los id de las capas
PlayerLayer = LayerMask.NameToLayer("Player");
ObstaclesLayer = LayerMask.NameToLayer("Obstacles");
if (Player)
{
InmunityComponent = Player.GetComponentInChildren<Inmunity>();
FSM = Player.GetComponentInChildren<PlayerManager>();
}
TextInmortal.text = "Inmortal";
}
public override bool Execute(FSMBehaviour fsm)
{
NodePort inPort = GetInputPort("inDecision");
if (inPort.Connection == null)
{
return(false);
}
NodeBase_Decision nodeDecision = (NodeBase_Decision)inPort.Connection.node;
return(!nodeDecision.Execute(fsm));
}
public override void Execute(FSMBehaviour fsm)
{
if (Application.isEditor && Application.isPlaying == false)
{
return;
}
Graph_State graph_state = (Graph_State)graph;
IntVar intvar = null;
if (graph_state.TryGetIntVar(varName, out intvar, localType))
{
intvar.value = GetInputValue <int>("inputValue", this.inputValue);
}
}
public XmasLogBehaviour1(Boss boss) : base(boss)
{
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-log-behaviour1");
var targetingInitialPositionBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingInitialPosition)
.OnUpdate(TargetingInitialPositionTaskUpdate);
var shootingPatternBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.ShootingPattern)
.OnEnter(ShootingPatternTaskEnter);
_stateMachine.Add(BehaviourState.TargetingInitialPosition, targetingInitialPositionBehaviour);
_stateMachine.Add(BehaviourState.ShootingPattern, shootingPatternBehaviour);
}
public XmasSnowmanBehaviour1(Boss boss) : base(boss)
{
InitialBehaviourLife = GameConfig.BossDefaultBehaviourLife * 0.5f;
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-snowman-behaviour1");
var targetingInitialPositionBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingInitialPosition)
.OnEnter(TargetingInitialPositionTaskEnter)
.OnUpdate(TargetingInitialPositionTaskUpdate)
.OnExit(TargetingInitialPositionTaskExit);
_stateMachine.Add(BehaviourState.TargetingInitialPosition, targetingInitialPositionBehaviour);
_initialBehaviourPosition = new Vector2(Boss.InitialPosition.X, Boss.InitialPosition.Y + 500);
}
public XmasSnowmanBehaviour3(Boss boss) : base(boss)
{
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-snowman-behaviour3");
var targetingInitialPositionBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingInitialPosition)
.OnUpdate(TargetingInitialPositionTaskUpdate);
var carrotShotBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.CarrotShot)
.OnEnter(CarrotShotTaskEnter)
.OnUpdate(CarrotShotTaskUpdate);
_stateMachine.Add(BehaviourState.TargetingInitialPosition, targetingInitialPositionBehaviour);
_stateMachine.Add(BehaviourState.CarrotShot, carrotShotBehaviour);
}
public XmasLogBehaviour2(Boss boss) : base(boss)
{
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-log-behaviour2");
var targetingScreenCenterBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingScreenCenter)
.OnUpdate(TargetingScreenCenterTaskUpdate);
var shootingPatternBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.HelicopterPattern)
.OnEnter(HelicopterPatternTaskEnter)
.OnUpdate(HelicopterPatternTaskUpdate);
_stateMachine.Add(BehaviourState.TargetingScreenCenter, targetingScreenCenterBehaviour);
_stateMachine.Add(BehaviourState.HelicopterPattern, shootingPatternBehaviour);
}
public XmasSnowmanBehaviour4(Boss boss) : base(boss)
{
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-snowman-behaviour4");
var targetingInitialPositionBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingInitialPosition)
.OnUpdate(TargetingInitialPositionTaskUpdate);
var hatAttackBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.HatAttack)
.OnEnter(HatAttackTaskEnter)
.OnUpdate(HatAttackTaskUpdate);
_stateMachine.Add(BehaviourState.TargetingInitialPosition, targetingInitialPositionBehaviour);
_stateMachine.Add(BehaviourState.HatAttack, hatAttackBehaviour);
}
public XmasLogBehaviour3(Boss boss) : base(boss)
{
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-log-behaviour3");
var targetingInitialPositionBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingInitialPosition)
.OnUpdate(TargetingInitialPositionTaskUpdate);
var babyLogBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.BabyLogs)
.OnEnter(BabyLogTaskEnter)
.OnUpdate(BabyLogTaskUpdate);
_stateMachine.Add(BehaviourState.TargetingInitialPosition, targetingInitialPositionBehaviour);
_stateMachine.Add(BehaviourState.BabyLogs, babyLogBehaviour);
_babyLogs = new List <BabyLog>();
}
public void ExecuteDecisions(FSMBehaviour fsm)
{
if (outputPort.ConnectionCount <= 0)
{
return;
}
bool result = GetDecisionResult(fsm);
//Transition to other state
if (result == false && outputPort.ConnectionCount <= 0)
{
return;
}
NodeBase_State state = (NodeBase_State)outputPort.Connection.node;
state.SetCurrentState();
}
public void InitGraph(FSMBehaviour fsm)
{
currentState_elapsedTime = 0;
if (RootState == null)
{
XNode.Node node = nodes.FirstOrDefault(r => r is NodeBase_State);
if (node != null)
{
_rootState = (NodeBase_State)node;
_currentState = _rootState;
}
}
if (RootState != null)
{
_currentState = RootState;
}
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
fsmBehaviour = (FSMBehaviour)target;
if (onSyncVariables == false)
{
fsmBehaviour.SyncVariablesAndTargets();
onSyncVariables = true;
return;
}
Draw_CreateVariablePanel();
DrawDefaultErrorPanel();
DrawGrahErrorPanel();
}
public XmasLogBehaviour4(Boss boss) : base(boss)
{
// State machine
_stateMachine = new FSM <BehaviourState>("xmas-log-behaviour4");
var targetingInitialPositionBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.TargetingInitialPosition)
.OnUpdate(TargetingInitialPositionTaskUpdate);
var removingHollyBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.HollyAttack)
.OnEnter(RemovingHollyTaskEnter);
var hollyAttackBehaviour =
new FSMBehaviour <BehaviourState>(BehaviourState.HollyAttack)
.OnEnter(HollyAttackTaskEnter)
.OnUpdate(HollyAttackTaskUpdate);
_stateMachine.Add(BehaviourState.TargetingInitialPosition, targetingInitialPositionBehaviour);
_stateMachine.Add(BehaviourState.RemovingHolly, removingHollyBehaviour);
_stateMachine.Add(BehaviourState.HollyAttack, hollyAttackBehaviour);
}
public override void Execute(FSMBehaviour fsm)
{
NodePort inputPort = GetInputPort("inputAction");
if (inputPort.Connection == null)
{
return;
}
if (inputPort.Connection.node == null)
{
return;
}
float waitDelay = GetInputValue <float>("delay", this.delay);
if (Time.time > lastDelayTime + waitDelay)
{
NodeBase_Action inputActNode = (NodeBase_Action)inputPort.Connection.node;
inputActNode.Execute(fsm);
lastDelayTime = Time.time;
}
}
public void AddExitBehaviour(FSMBehaviour behaviour)
{
this.hasBehaviours = true;
this.exitBehaviours.Add(behaviour);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
/// <param name="stateID">Identificador del estado</param>
public State(FSMBehaviour character, StateID stateID)
{
Character = character;
ID = stateID;
}
public void AddStartBehaviour(FSMBehaviour behaviour)
{
this.hasBehaviours = true;
this.startBehaviours.Add(behaviour);
}
public void AddUpdateBehaviour(FSMBehaviour behaviour)
{
this.hasBehaviours = true;
this.updateBehaviours.Add(behaviour);
}
public abstract bool Execute(FSMBehaviour fsm);
public override bool Execute(FSMBehaviour fsm)
{
return(CheckDecision((NavMeshAgentFSM)fsm));
}
public abstract void Execute(FSMBehaviour fsm);
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
public HitState(FSMBehaviour character)
: base(character, StateID.Hit)
{
InmunityComponent = Character.GetComponentInChildren<Inmunity>();
Direction = Vector3.down;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
public JumpState(FSMBehaviour character)
: base(character, StateID.Jump)
{
Direction = Vector3.forward + Vector3.up;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
public StopState(FSMBehaviour character)
: base(character, StateID.Stop)
{
Direction = Vector3.zero;
TrackPosition = character.GetComponent<TrackLocation>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
/// <param name="side">Direccion de movimiento</param>
public MoveToSideState(FSMBehaviour character, StateID stateID)
: base(character, stateID)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
/// <param name="target">Objetivo a seguir</param>
public FollowState(FSMBehaviour character)
: base(character, StateID.Follow)
{
Movement = Character.GetComponentInChildren<MovementManager>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
public MoveRightState(FSMBehaviour character)
: base(character, StateID.Right)
{
Direction = Vector3.right + Vector3.forward;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
/// <param name="side">Direccion de movimiento</param>
public MoveLeftState(FSMBehaviour character)
: base(character, StateID.Left)
{
Direction = Vector3.left + Vector3.forward;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
/// <param name="stateID">Estado</param>
public MoveState(FSMBehaviour character, StateID stateID)
: base(character, stateID)
{
Movement = Character.GetComponentInChildren<MovementManager>();
}
/// <summary>
/// Inicializacion del componente
/// </summary>
private void Start()
{
// Obtengo los id de las capas
PlayerLayer = LayerMask.NameToLayer("Player");
ObstaclesLayer = LayerMask.NameToLayer("Obstacles");
// Busco componentes
FPS = GetComponent<FramesPerSecond>();
Track = GetComponent<PlayerTrack>();
MemoryStats = GetComponent<ShowMemoryStats>();
TargetFrameRate = LastFrameRate = -1;
// Solo inicializo si hay un game manager
//if (GameManager.Instance)
// Time = GameManager.Instance.GetComponent<TimeManager>();
// Solo inicializo estos si hay un Player asignado
if (Player)
{
InmunityComponent = Player.GetComponentInChildren<Inmunity>();
FSM = Player.GetComponentInChildren<PlayerManager>();
}
// Inicializo GUI
InmortalText = "Inmortal";
GUISettings();
// SETEAR EL FRAME RATE DE LA APLICACION
Application.targetFrameRate = 60;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="character">Personaje a controlar</param>
public ForwardState(FSMBehaviour character)
: base(character, StateID.Forward)
{
Direction = Vector3.forward;
}
