Spaces:
Sleeping
Sleeping
| import random | |
| from flask_socketio import emit | |
| class Game: | |
| def __init__(self): | |
| self.map_size = 50 # Much larger dungeon | |
| self.visible_size = 10 # 10x10 visible area on screen | |
| self.door_pos = [48, 48] # Door to next level at far end - set before generating maze | |
| self.terrain = self.generate_maze() | |
| self.player_pos = [1, 1] # Start near top-left | |
| self.player_health = 10 | |
| self.player_attack = 2 | |
| self.inventory = [] | |
| self.monsters = self.generate_monsters() | |
| self.items = self.generate_items() | |
| self.level = 1 | |
| def generate_maze(self): | |
| # Simple recursive backtracking maze generation | |
| terrain = [['w' for _ in range(self.map_size)] for _ in range(self.map_size)] | |
| def carve(x, y): | |
| terrain[y][x] = 'f' | |
| directions = [(0, 2), (2, 0), (-2, 0), (0, -2)] # Right, Down, Left, Up (2 steps for corridors) | |
| random.shuffle(directions) | |
| for dx, dy in directions: | |
| nx, ny = x + dx, y + dy | |
| if (0 <= nx < self.map_size and 0 <= ny < self.map_size and | |
| terrain[ny][nx] == 'w'): | |
| mid_x, mid_y = x + dx // 2, y + dy // 2 | |
| terrain[mid_y][mid_x] = 'f' # Carve path | |
| carve(nx, ny) | |
| # Start carving from (1,1) to avoid edges | |
| carve(1, 1) | |
| # Ensure player start and door positions are accessible | |
| terrain[1][1] = 'f' | |
| if hasattr(self, 'door_pos'): # Safety check | |
| terrain[self.door_pos[1]][self.door_pos[0]] = 'd' # 'd' for door | |
| else: | |
| print("Warning: door_pos not set, using default [48, 48]") | |
| terrain[48][48] = 'd' # Fallback if door_pos is not set | |
| return terrain | |
| def generate_monsters(self): | |
| monsters = {} | |
| for _ in range(10): # 10 enemies (e.g., 5 goblins, 5 skeletons) | |
| while True: | |
| x, y = random.randint(2, self.map_size - 3), random.randint(2, self.map_size - 3) | |
| if self.terrain[y][x] == 'f' and (x, y) not in monsters and (x, y) != tuple(self.player_pos): | |
| monster_type = random.choice(['goblin', 'skeleton']) | |
| health = 5 if monster_type == 'goblin' else 6 | |
| attack = 1 if monster_type == 'goblin' else 2 | |
| monsters[(x, y)] = {'type': monster_type, 'health': health, 'attack': attack} | |
| break | |
| return monsters | |
| def generate_items(self): | |
| items = {} | |
| item_types = ['potion', 'sword'] | |
| for _ in range(5): # 5 items (e.g., 3 potions, 2 swords) | |
| while True: | |
| x, y = random.randint(2, self.map_size - 3), random.randint(2, self.map_size - 3) | |
| if self.terrain[y][x] == 'f' and (x, y) not in items and (x, y) not in self.monsters: | |
| items[(x, y)] = random.choice(item_types) | |
| break | |
| return items | |
| def get_visible_area(self): | |
| print("Generating visible area for player at:", self.player_pos) # Debug log | |
| px, py = self.player_pos | |
| half_size = self.visible_size // 2 | |
| start_x = max(0, px - half_size) | |
| start_y = max(0, py - half_size) | |
| end_x = min(self.map_size, px + half_size + 1) | |
| end_y = min(self.map_size, py + half_size + 1) | |
| visible_terrain = [['' for _ in range(self.visible_size)] for _ in range(self.visible_size)] | |
| visible_entities = [['' for _ in range(self.visible_size)] for _ in range(self.visible_size)] | |
| for y in range(start_y, end_y): | |
| for x in range(start_x, end_x): | |
| grid_y = y - (py - half_size) | |
| grid_x = x - (px - half_size) | |
| if 0 <= grid_y < self.visible_size and 0 <= grid_x < self.visible_size: | |
| visible_terrain[grid_y][grid_x] = self.terrain[y][x] if self.terrain[y][x] else 'f' # Default to 'f' | |
| if (x, y) == tuple(self.player_pos): | |
| visible_entities[grid_y][grid_x] = 'player' | |
| elif (x, y) in self.monsters: | |
| visible_entities[grid_y][grid_x] = self.monsters[(x, y)]['type'] | |
| elif (x, y) in self.items: | |
| visible_entities[grid_y][grid_x] = self.items[(x, y)] | |
| elif (x, y) == tuple(self.door_pos): | |
| visible_entities[grid_y][grid_x] = 'door' | |
| print("Visible terrain:", visible_terrain) # Debug log | |
| print("Visible entities:", visible_entities) # Debug log | |
| return {'terrain': visible_terrain, 'entities': visible_entities} | |
| def get_game_state(self): | |
| visible = self.get_visible_area() | |
| state = { | |
| 'terrain': visible['terrain'], | |
| 'entities': visible['entities'], | |
| 'health': self.player_health, | |
| 'inventory': self.inventory, | |
| 'attack': self.player_attack, | |
| 'level': self.level | |
| } | |
| print("Game state:", state) # Debug log | |
| return state | |
| def is_valid_position(self, x, y): | |
| return (0 <= x < self.map_size and 0 <= y < self.map_size and | |
| self.terrain[y][x] != 'w') | |
| def move_player(self, direction): | |
| dx, dy = {'up': (0, -1), 'down': (0, 1), 'left': (-1, 0), 'right': (1, 0)}[direction] | |
| new_x, new_y = self.player_pos[0] + dx, self.player_pos[1] + dy | |
| if self.is_valid_position(new_x, new_y): | |
| self.player_pos = [new_x, new_y] | |
| pos_tuple = tuple(self.player_pos) | |
| # Check for monster | |
| if pos_tuple in self.monsters: | |
| self.handle_combat(pos_tuple) | |
| # Check for item | |
| elif pos_tuple in self.items: | |
| item = self.items.pop(pos_tuple) | |
| self.inventory.append(item) | |
| if item == 'sword': | |
| self.player_attack += 1 | |
| emit('message', 'Picked up a sword! Attack increased.') | |
| else: | |
| emit('message', f'Picked up a {item}!') | |
| # Check for door | |
| elif pos_tuple == tuple(self.door_pos): | |
| self.level += 1 | |
| self.reset_level() | |
| emit('message', f'Entered Level {self.level}! New dungeon awaits.') | |
| def reset_level(self): | |
| self.door_pos = [48, 48] # Reset door position | |
| self.terrain = self.generate_maze() | |
| self.player_pos = [1, 1] | |
| self.player_health = 10 | |
| self.monsters = self.generate_monsters() | |
| self.items = self.generate_items() | |
| def handle_combat(self, pos): | |
| from flask_socketio import emit | |
| monster = self.monsters[pos] | |
| monster_health = monster['health'] | |
| while monster_health > 0 and self.player_health > 0: | |
| monster_health -= self.player_attack | |
| emit('message', f"You attack the {monster['type']} for {self.player_attack} damage.") | |
| if monster_health <= 0: | |
| emit('message', f"You defeated the {monster['type']}!") | |
| del self.monsters[pos] | |
| break | |
| self.player_health -= monster['attack'] | |
| emit('message', f"The {monster['type']} attacks you for {monster['attack']} damage.") | |
| if self.player_health <= 0: | |
| emit('message', 'Game over! You were defeated.') | |
| break |