public BasicState(FSMManager manager)
{
this.manager = manager;
this.from = manager.gameObject;
this.fromAttr = manager.GetComponent <BasicObjectAttr>();
this._config = Config.getInstance();
}
// protected float[] m_AngleCheckings = new float[] { 0, -15, 15, -45, 45 };
// protected float[] m_AngleAvoidances = new float[] { 10, 40, -40, 40, -40 };
// protected float[] m_LengthAvoidances = new float[] { 3f, 3f, 3f, 3f, 3f };
#endregion
#region Monobehaviour Implementation
protected override void Awake()
{
base.Awake();
this.m_NavMeshAgent = this.GetComponent <NavMeshAgent> ();
this.m_NavMeshAgent.speed = this.m_MoveSpeed + Random.Range(0, 2f);
this.m_MaxSpeed = this.m_NavMeshAgent.speed;
this.m_FSMManager = new FSMManager();
this.m_FSMManager.RegisterState("FSMSoccerIdleState", new FSMSoccerIdleState(this));
this.m_FSMManager.RegisterState("FSMSoccerAttackState", new FSMSoccerAttackState(this));
this.m_FSMManager.RegisterState("FSMSoccerDefendState", new FSMSoccerDefendState(this));
this.m_FSMManager.RegisterState("FSMSoccerPassBallState", new FSMSoccerPassBallState(this));
this.m_FSMManager.RegisterState("FSMSoccerAssistState", new FSMSoccerAssistState(this));
this.m_FSMManager.RegisterState("FSMSoccerChaseBallState", new FSMSoccerChaseBallState(this));
this.m_FSMManager.RegisterState("FSMSoccerCatchBallState", new FSMSoccerCatchBallState(this));
this.m_FSMManager.RegisterCondition("IsTeamAttacking", this.IsTeamAttacking);
this.m_FSMManager.RegisterCondition("HaveBall", this.HaveBall);
this.m_FSMManager.RegisterCondition("PassTheBall", this.PassTheBall);
this.m_FSMManager.RegisterCondition("DidToManyChaseBall", this.DidToManyChaseBall);
this.m_FSMManager.RegisterCondition("IsNearAllyGoal", this.IsNearAllyGoal);
this.m_FSMManager.RegisterCondition("IsNearEnemyGoal", this.IsNearEnemyGoal);
this.m_FSMManager.LoadFSM(this.m_FSMTextAsset.text);
}
void Start()
{
FSMManager manager = GetComponent <FSMManager>();
RandomState search = new RandomState();
FollowState follow = new FollowState();
EatState eat = new EatState();
/**
* Search for "food"
* when locate -> follow it
* When arrive -> eat it;
*/
manager.GetBasicState()
.configure("Food",
o => follow.whenArrive((e) => eat.setToEat(e).setAfterEat((s) => search), o), (o) => {
Debug.LogError("GOTCHA");
return(null);
});
/**
* Search for "player"
* when locate -> follow it
* When arrive -> attack it;
*/
// search.config("Player", o => follow.config((e) => attack.setTarget(e), o));
manager.setCurrentState(search);
}
// Use this for initialization
void Start()
{
controlMove = transform.GetComponent <CharacterController>();
animator = transform.GetComponentInChildren <Animator>();
animManager = new FSMManager((int)AnimalEnum.MaxValue);
PlayerIdle tmpIdle = new PlayerIdle(animator, new AnimalStateBack(AnimalStateChange));
animManager.AddState(tmpIdle);
PlayerRun tmpRun = new PlayerRun(animator, new AnimalStateBack(AnimalStateChange));
animManager.AddState(tmpRun);
PlayerAttact tmpAttact = new PlayerAttact(animator, new AnimalStateBack(AnimalStateChange));
animManager.AddState(tmpAttact);
PlayerBigAttact bigAttact = new PlayerBigAttact(animator, new AnimalStateBack(AnimalStateChange));
animManager.AddState(bigAttact);
transform.localEulerAngles = new Vector3(0, 90, 0);
}
protected override void Awake()
{
base.Awake();
m_ObjectPool = new ObjectPool <CAIController> ();
m_FSMManger = new FSMManager();
m_FSMManger.LoadFSM("FSM/SimpleNestFSM");
var idleNestState = new FSMNestIdleState(this);
var deactiveNestState = new FSMNestDeactiveState(this);
m_FSMManger.RegisterState("NestIdleState", idleNestState);
m_FSMManger.RegisterState("NestDeactiveState", deactiveNestState);
m_FSMManger.RegisterCondition("IsDeactive", IsDeactive);
m_Members = new List <CAIController> ();
m_Frees = new LinkedList <CAIController> ();
m_LineWorkers = new LinkedList <CAIController> ();
m_LineReturnNest = new LinkedList <CAIController> ();
OnNestInit();
}
void Start()
{
fsm = new FSMManager <Data>();
StateBase <Data> defreezeState = new DefreezeState(fsm);
defreezeState.AddTransition(Transition.PressFreeze, StateID.FreezeState);
defreezeState.AddTransition(Transition.PressReset, StateID.ResetState);
StateBase <Data> freezeState = new FreezeState(fsm);
freezeState.AddTransition(Transition.PressDefreeze, StateID.DefreezeState);
freezeState.AddTransition(Transition.PressReset, StateID.ResetState);
StateBase <Data> resetState = new ResetState(fsm);
resetState.AddTransition(Transition.PressDefreeze, StateID.DefreezeState);
resetState.AddTransition(Transition.PressFreeze, StateID.FreezeState);
fsm.AddState(defreezeState);
fsm.AddState(freezeState);
fsm.AddState(resetState);
fsm.InitState(freezeState);
}
private void Awake()
{
myActor = GetComponent <Actor> ();
myTimer = GetComponent <Timer> ();
myFsmManager = GetComponent <FSMManager> ();
myAnimator = GetComponent <Animator> ();
myDamager = GetComponentInChildren <Damager> ();
myShooter = GetComponentInChildren <Shooter> ();
myActor.solidLayer = solidLayer;
myActor.maxFall = maxFall;
myActor.gravity = gravity;
myFsmManager.RegisterState("Direction", "Left");
myFsmManager.RegisterState("Direction", "Right", true, true);
myFsmManager.RegisterState("FullBody", "Jump");
myFsmManager.RegisterState("FullBody", "Fall");
myFsmManager.RegisterState("FullBody", "Dash");
myFsmManager.RegisterState("FullBody", "Idle", true, true);
myFsmManager.RegisterState("FullBody", "Run");
myFsmManager.RegisterState("Action", "Attack", false);
myFsmManager.RegisterState("Action", "Shoot");
myTimer.RegisterAction("DashDuration", Timer.types.Auto);
myTimer.RegisterAction("DashLock", Timer.types.Auto);
myTimer.RegisterAction("AttackDuration", Timer.types.Auto);
myTimer.RegisterAction("AttackLock", Timer.types.Auto);
myTimer.RegisterAction("ShootLock", Timer.types.Auto);
// We can have several action cold down. Can cold down AttackLock/DashLock... -> parallel mode
// we can only have one action is performed at the moment. Can only Jump/Fall/Dash -> sequential mode. Transfer to the other state when the action is performed and allowed.
// we can only either have left or right -> sequential mode
// Maybe Manual mode becomes useless...
}
public FSMBaseAction(E_ActionTYpe type, Agent agent, FSMManager owner)
{
_actionType = type;
_agent = agent;
_owner = owner;
Initialize();
}
void FixedUpdate()
{
lineOfSight.enabled = _config.lightIsOn;
lineOfSight.SetStatus(LineOfSight.Status.Idle);
if (lineOfSight.enabled)
{
if (lineOfSight.SeeByTag("Player"))
{
List <GameObject> obs = lineOfSight.getViewing();
GameObject obj = obs[0];
Player player = obj.GetComponent <Player>();
if (player != null)
{
if (!player.disguised)
{
Collider[] colliders = Physics.OverlapSphere(gameObject.transform.position, alertRadious);
GameObject nearest = null;
float nearestDist = 0f;
foreach (Collider c in colliders)
{
if (c.tag.Equals("Soldier"))
{
float dist = Vector3.Distance(c.gameObject.transform.position, transform.position);
if (nearest == null || dist < nearestDist)
{
nearestDist = dist;
nearest = c.gameObject;
}
}
}
if (nearest != null)
{
FSMManager g = nearest.GetComponent <FSMManager>();
BasicObjectAttr attr = nearest.GetComponent <BasicObjectAttr>();
// We arrive to destination
List <SearchConfig> searchConf = g.GetBasicState().GetSearchConfig();
foreach (SearchConfig sc in searchConf)
{
if (sc.doWhenAlert != null)
{
IAState st = sc.doWhenAlert.Invoke(obj);
g.setCurrentState(st);
}
}
}
lineOfSight.SetStatus(LineOfSight.Status.Alerted);
}
else
{
lineOfSight.SetStatus(LineOfSight.Status.Suspicious);
}
}
}
}
}
void Awake(){
m_Instance = this;
//m_AIData初始化
m_AIData.fspeed = 20.0f;
m_AIData.fMaxspeed = m_fMaxSpeed;
m_AIData.frotate = 0.0f;
m_AIData.fMaxrotate = 10.0f;
m_AIData.fColProbe = 2.0f;
m_AIData.thisPoint = this.gameObject;
m_AIData.targetPoint = targetPoint;
m_AIData.m_Obs = SceneManager.m_Instance.m_Obs;
m_AIData.m_Wall = SceneManager.m_Instance.m_Wall;
m_AIData.fRadius = 0.5f;
m_AIData.iAstarIndex = -1;
m_AIData.targetPosition = Vector3.zero;
m_AIData.fDetectLength = 10.0f;
m_AIData.fAttackLength = 5.0f;
m_AIData.fAttack = 10.0f;
m_AIData.fSkill = 30.0f;
m_AIData.iLV = 1;
m_AIData.iEXP = 0;
m_AIData.fHP = fHP;
m_AIData.fMP = fMP;
m_AIData.fMaxHP = fMaxHP;
m_AIData.fMaxMP = fMaxMP;
//FSM的設定
m_FSMManager = new FSMManager ();
FSMIdleState IdleState = new FSMIdleState ();
m_FSMManager.AddState (IdleState);
m_AIData.m_State = m_FSMManager;
}
public override void OnUpdate(FSMManager fsm, float time)
{
//持续时间结束
if (time - enterTime >= lastTime)
{
fsm.EndState(FSMState.Sheep);
}
}
public void Aggro()
{
FSMState chaseState = FSMManager.GetState("ZombieChase");
if (chaseState != null)
{
EntityFSM.ChangeState(chaseState);
}
}
public void Awake()
{
_fsm = new FSMManager(this, E_ActionTYpe.Idle);
_fsm.Addaction(FSMActionFactory.Create(E_ActionTYpe.Idle, _fsm));
_fsm.Addaction(FSMActionFactory.Create(E_ActionTYpe.Walk, _fsm));
_fsm.Initialize();
controller = GetComponent <CharacterController>();
}
protected override void Awake()
{
base.Awake();
this.OnLoadData();
this.SetID(Guid.NewGuid().ToString());
this.m_FSMManager = new FSMManager();
this.OnStartAction = new CEventListener();
this.OnEndAction = new CEventListener();
}
void Start()
{
RunFSM tmpRunFSM = new RunFSM();
AttackFSM tmpAttackFSM = new AttackFSM();
manager = new FSMManager(2);
manager.AddState(tmpRunFSM);
manager.AddState(tmpAttackFSM);
}
void Start()
{
fromAttr = GetComponent <BasicObjectAttr>();
this.originalPos.transform.parent = null;
FSMManager manager = GetComponent <FSMManager>();
NavMeshAgent agent = GetComponent <NavMeshAgent>();
RandomState search = new RandomState();
FollowState follow = new FollowState();
IdleState idle = new IdleState();
idle.isInfinite = true;
InvestigateState investigateState = new InvestigateState();
manager.GetBasicState().configure("Player",
(o) => {
return(null);
},
(o) => {
investigateState.setTargetPos(o.transform.position);
investigateState.SetDoWhenArrive((s) => {
Collider[] coll = Physics.OverlapSphere(gameObject.transform.position, fromAttr.dangerViewAreaRadius);
Debug.Log("Clll" + coll.Length);
foreach (Collider c in coll)
{
if (c.tag.Equals("Player"))
{
var go = Camera.main.GetComponent <GameOverCameraControl>();
go.showDeadEffect = true;
return(null);
}
}
idle.time = fromAttr.investigateWaitTime;
idle.isInfinite = false;
idle.onComplete((s1) => {
investigateState.setTargetPos(this.originalPos.transform.position);
investigateState.SetDoWhenArrive((s2) => {
idle.isInfinite = true;
transform.rotation = this.originalPos.transform.rotation;
agent.destination = this.transform.position;
return(idle);
});
return(investigateState);
});
return(idle);
});
return(investigateState);
});
manager.setCurrentState(idle);
}
/*
//=============================角色動作=============================
public Animator Anim;
public AnimatorStateInfo BS;
static int Idle = Animator.StringToHash("Base.Layer.BG_Chibi_Idle");
static int Run = Animator.StringToHash("Base.Layer.BG_Chibi_B_Run");
static int Attac = Animator.StringToHash("Base.Layer.0G_Chibi_Attack00");
static int Skill = Animator.StringToHash("Base.Layer.0G_Chibi_Attack00");
public enum eEgo {
None = -1,
Idle,
Run,
Attac,
Skill
}
public eEgo iNowEgo = eEgo.None;
//=============================完=============================
*/
void Awake(){
//iNowEgo = eEgo.Idle;
m_Instance = this;
//獲得AStar的Component
//Camera mainCamera = Camera.main;
//m_AStar = mainCamera.GetComponent<AStar>();
m_AStar = this.GetComponent<AStar> ();
//m_AIData初始化
m_AIData.fspeed = 0.1f;
m_AIData.fMaxspeed = m_fMaxSpeed;
m_AIData.frotate = 0.0f;
m_AIData.fMaxrotate = 10.0f;
m_AIData.fColProbe = 1.0f;
m_AIData.thisPoint = this.gameObject;
m_AIData.targetPoint = targetPoint;
m_AIData.m_Obs = SceneManager.m_Instance.m_Obs;
m_AIData.fRadius = 0.5f;
m_AIData.iAstarIndex = -1;
m_AIData.targetPosition = Vector3.zero;
m_AIData.fDetectLength = 10.0f;
m_AIData.fAttackLength = 5.0f;
m_AIData.fAttack = 10.0f;
m_AIData.fSkill = 30.0f;
m_AIData.fSkillMP = 20.0f;
m_AIData.iEXPGET = 20;
m_AIData.fHP = fHP;
m_AIData.fMP = fMP;
m_AIData.fMaxHP = fMaxHP;
m_AIData.fMaxMP = fMaxMP;
/*
生成隊長時呼叫自己的小兵，並傳入變數給小兵，指派他的隊長
*/
//FSM的設定
m_FSMManager = new FSMManager ();
FSMNpcIdleState IdleState = new FSMNpcIdleState ();
FSMNpcTrackState TrackState = new FSMNpcTrackState ();
FSMNpcAttackState AttackState = new FSMNpcAttackState ();
FSMNpcSkillState SkillState = new FSMNpcSkillState ();
IdleState.AddTransition (eTransitionID.Idle_To_Track, eStateID.Track);
TrackState.AddTransition (eTransitionID.Track_To_Attack, eStateID.Attack);
TrackState.AddTransition (eTransitionID.Track_To_Skill, eStateID.Skill);
AttackState.AddTransition (eTransitionID.Attack_To_Idle, eStateID.Idle);
AttackState.AddTransition (eTransitionID.Attack_To_Track, eStateID.Track);
SkillState.AddTransition (eTransitionID.Skill_To_Idle, eStateID.Idle);
SkillState.AddTransition (eTransitionID.Skill_To_Track, eStateID.Track);
m_FSMManager.AddState (IdleState);
m_FSMManager.AddState (TrackState);
m_FSMManager.AddState (AttackState);
m_FSMManager.AddState (SkillState);
m_AIData.m_State = m_FSMManager;
}
protected override void Awake()
{
base.Awake();
this.m_FSMManager = new FSMManager();
this.m_FSMManager.LoadFSM(this.m_FSMText.text);
this.m_FSMManager.RegisterState("GameIdleState", new FSMGameIdleState(this));
this.m_FSMManager.RegisterState("GameActiveState", new FSMGameActiveState(this));
this.m_FSMManager.RegisterState("GameCompletedState", new FSMGameCompletedState(this));
this.m_FSMManager.RegisterState("GameEndState", new FSMGameEndState(this));
this.m_FSMManager.RegisterCondition("IsLoadingCompleted", this.IsLoadingCompleted);
this.m_FSMManager.RegisterCondition("IsPlayerDeath", this.IsPlayerDeath);
this.m_FSMManager.RegisterCondition("IsRoundCompleted", this.IsRoundCompleted);
}
private void Start()
{
//FSM TESTING
FSMState normalState = FSMManager.GetState("ZombieWander");
if (normalState != null)
{
EntityFSM.ChangeState(normalState);
}
else
{
Debug.LogError("Can't find Zombie Wander state");
}
}
// Use this for initialization
void Start()
{
m_AStar = this.GetComponent<AStar>(); ;
//m_AIData初始化
m_AIData.fspeed = 20.0f;
m_AIData.fMaxspeed = m_fMaxSpeed;
m_AIData.frotate = 0.0f;
m_AIData.fMaxrotate = 10.0f;
m_AIData.fColProbe = 2.0f;
m_AIData.thisPoint = this.gameObject;
m_AIData.targetPoint = targetPoint;
m_AIData.m_Obs = SceneManager.m_Instance.m_Obs;
m_AIData.m_Wall = SceneManager.m_Instance.m_Wall;
m_AIData.fRadius = 0.5f;
m_AIData.iAstarIndex = -1;
m_AIData.targetPosition = Vector3.zero;
m_AIData.fDetectLength = 20.0f;
m_AIData.fAttackLength = 10.0f;
m_AIData.fHP = 100.0f;
m_AIData.fMP = 30.0f;
m_AIData.fAttack = 10.0f;
m_AIData.fSkill = 30.0f;
//FSM的設定
m_FSMManager = new FSMManager();
FSMIdleState IdleState = new FSMIdleState();
//FSMTrackState TrackState = new FSMTrackState ();
//FSMChaseState ChaseState = new FSMChaseState ();
//FSMAttackState AttackState = new FSMAttackState ();
//FSMWanderState WanderState = new FSMWanderState ();
//IdleState.AddTransition (eTransitionID.Idle_To_Track, eStateID.Track);
//IdleState.AddTransition (eTransitionID.Idle_To_Chase, eStateID.Chase);
//IdleState.AddTransition (eTransitionID.Idle_To_Attack, eStateID.Attack);
//IdleState.AddTransition (eTransitionID.Idle_To_Wander, eStateID.Wander);
//TrackState.AddTransition (eTransitionID.Track_To_Idle, eStateID.Idle);
//TrackState.AddTransition (eTransitionID.Track_To_Chase, eStateID.Chase);
//TrackState.AddTransition (eTransitionID.Track_To_Attack, eStateID.Attack);
//TrackState.AddTransition (eTransitionID.Track_To_Wander, eStateID.Wander);
//ChaseState.AddTransition (eTransitionID.Chase_To_Attack, eStateID.Attack);
//ChaseState.AddTransition (eTransitionID.Chase_To_Idle, eStateID.Idle);
//AttackState.AddTransition (eTransitionID.Attack_To_Idle, eStateID.Idle);
//AttackState.AddTransition (eTransitionID.Attack_To_Chase, eStateID.Chase);
//WanderState.AddTransition (eTransitionID.Wander_To_Idle, eStateID.Idle);
m_FSMManager.AddState(IdleState);
//m_FSMManager.AddState (TrackState);
//m_FSMManager.AddState (ChaseState);
//m_FSMManager.AddState (AttackState);
//m_FSMManager.AddState (WanderState);
m_AIData.m_State = m_FSMManager;
}
// Use this for initialization
void Start()
{
fm = new FSMManager((int)AnimationEnum.Max);
Animator animator = GetComponent <Animator>();
CharacterController characterController = GetComponent <CharacterController>();;
PlayerIdle tmpIdle = new PlayerIdle(animator);
fm.AddState(tmpIdle);
PlayerRun tmpRun = new PlayerRun(animator, characterController);
fm.AddState(tmpRun);
PlayerAttack tmpAttack = new PlayerAttack(animator, this);
fm.AddState(tmpAttack);
}
public PatrolState(FSMManager <GameObject> fsm) : base(fsm)
{
stateID = StateID.PatrolState;
wayPointList = new List <Transform>();
Transform[] trans = GameObject.Find("WayPoints").GetComponentsInChildren <Transform>();
for (int i = 0; i < trans.Length; i++)
{
if (i != 0)
{
wayPointList.Add(trans[i]);
}
}
player = GameObject.Find("Player").transform;
}
protected override void Awake()
{
base.Awake();
this.m_FSMManager = new FSMManager();
this.m_FSMManager.LoadFSM(this.m_FSMText.text);
this.m_FSMManager.RegisterState("FishIdleState", new FSMFishIdleState(this));
this.m_FSMManager.RegisterState("FishChaseBaitState", new FSMFishChaseBaitState(this));
this.m_FSMManager.RegisterState("FishBiteBaitState", new FSMFishBiteBaitState(this));
this.m_FSMManager.RegisterCondition("HaveBait", this.HaveBait);
this.m_FSMManager.RegisterCondition("IsBiteBail", this.IsBiteBail);
this.m_FSMManager.RegisterCondition("IsBailTimer", this.IsBailTimer);
}
protected override void Awake()
{
base.Awake();
this.m_FSMManager = new FSMManager();
this.m_FSMManager.LoadFSM(this.m_FSMText.text);
this.m_FSMManager.RegisterState("RepairFishingState", new FSMRepairFishingState(this));
this.m_FSMManager.RegisterState("StartFishingState", new FSMStartFishingState(this));
this.m_FSMManager.RegisterState("FinishFishingState", new FSMFinishFishingState(this));
this.m_FSMManager.RegisterCondition("IsObjectActive", this.IsObjectActive);
this.m_FSMManager.RegisterCondition("IsBaitThrowed", this.IsBaitThrowed);
this.m_FSMManager.RegisterCondition("IsFishBite", this.IsFishBite);
this.m_FSMManager.RegisterCondition("IsFishingEnd", this.IsFishingEnd);
}
protected virtual void OnRegisterFSM()
{
var jsonText = Resources.Load <TextAsset>(m_MapManager.mapData.gameFSMPath);
var gameIdle = new FSMGameIdleState(this);
var gameLoading = new FSMGameLoadingState(this);
var gameStart = new FSMGameStartState(this);
var gameProcessing = new FSMGameProcessingState(this);
var startTurn = new FSMGameStartTurnState(this);
var updateTurn = new FSMGameUpdateTurnState(this);
var endTurn = new FSMGameEndTurnState(this);
var gameEnd = new FSMGameEndState(this);
var winGame = new FSMWinGameState(this);
var closeGame = new FSMCloseGameState(this);
m_FSMManager = new FSMManager();
m_FSMManager.RegisterState("GameIdleState", gameIdle);
m_FSMManager.RegisterState("GameLoadingState", gameLoading);
m_FSMManager.RegisterState("GameStartState", gameStart);
m_FSMManager.RegisterState("GameProcessingState", gameProcessing);
m_FSMManager.RegisterState("StartTurnState", startTurn);
m_FSMManager.RegisterState("UpdateTurnState", updateTurn);
m_FSMManager.RegisterState("EndTurnState", endTurn);
m_FSMManager.RegisterState("GameEndState", gameEnd);
m_FSMManager.RegisterState("WinGameState", winGame);
m_FSMManager.RegisterState("CloseGameState", closeGame);
m_FSMManager.RegisterCondition("IsLoading", IsLoading);
m_FSMManager.RegisterCondition("IsLoadingComplete", IsLoadingComplete);
m_FSMManager.RegisterCondition("IsProcessing", IsProcessing);
m_FSMManager.RegisterCondition("IsStartTurn", IsStartTurn);
m_FSMManager.RegisterCondition("IsUpdateTurn", IsUpdateTurn);
m_FSMManager.RegisterCondition("IsEndTurn", IsEndTurn);
m_FSMManager.RegisterCondition("IsEndGame", IsEndGame);
m_FSMManager.RegisterCondition("IsAllCompleteBlock", IsAllCompleteBlock);
m_FSMManager.RegisterCondition("IsOnceCompleteBlock", IsOnceCompleteBlock);
m_FSMManager.RegisterCondition("IsAllDeath", IsAllDeath);
m_FSMManager.RegisterCondition("IsOnceDeath", IsOnceDeath);
m_FSMManager.RegisterCondition("DidDeactiveTargetObject", DidDeactiveTargetObject);
m_FSMManager.RegisterCondition("Did5Turn", Did5Turn);
m_FSMManager.RegisterCondition("Did10Turn", Did10Turn);
m_FSMManager.RegisterCondition("Did20Turn", Did20Turn);
m_FSMManager.RegisterCondition("Did30Turn", Did30Turn);
m_FSMManager.RegisterCondition("Did40Turn", Did40Turn);
m_FSMManager.RegisterCondition("Did50Turn", Did50Turn);
m_FSMManager.LoadFSM(jsonText.text);
}
public virtual void Initial()
{
moveControl = transform.GetComponent <CharacterController>();
if (moveControl == null)
{
moveControl = gameObject.AddComponent <CharacterController>();
}
fsmManager = new FSMManager((int)StateEnum.MaxValue);
dataBase = new NPCDataBase(DataBackLogic);
// Debug.Log("parent Initial");
}
protected override void Awake()
{
base.Awake();
this.m_FSMManager = new FSMManager();
this.m_FSMManager.RegisterState("FSMTeamIdleState", new FSMTeamIdleState(this));
this.m_FSMManager.RegisterState("FSMTeamPlayingState", new FSMTeamPlayingState(this));
this.m_FSMManager.RegisterState("FSMTeamAttackState", new FSMTeamAttackState(this));
this.m_FSMManager.RegisterState("FSMTeamDefendState", new FSMTeamDefendState(this));
this.m_FSMManager.RegisterCondition("IsPlaying", this.IsPlaying);
this.m_FSMManager.RegisterCondition("IsTeamHaveBall", this.IsTeamHaveBall);
this.m_FSMManager.RegisterCondition("IsNearAllyGoal", this.IsNearAllyGoal);
this.m_FSMManager.RegisterCondition("IsNearEnemyGoal", this.IsNearEnemyGoal);
this.m_FSMManager.LoadFSM(this.m_FSMTextAsset.text);
}
// Use this for initialization
void Start()
{
fsmManager = new FSMManager((int)AnimationEnum.Max);
Animator animator = GetComponent <Animator>();
PlayerWait tmpWait = new PlayerWait(animator);
fsmManager.AddState(tmpWait);
PlayerJump tmpJump = new PlayerJump(animator, this);
fsmManager.AddState(tmpJump);
PlayerWalk tmpWalk = new PlayerWalk(animator);
fsmManager.AddState(tmpWalk);
PlayerWait02 tmpWait02 = new PlayerWait02(animator);
fsmManager.AddState(tmpWait02);
}
private static FSMBaseAction CreateAction(E_ActionTYpe type, Agent agent, FSMManager owner)
{
switch (type)
{
case E_ActionTYpe.Idle:
return(new PlayerIdleAction(agent, owner));
case E_ActionTYpe.Walk:
return(new PlayerWalkAction(agent, owner));
//case E_ActionTYpe.Attack:
// break;
default:
Debug.LogError("No this Action");
return(null);
}
}
public override void TakeDamage(float damage)
{
FSMManager _manager = GetComponent <FSMManager>();
if (!_manager.Dead)
{
if (_manager.Anim.GetBool("IsMoving"))
{
_manager.Anim.SetTrigger("Damaged");
}
else
{
_manager.SetState(PlayerState.Idle);
_manager.Anim.SetTrigger("Damaged");
}
base.TakeDamage(damage);
}
}
protected override void Awake()
{
base.Awake();
m_NavMeshAgent = this.GetComponent <NavMeshAgent> ();
havestObjects = new LinkedList <CObjectController> ();
m_FSMManager = new FSMManager();
m_FSMManager.LoadFSM("FSM/SimpleWorkerFSM");
var idleState = new FSMIdleState(this);
var moveState = new FSMMoveState(this);
var waitingState = new FSMWaitingState(this);
var waitingCommandState = new FSMWaitCommandState(this);
var havestState = new FSMHavestState(this);
var goNestState = new FSMGoNestState(this);
var productFoodState = new FSMProductFoodState(this);
var deathState = new FSMDeathState(this);
m_FSMManager.RegisterState("IdleState", idleState);
m_FSMManager.RegisterState("MoveState", moveState);
m_FSMManager.RegisterState("WaitingState", waitingState);
m_FSMManager.RegisterState("WaitingCommandState", waitingCommandState);
m_FSMManager.RegisterState("HavestState", havestState);
m_FSMManager.RegisterState("GoNestState", goNestState);
m_FSMManager.RegisterState("ProductFoodState", productFoodState);
m_FSMManager.RegisterState("DeathState", deathState);
m_FSMManager.RegisterCondition("HaveTarget", HaveTarget);
m_FSMManager.RegisterCondition("HaveHavest", HaveHavest);
m_FSMManager.RegisterCondition("DidMoveToSignPoint", DidMoveToSignPoint);
m_FSMManager.RegisterCondition("DidMoveToTarget", DidMoveToTarget);
m_FSMManager.RegisterCondition("DidMoveToNest", DidMoveToNest);
m_FSMManager.RegisterCondition("DidFullStorable", DidFullStorable);
m_FSMManager.RegisterCondition("DidProductFoodComplete", DidProductFoodComplete);
m_FSMManager.RegisterCondition("IsDeath", IsDeath);
m_MovableComponent = new CMovableComponent(this, m_NavMeshAgent);
m_MovableComponent.currentTransform = m_Transform;
m_MovableComponent.obstacles = m_ObstacleLayerMasks;
m_MovableComponent.radiusBase = 0f;
m_CurrentLayerMask = this.gameObject.layer;
}
public void TargetCheck()
{
GameObject player = GameObject.FindGameObjectWithTag("Player");
CharacterController cc = player.GetComponent <CharacterController>();
bool found = false;
if (cc)
{
Plane[] ps = GeometryUtility.CalculateFrustumPlanes(_sight);
if (GeometryUtility.TestPlanesAABB(ps, cc.bounds))
{
RaycastHit hit;
Vector3 direction = player.transform.position + Vector3.up * 1.5f;
direction = direction - _sight.transform.position;
Physics.Raycast(_sight.transform.position, direction, out hit);
Debug.DrawRay(_sight.transform.position, direction);
if (hit.transform == player.transform)
{
FSMManager playerManager = player.GetComponent <FSMManager>();
if (playerManager.CurrentState != PlayerState.Hide && playerManager.CurrentState != PlayerState.Dead)
{
found = true;
}
}
}
}
else if (Vector3.Distance(transform.position, player.transform.position) <= 1.0f)
{
found = true;
}
if (found)
{
_target = player;
}
else
{
_target = null;
}
}
void Start()
{
fromAttr = GetComponent <BasicObjectAttr>();
FSMManager manager = GetComponent <FSMManager>();
RandomState search = new RandomState();
FollowState follow = new FollowState();
IdleState idle = new IdleState();
PatrolState patrol = new PatrolState();
InvestigateState investigateState = new InvestigateState();
patrol.patrolRoute = patrolRoute;
patrol.setAgent(GetComponent <NavMeshAgent>());
manager.GetBasicState().configure("Player",
(o) => {
investigateState.setTargetPos(o.transform.position).SetDoWhenArrive(null);
return(investigateState);
},
(o) => {
investigateState.setTargetPos(o.transform.position);
investigateState.SetDoWhenArrive((s) => {
Collider[] coll = Physics.OverlapSphere(gameObject.transform.position, fromAttr.dangerViewAreaRadius);
foreach (Collider c in coll)
{
if (c.tag.Equals("Player"))
{
var go = Camera.main.GetComponent <GameOverCameraControl>();
go.showDeadEffect = true;
return(null);
}
}
return(patrol);
});
return(investigateState);
});
manager.setCurrentState(patrol);
}
public virtual void Init()
{
m_Transform = this.transform;
SetStartPosition (m_Transform.position);
SetTargetPosition (m_Transform.position);
m_AnimatorController = this.GetComponent<Animator> ();
m_Collider = this.GetComponent<CapsuleCollider> ();
m_ObjectCurrentvalue = new Dictionary<string, object>();
m_GameManager = TDCGameManager.GetInstance();
m_FSMManager = new FSMManager();
var waiting = new FSMWaitingState (this);
var waitingOne = new FSMWaitingOneSecondState (this);
var waitingOne2Three = new FSMWaitingOne2ThreeSecondState (this);
var waitingThree2Five = new FSMWaitingThree2FiveSecondState (this);
var sleepState = new FSMSleepState(this);
var dayModeState = new FSMDayModeState(this);
var nightModeState = new FSMNightModeState(this);
m_FSMManager.RegisterState("WaitingState", waiting);
m_FSMManager.RegisterState("WaitingOneSecondState", waitingOne);
m_FSMManager.RegisterState("WaitingOne2ThreeSecondState", waitingOne2Three);
m_FSMManager.RegisterState("WaitingThree2FiveSecondState", waitingThree2Five);
m_FSMManager.RegisterState("DayModeState", dayModeState);
m_FSMManager.RegisterState("NightModeState", nightModeState);
m_FSMManager.RegisterState("SleepState", sleepState);
m_FSMManager.RegisterCondition("IsActive", IsActive);
m_FSMManager.RegisterCondition("CountdownWaitingTime", CountdownWaitingTime);
m_FSMManager.RegisterCondition("IsDayTime", TDCDateTime.IsDayTime);
m_FSMManager.RegisterCondition("IsMidDayTime", TDCDateTime.IsMidDayTime);
m_FSMManager.RegisterCondition("IsNightTime", TDCDateTime.IsNightTime);
m_FSMManager.RegisterCondition("IsMidNightTime", TDCDateTime.IsMidNightTime);
m_FSMManager.RegisterCondition("IsSpring", IsSpring);
m_FSMManager.RegisterCondition("IsSummer", IsSummer);
m_FSMManager.RegisterCondition("IsAutumn", IsAutumn);
m_FSMManager.RegisterCondition("IsWinter", IsWinter);
m_FSMManager.RegisterCondition("IsRainy", IsRainy);
m_FSMManager.RegisterCondition("IsOverHeat", IsOverHeat);
m_FSMManager.RegisterCondition("IsWindy", IsWindy);
m_FSMManager.RegisterCondition("IsSnowy", IsSnowy);
}
