public void OnUpdate(FSMContext context)
{
if (playOrder != null && playOrder.bFinish)
{
SetReady(true);
}
}
public void OnLeave(FSMContext context)
{
BattleProcedure.CurSession.OrderController.StopInputJob();
SetReady(false);
playOrder = null;
BattleProcedure.CurSession.CleanPlayCardTable();
}
public void OnUpdate(FSMContext context)
{
if (BattleProcedure.CurSession.Performer.Finished)
{
context.FSM.SwitchToState((int)SessionState.IdleState);
}
}
public State Read(string xml, FSMContext context = null)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
return(Read(doc.DocumentElement, context));
}
public State Read(XmlNode node, FSMContext context = null)
{
State result;
lock (lockThisObj)
{
nsmgr = new XmlNamespaceManager(node.OwnerDocument.NameTable);
nsmgr.AddNamespace("s", FSMNamespace);
nodes = new Stack <XmlNode>();
if (context == null)
{
this.context = new FSMContext();
}
else
{
this.context = new FSMContext(context);
}
ReadStartNode(node);
result = ReadState();
ReadEndNode();
this.context = null;
this.nodes = null;
this.nsmgr = null;
}
return(result);
}
public void OnLeave(FSMContext context)
{
var pos = CameraManager.Instance.CameraCarrier.transform.position;
CameraManager.Instance.SetCameraRotation(new Vector3(50, 0, 0), true);
CameraManager.Instance.SetCameraFocusPosition(new Vector2(pos.x, pos.z), true);
}
public override void Execute(FSMContext context, GameObject obj) {
obj.GetComponent<Shoot>().IdleOn();
if (Input.GetMouseButtonDown(0))
{
obj.GetComponent<FiniteStateMachine>().Dispatch("Trigger Pulled", obj);
}
}
public void OnEnter(FSMContext context)
{
GestureManager.Instance.ClickAction += OnClick;
if (BattleProcedure.CurSession.CurPlayReq != null)
{
context.FSM.SwitchToState((int)SessionState.PlayCardState);
}
}
public object ReadExpr(FSMContext context, XmlNode exprNode, bool isBlock)
{
CompileContext ctx = new CompileContext(new FSMExpressionContextAdapter(context));
var expr = exprReader.Read(exprNode, isBlock, ctx);
return(expr);
}
public void Dispatch(FSMContext context, string eventName, GameObject obj) {
if( transitions.ContainsKey(eventName)) {
Transition t = (transitions[eventName] as Transition);
context.currentState.exitAction.Execute(context, obj);
t.execute(context, obj);
context.currentState = t.getTarget();
context.currentState.entryAction.Execute(context, obj);
}
}
public static FSMachine GetFSM()
{
FSMContext context = new FSMContext();
context.ExpressionProvider = new FSMExpressionProvider();
FSMachine fsm = new FSMachine(context);
return(fsm);
}
public override void execute(FSMContext c)
{
if (!this.owner.isGrounded)
{
this.owner.SetHeightLevel(player.HeightLevel);
}
this.owner.SetHeading((player.transform.position - this.owner.transform.position).normalized);
}
public override void Execute(FSMContext context, GameObject obj) {
obj.GetComponent<Shoot>().ShootingOn();
if(Input.GetMouseButtonUp(0)) {
obj.GetComponent<FiniteStateMachine>().Dispatch("Trigger Released", obj);
}
if(obj.GetComponent<Shoot>().ammo == 0) {
obj.GetComponent<FiniteStateMachine>().Dispatch("Empty Clip", obj);
}
}
public void OnEnter(FSMContext context)
{
_fsm = context.FSM;
SetReady(false);
paramList = BattleProcedure.CurSession.CurPlayReq.Cast <List <LuaTable> >();
playOrder = BattleProcedure.CurSession.OrderController.TakeInputJob(paramList);
EventManager.Instance.On(EventConst.ON_QUIT_PALYCARD, OnQuitPlayCard);
}
public void OnEnter(FSMContext context)
{
_camera = context.GetVariable("Camera") as Camera;
_carrier = context.GetVariable("Carrier") as GameObject;
var avatar = BattleProcedure.CurSession.Field.FindUnit(BattleProcedure.CurSession.CurSelectUid);
var curPos = CameraManager.Instance.CameraCarrier.transform.position;
CameraManager.Instance.SetCameraRotation(new Vector3(90, 0, 0), true);
CameraManager.Instance.SetCameraFocusPosition(new Vector2(avatar.transform.position.x, avatar.transform.position.y), true);
}
void Start () {
idle = new State(new Action_NoAction(), new Action_ReadyToShoot(), new Action_StartShooting(), "Idle");
firing = new State(new Action_NoAction(), new Action_Shooting(), new Action_StopShooting(), "Firing");
outOfAmmo = new State(new Action_NoAction(), new Action_EmptyClip(), new Action_ReloadTime(), "Out Of Ammo");
reload = new State(new Action_NoAction(), new Action_Reloading(), new Action_FullClip(), "Reload");
idle.AddTransition(new Transition(firing, new Action_NoAction()), "Trigger Pulled");
firing.AddTransition(new Transition(idle, new Action_NoAction()), "Trigger Released");
firing.AddTransition(new Transition(outOfAmmo, new Action_NoAction()), "Empty Clip");
outOfAmmo.AddTransition(new Transition(reload, new Action_NoAction()), "Reloading");
reload.AddTransition(new Transition(idle, new Action_NoAction()), "Reloaded");
stateMachine = ApplyStateMachine.createFSMInstance(idle, new Action_NoAction(), this.gameObject, name);
}
public override void execute(FSMContext c)
{
if (this.curCd > this.targetCd * 10)
{
this.curCd = 0;
owner.Ability.Use(Vector3.zero);
}
this.curCd += Time.deltaTime;
if (!this.owner.isGrounded)
{
this.owner.SetHeightLevel(GameManager.instance.InGameController.Airship.HeightLevel);
}
this.owner.SetHeading((GameManager.instance.InGameController.Airship.transform.position - this.owner.transform.position).normalized);
}
public override void execute(FSMContext c)
{
if (this.curPatrolPoint >= this.patrolPoints.Length)
{
this.curPatrolPoint = 0;
}
Transform targetPatrolPoint = this.patrolPoints [this.curPatrolPoint];
if ((targetPatrolPoint.position - this.owner.transform.position).magnitude > 1.0f)
{
this.owner.SetHeightLevel(GameEnum.HeightLevel.LOWER);
this.owner.SetHeading((targetPatrolPoint.position - this.owner.transform.position).normalized);
}
else
{
this.curPatrolPoint++;
}
}
public override void execute(FSMContext c)
{
if (this.curHeading >= this.directions.Length)
{
this.curHeading = 0;
}
Transform targetHeading = this.directions [this.curHeading];
if (this.timer < this.turnDuration)
{
this.owner.SetHeading((targetHeading.position - this.owner.transform.position).normalized);
this.timer += Time.deltaTime;
}
else
{
this.curHeading++;
this.timer = 0.0f;
}
}
public object EvalExpression(FSMContext context, object expr)
{
var ctx = new FSMExpressionContextAdapter(context);
InvocationDelegate eval = null;
if (expr is string)
{
// eval = GetOrCacheExprEval(ctx, expr as string);
}
else
{
eval = GetOrCacheExprEval(ctx, expr as Expression);
}
if (eval == null)
{
return(null);
}
object result = eval(ctx);
return(result);
}
public void FSM_Events_Lead_To_Valid_Transitions()
{
string active = "active";
string inactive = "inactive";
string idle = "idle";
var fsmBuilder = new FSMBuilder <FSMContext>();
fsmBuilder
.AddState(active, c => c.State = active)
.AddState(inactive, c => c.State = inactive)
.AddState(idle, c => c.State = idle);
var turnOffEvent = fsmBuilder.From(active).To(inactive);
var turnOnEvent = fsmBuilder.From(inactive).To(active);
var goIdleEvent = fsmBuilder.From(active).To(idle);
var fsm = fsmBuilder.Build(active);
var context = new FSMContext();
fsm.Update(context);
Assert.AreEqual(active, context.State);
turnOffEvent.Raise();
fsm.Update(context);
Assert.AreEqual(inactive, context.State);
goIdleEvent.Raise();
fsm.Update(context);
Assert.AreEqual(inactive, context.State);
turnOnEvent.Raise();
fsm.Update(context);
Assert.AreEqual(active, context.State);
goIdleEvent.Raise();
fsm.Update(context);
Assert.AreEqual(idle, context.State);
}
public override void Execute (FSMContext context, GameObject obj) {
}
public void PopScope()
{
this.context = context.Parent;
}
public void PushScope()
{
this.context = new FSMContext(context);
}
public abstract void Execute(FSMContext context, GameObject obj);
public override void Execute(FSMContext context, GameObject obj)
{
obj.GetComponent<Shoot>().ShootingOff();
}
public void execute(FSMContext context, GameObject obj) {
action.Execute(context, obj);
}
public void OnEnter(FSMContext context)
{
}
public void OnUpdate(FSMContext context)
{
}
public void OnLeave(FSMContext context)
{
GestureManager.Instance.ClickAction -= OnClick;
}
public FSM()
{
_stateMap = new Dictionary<int, IFSMState>();
_triggers = new List<string>();
_context = new FSMContext(this);
}
public override void Execute(FSMContext context, GameObject obj) {
obj.GetComponent<Shoot>().EmptyOn();
if (Input.GetKeyDown("r")) {
obj.GetComponent<FiniteStateMachine>().Dispatch("Reloading", obj);
}
}
public void OnEnter(FSMContext context)
{
_performRoot = context.GetVariable("PerformRoot") as LuaTable;
BattleProcedure.CurSession.Performer.Perform(_performRoot);
}
public override void execute(FSMContext c)
{
this.owner.SetSpeed(0.0f);
}
public void OnLeave(FSMContext context)
{
}
public void UpdateState(FSMContext context, GameObject obj) {
updateAction.Execute(context, obj);
}
public override void execute(FSMContext c)
{
this.owner.SetHeading((target - this.owner.transform.position).normalized);
}
public object ReadExpr(FSMContext context, string expr, bool isBlock)
{
CompileContext ctx = new CompileContext(new FSMExpressionContextAdapter(context));
return(LWJ.Expressions.Script.ScriptExpressionReader.Instance.Parse(expr, ctx));
}
void Start()
{
//vehicle
CharacterController controller = GetComponent<CharacterController>();
vehicle = new Vehicle(mass, maxSpeed, maxForce, controller.transform.position);
timer = 0.0f;
attributes = new Dictionary<string, int>();
idle = new State(new Action_IdleEnter(), new Action_Idle(), new Action_IdleExit(), "idle");
seek = new State(new Action_SeekEnter(), new Action_Seek(), new Action_SeekExit(), "seek");
flee = new State(new Action_FleeEnter(), new Action_Flee(), new Action_FleeExit(), "flee");
pursuit = new State(new Action_PursuitEnter(), new Action_Pursuit(), new Action_PursuitExit(), "pursuit");
evade = new State(new Action_EvadeEnter(), new Action_Evade(), new Action_EvadeExit(), "evade");
wander = new State(new Action_WanderEnter(), new Action_Wander(), new Action_WanderExit(), "wander");
patrol = new State(new Action_PatrolEnter(), new Action_Patrol(), new Action_PatrolExit(), "patrol");
seekEnter = new Transition(seek, new Action_None());
idleEnter = new Transition(idle, new Action_None());
fleeEnter = new Transition(flee, new Action_None());
pursuitEnter = new Transition(pursuit, new Action_None());
evadeEnter = new Transition(evade, new Action_None());
wanderEnter = new Transition(wander, new Action_None());
patrolEnter = new Transition(patrol, new Action_None());
idle.addTransition(seekEnter, "seekEnter");
idle.addTransition(fleeEnter, "fleeEnter");
idle.addTransition(pursuitEnter, "pursuitEnter");
idle.addTransition(evadeEnter, "evadeEnter");
idle.addTransition(wanderEnter, "wanderEnter");
idle.addTransition(patrolEnter, "patrolEnter");
seek.addTransition(idleEnter, "idleEnter");
seek.addTransition(fleeEnter, "fleeEnter");
seek.addTransition(pursuitEnter, "pursuitEnter");
seek.addTransition(evadeEnter, "evadeEnter");
seek.addTransition(wanderEnter, "wanderEnter");
seek.addTransition(patrolEnter, "patrolEnter");
flee.addTransition(idleEnter, "idleEnter");
flee.addTransition(seekEnter, "seekEnter");
flee.addTransition(pursuitEnter, "pursuitEnter");
flee.addTransition(evadeEnter, "evadeEnter");
flee.addTransition(wanderEnter, "wanderEnter");
flee.addTransition(patrolEnter, "patrolEnter");
pursuit.addTransition(idleEnter, "idleEnter");
pursuit.addTransition(seekEnter, "seekEnter");
pursuit.addTransition(fleeEnter, "fleeEnter");
pursuit.addTransition(evadeEnter, "evadeEnter");
pursuit.addTransition(wanderEnter, "wanderEnter");
patrol.addTransition(patrolEnter, "patrolEnter");
evade.addTransition(idleEnter, "idleEnter");
evade.addTransition(seekEnter, "seekEnter");
evade.addTransition(fleeEnter, "fleeEnter");
evade.addTransition(pursuitEnter, "pursuitEnter");
evade.addTransition(wanderEnter, "wanderEnter");
evade.addTransition(patrolEnter, "patrolEnter");
wander.addTransition(idleEnter, "idleEnter");
wander.addTransition(seekEnter, "seekEnter");
wander.addTransition(fleeEnter, "fleeEnter");
wander.addTransition(pursuitEnter, "pursuitEnter");
wander.addTransition(evadeEnter, "evadeEnter");
wander.addTransition(patrolEnter, "patrolEnter");
patrol.addTransition(idleEnter, "idleEnter");
patrol.addTransition(seekEnter, "seekEnter");
patrol.addTransition(fleeEnter, "fleeEnter");
patrol.addTransition(pursuitEnter, "pursuitEnter");
patrol.addTransition(evadeEnter, "evadeEnter");
patrol.addTransition(wanderEnter, "wanderEnter");
// set the player controller for use by the state machine
fsmc = FSM.FSM.createFSMInstance(idle, new Idle(), attributes, "hunter");
fsmc.setController(GetComponent<CharacterController>());
vehicle.setController(GetComponent<CharacterController());
}
public override void execute(FSMContext c)
{
}
public override void Execute(FSMContext context, GameObject obj) {
obj.GetComponent<Shoot>().ReloadingOn();
if(obj.GetComponent<Shoot>().ammo == 200) {
obj.GetComponent<FiniteStateMachine>().Dispatch("Reloaded", obj);
}
}
