220 lines
6.1 KiB
Python
220 lines
6.1 KiB
Python
with open('day15-input-dev', 'r') as file:
|
|
data = [l.strip('\n') for l in file]
|
|
# data = [
|
|
# '#######',
|
|
# '#.G...#',
|
|
# '#...EG#',
|
|
# '#.#.#G#',
|
|
# '#..G#E#',
|
|
# '#.....#',
|
|
# '#######',
|
|
# ]
|
|
import numpy as np
|
|
from pathfinding.core.grid import Grid
|
|
from pathfinding.finder.dijkstra import DijkstraFinder
|
|
import sys
|
|
|
|
grid = np.zeros((len(data), len(data[0])), dtype=np.int64)
|
|
cells = {'#': 0, '.': 1, 'G': 1, 'E': 1}
|
|
goblins = []
|
|
elves = []
|
|
starting_hp = 200
|
|
starting_atk = 3
|
|
starting_atk_elf = 29
|
|
adjacent = np.array([[0,-1], [-1,0], [1,0], [0,1]], dtype=np.int64)
|
|
enemy_teams = [goblins, elves]
|
|
unit_positions = []
|
|
pathfind_grid = None
|
|
# pathfinder = AStarFinder()
|
|
pathfinder = DijkstraFinder()
|
|
UID = 0
|
|
|
|
class Unit:
|
|
def __init__(self, x, y, starting_hp, atk, team):
|
|
global UID
|
|
self.team = team
|
|
self.atk = atk
|
|
self.hp = starting_hp
|
|
self.pos = np.array([x, y], dtype=np.int64)
|
|
self.uid = UID
|
|
UID += 1
|
|
|
|
def __eq__(self, other):
|
|
return self.uid == other.uid
|
|
|
|
@property
|
|
def x(self):
|
|
return self.pos[0]
|
|
@property
|
|
def y(self):
|
|
return self.pos[1]
|
|
|
|
def distance(self, pos):
|
|
return np.abs(pos - self.pos).sum()
|
|
|
|
def path_to(self, pos, exhaustive=False):
|
|
if not exhaustive:
|
|
pathfind_grid = Grid(matrix=grid2)
|
|
start = pathfind_grid.node(*tuple(self.pos))
|
|
end = pathfind_grid.node(*tuple(pos))
|
|
path, runs = pathfinder.find_path(start, end, pathfind_grid)
|
|
return path
|
|
else:
|
|
paths = []
|
|
for d in range(len(adjacent)):
|
|
try:
|
|
trystart = tuple(self.pos + adjacent[d])
|
|
if grid2[trystart] and trystart not in unit_positions:
|
|
pathfind_grid = Grid(matrix=grid2.T)
|
|
start = pathfind_grid.node(*trystart)
|
|
end = pathfind_grid.node(*tuple(pos))
|
|
path, runs = pathfinder.find_path(start, end, pathfind_grid)
|
|
# print(pathfind_grid.grid_str(path=path, start=start, end=end))
|
|
if len(path) > 0:
|
|
paths.append(path)
|
|
except Exception:
|
|
pass
|
|
if paths:
|
|
paths = sorted(paths, key=lambda x: len(x))
|
|
# print(paths)
|
|
return paths[0]
|
|
return []
|
|
|
|
def path_distance(self, pos):
|
|
return len(self.path_to(pos, True)) or 90000 # Sorting hack
|
|
|
|
def path_distance_and_priority(self, pos):
|
|
path = self.path_to(pos, True)
|
|
if path:
|
|
for i in range(len(adjacent)):
|
|
if path[0] == tuple(self.pos + adjacent[i]):
|
|
priority = i
|
|
break
|
|
return len(path), priority
|
|
return (90000, 90000) # Sorting hack
|
|
|
|
def __repr__(self):
|
|
return f'[{"Elf" if not self.team else "Gob"}, Position {self.x},{self.y}, HP {self.hp}]'
|
|
|
|
|
|
for y, row in enumerate(data):
|
|
for x, c in enumerate(row):
|
|
grid[x,y] = cells[c]
|
|
if c == 'E':
|
|
elves.append(Unit(x, y, starting_hp, starting_atk_elf, 0))
|
|
elif c == 'G':
|
|
goblins.append(Unit(x, y, starting_hp, starting_atk, 1))
|
|
grid2 = grid.copy()
|
|
|
|
def turn_sort(unit):
|
|
return unit.y, unit.x
|
|
|
|
|
|
def target_sort(unit):
|
|
return unit.hp, unit.y, unit.x
|
|
|
|
|
|
def do_round():
|
|
global unit_positions, pathfind_grid
|
|
combatants = sorted(goblins + elves, key=turn_sort)
|
|
i = 0
|
|
while i < len(combatants):
|
|
unit_positions = [tuple(u.pos) for u in combatants]
|
|
grid2[:] = grid[:]
|
|
for p in unit_positions:
|
|
grid2[p] = -1
|
|
unit = combatants[i]
|
|
i += 1
|
|
enemy_team = enemy_teams[unit.team]
|
|
|
|
# If no enemies left, end combat
|
|
if len(enemy_team) == 0:
|
|
return
|
|
|
|
# If adjacent to an enemy, attack it
|
|
adjacent_enemies = []
|
|
for enemy in enemy_team:
|
|
if unit.distance(enemy.pos) == 1:
|
|
adjacent_enemies.append(enemy)
|
|
if adjacent_enemies:
|
|
# print(sorted(adjacent_enemies, key=target_sort))
|
|
target = sorted(adjacent_enemies, key=target_sort)[0]
|
|
# print(f'Unit #{unit.uid} attacking unit {target.uid}')
|
|
target.hp -= unit.atk
|
|
if target.hp <= 0:
|
|
if target.team == 0:
|
|
print('Elf died, aborting!')
|
|
sys.exit(1)
|
|
enemy_team.remove(target)
|
|
j = combatants.index(target)
|
|
combatants.pop(j)
|
|
if j < i:
|
|
i -= 1
|
|
continue
|
|
|
|
# Find all cells to move to
|
|
target_cells = {tuple(t.pos + adjacent[j]) for t in enemy_team for j in range(4)}
|
|
target_cells = {c for c in target_cells if grid[c] == 1 and c not in unit_positions}
|
|
target_cells = sorted([np.array(c) for c in target_cells], key=lambda x: unit.path_distance_and_priority(x))
|
|
# Move to closest target cell
|
|
if target_cells:
|
|
path = unit.path_to(target_cells[0], exhaustive=True)
|
|
if path:
|
|
# print(f'Unit #{unit.uid} moving from {unit.pos} to {path[0]}')
|
|
unit.pos[:] = path[0]
|
|
else:
|
|
pass
|
|
# print(f'Unit #{unit.uid} cannot move!')
|
|
|
|
# If adjacent to an enemy, attack it
|
|
adjacent_enemies = []
|
|
for enemy in enemy_team:
|
|
if unit.distance(enemy.pos) == 1:
|
|
adjacent_enemies.append(enemy)
|
|
if adjacent_enemies:
|
|
target = sorted(adjacent_enemies, key=target_sort)[0]
|
|
# print(f'Unit #{unit.uid} attacking unit {target.uid}')
|
|
target.hp -= unit.atk
|
|
if target.hp <= 0:
|
|
enemy_team.remove(target)
|
|
j = combatants.index(target)
|
|
combatants.pop(j)
|
|
if j < i:
|
|
i -= 1
|
|
continue
|
|
|
|
def print_state():
|
|
char_array = np.zeros_like(grid)
|
|
char_array[(grid == 0)] = ord('#')
|
|
char_array[(grid == 1)] = ord('.')
|
|
unit_strs = [[] for i in range(len(char_array))]
|
|
for g in goblins:
|
|
char_array[g.x, g.y] = ord('G')
|
|
unit_strs[g.y].append((f'G({g.hp})', g.x))
|
|
for e in elves:
|
|
char_array[e.x, e.y] = ord('E')
|
|
unit_strs[e.y].append((f'E({e.hp})', e.x))
|
|
for row in range(len(char_array)):
|
|
maprow =''.join([chr(c) for c in char_array.T[row]])
|
|
unithps = ', '.join([s[0] for s in sorted(unit_strs[row], key=lambda x: x[1])])
|
|
print(maprow, unithps)
|
|
|
|
|
|
|
|
def do_exterminatus(quit_after=9999999):
|
|
rounds = 0
|
|
while len(goblins) and len(elves) and rounds < quit_after:
|
|
print(f'Round #{rounds}')
|
|
print_state()
|
|
do_round()
|
|
rounds += 1
|
|
return rounds
|
|
|
|
|
|
round = do_exterminatus()
|
|
if goblins:
|
|
num = sum(u.hp for u in goblins)
|
|
else:
|
|
num = sum(u.hp for u in elves)
|
|
print(round, num, round*num)
|