async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
row_size, column_size = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, row_size, column_size)
obstacles.append(obstacle)
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
obstacle.row, obstacle.column = row, column
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
await explode(canvas, row + row_size // 2, column + column_size // 2)
break
row += speed
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number)
row = 1
height, width = curses_tools.get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, rows_size=height, columns_size=width)
_, bounding_column, bounding_frame = obstacle.dump_bounding_box()
state.obstacles.append(obstacle)
while obstacle.row < rows_number:
# curses_tools.draw_frame(canvas, obstacle.row - 1, bounding_column, bounding_frame)
curses_tools.draw_frame(canvas, obstacle.row, column, garbage_frame)
await asyncio.sleep(0)
curses_tools.draw_frame(canvas,
obstacle.row,
column,
garbage_frame,
negative=True)
# curses_tools.draw_frame(canvas, obstacle.row - 1, bounding_column, bounding_frame, negative=True)
obstacle.row += speed
if obstacle in state.obstacles_in_last_collisions.copy():
state.obstacles_in_last_collisions.remove(obstacle)
state.obstacles.remove(obstacle)
state.coroutines.append(
explode(canvas, obstacle.row + height // 2,
column + width // 2))
return
async def fly_garbage(canvas, column: int, garbage_frame: TrashFrame,
obstacle_id: int, obstacles: dict,
destoyed_obstacle_ids: set):
"""
Animate garbage, flying from top to bottom.
Сolumn position will stay same, as specified on start.
"""
rows_number, columns_number = canvas.getmaxyx()
corrected_column = column - garbage_frame.width - 1
column = min(max(1, corrected_column), column)
obstacles[obstacle_id] = Obstacle(0, column, garbage_frame.height,
garbage_frame.width)
speed = 0.01 + random()
row = 0
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame.frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame.frame, negative=True)
if obstacle_id in destoyed_obstacle_ids:
destoyed_obstacle_ids.remove(obstacle_id)
center_row = row + int(garbage_frame.height / 2)
center_col = column + int(garbage_frame.width / 2)
await explode(canvas, center_row, center_col)
break
row += speed
obstacles[obstacle_id].row = row
del obstacles[obstacle_id]
async def fly_garbage(canvas, column, garbage_frame, status, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
rows_size, columns_size = get_frame_size(garbage_frame)
obstacle_object = Obstacle(row, column, rows_size, columns_size)
status.obstacles.append(obstacle_object)
try:
while row < rows_number:
if obstacle_object in status.obstacles_in_last_collisions:
await explode(canvas, row + rows_size // 2,
column + columns_size // 2)
status.obstacles_in_last_collisions.remove(obstacle_object)
return
draw_frame(canvas, row, column, garbage_frame)
await sleep()
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacle_object.row = row
finally:
status.obstacles.remove(obstacle_object)
async def fly_garbage(playground, column, garbage_frame, speed=0.5):
"""
Animate garbage, flying from top to bottom.
Column position will stay same, as specified on start.
"""
min_row, min_col, max_row, max_col = get_playground_limits(playground)
column = max(column, min_col)
column = min(column, max_col)
row = min_row
rows, cols = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, rows, cols)
obstacles.append(obstacle)
center_row = round(rows / 2)
center_col = round(cols / 2)
while row < max_row:
if obstacle in obstacles_in_last_collision:
obstacles.remove(obstacle)
obstacles_in_last_collision.remove(obstacle)
del obstacle
await explode(playground, row + center_row, column + center_col)
return
obstacle.row = row
draw_frame(playground, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(playground, row, column, garbage_frame, negative=True)
row += speed
else:
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay
same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
rows_size, columns_size = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, rows_size, columns_size)
obstacles.append(obstacle)
try:
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacle.row = row
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
await explode(canvas, row, column)
return
finally:
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
obstacle_height, obstacle_width = get_frame_size(garbage_frame)
obstacle = Obstacle(
0,
column,
rows_size=obstacle_height,
columns_size=obstacle_width
)
obstacles.append(obstacle)
row = 0
while row < rows_number and obstacle not in obstacles_in_last_collisions:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacle.row = row
if obstacle in obstacles_in_last_collisions:
center_obstacle_row = row + obstacle_height / 2
center_obstacle_column = column + obstacle_width / 2
await explode(canvas, center_obstacle_row, center_obstacle_column)
obstacles_in_last_collisions.remove(obstacle)
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 1
frame_rows, frame_columns = get_frame_size(garbage_frame)
barrier = Obstacle(row, column, frame_rows, frame_columns)
obstacles.append(barrier)
while row < rows_number - frame_rows - 3: # -3 to save the year info
barrier.row = row
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
if barrier in obstacles_in_last_collisions:
await explode(canvas, row, column)
obstacles_in_last_collisions.remove(barrier)
obstacles.remove(barrier)
return False
obstacles.remove(barrier)
async def fly_garbage(canvas, column, garbage_frame, speed=0.2):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
height, width = canvas.getmaxyx()
rows_number, columns_number = height, width
row_size, column_size = get_frame_size(garbage_frame)
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
obstacle = Obstacle(row, column, row_size, column_size)
global_obstacles.append(obstacle)
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
if obstacle in global_obstacles_in_last_collisions:
global_obstacles_in_last_collisions.remove(obstacle)
await explode(canvas, row + row_size // 2,
column + column_size // 2)
global_obstacles.remove(obstacle)
return
row += speed
obstacle.row = row
global_obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, obstacles, speed=0.5):
"""
Animate garbage, flying from top to bottom.
Column position will stay same, as specified on start.
"""
from main import obstacles_in_last_collisions
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
row_size, col_size = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, rows_size=row_size, columns_size=col_size)
obstacles.append(obstacle)
while row < rows_number:
obstacle.row = row
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
obstacles.remove(obstacle)
explode_row, explode_col = get_garbage_center(
row, column, row_size, col_size
)
await explode(canvas, explode_row, explode_col)
return
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom.
Сolumn position will stay same, as specified on start."""
global obstacles
global obstacles_in_last_collision
global coroutines
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
row_size, column_size = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, row_size, column_size)
obstacles.append(obstacle)
while row < rows_number:
if obstacle in obstacles_in_last_collision:
coroutines.append(
explode(canvas, row + row_size // 2,
column + column_size // 2))
obstacles_in_last_collision.remove(obstacle)
break
draw_frame(canvas, row, column, garbage_frame)
obstacle.row = row
obstacle.column = column
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5, uid=None):
"""Animate garbage, flying from top to bottom.
Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
garbage_rows, garbabe_columns = get_frame_size(garbage_frame)
global obstacles
global obstacles_in_last_collisions
obstacle = Obstacle(row, column, garbage_rows, garbabe_columns)
obstacles.append(obstacle)
try:
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await sleep(1)
draw_frame(canvas, row, column, garbage_frame, negative=True)
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
await explode(canvas, row + garbage_rows / 2,
column + garbabe_columns / 2)
return
row += speed
obstacle.row = row
finally:
obstacles.remove(obstacle)
def __init__(self, y, height, board):
focus = Point(FLOOR - height, y)
dimensions = Dimension(height, 7)
pipe = IDENTIFIER['pipe']
spring = IDENTIFIER['spring']
shape = [[pipe, pipe, spring, spring, spring, pipe, pipe]] * height
Obstacle.__init__(self, focus, shape, dimensions, board)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
global obstacles, coros
row_size, col_size = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, row_size, col_size)
obstacles.append(obstacle)
try:
while row < rows_number:
if obstacle in obstacles_in_last_collisions:
obstacles.remove(obstacle)
await explode(canvas, row, column)
return None
else:
draw_frame(canvas, row, column, garbage_frame)
obstacle.row = row
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
finally:
if obstacle in obstacles:
obstacles.remove(obstacle)
def main():
'''Test the functionality'''
pygame.init()
map = FlameMap()
SAMPLES = 300
samples = np.linspace(-5, 5, SAMPLES)
X, Y = np.meshgrid(samples, samples)
grid = np.dstack((X, Y))
if (True):
print "Single segment"
p1 = Vector2(-1.0, 1.0)
p2 = Vector2(1.0, 0.0)
seg = Segment(p1, p2)
s = time.clock()
dist = computeSegmentDistance(seg, grid)
e = time.clock()
print "\tTook %f seconds to compute %d distances" % (e - s,
grid.size / 2)
surface = map.colorOnSurface((dist.min(), dist.max()),
dist.T[:, ::-1])
imgSeg = imgSpaceSegment(seg, (-5.0, 5.0), (-5.0, 5.0), SAMPLES,
SAMPLES)
pygame.draw.line(surface, (255, 255, 255),
(imgSeg.p1.x, imgSeg.p1.y),
(imgSeg.p2.x, imgSeg.p2.y))
pygame.image.save(surface, 'distFieldSeg.png')
if (True):
print "Obstacle"
o = Obstacle()
o.closed = True
# create a hexagonal obstacle
RADIUS = 2.0
RAD_SAMPLE = 12
for i in xrange(RAD_SAMPLE):
theta = 2.0 * np.pi / RAD_SAMPLE * i
x = np.cos(theta) * RADIUS
y = np.sin(theta) * RADIUS
o.vertices.append(Vector3(x, y, 0))
s = time.clock()
dist = computeObstacleDistance(o, grid)
e = time.clock()
print "\tTook %f seconds to compute %d distances" % (e - s,
grid.size / 2)
## print dist
surface = map.colorOnSurface((dist.min(), dist.max()),
dist.T[:, ::-1])
for seg in o.segments:
imgSeg = imgSpaceSegment(seg, (-5.0, 5.0), (-5.0, 5.0),
SAMPLES, SAMPLES)
pygame.draw.line(surface, (255, 255, 255),
(imgSeg.p1.x, imgSeg.p1.y),
(imgSeg.p2.x, imgSeg.p2.y))
pygame.image.save(surface, 'distFieldObst.png')
async def fly_garbage(canvas,
obstacles,
obstacles_collisions,
column,
garbage_frame,
speed=0.5):
"""Animate garbage, flying from top to bottom. Column position will stay same, as specified on start.
E.g.
with open('garbage.txt', "r") as garbage_file:
frame = garbage_file.read()
coroutine = fly_garbage(canvas, 10, frame):
"""
assert speed > 0, AssertionError("Speed has to be positive")
assert len(garbage_frame) and all(garbage_frame), AssertionError(
"Frame can not be empty or has 0 height or width")
frame, frame_height, frame_width = garbage_frame
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
obstacle = Obstacle(row, column, frame_height, frame_width)
obstacles.add(obstacle)
while row < rows_number:
if obstacle in obstacles_collisions:
draw_frame(canvas, row, column, frame, negative=True)
await explode(canvas, row, column)
break
draw_frame(canvas, row, column, frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, frame, negative=True)
row += speed
obstacle.row = row
# delete obstacle
obstacles.discard(obstacle)
# restore borders
border = ord('|')
canvas.border(border, border)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""
Animate garbage, flying from top to bottom. Сolumn position will stay
same, as specified on start.
"""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
garbage_row, garbage_column = get_frame_size(garbage_frame)
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
obstacles.append(Obstacle(row, column, garbage_row, garbage_column))
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
obstacles.pop(0)
# for obst in obstacles_in_last_collisions:
# return obst
row += speed
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
rows_number, columns_number = canvas.getmaxyx()
row = 0
column = max(column, 0)
column = min(column, columns_number - 1)
obstacle_width, obstacle_height = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, obstacle_width, obstacle_height)
globals_vars.obstacles.append(obstacle)
try:
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacle.row += speed
if obstacle in globals_vars.obstacles_in_last_collisions:
await explode(canvas, obstacle.row, obstacle.column)
globals_vars.obstacles.remove(obstacle)
globals_vars.obstacles_in_last_collisions.remove(obstacle)
break
finally:
if obstacle in globals_vars.obstacles:
globals_vars.obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
obstacle_row, obstacle_column = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, obstacle_row, obstacle_column)
obstacles.append(obstacle)
# coroutines.append(show_obstacles(canvas, obstacles))
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacle.row += speed
if obstacle in obstacles_in_last_collision:
obstacles.remove(obstacle)
obstacles_in_last_collision.remove(obstacle)
await explode(canvas, row + obstacle_row // 2,
column + obstacle_column // 2)
return
else:
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom.
Сolumn position will stay same, as specified on start.
"""
global obstacles
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
frame_height, frame_width = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, frame_height, frame_width)
obstacles.append(obstacle)
await sleep(1)
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacle.row += speed
# Remove garbage that has encountered fire
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
obstacles.remove(obstacle)
await explode(canvas, row, column)
return
# Remove an obstacle flying over the edge
obstacles.remove(obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
frame_rows, frame_columns = get_frame_size(garbage_frame)
column = max(column, 0)
column = min(column, columns_number - 1)
uid = uuid.uuid4()
row = 0
while row < rows_number:
if uid in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(uid)
obstacles.pop(uid)
await explode(canvas, row, column)
return
obstacles[uid] = Obstacle(row,
column,
frame_rows,
frame_columns,
uid=uid)
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
obstacles.pop(uid)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
global obstacles
global obstacles_in_last_collisions
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
garbage_height, garbage_length = get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, garbage_height, garbage_length)
obstacles.append(obstacle)
if delay := get_garbage_delay_tics(year):
await sleep(delay)
draw_frame(canvas, row, column, garbage_frame, negative=True)
obstacles.remove(obstacle)
if obstacle in obstacles_in_last_collisions:
await explode(canvas, row + garbage_height // 2,
column + garbage_length // 2)
obstacles_in_last_collisions.remove(obstacle)
return
row += speed
async def fly_garbage(canvas, column, garbage_frame, speed=1):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
global OBSTACLES
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
row = 0
obstacle_row_size, obstacle_column_size = get_frame_size(garbage_frame)
garbage_obstacle_frame = Obstacle(row, column, obstacle_row_size, obstacle_column_size)
OBSTACLES.append(garbage_obstacle_frame)
await sleep(1)
while row < rows_number:
draw_frame(canvas, row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, row, column, garbage_frame, negative=True)
row += speed
garbage_obstacle_frame.row += speed
for obstacle in OBSTACLES_IN_LAST_COLLISION:
if garbage_obstacle_frame is obstacle:
OBSTACLES.remove(garbage_obstacle_frame)
await explode(canvas, row, column)
return
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
row_max, column_max = get_max_coords(canvas)
column = min(max(column, 0), column_max)
row = 0
height, width = get_frame_size(garbage_frame)
global obstacles_list, obstacles_in_last_collisions
uid = uuid.uuid4()
obstacle = Obstacle(row, column, height, width, uid)
obstacles_list.append(obstacle)
while obstacle.row < row_max:
draw_frame(canvas, obstacle.row, column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, obstacle.row, column, garbage_frame, negative=True)
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
obstacles_list.remove(obstacle)
row = obstacle.row + obstacle.rows_size / 2
column = obstacle.column + obstacle.columns_size / 2
await explode(canvas, round(row), round(column))
return
obstacle.row += speed
obstacles_list.remove(obstacle)
async def fill_orbit_with_garbage(
state,
canvas,
width,
):
frames = get_trash_frames()
while True:
garbage_speed, time_to_sleep = get_garbage_delay_tics(state["level"])
if time_to_sleep == None:
await sleep()
continue
column = randint(1, width)
frame = choice(frames)
rows, columns = get_frame_size(frame)
garbage_obstacle = Obstacle(0, column, rows, columns)
state["obstacles"].append(garbage_obstacle)
state["routines"].append(
fly_garbage(
state,
garbage_obstacle,
canvas,
column,
frame,
speed=garbage_speed,
), )
await sleep(time_to_sleep)
def generate_obstacles(self, penalty):
"""
Desc: Generates all obstacles with penalty. This is selected by
picking the spots randomly. Also removes occupied spots.
Input(s):
penalty: Penalty incurred for each obstacle
Output(s):
spots: Randomized list of coordinates for spots
"""
obstacles = []
num_spots = self.world_size[0] * self.world_size[1]
num_obstacles = int(ceil(self.obs_percent * num_spots))
logging.info("Num of obstacles: %d" % num_obstacles)
# choose obstacles
obstacle_indices = np.unravel_index(random.sample(range(num_spots), num_obstacles), self.world_size)
# set spot to obstacle
obstacle_indices = np.array(list(zip(obstacle_indices[0], obstacle_indices[1])))
# unravel_index gives y first
self.spots[obstacle_indices[:,1], obstacle_indices[:,0], 2] = 3
logging.info("Obstacle positions: ")
for pos in obstacle_indices:
logging.info(pos)
obstacles = [Obstacle(pos, penalty) for pos in obstacle_indices]
return obstacle_indices, obstacles
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Column position will stay the same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
garbage_current_row = 0
garbage_rows_takes, garbage_columns_takes = get_frame_size(garbage_frame)
column = max(column, 0)
garbage_current_column = min(column, columns_number - garbage_columns_takes)
current_obstacle = Obstacle(garbage_current_row, garbage_current_column, garbage_rows_takes, garbage_columns_takes)
obstacles.append(current_obstacle)
try:
while garbage_current_row < rows_number:
if current_obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(current_obstacle)
return
draw_frame(canvas, garbage_current_row, garbage_current_column, garbage_frame)
await asyncio.sleep(0)
draw_frame(canvas, garbage_current_row, garbage_current_column, garbage_frame, negative=True)
garbage_current_row += speed
current_obstacle.row += speed
finally:
obstacles.remove(current_obstacle)
async def fly_garbage(canvas, column, garbage_frame, speed=0.5):
"""Animate garbage, flying from top to bottom. Сolumn position will stay same, as specified on start."""
rows_number, columns_number = canvas.getmaxyx()
column = max(column, 0)
column = min(column, columns_number - 1)
# Get frame row size and run it higher so
# that it appears gradually instead suddenly
row = -utils.get_frame_size(garbage_frame)[0] + BORDER_WIDTH + 1
row_size, column_size = utils.get_frame_size(garbage_frame)
obstacle = Obstacle(row, column, row_size, column_size)
obstacles.append(obstacle)
while obstacle.row < rows_number - BORDER_WIDTH * 2 - DERIVED_WINDOW_HEIGHT:
if obstacle in obstacles_in_last_collisions:
obstacles_in_last_collisions.remove(obstacle)
coroutines.append(
explode(canvas, obstacle.row + row_size // 2,
obstacle.column + column_size // 2))
break
utils.draw_frame(canvas, obstacle.row, obstacle.column, garbage_frame)
await asyncio.sleep(0)
utils.draw_frame(canvas,
obstacle.row,
obstacle.column,
garbage_frame,
negative=True)
obstacle.row += speed
obstacles.remove(obstacle)
def add_obstacle(row, column, rows_size=1, columns_size=1, uid=None):
obstacle = Obstacle(row, column, rows_size, columns_size, uid)
state.obstacles.append(obstacle)
try:
yield obstacle
finally:
state.obstacles.remove(obstacle)
def create_frame_obstacles(row, column, frame, uid=None):
frame_row_size, frame_column_size = ct.get_frame_size(frame)
frame_obstacle = Obstacle(row=row,
column=column,
rows_size=frame_row_size,
columns_size=frame_column_size,
uid=uid)
OBSTACLES.append(frame_obstacle)
return frame_obstacle
