/** Roll for whether or not a cloud should be spawned **/
private IEnumerator RollForCloud()
{
cloudWaiting = true;
cloudObjects.RemoveAll(obj => obj == null); // clear despawned clouds from cloud list
if (Random.Range(0, 1f) < cloudProbability && cloudObjects.Count < MAX_CLOUDS)
{
//Instantiate cloud object
GameObject cloud = Instantiate(cloudPrefab);
// Set cloud light priority and targets
IsoLight l = cloud.GetComponent <IsoLight>();
l.UniquePriority = (int)LightPriorityBases.CLOUD + cloudObjects.Count;
l.AddTarget_All();
// let cloud begin moving
MoveToTarget temp = cloud.GetComponent <MoveToTarget>();
temp.destroyOnArrival = true;
temp.go = true;
// track cloud /add to count
cloudObjects.Add(cloud);
}
yield return(new WaitForSeconds(cloudRollPeriod));
cloudWaiting = false;
}
void Start()
{
stateMachine = new StateMachine();
newStateDict = new Dictionary <NPC_InteractableType, IState>();
isCustomer = false;
_target = GetRandomExit();
_exitTarget = _target;
Debug.Log(this.transform.name + "'s target is " + _target);
_agent = this.GetComponent <NavMeshAgent>();
_anim = this.GetComponent <Animator>();
_checkedTargets = new List <GameObject>();
_customerOrder = new List <Ingredient>();
IState moveToTarget = new MoveToTarget(_target, this, _agent, _anim);
IState sitAtBus = new SitAtBus(_target, this, _agent, _anim);
IState customer = new Customer(_target, this, _agent, _anim);
newStateDict.Add(NPC_InteractableType.BUS_STOP_SEAT, sitAtBus);
newStateDict.Add(NPC_InteractableType.CUSTOMER, customer);
newStateDict.Add(NPC_InteractableType.EXIT, moveToTarget);
stateMachine.newState = moveToTarget;
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(1))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, LayerMask.GetMask("TerrainRaycast")))
{
// The player has clicked the environment
if (hit.transform.gameObject.layer == LayerMask.NameToLayer("TerrainRaycast"))
{
MoveToTarget combatAction = focus.gameObject.AddComponent <MoveToTarget>();
combatAction.TargetLocation = hit.point;
focus.Actions.SetAction(combatAction);
}
else if (hit.transform.gameObject.tag == "Enemy")
{
Debug.Log("Enemy clicked");
// Attach the script to move towards the target combatant
MoveToCombatant combatAction = focus.gameObject.AddComponent <MoveToCombatant>();
combatAction.Target = hit.transform.gameObject.GetComponent <Enemy>();
focus.Actions.SetAction(combatAction);
// Attach the script that will cause the player to attack after he has arrived at the target
Attack attackAction = focus.gameObject.AddComponent <Attack>();
attackAction.enabled = false;
attackAction.SetTarget(hit.transform.gameObject.GetComponent <Enemy>());
focus.Actions.AddAction(attackAction);
}
// The player has clicked an enemy
}
}
}
internal static Action actionAleatoire(bool isTank)
{
float choix = Random.Range(0, 2);
if (choix == 0)
{
if (isTank)
{
return(BougerRandomTank.createRandom());
}
else
{
return(BougerRandomScout.createRandom());
}
}
else if (choix == 1)
{
if (isTank)
{
return(MoveToTarget.createRandom());
}
else
{
return(BougerRandomScout.createRandom());
}
}
throw new NotImplementedException();
}
protected override void Awake()
{
base.Awake();
var search = new SearchForTarget(this, "Player");
var moveToTarget = new MoveToTarget(this, moveSpeed, nextWaypointDistance
, myRigidbody, spriteContainer);
var idle = new Idle();
var FireRangedAttack = new FireRangedAttack(this, enemyProjectile, minTimeBetweenShots, maxTimeBetweenShots, enemyAnimator);
var death = new Death(this, enemyAnimator);
AddTransition(search, moveToTarget, TargetFound());
AddTransition(search, idle, TargetMissing());
//AddTransition(moveToTarget, search, IsStuck());
AddTransition(moveToTarget, search, TargetMissing());
AddTransition(idle, search, ShouldAttack());
AddTransition(moveToTarget, FireRangedAttack, InRangeToAttack());
AddTransition(FireRangedAttack, search, TargetOutofRange());
AddAnyTransition(idle, () => !shouldAttackPlayer);
AddAnyTransition(death, ReadyToDie());
StateMachine.SetState(search);
Func <bool> TargetMissing() => () => Target == null;
Func <bool> IsStuck() => () => moveToTarget.TimeStuck > timeTillSearchWhenStuck;
Func <bool> TargetFound() => () => Target != null;
Func <bool> ShouldAttack() => () => shouldAttackPlayer;
Func <bool> InRangeToAttack() => () => Target != null &&
Mathf.Abs(Vector3.Distance(Target.transform.position, transform.position)) <= maxDistance;
Func <bool> TargetOutofRange() => () => Target != null && Mathf.Abs(Vector3.Distance(Target.transform.position, transform.position)) > maxDistance;
Func <bool> ReadyToDie() => () => enemyHealth.GetCurrentHealth() <= 0;
InvokeRepeating(nameof(UpdatePath), 0f, .5f);
}
private void Awake()
{
rb = GetComponent <Rigidbody2D>();
sr = GetComponentInChildren <SpriteRenderer>();
moveToTarget = GetComponent <MoveToTarget>();
defaultScale = transform.localScale;
defaultGravity = rb.gravityScale;
}
private void Awake()
{
critter = GetComponent <Critter>();
wander = GetComponent <Wander>();
mtt = GetComponent <MoveToTarget>();
wander.speed = critter.speed;
}
public Task buildTree()
{
List <Task> tasks = new List <Task>();
// if !locked, open door
Task checkLock = new doorUnlocked(door);
Task waitASec = new Wait(1f);
Task openDoor = new OpenDoor(door);
tasks.Add(checkLock);
tasks.Add(waitASec);
tasks.Add(openDoor);
Sequence openUnlockedDoor = new Sequence(tasks);
// barge it
tasks = new List <Task>();
Task checkDoorClosed = new doorClosed(door);
Task bargeIt = new BargeDoor(door);
tasks.Add(checkDoorClosed);
tasks.Add(waitASec);
tasks.Add(bargeIt);
Sequence bargeClosedDoor = new Sequence(tasks);
// ways to open a closed door
tasks = new List <Task>();
tasks.Add(openUnlockedDoor);
tasks.Add(bargeClosedDoor);
Selector openIt = new Selector(tasks);
// get the cheese when door closed
tasks = new List <Task>();
Task toDoor = new MoveToDoor(mouse, door);
Task toTarget = new MoveToTarget(mouse, cheese);
tasks.Add(toDoor);
tasks.Add(waitASec);
tasks.Add(openIt);
tasks.Add(waitASec);
tasks.Add(toTarget);
Sequence reachTargetBehindClosedDoor = new Sequence(tasks);
// get the cheese when door is open
tasks = new List <Task>();
Task checkDoorOpen = new doorOpen(door);
tasks.Add(checkDoorOpen);
tasks.Add(toTarget);
Sequence reachTargetBehindOpenDoor = new Sequence(tasks);
// get that cheese
tasks = new List <Task>();
tasks.Add(reachTargetBehindOpenDoor);
tasks.Add(reachTargetBehindClosedDoor);
Selector reachTarget = new Selector(tasks);
return(reachTarget);
}
void Start()
{
destinationPosition = gameObject.transform.position; // prevents Nullference and unmanaged movement
moveSpeed = 4;
pride = 0;
scoresForFollow = 1;
manager = gameObject.AddComponent <Manager>();
move = new MoveToTarget();
}
void Start()
{
destinationPosition = gameObject.transform.position; // prevents Nullference and unmanaged movement
moveSpeed = 4;
pride = 0;
scoresForFollow = 1;
manager = gameObject.AddComponent<Manager>();
move = new MoveToTarget();
}
void Start()
{
moveSpeed = 3.5f; // setting of initial speed
objectToFollow = this.gameObject.transform;
isFollow = false;
isCaged = false;
animator = GetComponent<Animator>();
moveToTarget = new MoveToTarget();
}
void Start()
{
stats = GetComponent <CharacterStats>();
moveToTArget = GetComponent <MoveToTarget>();
attack = GetComponent <Attack>();
settings = GetComponent <CharacterSettings>();
OnStart();
}
bool isCaged; //Shows if follower is in cage - finish zone
void Start()
{
moveSpeed = 3.5f; // setting of initial speed
objectToFollow = this.gameObject.transform;
isFollow = false;
isCaged = false;
animator = GetComponent <Animator>();
moveToTarget = new MoveToTarget();
}
private void Awake()
{
enemyAnimation = GetComponentInChildren <EnemyAnimation>();
deathEvents = GetComponentsInChildren <IDeathEvent>().ToList();
enemyGraphics = GetComponent <IEnemyGraphicUpdater>();
enemyAttack = GetComponent <IEnemyAttack>();
enemyMove = GetComponent <IEnemyMove>();
moveToTarget = GetComponent <MoveToTarget>();
StartingColumn = Mathf.RoundToInt(transform.position.x);
}
void Start()
{
target = GameObject.Find("Ship").GetComponent <MoveToTarget>();
transform.localScale = new Vector3(transform.localScale.y * Screen.width / Screen.height,
-2.0f * Mathf.Tan(0.5f * Camera.main.fieldOfView) * 0.5f);
UnRenderMenu();
}
// Use this for initialization
void Start()
{
target = new GameObject();
target.transform.SetParent(trackball.transform);
mover = GetComponent <MoveToTarget> ();
mover.target = target.transform;
// body = GetComponent<Rigidbody> ();
mover.enabled = false;
marionetteSafe = marionette.constraints;
}
public void Setup()
{
Node moveToTargetNode = new MoveToTarget(this);
Player player = (MainController.GetControllerOfType(typeof(PlayerController)) as PlayerController).Player;
freeze = new Sequence(
new CanSeeWhisp(this, viewRange),
new Inverter(new IsPlayerCloserThanWhisps(this, viewRange)),
new SetFrozen(this),
new Monitor(
new DoNothing(),
new IsFrozen(this))
);
bringFragmentToPlayer = new Monitor(
new ActiveSelector(
new Monitor(
new Sequence(
new SetTargetLookPosition(this, Helpers.PlayerPosition),
new LookAtTarget(this)),
new IsPlayerWithinRange(this, maxOfferFragmentDistance)),
new Sequence(
new SetTargetMovePosition(this, Helpers.PlayerPosition),
moveToTargetNode)),
new HasFragment(this)
);
collectFragment = new Sequence(
new IsFragmentNear(this),
new SetTargetFragment(this),
new Monitor(
new Sequence(
new SetTargetMovePosition(this, Helpers.CurrentFragmentTarget),
moveToTargetNode,
new PickupFragment(this)),
new IsTargetFragmentAlive(this))
);
followPlayer = new ActiveSelector(
new Sequence(
new Inverter(new IsPlayerWithinRange(this, maxFollowPlayerDistance)),
new SetTargetMovePosition(this, Helpers.PlayerPosition),
moveToTargetNode),
new Sequence(
new SetTargetMovePosition(this, Helpers.RandomPosition),
moveToTargetNode,
new WaitRandom(0.5f, 2f))
);
ActiveSelector RootSelector = new ActiveSelector(freeze, bringFragmentToPlayer, collectFragment, followPlayer);
BehaviourTree = new BehaviourTree.BehaviourTree(RootSelector);
}
protected void Awake()
{
// Cache the Character instance controlling this component. Avoids excessive runtime lookups.
character = GetComponent <Character>();
// Adds a new component to the character which allows him to move to target posiitons
moveToTargetScript = gameObject.AddComponent <MoveToTarget>();
// Set the character's physics data to default
physicsData = new PhysicsData(defaultPhysicsData);
// Caches the entity's components to efficiently modify their behaviours
rigidbody = GetComponent <Rigidbody2D>();
}
public ITask ConfigureBehavior()
{
List <ITask> moveToOpenRoom = new List <ITask>();
ITask CheckOpenDoor = new isDoorOpen(door);
ITask MoveIntoRoom = new MoveToTarget();
moveToOpenRoom.Add(CheckOpenDoor);
moveToOpenRoom.Add(MoveIntoRoom);
Sequence moveToOpenRoomSeq = new Sequence(moveToOpenRoom);
List <ITask> tryToOpenDoor = new List <ITask>();
ITask isUnlocked = new isDoorUnlocked(door);
ITask openDoor = new OpenDoor(door);
tryToOpenDoor.Add(isUnlocked);
tryToOpenDoor.Add(openDoor);
ITask tryToOpenSeq = new Sequence(tryToOpenDoor);
List <ITask> breakLockedDoor = new List <ITask>();
ITask doorClosed = new isDoorClosed(door);
ITask bargeDoor = new BargeDoor(door);
breakLockedDoor.Add(doorClosed);
breakLockedDoor.Add(bargeDoor);
ITask breakDoor = new Sequence(breakLockedDoor);
List <ITask> interactWithDoor = new List <ITask>();
interactWithDoor.Add(tryToOpenSeq);
interactWithDoor.Add(breakDoor);
ITask interact = new Selector(interactWithDoor);
List <ITask> moveToDoor = new List <ITask>();
ITask goToDoor = new MoveToDoor();
ITask goToRoom = new MoveToTarget();
moveToDoor.Add(goToDoor);
moveToDoor.Add(interact);
moveToDoor.Add(goToRoom);
ITask moveToClosedRoomSeq = new Sequence(moveToDoor);
List <ITask> taskList = new List <ITask>();
taskList.Add(moveToOpenRoomSeq);
taskList.Add(moveToClosedRoomSeq);
ITask root = new Selector(taskList);
return(root);
}
public void Setup()
{
Node moveToTargetNode = new MoveToTarget(this);
Player player = (MainController.GetControllerOfType(typeof(PlayerController)) as PlayerController).Player;
Node canSeePlayerNode = new CanSeeAgent(this, player, playerViewRange);
fleeingAction = new Sequence(
canSeePlayerNode,
new IsPlayerWithinRange(this, PlayerFleeRange),
new InvokeDelegate(SetLastFleeTimeToNow),
new SetTargetMovePosition(this, Helpers.AwayFromPlayer),
moveToTargetNode
);
allertingAction = new ActiveSelector(
new Monitor(
new Sequence(
new SetTargetLookPosition(this, Helpers.PlayerPosition),
new LookAtTarget(this)),
canSeePlayerNode),
new Monitor(
new Sequence(
new SetTargetLookPosition(this, Helpers.RandomPosition),
new LookAtTarget(this)),
new HasFledRecently(this))
);
exploringAction = new ActiveSelector(
new Sequence(
new IsFragmentNear(this),
new SetTargetFragment(this),
new Monitor(
new Sequence(
new SetTargetMovePosition(this, Helpers.CurrentFragmentTarget),
moveToTargetNode,
new PickupFragment(this)),
new IsTargetFragmentAlive(this))),
new Sequence(
new Inverter(new HasMovedRecently(this)),
new SetTargetMovePosition(this, Helpers.RandomPosition),
moveToTargetNode)
);
idleAction = new WaitRandom(2, 4);
ActiveSelector RootSelector = new ActiveSelector(fleeingAction, allertingAction, exploringAction, idleAction);
BehaviourTree = new BehaviourTree.BehaviourTree(RootSelector);
}
void OnDragStop()
{
// try to find a dropzone who can accept this drop
Dropzone newTargetDropzone = null;
foreach (Dropzone dropzone in dropZones)
{
if (dropzone.CanDrop(_collider))
{
newTargetDropzone = dropzone;
break;
}
}
if (newTargetDropzone != null)
{
// tell our old dropzone, if any, to lift
if (targetDropzone)
{
targetDropzone.Lift();
}
targetDropzone = newTargetDropzone;
// accept drop and if cb returns true, auto move
if (OnDropAccepted(this))
{
MoveToTarget.Go(
gameObject,
targetDropzone.transform.position,
autoMoveArrivalThreshold
).OnArrival = (_) => FinishDrop();
}
}
else
{
// reject drop and if cb returns true, auto move home
if (OnDropRejected(this))
{
MoveToTarget.Go(
gameObject,
_dragging.OriginalPos,
autoMoveArrivalThreshold
).OnArrival = (_) => FinishReturn();
}
}
}
private void SendMoveToTarget(int targetId, Vector3 targetPos, float stopDistance)
{
if ((this.self.isPlayer || (this.self.MirrorState && this.self.ParentUnit.isPlayer)) && Singleton <PvpManager> .Instance.IsInPvp && GameManager.IsPlaying())
{
MoveToTarget data = new MoveToTarget
{
unitId = this.self.unique_id,
pos = MoveController.Vector3ToSVector3(this.self.transform.position),
targetId = targetId,
targetPos = MoveController.Vector3ToSVector3(targetPos),
stopDis = stopDistance
};
PvpEvent.SendMoveToTarget(SerializeHelper.Serialize <MoveToTarget>(data));
}
}
void InitRound()
{
Reset();
persons = new List <GameObject>();
for (int p = 0; p < PersonPrefabs.Length; p++)
{
GameObject person = familyTransform.Find(PersonPrefabs[p].name).gameObject;
if (person != null)
{
Debug.Log("Person " + person.name + " already placed by hand!");
person.GetComponent <PersonController>().SetHomePosition(homePositions[p]);
}
else
{
person = GameObject.Instantiate(PersonPrefabs[p]);
person.transform.parent = familyTransform;
// Set home position
person.GetComponent <PersonController>().SetHomePosition(homePositions[p]);
person.transform.position = homePositions[p].transform.position;
}
// Find and assign target
MoveToTarget moveToTarget = person.GetComponent <MoveToTarget>();
if (moveToTarget != null)
{
GameObject target = GameObject.Find(moveToTarget.TargetName);
if (target != null)
{
moveToTarget.Target = target;
}
}
// TODO mood cooldown/item settings?
person.transform.Find("StateText").gameObject.SetActive(ShowStatus);
persons.Add(person);
}
// hide home positions, will only be visible while dragging person
foreach (GameObject homePosition in homePositions)
{
homePosition.GetComponentInChildren <SpriteRenderer>().enabled = false;
}
EnterState(States.GAME);
}
public AgentBehaviorTreeBuilder Action(ActionType type)
{
Action action = null;
switch (type)
{
case ActionType.AssignTarget_Agent_ClosestInView:
action = new AssignTarget(agent, TargetType.Agent, TargetCriteria.ClosestInView);
break;
case ActionType.AssignTarget_Food_ClosestInView:
action = new AssignTarget(agent, TargetType.Food, TargetCriteria.ClosestInView);
break;
case ActionType.Eat:
action = new Eat(agent);
break;
case ActionType.AttackTarget:
action = new AttackTarget(agent);
break;
case ActionType.MoveToTarget:
action = new MoveToTarget(agent);
break;
case ActionType.SteerToTarget:
action = new SteerToTarget(agent);
break;
case ActionType.Wander:
action = new Wander(agent);
break;
case ActionType.ChangeColor_Aggressive:
action = new ChangeColorStatus(agent, ColorStatus.Aggressive);
break;
case ActionType.ChangeColor_Passive:
action = new ChangeColorStatus(agent, ColorStatus.Passive);
break;
}
base.Action(action);
return(this);
}
// utility for creating and starting a move
public static MoveToTarget Go(
GameObject toMove,
Vector3 pos,
float arrivalThreshold = default_arrival_threshold,
float speed = default_speed
)
{
MoveToTarget moveTo = toMove.GetComponent <MoveToTarget>();
if (moveTo == null)
{
moveTo = toMove.AddComponent <MoveToTarget>();
}
moveTo.arrivalThreshold = arrivalThreshold;
moveTo.speed = speed;
moveTo.Go(pos);
return(moveTo);
}
private IEnumerator TransferPointsRoutine(GameSphere fromSphere, GameSphere toSphere)
{
if (fromSphere == toSphere)
{
yield return(null);
}
int halfPoints = fromSphere.sphereStats.Points / 2;
for (int i = 0; i < halfPoints; i++)
{
Vector3 spawnLocation = fromSphere.transform.position + new Vector3(Random.Range(-gameData.spawnRadius, gameData.spawnRadius), Random.Range(-gameData.spawnRadius, gameData.spawnRadius), Random.Range(-gameData.spawnRadius, gameData.spawnRadius));
GameObject particle = ObjectPooler.instance.GetPooledObject(spawnLocation, Quaternion.identity);
MoveToTarget move = particle.GetComponent <MoveToTarget>();
move.SetOrigin(fromSphere);
move.SetTarget(toSphere.gameObject);
fromSphere.sphereStats.Points--;
yield return(new WaitForSeconds(.05f));
}
yield return(null);
}
// Start is called before the first frame update
void Start()
{
collider = GetComponent <Collider2D>();
spriteRenderer = GetComponentInChildren <SpriteRenderer>(); // Sprite is in child object
cooldown = gameObject.GetComponent <Cooldown>();
moodCooldown = gameObject.GetComponent <Mood>();
moveToTarget = gameObject.GetComponent <MoveToTarget>(); // TODO replace with generic moveToTarget
highlight = gameObject.transform.Find("Highlight")?.GetComponent <SpriteRenderer>();
// set random values for cooldowns
cooldown.DurationCD = Random.Range(5, 7);
if (moodCooldown)
{
moodCooldown.MoodValue = Random.Range(8, 10);
}
overlapsTriggers = new List <Collider2D>();
EnterState(InitialState);
}
private void InitFSMSystem()
{
fsm = new FsmSystem();
SeekTarget seekTarget = new SeekTarget(this, fsm, anim);
seekTarget.AddTransition(Transition.MoveToTarget, StateID.MoveToTarget);
seekTarget.AddTransition(Transition.Attack, StateID.Attack);
MoveToTarget moveToTarget = new MoveToTarget(this, fsm, anim);
moveToTarget.AddTransition(Transition.SeekTarget, StateID.SeekTarget);
moveToTarget.AddTransition(Transition.Attack, StateID.Attack);
AttackTarget attackTarget = new AttackTarget(this, fsm, anim);
attackTarget.AddTransition(Transition.SeekTarget, StateID.SeekTarget);
attackTarget.AddTransition(Transition.MoveToTarget, StateID.MoveToTarget);
fsm.AddState(seekTarget);
fsm.AddState(moveToTarget);
fsm.AddState(attackTarget);
}
// ********************************************************************
#endregion
// ********************************************************************
// ********************************************************************
#region Public Methods
// ********************************************************************
public void ApplyScreenShake(float _magnitude)
{
MoveToTarget mover = GetComponent <MoveToTarget>();
int numShakes = Mathf.CeilToInt(2.0f * _magnitude);
float distance = 0.05f * _magnitude;
if (!mover.hasTarget)
{
m_startingPoint = transform.position;
}
for (int i = 0; i < numShakes; ++i)
{
// shake to
Vector2 direction = Vector2.one.Randomise();
Vector3 target = m_startingPoint;
target.x += direction.x * distance;
target.y += direction.y * distance;
mover.MoveTo(target);
// shake back
mover.MoveTo(m_startingPoint);
}
}
public override void OnInspectorGUI()
{
MoveToTarget script = (MoveToTarget)target;
script.targetType = (MoveToTarget.TargetType)EditorGUILayout.EnumPopup("My type", script.targetType);
if (script.targetType == MoveToTarget.TargetType.Transform)
{
script.speed = EditorGUILayout.FloatField("Speed", script.speed);
script.targetObject = EditorGUILayout.ObjectField("Target Obj", script.targetObject, typeof(Transform), false) as Transform;
}
else if (script.targetType == MoveToTarget.TargetType.Vector3)
{
script.speed = EditorGUILayout.FloatField("Speed", script.speed);
script.targetPos = EditorGUILayout.Vector3Field("Target Pos", script.targetPos);
}
else if (script.targetType == MoveToTarget.TargetType.RigidBody)
{
script.speed = EditorGUILayout.FloatField("Speed", script.speed);
script.rotateSpeed = EditorGUILayout.FloatField("Rotate Speed", script.rotateSpeed);
script.targetObject = EditorGUILayout.ObjectField("Target Obj", script.targetObject, typeof(Transform), false) as Transform;
}
script.keepStartRot = EditorGUILayout.Toggle("Keep Start Rotation", script.keepStartRot);
}
protected override void SetupStateMachine()
{
stateMachine = new StateMachine();
// Set Up States
var walkRandomWithinCircle = new MoveToRandomWithinCircle(this, agent, SpawnPatrolRadius);
var walkToTarget = new MoveToTarget(this, agent, MoveState.Walking);
var standAndWait = new StandAndWait();
var runAwayFromPlayer = new RunAwayFromTransform(this, agent, playerProximity, MoveState.Running);
var startRunningAway = new StartRunningAway(this, agent, playerProximity, EscapedPlayerRadius);
//////----
// Set Transitions
//
// walkToTarget
stateMachine.AddTransition(walkToTarget, standAndWait, ReachedGoalPosition());
stateMachine.AddTransition(walkToTarget, standAndWait, GotStuck());
// standAndWait
stateMachine.AddTransition(standAndWait, walkRandomWithinCircle, WaitFor(standAndWait, IdleTime));
// startRunningAway
stateMachine.AddTransition(startRunningAway, runAwayFromPlayer, () => true);
// runAwayFromPlayer
stateMachine.AddTransition(runAwayFromPlayer, startRunningAway, GotStuck());
stateMachine.AddTransition(runAwayFromPlayer, startRunningAway, WaitFor(runAwayFromPlayer, 1.0f));
stateMachine.AddTransition(runAwayFromPlayer, walkRandomWithinCircle, EscapedFromPlayer());
// One-frame States
stateMachine.AddTransition(walkRandomWithinCircle, walkToTarget, () => true);
//////----
// Set Universal Transitions
//
// One-frame States
stateMachine.AddUniversalTransition(startRunningAway, WantToRunFromPlayer());
// Conditions
Func <bool> ReachedGoalPosition() =>
() => Vector3.Distance(transform.position, goalPosition) <= agent.stoppingDistance + 0.2f;
Func <bool> GotStuck() =>
() => timeSinceLastProgress > StuckTime;
Func <bool> WaitFor(IWaitableState state, float seconds) =>
() => state.GetTimeElapsed() > seconds;
Func <bool> WantToRunFromPlayer() =>
() => (stateMachine._curState != runAwayFromPlayer) && playerProximity.IsInRange;
Func <bool> EscapedFromPlayer() =>
() => !playerProximity.IsInRange;
// Set initial state
stateMachine.SetState(walkRandomWithinCircle);
}
private void Start()
{
var idle = new Idle(this);
var moveToSupply = new MoveToSupply(this);
var moveToSupplyWait = new MoveToSupplyWait(this);
var moveToTarget = new MoveToTarget(this);
var moveToDock = new MoveToDock(this);
var requestTarget = new RequestTarget(this, manager);
var descendToTarget = new DescendToTarget(this);
var ascendFromTarget = new AscendFromTarget(this);
var descendToSupply = new DescendToSupply(this);
var descendToSupplyWait = new DescendToSupplyWait(this);
var ascendFromSupply = new AscendFromSupply(this);
var descendToDock = new DescendToDock(this);
var ascendToTransHeight = new AscendToTransHeight(this);
var waitAtSupply = new WaitAtSupply(this);
var alignToSupply = new AlignToSupply(this);
var alignToSupplyWait = new AlignToSupplyWait(this);
var alignToDock = new AlignToDock(this);
var alignToTarget = new AlignToTarget(this);
var resupply = new Resupply(this);
var buildBlock = new BuildBlock(this);
var navigateToDock = new NavigateToDock(this);
var navigateToSupply = new NavigateToSupply(this);
var navigateToSupplyWait = new NavigateToSupplyWait(this);
var navigateToTarget = new NavigateToTarget(this);
_stateMachine.AddTransition(idle, requestTarget, IsRunning());
_stateMachine.AddTransition(requestTarget, ascendToTransHeight, AssignedTarget());
_stateMachine.AddTransition(requestTarget, navigateToDock, WaitForTarget());
_stateMachine.AddTransition(navigateToDock, moveToDock, ApproxNaviTargetPos);
_stateMachine.AddTransition(moveToDock, alignToDock, ReachedDockXZ());
_stateMachine.AddTransition(alignToDock, descendToDock, ReachedNaviTargetRot);
_stateMachine.AddTransition(descendToDock, idle, ReachedNaviTargetPos);
_stateMachine.AddTransition(ascendToTransHeight, navigateToSupply, ReachedNaviPosSupplyIsCurrent());
_stateMachine.AddTransition(ascendToTransHeight, navigateToSupplyWait, ReachedNaviPosSupplyIsWait());
_stateMachine.AddTransition(navigateToSupply, moveToSupply, ApproxNaviTargetPos);
_stateMachine.AddTransition(moveToSupply, alignToSupply, ReachedSupplyXZ());
_stateMachine.AddTransition(navigateToSupplyWait, moveToSupplyWait, ApproxNaviTargetPos);
_stateMachine.AddTransition(moveToSupplyWait, navigateToSupply, ReachedNaviPosSupplyIsCurrent());
_stateMachine.AddTransition(moveToSupplyWait, alignToSupplyWait, ReachedNaviPosSupplyIsWait());
_stateMachine.AddTransition(alignToSupplyWait, navigateToSupply, ReachedNaviRotSupplyIsCurrent());
_stateMachine.AddTransition(alignToSupplyWait, descendToSupplyWait, ReachedNaviRotSupplyIsWait());
_stateMachine.AddTransition(alignToSupply, descendToSupply, ReachedSupplyRot());
_stateMachine.AddTransition(descendToSupplyWait, waitAtSupply, ReachedSupplyWait());
_stateMachine.AddTransition(waitAtSupply, navigateToSupply, WaitForSupplyFinished());
_stateMachine.AddTransition(descendToSupply, resupply, ReachedSupplyPosIsCurrent());
_stateMachine.AddTransition(resupply, ascendFromSupply, () => true);
_stateMachine.AddTransition(ascendFromSupply, navigateToTarget, ReachedTransHeight());
_stateMachine.AddTransition(navigateToTarget, moveToTarget, ApproxNaviTargetPos);
_stateMachine.AddTransition(moveToTarget, alignToTarget, ReachedTargetXZ());
_stateMachine.AddTransition(alignToTarget, descendToTarget, ReachedTargetRot());
_stateMachine.AddTransition(descendToTarget, buildBlock, ReachedTarget());
_stateMachine.AddTransition(buildBlock, ascendFromTarget, () => true);
_stateMachine.AddTransition(ascendFromTarget, requestTarget, ReachedTransHeight());
_stateMachine.AddTransition(ascendFromTarget, navigateToDock, BatteryLow());
_stateMachine.SetState(idle);
Func <bool> IsRunning() => () => running && IsCharged();
Func <bool> AssignedTarget() => () => target != null;
Func <bool> WaitForTarget() => () =>
target == null && Vector3.Distance(transform.position, dock.position) > PosTolerance;
Func <bool> ReachedSupplyXZ() => () => target != null && supply != null &&
ReachedNaviTargetPos();
Func <bool> ReachedSupplyWait() => () => target != null && supply != null &&
ReachedNaviTargetPos();
Func <bool> WaitForSupplyFinished() => () => target != null && supply != null &&
supply.IsDroneCurrent(this);
Func <bool> ReachedTargetXZ() => () => target != null && ReachedNaviTargetPos();
Func <bool> ReachedTargetRot() => () => target != null && ReachedNaviTargetRot();
Func <bool> ReachedDockXZ() => () => target == null && ReachedNaviTargetPos();
Func <bool> ReachedTarget() => () => target != null && ReachedNaviTargetPos();
Func <bool> ReachedSupplyPosIsCurrent() => () =>
supply != null && ReachedNaviTargetPos() && supply.IsDroneCurrent(this) &&
Vector3.Distance(transform.position, supply.GetDroneAssignedTransform(this).position) <= PosTolerance;
Func <bool> ReachedSupplyRot() => () => supply != null && ReachedNaviTargetRot();
Func <bool> ReachedTransHeight() => () => Mathf.Abs(transform.position.y - TransHeight) < PosTolerance;
Func <bool> BatteryLow() => () => ReachedTransHeight()() && _battery <= BatteryThreshold;
Func <bool> ReachedNaviPosSupplyIsCurrent() => () => supply.IsDroneCurrent(this) && ReachedNaviTargetPos();
Func <bool> ReachedNaviPosSupplyIsWait() => () => supply.IsDroneWaiting(this) && ReachedNaviTargetPos();
Func <bool> ReachedNaviRotSupplyIsCurrent() => () => supply.IsDroneCurrent(this) && ReachedNaviTargetRot();
Func <bool> ReachedNaviRotSupplyIsWait() => () => supply.IsDroneWaiting(this) && ReachedNaviTargetRot();
bool ApproxNaviTargetPos() => Vector3.Distance(transform.position, _naviTarget.position) <= NavTolerance;
bool ReachedNaviTargetPos() => Vector3.Distance(transform.position, _naviTarget.position) <= PosTolerance;
bool ReachedNaviTargetRot() =>
Mathf.Abs(transform.eulerAngles.y - _naviTarget.rotation.eulerAngles.y) <= RotTolerance;
}
private void SelectSwarmComponent(MoveToTarget swarmComponent)
{
selectedSwarmComponents.Add (swarmComponent);
swarmComponent.EnableControl ();
}
private void DeselectSwarmComponent(MoveToTarget swarmComponent)
{
selectedSwarmComponents.Remove (swarmComponent);
swarmComponent.DisableControl ();
}
void OnEnable()
{
m_moveToTarget = GetComponent<MoveToTarget> ();
m_cameraOffset = transform.position.z - Camera.main.transform.position.z;
}
