Generera en unik labyrint och försök hitta in till mitten!

Maze Generation/GridApp.java

+package grid;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+public class GridApp extends JFrame {
+	
+	
+	
+	public static void main(String[] args) {
+
+
+		// Skapa ett JFrame-fönster
+		JFrame frame = new JFrame("MazeRunner");
+		frame.setIconImage(null);
+		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		frame.setSize(700, 700);
+		frame.setUndecorated(true);
+		frame.setResizable(false);
+		frame.setLocationRelativeTo(null);
+		
+		
+		Runner runner = new Runner();
+		frame.add(runner);
+
+		
+		frame.setVisible(true);
+
+	}
+}

Maze Generation/MazeGenerator.java

+package grid;
+
+import java.util.Random;
+
+public class MazeGenerator {
+    private int width, height;
+    public int[][] maze;
+    private Random random;
+    
+    // Directions for moving in the maze
+    private static final int[][] DIRECTIONS = {
+        {0, 2}, {2, 0}, {0, -2}, {-2, 0} // Right, Down, Left, Up
+    };
+
+    public MazeGenerator(int width, int height) {
+        this.width = width;
+        this.height = height;
+        this.maze = new int[height][width];
+        this.random = new Random();
+
+        generateMaze(1, 1); // Start generating from (1, 1)
+    }
+
+    public void generateMaze(int x, int y) {
+       
+        maze[y][x] = 1;
+        
+
+        // Randomly shuffle directions
+        for (int i = 0; i < DIRECTIONS.length; i++) {
+            int j = random.nextInt(DIRECTIONS.length);
+            int[] temp = DIRECTIONS[i];
+            DIRECTIONS[i] = DIRECTIONS[j];
+            DIRECTIONS[j] = temp;
+        }
+
+        for (int[] direction : DIRECTIONS) {
+            int newX = x + direction[0];
+            int newY = y + direction[1];
+
+            // Check if the new cell is within bounds and not visited
+            if (newX > 0 && newX < width && newY > 0 && newY < height && maze[newY][newX] == 0) {
+                maze[y + direction[1] / 2][x + direction[0] / 2] = 1; // Remove wall
+                generateMaze(newX, newY); // Recursively generate maze from the new cell
+            }
+        }
+    }
+    
+    
+    
+    
+    
+
+  /*  public void printMaze() {
+        for (int[] row : maze) {
+            for (int cell : row) {
+                System.out.print(cell == 1 ? " " : "#"); // Print space for path and # for walls
+                
+            }
+            System.out.println();
+        }
+    }
+
+    public static void main(String[] args) {
+        
+    	
+    	
+        MazeGenerator mazeGenerator = new MazeGenerator(21, 21);
+        mazeGenerator.printMaze();
+    }*/
+}
\ No newline at end of file

Maze Generation/Runner.java

+package grid;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.util.Random;
+
+import javax.swing.JPanel;
+import javax.swing.Timer;
+import java.util.concurrent.ThreadLocalRandom;
+
+
+
+public class Runner extends JPanel implements ActionListener, KeyListener{
+	
+	private Timer timer;
+	private Color c = Color.DARK_GRAY;
+	
+	int rader = 71;
+	int kolumner = rader;
+	
+	int grid_x;
+	int grid_y;
+	int size = 10;
+	
+	int x = 0;
+	int y = 0;
+	
+	int[][] grid = new int[rader][kolumner];
+	int[][] man = new int[rader][kolumner];
+	
+	MazeGenerator maze = new MazeGenerator(rader, kolumner);
+
+	
+	public Runner() {
+		// Skapa en timer som triggar var 10:e millisekund (100 fps)
+        timer = new Timer(10, this);
+        timer.start();  // Starta timern
+        
+        // Lägg till KeyListener
+        setFocusable(true);
+        addKeyListener(this);
+        
+
+	}
+	
+	
+	
+	protected void paintComponent(Graphics g) {
+	     super.paintComponent(g);
+
+		
+		
+		for (int i = 0; i < rader; i++) {
+            for (int j = 0; j < kolumner; j++) {
+            	// Calculate x and y coordinates for each cell
+                grid_x = i * size;
+                grid_y = j * size;
+                
+            	
+                grid[i][j] = maze.maze[i][j];
+                
+                man[rader/2][kolumner/2] = 3;
+
+               if (grid[i][j] == 1) {
+            	   g.setColor(Color.gray);
+            	   g.fillRect(grid_x, grid_y, size, size);
+            	   g.setColor(c);
+               }
+               
+               if (man[i][j] == 2) {
+            	   g.setColor(Color.cyan);
+            	   g.fillRect(grid_x, grid_y, size, size);
+            	   g.setColor(c);
+
+               }
+               if (man[i][j] == 3) {
+            	   g.setColor(Color.magenta);
+            	   g.fillRect(grid_x, grid_y, size, size);
+            	   g.setColor(c);
+            	   
+
+               }
+               
+                
+               
+               g.drawRect(grid_x, grid_y, size, size);
+            }
+            
+		}
+		
+	}
+	
+	
+	
+	
+	
+	 // Detta anropas varje gång timern triggar en uppdatering
+    @Override
+    public void actionPerformed(ActionEvent e) {
+    	
+    	man[x][y] = 2;
+    	
+
+        // Be om att panelen ritas om
+        repaint();
+    }
+    
+    
+     
+    
+    //////////////////////////////////////////////////////
+    //                                                  //
+    //                 MAPPING INPUTS                   //
+    //                                                  //
+    //////////////////////////////////////////////////////
+    
+    @Override
+    public void keyPressed(KeyEvent e) {
+    	
+        switch (e.getKeyCode()) {
+        
+        case KeyEvent.VK_ESCAPE:
+        	System.exit(0);
+        	
+        	break;
+            case KeyEvent.VK_W:
+            	if(y > 0) {
+            		
+            		if (grid[x][y-1] == 0) {
+            			
+            			y -= 1;
+            			man[x][y+1] = 3;
+            			
+            		}
+            	}
+                 // Flytta uppåt
+                break;
+            case KeyEvent.VK_S:
+            	if(y < kolumner -1) {
+            		
+            		if (grid[x][y+1] == 0) {
+            			
+            			y += 1;
+            			man[x][y-1] = 3;
+            		}
+            		
+            	}
+                 // Flytta nedåt
+                break;
+                
+                
+            case KeyEvent.VK_A:
+            	if(x >= 1) {
+            		
+            		
+            		if (grid[x-1][y] == 0) {
+            			
+            			x -= 1;
+            			man[x+1][y] = 3;
+            		}
+            		
+            		
+            		
+            	}
+            	// Flytta vänster
+            	break;
+            	
+            	
+            case KeyEvent.VK_D:
+            	if(x < rader - 1) {
+            		
+            		if (grid[x+1][y] == 0) {
+            			
+            			
+            			x += 1;
+            			man[x-1][y] = 3;
+
+            		}
+            	}
+            	
+            	 // Flytta höger
+            	break;
+            	
+            case KeyEvent.VK_R:
+            	
+
+            	
+            	for (int i = 0; i < rader ; i++) {
+            		for (int j = 0; j < kolumner ; j++) {
+            			man[i][j] = 0;
+            		}
+            	}
+
+            	
+            	x = ThreadLocalRandom.current().nextInt(rader/3, rader- rader/3);
+        		y = ThreadLocalRandom.current().nextInt(kolumner/3, kolumner-kolumner/3);
+            	
+        		while (grid[x][y] == 1) {
+        			x = ThreadLocalRandom.current().nextInt(rader/3, rader- rader/3);
+            		y = ThreadLocalRandom.current().nextInt(kolumner/3, kolumner-kolumner/3);
+        		}
+
+            	
+            	
+
+            	break;
+            	
+           
+            	
+        }
+    }
+
+
+    @Override
+    public void keyReleased(KeyEvent e) {
+        // Inget behov av att hantera detta i detta exempel
+    }
+
+    @Override
+    public void keyTyped(KeyEvent e) {
+        // Inget behov av att hantera detta i detta exempel
+    }
+
+}