1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
using UnityEngine;
using System.Collections.Generic;
using Pathfinding.RVO;
namespace Pathfinding.Examples {
/// <summary>
/// Example movement script for using RVO.
///
/// Primarily intended for the example scenes.
/// You can use the AIPath or RichAI movement scripts in your own projects.
///
/// See: <see cref="Pathfinding.AIPath"/>
/// See: <see cref="Pathfinding.RichAI"/>
/// See: <see cref="Pathfinding.RVO.RVOController"/>
/// </summary>
[RequireComponent(typeof(RVOController))]
[RequireComponent(typeof(Seeker))]
[HelpURL("https://arongranberg.com/astar/documentation/stable/rvoexampleagent.html")]
public class RVOExampleAgent : MonoBehaviour {
public float repathRate = 1;
private float nextRepath = 0;
private Vector3 target;
private bool canSearchAgain = true;
private RVOController controller;
public float maxSpeed = 10;
Path path = null;
List<Vector3> vectorPath;
int wp;
public float moveNextDist = 1;
public float slowdownDistance = 1;
public LayerMask groundMask;
Seeker seeker;
MeshRenderer[] rends;
public void Awake () {
seeker = GetComponent<Seeker>();
controller = GetComponent<RVOController>();
}
/// <summary>Set the point to move to</summary>
public void SetTarget (Vector3 target) {
this.target = target;
RecalculatePath();
}
/// <summary>Animate the change of color</summary>
public void SetColor (Color color) {
if (rends == null) rends = GetComponentsInChildren<MeshRenderer>();
foreach (var rend in rends) {
StartCoroutine(AnimateColor(rend, rend.material.GetColor("_Color"), color));
}
}
System.Collections.IEnumerator AnimateColor (MeshRenderer rend, Color startColor, Color endColor) {
float t = 0;
do {
t = Mathf.Min(1.0f, t + Time.deltaTime);
rend.material.SetColor("_Color", Color.Lerp(startColor, endColor, t));
yield return null;
} while (t < 1);
}
public void RecalculatePath () {
canSearchAgain = false;
nextRepath = Time.time+repathRate*(Random.value+0.5f);
seeker.StartPath(transform.position, target, OnPathComplete);
}
public void OnPathComplete (Path _p) {
ABPath p = _p as ABPath;
canSearchAgain = true;
if (path != null) path.Release(this);
path = p;
p.Claim(this);
if (p.error) {
wp = 0;
vectorPath = null;
return;
}
Vector3 p1 = p.originalStartPoint;
Vector3 p2 = transform.position;
p1.y = p2.y;
float d = (p2-p1).magnitude;
wp = 0;
vectorPath = p.vectorPath;
Vector3 waypoint;
if (moveNextDist > 0) {
for (float t = 0; t <= d; t += moveNextDist*0.6f) {
wp--;
Vector3 pos = p1 + (p2-p1)*t;
do {
wp++;
waypoint = vectorPath[wp];
} while (controller.To2D(pos - waypoint).sqrMagnitude < moveNextDist*moveNextDist && wp != vectorPath.Count-1);
}
}
}
public void Update () {
if (Time.time >= nextRepath && canSearchAgain) {
RecalculatePath();
}
Vector3 pos = transform.position;
if (vectorPath != null && vectorPath.Count > 1) {
while ((controller.To2D(pos - vectorPath[wp]).sqrMagnitude < moveNextDist*moveNextDist && wp != vectorPath.Count-1) || wp == 0) {
wp++;
}
// Current path segment goes from vectorPath[wp-1] to vectorPath[wp]
// We want to find the point on that segment that is 'moveNextDist' from our current position.
// This can be visualized as finding the intersection of a circle with radius 'moveNextDist'
// centered at our current position with that segment.
var p1 = vectorPath[wp-1];
var p2 = vectorPath[wp];
// Calculate the intersection with the circle. This involves some math.
var t = VectorMath.LineCircleIntersectionFactor(controller.To2D(transform.position), controller.To2D(p1), controller.To2D(p2), moveNextDist);
// Clamp to a point on the segment
t = Mathf.Clamp01(t);
Vector3 waypoint = Vector3.Lerp(p1, p2, t);
// Calculate distance to the end of the path
float remainingDistance = controller.To2D(waypoint - pos).magnitude + controller.To2D(waypoint - p2).magnitude;
for (int i = wp; i < vectorPath.Count - 1; i++) remainingDistance += controller.To2D(vectorPath[i+1] - vectorPath[i]).magnitude;
// Set the target to a point in the direction of the current waypoint at a distance
// equal to the remaining distance along the path. Since the rvo agent assumes that
// it should stop when it reaches the target point, this will produce good avoidance
// behavior near the end of the path. When not close to the end point it will act just
// as being commanded to move in a particular direction, not toward a particular point
var rvoTarget = (waypoint - pos).normalized * remainingDistance + pos;
// When within [slowdownDistance] units from the target, use a progressively lower speed
var desiredSpeed = Mathf.Clamp01(remainingDistance / slowdownDistance) * maxSpeed;
Debug.DrawLine(transform.position, waypoint, Color.red);
controller.SetTarget(rvoTarget, desiredSpeed, maxSpeed, vectorPath[vectorPath.Count-1]);
} else {
// Stand still
controller.SetTarget(pos, maxSpeed, maxSpeed, pos);
}
// Get a processed movement delta from the rvo controller and move the character.
// This is based on information from earlier frames.
var movementDelta = controller.CalculateMovementDelta(Time.deltaTime);
pos += movementDelta;
// Rotate the character if the velocity is not extremely small
if (Time.deltaTime > 0 && movementDelta.magnitude / Time.deltaTime > 0.01f) {
var rot = transform.rotation;
var targetRot = Quaternion.LookRotation(movementDelta, controller.To3D(Vector2.zero, 1));
const float RotationSpeed = 5;
if (controller.movementPlaneMode == MovementPlane.XY) {
targetRot = targetRot * Quaternion.Euler(-90, 180, 0);
}
transform.rotation = Quaternion.Slerp(rot, targetRot, Time.deltaTime * RotationSpeed);
}
if (controller.movementPlaneMode == MovementPlane.XZ) {
RaycastHit hit;
if (Physics.Raycast(pos + Vector3.up, Vector3.down, out hit, 2, groundMask)) {
pos.y = hit.point.y;
}
}
transform.position = pos;
}
}
}
|
