private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ServiceStatus.Initializing)
.Permit(ServiceStatus.Initializing, ServiceStatus.Started, ListenerStart)
.Permit(ServiceStatus.Started, ServiceStatus.Stopped, ListenerStop)
.Permit(ServiceStatus.Stopped, ServiceStatus.Started, ListenerStart);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(MonitorStatus.Initializing);
_stateMachine.Permit(MonitorStatus.Initializing, MonitorStatus.Started, StartMonitoring);
_stateMachine.Permit(MonitorStatus.Started, MonitorStatus.Stopped, StopMonitoring);
_stateMachine.Permit(MonitorStatus.Stopped, MonitorStatus.Started, StartMonitoring);
}
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ListenerStatus.Initializing)
.Permit(ListenerStatus.Initializing, ListenerStatus.Started, InputGatewayStart)
.Permit(ListenerStatus.Started, ListenerStatus.Stopped, InputGatewayStop)
.Permit(ListenerStatus.Stopped, ListenerStatus.Started, InputGatewayStart);
}
public void SignalAsync_GivenPassiveTransitionAndAutoAdvanceOn_TransitionsTraversedOnTaskThread()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
List <int> actuals = new List <int>();
TestBuilder.BuildOneWayPassiveMachine(harness.Machine);
TestBuilder.AddEffectToAll(uut, "Record Thread ID", c =>
{
actuals.Add(Thread.CurrentThread.ManagedThreadId);
});
uut.AutoAdvance = true;
uut.CompleteEdit();
var signalTask = uut.SignalAsync(new DataWaypoint(this, "Test method"));
bool signalResult = signalTask.Result;
Assert.IsTrue(signalResult, "Failed to signal the machine under test.");
Assert.AreNotEqual(0, actuals.Count, "No EFFECTS were executed.");
foreach (var threadId in actuals)
{
Assert.AreNotEqual(Thread.CurrentThread.ManagedThreadId, threadId, "A transition occurred on the main thread.");
}
//TODO: assert Task worker thread was used
}
public static void LiquidStateAwaitableSyncTest()
{
var config = StateMachineFactory.CreateAwaitableConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(async() => await AsyncConsoleWriteLine("OnEntry of Off"))
.OnExit(async() => await AsyncConsoleWriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, async() => { await AsyncConsoleWriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, async() => { await AsyncConsoleWriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(async() => await AsyncConsoleWriteLine("OnEntry of Ringing"))
.OnExit(async() => await AsyncConsoleWriteLine("OnExit of Ringing"))
.PermitDynamic(connectTriggerWithParameter,
async name =>
{
await Task.Yield();
return(DynamicState.Create(name == "Alice" ? State.Connected : State.Off));
},
async(trigger, name) =>
{
if (trigger.Destination == State.Connected)
{
await AsyncConsoleWriteLine("Attempting to connect to " + name);
}
else
{
await AsyncConsoleWriteLine("Hanging up on " + name);
}
})
.Permit(Trigger.Talk, State.Talking, async() => { await AsyncConsoleWriteLine("Attempting to talk"); });
config.ForState(State.Connected)
.OnEntry(async() => await AsyncConsoleWriteLine("AOnEntry of Connected"))
.OnExit(async() => await AsyncConsoleWriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, async() => { await AsyncConsoleWriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, async() => { await AsyncConsoleWriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(async() => await AsyncConsoleWriteLine("OnEntry of Talking"))
.OnExit(async() => await AsyncConsoleWriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, async() => { await AsyncConsoleWriteLine("Turning off"); })
.PermitDynamic(Trigger.Ring, () => DynamicState.Create(State.Ringing),
async() => { await AsyncConsoleWriteLine("Attempting to ring"); });
var machine = StateMachineFactory.Create(State.Ringing, config, queued: false);
machine.FireAsync(Trigger.Talk).Wait();
machine.FireAsync(Trigger.Ring).Wait();
machine.FireAsync(connectTriggerWithParameter, "Alice").Wait();
machine.FireAsync(Trigger.TurnOff).Wait();
machine.FireAsync(Trigger.Ring).Wait();
machine.FireAsync(connectTriggerWithParameter, "Bob").Wait();
}
public void Create_TriggersDoNotHaveThread_AndBehaviorsDoNotHaveThread_AndHasSynchronizer()
{
var uut = StateMachineFactory.Create <DummyState>("Demo StateMachine", _logger);
Assert.IsFalse(uut.HasBehaviorScheduler);
Assert.IsFalse(uut.HasTriggerScheduler);
Assert.IsNotNull(uut._synchronizer);
}
public GameClient(StartArguments arguments)
{
Arguments = arguments;
var context = new Context(this);
StateMachine = StateMachineFactory.Create(context);
GameTime = new GameTime();
}
public void ChangeState_GivenPartialSync_WhereBehaviorIsNotAsync_DoBehaviorIsNotAsync()
{
var uut = StateMachineFactory.Create <DummyState>("Demo StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayMachineWithTriggers(harness.Machine, harness);
Assert.IsFalse(harness.WaitUntilAsyncDoBehavior(TimeSpan.FromSeconds(1)), "DO behavior executed asynchronously.");
}
public void Create_TriggersDoNotHaveThread_AndBehaviorsDoNotHaveThread_AndHasSharedSynchronizer()
{
object sync = new object();
var uut = StateMachineFactory.Create <DummyState>("Demo StateMachine", _logger, sync);
Assert.IsFalse(uut.HasBehaviorScheduler);
Assert.IsFalse(uut.HasTriggerScheduler);
Assert.AreEqual(uut._synchronizer, sync);
}
public void ChangeState_GivenPartialSync_WhereBehaviorIsNotAsync_TransitionIsNotAsync()
{
var uut = StateMachineFactory.Create <DummyState>("Demo StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayMachineWithTriggers(harness.Machine, harness);
// The transition should be blocked from completing its work because the transition happens on the current thread.
Assert.IsFalse(harness.WaitUntilAsyncTransitionSuccess(TimeSpan.FromSeconds(1)), "Transition executed asynchronously.");
}
public static void LiquidStateSyncTest()
{
var config = StateMachineFactory.CreateConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(() => Console.WriteLine("OnEntry of Off"))
.OnExit(() => Console.WriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, () => { Console.WriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, () => { Console.WriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(() => Console.WriteLine("OnEntry of Ringing"))
.OnExit(() => Console.WriteLine("OnExit of Ringing"))
.PermitDynamic(connectTriggerWithParameter,
name => DynamicState.Create(name == "Alice" ? State.Connected : State.Off),
(trigger, name) =>
{
if (trigger.Destination == State.Connected)
{
Console.WriteLine("Attempting to connect to " + name);
}
else
{
Console.WriteLine("Hanging up on " + name);
}
})
.Permit(Trigger.Talk, State.Talking, () => { Console.WriteLine("Attempting to talk"); });
config.ForState(State.Connected)
.OnEntry(() => Console.WriteLine("AOnEntry of Connected"))
.OnExit(() => Console.WriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, () => { Console.WriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, () => { Console.WriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(() => Console.WriteLine("OnEntry of Talking"))
.OnExit(() => Console.WriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, () => { Console.WriteLine("Turning off"); })
.PermitDynamic(Trigger.Ring, () => DynamicState.Create(State.Ringing),
() => { Console.WriteLine("Attempting to ring"); });
var machine = StateMachineFactory.Create(State.Ringing, config);
machine.Fire(Trigger.Talk);
machine.Fire(Trigger.Ring);
machine.Fire(connectTriggerWithParameter, "Alice");
machine.Fire(Trigger.TurnOff);
machine.Fire(Trigger.Ring);
machine.Fire(connectTriggerWithParameter, "Bob");
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(MonitorStatus.Initializing);
_stateMachine.Permit(MonitorStatus.Initializing, MonitorStatus.Started, OnStartSampler)
.Permit(MonitorStatus.Started, MonitorStatus.Stopped, e =>
{
_cancellationTokenSource.Cancel();
InvokeOnStop();
})
.Permit(MonitorStatus.Stopped, MonitorStatus.Started, OnStartSampler);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ProcessorStatus.Initializing)
.Permit(ProcessorStatus.Initializing, ProcessorStatus.Configured,
OnConfiguredControl)
.Permit(ProcessorStatus.Configured, ProcessorStatus.Started,
OnStartControl)
.Permit(ProcessorStatus.Started, ProcessorStatus.Stopped, OnStopControl)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Started, OnStartControl)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Configured);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_endPointStateMachine = StateMachineFactory.Create(EndPointStatus.Initializing)
.Permit(EndPointStatus.Initializing, EndPointStatus.Receiving, t =>
{
InitializeEndPoint();
ReceivingStart();
})
.Permit(EndPointStatus.Receiving, EndPointStatus.Stopped, OnReceivingStop)
.Permit(EndPointStatus.Stopped, EndPointStatus.Receiving, t => ReceivingStart());
}
public void TryTransition_GivenPassiveTransitionAndAutoAdvanceOff_WhenInitialStateOne_TransitionsToStateTwo()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayPassiveMachine(harness.Machine);
uut.AutoAdvance = false;
uut.CompleteEdit();
uut.TryTransition(this);
Assert.AreEqual(DummyState.Two, uut.CurrentState);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ProcessorStatus.Initializing)
.Permit(ProcessorStatus.Initializing, ProcessorStatus.Configured)
.Permit(ProcessorStatus.Configured, ProcessorStatus.Started,
t => _inputGateway.Start())
.Permit(ProcessorStatus.Started, ProcessorStatus.Stopped,
t => _inputGateway.Stop())
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Started,
t => _inputGateway.Start())
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Configured);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
StateMachine = StateMachineFactory.Create(ProcessorStatus.Initializing)
.Permit(ProcessorStatus.Initializing, ProcessorStatus.Configured,
OnConfigured)
.Permit(ProcessorStatus.Configured, ProcessorStatus.Started,
InputGatewayStart)
.Permit(ProcessorStatus.Started, ProcessorStatus.Stopped, InputGatewayStop)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Started,
InputGatewayStart)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Configured);
}
public void Signal_GivenTriggeredTransition_TransitionNotTraversed()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayMachineWithTriggers(harness.Machine, harness);
uut.CompleteEdit();
Assert.AreEqual(DummyState.One, uut.CurrentState);
bool signalResult = uut.Signal(new DataWaypoint(this, "Test method"));
Assert.IsFalse(signalResult, "A transition was traversed but should not have been.");
Assert.AreEqual(DummyState.One, uut.CurrentState);
}
public void Signal_GivenPassiveTransitionAndAutoAdvanceOn_MultipleTransitionTraversed()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayPassiveMachine(harness.Machine);
uut.AutoAdvance = true;
uut.CompleteEdit();
Assert.AreEqual(DummyState.One, uut.CurrentState);
bool signalResult = uut.Signal(new DataWaypoint(this, "Test method"));
Assert.IsTrue(signalResult, "Failed to signal the machine under test.");
Assert.AreEqual(DummyState.Three, uut.CurrentState);
}
private static async Task AsyncMachineExample()
{
// Note the "CreateAsyncConfiguration"
var config = StateMachineFactory.CreateAwaitableConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(async() => Console.WriteLine("OnEntry of Off"))
.OnExit(async() => Console.WriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, async() => { Console.WriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, async() => { Console.WriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(() => Console.WriteLine("OnEntry of Ringing"))
.OnExit(() => Console.WriteLine("OnExit of Ringing"))
.Permit(connectTriggerWithParameter, State.Connected,
name => { Console.WriteLine("Attempting to connect to {0}", name); })
.Permit(Trigger.Talk, State.Talking, () => { Console.WriteLine("Attempting to talk"); });
config.ForState(State.Connected)
.OnEntry(async() => Console.WriteLine("AOnEntry of Connected"))
.OnExit(async() => Console.WriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(() => Console.WriteLine("OnEntry of Talking"))
.OnExit(() => Console.WriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, () => { Console.WriteLine("Turning off"); })
.Permit(Trigger.Ring, State.Ringing, () => { Console.WriteLine("Attempting to ring"); });
var machine = StateMachineFactory.Create(State.Ringing, config);
await machine.FireAsync(Trigger.Talk);
await machine.FireAsync(Trigger.Ring);
await machine.FireAsync(connectTriggerWithParameter, "John Doe");
}
public static void LiquidStateAwaitableSyncTest()
{
var config = StateMachineFactory.CreateAwaitableConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(async() => Console.WriteLine("OnEntry of Off"))
.OnExit(async() => Console.WriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, async() => { Console.WriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, async() => { Console.WriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(async() => Console.WriteLine("OnEntry of Ringing"))
.OnExit(async() => Console.WriteLine("OnExit of Ringing"))
.Permit(connectTriggerWithParameter, State.Connected,
async name => { Console.WriteLine("Attempting to connect to " + name); })
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); });
config.ForState(State.Connected)
.OnEntry(async() => Console.WriteLine("AOnEntry of Connected"))
.OnExit(async() => Console.WriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(async() => Console.WriteLine("OnEntry of Talking"))
.OnExit(async() => Console.WriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); })
.PermitDynamic(Trigger.Ring, () => DynamicState.Create(State.Ringing),
async() => { Console.WriteLine("Attempting to ring"); });
var machine = StateMachineFactory.Create(State.Ringing, config, queued: false);
machine.FireAsync(Trigger.Talk).Wait();
machine.FireAsync(Trigger.Ring).Wait();
machine.FireAsync(Trigger.Talk).Wait();
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ServiceStatus.Initializing)
.Permit(ServiceStatus.Initializing, ServiceStatus.StandBy, StartControl)
.Permit(ServiceStatus.StandBy, ServiceStatus.Started, StartProcessor)
.Permit(ServiceStatus.StandBy, ServiceStatus.Stopped, StopControl)
.Permit(ServiceStatus.Started, ServiceStatus.StandBy, StopProcessor)
.Permit(ServiceStatus.Started, ServiceStatus.Stopped, StopAll)
.Permit(ServiceStatus.Stopped, ServiceStatus.StandBy, StartControl);
_controller.OnStart += (sender, args) =>
{
//El processor es un bus no un servicio, los servicios arrancan cuando el controller acaba de configurarlos
if (_processor is ISubscriber)
{
if (_stateMachine.CanChangeState(ServiceStatus.Started))
{
_stateMachine.ChangeState(ServiceStatus.Started);
}
}
};
_processor.OnStart += (sender, args) =>
{
if (_stateMachine.CanChangeState(ServiceStatus.Started))
{
_stateMachine.ChangeState(ServiceStatus.Started);
}
};
_processor.OnStop += (sender, args) =>
{
if (_stateMachine.CanChangeState(ServiceStatus.StandBy))
{
_stateMachine.ChangeState(ServiceStatus.StandBy);
}
};
}
private void Construct(StateMachineFactory fsm)
{
StateMachine = fsm.Create();
OnInitialize();
}
public GameStatesManager(StateMachineFactory sfm)
{
_fsm = sfm.Create();
InitializeStates();
}
public static async Task LiquidStateAsyncTest()
{
var config = StateMachineFactory.CreateAwaitableConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(async() => Console.WriteLine("OnEntry of Off"))
.OnExit(async() => Console.WriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, async() => { Console.WriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, async() => { Console.WriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(async() => Console.WriteLine("OnEntry of Ringing"))
.OnExit(async() => Console.WriteLine("OnExit of Ringing"))
.Permit(connectTriggerWithParameter, State.Connected,
async name => { Console.WriteLine("Attempting to connect to " + name); })
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); })
.PermitReentry(Trigger.Ring);
config.ForState(State.Connected)
.OnEntry(async() => Console.WriteLine("AOnEntry of Connected"))
.OnExit(async() => Console.WriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(async() => Console.WriteLine("OnEntry of Talking"))
.OnExit(async() => Console.WriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); })
.Permit(Trigger.Ring, State.Ringing, async() => { Console.WriteLine("Attempting to ring"); })
.PermitReentry(Trigger.Talk);
var machine = StateMachineFactory.Create(State.Ringing, config, queued: true);
var sw = Stopwatch.StartNew();
var i = 0;
for (i = 0; i < 1; i++)
{
try
{
var t1 = Task.Run(async() =>
{
await machine.FireAsync(Trigger.Talk);
await machine.FireAsync(Trigger.Ring);
});
var t2 = Task.Run(async() =>
{
var i1 = machine.FireAsync(Trigger.Talk);
var i2 = machine.FireAsync(Trigger.Ring);
await Task.WhenAll(i1, i2);
});
var t3 = Task.Run(async() =>
{
var i1 = machine.FireAsync(Trigger.Talk);
var i2 = machine.FireAsync(Trigger.Ring);
await Task.WhenAll(i1, i2);
});
await Task.WhenAll(t1, t2, t3);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
void Configure()
{
var config = StateMachineFactory.CreateConfiguration <BlackKnightState, BlackKnightTrigger>();
config.ForState(BlackKnightState.Idle).Permit(BlackKnightTrigger.Patrol, BlackKnightState.Patroling);
config.ForState(BlackKnightState.Patroling).OnEntry(() =>
{
Debug.Log("patrolling");
playerTansform = null;
StartFind();
StartPatrol();
})
.OnExit(() =>
{
StopFind();
StopPatrol();
})
.Permit(BlackKnightTrigger.Found, BlackKnightState.Following);
config.ForState(BlackKnightState.Following).OnEntry(() =>
{
StartFollow();
})
.OnExit(() =>
{
StopFollow();
})
.Permit(BlackKnightTrigger.FollowFail, BlackKnightState.Patroling)
.Permit(BlackKnightTrigger.Touch, BlackKnightState.Attcking)
.Permit(BlackKnightTrigger.Confrontation, BlackKnightState.Confrontation);
config.ForState(BlackKnightState.Attcking).OnEntry(() =>
{
StartAutoAttack();
//Attack();
}).OnExit(() =>
{
StopAutoAttack();
//UnAttack();
})
.PermitIf(() => playerTansform != null, BlackKnightTrigger.UnTouch, BlackKnightState.Confrontation)
//.Permit(BlackKnightTrigger.UnTouch, BlackKnightState.Patroling)
;
fsm = StateMachineFactory.Create(BlackKnightState.Idle, config);
config.ForState(BlackKnightState.Confrontation)
.OnEntry(() =>
{
ac.lockController.Lock(playerTansform.gameObject);
//ac.camCtrl.Lock(playerTansform.gameObject);
StartConfrontatoin();
})
.OnExit(() =>
{
if (ac.lockController.lockState == true && playerTansform == null)
{
ac.lockController.UnLock();
}
//if (ac.camCtrl.lockState == true && playerTansform == null)
//{
// ac.camCtrl.UnLock();
//}
StopConfrontatation();
})
.Permit(BlackKnightTrigger.Touch, BlackKnightState.Attcking)
.Permit(BlackKnightTrigger.Go, BlackKnightState.Following);
}
private void InitializeStateMachine()
{
_stateMachine = StateMachineFactory.Create(ReinjectionStatus.Stopped);
_stateMachine.Permit(ReinjectionStatus.Stopped, ReinjectionStatus.Started, ars => InvokeOnStart());
_stateMachine.Permit(ReinjectionStatus.Started, ReinjectionStatus.Stopped, ars => InvokeOnStop());
}