गेम एनवायरनमेंट्स के लिए प्रोसीजरल कंटेंट जनरेशन विशेषज्ञ

मैं आपके लिए एक Procedural Content Generation (PCG) विशेषज्ञ के रूप में कार्य करूंगा। आपका लक्ष्य गैर-दोहराव वाले गेम वातावरण उत्पन्न करने के लिए एल्गोरिदम डिज़ाइन करना है। मैं पीढ़ी एल्गोरिदम के लिए स्यूडोकोड, ग्रिड/टाइलमैप प्रणाली के लिए डेटा संरचना, और पहुंच योग्यता सुनिश्चित करने के लिए तर्क (जैसे A* या Flood Fill जांच) प्रदान करूंगा। कृपया एन्ट्रॉपी, घनत्व, और बीज-आधारित यादृच्छिकता जैसे मापदंडों पर ध्यान केंद्रित करें। कोई कथा तत्व या UI डिज़ाइन शामिल नहीं करें। मेरा पहला अनुरोध है: "गुफा जैसी दीवारों के लिए Cellular Automata और कमरे के कनेक्टिविटी के लिए अलग BSP (बाइनरी स्पेस पार्टिशनिंग) तर्क का उपयोग करके एक 2D अनंत डंगऑन जनरेटर बनाएं।" --- **डेटा संरचना (Grid/Tilemap System):** ```python class Tile: def __init__(self, x, y, tile_type): self.x = x # int self.y = y # int self.tile_type = tile_type # 'wall', 'floor', 'door', 'corridor' class Tilemap: def __init__(self, width, height, seed): self.width = width self.height = height self.seed = seed self.grid = [[Tile(x, y, 'wall') for y in range(height)] for x in range(width)] self.rooms = [] # List of Room objects self.corridors = [] # List of Corridor objects def get_tile(self, x, y): if 0 <= x < self.width and 0 <= y < self.height: return self.grid[x][y] return None # Out of bounds def set_tile(self, x, y, tile_type): if 0 <= x < self.width and 0 <= y < self.height: self.grid[x][y].tile_type = tile_type ``` --- **Cellular Automata (गुफा जैसी दीवारें) - स्यूडोकोड:** ```python def generate_cave_layer(tilemap, density=0.45, iterations=5): # बीज-आधारित यादृच्छिकता rng = random.Random(tilemap.seed) # प्रारंभिक यादृच्छिक भरण for x in range(tilemap.width): for y in range(tilemap.height): if rng.random() < density: tilemap.set_tile(x, y, 'wall') else: tilemap.set_tile(x, y, 'floor') # Cellular Automata नियम (B678/S345678 - क्लासिक गुफा नियम) for _ in range(iterations): new_grid = [[tilemap.grid[x][y].tile_type for y in range(tilemap.height)] for x in range(tilemap.width)] for x in range(tilemap.width): for y in range(tilemap.height): wall_count = count_adjacent_walls(tilemap, x, y, radius=1) if new_grid[x][y] == 'wall': if wall_count < 4: new_grid[x][y] = 'floor' else: if wall_count >= 5: new_grid[x][y] = 'wall' # ग्रिड अपडेट करें for x in range(tilemap.width): for y in range(tilemap.height): tilemap.set_tile(x, y, new_grid[x][y]) # एन्ट्रॉपी नियंत्रण: छोटे द्वीपों को हटाएं (वैकल्पिक) remove_small_islands(tilemap, min_size=20) def count_adjacent_walls(tilemap, x, y, radius=1): count = 0 for dx in range(-radius, radius+1): for dy in range(-radius, radius+1): if dx == 0 and dy == 0: continue nx, ny = x + dx, y + dy tile = tilemap.get_tile(nx, ny) if tile and tile.tile_type == 'wall': count += 1 elif not tile: # सीमा से बाहर - दीवार मानें count += 1 return count def remove_small_islands(tilemap, min_size): # Flood Fill का उपयोग करके छोटे फ्लोर क्षेत्रों को हटाएं visited = set() for x in range(tilemap.width): for y in range(tilemap.height): if (x, y) not in visited and tilemap.get_tile(x, y).tile_type == 'floor': region = flood_fill(tilemap, x, y, 'floor') if len(region) < min_size: for (rx, ry) in region: tilemap.set_tile(rx, ry, 'wall') visited.update(region) ``` --- **BSP (कमरे और कनेक्टिविटी) - स्यूडोकोड:** ```python class Room: def __init__(self, x, y, width, height): self.x = x self.y = y self.width = width self.height = height self.center = (x + width // 2, y + height // 2) class BSPNode: def __init__(self, x, y, width, height): self.x = x self.y = y self.width = width self.height = height self.left = None self.right = None self.room = None def generate_bsp_rooms(tilemap, min_room_size=6, max_leaf_size=20): # बीज-आधारित यादृच्छिकता rng = random.Random(tilemap.seed + 1000) def split_node(node, depth=0): if node.width < max_leaf_size * 2 and node.height < max_leaf_size * 2: # पत्ती नोड - कमरा बनाएं room_w = rng.randint(min_room_size, min(node.width - 2, max_leaf_size)) room_h = rng.randint(min_room_size, min(node.height - 2, max_leaf_size)) room_x = node.x + rng.randint(1, node.width - room_w - 1) room_y = node.y + rng.randint(1, node.height - room_h - 1) node.room = Room(room_x, room_y, room_w, room_h) return # विभाजन दिशा चुनें (लंबी धुरी पर) if node.width > node.height: split_vertical = True elif node.height > node.width: split_vertical = False else: split_vertical = rng.random() < 0.5 if split_vertical: split_pos = rng.randint(node.x + max_leaf_size, node.x + node.width - max_leaf_size) node.left = BSPNode(node.x, node.y, split_pos - node.x, node.height) node.right = BSPNode(split_pos, node.y, node.x + node.width - split_pos, node.height) else: split_pos = rng.randint(node.y + max_leaf_size, node.y + node.height - max_leaf_size) node.left = BSPNode(node.x, node.y, node.width, split_pos - node.y) node.right = BSPNode(node.x, split_pos, node.width, node.y + node.height - split_pos) split_node(node.left, depth+1) split_node(node.right, depth+1) root = BSPNode(0, 0, tilemap.width, tilemap.height) split_node(root) # कमरों को टाइलमैप पर लागू करें def collect_rooms(node, room_list): if node.room: room_list.append(node.room) for x in range(node.room.x, node.room.x + node.room.width): for y in range(node.room.y, node.room.y + node.room.height): tilemap.set_tile(x, y, 'floor') else: if node.left: collect_rooms(node.left, room_list) if node.right: collect_rooms(node.right, room_list) room_list = [] collect_rooms(root, room_list) tilemap.rooms = room_list # कमरों के बीच कॉरिडोर बनाएं (BSP पेड़ के माध्यम से) def connect_rooms(node): if node.room: return node.room.center if node.left and node.right: left_center = connect_rooms(node.left) right_center = connect_rooms(node.right) create_corridor(tilemap, left_center, right_center) return left_center # या कोई भी केंद्र return None connect_rooms(root) ``` --- **कॉरिडोर निर्माण और पहुंच योग्यता (Reachability):** ```python def create_corridor(tilemap, start, end): # L-आकार का कॉरिडोर (सरल और प्रभावी) x1, y1 = start x2, y2 = end # क्षैतिज पहले, फिर लंबवत if rng.random() < 0.5: for x in range(min(x1, x2), max(x1, x2) + 1): tilemap.set_tile(x, y1, 'floor') for y in range(min(y1, y2), max(y1, y2) + 1): tilemap.set_tile(x2, y, 'floor') else: for y in range(min(y1, y2), max(y1, y2) + 1): tilemap.set_tile(x1, y, 'floor') for x in range(min(x1, x2), max(x1, x2) + 1): tilemap.set_tile(x, y2, 'floor') # कॉरिडोर को सूची में जोड़ें (वैकल्पिक) tilemap.corridors.append((start, end)) def flood_fill(tilemap, start_x, start_y, target_type): # Flood Fill जांच - पहुंच योग्यता सुनिश्चित करने के लिए stack = [(start_x, start_y)] visited = set() while stack: x, y = stack.pop() if (x, y) in visited: continue tile = tilemap.get_tile(x, y) if not tile or tile.tile_type != target_type: continue visited.add((x, y)) stack.append((x+1, y)) stack.append((x-1, y)) stack.append((x, y+1)) stack.append((x, y-1)) return visited def ensure_reachability(tilemap): # सभी फ्लोर टाइल्स एक ही क्षेत्र में हैं या नहीं जांचें all_floor = [] for x in range(tilemap.width): for y in range(tilemap.height): if tilemap.get_tile(x, y).tile_type == 'floor': all_floor.append((x, y)) if not all_floor: return False start = all_floor[0] reachable = flood_fill(tilemap, start[0], start[1], 'floor') return len(reachable) == len(all_floor) ``` --- **मुख्य जनरेटर (अनंत के लिए चंक-आधारित):** ```python def generate_infinite_dungeon(seed, chunk_size=64): # अनंत डंगऑन के लिए चंक-आधारित दृष्टिकोण # प्रत्येक चंक एक अलग बीज के साथ उत्पन्न होता है chunk_cache = {} def get_chunk(cx, cy): if (cx, cy) not in chunk_cache: chunk_seed = hash((seed, cx, cy)) % (2**32) tilemap = Tilemap(chunk_size, chunk_size, chunk_seed) # पहले Cellular Automata से गुफा परत बनाएं generate_cave_layer(tilemap, density=0.45, iterations=5) # फिर BSP से कमरे और कॉरिडोर जोड़ें generate_bsp_rooms(tilemap) # पहुंच योग्यता जांचें और ठीक करें if not ensure_reachability(tilemap): # यदि अलग-अलग क्षेत्र हैं, तो उन्हें कॉरिडोर से जोड़ें connect_disconnected_regions(tilemap) chunk_cache[(cx, cy)] = tilemap return chunk_cache[(cx, cy)] return get_chunk def connect_disconnected_regions(tilemap): # Flood Fill से सभी क्षेत्रों को खोजें regions = [] visited = set() for x in range(tilemap.width): for y in range(tilemap.height): if (x, y) not in visited and tilemap.get_tile(x, y).tile_type == 'floor': region = flood_fill(tilemap, x, y, 'floor') regions.append(region) visited.update(region) # क्षेत्रों को क्रम से जोड़ें for i in range(len(regions) - 1): region_a = list(regions[i]) region_b = list(regions[i+1]) # निकटतम बिंदु खोजें और कॉरिडोर बनाएं min_dist = float('inf') best_pair = None for (ax, ay) in region_a: for (bx, by) in region_b: dist = abs(ax - bx) + abs(ay - by) if dist < min_dist: min_dist = dist best_pair = ((ax, ay), (bx, by)) if best_pair: create_corridor(tilemap, best_pair[0], best_pair[1]) ``` --- **मापदंड सारांश:** - **एन्ट्रॉपी (Entropy):** Cellular Automata में `density` पैरामीटर (0.45) गुफा की जटिलता को नियंत्रित करता है। उच्च घनत्व = अधिक दीवारें, कम खुली जगह। - **घनत्व (Density):** BSP में `min_room_size` और `max_leaf_size` कमरे के आकार और संख्या को नियंत्रित करते हैं। - **बीज-आधारित यादृच्छिकता (Seed-based Randomness):** हर चंक के लिए अलग बीज (`chunk_seed`) सुनिश्चित करता है कि एक ही विश्व में कोई दोहराव न हो, लेकिन एक ही बीज से समान परिणाम मिले। यह डिज़ाइन अनंत डंगऑन के लिए चंक-आधारित है, जहां प्रत्येक चंक स्वतंत्र रूप से उत्पन्न होता है और पहुंच योग्यता सुनिश्चित की जाती है।