Scripting HelpersARCHIVE
A little piece of Roblox history. Preserved for everyone, one question at a time.Read about the archive →
✓ ANSWER ACCEPTED

Need some help with Hunt-and-Kill?

Hi, I hope this is a reasonable question. I do not understand this script at all. It's from the wiki, and I just don't get it. I'm probably an Intermediate scripter, however I don't know things like what a "node" is, and how this script was set up and what exactly it does. I'm really interested in it, I've been studying it for a while and I'd like some help breaking this down just a little? Or at least lead me into a direction to where I can smoothly read this script? I don't understand things like neighbors, and some of the very foreign syntax. Thanks for the help if you can. The wiki article I was looking at is here:

http://wiki.roblox.com/index.php?title=Hunt-and-Kill

Here's the script from that article, if you need it:

function Hunt_and_Kill(node)
	node.visited = true
 
	--Take visited neighbors out of the possible selections
	local neighbors = node:neighbors()
	for i=#neighbors,1,-1 do
		if neighbors[i].visited then
			table.remove(neighbors,i)
		end
	end
	--if there are unvisited neighbors of node, select a random one
	if #neighbors>0 then
		local new_node = neighbors[math.random(#neighbors)]
		--delete the wall between the two nodes
		deleteBetween(node,new_node)
		--repeat process on new_node
		Hunt_and_Kill(new_node)
 
	--if there are no unvisited neighbors, begin hunt for new neighbor
	else
		for y = 1, bottom_of_maze do
			for x = 1, end_of_maze do
				--if the node has not been visited and is next to a visited neighbor, select
				if not maze[x][y].visited then
					local visitedNeighbor = false
					for _, neighbor in pairs(maze[x][y]:neighbors()) do
						if v.visted then
							visitedNeighbor = neighbor
							break
						end
					end
					--if found, begin process over again
					if visitedNeighbor then
						Hunt_and_Kill(visitedNeighbor)
					end
				end
			end
		end
	end
end

1 answer

✓ Accepted answer

A node is "something" that connects to other nodes. In this case, it's a square in the maze's grid.

I found a good image to illustrate what this means: mazeBefore.gif

Each square is a node that may or may not connect to the squares directly adjacent to it horizontally/vertically -- ie, it's "neighbours". For any two adjacent nodes, they are connected if there is an opening from one node to the other; otherwise there is a wall blocking that movement. (ex in the image, the top-left square is connected to the one to the right of it).

Script breakdown:

Line 2: Records that the node has been visited so that we don't revisit nodes.

Line 3: ":neighbours()" is presumably a function that would return the valid neighbours of the node (ie the nodes directly to the left, right, above, and below the original node)

Lines 6-10: Remove from the "neighbours" list any nodes we've already visited

Lines 12-20: If there is a valid neighbour, we follow Procedure Steps 2-4 (see wiki). Line 15 refers to a function that would be responsible for removing the wall between "node" and "new_node". Line 17 performs recursion; it essentially restarts the algorithm for the new node. (Recursion isn't necessary; the algorithm could just as easily use a "repeat ... until node == nil" loop)

The remaining lines deal with Procedure Steps 5-6. It's doing a search for a node that has a visited neighbour and then connecting the two, and then recursing on the unvisited node. (If there is no such node, the algorithm is complete and the maze has been filled in.)

This discussion is preserved as it was. New answers, comments, and votes are closed.