private void InitializeFSM()
{
// Create Minion FSM.
fsm = new FSM <States>();
IdleState <States> idleState = new IdleState <States>(fsm, this);
SearchState <States> searchState = new SearchState <States>(fsm, this);
FlockState <States> flockState = new FlockState <States>(fsm, this, _flockingEntity);
PursuitState <States> pursuitState = new PursuitState <States>(fsm, this);
FleeState <States> fleeState = new FleeState <States>(fsm, this);
// [EVERYONE] Idle Transitions.
idleState.AddTransition(States.FLOCKING, flockState);
idleState.AddTransition(States.SEARCHING, searchState);
idleState.AddTransition(States.PURSUIT, pursuitState);
pursuitState.AddTransition(States.FLEE, fleeState);
pursuitState.AddTransition(States.FLOCKING, flockState);
pursuitState.AddTransition(States.IDLE, idleState);
fleeState.AddTransition(States.IDLE, idleState);
fleeState.AddTransition(States.PURSUIT, pursuitState);
// [BOSS] Search Transitions.
searchState.AddTransition(States.IDLE, idleState);
searchState.AddTransition(States.PURSUIT, pursuitState);
// [MINIONS] Flocking Transitions.
flockState.AddTransition(States.IDLE, idleState);
flockState.AddTransition(States.PURSUIT, pursuitState);
fsm.SetInitState(idleState);
}
private void MakeFSM()
{
IdleState idle = new IdleState();
idle.AddTransition(Transition.Walk, StateID.Walk);
idle.AddTransition(Transition.Jump, StateID.Jump);
idle.AddTransition(Transition.Die, StateID.Die);
WalkState walk = new WalkState(path);
walk.AddTransition(Transition.Idle, StateID.Idle);
walk.AddTransition(Transition.Jump, StateID.Jump);
walk.AddTransition(Transition.Die, StateID.Die);
JumpState jump = new JumpState();
jump.AddTransition(Transition.Idle, StateID.Idle);
jump.AddTransition(Transition.Die, StateID.Die);
DeadState die = new DeadState();
fsm = new FSMSystem();
fsm.AddState(idle);
fsm.AddState(walk);
fsm.AddState(jump);
fsm.AddState(die);
}
void Start()
{
player_anim = GetComponentInChildren <PlayerAnimation>();
_rb = GetComponent <Rigidbody>();
_player = GetComponent <Player>();
_fsm = new FSM <string>();
_healthUI = gameObject.GetComponentInChildren <HealthUI>();
IdleState <string> idle = new IdleState <string>(_fsm, player_anim, "Move", "Punch Attack", "Kick Attack");
MoveState <string> move = new MoveState <string>(_player, _fsm, player_anim, "Attack", "Idle");
//JumpState<string> jump = new JumpState<string>(_fsm, "Idle", _rb, _player);
PunchAttackState <string> punchAttack = new PunchAttackState <string>(_fsm, player_anim, "Idle", "Kick Attack");
KickAttackState <string> kickAttack = new KickAttackState <string>(_fsm, player_anim, "Idle", "Punch Attack");
idle.AddTransition("Move", move);
idle.AddTransition("Punch Attack", punchAttack);
idle.AddTransition("Kick Attack", kickAttack);
move.AddTransition("Idle", idle);
move.AddTransition("Punch Attack", punchAttack);
move.AddTransition("Kick Attack", kickAttack);
//jump.AddTransition("Idle", idle);
punchAttack.AddTransition("Idle", idle);
punchAttack.AddTransition("Kick Attack", kickAttack);
kickAttack.AddTransition("Idle", idle);
kickAttack.AddTransition("Punch Attack", punchAttack);
_fsm.SetInit(idle);
}
public void MakeFSM()
{
IdleState idle = new IdleState();
idle.AddTransition(Transition.SawPlayer, StateID.AttackingState);
idle.AddTransition(Transition.LostPlayer, StateID.MovingState);
MoveState move = new MoveState();
move.AddTransition(Transition.SawPlayer, StateID.AttackingState);
AttackState attack = new AttackState();
attack.AddTransition(Transition.LostPlayer, StateID.MovingState);
attack.AddTransition(Transition.IdleTransition, StateID.IdleStateID);
DefendState defend = new DefendState();
EvadeState evade = new EvadeState();
WinState win = new WinState();
DeathState death = new DeathState();
fsm = new FSMSystem();
fsm.AddState(move);
fsm.AddState(attack);
fsm.AddState(idle);
fsm.AddState(defend);
fsm.AddState(evade);
fsm.AddState(win);
fsm.AddState(death);
}
public override void StartFSM()
{
_idleState = new IdleState <states>(this, flags, _treeStartPoint);
_followState = new FollowState <states>(this, myLeader, flags, _treeStartPoint, stopDist);
_attackState = new AttackState <states>(this, flags, _treeStartPoint);
_escapeState = new EscapeState <states>(this, flags, _treeStartPoint);
_reloadState = new ReloadState <states>(this, flags, _treeStartPoint);
fsm = new FSM <states>(_idleState);
_idleState.AddTransition(states.Follow, _followState);
_idleState.AddTransition(states.Attack, _attackState);
_idleState.AddTransition(states.Escape, _escapeState);
_idleState.AddTransition(states.Reload, _reloadState);
_followState.AddTransition(states.Idle, _idleState);
_followState.AddTransition(states.Attack, _attackState);
_followState.AddTransition(states.Escape, _escapeState);
_followState.AddTransition(states.Reload, _reloadState);
_attackState.AddTransition(states.Idle, _idleState);
_attackState.AddTransition(states.Follow, _followState);
_attackState.AddTransition(states.Escape, _escapeState);
_attackState.AddTransition(states.Reload, _reloadState);
_reloadState.AddTransition(states.Idle, _idleState);
_reloadState.AddTransition(states.Attack, _attackState);
_reloadState.AddTransition(states.Follow, _followState);
_reloadState.AddTransition(states.Escape, _escapeState);
_escapeState.AddTransition(states.Idle, _idleState);
_escapeState.AddTransition(states.Follow, _followState);
fsm.SetState(_idleState);
}
void InitFSM()
{
IdleState idleState = new IdleState(gameObject);
RunState runState = new RunState(gameObject);
ThrowState throwState = new ThrowState(gameObject);
DeadState deadState = new DeadState(gameObject);
// 注册切换条件 对应的 状态
idleState.AddTransition(FSMTransition.IdleToRun, FSMStateId.Run);
runState.AddTransition(FSMTransition.RunToIdle, FSMStateId.Idle);
idleState.AddTransition(FSMTransition.IdleToThrow, FSMStateId.Throw);
runState.AddTransition(FSMTransition.RunToThrow, FSMStateId.Throw);
throwState.AddTransition(FSMTransition.ThrowToIdle, FSMStateId.Idle);
idleState.AddTransition(FSMTransition.IdleToDead, FSMStateId.Dead);
runState.AddTransition(FSMTransition.RunToDead, FSMStateId.Dead);
throwState.AddTransition(FSMTransition.ThrowToDead, FSMStateId.Dead);
system.AddState(idleState);
system.AddState(runState);
system.AddState(throwState);
system.AddState(deadState);
system.Start(FSMStateId.Idle);
}
void InitFSM()
{
fsm = new FSMSystem();
FSMState sleepState = new SleepState(fsm);
sleepState.AddTransition(Transition.Open, StateID.Idle);
FSMState IdleState = new IdleState(fsm);
IdleState.AddTransition(Transition.Close, StateID.Sleep);
IdleState.AddTransition(Transition.SeePlayer, StateID.Patrol);
IdleState.AddTransition(Transition.Shopping, StateID.GoOut);
IdleState.AddTransition(Transition.StartPlay, StateID.Play);
FSMState patrolState = new PatrolState(fsm);
patrolState.AddTransition(Transition.Open, StateID.Idle);
patrolState.AddTransition(Transition.SeePlayer, StateID.Chase);
FSMState chaseState = new ChaseState(fsm);
chaseState.AddTransition(Transition.LostPlayer, StateID.Patrol);
chaseState.AddTransition(Transition.FindEnemy, StateID.Bark);
FSMState barkState = new BarkState(fsm);
barkState.AddTransition(Transition.LostPlayer, StateID.Patrol);
FSMState gooutState = new GoOutState(fsm);
gooutState.AddTransition(Transition.Back, StateID.ComeBack);
gooutState.AddTransition(Transition.SeePlayer, StateID.Patrol);
FSMState comebackState = new ComeBackState(fsm);
comebackState.AddTransition(Transition.Open, StateID.Idle);
FSMState playState = new PlayState(fsm);
playState.AddTransition(Transition.Open, StateID.Idle);
playState.AddTransition(Transition.Close, StateID.Sleep);
playState.AddTransition(Transition.SeePlayer, StateID.Patrol);
playState.AddTransition(Transition.Shopping, StateID.GoOut);
fsm.AddState(sleepState);
fsm.AddState(IdleState);
fsm.AddState(patrolState);
fsm.AddState(chaseState);
fsm.AddState(barkState);
fsm.AddState(comebackState);
fsm.AddState(gooutState);
fsm.AddState(playState);
}
void MakeFSM()
{
SleepingState sleeping = new SleepingState();
sleeping.AddTransition("wake_up", "walk_to_mine");
WalkToMineState walkToMine = new WalkToMineState(mines);
walkToMine.AddTransition("reached_mine", "mining");
walkToMine.AddTransition("all_empty_mines", "idle");
IdleState idle = new IdleState(mines);
idle.AddTransition("money_in_pocket", "walk_to_bank");
idle.AddTransition("available_mines", "walk_to_mine");
idle.AddTransition("nothing_to_do", "walk_to_bar");
idle.AddTransition("no_energy", "walk_to_house");
WalkToHouseState walkToHouse = new WalkToHouseState(house);
walkToHouse.AddTransition("reached_house", "sleeping");
WalkToBarState walkToBar = new WalkToBarState(bar);
walkToBar.AddTransition("reached_bar", "drinking");
DrinkingState drinking = new DrinkingState();
drinking.AddTransition("finished_drink", "idle");
MiningState mining = new MiningState();
mining.AddTransition("empty_mine", "walk_to_mine");
mining.AddTransition("no_energy", "walk_to_house");
WalkToBankState walkToBank = new WalkToBankState(bank);
walkToBank.AddTransition("reached_bank", "depositing");
DepositingState depositing = new DepositingState();
depositing.AddTransition("finished_deposit", "idle");
fsm = new FSM();
fsm.AddState(walkToHouse);
fsm.AddState(sleeping);
fsm.AddState(walkToMine);
fsm.AddState(mining);
fsm.AddState(walkToBank);
fsm.AddState(idle);
fsm.AddState(walkToBar);
fsm.AddState(depositing);
fsm.AddState(drinking);
}
// The tile has 3 states: idle, wrapping and moving
// If it's on idle and userSwipe transition is fired, it changes to moving
// If it's on moving and reachedGoal transition is fired, it returns to idle
// If it's on moving and offGrid is fired, it changes to wrapping
// If it's on wrapping and finished wrap is fired, it changes to idle
private void MakeFSM()
{
IdleState idle = new IdleState(this);
idle.AddTransition(Transition.UserSwiped, StateID.Follow);
FollowState follow = new FollowState(this);
follow.AddTransition(Transition.FinishedFollow, StateID.Snapping);
SnappingState snap = new SnappingState(this);
snap.AddTransition(Transition.FinishedSnapping, StateID.Idle);
snap.AddTransition(Transition.OffGrid, StateID.Wrapping);
WrapState wrap = new WrapState(this);
wrap.AddTransition(Transition.FinishedWrap, StateID.Idle);
SetupState setup = new SetupState(this);
setup.AddTransition(Transition.FinishedSetup, StateID.Idle);
fsm = new FSMSystem();
fsm.AddState(setup);
fsm.AddState(idle);
fsm.AddState(follow);
fsm.AddState(snap);
fsm.AddState(wrap);
}
public WeaponFSM(string name, BaseWeapon weapon) : base(name, weapon)
{
if (!weapon)
{
// TODO: Add log
LogHalt("BaseWeapon object null!");
Halt();
}
idleState = new IdleState(this, EWeaponState.IDLE, "STATE_IDLE", weapon);
windupState = new WindupState(this, EWeaponState.WINDUP, "STATE_WINDUP", weapon);
fireState = new FireState(this, EWeaponState.FIRING, "STATE_FIRING", weapon);
cooldownState = new CooldownState(this, EWeaponState.COOLDOWN, "STATE_COOLDOWN", weapon);
idleState.AddTransition(new Tran_IdleToWindup(windupState, weapon));
windupState.AddTransition(new Tran_WindupToIdle(idleState, weapon));
windupState.AddTransition(new Tran_WindupToFire(fireState, weapon));
fireState.AddTransition(new Tran_FireToCooldown(cooldownState, weapon));
fireState.AddTransition(new Tran_FireToIdle(idleState, weapon));
fireState.AddTransition(new Tran_FireToFire(fireState, weapon));
AddState(idleState);
AddState(windupState);
AddState(fireState);
AddState(cooldownState);
}
public AIFSM(string name, EnemyController controller) : base(name, controller)
{
if (!controller)
{
// TODO: Add log
LogHalt("EnemyController object null!");
Halt();
}
#if UNITY_EDITOR
LogThis = true;
#endif
idleState = new IdleState(this, EAIState.IDLE, "STATE_IDLE", controller);
alertState = new AlertState(this, EAIState.ALERT, "STATE_ALERT", controller);
aggressiveState = new AggressiveState(this, EAIState.AGGRESSIVE, "STATE_AGGRESSIVE", controller);
idleState.AddTransition(new Tran_IdleToAlert(alertState, controller));
alertState.AddTransition(new Tran_AlertToAggressive(aggressiveState, controller));
alertState.AddTransition(new Tran_AlertToIdle(idleState, controller));
aggressiveState.AddTransition(new Tran_AggressiveToAlert(alertState, controller));
AddState(idleState);
AddState(alertState);
AddState(aggressiveState);
}
public override void StartFSM()
{
_leadState = new LeadState <states>(this, flags, leadStopDistance, _treeStartPoint);
_attackState = new AttackState <states>(this, flags, _treeStartPoint);
_buffState = new BuffState <states>(this, flags, _treeStartPoint);
_escapeState = new EscapeState <states>(this, flags, _treeStartPoint);
_idleState = new IdleState <states>(this, flags, _treeStartPoint);
_reloadState = new ReloadState <states>(this, flags, _treeStartPoint);
fsm = new FSM <states>(_idleState);
_idleState.AddTransition(states.Attack, _attackState);
_idleState.AddTransition(states.Buff, _buffState);
_idleState.AddTransition(states.Lead, _leadState);
_idleState.AddTransition(states.Escape, _escapeState);
_idleState.AddTransition(states.Reload, _reloadState);
_leadState.AddTransition(states.Attack, _attackState);
_leadState.AddTransition(states.Buff, _buffState);
_leadState.AddTransition(states.Escape, _escapeState);
_leadState.AddTransition(states.Idle, _idleState);
_leadState.AddTransition(states.Reload, _reloadState);
_attackState.AddTransition(states.Lead, _leadState);
_attackState.AddTransition(states.Buff, _buffState);
_attackState.AddTransition(states.Escape, _escapeState);
_attackState.AddTransition(states.Idle, _idleState);
_attackState.AddTransition(states.Reload, _reloadState);
_reloadState.AddTransition(states.Idle, _idleState);
_reloadState.AddTransition(states.Attack, _attackState);
_reloadState.AddTransition(states.Buff, _buffState);
_reloadState.AddTransition(states.Lead, _leadState);
_reloadState.AddTransition(states.Escape, _escapeState);
_buffState.AddTransition(states.Lead, _leadState);
_buffState.AddTransition(states.Attack, _attackState);
_buffState.AddTransition(states.Escape, _escapeState);
_buffState.AddTransition(states.Idle, _idleState);
_buffState.AddTransition(states.Reload, _reloadState);
_escapeState.AddTransition(states.Idle, _idleState);
_escapeState.AddTransition(states.Lead, _leadState);
fsm.SetState(_idleState);
}
private void BuildFSM() //Crea los estados, y las trancisiones que llevan a otros estados.
{
IdleState idle = new IdleState(this);
idle.AddTransition(TransitionID.StartRoaming, StateID.Roaming);
idle.AddTransition(TransitionID.SawTarget, StateID.ChasingTarget);
idle.AddTransition(TransitionID.StartHurt, StateID.Hurt);
idle.AddTransition(TransitionID.Dying, StateID.Dead);
RoamState roam = new RoamState(this);
roam.AddTransition(TransitionID.SawTarget, StateID.ChasingTarget);
roam.AddTransition(TransitionID.StopRoaming, StateID.Idle);
roam.AddTransition(TransitionID.StartHurt, StateID.Hurt);
roam.AddTransition(TransitionID.Dying, StateID.Dead);
ChaseTargetState chaseTarget = new ChaseTargetState(this);
chaseTarget.AddTransition(TransitionID.LostTarget, StateID.Roaming);
chaseTarget.AddTransition(TransitionID.StartHurt, StateID.Hurt);
chaseTarget.AddTransition(TransitionID.InRange, StateID.Attack);
chaseTarget.AddTransition(TransitionID.Dying, StateID.Dead);
AttackState attack = new AttackState(this);
attack.AddTransition(TransitionID.OutRange, StateID.ChasingTarget);
attack.AddTransition(TransitionID.Dying, StateID.Dead);
HurtState hurt = new HurtState(this);
hurt.AddTransition(TransitionID.StopHurt, StateID.ChasingTarget);
hurt.AddTransition(TransitionID.Dying, StateID.Dead);
DeadState dead = new DeadState(this);
dead.AddTransition(TransitionID.Healed, StateID.ChasingTarget);
fsm = new FSM();
fsm.AddState(roam);
fsm.AddState(idle);
fsm.AddState(chaseTarget);
fsm.AddState(attack);
fsm.AddState(hurt);
fsm.AddState(dead);
}
protected override IEnemyState InitializeStates()
{
var idle = new IdleState(this);
var claimForward = new ClaimForwardState(this, claimerPrefab);
var stepForward = new MoveForwardState(this, stepTime);
idle.AddTransition(() => { return(true); }, claimForward);
claimForward.AddTransition(() => { return(claimForward.IsDone()); }, stepForward);
stepForward.AddTransition(() => { return(stepForward.IsDone()); }, idle);
return(idle);
}
private void ConstructFSM()
{
IdleState idle = new IdleState();
idle.AddTransition(Transition.SawPlayer, FSMStateID.Attacking);
AttackState attack = new AttackState();
attack.AddTransition(Transition.LostPlayer, FSMStateID.Idling);
AddFSMState(idle);
AddFSMState(attack);
}
// The NPC has 3 states: Idle and ChasingPlayer
// If it's on the first state and SawPlayer transition is fired, it changes to ChasePlayer
// If it's on ChasePlayerState and LostPlayer transition is fired, it returns to FollowPath
protected void MakeFSM()
{
fsm = new FSMSystem ();
IdleState idleState = new IdleState (detectionRange, initialPosition);
idleState.AddTransition (Transition.PlayerDetected, StateID.ChasingPlayer);
ChasingPlayerState chasingState = new ChasingPlayerState (this.detectionRange, this.attackRange);
chasingState.AddTransition (Transition.PlayerConcealed, StateID.Idle);
fsm.AddState (idleState);
fsm.AddState (chasingState);
}
public void InitStateSystem() //初始化管理员
{
IdleState idle = new IdleState(this.gameObject, this);
idle.AddTransition(Transition.eTransiton_Object_Walk, StateID.eStateID_Object_Walk);
WalkState walk = new WalkState(this.gameObject, this);
walk.AddTransition(Transition.eTransiton_Object_Idle, StateID.eStateID_Object_Idle);
m_StateSystem = new StateSystem();
m_StateSystem.AddState(idle);
m_StateSystem.AddState(walk);
}
protected override void MakeFSM()
{
fsm = new FSMSystem();
IdleState idle = new IdleState(gameObject);
idle.AddTransition(Transition.PlayerVisible, StateID.Chase);
fsm.AddState(idle);
ChaseState chase = new ChaseState(gameObject);
chase.AddTransition(Transition.PlayerNotVisible, StateID.Idle);
fsm.AddState(chase);
}
private void MakeFSM()
{
IdleState idleState = new IdleState(this, StateID.IdleState);
WalkState walkState = new WalkState(this, StateID.PatrolState, walkSpeed);
//IdleState
idleState.AddTransition(new TimeTransition(walkState, idleTime));
//WalkState
walkState.AddTransition(new TimeTransition(idleState, walkTime));
_fsm.AddState(idleState);
_fsm.AddState(walkState);
}
void Start()
{
var idle = new IdleState <Feed>();
shooting = new ShootingState <Feed>(this.transform, target, this);
var cooldown = new CooldownState <Feed>();
idle.AddTransition(Feed.EnemigoEntraEnLOS, shooting);
shooting.AddTransition(Feed.EnemigoSaleDeLOS, idle);
shooting.AddTransition(Feed.ArmaRecalentada, cooldown);
cooldown.AddTransition(Feed.ArmaEnfriada, shooting);
cooldown.AddTransition(Feed.EnemigoSaleDeLOS, idle);
stateMachine = new FSM <Feed>(idle);
shootState = true;
}
protected override IEnemyState InitializeStates()
{
var idle = new IdleState(this);
var claimForward = new ClaimForwardState(this, claimerPrefab);
var chanceRoller = new ChanceRollerState(this);
var stepForward = new MoveForwardState(this, stepTime);
var jumpForward = new JumpForwardState(this, jumpHeight, jumpTime);
chanceRoller.AddEntry(jumpForward, Mathf.FloorToInt(jumpChance * 10));
chanceRoller.AddEntry(stepForward, Mathf.FloorToInt((1 - jumpChance) * 10));
idle.AddTransition(() => { return(true); }, claimForward);
claimForward.AddTransition(() => { return(claimForward.IsDone()); }, chanceRoller);
chanceRoller.AddTransition(() => { return(chanceRoller.PickedState == stepForward); }, stepForward);
chanceRoller.AddTransition(() => { return(chanceRoller.PickedState == jumpForward); }, jumpForward);
stepForward.AddTransition(() => { return(stepForward.IsDone()); }, idle);
jumpForward.AddTransition(() => { return(jumpForward.IsDone()); }, idle);
return(idle);
}
protected override IEnemyState InitializeStates()
{
var idle = new IdleState(this);
var claimForward = new ClaimForwardState(this, claimerPrefab);
var moveForward = new MoveForwardState(this, stepTime);
var forwardCounter = new CounterState(this, forwardSteps);
var switchState = new SwitchState(this);
var claimRight = new ClaimRightState(this, claimerPrefab);
var moveRight = new MoveRightState(this, stepTime);
var rightCounter = new CounterState(this, rightSteps);
var claimLeft = new ClaimLeftState(this, claimerPrefab);
var moveLeft = new MoveLeftState(this, stepTime);
var leftCounter = new CounterState(this, leftSteps);
idle.AddTransition(() => { return(true); }, claimForward);
claimForward.AddTransition(() => { return(claimForward.IsDone()); }, moveForward);
moveForward.AddTransition(() => { return(moveForward.IsDone()); }, forwardCounter);
forwardCounter.AddTransition(() => { return(forwardCounter.IsAmountReached()); }, switchState);
forwardCounter.AddTransition(() => { return(forwardCounter.IsAmountReached() == false); }, claimForward);
switchState.AddTransition(() => { return(switchState.Value == true); }, claimRight);
switchState.AddTransition(() => { return(switchState.Value == false); }, claimLeft);
claimRight.AddTransition(() => { return(claimRight.IsDone()); }, moveRight);
moveRight.AddTransition(() => { return(moveRight.IsDone()); }, rightCounter);
rightCounter.AddTransition(() => { return(rightCounter.IsAmountReached()); }, idle);
rightCounter.AddTransition(() => { return(rightCounter.IsAmountReached() == false); }, claimRight);
claimLeft.AddTransition(() => { return(claimLeft.IsDone()); }, moveLeft);
moveLeft.AddTransition(() => { return(moveLeft.IsDone()); }, leftCounter);
leftCounter.AddTransition(() => { return(leftCounter.IsAmountReached()); }, idle);
leftCounter.AddTransition(() => { return(leftCounter.IsAmountReached() == false); }, claimLeft);
return(idle);
}
void Start()
{
anim = GetComponent <Animator>();
StateIDToActionID = new Dictionary <StateID, Action>()
{
{ StateID.BattleFireBall, Action.FireBall },
{ StateID.BattleFallingBall, Action.FallingBall }
};
DragonHealth = 20;
PeriodSufferDamge = 0;
player = GameObject.FindGameObjectsWithTag("CurPlayer")[0];
GameObject controller_object = GameObject.FindGameObjectsWithTag("GameController")[0];
gamecontroller = controller_object.GetComponent <gamecontrol>();
DragonKnowledge = new KnowledgeSystem();
IdleState idle = new IdleState(player, gameObject);
idle.AddTransition(Transition.SawPlayer, StateID.BattleRoar);
idle.AddTransition(Transition.IdleEnd, StateID.RandomWalk);
RandomWalkState walk = new RandomWalkState(player, gameObject);
walk.AddTransition(Transition.SawPlayer, StateID.BattleRoar);
walk.AddTransition(Transition.WalkEnd, StateID.Idle);
BattleRoarState roar = new BattleRoarState(player, gameObject);
roar.AddTransition(Transition.Falling, StateID.BattleFallingBall);
roar.AddTransition(Transition.Beaten, StateID.BattleBeaten);
roar.AddTransition(Transition.FireBall, StateID.BattleFireBall);
roar.AddTransition(Transition.FarAway, StateID.BattleRun);
BattleFireBallState fireball = new BattleFireBallState(player, gameObject);
fireball.AddTransition(Transition.FireBall, StateID.BattleFireBall);
fireball.AddTransition(Transition.FarAway, StateID.BattleRun);
fireball.AddTransition(Transition.LowHealth, StateID.BattleRetreat);
fireball.AddTransition(Transition.Beaten, StateID.BattleBeaten);
fireball.AddTransition(Transition.Falling, StateID.BattleFallingBall);
BattleRunState run = new BattleRunState(player, gameObject);
run.AddTransition(Transition.FireBall, StateID.BattleFireBall);
run.AddTransition(Transition.LowHealth, StateID.BattleRetreat);
run.AddTransition(Transition.Falling, StateID.BattleFallingBall);
BattleRetreatState retreat = new BattleRetreatState(player, gameObject);
retreat.AddTransition(Transition.Beaten, StateID.BattleBeaten);
BattleBeatenState beaten = new BattleBeatenState(player, gameObject);
beaten.AddTransition(Transition.FireBall, StateID.BattleFireBall);
beaten.AddTransition(Transition.LowHealth, StateID.BattleRetreat);
beaten.AddTransition(Transition.FlyBack, StateID.BattleFlyBack);
BattleFlyBackState flyback = new BattleFlyBackState(player, gameObject);
flyback.AddTransition(Transition.FireBall, StateID.BattleFireBall);
flyback.AddTransition(Transition.Falling, StateID.BattleFallingBall);
flyback.AddTransition(Transition.FarAway, StateID.BattleRun);
flyback.AddTransition(Transition.Beaten, StateID.BattleBeaten);
BattleFallingBall fallingball = new BattleFallingBall(player, gameObject);
fallingball.AddTransition(Transition.FireBall, StateID.BattleFireBall);
fallingball.AddTransition(Transition.FarAway, StateID.BattleRun);
fallingball.AddTransition(Transition.LowHealth, StateID.BattleRetreat);
fallingball.AddTransition(Transition.Beaten, StateID.BattleBeaten);
fallingball.AddTransition(Transition.Falling, StateID.BattleFallingBall);
fsm = new FSMSystem();
fsm.AddState(idle);
fsm.AddState(walk);
fsm.AddState(roar);
fsm.AddState(fireball);
fsm.AddState(run);
fsm.AddState(retreat);
fsm.AddState(beaten);
fsm.AddState(flyback);
fsm.AddState(fallingball);
}
private void Start()
{
//Agarro el model
_model = GetComponent <Model>();
//Creo la FSM
_fsm = new FSM <string>();
//Creo los estados
IdleState <string> idle = new IdleState <string>(this);
PatrolState <string> patrol = new PatrolState <string>(Waypoints, transform, this);
ShootState <string> shoot = new ShootState <string>(this);
AlertState <string> alert = new AlertState <string>(this, Sight, ExclamationMark);
SearchState <string> search = new SearchState <string>(this);
//Creo las transiciones
idle.AddTransition(_patrolKey, patrol);
idle.AddTransition(_shootKey, shoot);
idle.AddTransition(_alertKey, alert);
idle.AddTransition(_searchKey, search);
idle.AddTransition(_idleKey, idle); //se tienen a si mismos por si llega a tener que volverse a ejecutar con el random
patrol.AddTransition(_idleKey, idle);
patrol.AddTransition(_shootKey, shoot);
patrol.AddTransition(_alertKey, alert);
patrol.AddTransition(_searchKey, search);
alert.AddTransition(_idleKey, idle);
alert.AddTransition(_shootKey, shoot);
alert.AddTransition(_patrolKey, patrol);
alert.AddTransition(_alertKey, alert);
alert.AddTransition(_searchKey, search);
search.AddTransition(_searchKey, search);
search.AddTransition(_idleKey, idle);
search.AddTransition(_shootKey, shoot);
search.AddTransition(_patrolKey, patrol);
search.AddTransition(_alertKey, alert);
//diccionario de todos los estados de idle para la roulette
_statesRoulette = new Dictionary <string, int>();
_statesRoulette.Add(_idleKey, 30);
_statesRoulette.Add(_patrolKey, 70);
_statesRoulette.Add(_searchKey, 50);
//inicializo la FSM
_fsm.SetInitialState(idle);
//Inicializo los nodos del Desicion Tree
ActionNode _shootActionNode = new ActionNode(ChangeToShootState); //Aca pasarle función
ActionNode _alertActionNode = new ActionNode(ChangeToAlertState);
ActionNode _randomStateActionNode = new ActionNode(ChangeToRandomState);
_isFirstTimeQuestionNode = new QuestionNode(Sight.SawTargetOnce, _shootActionNode, _alertActionNode);
_isSeeingPlayerQuestionNode = new QuestionNode(Sight.IsSeeingTarget, _isFirstTimeQuestionNode, _randomStateActionNode);
Sight.SawTarget.AddListener(ExecuteTree);
// Roulette
_actionRoulette = new Roulette <string>();
}
private void ConstructFSM()
{
IdleState idle = new IdleState();
idle.AddTransition(FSMTransitionType.CanBeMove, FSMStateType.Move);
idle.AddTransition(FSMTransitionType.AttackWithSingleWield, FSMStateType.SingleWieldAttack);
idle.AddTransition(FSMTransitionType.AttackWithDoubleHands, FSMStateType.DoubleHandsAttack);
idle.AddTransition(FSMTransitionType.UsingRipple, FSMStateType.RippleAttack);
idle.AddTransition(FSMTransitionType.UsingHeartAttack, FSMStateType.HeartAttack);
idle.AddTransition(FSMTransitionType.UsingStygianDesolator, FSMStateType.StygianDesolator);
idle.AddTransition(FSMTransitionType.UsingIceArrow, FSMStateType.IceArrow);
idle.AddTransition(FSMTransitionType.UsingChoshimArrow, FSMStateType.ChoshimArrow);
idle.AddTransition(FSMTransitionType.CanPickUp, FSMStateType.PickUp);
idle.AddTransition(FSMTransitionType.UsingThunderBolt, FSMStateType.ThunderBolt);
idle.AddTransition(FSMTransitionType.AttackWithSpear, FSMStateType.SpearAttack);
idle.AddTransition(FSMTransitionType.CanDefend, FSMStateType.Defend);
idle.AddTransition(FSMTransitionType.Falling, FSMStateType.Fall);
MoveState move = new MoveState();
move.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
move.AddTransition(FSMTransitionType.AttackWithSingleWield, FSMStateType.SingleWieldAttack);
move.AddTransition(FSMTransitionType.AttackWithDoubleHands, FSMStateType.DoubleHandsAttack);
move.AddTransition(FSMTransitionType.AttackWithSpear, FSMStateType.SpearAttack);
DefendState defend = new DefendState();
defend.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
SingleWieldAttackState singleWieldAttack = new SingleWieldAttackState();
singleWieldAttack.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
singleWieldAttack.AddTransition(FSMTransitionType.AttackWithSingleWield, FSMStateType.SingleWieldAttack);
singleWieldAttack.AddTransition(FSMTransitionType.CanBeMove, FSMStateType.Move);
DoubleHandsAttackState dualWieldAttack = new DoubleHandsAttackState();
dualWieldAttack.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
dualWieldAttack.AddTransition(FSMTransitionType.AttackWithDoubleHands, FSMStateType.DoubleHandsAttack);
dualWieldAttack.AddTransition(FSMTransitionType.CanBeMove, FSMStateType.Move);
SpearAttackState spearAttack = new SpearAttackState();
spearAttack.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
spearAttack.AddTransition(FSMTransitionType.CanBeMove, FSMStateType.Move);
RippleAttackState rippleAttack = new RippleAttackState();
rippleAttack.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
HeartAttackState heartAttack = new HeartAttackState();
heartAttack.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
StygianDesolatorState stygianDesolator = new StygianDesolatorState();
stygianDesolator.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
IceArrowState iceArrow = new IceArrowState();
iceArrow.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
ChoshimArrowState choshimArrow = new ChoshimArrowState();
choshimArrow.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
ThunderBoltState thunderBolt = new ThunderBoltState();
thunderBolt.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
PickUpState pickUp = new PickUpState();
pickUp.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
FallState fall = new FallState();
fall.AddTransition(FSMTransitionType.IsIdle, FSMStateType.Idle);
AddFSMState(idle);
AddFSMState(move);
AddFSMState(defend);
AddFSMState(singleWieldAttack);
AddFSMState(dualWieldAttack);
AddFSMState(rippleAttack);
AddFSMState(heartAttack);
AddFSMState(stygianDesolator);
AddFSMState(iceArrow);
AddFSMState(choshimArrow);
AddFSMState(thunderBolt);
AddFSMState(pickUp);
AddFSMState(spearAttack);
AddFSMState(fall);
}