//Creates Trees beside the road with "density". public static void Create(VertexPath path, float density) { float length = path.length; float distInterval = length / density; for (int i = 0; i < density; i++) { Vector3 offset = Vector3.right * 28f; Vector3 pos = path.GetPointAtDistance(distInterval * i) + Vector3.forward * Random.Range(-5f, 5f); int rand = Random.Range(1, 5); for (int j = 0; j < rand; j++) { offset.x += j * 10f; pos += offset; Instantiate(instance.Tree, pos, Quaternion.identity); } rand = Random.Range(1, 5); offset = Vector3.left * 28f; pos = path.GetPointAtDistance(distInterval * i) + Vector3.forward * Random.Range(-5f, 5f); for (int j = 0; j < rand; j++) { offset.x += -j * 10f; pos += offset; Instantiate(instance.Tree, pos, Quaternion.identity); } } }
private void GenerateLeaves() { lastLeafPosition.Clear(); lastLeafRotation.Clear(); foreach (Transform child in Leaves.transform) { GameObject.Destroy(child.gameObject); } for (int i = 0; i < LeafAmount; ++i) { GameObject leaf = Instantiate(LeafPrefab, Leaves.transform); Vector3 tempPosition = stemPath.GetPointAtDistance(1f / LeafAmount * i * 10); Vector3 tempRotation = stemPath.GetNormalAtDistance(1f / LeafAmount * i * 10); leaf.transform.position = tempPosition; float normalAngle = Vector3.Angle(tempRotation, Vector3.right); normalAngle = tempRotation.y > 0 ? normalAngle : -normalAngle; float[] currAngle = new float[] { Random.Range(0, 360), normalAngle }; leaf.transform.Rotate(new Vector3(0, currAngle[0], currAngle[1])); lastLeafPosition.Add(tempPosition); lastLeafRotation.Add(currAngle); } lastLeafAmount = LeafAmount; stemPath = StemSpline.GetComponent <PathCreator>().path; }
private void UpdateBallPosition(float distanceTraveled) { var pathPointPosition = _path.GetPointAtDistance(distanceTraveled + _config.StartOffset.Value); var pathPointRotation = _path.GetRotationAtDistance(distanceTraveled + _config.StartOffset.Value); var position = pathPointPosition + Vector3.up * 0.5f + Vector3.right * _onRoadPos * 2f; var rotationAngles = new Vector3( transform.rotation.eulerAngles.x, pathPointRotation.eulerAngles.y, transform.rotation.eulerAngles.z); transform.SetPositionAndRotation(position, Quaternion.Euler(rotationAngles)); Position = position; }
void Update() { _distanceTravelled += _speed * Time.deltaTime; var travelPercent = _distanceTravelled / _path.length; if (travelPercent > _startToFleePercent) { _startToFleeParticle.gameObject.SetActive(true); } if (travelPercent >= 1f) { OnDuckFlee?.Invoke(this); _OnDuckFlee.Invoke(); Destroy(gameObject); return; } transform.position = _path.GetPointAtDistance(_distanceTravelled); var forward = _path.GetDirectionAtDistance(_distanceTravelled); var rot = Quaternion.LookRotation(forward, Vector3.up); transform.rotation = rot; }
void Generate() { if (pathCreator != null && CheckPrefabArray() != false && planksHolder != null) { DestroyObjects(); VertexPath path = pathCreator.path; spacing = Mathf.Max(minSpacing, spacing); float dst = 0; while (dst < path.length) { Vector3 point = path.GetPointAtDistance(dst); Quaternion rot = path.GetRotationAtDistance(dst); Instantiate(prefabArray[Random.Range(0, prefabArray.Length)], point, rot, planksHolder.transform); dst += spacing; } /*if (anchorPrefab != null && anchorsHolder != null) * { * AddAnchor(0.0f, anchorSpacing , -anchorOffset); * // TODO : Looking at the source code, if the distance is 0 or Path.Lenght that will * // yield the same thing, because of the EndOfPathInstruction.Loop * // some weird shit, but it is what it is, i could implement an overload to pass a .stop * // but maybe other day * AddAnchor(path.length-0.01f, anchorSpacing, anchorOffset); * } */ SetHingesJoints(); } }
private void Update_Internal(float delta) { if (!stopped) { if (pathCreator != null) { path = pathCreator.path; } if (path == null) { return; } distanceTravelled += speed * delta; transform.position = path.GetPointAtDistance(distanceTravelled, endOfPathInstruction); if (updateRotation) { if (useDirectionToRotate) { var rot = path .GetDirectionAtDistance(distanceTravelled, endOfPathInstruction).LookRotation(); rot.Set(x: 0, z: 0); transform.rotation = rot; } else { transform.rotation = path.GetRotationAtDistance(distanceTravelled, endOfPathInstruction); } } } }
private void OnValidate() { if (obstacles == null) { obstacles = new List <GameObject>(); } if (pathCreator == null) { pathCreator = GetComponent <PathCreator>(); } if (prefab != null) { ClearObstacles(); if (container == null) { container = transform; } VertexPath path = pathCreator.path; if (distance >= 0.5f) { for (float i = 0f; i < path.length; i += distance) { obstacles.Add(Instantiate(prefab, path.GetPointAtDistance(i), rotate ? path.GetRotationAtDistance(i) : Quaternion.identity, container)); } } } }
public static void GetPath(List <Vector3> points, bool isClosed, PathSpace space, ref List <Vector3> results, float step) { results.Clear(); if (points.Count < 2) { Debug.LogError("Path requires at least 2 anchor points."); return; } var bezierPath = new BezierPath(points, isClosed, space); var vertexPath = new VertexPath(bezierPath, 0.3f, 0.01f); float length = vertexPath.length; float distance = 0; while (distance <= length) { Vector3 pos = vertexPath.GetPointAtDistance(distance, EndOfPathInstruction.Stop); results.Add(pos); distance += step; } }
public void AddObstacle(int index) { if (NextDistance > path.length) { ++cont; NextDistance = NextDistance % path.length; } if (NextDistance > middle_point) { half = 1; } else { half = 0; } string name = "Obstacles" + cont + half; GetParentObject(name); Vector3 position = path.GetPointAtDistance(NextDistance, endOfPathInstruction); Vector3 upward = path.GetDirectionAtDistance(NextDistance, endOfPathInstruction); Vector3 forward = path.GetNormalAtDistance(NextDistance, endOfPathInstruction); Quaternion rotation = Quaternion.LookRotation(forward, upward); Instantiate(obstacles[index], position, rotation, obstacles_object.transform); NextDistance += DistanceGap; }
//private void Update() //{ // counterColor += Time.deltaTime; // if (counterColor > 20) counterColor = 0; // startMat.color = Color.HSVToRGB(counterColor / 20, .33f, 1); //} public void Generate(float dst) { if (pathCreator != null && prefab != null && holder != null) { //DestroyObjects (); VertexPath path = pathCreator.path; Vector3 point = path.GetPointAtDistance(dst); Quaternion rot = path.GetRotationAtDistance(dst); index++; if (index >= Walls.Count) { index = 0; } dir *= -1; Walls[index].GetChild(0).GetComponent <MeshRenderer>().material = startMat; Walls[index].position = point; Walls[index].rotation = rot; Walls[index].transform.GetChild(0).localPosition = new Vector3(-0.5f, 0.4f * dir, 0); } }
void Generate() { if (pathCreator != null && prefab != null && holder != null) { DestroyObjects(); VertexPath path = pathCreator.path; spacing = Mathf.Max(minSpacing, spacing); float dst = 0; while (dst < path.length) { Vector3 point = path.GetPointAtDistance(dst); Quaternion rot = path.GetRotationAtDistance(dst); if (count % 2 == 0) { Instantiate(prefab[0], point, rot, holder.transform); } else { Instantiate(prefab[1], point, rot, holder.transform); } dst += spacing; count++; } } }
void Update() { if (path != null) { dstTravelled += speed * Time.deltaTime; transform.position = path.GetPointAtDistance(dstTravelled); } }
//create the random pattern private void InstantiateTheRandom(GameObject prefab, GameObject holder) { Vector3 point = _path.GetPointAtDistance(_dst); Quaternion rot = _path.GetRotationAtDistance(_dst); Instantiate(prefab, point + Vector3.up, rot, holder.transform); _dst += varStorge.spacingBtwObsticale; }
public override void OnUpdate(float deltaTime) { base.OnUpdate(deltaTime); if (!isActive) { return; } if (enemyState == EnemyState.die) { return; } CheckDirFollowPlayer(myPath.GetPointAtDistance(myPath.length, EndOfPathInstruction.Stop).x); distanceTravelled += speed * deltaTime; transform.position = myPath.GetPointAtDistance(distanceTravelled, EndOfPathInstruction.Stop); if (transform.position == myPath.GetPointAtDistance(myPath.length, EndOfPathInstruction.Stop)) { gameObject.SetActive(false); } }
private void generateCheckpoints() { GameObject startpoint = Resources.Load <GameObject>("Startpoint"); GameObject checkpoint = Resources.Load <GameObject>("Checkpoint"); PathCreator pc = GetComponent <PathCreator>(); if (checkpointHolder == null) { GameObject obj = new GameObject(); obj.name = "Checkpoints"; checkpointHolder = obj; } VertexPath path = pc.path; numCheckpoints = Mathf.Clamp((int)path.length / 10, 4, 10); float spacing = path.length / numCheckpoints; float dst = 0; dst += spacing; while (dst < path.length) { Vector3 point = path.GetPointAtDistance(dst); Quaternion rot = path.GetRotationAtDistance(dst) * Quaternion.Euler(90, 0, 90); Instantiate(checkpoint, point, rot, checkpointHolder.transform); dst += spacing; } // Startpoint: // Add the startpoint last since its the last checkpoint technically Vector3 point_start = path.GetPointAtDistance(0); Quaternion rot_start = path.GetRotationAtDistance(0) * Quaternion.Euler(90, 0, 90); Instantiate(startpoint, point_start, rot_start, checkpointHolder.transform); }
public bool AnimatePath() { //if (!obj) //return; t += Time.deltaTime * speed; obj.position = path.GetPointAtDistance(t, EndOfPathInstruction.Stop); obj.rotation = path.GetRotationAtDistance(t, EndOfPathInstruction.Stop); if (path.length > t) { return(false); } return(true); }
void Update() { if (currentPath != null) { CheckFront(); dstTravelled += CalculateSpeed() * Time.deltaTime; transform.position = currentPath.GetPointAtDistance(dstTravelled, EndOfPathInstruction.Stop); Quaternion newRot = currentPath.GetRotationAtDistance(dstTravelled, EndOfPathInstruction.Stop); transform.eulerAngles = new Vector3(0, newRot.eulerAngles.y - 180, 0); if (Vector3.Distance(transform.position, currentPath.GetPoint(.9999f)) <= .05f) { UpdateRoadAndPath(); } } }
//Update is called once per frame void Update() { var vehilcesToTransfer = new Dictionary <Vehicle, Node>(); var vehiclesToRemove = new List <Vehicle>(); foreach (var vehicle in vehicles) { var info = CreateRoadInfoForVehicle(vehicle); vehicle.UpdatePosition(info); if (vehicle.distanceOnCurrentRoadSegment > consequent.Find(c => c.node == vehicle.intermediateTarget.Current).path.length) { if (vehicle.intermediateTarget.Current.consequent.Count == 0 || vehicle.IsRouteFinished()) { SimulationManager.SpawnManager.NotifyVehicleRouteFinished(vehicle); vehiclesToRemove.Add(vehicle); } else { var nextHop = vehicle.GetNextTargetNode(); vehilcesToTransfer.Add(vehicle, vehicle.intermediateTarget.Current); vehicle.MoveOnPath(); vehicle.distanceOnCurrentRoadSegment = 0; } } else { VertexPath path = consequent.Find(c => c.node == vehicle.intermediateTarget.Current).path; vehicle.transform.position = path.GetPointAtDistance(vehicle.distanceOnCurrentRoadSegment, EndOfPathInstruction.Stop) + new Vector3(0, 0, -3); vehicle.transform.rotation = path.GetRotationAtDistance(vehicle.distanceOnCurrentRoadSegment, EndOfPathInstruction.Stop); } } foreach (var pair in vehilcesToTransfer) { vehicles.Remove(pair.Key); pair.Value.vehicles.Add(pair.Key); } foreach (var item in vehiclesToRemove) { vehicles.Remove(item); SimulationManager.VehicleManager.Delete(item); } }
IEnumerator Following(VertexPath path) { Vector3 lastPoint = path.GetPointAtTime(1f, EndOfPathInstruction.Stop); float befDist = 0.5f; if (stopped == false) { while (DistanceXZ(transform.position, lastPoint) > 0.5f) { float distance = Vector3.Distance(this.transform.position, lastPoint); if (distance < stopDistance) { stopped = true; body.velocity = Vector3.zero; } body.velocity = Vector3.ClampMagnitude(body.velocity, maxSpeed); body.AddForce(transform.forward * followSpeed, ForceMode.VelocityChange); float dist = path.GetClosestDistanceAlongPath(transform.position); if (dist < befDist) { dist = befDist; } else { befDist = dist; } Vector3 nextPoint = path.GetPointAtDistance(dist + followSpeed, EndOfPathInstruction.Stop); Vector3 diff = nextPoint - transform.position; diff.y = 0; diff.Normalize(); Debug.DrawLine(transform.position, nextPoint, Color.red); Debug.DrawRay(transform.position, diff, Color.gray); float angle = Mathf.Atan2(diff.x, diff.z) * Mathf.Rad2Deg; transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.AngleAxis(angle, Vector3.up), rotateSpeed * Time.fixedDeltaTime); yield return(new WaitForFixedUpdate()); } body.velocity = Vector3.zero; } }
private INode[] GenerateNodes() { VertexPath path = Road.path; List <INode> allNodes = new List <INode>(); nodeSpacing = Mathf.Max(NODE_MIN_SPACING, nodeSpacing); float distance = 0; int nodesPerAnchor = 3; // Create all nodes while (distance < path.length) { Vector3 centre = path.GetPointAtDistance(distance, TrackType); Vector3 normal = path.GetNormalAtDistance(distance, TrackType); Vector3 forward = Road.path.GetDirectionAtDistance(distance, TrackType); distance += nodeSpacing; allNodes.Add(new Node(centre + normal * (RoadWidth - nodesRoadEdgeOffset) * -1, forward, allNodes.Count)); allNodes.Add(new Node(centre, forward, allNodes.Count)); allNodes.Add(new Node(centre + normal * (RoadWidth - nodesRoadEdgeOffset), forward, allNodes.Count)); if (distance > path.length - nodeSpacing) { break; } } // Fill node connections for (int i = 0; i < allNodes.Count; i++) { allNodes[i].Connections = new int[nodesPerAnchor]; int neighbourIndexOffset = nodesPerAnchor - i % nodesPerAnchor; for (int j = 0; j < nodesPerAnchor; j++) { int connectionIndex = (i + j + neighbourIndexOffset) % allNodes.Count; allNodes[i].Connections[j] = allNodes[connectionIndex].ID; } } return(allNodes.ToArray()); }
private void FixedUpdate() { for (int i = 0; i < AICars.Length; i++) { Vector3 nextPoint = path.GetPointAtDistance(path.GetClosestDistanceAlongPath(AICars[i].transform.position) + AICars[i].AIDistanceFactor); float signedAngle = Vector2.SignedAngle(AICars[i].transform.up, nextPoint - AICars[i].transform.position); bool invert = false; if (Mathf.Abs(signedAngle) < 107) { AICars[i].Forward(); } else { AICars[i].Backward(); invert = true; } if (signedAngle > 5) { if (!invert) { AICars[i].Left(); } else { AICars[i].Right(); } } else if (signedAngle < -5) { if (!invert) { AICars[i].Right(); } else { AICars[i].Left(); } } } }
void Generate() { if (pathCreator != null && prefab != null && holder != null) { DestroyObjects(); VertexPath VertexPath = pathCreator.VertexPath; spacing = Mathf.Max(minSpacing, spacing); float dst = 0; while (dst < VertexPath.length) { Vector3 point = VertexPath.GetPointAtDistance(dst); Quaternion rot = VertexPath.GetRotationAtDistance(dst); Instantiate(prefab, point, rot, holder.transform); dst += spacing; } } }
public void GenerateTube(bool file) { string name = "Tube"; var generated_tranform = transform.Find(name); if (generated_tranform != null) { DestroyImmediate(generated_tranform.gameObject); Debug.Log("destroyed"); } tube = Create(name, gameObject); Debug.Log("create tube"); PathCreator path_creator = gameObject.GetComponent <PathCreator>(); if (path_creator != null) { VertexPath path = path_creator.path; /*if (file) * { * BezierPath bp = path_creator.LoadPath(); * path = new VertexPath(bp, transform); * } * else * { * path = path_creator.path; * }*/ Debug.Log("got path"); for (float distance = 0; distance < path.length; distance += 0.2f) { Vector3 position = path.GetPointAtDistance(distance, endOfPathInstruction); Vector3 upward = path.GetDirectionAtDistance(distance, endOfPathInstruction); Vector3 forward = path.GetNormalAtDistance(distance, endOfPathInstruction); Quaternion rotation = Quaternion.LookRotation(forward, upward); Instantiate(segment, position, rotation, tube.transform); } } }
// Start is called before the first frame update void Start() { // randomly pick a color and get the trail/ball combination for the color if (survival) { random = Random.Range(0, Min(balls.Length, trails.Length)); } else { random = Random.Range(1, Min(balls.Length, trails.Length)); } trail = trails[random]; ball = balls[random]; Vector3[] points = { start, middle, end }; path = new VertexPath(new BezierPath(points), transform); trail = Instantiate(trail, path.GetPointAtDistance(0), path.GetRotationAtDistance(0)); startHole = Instantiate(holePrefabStart, start, startRotation); endHole = Instantiate(holePrefabEnd, end, endRotation); travelDst = 0; spawned = false; }
private void SetPositionOnDistance() { float mag = Joystick.GetMagnitude() / InputSensitivity; Quaternion rot = Track.GetRotationAtDistance(Dist); Player.rotation = Quaternion.Euler(rot.eulerAngles.x, rot.eulerAngles.y, 0f); transform.rotation = Quaternion.Lerp(transform.rotation, Track.GetRotationAtDistance(Dist), CameraRotationSmoothing * Time.deltaTime); transform.rotation = Quaternion.Euler(transform.eulerAngles.x, transform.eulerAngles.y, 0f); Move = Track.GetPointAtDistance(Dist) + Vector3.up / 10f; transform.position = Move; Move = PlayerPos + Vector3.right * mag; Player.localPosition = Vector3.MoveTowards(Player.localPosition, Move, SideSpeed * Time.deltaTime); Player.localPosition = Vector3.ClampMagnitude(Player.localPosition, 3.5f); Car.position = Vector3.MoveTowards(Car.position, Player.position, Time.deltaTime * Speed); Car.LookAt(Player.position); }
void Generate() { if (pathCreator != null && holder != null)//(pathCreator != null && prefab != null && holder != null) { DestroyObjects(); VertexPath path = pathCreator.path; spacing = Mathf.Max(minSpacing, spacing); float dst = 0; while (dst < path.length) { if (dst == 0 || dst < initialstartspawn) { dst += spacing; //in starting add diamond collection for more interactive } else { if (dst < path.length - 75) { Vector3 point = path.GetPointAtDistance(dst); Quaternion rot = path.GetRotationAtDistance(dst); Instantiate(prefab[Random.Range(0, randommax)], point, rot, holder.transform); } dst += spacing; // Debug.Log(path.GetPointAtDistance(dst)); } /* Vector3 point = path.GetPointAtDistance (dst); * Quaternion rot = path.GetRotationAtDistance (dst); * Instantiate (prefab[Random.Range(0,7)], point, rot, holder.transform); * dst += spacing;*/ } } }
private void Init(VertexPath path, int density) { float length = path.length; float distInterval = length / density; for (int i = 0; i < density; i++) { int rand = Random.Range(0, 2); float dir = LevelGenerator.instance.RoadWidth / 2.5f; if (rand == 1) { dir = -dir; } Vector3 offset = new Vector3(dir, 0.2f, 0f); Vector3 pos = path.GetPointAtDistance(distInterval * i) + offset; Quaternion rot = path.GetRotationAtDistance(distInterval * i); GameObject go = Instantiate(CarPrefab, pos, Quaternion.Euler(rot.eulerAngles.x, rot.eulerAngles.y, 0f)); go.AddComponent <EntityMover>().Init(path, distInterval * i, offset, Mathf.Sign(dir), Random.Range(20f, 30f), Random.Range(2f, 6f)); go.AddComponent <HitTrigger>(); } }
//public override void CollectObservations(VectorSensor sensor) //{ // // # Basic information // Rigidbody rBody = GetComponent<Rigidbody>(); // // Agent positions & velocity // sensor.AddObservation(this.transform.localPosition); // sensor.AddObservation(rBody.velocity); // // # Collect Path's observations // float centerDistance = vertexPath.GetClosestDistanceAlongPath(this.transform.localPosition); // for (int d = tickerStart; d <= tickerEnd; d++) // { // float distance = centerDistance + d * tickerSpace; // Vector3 point = vertexPath.GetPointAtDistance(distance, EndOfPathInstruction.Loop); // Vector3 normal = vertexPath.GetNormalAtDistance(distance, EndOfPathInstruction.Loop); // AddObservationInXYZMode(sensor, point); // AddObservationInXYZMode(sensor, normal); // } // // # Padding observations // // If custom setting will have too more observations and cause the buffer overflow, We // // must warn user (in Pyhon interface level). // // Here we are padding the observation buffer with all zero // int MaxObservationSize = GetComponent<BehaviorParameters>().BrainParameters.VectorObservationSize; // for (int i = 0; i < MaxObservationSize - ObservationSize; i++) // sensor.AddObservation(0); //} public override void CollectObservations(VectorSensor sensor) { // # Basic information Rigidbody rBody = GetComponent <Rigidbody>(); // Agent velocity sensor.AddObservation(this.transform.localPosition); sensor.AddObservation(rBody.velocity); // # Collect Path's basic information float centerDistance = vertexPath.GetClosestDistanceAlongPath(this.transform.localPosition); Vector3 direction = vertexPath.GetDirectionAtDistance(centerDistance); // Check clockwise direction & determine ticker's start and end bool clockwise = (Vector3.Dot(rBody.velocity, direction) >= 0); int t_s = clockwise ? tickerStart : -tickerEnd; int t_e = clockwise ? tickerEnd : -tickerStart; // # Collect Path's observations for (int d = t_s; d <= t_e; d++) { float distance = centerDistance + d * tickerSpace; Vector3 point = vertexPath.GetPointAtDistance(distance, EndOfPathInstruction.Loop); Vector3 normal = vertexPath.GetNormalAtDistance(distance, EndOfPathInstruction.Loop); AddObservationInXYZMode(sensor, point - this.transform.localPosition); AddObservationInXYZMode(sensor, normal); } // # Padding observations // If custom setting will have too more observations and cause the buffer overflow, We // must warn user (in Pyhon interface level). // Here we are padding the observation buffer with all zero int MaxObservationSize = GetComponent <BehaviorParameters>().BrainParameters.VectorObservationSize; for (int i = 0; i < MaxObservationSize - ObservationSize; i++) { sensor.AddObservation(0); } }
// Update is called once per frame void Update() { // if the ball or the trail hits the end point, destory them if (trail != null && trail.transform.position == path.GetPointAtTime(1, EndOfPathInstruction.Stop)) { Destroy(trail, 3); } if (ball == null || ball.transform.position == path.GetPointAtTime(1, EndOfPathInstruction.Stop)) { if (ball != null && survival) { if (ball.tag != "Bomb" && scorekeeper.caught) { scorekeeper.caught = false; } else { scorekeeper.lives--; } } // the ball can be null if it is caught and destoryed if (ball != null) { Destroy(ball); } Destroy(startHole); Destroy(endHole); Destroy(this.gameObject); } travelDst += Time.deltaTime * speed; if (trail != null) { trail.transform.position = path.GetPointAtDistance(travelDst, EndOfPathInstruction.Stop); } float prevDelay = delay; delay -= Time.deltaTime; if (delay < 0) { // if this is the first time delay became less than 0, then instantiate the ball if (prevDelay >= 0) { ball = Instantiate(ball, path.GetPointAtDistance(0), path.GetRotationAtDistance(0)); spawned = true; // mark end of path since ball.transform.position is not accurate ball.GetComponent <Explosion>().end = this.end; if (random == 0) { Instantiate(GameObject.Find("AudioManager").GetComponent <AudioManager>().bombSpawn, start, Quaternion.identity); } else { Instantiate(GameObject.Find("AudioManager").GetComponent <AudioManager>().spawn, start, Quaternion.identity); } } if (ball != null) { ball.transform.position = path.GetPointAtDistance(-delay * speed, EndOfPathInstruction.Stop); ball.transform.rotation = path.GetRotationAtDistance(-delay * speed, EndOfPathInstruction.Stop); } } }
public override void OnStateExcute(float deltaTime) { base.OnStateExcute(deltaTime); if (action.paths.Count > 0) { if (mTargetPoint == null) { mTargetPoint = action.paths.First.Value; mDistance = 0; if (Chess.Instance.grid == BattleGrid.Rect) { var tile = BattleRectGrid.Instance.TileAt(mTargetPoint.destination); if (tile == null || tile.isValid == false) { action.Done(); var point = action.paths.First; while (point != null) { point.Value.Failed(agent); ObjectPool.ReturnInstance(point.Value); point = point.Next; } action.paths.Clear(); mTargetPoint = null; } } else { var tile = BattleHexGrid.Instance.TileAt(mTargetPoint.destination); if (tile == null || tile.isValid == false) { action.Done(); var point = action.paths.First; while (point != null) { point.Value.Failed(agent); ObjectPool.ReturnInstance(point.Value); point = point.Next; } action.paths.Clear(); mTargetPoint = null; } } if (mTargetPoint != null) { //水平移动需要多久 float duration = Vector3.Distance(agent.position, mTargetPoint.destination) / SPEED; if (duration > 0) { float halfTime = duration * 0.5f; float height = Math.Abs(GRAVITY) * halfTime * halfTime / 2; //限制垂直高度 height = Mathf.Clamp(height, MINHEIGHT, MAXHEIGHT); Vector3 center = (agent.position + mTargetPoint.destination) / 2f; center.y = height; List <Vector3> points = new List <Vector3>(); points.Add(agent.position); points.Add(center); points.Add(mTargetPoint.destination); mBezierPath = new BezierPath(points, false, PathSpace.xyz); mVertexPath = new VertexPath(mBezierPath, 0.3f, 0.01f); } else { mTargetPoint.Arrive(agent); ObjectPool.ReturnInstance(mTargetPoint); mTargetPoint = null; action.paths.RemoveFirst(); } } } if (mTargetPoint != null) { Vector3 direction = mTargetPoint.destination - agent.position; agent.position = mVertexPath.GetPointAtDistance(mDistance, EndOfPathInstruction.Stop); direction.y = 0; if (direction != Vector3.zero) { agent.rotation = Quaternion.LookRotation(direction); } mDistance += SPEED * deltaTime; if (mDistance > mVertexPath.length) { agent.position = mTargetPoint.destination; mDistance = 0; mTargetPoint.Arrive(agent); ObjectPool.ReturnInstance(mTargetPoint); mTargetPoint = null; action.paths.RemoveFirst(); } } } else { action.Done(); } }