AIGC 游戏：AIGC 领域的娱乐新体验

    import numpy as np
    
    class WFCGenerator:
    def __init__(self, size, patterns):
        self.size = size
        self.patterns = patterns
        self.grid = np.zeros((size, size), dtype=object)
        
    def propagate(self, x, y):
        # 约束传播算法
        neighbors = [(x-1,y), (x+1,y), (x,y-1), (x,y+1)]
        for nx, ny in neighbors:
            if 0 <= nx < self.size and 0 <= ny < self.size:
                possible = self.get_compatible(self.grid[x,y])
                self.grid[nx,ny] = np.intersect1d(self.grid[nx,ny], possible)
                
    def generate(self):
        for _ in range(self.size**2):
            min_entropy = self.find_min_entropy()
            if min_entropy is None: break
            x, y = min_entropy
            self.grid[x,y] = np.random.choice(self.grid[x,y])
            self.propagate(x, y)
        return self.grid
    
    # 示例使用
    patterns = ['corridor', 'room', 'stairs']
    generator = WFCGenerator(10, patterns)
    level = generator.generate()
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/3VFAYbNTn9pgEoHDfR875BLMwkUa.png)

    conda create -n aigc-game python=3.9
    conda install pytorch torchvision -c pytorch
    pip install pygame numpy matplotlib
    
    
    bash

    # dungeon_generator.py
    import pygame
    import numpy as np
    
    class DungeonGenerator:
    def __init__(self, width=50, height=50):
        self.width = width
        self.height = height
        self.grid = np.zeros((height, width))
        
    def generate_rooms(self, max_rooms=10):
        # Delaunay三角剖分实现房间分布
        rooms = []
        for _ in range(max_rooms):
            w = np.random.randint(5,12)
            h = np.random.randint(5,12)
            x = np.random.randint(0, self.width - w)
            y = np.random.randint(0, self.height - h)
            rooms.append((x, y, w, h))
        return rooms
    
    def connect_rooms(self, rooms):
        # A*算法路径连接
        for i in range(len(rooms)-1):
            start = (rooms[i][0]+rooms[i][2]//2, 
                    rooms[i][1]+rooms[i][3]//2)
            end = (rooms[i+1][0]+rooms[i+1][2]//2,
                  rooms[i+1][1]+rooms[i+1][3]//2)
            self._create_corridor(start, end)
            
    def _create_corridor(self, start, end):
        x1, y1 = start
        x2, y2 = end
        # Bresenham直线算法
        dx = abs(x2 - x1)
        dy = abs(y2 - y1)
        sx = 1 if x1 < x2 else -1
        sy = 1 if y1 < y2 else -1
        err = dx - dy
        
        while True:
            self.grid[y1][x1] = 1
            if x1 == x2 and y1 == y2:
                break
            e2 = 2*err
            if e2 > -dy:
                err -= dy
                x1 += sx
            if e2 < dx:
                err += dx
                y1 += sy
                
    def generate(self):
        rooms = self.generate_rooms()
        for x, y, w, h in rooms:
            self.grid[y:y+h, x:x+w] = 1
        self.connect_rooms(rooms)
        return self.grid
    
    # 可视化部分
    def draw_dungeon(surface, grid):
    cell_size = 10
    for y in range(grid.shape[0]):
        for x in range(grid.shape[1]):
            color = (255,255,255) if grid[y][x] else (0,0,0)
            pygame.draw.rect(surface, color, 
                           (x*cell_size, y*cell_size, 
                            cell_size-1, cell_size-1))
                            
    # 主程序
    if __name__ == "__main__":
    pygame.init()
    generator = DungeonGenerator()
    grid = generator.generate()
    
    screen = pygame.display.set_mode((500, 500))
    clock = pygame.time.Clock()
    
    running = True
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
                
        screen.fill((0,0,0))
        draw_dungeon(screen, grid)
        pygame.display.flip()
        clock.tick(30)
        
    pygame.quit()
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-16/cgwazmhYVE4ebn9xWiPMvp3SuBCU.png)