public void ShowPath(bool b)
{
if (!b)
{
return;
}
if (!SelfBaseUnit.IsPlayer())
{
return;
}
if (!IsHaveMoveTarget())
{
return;
}
var state = StateMachine.GetState(MoveTarget_State);
var curState = StateMachine.CurState;
if (!IsMoveTargetState(curState))
{
Vector3 realPoint = Vector3.zero;
if (MoveTarget_PosPreview == Vector3.zero)
{
return;
}
if (MoveTarget_PosPreview.IsInv())
{
return;
}
realPoint = (Vector3)AStarMgr.GetDistNode(SelfBaseUnit, MoveTarget_PosPreview, false, true, false, false, false).position;
PreviewPath(realPoint);
}
}
public override void OnDeath()
{
base.OnDeath();
var curNode = AStarMgr.GetNode(SelfBaseUnit.Pos);
AStarMgr.ExSeizeNodeData.ClearSeizeNode(curNode, SelfBaseUnit);
}
public void MoveoutLegion()
{
var inBlockerUnits = AStarMgr.GetBlockerUnits(SelfUnit, false);
foreach (var item in inBlockerUnits)
{
if (SelfUnit.IsSelf(item))
{
continue;
}
if (item is TLegion legion)
{
legion.LegionStationedMgr.LeaveBlocker(SelfUnit);
}
}
if (IsHaveDefender())
{
Defender.LegionStationedMgr.LeaveDefend(true);
}
if (IsInSiege())
{
Attackers.ForSafe(x =>
{
x.LegionStationedMgr.LeaveSiege(true);
});
}
}
void Start()
{
//初始化
AStarMgr.GetInstance().InitMapInfo(Y, H);
for (int i = 0; i < H; ++i)
{
for (int k = 0; k < Y; ++k)
{
//创建一个一个立方体
GameObject game = GameObject.CreatePrimitive(PrimitiveType.Cube);
game.transform.position = new Vector3(x + i * offsetX, y + k * offsetY, 0);
//存储名字
game.name = i + "_" + k;
cubes.Add(game.name, game);
//得到格子 判断他是不是阻挡
AStarNode node = AStarMgr.GetInstance().nodes[i, k];
if (node.startype == StarType.Stop)
{
game.GetComponent <MeshRenderer>().material = red;
}
}
}
}
public void CalcNodes()
{
Nodes.Clear();
NodeObjs = GetComponentsInChildren <Transform>();
if (NodeObjs != null)
{
foreach (var item in NodeObjs)
{
if (item == transform)
{
transform.localPosition = Vector3.zero;
continue;
}
GraphNode node = null;
if (Application.isPlaying)
{
node = AStarMgr.GetSafeNode(item.position);
}
else
{
node = AstarPath.GetNearest(item.position).node;
}
if (node == null)
{
CLog.Error("错误! 没有Node");
continue;
}
Nodes.Add(node);
item.position = (Vector3)node.position;
item.name = "Item";
}
}
}
protected override void OnMoveStart()
{
base.OnMoveStart();
TweenLastMove?.Kill();
MovingFlag = true;
AStarMgr.RemoveMoveQueue(SelfBaseUnit);
}
// 移动到指定单位边上
public bool MoveToUnit(BaseUnit unit)
{
if (unit == null)
{
return(false);
}
if (unit == SelfBaseUnit)
{
return(false);
}
if (unit.Pos.IsInv())
{
return(false);
}
Node closetNode = AStarMgr.GetClosedNode(SelfBaseUnit, unit);
if (closetNode == null)
{
return(false);
}
MoveTargetUnit = unit;
IsCanUnitOverlap = false;
MoveType = BasicMoveType2D.MoveToUnit;
var ret = _moveIntoNode(closetNode);
IsTriggerDoTraversal = true;
return(ret);
}
protected override void OnMoveEnd()
{
base.OnMoveEnd();
TweenLastMove?.Kill();
CalcCurNode();
MovingFlag = false;
AStarMgr.RemoveMoveQueue(SelfBaseUnit);
}
private void ClearBlock()
{
if (!UseBlockNode)
{
return;
}
AStarMgr.SetBlockNode(SelfBaseUnit, null);
}
private void CalcCurBlock()
{
if (!UseBlockNode)
{
return;
}
AStarMgr.SetBlockNode(SelfBaseUnit, GetBlockerNode());
}
private void ClearNode()
{
if (!UseSeizeNode)
{
return;
}
PreNode = CurNode;
CurNode = AStarMgr.GetSafeNode(SelfBaseUnit.Pos);
AStarMgr.ClearSeizeNode(CurNode, SelfBaseUnit);
}
public void ClearCurNode()
{
PreNode = CurNode;
CurNode = AStarMgr.GetNode(SelfBaseUnit.Pos);
if (CurNode == null)
{
CLog.Error("ClearCurNode:没有获取到寻路节点!!!{0}", SelfBaseUnit.GOName);
}
AStarMgr.ClearSeizeNode(CurNode, SelfBaseUnit);
}
public bool IsInConnection(BaseUnit target)
{
//如果没有链接,就返回
HashList <GraphNode> blockers = AStarMgr.GetBlocker(SelfBaseUnit);
if (!AStarMgr.IsConnection(blockers, target.AStarMoveMgr.CurNode))
{
return(false);
}
return(true);
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
//进行射线检测
RaycastHit info;
//得到屏幕鼠标位置触发的射线
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out info, 1000))
{
if (beginPos == Vector2.right * -1)
{
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
cubes[list[i].x + "_" + list[i].y].GetComponent <MeshRenderer>().material = Nomal;
}
}
//清理上一次的路径
string[] strs = info.collider.gameObject.name.Split('_');
beginPos = new Vector2(int.Parse(strs[0]), int.Parse(strs[1]));
//吧点击到的对象改成黄色
info.collider.gameObject.GetComponent <MeshRenderer>().material = yellow;
}
else
{
string[] strs = info.collider.gameObject.name.Split('_');
Vector2 endPos = new Vector2(int.Parse(strs[0]), int.Parse(strs[1]));
//寻路
list = AStarMgr.GetInstance().FindPath(beginPos, endPos);
//避免死路 的时候黄色不变
cubes[(int)beginPos.x + "_" + (int)beginPos.y].GetComponent <MeshRenderer>().material = Nomal;
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
cubes[list[i].x + "_" + list[i].y].GetComponent <MeshRenderer>().material = green;
}
}
//清除开始点 把它变成初始值
beginPos = Vector2.right * -1;
}
}
}
}
public virtual bool AdjToNode()
{
ClearNode();
GraphNode node = AStarMgr.GetNode(SelfMono.Pos);
if (node == null)
{
return(false);
}
SelfMono.Pos = (Vector3)node.position;
CalcCurNode();
return(true);
}
public virtual bool AdjToNode()
{
ClearCurNode();
Node node = AStarMgr.GetNode(SelfMono.Pos);
if (node == null)
{
return(false);
}
SelfMono.Pos = node.Pos;
CalcCurNode();
return(true);
}
Vector3 GetFinalPos(Vector3 pos)
{
Vector3 finalPos = (Vector3)AStarMgr.GetSafeNode(pos).position;
//单位可以和目标点重叠(finalPos必须是目标位置点才能重叠,所以需要Approximately判断,Approximately判断为了防止移动中途路径上的重叠)
if (IsCanUnitOverlap && MathUtil.Approximately(Destination, finalPos))
{
}
else
{
finalPos = (Vector3)AStarMgr.GetDistNode(SelfBaseUnit, finalPos, false, true, true, false, false).position;
}
return(finalPos);
}
public void LeaveDefend(bool isForce = false)
{
if (!IsInDefend())
{
return;
}
PreDefendCastle = DefendCastle;
DefendCastle = null;
PreDefendCastle.CastleStationedMgr.OnUnBeDefend(SelfUnit);
if (isForce)
{
AStarMgr.SetArroundUnit(PreDefendCastle, SelfUnit);
}
OnLeaveDefend(isForce);
Callback_OnDefendChanged?.Invoke(PreDefendCastle, null);
}
public bool MoveToUnitQueue(BaseUnit unit)
{
if (unit == null)
{
return(false);
}
if (unit == SelfBaseUnit)
{
return(false);
}
if (unit.Pos.IsInv())
{
return(false);
}
AStarMgr.AddMoveQueue(SelfBaseUnit, unit);
return(true);
}
private void CalcCurNode()
{
if (!UseSeizeNode)
{
return;
}
PreNode = CurNode;
CurNode = AStarMgr.GetSafeNode(SelfBaseUnit.Pos);
if (CurNode == null)
{
CLog.Error("没有获取到寻路节点!!!{0}", SelfBaseUnit.GOName);
}
else
{
SelfBaseUnit.Pos = (Vector3)CurNode.position;
}
AStarMgr.SetSeizeNode(CurNode, SelfBaseUnit);
}
public void CalcCurNode()
{
if (!SelfBaseUnit.IsLive)
{
return;
}
PreNode = CurNode;
CurNode = AStarMgr.GetNode(SelfBaseUnit.Pos);
if (CurNode == null)
{
CLog.Error("CalcCurNode:没有获取到寻路节点!!!{0}", SelfBaseUnit.GOName);
}
else
{
SelfBaseUnit.Pos = CurNode.Pos;
}
AStarMgr.SetSeizeNode(CurNode, SelfBaseUnit);
}
//移动范围是否可以链接到目标
public bool IsCanConstantConnection(BaseUnit unit)
{
if (ConstantNodesMove == null || ConstantNodesMove.Count == 0)
{
return(false);
}
HashList <GraphNode> links = AStarMgr.GetConnectionsBlocker(unit);
foreach (var item in links)
{
if (ConstantNodesMove.Contains(item))
{
return(true);
}
}
return(false);
}
// 移动到指定单位
public bool MoveIntoUnit(BaseUnit unit)
{
if (unit == null)
{
return(false);
}
if (unit.Pos.IsInv())
{
return(false);
}
MoveTargetUnit = unit;
IsCanUnitOverlap = true;
MoveType = BasicMoveType2D.MoveIntoUnit;
var targetNode = AStarMgr.GetNode(unit.Pos);
var ret = _moveIntoNode(targetNode);
IsTriggerDoTraversal = true;
return(ret);
}
private void Init()
{
CustomLoggerService.Instance.Init();
mTimer = TimerServiceForTest.Instance;
mTimer.Init();
SaveMgr.Instance.Init();
mMapMgr = MapMgr.Instance;
mMapMgr.Init(MapWidth, MapHeight);
mAStarMgr = AStarMgr.Instance;
mAStarMgr.Init();
mRandomMapCreator = RandomMapCreator.Instance;
mRandomMapCreator.Init();
mRecorder = Recorder.Instance;
mRecorder.Init();
mTimer.Subscribe(TIMER_KEY_CREATE_MAP);
mTimer.Subscribe(TIMER_KEY_ASTAR_PF);
InitDataId();
HTLogger.Info("All init done.");
}
public HashList <GraphNode> CalcConstant()
{
float range = CurMovePoint;
ConstantNodesDraw.Clear();
ConstantNodesMove.Clear();
ConstantNodesMove = AStarMgr.GetDistanceRange(SelfBaseUnit.Pos, range, x => Traversal.CanTraverse(null, x));
foreach (var item in ConstantNodesMove)
{
//过滤掉占有单位得节点,并且这个节点不是自身,防止重复绕路
if (AStarMgr.IsHaveUnit(item))
{
continue;
}
ConstantNodesDraw.Add(item);
}
return(ConstantNodesDraw);
}
protected virtual bool TryMove(IBaseNode node)
{
if (node == null ||
AStarMgr.ExSeizeNodeData.IsHaveUnit(node) ||
AStarMgr.IsHaveUnit(node))
{
return(false);
}
else
{
ClearCurNode();
var curNode = AStarMgr.GetNode(SelfBaseUnit.Pos);
AStarMgr.ExSeizeNodeData.ClearSeizeNode(curNode, SelfBaseUnit);
AStarMgr.ExSeizeNodeData.SetSeizeNode(node, SelfBaseUnit);
TweenLastMove?.Kill();
TweenLastMove = DOTween.To(() => SelfBaseUnit.Pos, x => SelfBaseUnit.Pos = x, node.Pos, MoveSpeed).SetEase(Ease.Linear);
return(true);
}
}
public void LeaveBlocker(BaseUnit unit)
{
if (unit == null)
{
return;
}
var castle = unit as TCastle;
if (castle == null)
{
CLog.Error("LeaveBlocker:castle == null)");
return;
}
if (IsInDefend())
{
return;
}
AStarMgr.SetArroundUnit(castle, SelfUnit);
OnLeaveBlocker(castle);
}
// 移动到指定单位边上
public bool MoveToUnit(BaseUnit unit, float speed)
{
if (unit == null)
{
return(false);
}
if (unit == SelfBaseUnit)
{
return(false);
}
if (unit.Pos.IsInv())
{
return(false);
}
GraphNode closetNode = AStarMgr.GetClosedNode(SelfBaseUnit, unit.Pos);
if (closetNode == null)
{
return(false);
}
IsCanUnitOverlap = false;
return(StartPath((Vector3)closetNode.position, speed));
}
//当前Unit的node是否可以连接到目标Unit的Blocker范围内,一般可以用来做攻击检测
public bool IsInBlockerRange(BaseUnit unit)
{
HashList <GraphNode> connection = new HashList <GraphNode>();
CurNode.GetConnections(connection.Add);
HashList <GraphNode> targetUnitBlocker = AStarMgr.GetBlocker(unit);
if (targetUnitBlocker != null)
{
foreach (var item in targetUnitBlocker)
{
if (connection.Contains(item))
{
return(true);
}
}
}
else
{
CLog.Error("{0}:目标单位没有Blocker", unit.BaseConfig.GetName());
}
return(false);
}
protected override IEnumerator <float> OnFollowPathCoroutine()
{
IsMovingFlag = false;
//是否为第一段移动
bool isFirstMoved = false;
//当前已经走过的路段
float distanceAlongSegment = 0;
//当前路段长度
var segmentLength = 0.0f;
//节点的大小
float nodeSize = AStarMgr.Ins.data.gridGraph.nodeSize;
//最大可以移动的距离
float maxMoveDistance = nodeSize * MaxMovePoint;
//已经移动的距离
float movedDistance = 0;
var moveStep = Time.smoothDeltaTime * RealMoveSpeed;
IsForceBreak = false;
IsFinalPosMove = false;
for (int i = 0; i < ABPath.vectorPath.Count - 1; i++)
{
CurIndex = i;
var p1 = ABPath.vectorPath[i];
var p2 = ABPath.vectorPath[i + 1];
segmentLength = Vector3.Distance(p1, p2);
if (CurMovePoint <= segmentLength)
{
p2 = (Vector3)AStarMgr.GetSafeNode(p2).position;;
}
while (IsHaveMoveSegment() && !IsForceBreak)
{
if (CurMovePoint < nodeSize &&
MathUtil.Approximately(SelfBaseUnit.Pos, p2))
{
IsForceBreak = true;
}
else
{
LerpMove(p1, p2, 1, true, false);
}
yield return(Timing.WaitForOneFrame);
if (!isFirstMoved)
{
isFirstMoved = true;
Callback_OnFirstMovingAlone?.Invoke();
}
}
distanceAlongSegment -= segmentLength;
OnMoveStep(movedDistance, maxMoveDistance, nodeSize, segmentLength);
CurIndex++;
if (!IsCanMove || IsForceBreak)
{
break;
}
}
//计算最后的安全落点
yield return(Timing.WaitUntilDone(FinalPosMove()));
if (CurMovePoint < 1)
{
CurMovePoint = 0;
}
IsMovingFlag = true;
Callback_OnMoveDestination?.Invoke();
StopPath();
//最后位置点的矫正
IEnumerator <float> FinalPosMove()
{
IsFinalPosMove = true;
Vector3 startPos = SelfBaseUnit.Pos;
var finalPos = GetFinalPos(startPos);
if (MathUtil.Approximately(startPos, finalPos))
{
yield break;
}
//将单位移动到最终的目标节点
distanceAlongSegment = 0;
segmentLength = Vector3.Distance(startPos, finalPos);
while (IsHaveMoveSegment())
{
LerpMove(startPos, finalPos, 1, segmentLength > nodeSize, true);
yield return(Timing.WaitForOneFrame);
}
SelfBaseUnit.Pos = finalPos;
//如果目标无效,进入递归
if (!MathUtil.Approximately(finalPos, GetFinalPos(SelfBaseUnit.Pos)))
{
yield return(Timing.WaitUntilDone(FinalPosMove()));
}
IsForceBreak = false;
IsFinalPosMove = false;
}
bool LerpMove(Vector3 p1, Vector3 p2, float speedMul = 1.0f, bool isRot = true, bool isFinalCorrect = false)
{
float aiSpeedMul = 1;
if (BaseGlobal.FOWMgr != null &&
BaseGlobal.FOWMgr.IsInFog(p2) &&
SelfBaseUnit != null &&
SelfBaseUnit.IsAI() &&
SelfBaseUnit.FOWMgr != null &&
!SelfBaseUnit.FOWMgr.IsVisible &&
!SelfBaseUnit.FOWMgr.IsPreVisible)
{
aiSpeedMul = 10;
}
if (!isFinalCorrect && IsForceBreak)
{
return(false);
}
var tempMoveStep = moveStep * speedMul * aiSpeedMul;
var interpolatedPoint = Vector3.Lerp(p1, p2, distanceAlongSegment / segmentLength);
var targetRot = Quaternion.LookRotation((p2 - p1).SetY(0), Vector3.up);
if (isRot)
{
SelfBaseUnit.Rot = Quaternion.Slerp(SelfBaseUnit.Rot, targetRot, tempMoveStep);
}
bool isValid = OnPreLerpMoveAlone(interpolatedPoint, tempMoveStep, movedDistance, maxMoveDistance, nodeSize, segmentLength, isFinalCorrect);
if (!isValid)
{
return(false);
}
SelfBaseUnit.Pos = interpolatedPoint;
movedDistance += tempMoveStep;
distanceAlongSegment += tempMoveStep;
OnLerpMoveAlone(tempMoveStep, movedDistance, maxMoveDistance, nodeSize, segmentLength, isFinalCorrect);
Callback_OnMovingAlone?.Invoke();
return(true);
}
//是否有移动的路段
bool IsHaveMoveSegment()
{
return(distanceAlongSegment < segmentLength);
}
}
