/// <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; }
/// <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 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); }
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 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), }); }
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 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); }