To achieve this, we'll create a simple Java program with a few classes representing the different components of the dungeon:

1. `Dungeon`: Represents the overall dungeon.
2. `Room`: Represents a room in the dungeon.
3. `Wall`: Represents a wall in the dungeon.
4. `Door`: Represents a door between two rooms.

First, let's create the `Wall`, `Door`, and `Room` classes:

```java
class Wall {
    int x1, y1, x2, y2;

    Wall(int x1, int y1, int x2, int y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }
}

class Door {
    int x, y;

    Door(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

class Room {
    int x, y, width, height;
    ArrayList<Door> doors;

    Room(int x, int y, int width, int height) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
        doors = new ArrayList<>();
    }

    void addDoor(Door door) {
        doors.add(door);
    }

    boolean overlaps(Room other) {
        return !(this.x + this.width <= other.x || other.x + other.width <= this.x ||
                 this.y + this.height <= other.y || other.y + other.height <= this.y);
    }
}

```


Now, let's create the `Dungeon` class that will handle generating the dungeon map:

```java
import java.util.ArrayList;
import java.util.Random;

class Dungeon {
    ArrayList<Room> rooms;
    ArrayList<Wall> walls;
    int maxAttempts;
    Random random;

    Dungeon(int maxAttempts) {
        rooms = new ArrayList<>();
        walls = new ArrayList<>();
        this.maxAttempts = maxAttempts;
        random = new Random();
    }

    void addWall(Wall wall) {
        walls.add(wall);
    }

    boolean generateMap() {
        while (!walls.isEmpty()) {
            int wallIndex = random.nextInt(walls.size());
            Wall selectedWall = walls.remove(wallIndex);

            int doorX = random.nextInt(selectedWall.x2 - selectedWall.x1) + selectedWall.x1;
            int doorY = random.nextInt(selectedWall.y2 - selectedWall.y1) + selectedWall.y1;
            Door wallDoor = new Door(doorX, doorY);

            int roomWidth = random.nextInt(10) + 5;
            int roomHeight = random.nextInt(10) + 5;
            Room newRoom = new Room(doorX - roomWidth / 2, doorY - roomHeight / 2, roomWidth, roomHeight);
            newRoom.addDoor(wallDoor);

            int attempts = 0;
            while (overlapsExistingRooms(newRoom) && attempts < maxAttempts) {
                newRoom.x = newRoom.x + random.nextInt(3) - 1;
                newRoom.y = newRoom.y + random.nextInt(3) - 1;
                attempts++;
            }

            if (attempts < maxAttempts) {
                rooms.add(newRoom);
            } else {
                return false;
            }
        }
        return true;
    }

    private boolean overlapsExistingRooms(Room newRoom) {
        for (Room existingRoom : rooms) {
            if (existingRoom.overlaps(newRoom)) {
                return true;
            }
        }
        return false;
    }
}
```

Finally, you can create a `Main` class to test the dungeon generation algorithm by adding walls, setting the maximum number of attempts to place a room, and generating the dungeon map:

```java
public class Main {
    public static void main(String[] args) {
        Dungeon dungeon = new Dungeon(100); // Set maxAttempts to 100

        // Add walls to the dungeon
        dungeon.addWall(new Wall(0, 0, 50, 0));
        dungeon.addWall(new Wall(50, 0, 50, 50));
        dungeon.addWall(new Wall(50, 50, 0, 50));
        dungeon.addWall(new Wall(0, 50, 0, 0));

        // Generate the dungeon map
        if (dungeon.generateMap()) {
            System.out.println("Dungeon generation successful!");
            System.out.println("Number of rooms: " + dungeon.rooms.size());

            // Print the rooms and doors
            for (int i = 0; i < dungeon.rooms.size(); i++) {
                Room room = dungeon.rooms.get(i);
                System.out.println("Room " + (i + 1) + ": x=" + room.x + ", y=" + room.y + ", width=" + room.width + ", height=" + room.height);
                System.out.println("Doors:");
                for (Door door : room.doors) {
                    System.out.println("  x=" + door.x + ", y=" + door.y);
                }
            }
        } else {
            System.out.println("Dungeon generation failed!");
        }
    }
}

```


This `Main` class creates a `Dungeon` object, adds the boundary walls, generates the dungeon map, and prints the rooms and doors if the generation is successful. Note that this implementation only prints the dungeon map to the console. You could create a graphical representation of the dungeon using a library like JavaFX or AWT if desired.
เพื่อให้บรรลุเป้าหมายนี้ เราจะสร้างโปรแกรม Java ง่ายๆ โดยมีคลาสสองสามคลาสที่แสดงถึงส่วนประกอบต่างๆ ของดันเจี้ยน: 1. `ดันเจี้ยน`: แสดงถึงดันเจี้ยนโดยรวม 2. `ห้อง`: หมายถึงห้องในดันเจี้ยน 3. `กำแพง`: หมายถึงกำแพงในดันเจี้ยน 4. `ประตู`: หมายถึงประตูระหว่างสองห้อง ขั้นแรก เรามาสร้างคลาส `Wall`, `Door` และ `Room`: ```java class Wall { int x1, y1, x2, y2; ผนัง(int x1, int y1, int x2, int y2) { this.x1 = x1; นี่.y1 = y1; นี่.x2 = x2; นี่.y2 = y2; } } ประตูคลาส { int x, y; ประตู(int x, int y) { this.x = x; นี่.y = y; } } ห้องคลาส { int x, y, ความกว้าง, ความสูง; ArrayList<ประตู> ประตู; ห้อง (int x, int y, ความกว้าง int, ความสูง int) { this.x = x; นี่.y = y; this.width = ความกว้าง; this.height = ความสูง; ประตู = ArrayList ใหม่ <>(); } addDoor เป็นโมฆะ (ประตูประตู) { door.add (ประตู); } บูลีนทับซ้อนกัน (ห้องอื่น) { return !(this.x + this.width <= other.x || other.x + other.width <= this.x || this.y + this.height <= other y || other.y + other.height <= this.y); } } ``` ตอนนี้เรามาสร้างคลาส `Dungeon` ที่จะจัดการการสร้างแผนที่ดันเจี้ยน: ```java import java.util.ArrayList; นำเข้า java.util.สุ่ม; คลาสดันเจี้ยน { ArrayList<ห้อง> ห้อง; ผนัง ArrayList<Wall>; int maxAttempts; สุ่มสุ่ม; ดันเจี้ยน (int maxAttempts) { ห้อง = ใหม่ ArrayList <> (); ผนัง = ArrayList ใหม่ <>(); this.maxAttempts = maxAttempts; สุ่ม = สุ่มใหม่ (); } addWall เป็นโมฆะ (ผนังผนัง) { ผนังเพิ่ม (ผนัง); } บูลีน GenerateMap() { ในขณะที่ (!walls.isEmpty()) { int wallIndex = Random.nextInt(walls.size()); ผนังที่เลือก Wall = ผนัง.remove(wallIndex); int doorX = Random.nextInt(selectedWall.x2 - SelectedWall.x1) + SelectedWall.x1; int doorY = Random.nextInt(selectedWall.y2 - SelectedWall.y1) + SelectedWall.y1; ผนังประตูประตู = ประตูใหม่ (ประตู X, ประตู Y); int roomWidth = สุ่ม.nextInt(10) + 5; int roomHeight = Random.nextInt (10) + 5; ห้องใหม่ห้อง = ห้องใหม่ (doorX - roomWidth / 2, doorY - roomHeight / 2, roomWidth, roomHeight); newRoom.addDoor (ประตูผนัง); ความพยายาม int = 0; ในขณะที่ (overlapsExistingRooms (ห้องใหม่) && พยายาม < maxAttempts) { newRoom.x = newRoom.x + Random.nextInt (3) - 1; newRoom.y = newRoom.y + Random.nextInt(3) - 1; ความพยายาม++; } ถ้า (พยายาม < maxAttempts) { rooms.add(newRoom); } อื่น { กลับเท็จ; } } กลับเป็นจริง; } } ทับซ้อนบูลีนส่วนตัว ExistingRooms (ห้องใหม่ห้อง) { สำหรับ (ห้องที่มีอยู่ห้อง : ห้อง) { ถ้า (existingRoom.overlaps (ห้องใหม่)) { กลับจริง; } } กลับเท็จ; } } ``` สุดท้ายนี้ คุณสามารถสร้างคลาส `Main` เพื่อทดสอบอัลกอริธึมการสร้างดันเจี้ยนโดยการเพิ่มกำแพง กำหนดจำนวนครั้งสูงสุดในการวางห้อง และสร้างแผนที่ดันเจี้ยน: ```java public class Main { โมฆะคงที่สาธารณะ main (String [] args) { ดันเจี้ยนดันเจี้ยน = ดันเจี้ยนใหม่ (100); // ตั้งค่า maxAttempts เป็น 100 // เพิ่มกำแพงในดันเจี้ยน dungeon.addWall(กำแพงใหม่ (0, 0, 50, 0)); dungeon.addWall(กำแพงใหม่ (50, 0, 50, 50)); dungeon.addWall(กำแพงใหม่ (50, 50, 0, 50)); dungeon.addWall(กำแพงใหม่ (0, 50, 0, 0)); // สร้างแผนที่ดันเจี้ยนถ้า (dungeon.generateMap()) { System.out.println("การสร้างดันเจี้ยนสำเร็จ!"); System.out.println("จำนวนห้อง: " + dungeon.rooms.size()); // พิมพ์ห้องและประตูสำหรับ (int i = 0; i < dungeon.rooms.size(); i++) { Room room = dungeon.rooms.get(i); System.out.println("ห้อง " + (i + 1) + ": x=" + room.x + ", y=" + room.y + ", width=" + room.width + ", height= " + ห้องความสูง); System.out.println("ประตู:"); สำหรับ (ประตูประตู : room.doors) { System.out.println(" x=" + door.x + ", y=" + door.y); } } } else { System.out.println("การสร้างดันเจี้ยนล้มเหลว!"); } } } ``` คลาส `หลัก` นี้สร้างวัตถุ `ดันเจี้ยน` เพิ่มกำแพงขอบเขต สร้างแผนที่ดันเจี้ยน และพิมพ์ห้องและประตูหากการสร้างสำเร็จ โปรดทราบว่าการใช้งานนี้จะพิมพ์แผนที่ดันเจี้ยนไปยังคอนโซลเท่านั้น คุณสามารถสร้างการแสดงกราฟิกของดันเจี้ยนโดยใช้ไลบรารีเช่น JavaFX หรือ AWT ได้หากต้องการ
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence