Incorporare la generazione casuale del labirinto nel mio gioco (Java)

Question

Attualmente sto realizzando un gioco di risoluzione di labirinti in Java e attualmente sto incontrando un problema. Tutti gli algoritmi casuali di generazione del labirinto che ho potuto trovare in un modo che non riuscivo a capire come implementare nel mio codice corrente. Stavo considerando l'utilizzo di Depth First Search, Recursive Backtracker o Prim's Algorithm, poiché pensavo che sarebbero stati i più facili da implementare pur generando buoni labirinti. Quale sarebbe un uso funzionante di uno di quegli algoritmi che funziona con il mio programma attuale? Questa è la mia classe di gioco: (Sentitevi liberi di segnalare eventuali cattive pratiche così, io sono abbastanza nuovo a Java)

package game; 

import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 

public class Game extends JPanel implements ActionListener, KeyListener { 

    private boolean upPressed = false; 
    private boolean downPressed = false; 
    private boolean rightPressed = false; 
    private boolean leftPressed = false; 

    private final int playerDiam = 100; 
    private final int playerSpeed = 15; 
    private final int tileSize = 400; 

    private int[][] maze = {{1, 1, 1, 1, 1, 1}, 
          {1, 2, 1, 1, 3, 1}, 
          {1, 0, 1, 0, 0, 1}, 
          {1, 0, 1, 0, 1, 1}, 
          {1, 0, 0, 0, 1, 1}, 
          {1, 1, 1, 1, 1, 1}, 
          }; 
    private int[][] initX = new int[maze.length][maze.length]; 
    private int[][] initY = new int[maze.length][maze.length]; 

    private int deltaX = -210; 
    private int deltaY = -210; 

    private String screen = "menu"; 


    public Game() { 
     setFocusable(true); 
     addKeyListener(this); 
     setUpInitialCoordinates(); 
     Timer timer = new Timer(1000/60, this); 
     timer.start(); 
    } 

    @Override 
    public void actionPerformed(ActionEvent e) { 
     tick(); 
    } 

    private void setUpInitialCoordinates() { 
     int x = 0; 
     int y; 
     for (int[] rowData : maze) { 
      y = 0; 
      for (int ignored : rowData) { 
       initX[x][y] = x * tileSize; 
       initY[x][y] = y * tileSize; 
       y++; 
      } 
      x++; 
     } 
    } 

    private void generateMaze() { 
    } 

    private void tick() { 
     if (screen.equals("playing")) { 
      if (upPressed) { 
       deltaY += playerSpeed; 
      } else if (downPressed) { 
       deltaY -= playerSpeed; 
      } 
      if (rightPressed) { 
       deltaX -= playerSpeed; 
      } else if (leftPressed) { 
       deltaX += playerSpeed; 
      } 
     } 
     repaint(); 
    } 

    @Override 
    public void keyTyped(KeyEvent e) {} 

    @Override 
    public void keyPressed(KeyEvent e) { 
     if (e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_W) { 
      upPressed = true; 
     } else if (e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_S) { 
      downPressed = true; 
     } else if (e.getKeyCode() == KeyEvent.VK_RIGHT || e.getKeyCode() == KeyEvent.VK_D) { 
      rightPressed = true; 
     } else if (e.getKeyCode() == KeyEvent.VK_LEFT || e.getKeyCode() == KeyEvent.VK_A) { 
      leftPressed = true; 
     } 
    } 


    @Override 
    public void keyReleased(KeyEvent e) { 
     if (screen.equals("menu") && e.getKeyCode() == KeyEvent.VK_ENTER) { 
      upPressed = false; 
      downPressed = false; 
      rightPressed = false; 
      leftPressed = false; 
      screen = "playing"; 
     } else if (screen.equals("playing")) { 
      if (e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_W) { 
       upPressed = false; 
      } else if (e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_S) { 
       downPressed = false; 
      } else if (e.getKeyCode() == KeyEvent.VK_RIGHT || e.getKeyCode() == KeyEvent.VK_D) { 
       rightPressed = false; 
      } else if (e.getKeyCode() == KeyEvent.VK_LEFT || e.getKeyCode() == KeyEvent.VK_A) { 
       leftPressed = false; 
      } else if (e.getKeyCode() == KeyEvent.VK_P) { 
       screen = "paused"; 
      } 
     } else if (screen.equals("paused") && e.getKeyCode() ==  KeyEvent.VK_P) { 
      upPressed = false; 
      downPressed = false; 
      rightPressed = false; 
      leftPressed = false; 
      screen = "playing"; 
     } 
    } 

    @Override 
    public void paintComponent(Graphics g) { 
     super.paintComponent(g); 
     g.setFont(new Font("Aharoni", Font.PLAIN, 36)); 
     g.setColor(Color.WHITE); 
     g.fillRect(0, 0, getWidth(), getHeight()); 
     switch (screen) { 
      case "menu": 
       g.setColor(Color.BLACK); 
       g.drawString("Labyrinth", 300, 200); 
       g.drawString("Press Enter to Play!", getWidth()/3, 500); 
       break; 
      case "playing": 
       int x = 0; 
       int y = 0; 

       for (int[] rowData : maze) { 
        for (int cellData : rowData) { 
         if (cellData == 1) { 
          g.setColor(Color.DARK_GRAY); 
          g.fillRect(x + deltaX, y + deltaY, tileSize, tileSize); 
         } else if (cellData == 2) { 
          g.setColor(Color.GREEN); 
          g.fillRect(x + deltaX, y + deltaY, tileSize, tileSize); 
         } else if (cellData == 3) { 
          g.setColor(Color.YELLOW); 
          g.fillRect(x + deltaX, y + deltaY, tileSize, tileSize); 
         } 
         x += tileSize; 
         if (x == maze.length * tileSize) { 
          x = 0; 
          y += tileSize; 
         } 
        } 
       } g.setColor(Color.RED); 
       g.fillOval(getWidth()/2, getHeight()/2, playerDiam, playerDiam); 
       break; 
      case "gameOver": 
       g.setColor(Color.BLACK); 
       g.drawString("Game Over",getWidth()/3 ,50); 
       break; 
      case "paused": 
       g.setColor(Color.BLACK); 
       g.drawString("Paused", getWidth()/3, 50); 
       break; 
     } 
    } 
} 

Answer 1

come inizio mi farebbe

1. labirinto chiaro
2. casualmente aggiungo muri

3. creare percorso casuale per punti coppie presenti

   • chiaro il labirinto c tutto ingresso/uscita ells lungo loro.

Se avete solo bisogno labirinto risolutore (alcuni algos per la generazione di labirinto ha bisogno di loro)

• poi guarda qui How to speed up A* algorithm at large spatial scales?

con l'utilizzo di risolutore è possibile modificare l'algoritmo a

1. labirinto chiaro

2. aggiungere parete casuale

   • se l'aggiunta fornisce ancora una soluzione

3. ciclo proiettile (2) n volte

È necessario essere attenti a come aggiungere il muri

• per esame pio se si aggiungono le linee solo semplici poi il labirinto sarà simile a questo:
• 

Questo è il codice per esso (utilizza la classe dalla risposta collegata)

// generate random maze with path from x0,y0 to x1,y1 present, n walls 
void A_star::generate(int x0,int y0,int x1,int y1,int n) 
    { 
    int x,y,i,j,dx,dy,l,*p; 
    // [clear map] 
    for (y=0;y<ys;y++) 
    for (x=0;x<xs;x++) 
     map[y][x]=A_star_space; 
    // temp space 
    p=new int [xs>>1]; if (p==NULL) return; 
    // generate n walls 
    for (i=0;i<n;i++) 
     { 
     // random start pos,dir,length 
     x =Random(xs); 
     y =Random(ys); 
     dx=Random(4); 
     l =Random(xs>>2)+2; 
      if (dx==0) { dx=+1; dy= 0; } 
     else if (dx==1) { dx=-1; dy= 0; } 
     else if (dx==2) { dx= 0; dy=+1; } 
     else if (dx==3) { dx= 0; dy=-1; } 
     // add wall to maze remember set cells (for remowal if needed) 
     for (j=0;l;l--,x+=dx,y+=dy) 
     if ((x>=0)&&(x<xs)) 
      if ((y>=0)&&(y<ys)) 
      if (map[y][x]!=A_star_wall) 
      { 
      p[j]=x; j++; 
      p[j]=y; j++; 
      map[y][x]=A_star_wall; 
      } 
     // is there solution? 
     compute(x0,y0,x1,y1); 
     // if not remowe last added wall 
     if (ps==0) for (;j;) 
      { 
      j--; y=p[j]; 
      j--; x=p[j]; 
      map[y][x]=A_star_space; 
      } 
     } 
    delete[] p; 
    } 

generato da questo codice :

A_star map; 
map.resize(256,256); 
map.generate(5,5,250,250,500);