Código 1 (Blogspot_Laberinto_final.java):
package blogspot_laberinto_final;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class Blogspot_Laberinto_final {
public static void main(String[] args) {
//tamaño laberinto (núm. bloques)
int x = 21;
int y = 29;
//generar laberinto aleatorio
String strMaze = new LineMaze(new BinMaze(new Maze(y - 2, x - 2).toString(), x, y).toMatrix(), x, y).toString();
//tamaño lienzo
int res_x = 1024;
int res_y = 768;
BufferedImage imagen = new BufferedImage(res_x, res_y, BufferedImage.TYPE_INT_RGB);
Lienzo.Dibujar((Graphics2D) imagen.getGraphics(), res_x, res_y, strMaze);
try {
ImageIO.write(imagen, "png", new File("Laberinto.png"));
} catch (IOException e) {
}
}
}
Código 2 (Maze.java):
package blogspot_laberinto;
import java.util.LinkedList;
import java.util.Random;
public class Maze {
public static final char PASSAGE_CHAR = ' ';
public static final char WALL_CHAR = '█';
public static final boolean WALL = false;
public static final boolean PASSAGE = !WALL;
private final boolean map[][];
private final int width;
private final int height;
public Maze(final int width, final int height) {
this.width = width;
this.height = height;
this.map = new boolean[width][height];
final LinkedList<int[]> frontiers = new LinkedList<>();
final Random random = new Random();
int x = random.nextInt(width);
int y = random.nextInt(height);
frontiers.add(new int[]{x, y, x, y});
while (!frontiers.isEmpty()) {
final int[] f = frontiers.remove(random.nextInt(frontiers.size()));
x = f[2];
y = f[3];
if (map[x][y] == WALL) {
map[f[0]][f[1]] = map[x][y] = PASSAGE;
if (x >= 2 && map[x - 2][y] == WALL) {
frontiers.add(new int[]{x - 1, y, x - 2, y});
}
if (y >= 2 && map[x][y - 2] == WALL) {
frontiers.add(new int[]{x, y - 1, x, y - 2});
}
if (x < width - 2 && map[x + 2][y] == WALL) {
frontiers.add(new int[]{x + 1, y, x + 2, y});
}
if (y < height - 2 && map[x][y + 2] == WALL) {
frontiers.add(new int[]{x, y + 1, x, y + 2});
}
}
}
}
@Override
public String toString() {
final StringBuffer b = new StringBuffer();
for (int x = 0; x < width + 2; x++) {
b.append(WALL_CHAR);
}
b.append('\n');
for (int y = 0; y < height; y++) {
b.append(WALL_CHAR);
for (int x = 0; x < width; x++) {
b.append(map[x][y] == WALL ? WALL_CHAR : PASSAGE_CHAR);
}
b.append(WALL_CHAR);
b.append('\n');
}
for (int x = 0; x < width + 2; x++) {
b.append(WALL_CHAR);
}
b.append('\n');
return b.toString();
}
}
Código 3 (BinMaze.java):
package blogspot_laberinto_final;
public class BinMaze {
char[] vMaze;
boolean[][] mMaze;
public BinMaze(String strMaze, int x, int y) {
vMaze = strMaze.replace("\n", "").toCharArray();
mMaze = new boolean[x + 2][y + 2]; //se suma 2 para los bordes (ahorrar codigo)
int cont = 0;
for (int i = 1; i < x + 1; i++) {
for (int j = 1; j < y + 1; j++) {
mMaze[i][j] = vMaze[cont] == '█';
cont++;
}
}
}
public boolean[][] toMatrix() {
return mMaze;
}
public char[] toArray() {
return vMaze;
}
}
Código 4 (LineMaze.java):
package blogspot_laberinto_final;
public class LineMaze {
String styleMap;
public LineMaze(boolean[][] mMaze, int x, int y) {
this.styleMap = "";
String strMuro = " ├┬┌┤─┐┬┴└│├┘┴┤┼";
boolean[][] mCod = combina();
for (int i = 1; i < x + 1; i++) {
for (int j = 1; j < y + 1; j++) {
if (mMaze[i][j]) { // si hay muro
for (int k = 0; k < 16; k++) {
if (mMaze[i - 1][j] == mCod[k][0] && mMaze[i][j - 1] == mCod[k][1] && mMaze[i + 1][j] == mCod[k][2] && mMaze[i][j + 1] == mCod[k][3]) {
styleMap += strMuro.charAt(k);
}
}
} else {
styleMap += " ";
}
}
styleMap += "\n";
}
}
@Override
public String toString() {
return styleMap;
}
private boolean[][] combina() {
String cod;
boolean[][] mCod = new boolean[16][4];
for (int i = 0; i < 16; i++) {
cod = Integer.toBinaryString(i);
while (cod.length() < 4) {
cod = "0" + cod;
}
for (int j = 0; j < cod.length(); j++) {
mCod[i][j] = cod.charAt(j) == '1';
}
}
return mCod;
}
}
Código 5 (Lienzo.java):
package blogspot_laberinto_final;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Stroke;
class Lienzo {
static void Dibujar(Graphics2D g, int x, int y, String strMaze) {
//tamaño bloque 32x32
int bloque_x = 32;
int bloque_y = 32;
String[] arrMaze = strMaze.split("\n");
//grosor muro
Stroke stroke5 = new BasicStroke(15f);
//fondo blanco
g.setColor(Color.WHITE);
g.fillRect(0, 0, x, y);
//color muro
g.setColor(Color.BLUE);
int x0, y0;
for (int j = 0; j < arrMaze.length; j++) {
for (int i = 0; i < arrMaze[0].length(); i++) {
if (arrMaze[j].charAt(i) != ' ') {
x0 = ((i + 1) * bloque_x) + bloque_x / 2;
y0 = ((j + 1) * bloque_y) + bloque_y / 2;
g.setStroke(stroke5);
switch (arrMaze[j].charAt(i)) {
case '─':
g.drawLine(x0, y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
break;
case '│':
g.drawLine(x0 + (bloque_x / 2), y0, x0 + (bloque_x / 2), y0 + bloque_y);
break;
case '┼':
g.drawLine(x0, y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0, x0 + (bloque_x / 2), y0 + bloque_y);
break;
case '┬':
g.drawLine(x0, y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 + bloque_y);
break;
case '┴':
g.drawLine(x0, y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 - bloque_y);
break;
case '├':
g.drawLine(x0 + (bloque_x / 2), y0, x0 + (bloque_x / 2), y0 + bloque_y);
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
break;
case '┤':
g.drawLine(x0 + (bloque_x / 2), y0, x0 + (bloque_x / 2), y0 + bloque_y);
g.drawLine(x0, y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 + (bloque_y / 2));
break;
case '┌':
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 + bloque_y);
break;
case '┐':
g.drawLine(x0, y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 + bloque_y);
break;
case '└':
g.drawLine(x0 + (bloque_x / 2), y0, x0 + (bloque_x / 2), y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0 + (bloque_y / 2), x0 + bloque_x, y0 + (bloque_y / 2));
break;
case '┘':
g.drawLine(x0, y0 + (bloque_y / 2), x0 + (bloque_x / 2), y0 + (bloque_y / 2));
g.drawLine(x0 + (bloque_x / 2), y0, x0 + (bloque_x / 2), y0 + (bloque_y / 2));
break;
default:
break;
}
}
}
}
}
}
Resultado:
