Example #1
0
//Create a new Depth-First maze with the given bias.
//Valid biases are:
//"H": Prefer horizontal paths over vertical
//"V": Prefer vertical paths over horizontal
//"X": Choose cell furthest from goal. This will create a long winding path from start to finish.
//"O": Chose path closest to goal. This will create a direct path to treasure and the rest will be a disconnected component. Goal being to bait icarus into taking the wrong path and having to backtrack.
//"", or any other value:  Default, no bias. Always picka a random neighbor.
func DepthFirst(width, height int, bias string) *mazelib.Maze {
	m := mazelib.FullMaze(width, height)
	x, y := m.End() //search treasure -> icarus so treasure is usually in a dead end.
	startCoord := mazelib.Coordinate{x, y}
	visited := map[mazelib.Coordinate]bool{}
	visited[startCoord] = true
	current := []mazelib.Coordinate{startCoord}
	goalX, goalY := m.Start()
	for len(current) > 0 {
		possible := []possibility{}
		tip := current[len(current)-1]
		leftCoord := mazelib.Coordinate{tip.X - 1, tip.Y}
		if tip.X > 0 && !visited[leftCoord] {
			possible = append(possible, possibility{"left", leftCoord})
		}
		rightCoord := mazelib.Coordinate{tip.X + 1, tip.Y}
		if tip.X < width-1 && !visited[rightCoord] {
			possible = append(possible, possibility{"right", rightCoord})
		}
		upCoord := mazelib.Coordinate{tip.X, tip.Y - 1}
		if tip.Y > 0 && !visited[upCoord] {
			possible = append(possible, possibility{"up", upCoord})
		}
		downCoord := mazelib.Coordinate{tip.X, tip.Y + 1}
		if tip.Y < height-1 && !visited[downCoord] {
			possible = append(possible, possibility{"down", downCoord})
		}
		if len(possible) == 0 {
			current = current[:len(current)-1]
			continue
		}
		dir := randomDir(possible, tip.X, tip.Y, goalX, goalY, bias)
		newCoord := digInto(dir, tip, m)
		visited[newCoord] = true
		current = append(current, newCoord)
	}
	// Bias O is a direct path to treasure. Remove all other walls from start
	// so that everything not on the path will be connected, and likely fully explored before backtracking
	// to the right route. Also makes choosing correct path less likely.
	if bias == "O" {
		if goalX > 0 {
			digInto("left", mazelib.Coordinate{goalX, goalY}, m)
		}
		if goalX < width-1 {
			digInto("right", mazelib.Coordinate{goalX, goalY}, m)
		}
		if goalY > 0 {
			digInto("up", mazelib.Coordinate{goalX, goalY}, m)
		}
		if goalY < height-1 {
			digInto("down", mazelib.Coordinate{goalX, goalY}, m)
		}
	}
	return m
}
Example #2
0
// Creates a maze with all walls
// Good starting point for subtractive algorithms
func FullMaze() *mazelib.Maze {
	ySize := viper.GetInt("height")
	xSize := viper.GetInt("width")
	return mazelib.FullMaze(xSize, ySize)
}