public static IPathSearch FromPoints(World world, Locomotor locomotor, Actor self, IEnumerable <CPos> froms, CPos target, BlockedByActor check) { var graph = new PathGraph(LayerPoolForWorld(world), locomotor, self, world, check); var search = new PathSearch(graph); search.heuristic = search.DefaultEstimator(target); // The search will aim for the shortest path by default, a weight of 100%. // We can allow the search to find paths that aren't optimal by changing the weight. // We provide a weight that limits the worst case length of the path, // e.g. a weight of 110% will find a path no more than 10% longer than the shortest possible. // The benefit of allowing the search to return suboptimal paths is faster computation time. // The search can skip some areas of the search space, meaning it has less work to do. // We allow paths up to 25% longer than the shortest, optimal path, to improve pathfinding time. search.heuristicWeightPercentage = 125; search.isGoal = loc => { var locInfo = search.Graph[loc]; return(locInfo.EstimatedTotal - locInfo.CostSoFar == 0); }; foreach (var sl in froms) { if (world.Map.Contains(sl)) { search.AddInitialCell(sl); } } return(search); }
public PathGraph(CellInfoLayerPool layerPool, Locomotor locomotor, Actor actor, World world, BlockedByActor check, Func <CPos, int> customCost, Actor ignoreActor, bool inReverse, bool laneBias) { customMovementLayers = world.GetCustomMovementLayers(); customMovementLayersEnabledForLocomotor = customMovementLayers.Count(cml => cml != null && cml.EnabledForLocomotor(locomotor.Info)); this.locomotor = locomotor; this.world = world; this.actor = actor; this.check = check; this.customCost = customCost; this.ignoreActor = ignoreActor; this.inReverse = inReverse; this.laneBias = laneBias; checkTerrainHeight = world.Map.Grid.MaximumTerrainHeight > 0; // As we support a search over the whole map area, // use the pool to grab the CellInfos we need to track the graph state. // This allows us to avoid the cost of allocating large arrays constantly. // PERF: Avoid LINQ pooledLayer = layerPool.Get(); cellInfoForLayer = new CellLayer <CellInfo> [customMovementLayers.Length]; cellInfoForLayer[0] = pooledLayer.GetLayer(); foreach (var cml in customMovementLayers) { if (cml != null && cml.EnabledForLocomotor(locomotor.Info)) { cellInfoForLayer[cml.Index] = pooledLayer.GetLayer(); } } }
public PathGraph(CellInfoLayerPool layerPool, Locomotor locomotor, Actor actor, World world, BlockedByActor check) { this.locomotor = locomotor; // As we support a search over the whole map area, // use the pool to grab the CellInfos we need to track the graph state. // This allows us to avoid the cost of allocating large arrays constantly. // PERF: Avoid LINQ var cmls = world.GetCustomMovementLayers(); pooledLayer = layerPool.Get(); cellInfoForLayer = new CellLayer <CellInfo> [cmls.Length]; cellInfoForLayer[0] = pooledLayer.GetLayer(); foreach (var cml in cmls) { if (cml != null && cml.EnabledForLocomotor(locomotor.Info)) { cellInfoForLayer[cml.Index] = pooledLayer.GetLayer(); } } World = world; Actor = actor; LaneBias = 1; checkConditions = check; checkTerrainHeight = world.Map.Grid.MaximumTerrainHeight > 0; }
void Awake() { Graphic = GetComponent<Graphic>(); Locomotor = GetComponent<Locomotor>(); Animator = GetComponentInChildren<Animator>(); Sprite = GetComponentInChildren<SpriteRenderer>(); GetBrain(); }
public MinerTraitWrapper(Actor actor) { Actor = actor; var mobile = actor.Trait <Mobile>(); Locomotor = mobile.Locomotor; Transforms = actor.Trait <Transforms>(); }
public HarvesterTraitWrapper(Actor actor) { Actor = actor; Harvester = actor.Trait <Harvester>(); var mobile = actor.Trait <Mobile>(); Locomotor = mobile.Locomotor; }
public static IPathSearch Search(World world, Locomotor locomotor, Actor self, BlockedByActor check, Func <CPos, bool> goalCondition) { var graph = new PathGraph(LayerPoolForWorld(world), locomotor, self, world, check); var search = new PathSearch(graph); search.isGoal = goalCondition; search.heuristic = loc => 0; return(search); }
public static PathSearch ToTargetCell( World world, Locomotor locomotor, Actor self, CPos from, CPos target, BlockedByActor check, Func <CPos, int> customCost = null, Actor ignoreActor = null, bool inReverse = false, bool laneBias = DefaultLaneBias) { return(ToTargetCell(world, locomotor, self, new[] { from }, target, check, customCost, ignoreActor, inReverse, laneBias)); }
// Start is called before the first frame update void Start() { locomotor = GetComponent <Locomotor>(); bomber = GetComponent <Bomber>(); turret = this.transform.GetChild(2).gameObject; if (pcControl) { moveJoystick.gameObject.SetActive(false); aimJoystick.gameObject.SetActive(false); } }
protected DensePathGraph(Locomotor locomotor, Actor actor, World world, BlockedByActor check, Func <CPos, int> customCost, Actor ignoreActor, bool laneBias, bool inReverse) { CustomMovementLayers = world.GetCustomMovementLayers(); customMovementLayersEnabledForLocomotor = CustomMovementLayers.Count(cml => cml != null && cml.EnabledForLocomotor(locomotor.Info)); this.locomotor = locomotor; this.world = world; this.actor = actor; this.check = check; this.customCost = customCost; this.ignoreActor = ignoreActor; this.laneBias = laneBias; this.inReverse = inReverse; checkTerrainHeight = world.Map.Grid.MaximumTerrainHeight > 0; }
public static PathSearch ToTargetCellByPredicate( World world, Locomotor locomotor, Actor self, IEnumerable <CPos> froms, Func <CPos, bool> targetPredicate, BlockedByActor check, Func <CPos, int> customCost = null) { var graph = new PathGraph(LayerPoolForWorld(world), locomotor, self, world, check, customCost, null, false, DefaultLaneBias); var search = new PathSearch(graph, loc => 0, DefaultHeuristicWeightPercentage, targetPredicate); foreach (var sl in froms) { if (world.Map.Contains(sl)) { search.AddInitialCell(sl); } } return(search); }
/// <summary> /// Default: Diagonal distance heuristic. More information: /// http://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html /// Layers are ignored and incur no additional cost. /// </summary> /// <param name="locomotor">Locomotor used to provide terrain costs.</param> /// <returns>A delegate that calculates the cost estimation between the given cells.</returns> public static Func <CPos, CPos, int> DefaultCostEstimator(Locomotor locomotor) { // Determine the minimum possible cost for moving horizontally between cells based on terrain speeds. // The minimum possible cost diagonally is then Sqrt(2) times more costly. var cellCost = locomotor.Info.TerrainSpeeds.Values.Min(ti => ti.Cost); var diagonalCellCost = Exts.MultiplyBySqrtTwo(cellCost); return((here, destination) => { var diag = Math.Min(Math.Abs(here.X - destination.X), Math.Abs(here.Y - destination.Y)); var straight = Math.Abs(here.X - destination.X) + Math.Abs(here.Y - destination.Y); // According to the information link, this is the shape of the function. // We just extract factors to simplify. // Possible simplification: var h = Constants.CellCost * (straight + (Constants.Sqrt2 - 2) * diag); return cellCost * straight + (diagonalCellCost - 2 * cellCost) * diag; }); }
public MapPathGraph(CellInfoLayerPool layerPool, Locomotor locomotor, Actor actor, World world, BlockedByActor check, Func <CPos, int> customCost, Actor ignoreActor, bool laneBias, bool inReverse) : base(locomotor, actor, world, check, customCost, ignoreActor, laneBias, inReverse) { // As we support a search over the whole map area, // use the pool to grab the CellInfos we need to track the graph state. // This allows us to avoid the cost of allocating large arrays constantly. // PERF: Avoid LINQ pooledLayer = layerPool.Get(); cellInfoForLayer = new CellLayer <CellInfo> [CustomMovementLayers.Length]; cellInfoForLayer[0] = pooledLayer.GetLayer(); foreach (var cml in CustomMovementLayers) { if (cml != null && cml.EnabledForLocomotor(locomotor.Info)) { cellInfoForLayer[cml.Index] = pooledLayer.GetLayer(); } } }
void Awake() { // Setup Dependancies animator = GetComponent<Animation>(); audioSource = GetComponent<AudioSource>(); locomotor = GetComponent<Locomotor>(); acquirer = GetComponent<Acquirer>(); stats = GetComponent<Stats>(); // Setup Components if (animationClip != null) { animationClip.wrapMode = WrapMode.Loop; animator.clip = animationClip; animator.Play(); } rigidbody.freezeRotation = true; //rigidbody.useGravity = false; Hungry = true; }
public static IPathSearch FromPoints(World world, Locomotor locomotor, Actor self, IEnumerable <CPos> froms, CPos target, bool checkForBlocked) { var graph = new PathGraph(LayerPoolForWorld(world), locomotor, self, world, checkForBlocked); var search = new PathSearch(graph) { heuristic = DefaultEstimator(target) }; search.isGoal = loc => { var locInfo = search.Graph[loc]; return(locInfo.EstimatedTotal - locInfo.CostSoFar == 0); }; foreach (var sl in froms.Where(sl => world.Map.Contains(sl))) { search.AddInitialCell(sl); } return(search); }
public static IPathSearch FromPoint(World world, Locomotor locomotor, Actor self, CPos @from, CPos target, bool checkForBlocked) { var graph = new PathGraph(LayerPoolForWorld(world), locomotor, self, world, checkForBlocked); var search = new PathSearch(graph) { heuristic = DefaultEstimator(target) }; search.isGoal = loc => { var locInfo = search.Graph[loc]; return(locInfo.EstimatedTotal - locInfo.CostSoFar == 0); }; if (world.Map.Contains(from)) { search.AddInitialCell(from); } return(search); }
public PathGraph(CellInfoLayerPool layerPool, Locomotor locomotor, Actor actor, World world, BlockedByActor check) { pooledLayer = layerPool.Get(); groundInfo = pooledLayer.GetLayer(); var locomotorInfo = locomotor.Info; this.locomotor = locomotor; var layers = world.GetCustomMovementLayers().Values .Where(cml => cml.EnabledForActor(actor.Info, locomotorInfo)); foreach (var cml in layers) { customLayerInfo[cml.Index] = Pair.New(cml, pooledLayer.GetLayer()); } World = world; worldMovementInfo = locomotorInfo.GetWorldMovementInfo(world); Actor = actor; LaneBias = 1; checkConditions = check; checkTerrainHeight = world.Map.Grid.MaximumTerrainHeight > 0; }
public static PathSearch ToTargetCell( World world, Locomotor locomotor, Actor self, IEnumerable <CPos> froms, CPos target, BlockedByActor check, Func <CPos, int> customCost = null, Actor ignoreActor = null, bool laneBias = true, bool inReverse = false, Func <CPos, int> heuristic = null, int heuristicWeightPercentage = DefaultHeuristicWeightPercentage) { var graph = new MapPathGraph(LayerPoolForWorld(world), locomotor, self, world, check, customCost, ignoreActor, laneBias, inReverse); heuristic = heuristic ?? DefaultCostEstimator(locomotor, target); var search = new PathSearch(graph, heuristic, heuristicWeightPercentage, loc => loc == target); foreach (var sl in froms) { if (world.Map.Contains(sl)) { search.AddInitialCell(sl); } } return(search); }
/// <summary> /// Default: Diagonal distance heuristic. More information: /// http://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html /// Layers are ignored and incur no additional cost. /// </summary> /// <param name="locomotor">Locomotor used to provide terrain costs.</param> /// <param name="destination">The cell for which costs are to be given by the estimation function.</param> /// <returns>A delegate that calculates the cost estimation between the <paramref name="destination"/> and the given cell.</returns> public static Func <CPos, int> DefaultCostEstimator(Locomotor locomotor, CPos destination) { var estimator = DefaultCostEstimator(locomotor); return(here => estimator(here, destination)); }
public static IPathSearch FromPoint(World world, Locomotor locomotor, Actor self, CPos @from, CPos target, BlockedByActor check) { return(FromPoints(world, locomotor, self, new[] { from }, target, check)); }
void Start() { SetupJoysticks(); locomotor = GetComponent<Locomotor> (); acquirer = GetComponent<Acquirer> (); thrower = GetComponent<InventoryThrower> (); Screen.showCursor = false; }
void Start() { locomotor = GetComponent<Locomotor>(); player = GetComponent<PlayerGravityBody>(); attractors = new Cycler(FindObjectsOfType(typeof(GravityAttractor))); }