/// <summary>
/// Find route from src to dst, using the given positionings
/// </summary>
public static AStarResult Find(IEnvironmentObject env, IntVector3 src, DirectionSet srcPositioning, IntVector3 dst, DirectionSet dstPositioning,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
var initLocs = env.GetPositioningLocations(src, srcPositioning);
var target = new AStarDefaultTarget(env, dst, dstPositioning);
return Find(initLocs, target, maxNodeCount, cancellationToken);
}
/* Parallel */
/// <summary>
/// Returns if dst can be reached from src
/// </summary>
public static bool CanReach(IEnvironmentObject env, IntVector3 src, IntVector3 dst, DirectionSet dstPositioning)
{
Debug.Assert(env != null);
// Do pathfinding to both directions simultaneously to detect faster if the destination is blocked
CancellationTokenSource cts = new CancellationTokenSource();
AStarResult resBackward = null;
AStarResult resForward = null;
var taskForward = new Task(delegate
{
resForward = Find(env, src, DirectionSet.Exact, dst, dstPositioning, 200000, cts.Token);
});
taskForward.Start();
var taskBackward = new Task(delegate
{
resBackward = Find(env, dst, dstPositioning.Reverse(), src, DirectionSet.Exact, 200000, cts.Token);
});
taskBackward.Start();
Task.WaitAny(taskBackward, taskForward);
cts.Cancel();
Task.WaitAll(taskBackward, taskForward);
if (resForward.Status == AStarStatus.Found || resBackward.Status == AStarStatus.Found)
return true;
else
return false;
}
public FetchItemAssignment(IJobObserver parent, IEnvironmentObject env, IntVector3 location, IItemObject item, DirectionSet positioning)
: base(parent)
{
this.Item = item;
m_environment = env;
m_location = location;
m_state = State.None;
m_positioning = positioning;
this.LaborID = Dwarrowdelf.LaborID.Hauling;
}
public FetchItems(IJobObserver parent, IEnvironmentObject env, IntPoint3 location, IEnumerable<IItemObject> items, DirectionSet positioning)
: base(parent)
{
foreach (var item in items)
{
var job = new AssignmentGroups.FetchItemAssignment(this, env, location, item, positioning);
AddSubJob(job);
}
Debug.Assert(this.SubJobs.Count > 0);
}
public AnimatedSpriteDefinition this[Direction direction]
{
get { return _directions[(int)direction]; }
set
{
if (value == null) {
_directions[(int)direction] = null;
_availableDirections &= ~(DirectionSet)(1 << (int)direction);
}
else {
_directions[(int)direction] = value;
_availableDirections |= (DirectionSet)(1 << (int)direction);
}
}
}
/// <summary>
/// Find route from src to dest, finding the route in parallel from both directions
/// </summary>
public static IEnumerable<Direction> Find(IEnvironmentObject env, IntVector3 src, IntVector3 dest, DirectionSet positioning)
{
AStarResult resBackward;
AStarResult resForward;
ParallelFind(env, src, dest, positioning, out resBackward, out resForward);
IEnumerable<Direction> dirs;
if (resForward.Status == AStarStatus.Found)
dirs = resForward.GetPath();
else if (resBackward.Status == AStarStatus.Found)
dirs = resBackward.GetPathReverse();
else
dirs = null;
return dirs;
}
public TileModel GetModel(DirectionSet directions, SampleSet sampleSet, TileRotation tileRotation)
{
var samples = sampleSet.Samples;
var modelConfig = Config.Model ?? new Adjacent();
TileModel tileModel;
if (modelConfig is Overlapping overlapping)
{
var model = new OverlappingModel(overlapping.NX, overlapping.NY, overlapping.NZ);
foreach (var sample in samples)
{
model.AddSample(sample, tileRotation);
}
tileModel = model;
}
else if (modelConfig is Adjacent adjacent)
{
var model = new AdjacentModel(directions);
foreach (var sample in samples)
{
model.AddSample(sample, tileRotation);
}
tileModel = model;
}
else
{
throw new ConfigurationException($"Unrecognized model type {modelConfig.GetType()}");
}
var autoAdjacencies = Config.AutoAdjacency
? AdjacencyUtils.GetAutoAdjacencies(sampleSet, tileRotation, Config.AutoAdjacencyTolerance)
: new AdjacentModel.Adjacency[0];
var manualAdjacencies = GetManualAdjacencies(sampleSet.Directions, tileRotation);
SetupAdjacencies(tileModel, tileRotation, autoAdjacencies.Concat(manualAdjacencies).ToList());
SetupTiles(tileModel, tileRotation);
return(tileModel);
}
private IList <AdjacentModel.Adjacency> GetManualAdjacencies(DirectionSet directions, TileRotation tileRotation)
{
if (Config.Adjacencies == null)
{
return(new AdjacentModel.Adjacency[0]);
}
AdjacentModel.Adjacency Convert(AdjacencyData a)
{
return(new AdjacentModel.Adjacency
{
Src = a.Src.Select(Parse).Select(tileRotation.Canonicalize).ToArray(),
Dest = a.Dest.Select(Parse).Select(tileRotation.Canonicalize).ToArray(),
Direction = a.Direction,
});
}
return(AdjacencyUtils.Rotate(
Config.Adjacencies.Select(Convert).ToList(),
tileRotation.RotationGroup,
directions,
tileRotation));
}
/// <summary>
/// Find route from src to dest, finding the route in parallel from both directions
/// </summary>
public static IEnumerable<Direction> Find(IEnvironmentObject env, IntVector3 src, IntVector3 dest, DirectionSet positioning,
out IntVector3 finalLocation)
{
AStarResult resBackward;
AStarResult resForward;
ParallelFind(env, src, dest, positioning, out resBackward, out resForward);
IEnumerable<Direction> dirs;
if (resForward.Status == AStarStatus.Found)
{
dirs = resForward.GetPath();
finalLocation = resForward.LastNode.Loc;
}
else if (resBackward.Status == AStarStatus.Found)
{
dirs = resBackward.GetPathReverse();
AStarNode n = resBackward.LastNode;
while (n.Parent != null)
n = n.Parent;
finalLocation = n.Loc;
}
else
{
dirs = null;
finalLocation = new IntVector3();
}
return dirs;
}
/// <summary>
/// Find route from src to dst, using the given positionings
/// </summary>
public static AStarResult Find(IAStarEnvironment environment, IntPoint3 src, DirectionSet srcPositioning, IntPoint3 dst, DirectionSet dstPositioning,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
return Find(environment, src, srcPositioning, new AStarDefaultTarget(dst, dstPositioning),
maxNodeCount, cancellationToken);
}
public static IEnumerable<AStarResult> FindMany(IAStarEnvironment environment,
IntPoint3 src, DirectionSet srcPositioning, IAStarTarget target,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
var astar = new AStarImpl(environment, src, srcPositioning, target, maxNodeCount, cancellationToken);
AStarStatus status;
while ((status = astar.Find()) == AStarStatus.Found)
yield return new AStarResult(astar.Nodes, astar.LastNode, status);
}
protected MoveAssignmentBase(IJobObserver parent, IEnvironmentObject environment, DirectionSet positioning, IItemObject hauledItem)
: this(parent, environment, positioning)
{
this.HauledItem = hauledItem;
}
static void Main(string[] args)
{
Stopwatch sw = Stopwatch.StartNew();
//Test in closure
{
string gameJson = "{ \"id\":\"s2xh3aig\", \"turn\":1100, \"maxTurns\":1200, \"heroes\":[ { \"id\":1, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":5, \"y\":6 }, \"life\":60, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":5, \"y\":6 }, \"crashed\":true }, { \"id\":2, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":12, \"y\":6 }, \"life\":100, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":12, \"y\":6 }, \"crashed\":true }, { \"id\":3, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":12, \"y\":11 }, \"life\":80, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":12, \"y\":11 }, \"crashed\":true }, { \"id\":4, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":4, \"y\":8 }, \"lastDir\": \"South\", \"life\":38, \"gold\":1078, \"mineCount\":6, \"spawnPos\":{ \"x\":5, \"y\":11 }, \"crashed\":false } ], \"board\":{ \"size\":18, \"tiles\":\"############## ############################ ############################## ##############################$4 $4############################ @4 ######################## @1## ## #################### [] [] ################## #### #################### $4####$4 ######################## $4####$4 #################### #### ################## [] [] #################### @2## ##@3 ######################## ############################$- $-############################## ############################## ############################ ##############\" }, \"finished\":true }";
string heroJson = " { \"id\":1, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":5, \"y\":6 }, \"lastDir\": \"South\", \"life\":60, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":5, \"y\":6 }, \"crashed\":true }";
Game game = Game.FromJson(gameJson);
Hero hero = Hero.FromJson(heroJson);
}
string gameStepJson = "{ \"game\":{ \"id\":\"s2xh3aig\", \"turn\":1100, \"maxTurns\":1200, \"heroes\":[ { \"id\":1, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":5, \"y\":6 }, \"life\":60, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":5, \"y\":6 }, \"crashed\":true }, { \"id\":2, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":12, \"y\":6 }, \"life\":100, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":12, \"y\":6 }, \"crashed\":true }, { \"id\":3, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":12, \"y\":11 }, \"life\":80, \"gold\":0, \"mineCount\":0, \"spawnPos\":{ \"x\":12, \"y\":11 }, \"crashed\":true }, { \"id\":4, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":4, \"y\":8 }, \"lastDir\": \"South\", \"life\":38, \"gold\":1078, \"mineCount\":6, \"spawnPos\":{ \"x\":5, \"y\":11 }, \"crashed\":false } ], \"board\":{ \"size\":18, \"tiles\":\"############## ############################ ############################## ##############################$4 $4############################ @4 ######################## @1## ## #################### [] [] ################## #### #################### $4####$4 ######################## $4####$4 #################### #### ################## [] [] #################### @2## ##@3 ######################## ############################$- $-############################## ############################## ############################ ##############\" }, \"finished\":true }, \"hero\":{ \"id\":4, \"name\":\"vjousse\", \"userId\":\"j07ws669\", \"elo\":1200, \"pos\":{ \"x\":4, \"y\":8 }, \"lastDir\": \"South\", \"life\":38, \"gold\":1078, \"mineCount\":6, \"spawnPos\":{ \"x\":5, \"y\":11 }, \"crashed\":false }, \"token\":\"lte0\", \"viewUrl\":\"http://localhost:9000/s2xh3aig\", \"playUrl\":\"http://localhost:9000/api/s2xh3aig/lte0/play\" }";
GameState state = GameState.FromJson(gameStepJson);
Console.WriteLine(state.Game.Board.ToString());
Console.WriteLine(string.Format("{0:#,0} ms", sw.ElapsedMilliseconds));
Hero myHero = state.Game.Heroes.First(x => x.ID == 1);
Tile hero1Tile = state.Game.FindHeroes(x => x.OwnerId == 1).FirstOrDefault();
Tile hero3Tile = state.Game.FindHeroes(x => x.OwnerId == 3).FirstOrDefault();
IEnumerable <Tile> goldMines = state.Game.FindGoldMines(x => true);
sw.Restart();
PathFinder pathFinder = new PathFinder(state.Game.Board);
var safeTravelFunc = new Func <Node, NodeStatus>(node => {
Tile t = node as Tile;
var neighbors = state.Game.Board.GetNeighboringNodes(t, 1, true).Select(x => x as Tile);
foreach (var x in neighbors)
{
//Any heros in the area?
if (x.TileType == Tile.TileTypes.Hero &&
x.OwnerId != myHero.ID)
{
//Dangerous heros in the way?
Hero h = state.Game.LookupHero(x);
if (h != null)
{
//Avoid!
return(new NodeStatus(30, true));
}
}
}
return(new NodeStatus(1, false));
});
//Map all gold mines
var pathsToGoldMines = state.Game.FindPathsToGoldMines(hero1Tile, x => true, safeTravelFunc).ToList();
Console.WriteLine(string.Format("{0:#,0} ms", sw.ElapsedMilliseconds));
foreach (var path in pathsToGoldMines)
{
sw.Restart();
Console.WriteLine(state.Game.Board.ToString(path));
Console.WriteLine(string.Format("{0:#,0} ms", sw.ElapsedMilliseconds));
}
sw.Restart();
DirectionSet path2 = state.Game.FindPath(hero1Tile, hero3Tile);
Console.WriteLine(string.Format("{0:#,0} ms", sw.ElapsedMilliseconds));
Console.WriteLine(state.Game.Board.ToString(path2));
Console.ReadLine();
}
public GridTopology GetOutputTopology(DirectionSet directions)
{
var is3d = directions.Type == DirectionSetType.Cartesian3d;
return(new GridTopology(directions, Config.Width, Config.Height, is3d ? Config.Depth : 1, Config.PeriodicX, Config.PeriodicY, Config.PeriodicZ));
}
/// <summary>
/// Find route from src to dest, finding the route in parallel from both directions
/// </summary>
public static IEnumerable <Direction> Find(IEnvironmentObject env, IntVector3 src, IntVector3 dest, DirectionSet positioning)
{
AStarResult resBackward;
AStarResult resForward;
ParallelFind(env, src, dest, positioning, out resBackward, out resForward);
IEnumerable <Direction> dirs;
if (resForward.Status == AStarStatus.Found)
{
dirs = resForward.GetPath();
}
else if (resBackward.Status == AStarStatus.Found)
{
dirs = resBackward.GetPathReverse();
}
else
{
dirs = null;
}
return(dirs);
}
public AStarDefaultTarget(IEnvironmentObject env, IntVector3 destination, DirectionSet positioning)
: base(env)
{
m_destination = destination;
m_positioning = positioning;
}
public MyTarget(Map env, IntVector3 destination, DirectionSet positioning)
{
m_env = env;
m_destination = destination;
m_positioning = positioning;
}
public MyTarget(Map env, IntVector3 destination, DirectionSet positioning)
{
m_env = env;
m_destination = destination;
m_positioning = positioning;
}
/// <summary>
/// Return enterable positions around the given location, based on positioning
/// </summary>
public static IEnumerable <IntVector3> GetPositioningLocations(this IEnvironmentObject env, IntVector3 pos,
DirectionSet positioning)
{
return(positioning.ToSurroundingPoints(pos).Where(p => CanEnter(env, p)));
}
public FetchItemAssignment(IJobObserver parent, IEnvironmentObject env, IntVector3 location, IItemObject item, DirectionSet positioning)
: base(parent)
{
this.Item = item;
m_environment = env;
m_location = location;
m_state = State.None;
m_positioning = positioning;
this.LaborID = Dwarrowdelf.LaborID.Hauling;
}
public static IEnumerable<AStarResult> FindMany(IEnvironmentObject env,
IntVector3 src, DirectionSet srcPositioning, IAStarTarget target,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
var initLocs = env.GetPositioningLocations(src, srcPositioning);
var astar = new AStar(initLocs, target);
astar.MaxNodeCount = maxNodeCount;
if (cancellationToken.HasValue)
astar.CancellationToken = cancellationToken.Value;
AStarStatus status;
while ((status = astar.Find()) == AStarStatus.Found)
yield return new AStarResult(status, astar.LastNode);
}
static void ParallelFind(IEnvironmentObject env, IntVector3 src, IntVector3 dest, DirectionSet positioning, out AStarResult resBackward, out AStarResult resForward)
{
Debug.Assert(env != null);
// Do pathfinding to both directions simultaneously to detect faster if the destination is blocked
CancellationTokenSource cts = new CancellationTokenSource();
AStarResult rb = null;
AStarResult rf = null;
var taskForward = new Task(delegate
{
rf = Find(env, src, DirectionSet.Exact, dest, positioning, 200000, cts.Token);
});
taskForward.Start();
var taskBackward = new Task(delegate
{
rb = Find(env, dest, positioning.Reverse(), src, DirectionSet.Exact, 200000, cts.Token);
});
taskBackward.Start();
Task.WaitAny(taskBackward, taskForward);
cts.Cancel();
Task.WaitAll(taskBackward, taskForward);
resForward = rf;
resBackward = rb;
}
/// <summary>
/// Find route from src to dest, finding the route in parallel from both directions
/// </summary>
public static IEnumerable <Direction> Find(IEnvironmentObject env, IntVector3 src, IntVector3 dest, DirectionSet positioning,
out IntVector3 finalLocation)
{
AStarResult resBackward;
AStarResult resForward;
ParallelFind(env, src, dest, positioning, out resBackward, out resForward);
IEnumerable <Direction> dirs;
if (resForward.Status == AStarStatus.Found)
{
dirs = resForward.GetPath();
finalLocation = resForward.LastNode.Loc;
}
else if (resBackward.Status == AStarStatus.Found)
{
dirs = resBackward.GetPathReverse();
AStarNode n = resBackward.LastNode;
while (n.Parent != null)
{
n = n.Parent;
}
finalLocation = n.Loc;
}
else
{
dirs = null;
finalLocation = new IntVector3();
}
return(dirs);
}
public MoveToAreaAssignment(IJobObserver parent, IEnvironmentObject environment, IntGrid3 destination, DirectionSet positioning)
: base(parent, environment, positioning)
{
m_dest = destination;
}
/// <summary>
/// Find route from src to dst, using the given positionings
/// </summary>
public static AStarResult Find(IEnvironmentObject env, IntVector3 src, DirectionSet srcPositioning, IntVector3 dst, DirectionSet dstPositioning,
int maxNodeCount = 200000, CancellationToken?cancellationToken = null)
{
var initLocs = env.GetPositioningLocations(src, srcPositioning);
var target = new AStarDefaultTarget(env, dst, dstPositioning);
return(Find(initLocs, target, maxNodeCount, cancellationToken));
}
public List <ITileConstraint> GetConstraints(DirectionSet directions, TileRotation tileRotation)
{
var is3d = directions.Type == DirectionSetType.Cartesian3d;
var constraints = new List <ITileConstraint>();
if (Config.Ground != null)
{
var groundTile = Parse(Config.Ground);
constraints.Add(new BorderConstraint
{
Sides = is3d ? BorderSides.ZMin : BorderSides.YMax,
Tiles = new[] { groundTile },
});
constraints.Add(new BorderConstraint
{
Sides = is3d ? BorderSides.ZMin : BorderSides.YMax,
Tiles = new[] { groundTile },
InvertArea = true,
Ban = true,
});
}
if (Config.Constraints != null)
{
foreach (var constraint in Config.Constraints)
{
if (constraint is PathConfig pathData)
{
var tiles = new HashSet <Tile>(pathData.Tiles.Select(Parse));
#pragma warning disable CS0618 // Type or member is obsolete
var p = new PathConstraint(tiles, pathData.EndPoints, tileRotation)
#pragma warning restore CS0618 // Type or member is obsolete
{
EndPointTiles = pathData.EndPointTiles == null ? null : new HashSet <Tile>(pathData.EndPointTiles.Select(Parse))
};
constraints.Add(p);
}
else if (constraint is EdgedPathConfig edgedPathData)
{
var exits = edgedPathData.Exits.ToDictionary(
kv => Parse(kv.Key), x => (ISet <Direction>) new HashSet <Direction>(x.Value.Select(ParseDirection)));
#pragma warning disable CS0618 // Type or member is obsolete
var p = new EdgedPathConstraint(exits, edgedPathData.EndPoints, tileRotation)
#pragma warning restore CS0618 // Type or member is obsolete
{
EndPointTiles = edgedPathData.EndPointTiles == null ? null : new HashSet <Tile>(edgedPathData.EndPointTiles.Select(Parse))
};
constraints.Add(p);
}
else if (constraint is BorderConfig borderData)
{
var tiles = borderData.Tiles.Select(Parse).ToArray();
var sides = borderData.Sides == null ? BorderSides.All : (BorderSides)Enum.Parse(typeof(BorderSides), borderData.Sides, true);
var excludeSides = borderData.ExcludeSides == null ? BorderSides.None : (BorderSides)Enum.Parse(typeof(BorderSides), borderData.ExcludeSides, true);
if (!is3d)
{
sides = sides & ~BorderSides.ZMin & ~BorderSides.ZMax;
excludeSides = excludeSides & ~BorderSides.ZMin & ~BorderSides.ZMax;
}
constraints.Add(new BorderConstraint
{
Tiles = tiles,
Sides = sides,
ExcludeSides = excludeSides,
InvertArea = borderData.InvertArea,
Ban = borderData.Ban,
});
}
else if (constraint is FixedTileConfig fixedTileConfig)
{
constraints.Add(new FixedTileConstraint
{
Tiles = fixedTileConfig.Tiles.Select(Parse).ToArray(),
Point = fixedTileConfig.Point,
});
}
else if (constraint is MaxConsecutiveConfig maxConsecutiveConfig)
{
var axes = maxConsecutiveConfig.Axes?.Select(ParseAxis);
constraints.Add(new MaxConsecutiveConstraint
{
Tiles = new HashSet <Tile>(maxConsecutiveConfig.Tiles.Select(Parse)),
MaxCount = maxConsecutiveConfig.MaxCount,
Axes = axes == null ? null : new HashSet <Axis>(axes),
});
}
else if (constraint is MirrorXConfig mirrorYConfig)
{
constraints.Add(new MirrorXConstraint
{
TileRotation = tileRotation,
});
}
else if (constraint is MirrorYConfig mirrorXConfig)
{
constraints.Add(new MirrorYConstraint
{
TileRotation = tileRotation,
});
}
else if (constraint is CountConfig countConfig)
{
constraints.Add(new CountConstraint
{
Tiles = new HashSet <Tile>(countConfig.Tiles.Select(Parse)),
Comparison = countConfig.Comparison,
Count = countConfig.Count,
Eager = countConfig.Eager,
});
}
else if (constraint is SeparationConfig separationConfig)
{
constraints.Add(new SeparationConstraint
{
Tiles = new HashSet <Tile>(separationConfig.Tiles.Select(Parse)),
MinDistance = separationConfig.MinDistance,
});
}
else if (constraint is ConnectedConfig connectedConfig)
{
constraints.Add(new ConnectedConstraint
{
PathSpec = GetPathSpec(connectedConfig.PathSpec),
});
}
else if (constraint is LoopConfig loopConfig)
{
constraints.Add(new LoopConstraint
{
PathSpec = GetPathSpec(loopConfig.PathSpec),
});
}
else if (constraint is AcyclicConfig acyclicConfig)
{
constraints.Add(new AcyclicConstraint
{
PathSpec = GetPathSpec(acyclicConfig.PathSpec),
});
}
else
{
throw new NotImplementedException($"Unknown constraint type {constraint.GetType()}");
}
}
}
return(constraints);
}
static void ParallelFind(IEnvironmentObject env, IntVector3 src, IntVector3 dest, DirectionSet positioning, out AStarResult resBackward, out AStarResult resForward)
{
Debug.Assert(env != null);
// Do pathfinding to both directions simultaneously to detect faster if the destination is blocked
CancellationTokenSource cts = new CancellationTokenSource();
AStarResult rb = null;
AStarResult rf = null;
var taskForward = new Task(delegate
{
rf = Find(env, src, DirectionSet.Exact, dest, positioning, 200000, cts.Token);
});
taskForward.Start();
var taskBackward = new Task(delegate
{
rb = Find(env, dest, positioning.Reverse(), src, DirectionSet.Exact, 200000, cts.Token);
});
taskBackward.Start();
Task.WaitAny(taskBackward, taskForward);
cts.Cancel();
Task.WaitAll(taskBackward, taskForward);
resForward = rf;
resBackward = rb;
}
protected MoveAssignmentBase(IJobObserver parent, IEnvironmentObject environment, DirectionSet positioning)
: base(parent)
{
m_environment = environment;
m_positioning = positioning;
}
/* Parallel */
/// <summary>
/// Returns if dst can be reached from src
/// </summary>
public static bool CanReach(IEnvironmentObject env, IntVector3 src, IntVector3 dst, DirectionSet dstPositioning)
{
Debug.Assert(env != null);
// Do pathfinding to both directions simultaneously to detect faster if the destination is blocked
CancellationTokenSource cts = new CancellationTokenSource();
AStarResult resBackward = null;
AStarResult resForward = null;
var taskForward = new Task(delegate
{
resForward = Find(env, src, DirectionSet.Exact, dst, dstPositioning, 200000, cts.Token);
});
taskForward.Start();
var taskBackward = new Task(delegate
{
resBackward = Find(env, dst, dstPositioning.Reverse(), src, DirectionSet.Exact, 200000, cts.Token);
});
taskBackward.Start();
Task.WaitAny(taskBackward, taskForward);
cts.Cancel();
Task.WaitAll(taskBackward, taskForward);
if (resForward.Status == AStarStatus.Found || resBackward.Status == AStarStatus.Found)
{
return(true);
}
else
{
return(false);
}
}
public static IEnumerable<AStarResult> FindMany(IAStarEnvironment environment,
IntPoint3 src, DirectionSet srcPositioning, Func<IntPoint3, bool> func,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
return FindMany(environment, src, srcPositioning, new AStarDelegateTarget(func), maxNodeCount, cancellationToken);
}
public MoveToAreaAssignment(IJobObserver parent, IEnvironmentObject environment, IntGrid3 destination, DirectionSet positioning)
: base(parent, environment, positioning)
{
m_dest = destination;
}
public AStarImpl(IAStarEnvironment environment, IntPoint3 src, DirectionSet srcPositioning,
IAStarTarget target, int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
m_environment = environment;
m_src = src;
m_srcPositioning = srcPositioning;
m_maxNodeCount = maxNodeCount;
m_cancellationToken = cancellationToken.HasValue ? cancellationToken.Value : CancellationToken.None;
m_target = target;
m_nodeMap = new Dictionary<IntPoint3, AStarNode>();
m_openList = new BinaryHeap<AStarNode>();
AddInitialNodes();
}
/// <summary>
/// Constructs a 2d topology.
/// </summary>
public GridTopology(DirectionSet directions, int width, int height, bool periodicX, bool periodicY, bool[] mask = null)
: this(directions, width, height, 1, periodicX, periodicY, false, mask)
{
}
/// <summary>
/// Find route from src to destination defined by IAstarTarget
/// </summary>
public static AStarResult Find(IAStarEnvironment environment, IntPoint3 src, DirectionSet srcPositioning, IAStarTarget target,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
var astar = new AStarImpl(environment, src, srcPositioning, target, maxNodeCount, cancellationToken);
var status = astar.Find();
return new AStarResult(astar.Nodes, astar.LastNode, status);
}
public List <ITileConstraint> GetConstraints(DirectionSet directions, TileRotation tileRotation)
{
var is3d = directions.Type == DirectionSetType.Cartesian3d;
var constraints = new List <ITileConstraint>();
if (Config.Ground != null)
{
var groundTile = Parse(Config.Ground);
constraints.Add(new BorderConstraint
{
Sides = is3d ? BorderSides.ZMin : BorderSides.YMax,
Tiles = new[] { groundTile },
});
constraints.Add(new BorderConstraint
{
Sides = is3d ? BorderSides.ZMin : BorderSides.YMax,
Tiles = new[] { groundTile },
InvertArea = true,
Ban = true,
});
}
if (Config.Constraints != null)
{
foreach (var constraint in Config.Constraints)
{
if (constraint is PathConfig pathData)
{
var tiles = new HashSet <Tile>(pathData.Tiles.Select(Parse));
var p = new PathConstraint(tiles, pathData.EndPoints);
constraints.Add(p);
}
else if (constraint is EdgedPathConfig edgedPathData)
{
var exits = edgedPathData.Exits.ToDictionary(
kv => Parse(kv.Key), x => (ISet <Direction>) new HashSet <Direction>(x.Value.Select(ParseDirection)));
var p = new EdgedPathConstraint(exits, edgedPathData.EndPoints, tileRotation);
constraints.Add(p);
}
else if (constraint is BorderConfig borderData)
{
var tiles = borderData.Tiles.Select(Parse).ToArray();
var sides = borderData.Sides == null ? BorderSides.All : (BorderSides)Enum.Parse(typeof(BorderSides), borderData.Sides, true);
var excludeSides = borderData.ExcludeSides == null ? BorderSides.None : (BorderSides)Enum.Parse(typeof(BorderSides), borderData.ExcludeSides, true);
if (!is3d)
{
sides = sides & ~BorderSides.ZMin & ~BorderSides.ZMax;
excludeSides = excludeSides & ~BorderSides.ZMin & ~BorderSides.ZMax;
}
constraints.Add(new BorderConstraint
{
Tiles = tiles,
Sides = sides,
ExcludeSides = excludeSides,
InvertArea = borderData.InvertArea,
Ban = borderData.Ban,
});
}
else if (constraint is FixedTileConfig fixedTileConfig)
{
constraints.Add(new FixedTileConstraint
{
Tiles = fixedTileConfig.Tiles.Select(Parse).ToArray(),
Point = fixedTileConfig.Point,
});
}
else if (constraint is MaxConsecutiveConfig maxConsecutiveConfig)
{
var axes = maxConsecutiveConfig.Axes?.Select(ParseAxis);
constraints.Add(new MaxConsecutiveConstraint
{
Tiles = new HashSet <Tile>(maxConsecutiveConfig.Tiles.Select(Parse)),
MaxCount = maxConsecutiveConfig.MaxCount,
Axes = axes == null ? null : new HashSet <Axis>(axes),
});
}
else if (constraint is MirrorConfig mirrorConfig)
{
constraints.Add(new MirrorConstraint
{
TileRotation = tileRotation,
});
}
else
{
throw new NotImplementedException($"Unknown constraint type {constraint.GetType()}");
}
}
}
return(constraints);
}
public static IEnumerable<AStarResult> FindMany(IEnvironmentObject env,
IntVector3 src, DirectionSet srcPositioning, Func<IntVector3, bool> func,
int maxNodeCount = 200000, CancellationToken? cancellationToken = null)
{
var target = new AStarDelegateTarget(env, func);
return FindMany(env, src, srcPositioning, target, maxNodeCount, cancellationToken);
}
public static AdjacentModel.Adjacency Rotate(AdjacentModel.Adjacency adjacency, Rotation rotation, DirectionSet directions, TileRotation tileRotation)
{
return(new AdjacentModel.Adjacency
{
Src = tileRotation.Rotate(adjacency.Src, rotation).ToArray(),
Dest = tileRotation.Rotate(adjacency.Dest, rotation).ToArray(),
Direction = TopoArrayUtils.RotateDirection(directions, adjacency.Direction, rotation),
});
}
protected MoveAssignmentBase(IJobObserver parent, IEnvironmentObject environment, DirectionSet positioning)
: base(parent)
{
m_environment = environment;
m_positioning = positioning;
}
public static IList <AdjacentModel.Adjacency> Rotate(IList <AdjacentModel.Adjacency> adjacencies, Rotation rotation, DirectionSet directions, TileRotation tileRotation)
{
return(adjacencies
.Select(x => Rotate(x, rotation, directions, tileRotation))
.Where(x => x.Src.Length > 0 && x.Dest.Length > 0)
.ToList());
}
public AStarDefaultTarget(IEnvironmentObject env, IntVector3 destination, DirectionSet positioning)
: base(env)
{
m_destination = destination;
m_positioning = positioning;
}
public static IList <AdjacentModel.Adjacency> Rotate(IList <AdjacentModel.Adjacency> adjacencies, RotationGroup rg, DirectionSet directions, TileRotation tileRotation)
{
return(rg.SelectMany(r => Rotate(adjacencies, r, directions, tileRotation)).ToList());
}
public HaulAssignment(IJobObserver parent, IEnvironmentObject environment, IntVector3 destination, DirectionSet positioning, IItemObject hauledItem)
: base(parent, environment, positioning, hauledItem)
{
m_dest = destination;
}
public AStarDefaultTarget(IntPoint3 destination, DirectionSet positioning)
{
m_destination = destination;
m_positioning = positioning;
}
public HaulToAreaAssignment(IJobObserver parent, IEnvironmentObject environment, IntGrid3 destination, DirectionSet positioning, IItemObject hauledItem)
: base(parent, environment, positioning, hauledItem)
{
m_dest = destination;
}
public FetchItems(IJobObserver parent, IEnvironmentObject env, IntVector3 location, IEnumerable <IItemObject> items, DirectionSet positioning)
: base(parent)
{
foreach (var item in items)
{
var job = new AssignmentGroups.FetchItemAssignment(this, env, location, item, positioning);
AddSubJob(job);
}
Debug.Assert(this.SubJobs.Count > 0);
}
/// <summary>
/// Return enterable positions around the given location, based on positioning
/// </summary>
public static IEnumerable<IntVector3> GetPositioningLocations(this IEnvironmentObject env, IntVector3 pos,
DirectionSet positioning)
{
return positioning.ToSurroundingPoints(pos).Where(p => CanEnter(env, p));
}
public static bool Contains(this DirectionSet dirset, Direction dir)
{
var ds = dir.ToDirectionSet();
return((dirset & ds) != 0);
}
/// <summary>
/// Constructs an AdjacentModel.
/// </summary>
public AdjacentModel(DirectionSet directions)
: this()
{
SetDirections(directions);
}
protected MoveAssignmentBase(IJobObserver parent, IEnvironmentObject environment, DirectionSet positioning, IItemObject hauledItem)
: this(parent, environment, positioning)
{
this.HauledItem = hauledItem;
}
