public List <GridPos> FindPath(Vector2 p1, Vector2 p2) { var jpParam = new JumpPointParam(grids, new GridPos(Convert.ToInt32(p1.x), Convert.ToInt32(p1.y)), new GridPos(Convert.ToInt32(p2.x), Convert.ToInt32(p2.y))); var path = JumpPointFinder.FindPath(jpParam); return(path); }
public IList <Point2D> GetPath(int[][] grid, Point2D start, Point2D end, GameDiagonalMovement type) { var width = grid.Length; var height = grid[0].Length; bool[][] movableMatrix = new bool[width][]; for (int widthTrav = 0; widthTrav < width; widthTrav++) { movableMatrix[widthTrav] = new bool[height]; for (int heightTrav = 0; heightTrav < height; heightTrav++) { movableMatrix[widthTrav][heightTrav] = grid[widthTrav][heightTrav] == 0; } } Board = new StaticGrid(width, height, movableMatrix); StartPos = new GridPos(start.X, start.Y); EndPos = new GridPos(end.X, end.Y); JumpPointParam jpParam = new JumpPointParam(Board, StartPos, EndPos, EndNodeUnWalkableTreatment.DISALLOW, type == GameDiagonalMovement.Never ? DiagonalMovement.Never : DiagonalMovement.Always, HeuristicMode.EUCLIDEAN); List <GridPos> resultPathList = JumpPointFinder.FindPath(jpParam); return(resultPathList.Select(x => new Point2D(x.x, x.y)).ToList()); }
public List <MapCell> JPSPlus(MapCell cell1, MapCell cell2) { List <MapCell> path = new List <MapCell>(); List <GridPos> lpath = new List <GridPos>(); if (cell1.MapId != cell2.MapId) { return(path); } JumpPointParam JumpPointParameters = new JumpPointParam(_tempgrid, new GridPos(cell1.X, cell1.Y), new GridPos(cell2.X, cell2.Y), false, true, true, HeuristicMode.MANHATTAN); List <GridPos> resultPathList = JumpPointFinder.FindPath(JumpPointParameters); lpath = JumpPointFinder.GetFullPath(resultPathList); Debug.WriteLine($"From X: {cell1.X} Y: {cell1.Y}, To X: {cell2.X} Y: {cell2.Y}, Paths: {resultPathList.Count}, LPath: {lpath.Count}"); if (lpath.Count > 0) { foreach (GridPos item in lpath) { path.Add(new MapCell { X = Convert.ToInt16(item.x), Y = Convert.ToInt16(item.y), MapId = cell1.MapId }); } } return(path); }
// Use this for initialization void Start() { m_hidden = new Color(1.0f, 1.0f, 1.0f, 0.0f); //invisible m_basic = new Color(1.0f, 1.0f, 1.0f, 0.03f); //visible m_start = new Color(Color.green.r, Color.green.g, Color.green.b, 1.0f); m_end = new Color(Color.red.r, Color.red.g, Color.red.b, 1.0f); m_open = new Color(Color.blue.r, Color.blue.g, Color.blue.b, 0.3f); m_close = new Color(Color.cyan.r, Color.cyan.g, Color.cyan.b, 0.3f); m_unwalkable = new Color(Color.black.r, Color.black.g, Color.black.b, 1.0f); //// UI //// //loading & mapping m_cube = Resources.Load("Prefabs/Cube") as GameObject; GameObject.Find("Canvas/btnClear").GetComponent <Button>().onClick.AddListener(OnbtnClearClicked); GameObject.Find("Canvas/btnSearch").GetComponent <Button>().onClick.AddListener(OnbtnSearchClicked); GameObject.Find("Canvas/btnLoadMap").GetComponent <Button>().onClick.AddListener(OnbtnLoadMapClicked); GameObject.Find("Canvas/btnLoadStartEnd").GetComponent <Button>().onClick.AddListener(OnbtnLoadStartEndClicked); m_ddDiagonalMode = GameObject.Find("Canvas/DropdownMode").GetComponent <Dropdown>(); m_tRecursive = GameObject.Find("Canvas/ToggleRecursive").GetComponent <Toggle>(); m_tOpenedCell = GameObject.Find("Canvas/ToggleOpenedCell").GetComponent <Toggle>(); m_tTotalMap = GameObject.Find("Canvas/ToggleTotalMap").GetComponent <Toggle>(); m_tOpenedCell.onValueChanged.AddListener((value) => { OntOpenedCellValue(value); }); m_tTotalMap.onValueChanged.AddListener((value) => { OntTotalMapValue(value); }); ////cube setup//// m_cubeMap = new Dictionary <int, GameObject>(); int width = 10, length = 10, height = 10; buildCubes(width, length, height); ////Testbeds//// //2 testbeds //m_testbedList.Add(new Testbed()); //default //m_testbedList.Add(new Testbed(new GridPos(1, 2, 3), new GridPos(9, 8, 7))); //custom ////path grid setup//// //convert all matrix walkable bool[][][] movableMatrix = new bool [width][][]; for (int widthTrav = 0; widthTrav < width; widthTrav++) { movableMatrix[widthTrav] = new bool[length][]; for (int lengthTrav = 0; lengthTrav < length; lengthTrav++) { movableMatrix[widthTrav][lengthTrav] = new bool[height]; for (int heightTrav = 0; heightTrav < height; heightTrav++) { movableMatrix[widthTrav][lengthTrav][heightTrav] = true; } } } BaseGrid searchGrid = new StaticGrid(width, length, height, movableMatrix); m_jumpParam = new JumpPointParam(searchGrid, new GridPos(), new GridPos(), EndNodeUnWalkableTreatment.ALLOW, DiagonalMovement.Always); }
private IList <GridPos> GetJumpPointsFromJumpPointFinder(Vector2Int startPoint, Vector2Int targetPoint) { if (!_gridInfoProvider.IsWalkable(targetPoint)) { return(new GridPos[0]); } GridPos startPosition = ZeroBasedPosition(startPoint); GridPos targetPosition = ZeroBasedPosition(targetPoint); // todo: when iAllowEndNodeUnWalkable is set to false, it seems that search is performed anyway — it just finishes with failure. Fix! JumpPointParam jumpPointsParams = new JumpPointParam(_navigationGrid, startPosition, targetPosition, iAllowEndNodeUnWalkable: false, iMode: HeuristicMode.MANHATTAN); // todo: note that resetting the grid causes all the nodes to be created again, // which probably causes bad performance (5-30 ms for 30x50 grid). // Possible solutions: use DynamicGridWPool instead of StaticGrid; refactor the library; use other library. jumpPointsParams.Reset(startPosition, targetPosition); IList <GridPos> resultPathList = JumpPointFinder.FindPath(jumpPointsParams); if (!resultPathList.Any()) { return(new GridPos[0]); } return(resultPathList); }
public IEnumerable <Vector2D> Find(Vector2D origin, Vector2D destination) { BaseGrid searchGrid = new StaticGrid(map.Width, map.Height, matrix); var jp = new JumpPointParam(searchGrid, new GridPos(origin.X, origin.Y), new GridPos(destination.X, destination.Y), EndNodeUnWalkableTreatment.Allow); return(JumpPointFinder.FindPath(jp).Select(x => new Vector2D(x.X, x.Y))); }
public void LoadZone() { Stream stream = new MemoryStream(Data); byte[] bytes = new byte[stream.Length]; int numBytesToRead = 1; int numBytesRead = 0; byte[] xlength = new byte[2]; byte[] ylength = new byte[2]; stream.Read(bytes, numBytesRead, numBytesToRead); xlength[0] = bytes[0]; stream.Read(bytes, numBytesRead, numBytesToRead); xlength[1] = bytes[0]; stream.Read(bytes, numBytesRead, numBytesToRead); ylength[0] = bytes[0]; stream.Read(bytes, numBytesRead, numBytesToRead); ylength[1] = bytes[0]; YLength = BitConverter.ToInt16(ylength, 0); XLength = BitConverter.ToInt16(xlength, 0); _grid = new short[XLength, YLength]; for (int i = 0; i < YLength; ++i) { for (int t = 0; t < XLength; ++t) { stream.Read(bytes, numBytesRead, numBytesToRead); _grid[t, i] = Convert.ToInt16(bytes[0]); } } // initialize JPS _tempgrid = ConvertToGrid(_grid); JumpPointParameters = new JumpPointParam(_tempgrid, new GridPos(0, 0), new GridPos(0, 0), false, true, true, HeuristicMode.MANHATTAN); }
public static List <GridPos> GetPath(Point2D start, Point2D end) { for (int i = 0; i < MovableMatrix.Length; i++) { var row = MovableMatrix[i]; for (int index = 0; index < row.Length; index++) { MovableMatrix[i][index] = true; } } List <CircularUnit> circularUnits = new List <CircularUnit>(Tick.World.Minions); circularUnits.AddRange(Tick.World.Buildings); circularUnits.AddRange(Tick.World.Wizards.Where(x => !x.IsMe)); circularUnits.AddRange(Tick.World.Trees); circularUnits = circularUnits.Where(x => Tick.Self.GetDistanceTo(x) < Tick.Self.VisionRange).ToList(); foreach (var nearestMinion in circularUnits) { var p1 = (int)nearestMinion.X / gridStep; var p2 = (int)nearestMinion.Y / gridStep; FillMovableCircle(p1, p2, (int)(nearestMinion.Radius + Tick.Self.Radius * 1.2) / gridStep, gridSize, MovableMatrix, false); } var startGridPos = GetGridPosByPoint2d(start, gridStep); var endGridPos = GetGridPosByPoint2d(end, gridStep); MovableMatrix[startGridPos.x][startGridPos.y] = true; FillMovableCircle(endGridPos.x, endGridPos.y, (int)(Tick.Self.Radius * 2) / gridStep, gridSize, MovableMatrix, true); BaseGrid searchGrid = new StaticGrid(gridSize, gridSize, MovableMatrix); JumpPointParam jpParam = new JumpPointParam(searchGrid, startGridPos, endGridPos); var result = JumpPointFinder.FindPath(jpParam); //result = JumpPointFinder.GetFullPath(result); //var clmnIdx = 0; //foreach (var row in MovableMatrix) //{ // var rowIdx = 0; // foreach (var b in row) // { // if (!b) // { // VisualClientHelper.Rect(new Point2D(clmnIdx * gridStep, rowIdx * gridStep), // new Point2D((clmnIdx + 1) * gridStep, (rowIdx + 1) * gridStep), new VisualClientColor(0, 0, 1)); // } // rowIdx++; // } // clmnIdx++; //} DrawPath(result, gridStep); return(result); }
private void Start() { SpawnPoint = transform.position; jpParam = new JumpPointParam(MapLoader.maps[agent.session.map].aStar); skills_defense = agent.skills.ToList().FindAll(x => x.effectType == EffectType.Heal || x.effectType == EffectType.DamageShield).ToArray(); skills_attack = agent.skills.ToList().FindAll(x => x.effectType != EffectType.Heal && x.effectType != EffectType.DamageShield).ToArray(); }
public Map(int width, int height) { _mapLayout = new Tile[width, height]; _searchGrid = new StaticGrid(width, height); _width = width; _height = height; jpParam = new JumpPointParam(null, true, false, false); _tileObjects = new List <TileObject>(); }
public static List <GridPos> JPSPlus(JumpPointParam JumpPointParameters, GridPos cell1, GridPos cell2) { if (JumpPointParameters != null) { JumpPointParameters.Reset(cell1, cell2); return(JumpPointFinder.GetFullPath(JumpPointFinder.FindPath(JumpPointParameters))); } return(new List <GridPos>()); }
public void FindPath_Trivial() { var grid = new StaticGrid(3, 3); //grid.SetWalkableAll(true); var param = new JumpPointParam(grid, new GridPos(0, 0), new GridPos(2, 2)); var path = JumpPointFinder.FindPath(param); Assert.Contains(new GridPos(0, 0), path); Assert.Contains(new GridPos(2, 2), path); }
public Routing(GridPos theCurrent, GridPos theDestination, BaseGrid theGrid) { myCurrent = theCurrent; myDestination = theDestination; theGrid.SetWalkableAt(theDestination, true); myGrid = new JumpPointParam(theGrid, true, DiagonalMovement.IfAtLeastOneWalkable); //myGrid.AllowEndNodeUnWalkable = true; GetNodes(); }
public List <GridPos> JPSPlus(JumpPointParam JumpPointParameters, GridPos cell1, GridPos cell2) { List <GridPos> lpath = new List <GridPos>(); if (JumpPointParameters != null) { JumpPointParameters.Reset(cell1, cell2); List <GridPos> resultPathList = JumpPointFinder.FindPath(JumpPointParameters); lpath = JumpPointFinder.GetFullPath(resultPathList); } return(lpath); }
private void Load(string fileName) { if (!File.Exists(fileName)) { Logger.Error("path file do not exit. {0}", fileName); return; } FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read); int nSeek = 0; //先从文件头读取地图的长和宽 byte[] byteLen = new byte[Marshal.SizeOf(typeof(int))]; fileStream.Seek(nSeek, SeekOrigin.Begin); fileStream.Read(byteLen, 0, byteLen.Length); Height = System.BitConverter.ToInt32(byteLen, 0); nSeek += byteLen.Length; byte[] byteWid = new byte[Marshal.SizeOf(typeof(int))]; fileStream.Seek(nSeek, SeekOrigin.Begin); fileStream.Read(byteWid, 0, byteWid.Length); Width = System.BitConverter.ToInt32(byteWid, 0); nSeek += byteWid.Length; int nReadLen = Marshal.SizeOf(typeof(ObstacleItem)); byte[] read = new byte[nReadLen]; mSearchGrid = new StaticGrid(Width * 2 + 1, Height * 2 + 1); byte[][] mat = new byte[Width * 2 + 1][]; for (int i = 0; i < Width * 2 + 1; i++) { mat[i] = new byte[Height * 2 + 1]; } for (int i = 0; i < (Height * 2 + 1) * (Width * 2 + 1); ++i) { fileStream.Seek(nSeek, SeekOrigin.Begin); fileStream.Read(read, 0, nReadLen); nSeek += nReadLen; ObstacleItem info = Byte2Struct(read); mat[(int)(info.Fx * 2)][(int)(info.Fy * 2)] = (byte)info.Value; } mSearchGrid.Reset(mat); mParam = new JumpPointParam(mSearchGrid, new GridPos(0, 0), new GridPos(0, 0), true, true, false, HeuristicMode.MANHATTAN); }
/// <summary> /// Keep in mind this method returns the start end and turn points of the path, and not all movement steps. /// </summary> private List <GridPos> FindPath(int fromX, int fromZ, int toX, int toZ) { JumpPointParam jpParam = GetJumpPointParam(); GridPos from = new GridPos(fromX, fromZ); GridPos to = new GridPos(toX, toZ); jpParam.Reset(from, to); List <GridPos> routeFound = JumpPointFinder.FindPath(jpParam); return(routeFound); }
public List<GridPos> findPath(BaseGrid grid, DiagonalMovement move, GridPos startPos, GridPos endPos){ JumpPointParam jpParam = new JumpPointParam( grid, startPos, endPos, true, move, HeuristicMode.EUCLIDEAN ); List<GridPos> result = JumpPointFinder.FindPath(jpParam); if (debug) Console.WriteLine("found path"); return result; }
public void OkEmptyGridTest() { GridPos startPos = new GridPos(10, 10); GridPos endPos = new GridPos(20, 10); JumpPointParam jpParam = new JumpPointParam(_searchGrid, startPos, endPos); List <GridPos> resultPathList = JumpPointFinder.FindPath(jpParam); Assert.AreEqual(2, resultPathList.Count); Assert.AreEqual(startPos.x, resultPathList.First().x); Assert.AreEqual(startPos.y, resultPathList.First().y); Assert.AreEqual(endPos.x, resultPathList.Last().x); Assert.AreEqual(endPos.y, resultPathList.Last().y); }
public void identifySuccessors(JumpPointParam iParam, Node iNode) { List <Node> tOpenList = iParam.openList; int tEndX = iParam.EndNode.xz; int tEndY = iParam.EndNode.yz; Node tNeighbor; GridPos? tJumpPoint; Node tJumpNode; List <Node> tNeighbors = iNode.neighbours; for (int i = 0; i < iNode.neighbours.Count; i++) { tNeighbor = tNeighbors[i]; tJumpPoint = jumpLoop(iParam, tNeighbor.xz, tNeighbor.yz, iNode.xz, iNode.yz); if (tJumpPoint != null) { tJumpNode = graph[tJumpPoint.Value.x, tJumpPoint.Value.y]; if (tJumpNode == null) { if (iParam.EndNode.xz == tJumpPoint.Value.x && iParam.EndNode.yz == tJumpPoint.Value.y) { tJumpNode = graph[tJumpPoint.Value.x, tJumpPoint.Value.y]; } } if (tJumpNode.isClosed) { continue; } float tCurNodeToJumpNodeLen = Manhattan(Mathf.Abs(tJumpPoint.Value.x - iNode.xz), Mathf.Abs(tJumpPoint.Value.y - iNode.yz)); float tStartToJumpNodeLen = iNode.startToCurNodeLen + tCurNodeToJumpNodeLen; if (!tJumpNode.isOpened || tStartToJumpNodeLen < tJumpNode.startToCurNodeLen) { tJumpNode.startToCurNodeLen = tStartToJumpNodeLen; tJumpNode.heuristicCurNodeToEndLen = (tJumpNode.heuristicCurNodeToEndLen == null ? Manhattan(Mathf.Abs(tJumpPoint.Value.x - tEndX), Mathf.Abs(tJumpPoint.Value.y - tEndY)) : tJumpNode.heuristicCurNodeToEndLen); tJumpNode.heuristicStartToEndLen = tJumpNode.startToCurNodeLen + tJumpNode.heuristicCurNodeToEndLen.Value; tJumpNode.parent = iNode; if (!tJumpNode.isOpened) { tOpenList.Add(tJumpNode); tJumpNode.isOpened = true; } } } } }
public IEnumerable <Point> FindPath(Point startPos, Point endPos) { var start = new GridPos(startPos.X, startPos.Y); var end = new GridPos(endPos.X, endPos.Y); var param = new JumpPointParam(_staticGrid, start, end, EndNodeUnWalkableTreatment.Allow); var listPositions = JumpPointFinder.FindPath(param); return(listPositions.Select(z => new Point() { X = z.x, Y = z.y })); }
/// <summary> /// Finds a path between 2 position on a map /// </summary> /// <param name="startPosition">Starting position</param> /// <param name="endPosition">Destination</param> /// <param name="map">Game map currently being used</param> /// <param name="endNodeUnWalkable"></param> /// <returns>A list of Vector2 waypoints that the object must traverse to get to its destination</returns> internal Stack <Vector2> FindPath(Vector2 startPosition, Vector2 endPosition, ref Map.Map map, EndNodeUnWalkableTreatment endNodeUnWalkable = EndNodeUnWalkableTreatment.DISALLOW) { if (!Map.Map.IsOnTop(endPosition) || !map.GetCollisionMap().GetWalkabilityGrid().IsWalkableAt(VectorToGridPos(endPosition))) { return(new Stack <Vector2>()); } var startGridPos = VectorToGridPos(startPosition); var endGridPos = VectorToGridPos(endPosition); if (ClearDirectPath(startGridPos.x, startGridPos.y, endGridPos.x, endGridPos.y, ref map)) { var pathVector = new Stack <Vector2>(1); pathVector.Push(endPosition); return(pathVector); } else { if (mJpParam != null) { mJpParam.Reset(VectorToGridPos(startPosition), VectorToGridPos(endPosition)); } else { mJpParam = new JumpPointParam(map.GetCollisionMap().GetWalkabilityGrid(), startGridPos, iDiagonalMovement: DiagonalMovement.OnlyWhenNoObstacles, iEndPos: endGridPos, iAllowEndNodeUnWalkable: endNodeUnWalkable, iMode: HeuristicMode.MANHATTAN); } var pathGrid = JumpPointFinder.FindPath(mJpParam); var pathVector = new Stack <Vector2>(pathGrid.Count); pathVector.Push(endPosition); for (var i = pathGrid.Count - 1; i > 0; i--) { var gridPos = GridPosToVector2(pathGrid[i]); pathVector.Push(gridPos); } return(pathVector); } }
public List <Vector3> FindPath(GridPos startPos, GridPos endPos) { BaseGrid searchGrid = CreateMovableGrid(); JumpPointParam jpParam = new JumpPointParam(searchGrid, startPos, endPos, EndNodeUnWalkableTreatment.ALLOW, DiagonalMovement.Always, HeuristicMode.MANHATTAN); List <GridPos> resultPathList = JumpPointFinder.FindPath(jpParam); List <Vector3> worldPath = new List <Vector3>(); for (int i = 0; i < resultPathList.Count; i++) { worldPath.Add(GridPosToWorld(resultPathList[i].x, resultPathList[i].y)); } return(worldPath); }
public void OkObstacleTest() { _searchGrid.SetWalkableAt(15, 10, false); GridPos startPos = new GridPos(10, 10); GridPos endPos = new GridPos(20, 10); JumpPointParam jpParam = new JumpPointParam(_searchGrid, startPos, endPos); List <GridPos> resultPathList = JumpPointFinder.FindPath(jpParam); Assert.Greater(resultPathList.Count, 2); Assert.AreEqual(startPos.x, resultPathList.First().x); Assert.AreEqual(startPos.y, resultPathList.First().y); Assert.AreEqual(endPos.x, resultPathList.Last().x); Assert.AreEqual(endPos.y, resultPathList.Last().y); }
public SearchGridForm() { InitializeComponent(); this.DoubleBuffered = true; m_resultBox = new List <ResultBox>(); this.Width = (width + 1) * 20; this.Height = (height + 1) * 20 + 100; this.MaximumSize = new Size(this.Width, this.Height); this.MaximizeBox = false; m_rectangles = new GridBox[width][]; for (int widthTrav = 0; widthTrav < width; widthTrav++) { m_rectangles[widthTrav] = new GridBox[height]; for (int heightTrav = 0; heightTrav < height; heightTrav++) { if (widthTrav == (width / 3) && heightTrav == (height / 2)) { m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.Start); } else if (widthTrav == 41 && heightTrav == (height / 2)) { m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.End); } else { m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.Normal); } } } cbbJumpType.Items.Add("Always"); cbbJumpType.Items.Add("Never"); cbbJumpType.Items.Add("IfAtLeastOneWalkable"); cbbJumpType.Items.Add("OnlyWhenNoObstacles"); cbbJumpType.SelectedIndex = 0; m_resultLine = new List <GridLine>(); searchGrid = new StaticGrid(width, height); // searchGrid = new DynamicGrid(); //searchGrid = new DynamicGridWPool(SingletonHolder<NodePool>.Instance); jumpParam = new JumpPointParam(searchGrid, true, (DiagonalMovement)cbbJumpType.SelectedIndex, HeuristicMode.EUCLIDEAN);//new JumpPointParam(searchGrid, startPos, endPos, cbCrossCorners.Checked, HeuristicMode.EUCLIDEANSQR); jumpParam.UseRecursive = cbUseRecursive.Checked; }
public static List <GridPos> GetPath(Point2D start, Point2D end) { BaseGrid searchGrid = new StaticGrid(gridSize, gridSize, MovableMatrix); var startGridPos = GetGridPosByPoint2d(start, gridStep); var endGridPos = GetGridPosByPoint2d(end, gridStep); JumpPointParam jpParam = new JumpPointParam(searchGrid, startGridPos, endGridPos); var result = JumpPointFinder.FindPath(jpParam); result = JumpPointFinder.GetFullPath(result); DrawPath(result, gridStep); return(result); }
public void ErrorUnrecheableTest() { _searchGrid.SetWalkableAt(19, 9, false); _searchGrid.SetWalkableAt(20, 9, false); _searchGrid.SetWalkableAt(21, 9, false); _searchGrid.SetWalkableAt(21, 10, false); _searchGrid.SetWalkableAt(21, 11, false); _searchGrid.SetWalkableAt(20, 11, false); _searchGrid.SetWalkableAt(19, 11, false); _searchGrid.SetWalkableAt(19, 10, false); GridPos startPos = new GridPos(10, 10); GridPos endPos = new GridPos(20, 10); JumpPointParam jpParam = new JumpPointParam(_searchGrid, startPos, endPos); List <GridPos> resultPathList = JumpPointFinder.FindPath(jpParam); Assert.IsEmpty(resultPathList); }
private JumpPointParam GetJumpPointParam() { if (_cachedJpParam == null) { BaseGrid searchGrid = new StaticGrid(WorldController.instance.Width, WorldController.instance.Height); for (int x = 0; x < WorldController.instance.Width; x++) { for (int z = 0; z < WorldController.instance.Height; z++) { searchGrid.SetWalkableAt(x, z, true); } } _cachedJpParam = new JumpPointParam(searchGrid); // Cant configure it to not allow diagonally moving, has to be enforced by us } return(_cachedJpParam); }
private void monsterUpdate(object sender, MonsterUpdateEventArgs e) { PlayerSeen = canSeePlayer(e.engine.map.mGrid, e.playerPos); if (moves.Count == 0) { if (PlayerSeen) { JumpPointParam jParam = new JumpPointParam(e.engine.searchgrid, false, false); jParam.Reset(new GridPos(pos.X, pos.Y), new GridPos(e.playerPos.X, e.playerPos.Y)); List <GridPos> resultPathList = JumpPointFinder.FindPath(jParam); resultPathList = JumpPointFinder.GetFullPath(resultPathList); if (moves.Count != 0) { moves.Clear(); } for (int i = 0; i < resultPathList.Count; i++) { moves.Enqueue(new Vector2(resultPathList[i].x, resultPathList[i].y)); } } } if (moves.Count != 0) { var dxdy = e.engine.map.getDxDy(pos, moves.Dequeue()); if (!e.engine.checkEntity(pos, e.playerPos, dxdy.X, dxdy.Y)) { move(dxdy.X, dxdy.Y); } } if (PlayerSeen == false) { Vector2 a = rndMoves[rnd.Next(rndMoves.Count)]; if (e.engine.map.canMove(pos, a.X, a.Y)) { move(a.X, a.Y); } } if (isPlayerNear(e.playerPos)) { attack(e.engine.player); } }
public SearchGridForm() { InitializeComponent(); this.DoubleBuffered = true; m_resultBox = new List <ResultBox>(); this.Width = (width + 1) * 20; this.Height = (height + 1) * 20 + 100; this.MaximumSize = new Size(this.Width, this.Height); this.MaximizeBox = false; m_rectangles = new GridBox[width][]; for (int widthTrav = 0; widthTrav < width; widthTrav++) { m_rectangles[widthTrav] = new GridBox[height]; for (int heightTrav = 0; heightTrav < height; heightTrav++) { if (widthTrav == (width / 3) && heightTrav == (height / 2)) { m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.Start); } else if (widthTrav == 41 && heightTrav == (height / 2)) { m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.End); } else { m_rectangles[widthTrav][heightTrav] = new GridBox(widthTrav * 20, heightTrav * 20 + 50, BoxType.Normal); } } } m_resultLine = new List <GridLine>(); searchGrid = new StaticGrid(width, height); // searchGrid = new DynamicGrid(); //searchGrid = new DynamicGridWPool(SingletonHolder<NodePool>.Instance); jumpParam = new JumpPointParam(searchGrid, true, cbCrossCorners.Checked, cbCrossAdjacentPoint.Checked, HeuristicMode.EUCLIDEAN);//new JumpPointParam(searchGrid, startPos, endPos, cbCrossCorners.Checked, HeuristicMode.EUCLIDEANSQR); jumpParam.UseRecursive = cbUseRecursive.Checked; }
public SearchGridForm() { InitializeComponent(); DoubleBuffered = true; resultBox = new List <ResultBox>(); Width = (width + 1) * 20; Height = ((height + 1) * 20) + 100; MaximumSize = new Size(Width, Height); MaximizeBox = false; rectangles = new GridBox[width][]; for (var x = 0; x < width; x++) { rectangles[x] = new GridBox[height]; for (var y = 0; y < height; y++) { rectangles[x][y] = x == (width / 3) && y == (height / 2) ? new GridBox(x * 20, (y * 20) + 50, BoxType.Start) : x == 41 && y == (height / 2) ? new GridBox(x * 20, (y * 20) + 50, BoxType.End) : new GridBox(x * 20, (y * 20) + 50, BoxType.Normal); } } _ = cbbJumpType.Items.Add("Always"); _ = cbbJumpType.Items.Add("Never"); _ = cbbJumpType.Items.Add("IfAtLeastOneWalkable"); _ = cbbJumpType.Items.Add("OnlyWhenNoObstacles"); cbbJumpType.SelectedIndex = 0; resultLine = new List <GridLine>(); searchGrid = new StaticGrid(width, height); // searchGrid = new DynamicGrid(); //searchGrid = new DynamicGridWPool(SingletonHolder<NodePool>.Instance); jumpParam = new JumpPointParam(searchGrid, EndNodeUnWalkableTreatment.Allow, (DiagonalMovement)cbbJumpType.SelectedIndex, HeuristicMode.Euclidean) { CurIterationType = cbUseRecursive.Checked ? IterationType.Recursive : IterationType.Loop }; //new JumpPointParam(searchGrid, startPos, endPos, cbCrossCorners.Checked, HeuristicMode.EUCLIDEANSQR); }