Come posso evitare di stampare entrambi i lati di un muro nel mio labirinto ascii?

Question

Ho scritto un codice che genera labirinti per me. Il labirinto consiste di (n x n) celle, ogni cella ha un valore booleano per rappresentare un muro (nord, sud, est ovest).

si sta lavorando bene, e ho scritto la funzione di seguito per stampare il labirinto:

public static void printMaze(Cell[][] maze) 
    { 
     for(int i = 0; i < maze.length; i++) 
     { 
      for(int j = 0; j < maze[i].length; j++) 
      { 
       System.out.print((maze[i][j].walls.get(Dir.NORTH)) ? "+--+" : "+ +"); 
      } 
      System.out.println(); 
      for(int j = 0; j < maze[i].length; j++) 
      { 
       System.out.print((maze[i][j].walls.get(Dir.WEST)) ? "|" : " "); 
       System.out.print(" "); 
       System.out.print((maze[i][j].walls.get(Dir.EAST)) ? "|" : " "); 
      } 
      System.out.println(); 
      for(int j = 0; j < maze[i].length; j++) 
      { 
       System.out.print((maze[i][j].walls.get(Dir.SOUTH)) ? "+--+" : "+ +"); 
      } 
      System.out.println(); 
     } 
    } 

Tuttavia, poiché le pareti delle cellule condividono ho producono una sorta di uno sguardo corridoio a doppia parete nella mia funzione di stampa:

+--++--++--++--++--++--++--++--++--++--+ 
|  ||     ||   | 
+--++ ++--++--++ ++--++--++ ++ ++--+ 
+--++ ++--++--++ ++--++--++ ++ ++--+ 
| ||   || ||   ||  | 
+ ++--++--++ ++ ++ ++--++--++--++ + 
+ ++--++--++ ++ ++ ++--++--++--++ + 
|  ||  || || ||  || || | 
+ ++ ++ ++--++ ++ ++ ++ ++ ++ + 
+ ++ ++ ++--++ ++ ++ ++ ++ ++ + 
| || || || ||   ||  || | 
+ ++ ++ ++ ++ ++--++--++--++--++ + 
+ ++ ++ ++ ++ ++--++--++--++--++ + 
| ||  ||   ||   || | 
+ ++--++--++--++--++--++ ++--++ ++ + 
+ ++--++--++--++--++--++ ++--++ ++ + 
| ||   ||   ||  || | 
+ ++--++ ++ ++ ++--++--++ ++--++ + 
+ ++--++ ++ ++ ++--++--++ ++--++ + 
|   || || ||  || ||  | 
+--++--++--++ ++ ++ ++ ++ ++ ++ + 
+--++--++--++ ++ ++ ++ ++ ++ ++ + 
|   || || || || ||  || | 
+ ++ ++--++ ++ ++ ++ ++--++--++ + 
+ ++ ++--++ ++ ++ ++ ++--++--++ + 
| || ||  ||  || || ||  | 
+ ++ ++ ++--++--++--++ ++ ++ ++--+ 
+ ++ ++ ++--++--++--++ ++ ++ ++--+ 
| ||      ||   | 
+--++--++--++--++--++--++--++--++--++--+ 

Come devo modificare la mia funzione di stampa in modo che appaia come:

+--+--+--+--+--+--+--+--+--+--+ 
|  |    |  | 
+--+ +--+--+ +--+--+ + +--+ 
| |  | |  |  | 
+ +--+--+ + + +--+--+--+ + 
|  |  | | |  | | | 
+ + + +--+ + + + + + + 
| | | | |  |  | | 
+ + + + + +--+--+--+--+ + 
| |  |  |  | | 
+ +--+--+--+--+--+ +--+ + + 
| |  |  |  | | 
+ +--+ + + +--+--+ +--+ + 
|  | | |  | |  | 
+--+--+--+ + + + + + + + 
|  | | | | |  | | 
+ + +--+ + + + +--+--+ + 
| | |  |  | | |  | 
+ + + +--+--+--+ + + +--+ 
| |     |  | 
+--+--+--+--+--+--+--+--+--+--+ 

temo Affronterò un problema simile quando alla fine arriverò al punto in cui comincio a disegnare il mio labirinto usando una grafica reale piuttosto che ascii.

Come si modifica il metodo printMaze in modo che passi dal primo esempio al secondo?

Nel caso qualcuno sia interessato, il codice sorgente della mia classe per la generazione di questi è here.

Answer 1

Stampare solo le pareti NORD e OVEST. Codice per la sua strada ...

ho cambiato i muri a un EnumSet

public Set<Dir> walls = EnumSet.allOf(Dir.class); 

Quindi non c'è bisogno di aggiungere qualsiasi pareti nel costruttore:

public Cell(final int x, final int y) { 
    this.x = x; 
    this.y = y; 
    this.Visited = false; 
} 

e di togliere la vostra muri, usano:

this.walls.remove(randDir); 
randomNeighbor.walls.remove(randDir.opposite()); 

E poi il codice di stampa è simile:

public static void printMaze(final Cell[][] maze) { 
    for (int r = 0; r < maze.length; r++) { 
     final Cell[] row = maze[r]; 
     printTop(row); 
     printMiddle(row); 
     if (r == maze.length - 1) { 
      printBottom(row); 
     } 
    } 
} 

private static void printBottom(final Cell[] row) { 
    for (final Cell cell : row) { 
     System.out.print(cell.walls.contains(Dir.SOUTH) ? "+--" : "+ "); 
    } 
    System.out.println("+"); 
} 

private static void printMiddle(final Cell[] row) { 
    for (int c = 0; c < row.length; c++) { 
     final Cell cell = row[c]; 
     System.out.print(cell.walls.contains(Dir.WEST) ? "| " : " "); 
     if (c == row.length - 1) { 
      System.out.println(cell.walls.contains(Dir.EAST) ? "|" : " "); 
     } 
    } 
} 

private static void printTop(final Cell[] row) { 
    for (final Cell cell : row) { 
     System.out.print(cell.walls.contains(Dir.NORTH) ? "+--" : "+ "); 
    } 
    System.out.println("+"); 
} 

(Nota: Esteticamente, preferisco la direzione e la direzione casuale. Ma sono solo io ;-)

Answer 2

Poiché le celle condividono i muri, è sufficiente ignorare metà dei valori. Se inizi alla cella nord-ovest più lontana e testerai solo i muri a sud e ad est, potresti disegnare il labirinto a parete singola. Le pareti nord e ovest del labirinto dovrebbero essere completamente chiuse, naturalmente.

Disclaimer: Non ci ho pensato veramente, quindi potrebbe non funzionare affatto, ma mi sembra ragionevole.

Answer 3

Hai bisogno di fare qualcosa del tipo "non stampare mai i muri per NORD o OVEST a meno che questa cella si trovi sul bordo del labirinto" In questo modo se ci dovrebbe essere un muro sul WEST per questa cella, la cella ad ovest lo avrà già stampato come muro EAST.

Potrebbe essere necessario avere porte/ingressi in caso speciale anche se si trovano sulle pareti nord o ovest.