Show HN: Visual a* Pathfinding and Maze Generation in Python

Here's a direct link to the YouTube demo video: https://www.youtube.com/watch?v=iA6XJRE6CTM

Also, here's the Lisp implementation post that inspired me (and which I based my Python code on):

https://news.ycombinator.com/item?id=41145528

And here are a few other sample videos using different settings-- I'll add more during the day as they finish generating:

https://www.dropbox.com/scl/fo/q13cxuvgy8vxr3ksi06uw/APkL57-...

I prefer this video of A* pathfinding on a real map (Chicago and Rome):

https://youtu.be/CgW0HPHqFE8?si=9aw_eHy3IedXY1Ro

I would be interested to hear what fraction of this script and README were generated by large language models. At first glance, the code contains a number of repetitive anti-patterns that 'feel like' they are Copilot-isms (e.g. large stacks of elif statements instead of using appropriate data structures), and the README is very verbose and includes a high fraction of filler words.

I like this..I recently used A* to implement laying out connectors between nodes in a graph. I really like the abstraction of a heuristic function. I was able to add in all sorts of things to make the implementation work the way i want (penalise turns, crossing over lines etc.). This would automatically create "last resort" style solutions and minimise ugliness in the diagram.

This would be neat to see applied to Vine Robots: https://youtu.be/eLVAMG_3fLg?t=153

---

They talk about the use of the pneumatic vine robots to nav rubble and caves etc - but if the vine robot could evaluate the terrain and use apropriate routing algo based on the nature of the terrain it was doing. they arent using vision necessarily in the vine robots - but if they could use terrain sensors that informed the best routing algo to use/accomplish goal that would be neat.

Another interesting thing about this would be to apply it to where vine-style micro-trenchers could know the patter of the lattice that will best be needed to accomplish whatever the stated newton bracing requirement were - then you could plop relative light foot pads onto a celestial body - then have these vine into the surface in such a way where you can begin to attach larger objects and very easily build foundations to large space structures - plus, as it maps out - you have an exact map of what your mycelium -like base foundation look like.

EDIT:

And you could grow the foundation as need - however, imagine a series of tubes mabe by these vinind robotw - that are later filled in (the robots) with structural hardening material -- you vine your robots into the mountian in sequences - first do a large outer lattice - and strucurally brace it with whatever material - then in the center space - vine into the core and fill those with explosives and tunnel. -- then you can snake through your exploded rubble - see whatst up - and deliver cables and hoses through the vine to a forward location...

A vine robot that tunnels - but its outer layer is a permiable filter and it has capillary features - but basically it unfulrs into being a well and the outer material is expanded do to corrugations in the design allowing debris filteres water to create a layer around the new pipe - and then capillaried up - or a pump in the core at the head of the water-wyrm.

(I need to figure out how to make some of these -- I love them.)

I'm wondering if there's someway of abusing the heuristic to produce an absolute monster of a maze;

Somehow make it so that the top ~70% of next steps in the queue are never the next step in the solution (I'm too tired right now to come up with any sort of answer, but my guess is that it wouldn't be possible to generate a planar maze that way).

It reminds me another JavaScript path finding algorithms visualization: https://qiao.github.io/PathFinding.js/visual/

seems this was LLM generated? I dont mind people using LLMs to generate boilerplate, but at least apply some basic oop fundamentals to make it readable. the bar is on the floor

Interesting how it looks just like rainwater trickling down a dusty windshield.

@eigenvalue, some comments suggest the project code and README was LLM-generated. Could you say to what extent that is the case?

Edit: I'm curious about other repositories under your account also. For example, this one:

https://github.com/Dicklesworthstone/introduction_to_tempora...

The content of this repo is an essay on temporal logic that seems at once unnecessarily verbose and lacking in concrete information (e.g. lists of "logical operators" -i.e. logical connectives and quantifiers- and their examples but nothing about logical interpretations, in an essay about proofs). If that's the case, then I'm curious what is the motivation of having that on github. If I were really paranoid I'd think you're trying to hasten self-training model collapse :)