warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix: Fixes FastAStar (#788)

Browse source 
* Fixes FastAStar algorithm, thanks @nullptr-w8
* Cleans up the code a little
* Removes SlowAStar
* Changes [Path recall runes to waypoints
This commit is contained in:
Kamron Batman 2021-09-16 23:38:51 -07:00 • committed by GitHub
parent 73c65a43ad
commit fd440f29ce
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 77 additions and 392 deletions
Download patch file Download diff file Expand all files Collapse all files

145
Projects/UOContent/Engines/Pathing/FastAStarAlgorithm.cs
View file

@ -24,22 +24,23 @@ namespace Server.PathAlgorithms.FastAStar
private const int PlaneHeight = 20; private const int PlaneHeight = 20;
public static PathAlgorithm Instance = new FastAStarAlgorithm(); public static PathAlgorithm Instance = new FastAStarAlgorithm();
private static readonly Direction[] m_Path = new Direction[AreaSize * AreaSize]; private static readonly Direction[] _path = new Direction[AreaSize * AreaSize];
private static readonly PathNode[] m_Nodes = new PathNode[NodeCount]; private static readonly PathNode[] _nodes = new PathNode[NodeCount];
private static readonly BitArray m_Touched = new(NodeCount); private static readonly BitArray _touched = new(NodeCount);
private static readonly BitArray m_OnOpen = new(NodeCount); private static readonly BitArray _onOpen = new(NodeCount);
private static readonly int[] m_Successors = new int[8]; private static readonly int[] _successors = new int[8];
private static int m_xOffset, m_yOffset; private static int _xOffset;
private static int m_OpenList; private static int _yOffset;
private static int _openList;
private Point3D m_Goal; private Point3D _goal;
public int Heuristic(int x, int y, int z) public int Heuristic(int x, int y, int z)
{ {
x -= m_Goal.X - m_xOffset; x -= _goal.X - _xOffset;
y -= m_Goal.Y - m_yOffset; y -= _goal.Y - _yOffset;
z -= m_Goal.Z; z -= _goal.Z;
x *= 11; x *= 11;
y *= 11; y *= 11;
@ -52,59 +53,59 @@ namespace Server.PathAlgorithms.FastAStar
private void RemoveFromChain(int node) private void RemoveFromChain(int node)
{ {
if (node < 0 || node >= NodeCount) if (node is < 0 or >= NodeCount)
{ {
return; return;
} }
if (!m_Touched[node] || !m_OnOpen[node]) if (!_touched[node] || !_onOpen[node])
{ {
return; return;
} }
var prev = m_Nodes[node].prev; var prev = _nodes[node].prev;
var next = m_Nodes[node].next; var next = _nodes[node].next;
if (m_OpenList == node) if (_openList == node)
{ {
m_OpenList = next; _openList = next;
} }
if (prev != -1) if (prev != -1)
{ {
m_Nodes[prev].next = next; _nodes[prev].next = next;
} }
if (next != -1) if (next != -1)
{ {
m_Nodes[next].prev = prev; _nodes[next].prev = prev;
} }
m_Nodes[node].prev = -1; _nodes[node].prev = -1;
m_Nodes[node].next = -1; _nodes[node].next = -1;
} }
private void AddToChain(int node) private void AddToChain(int node)
{ {
if (node < 0 || node >= NodeCount) if (node is < 0 or >= NodeCount)
{ {
return; return;
} }
RemoveFromChain(node); RemoveFromChain(node);
if (m_OpenList != -1) if (_openList != -1)
{ {
m_Nodes[m_OpenList].prev = node; _nodes[_openList].prev = node;
} }
m_Nodes[node].next = m_OpenList; _nodes[node].next = _openList;
m_Nodes[node].prev = -1; _nodes[node].prev = -1;
m_OpenList = node; _openList = node;
m_Touched[node] = true; _touched[node] = true;
m_OnOpen[node] = true; _onOpen[node] = true;
} }
public override Direction[] Find(Mobile m, Map map, Point3D start, Point3D goal) public override Direction[] Find(Mobile m, Map map, Point3D start, Point3D goal)
@ -114,37 +115,38 @@ namespace Server.PathAlgorithms.FastAStar
return null; return null;
} }
m_Touched.SetAll(false); _touched.SetAll(false);
_onOpen.SetAll(false);
m_Goal = goal; _goal = goal;
m_xOffset = (start.X + goal.X - AreaSize) / 2; _xOffset = (start.X + goal.X - AreaSize) / 2;
m_yOffset = (start.Y + goal.Y - AreaSize) / 2; _yOffset = (start.Y + goal.Y - AreaSize) / 2;
var fromNode = GetIndex(start.X, start.Y, start.Z); var fromNode = GetIndex(start.X, start.Y, start.Z);
var destNode = GetIndex(goal.X, goal.Y, goal.Z); var destNode = GetIndex(goal.X, goal.Y, goal.Z);
m_OpenList = fromNode; _openList = fromNode;
m_Nodes[m_OpenList].cost = 0; _nodes[_openList].cost = 0;
m_Nodes[m_OpenList].total = Heuristic(start.X - m_xOffset, start.Y - m_yOffset, start.Z); _nodes[_openList].total = Heuristic(start.X - _xOffset, start.Y - _yOffset, start.Z);
m_Nodes[m_OpenList].parent = -1; _nodes[_openList].parent = -1;
m_Nodes[m_OpenList].next = -1; _nodes[_openList].next = -1;
m_Nodes[m_OpenList].prev = -1; _nodes[_openList].prev = -1;
m_Nodes[m_OpenList].z = start.Z; _nodes[_openList].z = start.Z;
m_OnOpen[m_OpenList] = true; _onOpen[_openList] = true;
m_Touched[m_OpenList] = true; _touched[_openList] = true;
var bc = m as BaseCreature; var bc = m as BaseCreature;
int backtrack = 0, depth = 0; int backtrack = 0, depth = 0;
var path = m_Path; var path = _path;
while (m_OpenList != -1) while (_openList != -1)
{ {
var bestNode = FindBest(m_OpenList); var bestNode = FindBest(_openList);
if (++depth > MaxDepth) if (++depth > MaxDepth)
{ {
@ -159,7 +161,7 @@ namespace Server.PathAlgorithms.FastAStar
MoveImpl.Goal = goal; MoveImpl.Goal = goal;
var vals = m_Successors; var vals = _successors;
var count = GetSuccessors(bestNode, m, map); var count = GetSuccessors(bestNode, m, map);
MoveImpl.AlwaysIgnoreDoors = false; MoveImpl.AlwaysIgnoreDoors = false;
@ -175,30 +177,25 @@ namespace Server.PathAlgorithms.FastAStar
{ {
var newNode = vals[i]; var newNode = vals[i];
var wasTouched = m_Touched[newNode]; var wasTouched = _touched[newNode];
if (wasTouched) if (wasTouched)
{ {
continue; continue;
} }
var newCost = m_Nodes[bestNode].cost + 1; var newCost = _nodes[bestNode].cost + 1;
var newTotal = newCost + Heuristic( var newTotal = newCost + Heuristic(
newNode % AreaSize, newNode % AreaSize,
newNode / AreaSize % AreaSize, newNode / AreaSize % AreaSize,
m_Nodes[newNode].z _nodes[newNode].z
); );
if (m_Nodes[newNode].total <= newTotal) _nodes[newNode].parent = bestNode;
{ _nodes[newNode].cost = newCost;
continue; _nodes[newNode].total = newTotal;
}
m_Nodes[newNode].parent = bestNode; if (_onOpen[newNode])
m_Nodes[newNode].cost = newCost;
m_Nodes[newNode].total = newTotal;
if (m_OnOpen[newNode])
{ {
continue; continue;
} }
@ -211,7 +208,7 @@ namespace Server.PathAlgorithms.FastAStar
} }
var pathCount = 0; var pathCount = 0;
var parent = m_Nodes[newNode].parent; var parent = _nodes[newNode].parent;
while (parent != -1) while (parent != -1)
{ {
@ -222,7 +219,7 @@ namespace Server.PathAlgorithms.FastAStar
newNode / AreaSize % AreaSize newNode / AreaSize % AreaSize
); );
newNode = parent; newNode = parent;
parent = m_Nodes[newNode].parent; parent = _nodes[newNode].parent;
if (newNode == fromNode) if (newNode == fromNode)
{ {
@ -246,8 +243,8 @@ namespace Server.PathAlgorithms.FastAStar
private int GetIndex(int x, int y, int z) private int GetIndex(int x, int y, int z)
{ {
x -= m_xOffset; x -= _xOffset;
y -= m_yOffset; y -= _yOffset;
z += PlaneOffset; z += PlaneOffset;
z /= PlaneHeight; z /= PlaneHeight;
@ -256,24 +253,24 @@ namespace Server.PathAlgorithms.FastAStar
private int FindBest(int node) private int FindBest(int node)
{ {
var least = m_Nodes[node].total; var least = _nodes[node].total;
var leastNode = node; var leastNode = node;
while (node != -1) while (node != -1)
{ {
if (m_Nodes[node].total < least) if (_nodes[node].total < least)
{ {
least = m_Nodes[node].total; least = _nodes[node].total;
leastNode = node; leastNode = node;
} }
node = m_Nodes[node].next; node = _nodes[node].next;
} }
RemoveFromChain(leastNode); RemoveFromChain(leastNode);
m_Touched[leastNode] = true; _touched[leastNode] = true;
m_OnOpen[leastNode] = false; _onOpen[leastNode] = false;
return leastNode; return leastNode;
} }
@ -282,11 +279,11 @@ namespace Server.PathAlgorithms.FastAStar
{ {
var px = p % AreaSize; var px = p % AreaSize;
var py = p / AreaSize % AreaSize; var py = p / AreaSize % AreaSize;
var pz = m_Nodes[p].z; var pz = _nodes[p].z;
var p3D = new Point3D(px + m_xOffset, py + m_yOffset, pz); var p3D = new Point3D(px + _xOffset, py + _yOffset, pz);
var vals = m_Successors; var vals = _successors;
var count = 0; var count = 0;
for (var i = 0; i < 8; ++i) for (var i = 0; i < 8; ++i)
@ -332,18 +329,18 @@ namespace Server.PathAlgorithms.FastAStar
x += px; x += px;
y += py; y += py;
if (x < 0 || x >= AreaSize || y < 0 || y >= AreaSize) if (x is < 0 or >= AreaSize || y is < 0 or >= AreaSize)
{ {
continue; continue;
} }
if (CalcMoves.CheckMovement(m, map, p3D, (Direction)i, out var z)) if (CalcMoves.CheckMovement(m, map, p3D, (Direction)i, out var z))
{ {
var idx = GetIndex(x + m_xOffset, y + m_yOffset, z); var idx = GetIndex(x + _xOffset, y + _yOffset, z);
if (idx >= 0 && idx < NodeCount) if (idx >= 0 && idx < NodeCount)
{ {
m_Nodes[idx].z = z; _nodes[idx].z = z;
vals[count++] = idx; vals[count++] = idx;
} }
} }

9
Projects/UOContent/Engines/Pathing/MovementPath.cs
View file

@ -3,7 +3,6 @@ using System.Diagnostics;
using Server.Items; using Server.Items;
using Server.PathAlgorithms; using Server.PathAlgorithms;
using Server.PathAlgorithms.FastAStar; using Server.PathAlgorithms.FastAStar;
using Server.PathAlgorithms.SlowAStar;
using Server.Spells; using Server.Spells;
using Server.Targeting; using Server.Targeting;
@ -89,18 +88,21 @@ namespace Server
var y = from.Y; var y = from.Y;
var z = from.Z; var z = from.Z;
WayPoint waypoint = null;
for (var i = 0; i < path.Directions.Length; ++i) for (var i = 0; i < path.Directions.Length; ++i)
{ {
Movement.Movement.Offset(path.Directions[i], ref x, ref y); Movement.Movement.Offset(path.Directions[i], ref x, ref y);
new RecallRune().MoveToWorld(new Point3D(x, y, z + zOffset), from.Map); waypoint = new WayPoint(waypoint);
waypoint.MoveToWorld(new Point3D(x, y, z + zOffset), from.Map);
} }
} }
} }
public static void Path_OnTarget(Mobile from, object targeted) public static void Path_OnTarget(Mobile from, object targeted)
{ {
if (!(targeted is IPoint3D p)) if (targeted is not IPoint3D p)
{ {
return; return;
} }
@ -108,7 +110,6 @@ namespace Server
SpellHelper.GetSurfaceTop(ref p); SpellHelper.GetSurfaceTop(ref p);
Path(from, p, FastAStarAlgorithm.Instance, "Fast", 0); Path(from, p, FastAStarAlgorithm.Instance, "Fast", 0);
Path(from, p, SlowAStarAlgorithm.Instance, "Slow", 2);
OverrideAlgorithm = null; OverrideAlgorithm = null;
} }
} }

314
Projects/UOContent/Engines/Pathing/SlowAStarAlgorithm.cs
View file

@ -1,314 +0,0 @@
using System;
using Server.Mobiles;
using CalcMoves = Server.Movement.Movement;
using MoveImpl = Server.Movement.MovementImpl;
namespace Server.PathAlgorithms.SlowAStar
{
public struct PathNode
{
public int x, y, z;
public int g, h;
public int px, py, pz;
public int dir;
}
public class SlowAStarAlgorithm : PathAlgorithm
{
private const int MaxDepth = 300;
private const int MaxNodes = MaxDepth * 16;
public static PathAlgorithm Instance = new SlowAStarAlgorithm();
private static readonly PathNode[] m_Closed = new PathNode[MaxNodes];
private static readonly PathNode[] m_Open = new PathNode[MaxNodes];
private static readonly PathNode[] m_Successors = new PathNode[8];
private static readonly Direction[] m_Path = new Direction[MaxNodes];
private Point3D m_Goal;
public int Heuristic(int x, int y, int z)
{
x -= m_Goal.X;
y -= m_Goal.Y;
z -= m_Goal.Z;
x *= 11;
y *= 11;
return x * x + y * y + z * z;
}
public override bool CheckCondition(Mobile m, Map map, Point3D start, Point3D goal) => false;
public override Direction[] Find(Mobile m, Map map, Point3D start, Point3D goal)
{
m_Goal = goal;
var bc = m as BaseCreature;
PathNode curNode;
var goalNode = new PathNode();
goalNode.x = goal.X;
goalNode.y = goal.Y;
goalNode.z = goal.Z;
var startNode = new PathNode();
startNode.x = start.X;
startNode.y = start.Y;
startNode.z = start.Z;
startNode.h = Heuristic(startNode.x, startNode.y, startNode.z);
PathNode[] closed = m_Closed, open = m_Open, successors = m_Successors;
var path = m_Path;
int closedCount = 0, openCount = 0;
var pathCount = 0;
var depth = 0;
var iBacktrack = 0;
open[openCount++] = startNode;
while (openCount > 0)
{
curNode = open[0];
var curF = curNode.g + curNode.h;
var popIndex = 0;
for (var i = 1; i < openCount; ++i)
{
if (open[i].g + open[i].h < curF)
{
curNode = open[i];
curF = curNode.g + curNode.h;
popIndex = i;
}
}
if (curNode.x == goalNode.x && curNode.y == goalNode.y && (curNode.z - goalNode.z).Abs() < 16)
{
if (closedCount == MaxNodes)
{
break;
}
closed[closedCount++] = curNode;
var xBacktrack = curNode.px;
var yBacktrack = curNode.py;
var zBacktrack = curNode.pz;
path[pathCount++] = (Direction)curNode.dir;
// if (pathCount == MaxNodes)
// {
// break;
// }
while (xBacktrack != startNode.x || yBacktrack != startNode.y || zBacktrack != startNode.z)
{
var found = false;
for (var j = 0; !found && j < closedCount; ++j)
{
if (closed[j].x == xBacktrack && closed[j].y == yBacktrack && closed[j].z == zBacktrack)
{
if (pathCount == MaxNodes)
{
break;
}
curNode = closed[j];
path[pathCount++] = (Direction)curNode.dir;
xBacktrack = curNode.px;
yBacktrack = curNode.py;
zBacktrack = curNode.pz;
found = true;
}
}
if (!found)
{
Console.WriteLine("bugaboo..");
return null;
}
if (pathCount == MaxNodes)
{
break;
}
}
if (pathCount == MaxNodes)
{
break;
}
var dirs = new Direction[pathCount];
while (pathCount > 0)
{
dirs[iBacktrack++] = path[--pathCount];
}
return dirs;
}
--openCount;
for (var i = popIndex; i < openCount; ++i)
{
open[i] = open[i + 1];
}
var sucCount = 0;
if (bc != null)
{
MoveImpl.AlwaysIgnoreDoors = bc.CanOpenDoors;
MoveImpl.IgnoreMovableImpassables = bc.CanMoveOverObstacles;
}
MoveImpl.Goal = goal;
int x;
int y;
int z;
for (var i = 0; i < 8; ++i)
{
switch (i)
{
default:
x = 0;
y = -1;
break;
case 1:
x = 1;
y = -1;
break;
case 2:
x = 1;
y = 0;
break;
case 3:
x = 1;
y = 1;
break;
case 4:
x = 0;
y = 1;
break;
case 5:
x = -1;
y = 1;
break;
case 6:
x = -1;
y = 0;
break;
case 7:
x = -1;
y = -1;
break;
}
if (CalcMoves.CheckMovement(m, map, new Point3D(curNode.x, curNode.y, curNode.z), (Direction)i, out z))
{
successors[sucCount].x = x + curNode.x;
successors[sucCount].y = y + curNode.y;
successors[sucCount++].z = z;
}
}
MoveImpl.AlwaysIgnoreDoors = false;
MoveImpl.IgnoreMovableImpassables = false;
MoveImpl.Goal = Point3D.Zero;
if (sucCount == 0 || ++depth > MaxDepth)
{
break;
}
for (var i = 0; i < sucCount; ++i)
{
x = successors[i].x;
y = successors[i].y;
z = successors[i].z;
successors[i].g = curNode.g + 1;
int openIndex = -1, closedIndex = -1;
for (var j = 0; openIndex == -1 && j < openCount; ++j)
{
if (open[j].x == x && open[j].y == y && open[j].z == z)
{
openIndex = j;
}
}
if (openIndex >= 0 && open[openIndex].g < successors[i].g)
{
continue;
}
for (var j = 0; closedIndex == -1 && j < closedCount; ++j)
{
if (closed[j].x == x && closed[j].y == y && closed[j].z == z)
{
closedIndex = j;
}
}
if (closedIndex >= 0 && closed[closedIndex].g < successors[i].g)
{
continue;
}
if (openIndex >= 0)
{
--openCount;
for (var j = openIndex; j < openCount; ++j)
{
open[j] = open[j + 1];
}
}
if (closedIndex >= 0)
{
--closedCount;
for (var j = closedIndex; j < closedCount; ++j)
{
closed[j] = closed[j + 1];
}
}
successors[i].px = curNode.x;
successors[i].py = curNode.y;
successors[i].pz = curNode.z;
successors[i].dir = (int)GetDirection(curNode.x, curNode.y, x, y);
successors[i].h = Heuristic(x, y, z);
if (openCount == MaxNodes)
{
break;
}
open[openCount++] = successors[i];
}
if (openCount == MaxNodes || closedCount == MaxNodes)
{
break;
}
closed[closedCount++] = curNode;
}
return null;
}
}
}

1
Projects/UOContent/Items/Misc/Waypoint.cs → Projects/UOContent/Items/Misc/WayPoint.cs
View file

@ -13,6 +13,7 @@ namespace Server.Items
Hue = 0x498; Hue = 0x498;
Visible = false; Visible = false;
// this.Movable = false; // this.Movable = false;
if (prev != null) if (prev != null)
{ {
prev.NextPoint = this; prev.NextPoint = this;