learn-code-the-hard-way
/
curseyou-python-rogue
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

I hated how I was doing Phase 13 so I'm just deleting it and will do one that doesn't use ECS.

Browse Source
master
Zed A. Shaw 3 days ago
parent 7fa0403a28
commit ba73ff762f
4 changed files with 0 additions and 369 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 111
      phase_13/ecs.py
  2. 207
      phase_13/game.py
  3. 41
      phase_13/pathing.py
  4. 10
      phase_13/utils.py

111
phase_13/ecs.py
Unescape View File

@ -1,111 +0,0 @@
import utils
import numpy as np
import pathing
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 ECS:
def __init__(self):
self.entities = {}
self.facts = {}
self.id_counter = 0
def entity(self):
self.id_counter += 1
return self.id_counter
def set(self, entity_id, obj):
name = obj.__class__.__qualname__
target = self.entities.get(name, {})
target[entity_id] = obj
self.entities[name] = target
def query(self, cls):
return self.entities[cls.__qualname__].items()
class Systems:
def __init__(self, ecs, ui, the_map):
self.ecs = ecs
self.map = the_map
self.ui = ui
self.height = self.map.height
self.width = self.map.width
self.paths = np.full((self.height, self.width), utils.PATH_LIMIT, dtype=int)
def move_enemies(self):
in_grid = np.full((self.map.height, self.map.width), 1, dtype=int)
in_grid[self.player.y, self.player.x] = 0
pathing.calculate_paths(self.map, self.paths, in_grid)
# for every enemy (actors[0] is player)
for enemy in self.actors[1:]:
nearby = utils.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)

207
phase_13/game.py
Unescape View File

@ -1,207 +0,0 @@
import curses
import sys
import random
import numpy as np
import ecs
import utils
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] == utils.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), utils.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] = utils.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] != utils.WALL: continue
found = self.neighbors(grid, x, y)
for found_x, found_y in found:
if grid[found_y, found_x] == utils.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 = utils.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] == utils.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] = utils.SPACE
row = (on_y + found_y) // 2
col = (on_x + found_x) // 2
grid[row, col] = utils.SPACE
else:
nb_x, nb_y = random.choice(n)
grid[nb_y, nb_x] = utils.SPACE
row = (nb_y + on_y) // 2
col = (nb_x + on_x) // 2
grid[row, col] = utils.SPACE
on_x, on_y = nb_x, nb_y
return dead_ends
def render_map(self, grid):
self.map = np.full((self.height, self.width), '#', dtype=str)
for y, y_line in enumerate(grid):
for x, char in enumerate(y_line):
self.map[y, x] = char
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] == utils.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] != utils.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)
self.ecs = ecs.ECS()
self.systems = ecs.Systems(self.ecs, self.ui, self.map)
def run(self):
self.systems.spawn_actors(5)
self.systems.move_enemies()
while True:
# remember, first one has to be the player
self.ui.update(self.systems.actors)
new_x, new_y = self.ui.handle_input(self.systems.player.x, self.systems.player.y)
self.systems.move_player(self.systems.player, new_x, new_y)
self.systems.move_enemies()
def main(stdscr):
width=27
height=16
ui = UI(stdscr, height, width, 5)
game = GameEngine(ui)
game.run()
curses.wrapper(main)

41
phase_13/pathing.py
Unescape View File

@ -1,41 +0,0 @@
import utils
def add_neighbors(the_map, neighbors, closed, near_y, near_x):
points = utils.compass(near_x, near_y)
for x,y in points:
if the_map.inbounds(x,y) and closed[y, x] == utils.SPACE:
closed[y, x] = utils.WALL
neighbors.append([x,y])
def calculate_paths(the_map, paths, in_grid):
height, width = paths.shape
paths.fill(utils.PATH_LIMIT)
closed = the_map.map.copy()
starting_pixels = []
open_pixels = []
counter = 0
while counter < height * width:
x = counter % width
y = counter // width
if in_grid[y, x] == 0:
paths[y, x] = 0
closed[y, x] = utils.WALL
starting_pixels.append([x,y])
counter += 1
for x, y in starting_pixels:
add_neighbors(the_map, open_pixels, closed, y, x)
counter = 1
while counter < utils.PATH_LIMIT and open_pixels:
next_open = []
for x,y in open_pixels:
paths[y, x] = counter
add_neighbors(the_map, next_open, closed, y, x)
open_pixels = next_open
counter += 1
for x, y in open_pixels:
paths[y, x] = counter

10
phase_13/utils.py
Unescape View File

@ -1,10 +0,0 @@
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
Write Preview
Loading…
Cancel
Save