# Leonhard loves labyrinths

## The background

My son Leonhard (4 years old) loves labyrinths. I don't know where he knows labyrinths from, but he paints them and knows quite well how they work:

Recently, he started making a game from his paintings. These are his rules:

• a black square denotes the starting point.
• a hook denotes the exit of the labyrinth (that's where you get pulled out).
• you can collect crowns.
• you can collect gold nuggets (the round things).
• you can go a way forth and back, but not more than that.
• arrows may guide you to the exit. (If he paints a labyrinth for me to solve, they are often misleading).

Annotated version:

• blue: starting point
• orange: crowns
• yellow: area with gold nuggets
• green: hook (exit)

Maybe you know, at the age of 4, kids start telling porky-pies and sometimes he does not follow his own rules, especially if he finds out that he cannot reach the end of the maze any more.

That's where you come into play: since I'm looking for games for kids anyway, you turn his idea into a game where cheating is not possible.

Well, we need some more definitions I'd say:

• the playing field is a n*m rectangle of equally sized squares.
• a square can have 0 to 4 walls, one on each side.
• a crown is worth 50 points.
• a gold nugget is worth 20 points.
• walking on a square that has already been walked subtracts 1 point.
• squares are marked in a way to identify how often the player walked on it (0, 1 or 2 times)
• the player can walk in 4 directions, except if there is a wall.
• Input device can be anything. Please consider keyboard support.
• The labyrinth must be solvable. I.e. it must be possible to reach the hook from the starting point and it must be possible to collect all the valuables (even if that does not result in the highest possible score).
• If the player gets stuck, the game ends.
• The player must not die by falling off the board. You may put a wall around the complete maze or wrap around edges, whatever you like.
• the program takes an word (0-65535) argument as input. This is the seed for the random number generator. Calling the program with the same seed again results in the same labyrinth.

Bonus:

• calculate the maximum points that can be collected. Consider that due to -1 points it might be better to not collect all items.
• Show the best solution (shortest way to get maximum points)

## The Rules

This is a popularity contest, since I want to be able to read and understand the code and perhaps adapt to new ideas of my son. Sorry, code golfers, maybe you want to create a copy of this question with rules more suitable for golfing, e.g. a console version with all the characters defined.

The most popular game on 3rd of May will become the accepted answer. And, hey, why not publish it in an app store?

• I feel as though this may come under fire for being too much of an art competition vs a programming one. Since all of these games should behave in a nearly identical way, what reason would I have to vote for one over another besides how nice it looks? There doesn't seem to be much potential creativity in making this maze game. That said, I'm more of a golfer, so I'll let people who more frequently participate in pop-cons decide if this is on topic. Apr 20, 2015 at 22:51
• There are two separate parts to this challenge: one is the labyrinth design (but it is difficult to algorithmically produce a satisfactory game labyrinth) and the other is the game engine (which is rather easier). I think it would be better if you restricted the challenge to the game engine (and made it a code golf.) You would need to post some sample labyrinths (to be taken as input from text file) in the question (possibly designed with your son's help.) Apr 20, 2015 at 23:00
• Related (and perhaps a partial duplicate of the labyrinth design part) codegolf.stackexchange.com/q/25967/15599 Apr 20, 2015 at 23:03
• I think this is an excellent challenge. It has several problems to solve and room for creativity. More challenges like this please +1. [back to building a solution...] Apr 20, 2015 at 23:16
• Are we required to generate "arrows". Do they allow the player to cross them the other way? Apr 22, 2015 at 2:25

# JavaScript

Work in progress. Unfortunately the maze is not always solvable - the limit on back-forward is the real hurdle.

Edit 1 Cosmetic
Edit 2 Better gameplay, but the big problem is still there

var rows, columns, rowOfs, maze, plPos, points, playing

$('#BNEW').on('click', function() { NewMaze(); });$('#BREP').on('click', function() {
Start();
});

$(document).on('keydown', function(e) { var ok, move, pxy, mz,$td
switch (e.which)
{
case 37:
(move = -1, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
break;
case 39:
(move = 1, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
break;
case 38:
(move = -rowOfs, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
break;
case 40:
(move = rowOfs, ok = maze[plPos+move] < 9 && maze[plPos+move*2] < 9);
break;
}
if (playing && ok)
{
pxy = getXY(plPos)
mz = maze[plPos] < 8 ? 8 : 9;
$td =$('#Field table tr').eq(pxy.y).find('td').eq(pxy.x)
$td.addClass("m"+mz); maze[plPos] = mz; maze[plPos+move] = mz; plPos += move*2; mz = maze[plPos]; PTS.value = mz==7 ? points += 20 : mz==6 ? points += 50 : mz == 8 ? points -= 1 : points; pxy = getXY(plPos)$td = $('#Field table tr').eq(pxy.y).find('td').eq(pxy.x)$td.removeClass("m6 m7")
$('#Player').finish().animate(playerCss(pxy.x,pxy.y)); CheckEndGame(); } return !move }); function CheckEndGame() { var msg = '' if (maze[plPos] == 5) { msg = "Maze completed!"; } else if (maze[plPos+1]==9 && maze[plPos-1]==9 && maze[plPos+rowOfs]==9 && maze[plPos-rowOfs]==9) { msg = "You are stuck, try again!"; } if (msg) {$("#Msg").text(msg).show();
playing=false
}
}

function seed(s) {
return function() {
s = Math.sin(s) * 10000; return s - Math.floor(s);
};
};

function Build()
{
var i
var Fill = function(p)
{
var d=[rowOfs,-rowOfs,1,-1], i, s, l
maze[p] = 1
while(d[0])
{
i = random()*d.length|0
s = d[i]
if (s != (l=d.pop())) d[i]=l
if (maze[p+s+s]>8) {
maze[p+s] = 1, Fill(p+s+s)
}
}
}
rowOfs = (columns + 1) * 2
maze = Array(rowOfs * (rows*2+1))
for (i=0; i < maze.length; i++)
maze[i] = i % rowOfs? 9 : 0
Fill(rowOfs+2)
}

function NewMaze()
{
SEED.value = Math.random()*65536 | 0
Start()
}

function Start()
{
var sd = SEED.value || 1
columns = COLS.value |0 || 18
rows = ROWS.value | 0 || 12
COLS.value = columns
ROWS.value = rows
random = seed(sd)
PTS.value = points = 0
$("#Msg").hide(); Build() plx = random()*columns|0; ply = random()*rows|0; setPlayer(plx,ply); plPos = getPos(plx,ply); BlockTriples(plPos); AddItems(plPos); Draw(); playing = true; } function AddItems(p) { var d=[rowOfs,-rowOfs,1,-1] var cells=[] // scan all reachable cells and calc distance from start var Go = function(p,l) { var i,t,mark,r ++l cells.push([p,l]) maze[p] = 8; for(i=0; d[i]; i++) { t = d[i] if (maze[p+t]<2 && maze[p+t+t]<2) { Go(p+t+t, l) } } maze[p] = 0; } Go(p,0) cells.sort(function(a,b){return a[1]-b[1]}) cells=cells.slice(10) // cut the shortest distances r = random()*10|0; //exit r = cells.length-r-1 maze[cells[r][0]] = 5; console.log(r) cells = cells.slice(0,r) var ncr = rows, nnu = columns for(i = ncr+nnu; i; i--) { r = random()*cells.length|0 maze[cells[r][0]] = (i > ncr ? 7 : 6); cells[r] = cells.pop(); } } function BlockTriples(p) { var d=[rowOfs,-rowOfs,1,-1] var Go = function(p) { var i,t,size=[0,0,0,0],s=1,nw=0,min,minp maze[p] = 8 for(i=0; d[i]; i++) { t = d[i] if (maze[p+t]<9 && maze[p+t+t]<8) { ++nw s += size[i] = Go(p+t+t) } } if (nw > 2) // triple way, block the smallest { for(i=0,min=1e6; d[i]; i++) size[i] && size[i] < min && (min = size[minp = i]) maze[p + d[minp]] = 5; } maze[p]=0 return s } Go(p) } function Draw() { var q=[], i, x, y; for(i = rowOfs+2, y = 0; y < rows; y++) { q.push('<tr>') for (x = 0; x < columns; i += 2, x++) { tcl = 'm'+(maze[i]|0) maze[i-1]>8 && (tcl += ' wl') maze[i+1]>8 && (tcl += ' wr') maze[i-rowOfs]>8 && (tcl += ' wu') maze[i+rowOfs]>8 && (tcl += ' wb') q.push('<td class="'+tcl+'"></td>') } q.push('</tr>') i += rowOfs+2 }$("#TOUT").html(q.join(''));
$("#Field").show(); } function setPlayer(posx, posy) {$('#Player').css(playerCss(posx, posy));
}

function getXY(pos)
{
return { x: (plPos % rowOfs)/2-1, y: plPos / rowOfs / 2 | 0}
}

function getPos(x, y)
{
return (x+y*rowOfs)*2 + rowOfs+2;
}

function playerCss(posx, posy)
{
return{ left: 6+posx*21, top: posy*21+2};
}
input { width: 3em; margin-right:1em }
table {
border: 2px solid #000;
border-collapse: collapse;
font-size: 8px }
#Field {
margin: 10px;
position: relative;
display: none;
}
td {
width: 19px; height: 19px;
text-align: center;
}
td.wl { border-left: 2px solid #444; background: #fff }
td.wr { border-right: 2px solid #444; background: #fff }
td.wt { border-top: 2px solid #444;; background: #fff }
td.wb { border-bottom: 2px solid #444; background: #fff }
td.m7 { background: #ffd url(https://i.sstatic.net/QUInh.png) -21px 0}
td.m6 { background: #efe url(https://i.sstatic.net/QUInh.png) -1px 0}
td.m5 { background: #ddf url(https://i.sstatic.net/QUInh.png) -40px 0}
td.m8 { background: #eed }
td.m9 { background: #f55 }
#Player { position: absolute; top:0; left:0; color: #007; background: #fcb; font-size:12px }
#Msg { color: red; font-size:40px; display:none;  }
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
ID:<input id=SEED>
Rows:<input id=ROWS>
Columns:<input id=COLS>
<button id=BNEW>New</button>
<button id=BREP>Replay</button>
<div id=Msg></div>
<div id=Field>
</table>
<span id=Player>⛄</span>
</div>
Score: <input readonly id=PTS>

• Well done, impressive. 👍🏼 I do not get the 'logic' on how you create the maze. How does that part work? May 4, 2015 at 11:47
• @CousinCocaine The Build function use a recursive fill, it's the more 'classic' way to build a simply connected maze - see en.wikipedia.org/wiki/Maze_generation_algorithm May 4, 2015 at 12:21
• My son loves it. While he wants me to print larger size mazes, he plays the smaller ones online. According to the rules, your answer was the best on 3rd of May, so I've accepted it now. Since it is also the only answer, you get the bounty. Well done, it's amazing. May 8, 2015 at 16:58
• Thank you very much, glad that your son likes it. Now it's time to raise the biddings. May 8, 2015 at 18:07

# Java

I never complained about GolfScript or CJam, but here's a Java answer for you anyway. This was a really enjoyable challenge. ;)

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.geom.Ellipse2D;
import java.util.*;
import javax.swing.*;

public class MazeMaker {
int row, col, exitRow, exitCol, numCells, score, array[][];
final int SQWIDTH = 20;
boolean gameOver = true;
Ellipse2D.Double ellipse;
JFrame frame;
JPanel mazePanel;
JLabel scoreLabel;

public MazeMaker() {
frame = new JFrame("Maze");
frame.setLayout(new BorderLayout());
JPanel topPanel = createTopPanel();

createMazePanel();

setKeyActions();

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}

private void constructArray(int seed, int rows, int cols) {
array = new int[rows*2-1][cols*2-1];
for (int[] a : array)
Arrays.fill(a,-1);
numCells = (array.length / 2 + 1) * (array[0].length / 2 + 1);
Random rand = new Random(seed);
int row = rand.nextInt(array.length / 2 + 1) * 2;
int col = rand.nextInt(array[0].length / 2 + 1) * 2;
array[row][col] = 0;
boolean first = true, a = false, exitFound = false;

while (true) {
if (first) {
int direction = rand.nextInt(4);
if (direction == 0 && row != 0) {
array[row-1][col] = 0;
array[row-2][col] = 0;
row -= 2;
first = false;
}
else if (direction == 1 && col != array[0].length - 1) {
array[row][col+1] = 0;
array[row][col+2] = 0;
col += 2;
first = false;
}
else if (direction == 2 && row != array.length - 1) {
array[row+1][col] = 0;
array[row+2][col] = 0;
row += 2;
first = false;
}
else if (direction == 3 && col != 0) {
array[row][col-1] = 0;
array[row][col-2] = 0;
col -= 2;
first = false;
}
}
else {
int availableCells = 0;
boolean up = false, down = false, left = false, right = false;
if (row != 0 && array[row-2][col] == -1) {
availableCells++;
up = true;
}

if (col != array[0].length-1 && array[row][col+2] == -1) {
availableCells++;
right = true;
}

if (row != array.length-1 && array[row+2][col] == -1) {
availableCells++;
down = true;
}

if (col != 0 && array[row][col-2] == -1) {
availableCells++;
left = true;
}

if (availableCells != 0) {
a = true;
while (true) {
boolean[] b = {up,right,down,left};
int i = rand.nextInt(4);
if (b[i]) {
if (i == 0) {
array[row-1][col] = 0;
array[row-2][col] = 0;
row -= 2;
}
else if (i == 1) {
array[row][col+1] = 0;
array[row][col+2] = 0;
col += 2;
}
else if (i == 2) {
array[row+1][col] = 0;
array[row+2][col] = 0;
row += 2;
}
else if (i == 3) {
array[row][col-1] = 0;
array[row][col-2] = 0;
col -= 2;
}
break;
}
}
}
else {
array[row][col] = 1;
if (!exitFound && a) {
if (new Random().nextInt(5) == 0) {
exitFound = true;
exitRow = row;
exitCol = col;
}
}
a = false;
if (row != 0 && array[row-1][col] == 0 && (array[row-2][col] == 0 || array[row-2][col] == 1)) {
array[row-1][col] = 1;
array[row-2][col] = 1;
row -= 2;
}
else if (col != array[0].length-1 && array[row][col+1] == 0 && (array[row][col+2] == 0 || array[row][col+2] == 1)) {
array[row][col+1] = 1;
array[row][col+2] = 1;
col += 2;
}
else if (row != array.length-1 && array[row+1][col] == 0 && (array[row+2][col] == 0 || array[row+2][col] == 1)) {
array[row+1][col] = 1;
array[row+2][col] = 1;
row += 2;
}
else if (col != 0 && array[row][col-1] == 0 && (array[row][col-2] == 0 || array[row][col-2] == 1)) {
array[row][col-1] = 1;
array[row][col-2] = 1;
col -= 2;
}
}
if (checkDone()) {
if (!exitFound) {
exitRow = row;
exitCol = col;
}
break;
}
}
}
}

private boolean checkDone() {
int count = 0;
for (int k = 0; k < array.length; k+=2) {
for (int l = 0; l < array[0].length; l+=2) {
if (array[k][l] == 0 || array[k][l] == 1)
count++;
}
}
return count == numCells;
}

private JPanel createTopPanel() {
GridBagLayout l = new GridBagLayout();
GridBagConstraints c = new GridBagConstraints();
c.fill = GridBagConstraints.BOTH;

JPanel panel = new JPanel(l);
JLabel inputLabel = new JLabel("ID:");
c.gridwidth = 1;
l.setConstraints(inputLabel,c);

JTextField inputField = new JTextField(5);
l.setConstraints(inputField,c);

JLabel rowLabel = new JLabel("Rows:");
l.setConstraints(rowLabel,c);

JTextField rowField = new JTextField(3);
l.setConstraints(rowField,c);

JLabel colLabel = new JLabel("Columns:");
l.setConstraints(colLabel,c);

JTextField colField = new JTextField(3);
l.setConstraints(colField,c);

JButton applyButton = new JButton("Apply");
try {
int seed = Integer.parseInt(inputField.getText()),
rows = Integer.parseInt(rowField.getText()),
cols = Integer.parseInt(colField.getText());
if (seed >= 0 && rows >= 3 && cols >= 3) {
gameOver = false;
scoreLabel.setText("Score: " + (score = 0));
constructArray(seed,rows,cols);
row = (int) (Math.random() * (array.length / 2 + 1)) * 2;
col = (int) (Math.random() * (array[0].length / 2 + 1)) * 2;
frame.setSize((1+SQWIDTH * array[0].length)/2 > 750 ? (1+SQWIDTH * array[0].length)/2 : 750,
75+(1+SQWIDTH * array.length)/2);
mazePanel.setPreferredSize(new Dimension(
(1+SQWIDTH * array[0].length)/2 > 750 ? (1+SQWIDTH * array[0].length)/2 - 15 : 750,
15+(1+SQWIDTH * array.length)/2));
ellipse = new Ellipse2D.Double(col*SQWIDTH/2+3,row*SQWIDTH/2+3,10,10);
setItems();
mazePanel.repaint();
}
} catch (NumberFormatException ignore) {}
});
l.setConstraints(applyButton,c);

scoreLabel = new JLabel("Score: ");
c.gridwidth = GridBagConstraints.REMAINDER;
l.setConstraints(scoreLabel,c);

return panel;
}

private void createMazePanel() {
mazePanel = new JPanel() {
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
int x = 0, y = 0;
if (!gameOver) {
for (int k = 0; k < array.length; k+=2) {
for (int l = 0; l < array[0].length; l+=2) {
int n = array[k][l];
if (n == 0 || n == 1 || n == 4 || n == 5 || n == 6)
g.setColor(Color.white);
else if (n == 2)
g.setColor(Color.green);
else if (n == 3)
g.setColor(Color.red);
g.fillRect(x, y, SQWIDTH, SQWIDTH);
if (n == 4) {
g.setColor(new Color(245,209,34));
g.fillOval(x+3, y+3, 10, 10);
}
else if (n == 5) {
g.setColor(new Color(255,223,55));
g.fillPolygon(new int[]{x,x+3,x+8,x+13,x+16,x+14,x+2},new int[]{y+2,y+6,y+2,y+6,y+2,y+16,y+16},7);
g.setColor(new Color(12,234,44));
g.fillOval(x+7,y+6,4,7);
}
else if (n == 6) {
Graphics2D g2 = (Graphics2D) g.create();
g2.setStroke(new BasicStroke(2,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
g2.setColor(new Color(108,225,119));
g2.drawOval(x+5, y+1, 8, 8);
g2.drawLine(x+5, y+3, x+5, y+11);
g2.drawArc(x+5, y+8, 7, 7, 180, 180);
}
g.setColor(Color.black);
if (k != array.length-1 && array[k+1][l] == -1)
g.fillRect(x-3, y+SQWIDTH-3, SQWIDTH+3, 3);
if (l != array[0].length-1 && array[k][l+1] == -1)
g.fillRect(x+SQWIDTH-3,y,3,SQWIDTH);
x += SQWIDTH;
}
x = 0;
y += SQWIDTH;
}
g.setColor(Color.red);
((Graphics2D) g).fill(ellipse);
}
}
};
}

private void setKeyActions() {
InputMap im = mazePanel.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
ActionMap am = mazePanel.getActionMap();

im.put(KeyStroke.getKeyStroke("pressed UP"), "up");
am.put("up", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ev) {
if (row != 0 && array[row-1][col] != -1 && array[row-2][col] != 3 && !gameOver) {
int n = array[row][col];
array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
row -= 2;
n = array[row][col];
if (n == 4)
scoreLabel.setText("Score: " + (score += 20));
else if (n == 5)
scoreLabel.setText("Score: " + (score += 50));
else if (n == 2)
scoreLabel.setText("Score: " + (score -= 1));
ellipse.y = row * SQWIDTH/2 + 3;
mazePanel.repaint();
}
if (!gameOver && array[row][col] == 6) {
JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
else if (!gameOver && checkGameOver()) {
JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
}
});

im.put(KeyStroke.getKeyStroke("pressed RIGHT"), "right");
am.put("right",new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ev) {
if (col != array[0].length-1 && array[row][col+1] != -1 && array[row][col+2] != 3 && !gameOver) {
int n = array[row][col];
array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
col += 2;
n = array[row][col];
if (n == 4)
scoreLabel.setText("Score: " + (score += 20));
else if (n == 5)
scoreLabel.setText("Score: " + (score += 50));
else if (n == 2)
scoreLabel.setText("Score: " + (score -= 1));
ellipse.x = col * SQWIDTH/2 + 3;
mazePanel.repaint();
}
if (!gameOver && array[row][col] == 6) {
JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
else if (!gameOver && checkGameOver()) {
JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
}
});

im.put(KeyStroke.getKeyStroke("pressed DOWN"), "down");
am.put("down", new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ev) {
if (row != array.length-1 && array[row+1][col] != -1 && array[row+2][col] != 3 && !gameOver) {
int n = array[row][col];
array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
row += 2;
n = array[row][col];
if (n == 4)
scoreLabel.setText("Score: " + (score += 20));
else if (n == 5)
scoreLabel.setText("Score: " + (score += 50));
else if (n == 2)
scoreLabel.setText("Score: " + (score -= 1));
ellipse.y = row * SQWIDTH/2 + 3;
mazePanel.repaint();
}
if (!gameOver && array[row][col] == 6) {
JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
else if (!gameOver && checkGameOver()) {
JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
}
});

im.put(KeyStroke.getKeyStroke("pressed LEFT"), "left");
am.put("left",new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ev) {
if (col != 0 && array[row][col-1] != -1 && array[row][col-2] != -1 && !gameOver) {
int n = array[row][col];
array[row][col] = n == 0 || n == 1 || n == 4 || n == 5 ? 2 : 3;
col -= 2;
n = array[row][col];
if (n == 4)
scoreLabel.setText("Score: " + (score += 20));
else if (n == 5)
scoreLabel.setText("Score: " + (score += 50));
else if (n == 2)
scoreLabel.setText("Score: " + (score -= 1));
ellipse.x = col * SQWIDTH/2 + 3;
mazePanel.repaint();
}
if (!gameOver && array[row][col] == 6) {
JOptionPane.showMessageDialog(frame, "Huzzah! You found the exit! ", "Finish", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
else if (!gameOver && checkGameOver()) {
JOptionPane.showMessageDialog(frame, "You got trapped! Try again!", "Game over", JOptionPane.PLAIN_MESSAGE);
gameOver = true;
}
}
});
}

private void setItems() {
array[exitRow][exitCol] = 6;
Random r = new Random();
for (int k = 1; k < (array.length * array[0].length) / 20; k++) {
int row = r.nextInt(array.length / 2 + 1) * 2,
col = r.nextInt(array[0].length / 2 + 1) * 2;
if ((row == this.row && col == this.col) || array[row][col] == 4 || array[row][col] == 5 || array[row][col] == 6)
k--;
else
array[row][col] = r.nextInt(2) + 4;
}
}

private boolean checkGameOver() {
if (row == 0 && col == 0)
return (array[row+2][col] == 3 && array[row][col+2] == 3) ||
(array[row+1][col] == -1 && array[row][col+2] == 3) ||
(array[row+2][col] == 3 && array[row][col+1] == -1);
else if (row == 0 && col == array[0].length-1)
return (array[row+2][col] == 3 && array[row][col-2] == 3) ||
(array[row+1][col] == -1 && array[row][col-2] == 3) ||
(array[row+2][col] == 3 && array[row][col-1] == -1);
else if (row == array.length-1 && col == 0)
return (array[row-2][col] == 3 && array[row][col+2] == 3) ||
(array[row-1][col] == -1 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row][col+1] == -1);
else if (row == array.length-1 && col == array[0].length-1)
return (array[row-2][col] == 3 && array[row][col-2] == 3) ||
(array[row-1][col] == -1 && array[row][col-2] == 3) ||
(array[row-2][col] == 3 && array[row][col-1] == -1);
else if (row == 0)
return (array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+1] == -1) ||
(array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row+1][col] == -1 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
(array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3);
else if (col == 0)
return (array[row][col+2] == 3 && array[row-1][col] == -1 && array[row+1][col] == -1) ||
(array[row][col+1] == -1 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
(array[row][col+1] == -1 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
(array[row][col+1] == -1 && array[row-2][col] == 3 && array[row+2][col] == 3) ||
(array[row][col+2] == 3 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
(array[row][col+2] == 3 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
(array[row][col+2] == 3 && array[row-2][col] == 3 && array[row+2][col] == 3);
else if (row == array.length-1)
return (array[row-2][col] == 3 && array[row][col-1] == -1 && array[row][col+1] == -1) ||
(array[row-1][col] == -1 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row-1][col] == -1 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row-1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row-2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3);
else if (col == array[0].length-1)
return (array[row][col-2] == 3 && array[row-1][col] == -1 && array[row+1][col] == -1) ||
(array[row][col-1] == -1 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
(array[row][col-1] == -1 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
(array[row][col-1] == -1 && array[row-2][col] == 3 && array[row+2][col] == 3) ||
(array[row][col-2] == 3 && array[row-2][col] == 3 && array[row+1][col] == -1) ||
(array[row][col-2] == 3 && array[row-1][col] == -1 && array[row+2][col] == 3) ||
(array[row][col-2] == 3 && array[row-2][col] == 3 && array[row+2][col] == 3);
else
return (array[row-2][col] == 3 && array[row][col+1] == -1 && array[row+1][col] == -1 && array[row][col-1] == -1) ||
(array[row-1][col] == -1 && array[row][col+2] == 3 && array[row+1][col] == -1 && array[row][col-1] == -1) ||
(array[row-1][col] == -1 && array[row][col+1] == -1 && array[row+2][col] == 3 && array[row][col-1] == -1) ||
(array[row-1][col] == -1 && array[row][col+1] == -1 && array[row+1][col] == -1 && array[row][col-2] == 3) ||
(array[row-1][col] == -1 && array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+1] == -1) ||
(array[row-2][col] == 3 && array[row+1][col] == -1 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row-1][col] == -1 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row-1][col] == -1 && array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row-1][col] == -1 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row+1][col] == -1 && array[row][col-2] == 3 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-1] == -1 && array[row][col+2] == 3) ||
(array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+1] == -1) ||
(array[row-2][col] == 3 && array[row+2][col] == 3 && array[row][col-2] == 3 && array[row][col+2] == 3);
}

public static void main(String[] args) {
SwingUtilities.invokeLater(MazeMaker::new);
}
}


The process of creating the actual maze uses the depth-first search algorithm, but with an iterative approach. Here's how it works.

We start with a 2D array of int values, each element being a -1. A random element with even indices is chosen, and its value becomes 0:

-1 -1 -1 -1 -1 -1  0 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1


Then the program enters a loop, checking for available cells until it reaches a state where there are no available cells. This can happen several times, and is when it begins to backtrack. At this time all 0s that it comes across become 1s. Also during this time is when it determines whether an exit should be placed at that location. So at the end of it all, the array could look like this:

 0  0  0  0  0  0  1  1  1
0 -1 -1 -1 -1 -1  0 -1  1
0  0  0  0  0 -1  0 -1  1
-1 -1 -1 -1 -1 -1  0 -1  1
0  0  0  0  0  0  0 -1  1
0 -1 -1 -1 -1 -1 -1 -1  1
0 -1  1  1  1  1  1 -1  1
0 -1  1 -1  1 -1 -1 -1  1
0 -1  1 -1  1  1  1  1  1


When there are a predetermined number of 1s or 0s at certain spots in the array, the loop exits. Then, using the array, the resulting maze is drawn:

It's easy to see that the -1s in the array represent walls, and the 0s and 1s are corridors. Items are randomly distributed throughout the maze. The red ellipse is the "player" that you control.

The maze is wrapped in a scroll pane for convenience so that if the size exceeds the frame's maximum size you can scroll to see the rest of the maze.

I'd say the only problem with this is how the end of game check is carried out. I thought about several ways to go about doing it, but I ended up resorting to hard-coding it all. I'm open to suggestions on how it can be done.

• This doesn't compile. MazeMaker.java:168: error: cannot find symbol printArray(); ^ symbol: method printArray() location: class MazeMaker May 10, 2015 at 13:26
• @edc65 Thanks for letting me know. I did have a method called printArray that I used to output the array, but deleted it and forgot to remove the method call.
– TNT
May 10, 2015 at 13:32
• Ok, I have it running now. It's nice. I'm trying to restart the same maze keeping the same id, but does not seem to work. May 10, 2015 at 13:36
• I have it so that the start and end positions are randomized each time the Apply button is pressed, but the layout of the maze remains the same. Should it not be that way?
– TNT
May 10, 2015 at 13:42
• I thought that as a way to start again with the exactly the same challenge. My main concern is to verify that the challenge is always solvable (a constraint of original questione that I found hard) May 10, 2015 at 13:48

# Python

I realize I'm late for the party, but here is my take on this challenge. I went text based as I haven't gotten around to learning pygame, yet. It is Python 3. Change input to raw_input and it should work in python2 also.

The Hook (exit) is represented by "J". "W" is crowns (50). "G" is Gold nuggets (20). The Player is "O". I experimented with using "P" for the player, but I found "O" easier to Identify.

I used standard depth first maze generation, then add the gold, crowns, hook, and current player position. I did not implement the criteria that all treasure can be obtained.

import random

direcs = {'n':[0,-1],
's':[0,1],
'w':[-1,0],
'e':[1,0]}
dirs = ['n','s','e','w']

class maze_space(object):
def __init__(self):
self.n = 0
self.s = 0
self.e = 0
self.w = 0
self.visited = 0
self.contents = ' '

def mirror(self,drct,val):
if drct == 'n' : self.s = val
if drct == 's' : self.n = val
if drct == 'e' : self.w = val
if drct == 'w' : self.e = val

class MazeGame(object):

def __init__(self,horiz=12,vert=8):
self.completed = 0
self.score = 0
self.grid = [[maze_space() for x in range(horiz)] for y in range(vert)]

def walk(y,x):
self.grid[y][x].visited = 1
drs = self.make_dir_list(y, x)
random.shuffle(drs)
for dr in drs:
yy = y + direcs[dr][1]
xx = x + direcs[dr][0]
if not self.grid[yy][xx].visited:
setattr(self.grid[y][x], dr, 1)
self.grid[yy][xx].mirror(dr, 1)
walk(yy, xx)

y, x = self.pick_row_col()
walk(y, x)
self.maze_populate()
self.printmaze()

def main_loop(self):
while not self.completed:
move = get_move(self.grid, self.cury, self.curx)
self.make_move(move)
self.printmaze()

def pick_row_col(self):
'''pick a random cell in the grid'''
row = random.randint(0, len(self.grid) - 1)
col = random.randint(0, len(self.grid[0]) - 1)
return row, col

def make_dir_list(self, y, x):
'''return list of available move directions'''
drs = dirs[:]
if x == 0 : drs.pop(drs.index('w'))
if y == 0 : drs.pop(drs.index('n'))
if x == len(self.grid[0]) - 1 : drs.pop(drs.index('e'))
if y == len(self.grid) - 1 : drs.pop(drs.index('s'))
return drs

def maze_populate(self):
# populate maze with crowns and gold nuggets
for treasure in ['G', 'W']:
for _ in range(random.randint(1, len(self.grid[0]))):
yy, xx = self.pick_row_col()
self.grid[yy][xx].contents = treasure

self.cury, self.curx = self.pick_row_col() # start position
exity, exitx = self.pick_row_col() # hook (exit) position
#make sure start is not on top of exit
while self.cury == exity and self.curx == exitx :
exitx = random.randint(0, len(self.grid[0]) - 1)

self.grid[self.cury][self.curx].contents = 'O'
self.grid[exity][exitx].contents = 'J'

def make_move(self,dr):
self.grid[self.cury][self.curx].visited += 1
self.grid[self.cury][self.curx].contents = '.'
# player has walked twice -> disable
if self.grid[self.cury][self.curx].visited >= 3:
self.grid[self.cury][self.curx].contents = 'X'
drs = self.make_dir_list(self.cury, self.curx)
for d in drs:
yyy = self.cury + direcs[d][1]
xxx = self.curx + direcs[d][0]
self.grid[yyy][xxx].mirror(d,0)

yy = self.cury + direcs[dr][1]
xx = self.curx + direcs[dr][0]
if self.grid[yy][xx].contents == 'J': self.completed = 1
if self.grid[yy][xx].contents == 'W': self.score += 50
if self.grid[yy][xx].contents == 'G': self.score += 20
if self.grid[yy][xx].contents == '.': self.score -= 1
self.grid[yy][xx].contents = 'O'
self.cury, self.curx = yy, xx

def printmaze(self):
if self.completed: print('\nMaze complete.  Good job!')
print('Score: %d'%self.score)
print('|'+''.join('---' for _ in self.grid[0]))
for line in self.grid:
print('|' + ''.join(' %s '%x.contents if x.e else ' %s|'%
x.contents for x in line))
print('|' + ''.join('  -' if x.s else '---' for x in line))

def get_params():
hor = input('width (default=12): ')
hor = int(hor) if hor else 12
ver = input('height (default=8): ')
ver = int(ver) if ver else 8
rseed = input('seed : ')
rseed = int(rseed) if rseed else random.randint(1,65535)
print(rseed)
random.seed(rseed)
print("'J' = hook (exit)\n'O' = Player")
print("'G' = gold nugget (20 points)\n'W' = Crown (50 points)")
print('Player may only tread on a given tile twice')
return hor,ver

def get_move(grid, y, x):
choice = input('where do you want to move %s q to quit: '%dirs)
if choice == 'q' : exit()
if choice in dirs and getattr(grid[y][x],choice): return choice
return get_move(grid, y, x)

def main():
hor,ver = get_params()
maze = MazeGame(hor,ver)
maze.main_loop()

if __name__ == '__main__':
main()