mazes | A comprehensive library of maze generation algorithms | Generator Utils library

Solution was to set:

You need to create a sounds object and use that in your code. Something like the following. Note how the object is defined outside of the start method so that it can be referenced easily:

There are some errors in the code and others in the logic:

1. The 'else if' doesn't do anything because of the ';', the printf after it will occur every time.

Your braces are indeed incorrect. Looking at the problem conditional:

No, the algorithm is not mine; I learned it from Walter Pullen’s page, here: https://www.astrolog.org/labyrnth/algrithm.htm. He also does not cite an author for this algorithm. It should be noted that many maze algorithms are adaptations of more general graph algorithms, so it could be that this one has an analog in graph theory somewhere...

At any rate, it’s not mine. I used the word “novel” in my post in the second sense given here (https://www.merriam-webster.com/dictionary/novel) “original or striking especially in conception or style”, not in the sense of “new”.

JFrame is using a BorderLayout by default, this will only manage/layout the last component added to each available position - so, this means, the only component actually been laid out is the startp panel, all the other components are been left at the original size of 0x0 and Swing is smart enough not to paint components with no size.

A better solution would be to use a CardLayout is designed to do exactly what you're trying to do.

For example...

It looks to me like you're appending a char to the route during your BFS. This will not return the correct shortest path because the code needs to validate which direction actually corresponds with the shortest path. By adding directions to the path before actually testing if its part of the shortest path, the output really just tells us the path of execution for the BFS itself.

To solve this, we use a parent array, which keeps every node's parent (when you first visit an adjacent cell, set that cell's parent to the current cell). After the breadth-first search completes, set a "tracer" variable to the destination and use the parent array to trace backwards until you reach the start. Note that this "path reconstruction" at the end reconstructs the path in reverse order (because we iterate from the destination back to the start).

Here's my code implementing this approach:

let new_path = path; creates an alias of path, pushes to it (same as pushing to path directly), then discards the alias at the end of the block after printing. This means you're working with the same path array the entire time.

Most likely, you want queue.push(path.concat(neighbour)) which allocates a new array, concatenates the new neighbour vertex and pushes it to the queue, effectively extending the current path by one node but without modifying it in place as push does.

Beyond that, objects with all values as 1 seems like somewhat of an antipattern for an adjacency list. A Set or array seems more intuitive here, so I took the liberty of making that adjustment as well as a few others.

visited being an array means complexity for lookups is O(n). Using a Set gives you O(1) lookups and is the correct structure for membership tests like this. In fact, visited is an unused variable in the original version, so if the graph had a cycle we'd get an infinite loop.

Array.isArray(queue) is an unnecessary check--queue is purely local and we can't reassign it if we make it const.

Lastly, when vertex is not in graph, it's not a bad idea to handle that by null coalescing to an empty array to avoid a crash (you may expect input to always be well-formed but it's a pretty easy adjustment).

Here's the code:

You have to access noOfSteps via self.