PathFinding | Windows Forms application demonstrating several common path | Learning library

Interesting problem... To set a solid foundation, here's a hexagon grid class that is neither lengthy nor finicky, based on a simple data structure of a linear array. A couple of notes...

• The HexagonGrid constructor accepts the hexagon grid dimensions in terms of the number of hexagons wide (hexWidth) by number of hexagons high (hexHeight).
• The hexHeight alternates by an additional hexagon every other column for a more pleasing appearance. Thus an odd number for hexWidth bookends the hexagon grid with the same number of hexagons in the first and last columns.
• The length attribute represents the total number of hexagons in the grid.
• Each hexagon is referenced by a linear index from 0..length.
• The hexagonIndex method which takes (x,y) coordinates returns an the linear index based on an approximation of the closest hexagon. Thus, when near the edges of a hexagon, the index returned might be a close neighbor.
• Am not totally satisfied with the class structure, but is sufficient to show the key algorithms involved in a linear indexed hexagon grid.

To aid in visualizing the linear indexing scheme, the code snippet displays the linear index value in the hexagon. Such an indexing scheme offers the opportunity to have a parallel array of the same length which represents the characteristics of each specific hexagon by index.

Also exemplified is the ability to translate from mouse coordinates to the hexagon index, by clicking on any hexagon, which will redraw the hexagon with a thicker border.

EDIT:

the misterious 5th print is coming from this line, of course

This code defines a type of object Node; each instance of the Node object has four attributes: position, f, g, and h.

Instances of the Node class of objects also come with the ability to be compared to other Nodes (we know this because __eq__() has been defined for the class).

The __eq__() method of the Node class takes two instances of the Node class as inputs. These are called self and other in the function definition. Both self and other have the four attributes belonging to the Node object as mentioned above: position, f, g, and h.

The values of those attributes are accessed through Python's 'dot notation': e.g., self.position gives the position of the object with which the method has been called. other.position gives the position of a different Node that you're comparing to.

The key here is that other refers to an entirely different object, not another attribute of self. (other doesn't have to be a Node; the code will work as long as other also has an attribute named position; otherwise, it will raise an AttributeError.)

The correct way would be to not search for a specific node, but any node within some distance from the target, or any node within some distance and with a direct line of sight.

It looks like the AStar pathfinding library should have functions for things like that. There is for example a GetNearest overload that takes a constraint that might work. Or the maxNearestNodeDistance field. But I'm not familiar with that library, so I have difficulty providing specific suggestions.

Another alternative would be to just write your own implementation. This is not trivial, but also not overly complex, and there are plenty of resources explaining algorithms like A*. You will probably not reach feature parity with a commercial library, but you might only need fairly simple functionality. It might also be useful as a learning exercise to get better knowledge on how AI and path finding works.

In your code, changing location in two dimensions should be based on 14 (10 * square root of 2), but changing in all three dimensions at once should be based on 17 (10 * square root of 3), if my quick math is correct. I suspect that may solve your issue.

(Sure enough...here's a short explanation of why it should be based on sqrt(3).)

I think you are looking for A* algorithm. There are also other ways to do this, but most of them are based on graphs, including Unity NavMesh.

There is amazing site with interactive examples and implementation guide, for sure it will be helpful, whether you want to implement this yourself or just understand how it works: https://www.redblobgames.com/pathfinding/a-star/introduction.html

If you dont use the --onefile command, you can just drag and drop the images into the folder your exe is in. Or drop in the folder of images.

If you do use onefile, you need to modify the .spec file you get when you run the code pyinstaller script.py. Then run pyinstaller scriptname.spec. edit the datas variable somewhat like this

Follow a tutorial to learn the basics of Swing. Oracle provides one free-of-cost.

There you will find this example code to compare to your code.

In that example code you’ll find the main method makes this call:

If you are using GKGridGraph(fromStartingGridAt:width:height:diagonalsAllowed:) to create your graph then every node has connections to each of its neighbors. So a better picture of your map would be this:

Since every node is connected it will find the shortest path which will pass through the water. To prevent that you need to remove the impossible connections. Your graph should look something like this:

To achieve that you cam simply remove the unwanted connections from your graph using GKGraphNode.removeConnections(to:bidirectional:)

This could be achieved by a function like this one: