public void MoveTo(UnitCtl fromCtl, UnitCtl toCtl)
{
fromUnitData = fromCtl.unitData;
toUnitData = toCtl.unitData;
this.from = fromCtl.transform;
this.to = toCtl.transform;
navMeshAgent.SetDestination(to.position);
Vector3 fromPoint = from.position;
Vector3 toPoint = to.position;
Vector3 direction = (toPoint - fromPoint).normalized * beginDistance;
float radian = HMath.radian(0, 0, direction.x, direction.z);
radian += Mathf.PI * 0.5F;
direction += fromPoint;
float x = HMath.radianPointX(radian, gap * index, direction.x);
float z = HMath.radianPointY(radian, gap * index, direction.z);
begionTarget.x = x;
begionTarget.z = z;
direction = (toPoint - fromPoint).normalized * endDistance;
radian = HMath.radian(0, 0, direction.x, direction.z);
radian += Mathf.PI * 0.5F;
direction = toPoint - direction;
x = HMath.radianPointX(radian, gap * index, direction.x);
z = HMath.radianPointY(radian, gap * index, direction.z);
endTarget.x = x;
endTarget.z = z;
Out();
}
public Vector3[] GetAnchorPoints()
{
if (isChange == false)
{
return(anchorPointsSource);
}
isChange = false;
Vector3 center = transform.position;
Vector3 size = transform.lossyScale;
float angle = -transform.eulerAngles.y;
anchorPointsSource[0] = new Vector3(size.x * -0.5F, 0F, size.z * -0.5F);
anchorPointsSource[1] = new Vector3(size.x * 0.5F, 0F, size.z * 0.5F);
anchorPointsSource[2] = new Vector3(size.x * -0.5F, 0F, size.z * 0.5F);
anchorPointsSource[3] = new Vector3(size.x * 0.5F, 0F, size.z * -0.5F);
size.x += extended;
size.z += extended;
anchorPoints[0] = new Vector3(size.x * -0.5F, 0F, size.z * -0.5F);
anchorPoints[1] = new Vector3(size.x * 0.5F, 0F, size.z * 0.5F);
anchorPoints[2] = new Vector3(size.x * -0.5F, 0F, size.z * 0.5F);
anchorPoints[3] = new Vector3(size.x * 0.5F, 0F, size.z * -0.5F);
min.x = min.z = 9999999F;
max.x = max.z = -9999999F;
for (int i = 0; i < anchorPoints.Length; i++)
{
Vector3 point = anchorPoints[i];
float anglePoint = HMath.angle(0f, 0f, point.x, point.z);
float angleEnd = angle + anglePoint;
float length = point.magnitude;
float radian = HMath.angleToRadian(angleEnd);
point.x = HMath.radianPointX(radian, length, 0f);
point.z = HMath.radianPointY(radian, length, 0f);
point += center;
anchorPoints[i] = point;
if (point.x < min.x)
{
min.x = point.x;
}
if (point.z < min.z)
{
min.z = point.z;
}
if (point.x > max.x)
{
max.x = point.x;
}
if (point.z > max.z)
{
max.z = point.z;
}
point = anchorPointsSource[i];
anglePoint = HMath.angle(0f, 0f, point.x, point.z);
angleEnd = angle + anglePoint;
length = point.magnitude;
radian = HMath.angleToRadian(angleEnd);
point.x = HMath.radianPointX(radian, length, 0f);
point.z = HMath.radianPointY(radian, length, 0f);
point += center;
anchorPointsSource[i] = point;
}
anchorPoints2[0] = anchorPoints[1];
anchorPoints2[1] = anchorPoints[2];
anchorPoints2[2] = anchorPoints[0];
anchorPoints2[3] = anchorPoints[3];
return(anchorPoints);
}
public void SetPath(List <Vector3> paths)
{
List <Vector3> list = new List <Vector3>();
if (paths.Count >= 2)
{
Vector3 p1 = paths[0];
Vector3 p2 = paths[1];
float distance = Vector3.Distance(p1, p2);
Vector3 p3 = Vector3.zero;
int add = 0;
bool begin = false;
bool end = false;
if (distance > 1F)
{
p3.x = HMath.directionPointX(p1.x, p1.z, p2.x, p2.z, lengthRadius);
p3.z = HMath.directionPointY(p1.x, p1.z, p2.x, p2.z, lengthRadius);
add += 1;
begin = true;
}
p1 = paths[paths.Count - 1];
p2 = paths[paths.Count - 2];
distance = Vector3.Distance(p1, p2);
Vector3 p4 = Vector3.zero;
if (distance > 1F)
{
p4.x = HMath.directionPointX(p1.x, p1.z, p2.x, p2.z, lengthRadius);
p4.z = HMath.directionPointY(p1.x, p1.z, p2.x, p2.z, lengthRadius);
add += 1;
end = true;
}
for (int i = 0; i < paths.Count; i++)
{
list.Add(paths[i]);
if (add > 0)
{
if (i == 0 && begin)
{
list.Add(p3);
}
if (i == paths.Count - 2 && end)
{
list.Add(p4);
}
}
}
}
for (int i = 0; i < list.Count; i++)
{
Vector3 source = list[i];
Vector3 pos = new Vector3(source.x, source.y, source.z);
if (i != 0 && i != list.Count - 1)
{
float myGap = gap;
// if(i > 1 && i < list.Count - 2)
// {
// myGap = turnGap;
// }
if (list.Count > 4 && i < list.Count - 1)
{
myGap = turnGap;
}
Vector3 d1 = pos - list[i - 1];
Vector3 d2 = list[i + 1] - pos;
Vector3 d = d1.normalized + d2.normalized;
float radian = HMath.radian(0, 0, d.x, d.z);
radian += Mathf.PI * 0.5F;
float x = HMath.radianPointX(radian, myGap * index, pos.x);
float z = HMath.radianPointY(radian, myGap * index, pos.z);
pos.x = x;
pos.z = z;
}
this.list.Add(pos);
}
}
/** 检测建筑障碍 */
public void CheckBuild()
{
if (paths.Count == 0)
{
return;
}
int listCount = paths[0].list.Count;
for (int i = 0; i < listCount; i++)
{
bool hasHit = false;
float minHitDistance = 9999;
RaycastHit hitInfo = new RaycastHit();
float radius = 1f;
Vector3 pos = Vector3.zero;
// 查找最近的碰撞体
foreach (Path path in paths)
{
List <Vector3> list = path.list;
List <Vector3> points = path.points;
path.hit = null;
points.Add(list[i]);
if (i == 0)
{
continue;
}
if (i < listCount - 2)
{
Vector3 p1 = list[i];
Vector3 p2 = list[i + 1];
RaycastHit _hitInfo;
if (Physics.Linecast(p1, p2, out _hitInfo, buildLayer.value))
{
path.hit = _hitInfo.collider.gameObject;
pos = _hitInfo.collider.transform.position;
float hitDistance = Vector3.Distance(paths[0].list[i], pos);
radius = (_hitInfo.collider as SphereCollider).radius * _hitInfo.collider.transform.lossyScale.x;
if (hitDistance <= radius * hitRadiusMultiply || Vector3.Distance(paths[0].list[i + 1], pos) <= radius * hitRadiusMultiply)
{
continue;
}
if (hasHit == false)
{
hasHit = true;
hitInfo = _hitInfo;
minHitDistance = hitDistance;
}
else if (hitDistance <= minHitDistance)
{
hitInfo = _hitInfo;
minHitDistance = hitDistance;
}
}
}
}
int hL = -100;
int hR = 100;
//查找hL、hR
if (hasHit)
{
radius = (hitInfo.collider as SphereCollider).radius * hitInfo.collider.transform.lossyScale.x;
pos = hitInfo.collider.transform.position;
foreach (Path path in paths)
{
if (path.hit == null)
{
continue;
}
if (path.hit != hitInfo.collider.gameObject)
{
continue;
}
int index = path.index;
int myIndex = index;
List <Vector3> list = path.list;
List <Vector3> points = path.points;
Vector3 p1 = list[i];
Vector3 p2 = list[i + 1];
Vector3 d0 = p2 - p1;
Vector3 d1 = pos - p1;
Vector3 cross = Vector3.Cross(d1, d0);
if (cross.y < 0)
{
if (myIndex <= hR)
{
hR = myIndex;
}
}
else
{
if (myIndex >= hL)
{
hL = myIndex;
}
}
}
}
if (hasHit)
{
if (hR == 100)
{
hR = hL + 1;
}
if (hL == -100)
{
hL = hR - 1;
}
// Debug.Log("hL=" + hL + " hR=" + hR);
foreach (Path path in paths)
{
int index = path.index;
int myIndex = index;
List <Vector3> list = path.list;
List <Vector3> points = path.points;
Vector3 p1 = list[i];
Vector3 p2 = list[i + 1];
int symbol = 1;
int gapIndex = 0;
if (myIndex <= hL)
{
gapIndex = myIndex - hL - 1;
symbol = -1;
}
else
{
gapIndex = myIndex - hR + 1;
symbol = 1;
}
Vector3 direction = (p2 - p1).normalized;
float radian = HMath.radian(0, 0, direction.x, direction.z);
radian += Mathf.PI * 0.5F;
Vector3 ip = HMath.IntersectionPoint(pos, p1, p2);
float r = radius * symbol + gap * gapIndex;
// Debug.Log("index="+index + " gapIndex=" + gapIndex + " r=" + r);
Vector3 p;
if (Vector3.Distance(ip, p1) > radius * hitRadiusMultiply * hitRadiusMultiplyVertical)
{
p = ip - direction * radius * hitRadiusMultiply * hitRadiusMultiplyVertical;
points.Add(p);
}
p = Vector3.zero;
p.x = HMath.radianPointX(radian, r, pos.x);
p.z = HMath.radianPointY(radian, r, pos.z);
points.Add(p);
if (Vector3.Distance(ip, p2) > radius * hitRadiusMultiply * hitRadiusMultiplyVertical)
{
p = ip + direction * radius * hitRadiusMultiply * hitRadiusMultiplyVertical;
points.Add(p);
list.Insert(i + 1, p);
}
else
{
list.Insert(i + 1, p2);
}
}
listCount = paths[0].list.Count;
}
}
}
