531 lines
22 KiB
Python
531 lines
22 KiB
Python
# maze.py - module for the maze class
|
|
# Copyright (C) 2017-2020 Nguyễn Gia Phong
|
|
#
|
|
# This file is part of Brutal Maze.
|
|
#
|
|
# Brutal Maze is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# Brutal Maze is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with Brutal Maze. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
__doc__ = 'Brutal Maze module for the maze class'
|
|
|
|
import json
|
|
from collections import defaultdict, deque
|
|
from math import log, pi
|
|
from os import path
|
|
from random import choice, sample
|
|
|
|
import pygame
|
|
|
|
from .characters import Hero, new_enemy
|
|
from .constants import (ADJACENTS, ATTACK_SPEED, BG_COLOR,
|
|
BULLET_LIFETIME, CELL_NODES, CELL_WIDTH, COLORS,
|
|
EMPTY, ENEMIES, ENEMY, ENEMY_HP, FG_COLOR, HERO,
|
|
HERO_HP, HERO_SPEED, INIT_SCORE, JSON_SEPARATORS,
|
|
MAX_WOUND, MAZE_SIZE, MIDDLE, ROAD_WIDTH,
|
|
SFX_LOSE, SFX_MISSED, SFX_SLASH_ENEMY, SFX_SPAWN,
|
|
SQRT2, TANGO_VALUES, WALL, WALL_WIDTH)
|
|
from .misc import around, deg, fill_aapolygon, json_rec, play, regpoly, sign
|
|
from .weapons import LockOn
|
|
|
|
|
|
class Maze:
|
|
"""Object representing the maze, including the characters.
|
|
|
|
Attributes:
|
|
w, h (int): width and height of the display (in px)
|
|
fps (float): current frame rate
|
|
surface (pygame.Surface): the display to draw on
|
|
distance (float): distance between centers of grids (in px)
|
|
x, y (int): coordinates of the center of the hero (in px)
|
|
centerx, centery (float): center grid's center's coordinates (in px)
|
|
rangex, rangey (list): range of the index of the grids on display
|
|
score (float): current score
|
|
map (deque of deque): map of grids representing objects on the maze
|
|
vx, vy (float): velocity of the maze movement (in pixels per frame)
|
|
rotatex, rotatey (int): grids rotated
|
|
bullets (list of .weapons.Bullet): flying bullets
|
|
enemies (list of Enemy): alive enemies
|
|
hero (Hero): the hero
|
|
destx, desty (int): the grid the hero is moving to
|
|
stepx, stepy (int): direction the maze is moving
|
|
target (Enemy or LockOn): target to automatically aim at
|
|
next_move (float): time until the hero gets mobilized (in ms)
|
|
glitch (float): time that the maze remain flashing colors (in ms)
|
|
next_slashfx (float): time until next slash effect of the hero (in ms)
|
|
slashd (float): minimum distance for slashes to be effective
|
|
export (list of defaultdict): records of game states
|
|
export_dir (str): directory containing records of game states
|
|
export_rate (float): milliseconds per snapshot
|
|
next_export (float): time until next snapshot (in ms)
|
|
"""
|
|
def __init__(self, fps, size, headless, export_dir, export_rate):
|
|
self.fps = fps
|
|
self.w, self.h = size
|
|
if headless:
|
|
self.surface = None
|
|
else:
|
|
self.surface = pygame.display.set_mode(size, pygame.RESIZABLE)
|
|
self.export_dir = path.abspath(export_dir) if export_dir else ''
|
|
self.next_export = self.export_rate = export_rate
|
|
self.export = []
|
|
|
|
self.distance = (self.w * self.h / 416) ** 0.5
|
|
self.x, self.y = self.w // 2, self.h // 2
|
|
self.centerx, self.centery = self.w / 2, self.h / 2
|
|
w, h = (int(i/self.distance/2 + 1) for i in size)
|
|
self.rangex = list(range(MIDDLE - w, MIDDLE + w + 1))
|
|
self.rangey = list(range(MIDDLE - h, MIDDLE + h + 1))
|
|
self.score = INIT_SCORE
|
|
self.new_map()
|
|
|
|
self.vx = self.vy = 0.0
|
|
self.rotatex = self.rotatey = 0
|
|
self.bullets, self.enemies = [], []
|
|
self.add_enemy()
|
|
self.hero = Hero(self.surface, fps, size)
|
|
self.target = LockOn(MIDDLE, MIDDLE, retired=True)
|
|
self.next_move = self.glitch = self.next_slashfx = 0.0
|
|
self.slashd = self.hero.R + self.distance/SQRT2
|
|
|
|
self.sfx_spawn = SFX_SPAWN
|
|
self.sfx_slash = SFX_SLASH_ENEMY
|
|
self.sfx_lose = SFX_LOSE
|
|
|
|
def new_cell(self, x, y):
|
|
"""Draw on the map a newly created cell
|
|
whose coordinates are given.
|
|
"""
|
|
def draw_bit(bit, dx=0, dy=0):
|
|
startx, starty = x + CELL_NODES[dx], y + CELL_NODES[dy]
|
|
height = ROAD_WIDTH if dy else WALL_WIDTH
|
|
for i in range(ROAD_WIDTH if dx else WALL_WIDTH):
|
|
for j in range(height): self.map[startx + i][starty + j] = bit
|
|
|
|
x, y = x * CELL_WIDTH, y * CELL_WIDTH
|
|
draw_bit(WALL)
|
|
walls = set(sample(ADJACENTS, 2))
|
|
walls.add(choice(ADJACENTS))
|
|
for i, j in ADJACENTS:
|
|
draw_bit((WALL if (i, j) in walls else EMPTY), i, j)
|
|
|
|
def isdisplayed(self, x, y):
|
|
"""Return True if the grid (x, y) is in the displayable part
|
|
of the map, False otherwise.
|
|
"""
|
|
return (self.rangex[0] <= x <= self.rangex[-1]
|
|
and self.rangey[0] <= y <= self.rangey[-1])
|
|
|
|
def new_map(self):
|
|
"""Generate a new map."""
|
|
self.map = deque(deque(EMPTY for _ in range(MAZE_SIZE * CELL_WIDTH))
|
|
for _ in range(MAZE_SIZE * CELL_WIDTH))
|
|
for x in range(MAZE_SIZE):
|
|
for y in range(MAZE_SIZE): self.new_cell(x, y)
|
|
# Regenerate if the hero is trapped. This can only reach
|
|
# maximum recursion depth is there's a flaw with the system's entropy.
|
|
room, visited = [(MIDDLE, MIDDLE)], set()
|
|
while room:
|
|
bit = room.pop()
|
|
if bit not in visited:
|
|
if not self.isdisplayed(*bit): break
|
|
visited.add(bit)
|
|
for x, y in around(*bit):
|
|
if self.map[x][y] == EMPTY: room.append((x, y))
|
|
else:
|
|
self.new_map()
|
|
self.map[MIDDLE][MIDDLE] = HERO
|
|
self.destx = self.desty = MIDDLE
|
|
self.stepx = self.stepy = 0
|
|
|
|
def add_enemy(self):
|
|
"""Add enough enemies."""
|
|
self.enemies = [e for e in self.enemies if e.alive]
|
|
walls = [(i, j) for i in self.rangex for j in self.rangey
|
|
if self.map[i][j] == WALL]
|
|
plums = [e for e in self.enemies if e.color == 'Plum' and e.awake]
|
|
plum = choice(plums) if plums else None
|
|
num = log(self.score, INIT_SCORE)
|
|
while walls and len(self.enemies) < num:
|
|
x, y = choice(walls)
|
|
if all(self.map[x + a][y + b] == WALL for a, b in ADJACENTS):
|
|
continue
|
|
enemy = new_enemy(self, x, y)
|
|
self.enemies.append(enemy)
|
|
if plum is None or not plum.clone(enemy): walls.remove((x, y))
|
|
|
|
def get_pos(self, x, y):
|
|
"""Return coordinate of the center of the grid (x, y)."""
|
|
return (self.centerx + (x - MIDDLE)*self.distance,
|
|
self.centery + (y - MIDDLE)*self.distance)
|
|
|
|
def get_grid(self, x, y):
|
|
"""Return the grid containing the point (x, y)."""
|
|
return (MIDDLE + round((x-self.centerx) / self.distance),
|
|
MIDDLE + round((y-self.centery) / self.distance))
|
|
|
|
def get_target(self, x, y):
|
|
"""Return shooting target the grid containing the point (x, y).
|
|
|
|
If the grid is the hero, return a retired target.
|
|
"""
|
|
gridx, gridy = self.get_grid(x, y)
|
|
if gridx == gridy == MIDDLE: return LockOn(gridx, gridy, True)
|
|
for enemy in self.enemies:
|
|
if not enemy.isunnoticeable(gridx, gridy): return enemy
|
|
return LockOn(gridx, gridy)
|
|
|
|
def get_score(self):
|
|
"""Return the current score."""
|
|
return int(self.score - INIT_SCORE)
|
|
|
|
def get_color(self):
|
|
"""Return color of a grid."""
|
|
return choice(TANGO_VALUES)[0] if self.glitch > 0 else FG_COLOR
|
|
|
|
def draw(self):
|
|
"""Draw the maze."""
|
|
self.surface.fill(BG_COLOR)
|
|
if self.next_move <= 0:
|
|
for i in self.rangex:
|
|
for j in self.rangey:
|
|
if self.map[i][j] != WALL: continue
|
|
x, y = self.get_pos(i, j)
|
|
square = regpoly(4, self.distance / SQRT2, pi / 4, x, y)
|
|
fill_aapolygon(self.surface, square, self.get_color())
|
|
|
|
for enemy in self.enemies: enemy.draw()
|
|
if not self.hero.dead: self.hero.draw()
|
|
bullet_radius = self.distance / 4
|
|
for bullet in self.bullets: bullet.draw(bullet_radius)
|
|
pygame.display.flip()
|
|
pygame.display.set_caption(
|
|
'Brutal Maze - Score: {}'.format(self.get_score()))
|
|
|
|
def rotate(self):
|
|
"""Rotate the maze if needed."""
|
|
x = int((self.centerx-self.x) * 2 / self.distance)
|
|
y = int((self.centery-self.y) * 2 / self.distance)
|
|
if x == y == 0: return
|
|
for enemy in self.enemies:
|
|
if self.map[enemy.x][enemy.y] == ENEMY:
|
|
self.map[enemy.x][enemy.y] = EMPTY
|
|
|
|
self.map[MIDDLE][MIDDLE] = EMPTY
|
|
self.centerx -= x * self.distance
|
|
self.map.rotate(x)
|
|
self.rotatex += x
|
|
self.centery -= y * self.distance
|
|
for d in self.map: d.rotate(y)
|
|
self.rotatey += y
|
|
self.map[MIDDLE][MIDDLE] = HERO
|
|
if self.map[self.destx][self.desty] != HERO:
|
|
self.destx += x
|
|
self.desty += y
|
|
self.stepx = self.stepy = 0
|
|
|
|
# Respawn the enemies that fall off the display
|
|
for i, enemy in enumerate(self.enemies):
|
|
enemy.place(x, y)
|
|
if not self.isdisplayed(enemy.x, enemy.y):
|
|
self.score += enemy.wound
|
|
enemy.die()
|
|
self.add_enemy()
|
|
|
|
# LockOn target is not yet updated.
|
|
if isinstance(self.target, LockOn):
|
|
self.target.place(x, y, self.isdisplayed)
|
|
|
|
# Regenerate the maze
|
|
if abs(self.rotatex) == CELL_WIDTH:
|
|
self.rotatex = 0
|
|
for i in range(CELL_WIDTH): self.map[i].rotate(-self.rotatey)
|
|
for i in range(MAZE_SIZE): self.new_cell(0, i)
|
|
for i in range(CELL_WIDTH): self.map[i].rotate(self.rotatey)
|
|
if abs(self.rotatey) == CELL_WIDTH:
|
|
self.rotatey = 0
|
|
self.map.rotate(-self.rotatex)
|
|
for i in range(MAZE_SIZE): self.new_cell(i, 0)
|
|
self.map.rotate(self.rotatex)
|
|
|
|
def get_distance(self, x, y):
|
|
"""Return the distance from the center of the maze to the point
|
|
(x, y).
|
|
"""
|
|
return ((self.x-x)**2 + (self.y-y)**2)**0.5
|
|
|
|
def hit_hero(self, wound, color):
|
|
"""Handle the hero when he loses HP."""
|
|
if color == 'Orange':
|
|
# If called by close-range attack, this is FPS-dependant, although
|
|
# in playable FPS (24 to infinity), the difference within 2%.
|
|
self.hero.next_heal = abs(self.hero.next_heal * (1 - wound))
|
|
elif choice(ENEMIES) == color:
|
|
self.hero.next_heal = -1.0 # what doesn't kill you heals you
|
|
if color == 'Butter' or color == 'ScarletRed':
|
|
wound *= ENEMY_HP
|
|
elif color == 'Chocolate':
|
|
self.hero.highness += wound
|
|
wound = 0
|
|
elif color == 'SkyBlue':
|
|
self.next_move = max(self.next_move, 0) + wound*1000
|
|
wound = 0
|
|
if wound and sum(self.hero.wounds) < MAX_WOUND:
|
|
self.hero.wounds[-1] += wound
|
|
|
|
def slash(self):
|
|
"""Handle close-range attacks."""
|
|
for enemy in self.enemies: enemy.slash()
|
|
if not self.hero.spin_queue: return
|
|
for enemy in filter(lambda e: e.awake, self.enemies):
|
|
d = self.slashd - enemy.distance
|
|
if d > 0:
|
|
wound = d * SQRT2 / self.distance
|
|
if self.next_slashfx <= 0:
|
|
play(SFX_SLASH_ENEMY, enemy.x, enemy.y, wound)
|
|
self.next_slashfx = ATTACK_SPEED
|
|
enemy.hit(wound / self.hero.spin_speed)
|
|
if enemy.wound >= ENEMY_HP:
|
|
self.score += enemy.wound
|
|
enemy.die()
|
|
self.add_enemy()
|
|
|
|
def track_bullets(self):
|
|
"""Handle the bullets."""
|
|
self.bullets.extend(self.hero.shots)
|
|
fallen = []
|
|
block = (self.hero.spin_queue and self.hero.next_heal < 0
|
|
and self.hero.next_strike > self.hero.spin_queue / self.fps)
|
|
|
|
for i, bullet in enumerate(self.bullets):
|
|
wound = bullet.fall_time / BULLET_LIFETIME
|
|
bullet.update(self.fps, self.distance)
|
|
gridx, gridy = self.get_grid(bullet.x, bullet.y)
|
|
if wound <= 0 or not self.isdisplayed(gridx, gridy):
|
|
fallen.append(i)
|
|
elif bullet.color == 'Aluminium':
|
|
active_enemies = [e for e in self.enemies if e.awake]
|
|
if self.map[gridx][gridy] == WALL and self.next_move <= 0:
|
|
fallen.append(i)
|
|
if not active_enemies: continue
|
|
self.glitch = wound * 1000
|
|
enemy = new_enemy(self, gridx, gridy)
|
|
enemy.awake = True
|
|
self.map[gridx][gridy] = ENEMY
|
|
play(SFX_SPAWN, enemy.x, enemy.y)
|
|
enemy.hit(wound)
|
|
self.enemies.append(enemy)
|
|
continue
|
|
for enemy in active_enemies:
|
|
if bullet.get_distance(*enemy.pos) < self.distance:
|
|
enemy.hit(wound)
|
|
if enemy.wound >= ENEMY_HP:
|
|
self.score += enemy.wound
|
|
enemy.die()
|
|
self.add_enemy()
|
|
play(bullet.sfx_hit, gridx, gridy, wound)
|
|
fallen.append(i)
|
|
break
|
|
elif bullet.get_distance(self.x, self.y) < self.distance:
|
|
if block:
|
|
self.hero.next_strike = (abs(self.hero.spin_queue/self.fps)
|
|
+ ATTACK_SPEED)
|
|
play(SFX_MISSED, gain=wound)
|
|
else:
|
|
self.hit_hero(wound, bullet.color)
|
|
play(bullet.sfx_hit, gain=wound)
|
|
fallen.append(i)
|
|
for i in reversed(fallen): self.bullets.pop(i)
|
|
|
|
def is_valid_move(self, vx=0.0, vy=0.0):
|
|
"""Return dx or dy if it it valid to move the maze in that
|
|
velocity, otherwise return 0.0.
|
|
"""
|
|
d = self.distance/2 + self.hero.R
|
|
herox, heroy, dx, dy = self.x - vx, self.y - vy, sign(vx), sign(vy)
|
|
for gridx in range(MIDDLE - dx - 1, MIDDLE - dx + 2):
|
|
for gridy in range(MIDDLE - dy - 1, MIDDLE - dy + 2):
|
|
x, y = self.get_pos(gridx, gridy)
|
|
if (max(abs(herox - x), abs(heroy - y)) < d
|
|
and self.map[gridx][gridy] == WALL):
|
|
return 0.0
|
|
for enemy in self.enemies:
|
|
x, y = self.get_pos(enemy.x, enemy.y)
|
|
if max(abs(herox - x), abs(heroy - y)) * 2 < self.distance:
|
|
return 0.0
|
|
return vx or vy
|
|
|
|
def expos(self, x, y):
|
|
"""Return position of the given coordinates in rounded percent."""
|
|
cx = len(self.rangex)*50 + (x - self.centerx)/self.distance*100
|
|
cy = len(self.rangey)*50 + (y - self.centery)/self.distance*100
|
|
return round(cx), round(cy)
|
|
|
|
def update_export(self, forced=False):
|
|
"""Update the maze's data export and return the last record."""
|
|
if self.next_export > 0 and not forced or self.hero.dead: return
|
|
export = defaultdict(list)
|
|
export['s'] = self.get_score()
|
|
|
|
if self.next_move <= 0:
|
|
for y in self.rangey:
|
|
export['m'].append(''.join(
|
|
COLORS[self.get_color()] if self.map[x][y] == WALL else '0'
|
|
for x in self.rangex))
|
|
|
|
x, y = self.expos(self.x, self.y)
|
|
export['h'] = [
|
|
COLORS[self.hero.get_color()], x, y, deg(self.hero.angle),
|
|
int(self.hero.next_strike <= 0), int(self.hero.next_heal <= 0)]
|
|
|
|
for enemy in self.enemies:
|
|
if enemy.isunnoticeable(): continue
|
|
x, y = self.expos(*enemy.pos)
|
|
color, angle = COLORS[enemy.get_color()], deg(enemy.angle)
|
|
export['e'].append([color, x, y, angle])
|
|
|
|
for bullet in self.bullets:
|
|
x, y = self.expos(bullet.x, bullet.y)
|
|
color, angle = COLORS[bullet.get_color()], deg(bullet.angle)
|
|
if color != '0': export['b'].append([color, x, y, angle])
|
|
|
|
if self.next_export <= 0:
|
|
export['t'] = round(self.export_rate - self.next_export)
|
|
self.export.append(export)
|
|
self.next_export = self.export_rate
|
|
return export
|
|
|
|
def update(self, fps):
|
|
"""Update the maze."""
|
|
self.fps = fps
|
|
self.vx = self.is_valid_move(vx=self.vx)
|
|
self.centerx += self.vx
|
|
self.vy = self.is_valid_move(vy=self.vy)
|
|
self.centery += self.vy
|
|
|
|
self.next_move -= 1000 / fps
|
|
self.glitch -= 1000 / fps
|
|
self.next_slashfx -= 1000 / fps
|
|
self.next_export -= 1000 / fps
|
|
|
|
self.rotate()
|
|
if self.vx or self.vy or self.hero.firing or self.hero.slashing:
|
|
for enemy in self.enemies: enemy.wake()
|
|
for bullet in self.bullets: bullet.place(self.vx, self.vy)
|
|
|
|
for enemy in self.enemies: enemy.update()
|
|
self.track_bullets()
|
|
if not self.hero.dead:
|
|
self.hero.update(fps)
|
|
self.slash()
|
|
if self.hero.wound >= HERO_HP: self.lose()
|
|
self.update_export()
|
|
|
|
def resize(self, size):
|
|
"""Resize the maze."""
|
|
self.w, self.h = size
|
|
self.surface = pygame.display.set_mode(size, pygame.RESIZABLE)
|
|
self.hero.resize(size)
|
|
|
|
offsetx = (self.centerx-self.x) / self.distance
|
|
offsety = (self.centery-self.y) / self.distance
|
|
self.distance = (self.w * self.h / 416) ** 0.5
|
|
self.x, self.y = self.w // 2, self.h // 2
|
|
self.centerx = self.x + offsetx*self.distance
|
|
self.centery = self.y + offsety*self.distance
|
|
w, h = int(self.w/self.distance/2 + 1), int(self.h/self.distance/2 + 1)
|
|
self.rangex = list(range(MIDDLE - w, MIDDLE + w + 1))
|
|
self.rangey = list(range(MIDDLE - h, MIDDLE + h + 1))
|
|
self.slashd = self.hero.R + self.distance/SQRT2
|
|
|
|
def set_step(self, check=(lambda x, y: True)):
|
|
"""Work out next step on the shortest path to the destination.
|
|
|
|
Return whether target is impossible to reach and hero should
|
|
shoot toward it instead.
|
|
"""
|
|
if self.stepx or self.stepy and self.vx == self.vy == 0.0:
|
|
x, y = MIDDLE - self.stepx, MIDDLE - self.stepy
|
|
if self.stepx and not self.stepy:
|
|
nextx = x - self.stepx
|
|
n = self.map[x][y - 1] == EMPTY == self.map[nextx][y - 1]
|
|
s = self.map[x][y + 1] == EMPTY == self.map[nextx][y + 1]
|
|
self.stepy = n - s
|
|
elif not self.stepx and self.stepy:
|
|
nexty = y - self.stepy
|
|
w = self.map[x - 1][y] == EMPTY == self.map[x - 1][nexty]
|
|
e = self.map[x + 1][y] == EMPTY == self.map[x + 1][nexty]
|
|
self.stepx = w - e
|
|
return False
|
|
|
|
# Shoot WALL and ENEMY instead
|
|
if self.map[self.destx][self.desty] != EMPTY:
|
|
self.stepx = self.stepy = 0
|
|
return True
|
|
|
|
# Forest Fire algorithm
|
|
queue, visited = deque([(self.destx, self.desty)]), set()
|
|
while queue:
|
|
x, y = queue.pop()
|
|
if (x, y) in visited: continue
|
|
visited.add((x, y))
|
|
dx, dy = MIDDLE - x, MIDDLE - y
|
|
if dx**2 + dy**2 <= 2:
|
|
# Succeeded on finding a path
|
|
self.stepx, self.stepy = dx, dy
|
|
return False
|
|
for i, j in around(x, y):
|
|
if self.map[i][j] == EMPTY and check(i, j):
|
|
queue.appendleft((i, j))
|
|
# Failed to find way to move to target
|
|
self.stepx = self.stepy = 0
|
|
return True
|
|
|
|
def isfast(self):
|
|
"""Return if the hero is moving faster than HERO_SPEED."""
|
|
return (self.vx**2+self.vy**2)**0.5*self.fps > HERO_SPEED*self.distance
|
|
|
|
def dump_records(self):
|
|
"""Dump JSON records."""
|
|
if self.export_dir:
|
|
with open(json_rec(self.export_dir), 'w') as f:
|
|
json.dump(self.export, f, separators=JSON_SEPARATORS)
|
|
|
|
def lose(self):
|
|
"""Handle loses."""
|
|
self.hero.dead = True
|
|
self.hero.wound = HERO_HP
|
|
self.hero.slashing = self.hero.firing = False
|
|
self.destx = self.desty = MIDDLE
|
|
self.stepx = self.stepy = 0
|
|
self.vx = self.vy = 0.0
|
|
play(SFX_LOSE)
|
|
self.dump_records()
|
|
|
|
def reinit(self):
|
|
"""Open new game."""
|
|
self.centerx, self.centery = self.w / 2, self.h / 2
|
|
self.score, self.export = INIT_SCORE, []
|
|
self.new_map()
|
|
self.vx = self.vy = 0.0
|
|
self.rotatex = self.rotatey = 0
|
|
self.bullets, self.enemies = [], []
|
|
self.add_enemy()
|
|
|
|
self.next_move = self.next_slashfx = self.hero.next_strike = 0.0
|
|
self.target = LockOn(MIDDLE, MIDDLE, retired=True)
|
|
self.hero.next_heal = -1.0
|
|
self.hero.highness = 0.0
|
|
self.hero.slashing = self.hero.firing = self.hero.dead = False
|
|
self.hero.spin_queue = self.hero.wound = 0.0
|
|
self.hero.wounds = deque([0.0])
|