public async Task <IActionResult> PutArrive(string id, Arrive arrive)
{
if (id != arrive.ArriveId)
{
return(BadRequest());
}
_context.Entry(arrive).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ArriveExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// Use this for initialization
protected override void Start()
{
Sight = GetComponent <FieldOfView>();
Search = GetComponent <AStarSearch>();
Path = GetComponent <ASPathFollower>();
Wander = GetComponent <Wander>();
Seek = GetComponent <Seek>();
Flee = GetComponent <Flee>();
Arrive = GetComponent <Arrive>();
Terrain = GameObject.Find("Terrain");
Animator = GetComponent <Animator>();
SearchAgent = GetComponent <ASAgent>();
State = new FiniteStateMachine <Velociraptor>(this);
State.Change(V_Idle.Instance);
Path.enabled = true;
Path.path = new ASPath();
Path.enabled = false;
collision_ticks = 0.0f;
health_time = 0.0f;
hunger_time = 0.0f;
thirst_time = 0.0f;
base.Start();
}
//public bool MustRefreshPath { get; set; }
private void Awake()
{
_myTransform = transform;
_sqrMoveThreashold = PathUpdateMoveThreashold * PathUpdateMoveThreashold;
_arrive = GetComponent <Arrive>();
_steering = GetComponent <SteeringBasics>();
}
public void Init(Legs legs,Grid grid)
{
base.Init(legs);
this.grid = grid;
this.auxiliarySteering = new Arrive();
this.auxiliarySteering.Init(getLegs());
}
public override IEnumerator Enter(Machine owner, Brain controller)
{
mainMachine = owner;
myBrain = controller;
Legs myLeg = myBrain.legs;
//get sheep target
sheepTarget = myBrain.memory.GetValue<SensedObject>("hasCommand");
sheepBrain = (Brain)sheepTarget.getObject().GetComponent("Brain");
sheepMemory = sheepBrain.memory;
sheepMemory.SetValue("BeingEaten", true);
arriveBehaviour = new Arrive();
arriveBehaviour.Init(myLeg);
arriveBehaviour.setTarget(sheepTarget.getObject());
//speed is zero
myBrain.legs.maxSpeed = 0f;
Debug.Log("I'm eating:" + sheepTarget.getObject() + " HP: " + sheepMemory.GetValue<float>("HP"));
yield return null;
}
public override void Enter()
{
Arrive a = owner.GetComponent <Arrive>();
a.targetPosition = owner.GetComponent <FighterController>().myBase.transform.position;
a.enabled = true;
}
public override void Init()
{
base.Init();
g = GrafoManager.GetComponent <AEstrella>().GetGrafo();
arrive = transform.GetComponent <Arrive> ();
arrive.Init();
}
//Seek like behavior with arrive
public PathFollow(Transform owned, float accelTime, float maxSpeed, float maxAccel, float followDistance, Vector2[] path)
{
arrive = new Arrive(owned, 0, 0, accelTime, maxSpeed, maxAccel);
this.owned = owned;
this.followDistance = followDistance;
this.path = path;
}
public void PickTargetBase()
{
target = BaseSingleton.Instance.GetRandomTarget(_parentBase);
Arrive arrive = GetComponent <Arrive>();
arrive.targetGameObject = target.gameObject;
}
/// <summary>
/// Update behavoir on current mode
/// </summary>
private void UpdateDataCubeBehavoir()
{
List <IBehavor> behavors = GetBehavoirs(m_DataCubeBehavoirs[DataCubeStatus]);
ObjectAvoidance objectAvoidance = null;
Arrive arrive = null;
if (m_ObjectAvoidanceActive)
{
objectAvoidance = new ObjectAvoidance(m_Radius, LayerMask);
objectAvoidance.Label = BehaviorEnum.ObjectAvoid.ToString();
behavors.Add(objectAvoidance);
}
if (m_ArriveActive)
{
if (m_Target != null)
{
arrive = new Arrive(m_Target.transform);
arrive.Label = "Arrive";
behavors.Add(arrive);
}
}
if (behavors.Count > 0)
{
m_Steering.SetBehaviors(objectAvoidance, arrive, behavors, behavors[0].Label);
}
else
{
m_Steering.SetBehaviors(objectAvoidance, arrive, behavors, "No Behavoir");
}
}
// Use this for initialization
private void Awake()
{
_facingCosineVal = Mathf.Cos(FacingCosine * Mathf.Deg2Rad);
_steeringBasics = GetComponent <SteeringBasics>();
_arrive = GetComponent <Arrive>();
SteeringBasics.RbConstraints(GetComponent <Rigidbody>());
}
protected override void OnEnter()
{
_arrive = Steering.GetBehaviour <Arrive>();
_arrive.enabled = true;
_arrive.Target = _food.transform;
// _arrive.MoveToFront();
}
/// <summary>
/// Occurs when the entity enters to this state.
/// </summary>
public override void Enter()
{
AI.MyTeam.PassReceiver = Player;
AI.MyTeam.ControllingPlayer = Player;
SteeringBehavior = new Arrive(Player, 1, 1.0, PassTarget);
Player.SteeringBehaviorsManager.AddBehavior(SteeringBehavior);
}
public void SetParentTarget()
{
Arrive arrive = GetComponent <Arrive>();
arrive.targetGameObject = _parentBase.gameObject;
target = _parentBase.transform;
}
private float restingTime; // time elapsed since resting time started
void Start()
{
// get the steerings that are going to be used by this FSM
arrive = GetComponent <Arrive>();
if (arrive == null)
{
Debug.LogError(gameObject + " has no Arrive attached in " + this);
}
pursue = GetComponent <Pursue>();
if (pursue == null)
{
Debug.LogError(gameObject + " has no Pursue attached in " + this);
}
// get the internal state + world representation (the "BLACKBOARD")
blackboard = GetComponent <BATCAT_Blackboard>();
if (blackboard == null)
{
blackboard = gameObject.AddComponent <BATCAT_Blackboard>();
}
arrive.enabled = false;
pursue.enabled = false;
}
// Start is called before the first frame update
void Start()
{
mySeek = new Seek();
mySeek.character = this;
mySeek.target = target;
myFlee = new Flee();
myFlee.character = this;
myFlee.target = target;
myArrv = new Arrive();
myArrv.character = this;
myArrv.target = target;
myAlgn = new Align();
myAlgn.character = this;
myAlgn.target = target;
myFace = new Face();
myFace.character = this;
myFace.target = target;
myLWYG = new LookWhereGoing();
myLWYG.character = this;
myLWYG.target = target;
myFPth = new FollowPathDemo();
myFPth.character = this;
myFPth.path = waypointList;
//myFPth.target = target;
}
// Start is called before the first frame update
void Start()
{
kinematic = GetComponent <Kinematic>();
arrive = new Arrive();
arrive.character = kinematic;
arrive.target = kinematic;
}
public static Machine WanderAroundSpot(GameObject owner, GameContext game)
{
var transform = owner.Components.Get <TransformComponent>();
var map = game.SceneManager.Current.FindGameObjectByName(ObjectNames.Map);
var mapRenderer = map.Components.Get <MapRenderComponent>();
var startTile = mapRenderer.GetTileAt(transform.World.Position);
var idle = new Idle(owner, 2000f);
var arrive = new Arrive(owner);
var machine = new Machine(new State[]
{
idle,
arrive
});
machine.AddTransition(idle, arrive, s => s.IsCompleted, s =>
{
var currTile = mapRenderer.GetTileAt(transform.World.Position);
var isStartTile = currTile == startTile;
var destTile = isStartTile ? mapRenderer.Map.GetRandomEmptyTile(startTile, 5) : startTile;
var a = s as Arrive;
a.SetDestination(destTile);
});
machine.AddTransition(arrive, idle, s => s.IsCompleted, s =>
{
idle.SetDuration(MathUtils.Random.NextSingle() * 5000f);
});
return(machine);
}
public static Steering GetSteering(Agent target, Agent npc, float maxDist, float distanceBoundary, float maxAccel, float evadePrediction, float faceTimeToTarget)
{
float minDist = maxDist;
Vector3 bestHidingSpot = Vector3.zero;
bool changed = false;
LayerMask obstacleMask = LayerMask.GetMask("Wall");
Collider[] hits = Physics.OverlapSphere(npc.position, minDist + distanceBoundary + 0.5f, obstacleMask);
foreach (Collider coll in hits)
{
Vector3 hidingSpot = Hide.GetHidingPosition(coll.GetComponent <Body>(), npc.interiorRadius, target.position, distanceBoundary);
float distance = Vector3.Distance(hidingSpot, npc.position);
if (distance < minDist)
{
minDist = distance;
bestHidingSpot = hidingSpot;
changed = true;
}
}
if (changed == false)
{
return(Evade.GetSteering(target, npc, maxAccel, evadePrediction, true));
}
else
{
return(Arrive.GetSteering(bestHidingSpot, npc, npc.exteriorRadius, maxAccel));
}
}
public PathFollow(Arrive arrive, float followDistance, Vector2[] path)
{
this.arrive = arrive;
this.owned = arrive.tf;
this.followDistance = followDistance;
this.path = path;
}
public static Arrive GetInstance()
{
if (instance == null)
{
instance = new Arrive();
}
return(instance);
}
void Start()
{
flockWander = GetComponent <FSM_SHEEP_FlockWandering>();
arrive = GetComponent <Arrive>();
blackboard = GetComponent <SHEEP_Blackboard>();
arrive.enabled = false;
flockWander.enabled = false;
}
public void Awake()
{
TraversalMargin = 3;
movingEntity = GetComponent <MovingEntity>();
aiController = GetComponent <AiController>();
seek = GetComponent <Seek>();
arrive = GetComponent <Arrive>();
}
public override void Enter()
{
arrive = owner.GetComponent <Arrive>();
// Vector3 newTarget = Player.instance.transform.position + Player.instance.transform.forward*10f;
// newTarget.y = 0f;
// arrive.targetPosition = newTarget;
}
// Start is called before the first frame update
void Start()
{
moveType = new Arrive();
moveType.character = this;
moveType.target = target;
mouse = this.gameObject;
}
public override void Enter()
{
_controller = owner.GetComponent <DogController>();
_arrive = owner.GetComponent <Arrive>();
// play dog bark on state enter
owner.gameObject.GetComponent <AudioSource>().Play();
}
public override void Enter()
{
_controller = owner.GetComponent <DogController>();
_arrive = owner.GetComponent <Arrive>();
// set the target to the players ball drop target
_arrive.targetGameObject = _controller.player.GetComponent <PlayerController>().dogTarget.gameObject;
}
void FixedUpdate()
{
var targetPosition = _enemy.PathFollower.transform.position + _enemy.PathFollower.offsetTranslation;
var steeringForce = Arrive.Calculate(transform.position, _enemy.Rigidbody.velocity, targetPosition, MaxSpeed);
_enemy.Rigidbody.AddForce(steeringForce, ForceMode.Acceleration);
}
private void Start()
{
kinematic = GetComponent <Kinematic>();
switch (moveType)
{
case SteeringType.Pursue:
pursueAI = new Pursue();
pursueAI.character = kinematic;
pursueAI.target = target;
break;
case SteeringType.Evade:
evadeAI = new Evade();
evadeAI.character = kinematic;
evadeAI.target = target;
break;
case SteeringType.FollowPath:
followAI = new PathFollow();
followAI.character = kinematic;
followAI.path = pathOfObjects;
break;
case SteeringType.Seek:
seekAI = new Seek();
seekAI.character = kinematic;
seekAI.target = target;
break;
case SteeringType.Flee:
fleeAI = new Flee();
fleeAI.character = kinematic;
fleeAI.target = target;
break;
case SteeringType.Seperation:
seperationAI = new Seperation();
seperationAI.character = kinematic;
seperationAI.targets = seperateObstacles;
break;
case SteeringType.Arrive:
arriveAI = new Arrive();
arriveAI.character = kinematic;
arriveAI.target = target;
break;
}
switch (lookType)
{
case LookType.Align:
alignAI = new Align();
alignAI.character = kinematic;
alignAI.target = target;
break;
}
}
// Update is called once per frame
void Update()
{
// update my position and rotation
this.transform.position += linearVelocity * Time.deltaTime;
Vector3 v = new Vector3(0, angularVelocity, 0);
this.transform.eulerAngles += v * Time.deltaTime;
// update linear and angular velocities
SteeringOutput steering = new SteeringOutput();
if (behaviorType == "Seek" || behaviorType == "seek")
{
Seek mySeek = new Seek();
mySeek.character = this;
mySeek.target = myTarget;
steering = mySeek.getSteering();
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
else if (behaviorType == "Flee" || behaviorType == "flee")
{
Flee myFlee = new Flee();
myFlee.character = this;
myFlee.target = myTarget;
steering = myFlee.getSteering();
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
else if (behaviorType == "Arrive" || behaviorType == "arrive")
{
Arrive myArrive = new Arrive();
myArrive.character = this;
myArrive.target = myTarget;
steering = myArrive.getSteering();
if (steering != null)
{
linearVelocity += steering.linear * Time.deltaTime;
angularVelocity += steering.angular * Time.deltaTime;
}
else
{
linearVelocity = Vector3.zero;
}
}
//Align myAlign = new Align();
//myAlign.character = this;
//myAlign.target = myTarget;
//steering = myAlign.getSteering();
//if (steering != null)
//{
// linearVelocity += steering.linear * Time.deltaTime;
// angularVelocity += steering.angular * Time.deltaTime;
//}
}
void Start()
{
fsmCivilianFollowsMarine = GetComponent <FSM_CIVILIAN_FOLLOWS_MARINE>();
arrive = GetComponent <Arrive>();
blackboard = GetComponent <CIVILIAN_BlackBoard>();
fsmCivilianFollowsMarine.enabled = false;
arrive.enabled = false;
}
//public bool MustRefreshPath { get; set; }
private void Awake()
{
_pathRequestManager = GameObject.Find("PathfindingA").GetComponent <PathRequestManager>();
_myTransform = transform;
_sqrMoveThreashold = PathUpdateMoveThreashold * PathUpdateMoveThreashold;
_arrive = GetComponent <Arrive>();
_steering = GetComponent <SteeringBasics>();
}
/// <summary>
/// Creates a new instance
/// </summary>
public Behaviors()
{
Alignment = new Alignment();
Arrive = new Arrive();
Cohesion = new Cohesion();
Evade = new Evade();
Flee = new Flee();
Hide = new Hide();
Interpose = new Interpose();
ObstacleAvoidance = new ObstacleAvoidance();
OffsetPursuit = new OffsetPursuit();
PathFollowing = new PathFollowing();
Pursuit = new Pursuit();
Seek = new Seek();
Separation = new Separation();
WallAvoidance = new WallAvoidance();
Wander = new Wander();
}
public override void init()
{
if(objectRegistry) {
objectRegistry.RegisterObject(new SensableObject(gameObject, AgentClassification.Sheep));
}
seekBehaviour = new Arrive();
seekBehaviour.Init (this);
//separation = new Separation();
//separation.Init (this);
//cohesion = new Cohesion();
//cohesion.Init (this);
//alignment = new Alignment();
//alignment.Init (this);
random = new RandomWalk(0.6f, 1, 2);
random.Init (this);
// By name
var go = GameObject.Find("SheepTarget");
seekBehaviour.setTarget (go);
this.addSteeringBehaviour(seekBehaviour);
//this.addSteeringBehaviour(separation);
//this.addSteeringBehaviour(cohesion);
//this.addSteeringBehaviour(alignment);
this.addSteeringBehaviour(random);
}
protected void enemyStart(){
characterStart ();
sphere.renderer.material.color = Color.red;
grid = (Grid)GameObject.FindObjectOfType (typeof(Grid));
pathing = (PathFinding)GameObject.FindObjectOfType (typeof(PathFinding));
experienceBase = 25;
xpGiven = false;
lootGiven = false;
lootFactory = GameObject.FindObjectOfType<LootFactory> ();
// networking: makes sure each enemy is properly instantiated even on another game instance that didn't run the EnemyFactory code.
target = (Fighter) GameObject.FindObjectOfType (typeof (Fighter)); // for the enemies perspective target is always fighter
sorcerer = (Sorcerer)SorcererInstanceManager.getSorcerer (); // sorcerer = (Sorcerer) GameObject.FindObjectOfType (typeof (Sorcerer));
level = target.level;
initializePrimaryStats();
initializeSecondaryStatsBase();
initializeSecondaryStats();
calculateSecondaryStats();
health = maxHealth;
energy = maxEnergy;
activeSkill1 = (BasicMelee)GetComponent<BasicMelee>();
this.transform.parent = GameObject.Find("Enemies").transform;
// networking:
enemyNetworkScript = (EnemyNetworkScript)GetComponent<EnemyNetworkScript> ();
collider = GetComponent<CapsuleCollider>();
wanderScript = GetComponent<Wander> ();
arriveScript = GetComponent<Arrive> ();
}
void Awake()
{
steeringAgent = GetComponent<SteeringAgent>();
steeringSeek = GetComponent<Seek>();
steeringArrive = GetComponent<Arrive>();
//steeringFlee = GetComponent<SteeringFlee>();
//steeringWander = GetComponent<SteeringWander>();
steeringAgent.enabled = true;
//Wander();
InitBT();
bt.Start();
}
// Use this for initialization
protected virtual void Start()
{
graph = GetComponent<Graph> ();
agent = GetComponent<SteeringAgent> ();
seekScript = GetComponent<Seek> ();
arriveScript = GetComponent<Arrive> ();
characterNode = GetComponent<Node> ();
openList = new List<Node>();
closedList = new List<Node>();
path = new List<Node> ();
pathIndex = 0;
DontDestroyOnLoad (gameObject);
}
protected void characterStart(){
//script of same GameObject initiation
seekScript = GetComponent<Seek> ();
arriveScript = GetComponent<Arrive> ();
steeringScript = GetComponent<SteeringAgent> ();
alignScript = GetComponent<Align> ();
ai = GetComponent<SorcererAI>();
playerNetworkScript = GetComponent<CharacterNetworkScript>();
basicAttackScript = GetComponent<BasicAttack> ();
sphere = GameObject.CreatePrimitive (PrimitiveType.Sphere);
sphere.renderer.castShadows = false;
sphere.renderer.receiveShadows = false;
sphere.transform.parent = transform;
sphere.transform.localScale = new Vector3 (1.0f, 1.0f, 1.0f);
sphere.gameObject.layer = LayerMask.NameToLayer ("Minimap");
accuracy = 0.8f;
attacking = false;
stopMoving ();
}
public void Awake()
{
TraversalMargin = 3;
movingEntity = GetComponent<MovingEntity>();
aiController = GetComponent<AiController>();
seek = GetComponent<Seek>();
arrive = GetComponent<Arrive>();
}
