You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
353 lines
10 KiB
353 lines
10 KiB
import curses
|
|
import sys
|
|
import random
|
|
import numpy as np
|
|
|
|
WALL = '#'
|
|
SPACE = '.'
|
|
PATH_LIMIT = 1000
|
|
|
|
def compass(x, y, offset=1):
|
|
return [[x, y - offset], # North
|
|
[x, y + offset], # South
|
|
[x + offset, y], # East
|
|
[x - offset, y]] # West
|
|
|
|
class Player:
|
|
def __init__(self, x, y):
|
|
self.x = x
|
|
self.y = y
|
|
self.symbol = '@'
|
|
self.name = 'You'
|
|
self.hp = 10
|
|
self.damage = 2
|
|
|
|
class Enemy:
|
|
def __init__(self, x, y, symbol):
|
|
self.x = x
|
|
self.y = y
|
|
self.symbol = symbol
|
|
self.name = 'Python'
|
|
self.hp = 5
|
|
self.damage = 1
|
|
self.hearing_distance = 5
|
|
|
|
class Map:
|
|
def __init__(self, width, height):
|
|
self.width = width
|
|
self.height = height
|
|
grid = self.make_grid()
|
|
dead_ends = self.hunt_and_kill(grid)
|
|
grid = self.sample_rooms(grid, dead_ends, 4, int(len(dead_ends) * 0.6))
|
|
self.hunt_and_kill(grid)
|
|
self.render_map(grid)
|
|
|
|
def spawn(self):
|
|
while True:
|
|
y = random.randrange(0, self.height)
|
|
x = random.randrange(0, self.width)
|
|
if self.map[y][x] == SPACE:
|
|
return x, y
|
|
|
|
def sample_rooms(self, grid, dead_ends, size, count):
|
|
grid = self.make_grid()
|
|
for x, y in random.sample(dead_ends, count):
|
|
if x < self.width - size and y < self.height - size:
|
|
self.make_room(grid, x, y, size)
|
|
return grid
|
|
|
|
def make_grid(self):
|
|
return np.full((self.height, self.width), WALL, dtype=str)
|
|
|
|
def make_room(self, grid, x, y, size):
|
|
for row in range(y, y+size):
|
|
for col in range(x, x+size):
|
|
grid[row][col] = SPACE
|
|
|
|
def find_coord(self, grid):
|
|
for y in range(1, self.height, 2):
|
|
for x in range(1, self.width, 2):
|
|
if grid[y][x] != WALL: continue
|
|
|
|
found = self.neighbors(grid, x, y)
|
|
for found_x, found_y in found:
|
|
if grid[found_y][found_x] == SPACE:
|
|
return [[x,y],[found_x, found_y]]
|
|
return None
|
|
|
|
|
|
def inbounds(self, x, y):
|
|
return x >= 0 and x < self.width and y >= 0 and y < self.height
|
|
|
|
def neighbors(self, grid, x, y):
|
|
points = compass(x, y, 2)
|
|
|
|
result = []
|
|
for x,y in points:
|
|
if self.inbounds(x, y):
|
|
result.append([x,y])
|
|
return result
|
|
|
|
def neighbor_walls(self, grid, x, y):
|
|
neighbors = self.neighbors(grid, x, y)
|
|
result = []
|
|
for x,y in neighbors:
|
|
if grid[y][x] == WALL:
|
|
result.append([x,y])
|
|
return result
|
|
|
|
def hunt_and_kill(self, grid):
|
|
on_x = 1
|
|
on_y = 1
|
|
dead_ends = []
|
|
|
|
while True:
|
|
n = self.neighbor_walls(grid, on_x, on_y)
|
|
if len(n) == 0:
|
|
dead_ends.append([on_x, on_y])
|
|
t = self.find_coord(grid)
|
|
if t == None: break
|
|
on_x, on_y = t[0]
|
|
found_x, found_y = t[1]
|
|
grid[on_y][on_x] = SPACE
|
|
row = (on_y + found_y) // 2
|
|
col = (on_x + found_x) // 2
|
|
grid[row][col] = SPACE
|
|
else:
|
|
nb_x, nb_y = random.choice(n)
|
|
grid[nb_y][nb_x] = SPACE
|
|
row = (nb_y + on_y) // 2
|
|
col = (nb_x + on_x) // 2
|
|
grid[row][col] = SPACE
|
|
on_x, on_y = nb_x, nb_y
|
|
|
|
return dead_ends
|
|
|
|
|
|
def render_map(self, grid):
|
|
self.map = []
|
|
for y, y_line in enumerate(grid):
|
|
cur_row = ""
|
|
|
|
for x, char in enumerate(y_line):
|
|
cur_row += char
|
|
self.map.append(cur_row)
|
|
|
|
def collision(self, target_x, target_y):
|
|
# remember this is True==COLLIDE WITH WALL, False=CAN MOVE THERE
|
|
return self.map[target_y][target_x] == WALL
|
|
|
|
def draw(self, win):
|
|
for y, row in enumerate(self.map):
|
|
win.addstr(y, 0, "".join(row))
|
|
|
|
class UI:
|
|
def __init__(self, stdscr, height, width, status_height):
|
|
curses.curs_set(0)
|
|
stdscr.clear()
|
|
begin_x = 0
|
|
begin_y = 0
|
|
|
|
win = curses.newwin(height, width, begin_y, begin_x)
|
|
win.keypad(True)
|
|
status = win.subwin(status_height, width, height-status_height, begin_x)
|
|
|
|
# keep these for later by assigning to self
|
|
self.begin_x = 0
|
|
self.begin_y = 0
|
|
self.map = None
|
|
self.height = height
|
|
self.width = width
|
|
self.win = win
|
|
self.status = status
|
|
self.status_msg = "HAVE FUN!"
|
|
self.status_height = status_height
|
|
|
|
def set_map(self, the_map):
|
|
self.map = the_map
|
|
|
|
def update(self, actors):
|
|
assert self.map, "You forgot to call set_map()"
|
|
self.win.clear()
|
|
self.status.box()
|
|
self.map.draw(self.win)
|
|
# this assumes actors[0] is the player
|
|
self.draw_status(actors)
|
|
|
|
for actor in actors:
|
|
self.draw_actor(actor)
|
|
self.win.refresh()
|
|
|
|
def post_status(self, msg):
|
|
self.status_msg = msg
|
|
|
|
def draw_status(self, actors):
|
|
self.status.addstr(1, 1, self.status_msg)
|
|
|
|
def draw_actor(self, actor):
|
|
assert self.map.map[actor.y][actor.x] != WALL, f"WHAT? actor at {actor.x},{actor.y} but that's a wall!"
|
|
|
|
# actor has to be moved in by 1 for the border
|
|
self.win.addstr(actor.y, actor.x, actor.symbol, curses.A_BOLD)
|
|
|
|
def handle_input(self, x, y):
|
|
ch = self.win.getch()
|
|
|
|
if ch == ord('q'):
|
|
sys.exit(0)
|
|
elif ch == curses.KEY_UP:
|
|
y = (y - 1) % self.height
|
|
elif ch == curses.KEY_DOWN:
|
|
y = (y + 1) % self.height
|
|
elif ch == curses.KEY_RIGHT:
|
|
x = (x + 1) % self.width
|
|
elif ch == curses.KEY_LEFT:
|
|
x = (x - 1) % self.width
|
|
|
|
return x, y
|
|
|
|
class GameEngine:
|
|
def __init__(self, ui):
|
|
self.ui = ui
|
|
self.map = Map(ui.width, ui.height - ui.status_height)
|
|
self.ui = ui
|
|
ui.set_map(self.map)
|
|
|
|
def add_neighbors(self, neighbors, closed, near_y, near_x):
|
|
points = compass(near_x, near_y)
|
|
|
|
for x,y in points:
|
|
if self.map.inbounds(x,y) and closed[y][x] == SPACE:
|
|
closed[y][x] = WALL
|
|
neighbors.append([x,y])
|
|
|
|
def path_enemies(self, in_grid):
|
|
height = self.map.height
|
|
width = self.map.width
|
|
|
|
self.paths = [[PATH_LIMIT] * width for x in range(0, height)]
|
|
closed = [list(row) for row in self.map.map]
|
|
starting_pixels = []
|
|
open_pixels = []
|
|
|
|
counter = 0
|
|
while counter < height * width:
|
|
x = counter % width
|
|
y = counter // width
|
|
if in_grid[y][x] == 0:
|
|
self.paths[y][x] = 0
|
|
closed[y][x] = WALL
|
|
starting_pixels.append([x,y])
|
|
counter += 1
|
|
|
|
for x, y in starting_pixels:
|
|
self.add_neighbors(open_pixels, closed, y, x)
|
|
|
|
counter = 1
|
|
while counter < PATH_LIMIT and open_pixels:
|
|
next_open = []
|
|
for x,y in open_pixels:
|
|
self.paths[y][x] = counter
|
|
self.add_neighbors(next_open, closed, y, x)
|
|
open_pixels = next_open
|
|
counter += 1
|
|
|
|
for x, y in open_pixels:
|
|
self.paths[y][x] = counter
|
|
|
|
def debug_paths(self):
|
|
debug_map = []
|
|
|
|
for y in range(0, self.map.height):
|
|
row = list(self.map.map[y])
|
|
for x in range(0, self.map.width):
|
|
level = self.paths[y][x]
|
|
if row[x] != WALL:
|
|
if level < 10:
|
|
row[x] = str(level)
|
|
else:
|
|
row[x] = '*'
|
|
debug_map.append("".join(row))
|
|
return debug_map
|
|
|
|
def move_enemies(self):
|
|
in_grid = [[1] * self.map.width for x in range(0, self.map.height)]
|
|
in_grid[self.player.y][self.player.x] = 0
|
|
|
|
self.path_enemies(in_grid)
|
|
# for every enemy (actors[0] is player)
|
|
for enemy in self.actors[1:]:
|
|
nearby = compass(enemy.x, enemy.y)
|
|
our_path = self.paths[enemy.y][enemy.x]
|
|
|
|
if our_path > enemy.hearing_distance: continue
|
|
|
|
for x, y in nearby:
|
|
if self.paths[y][x] <= our_path and not self.actor_collision(enemy, x, y):
|
|
enemy.x = x
|
|
enemy.y = y
|
|
break
|
|
|
|
def death(self, target):
|
|
self.actors.remove(target)
|
|
self.ui.post_status(f"Killed {target.name}")
|
|
|
|
def combat(self, actor, target):
|
|
target.hp -= actor.damage
|
|
if target.hp > 0:
|
|
self.ui.post_status(f"HIT {target.name} for {actor.damage}")
|
|
else:
|
|
self.death(target)
|
|
|
|
def actor_collision(self, actor, x, y):
|
|
for target in self.actors:
|
|
if target != actor and target.x == x and target.y == y:
|
|
return target
|
|
return None
|
|
|
|
def collision(self, actor, x, y):
|
|
if self.map.collision(x, y): return True
|
|
|
|
target = self.actor_collision(actor, x, y)
|
|
|
|
if target:
|
|
self.combat(actor, target)
|
|
return True
|
|
|
|
return False
|
|
|
|
def move_player(self, actor, x, y):
|
|
if not self.collision(actor, x, y):
|
|
actor.x = x
|
|
actor.y = y
|
|
|
|
def spawn_actors(self, enemy_count):
|
|
x, y = self.map.spawn()
|
|
self.player = Player(x, y)
|
|
self.actors = [self.player]
|
|
|
|
for i in range(0, enemy_count):
|
|
x, y = self.map.spawn()
|
|
enemy = Enemy(x, y, '{')
|
|
self.actors.append(enemy)
|
|
|
|
def run(self):
|
|
self.spawn_actors(5)
|
|
self.move_enemies()
|
|
|
|
while True:
|
|
# remember, first one has to be the player
|
|
self.ui.update(self.actors)
|
|
|
|
new_x, new_y = self.ui.handle_input(self.player.x, self.player.y)
|
|
self.move_player(self.player, new_x, new_y)
|
|
self.move_enemies()
|
|
|
|
def main(stdscr):
|
|
width=27
|
|
height=16
|
|
ui = UI(stdscr, height, width, 5)
|
|
game = GameEngine(ui)
|
|
game.run()
|
|
|
|
curses.wrapper(main)
|
|
|