def move(self, poly):
if self.frozen:
return
dot = (self.x, self.y)
# check if we are still on the new poly, because if we are not, then
# we will keep walking the old one until we get back on track
if game_utils.on_line(dot, poly):
self._polys_stack = [poly]
else:
if poly not in self._polys_stack:
self._polys_stack.append(poly)
if len(self._polys_stack) == 2:
self.show_confusion()
# we go from the freshest to oldest poly to see if we can find ourselves
for i, p in enumerate(reversed(self._polys_stack)):
if game_utils.on_line(dot, p):
poly = p
break
if not poly:
return
dot2 = None
if dot in poly:
dot2 = self.next(dot, poly)
else:
line = game_utils.on_line(dot, poly)
if not line:
return
dot2 = line[1] if self.clockwise else line[0]
# distance is sum because one of them will be the same
speed = self.speed
while speed > 0:
distance = game_utils.distance(dot, dot2)
direction = 1 if any ((a<b for a, b in zip(dot, dot2))) else -1
step_speed = min(speed, distance)
if dot[0] == dot2[0]:
# vertical movement
self.y += step_speed * direction
else:
# horizontal movement
self.x += step_speed * direction
distance = distance - step_speed
if distance == 0:
dot, dot2 = dot2, self.next(dot2, poly)
speed = speed - step_speed
self.current_line = game_utils.on_line((self.x, self.y), poly)
def _handle_keys(self, keys_down, game):
x, y = self.cube.x, self.cube.y
# if we have direction, we know that user wants to do something
# when drawing hasn't been initiated, user can move around the game poly
# moving around game poly means the dot is on the line at any given time
# when drawing is started, user can move all over the place but can't bump
# into the current drawing polygon
# path is closed if the move ends up on the game poly
#
# both cases we will want to adjust the new_x or new direction so that
# it is somewhere on the line
game_poly_dot, non_game_poly_dot = None, None
current_pos = (self.cube.x, self.cube.y)
if current_pos in self.game_area:
current_line = [game_utils.prev_dot(current_pos, self.game_area),
current_pos,
game_utils.next_dot(current_pos, self.game_area)]
else:
current_line = game_utils.on_line(current_pos, self.game_area)
key_directions = {
gdk.KEY_Left: "left",
gdk.KEY_j: "left",
gdk.KEY_J: "left",
gdk.KEY_Right: "right",
gdk.KEY_l: "right",
gdk.KEY_L: "right",
gdk.KEY_Up: "up",
gdk.KEY_i: "up",
gdk.KEY_I: "up",
gdk.KEY_Down: "down",
gdk.KEY_k: "down",
gdk.KEY_K: "down",
}
direction = None
for keyval in reversed(keys_down):
if keyval in key_directions:
direction = key_directions[keyval]
break
if not direction:
return
speed_direction = 1 if direction in ("right", "down") else -1
# find the furthest step we can take for the next game polygon dot
# when not drawing that's as far as we can go on current line
# when drawing, that's the closest border within step
for speed in reversed(range(self.cube.speed)):
game_x = x if direction in ("up", "down") else x + (speed + 1) * speed_direction
game_y = y if direction in ("left", "right") else y + (speed + 1) * speed_direction
if current_line:
if not game_poly_dot and game_utils.on_line((game_x, game_y), current_line):
# if we are on a line then we are looking for the max position at
# which we still have a hit
game_poly_dot = (game_x, game_y)
else:
# roaming around - checking if the next move is valid
if game_utils.on_line((game_x, game_y), self.game_area):
game_poly_dot = (game_x, game_y)
# look for the furthest valid non-game poly
# we stop when we find non-poly point and then bump into an on-line point
for speed in range(self.cube.speed):
game_x = x if direction in ("up", "down") else x + (speed + 1) * speed_direction
game_y = y if direction in ("left", "right") else y + (speed + 1) * speed_direction
on_line = game_utils.on_line((game_x, game_y), self.game_area)
if not self.in_game_bounds((game_x, game_y)):
break
if not on_line:
non_game_poly_dot = (game_x, game_y)
elif on_line and non_game_poly_dot:
break
space_down = any([key in keys_down for key in (gdk.KEY_space, gdk.KEY_Shift_L, gdk.KEY_Shift_R)])
if space_down and non_game_poly_dot and not game.claiming:
if game_utils.in_area(non_game_poly_dot, self.game_rects, on_line=True):
game.claiming = True
self.cube.set_drawing(True)
self._current_direction = None
if game.claiming and self._current_direction != direction:
self._current_direction = direction
if (self.cube.x, self.cube.y) not in self.current_polygon:
self.current_polygon.append((self.cube.x, self.cube.y))
# when we are drawing, we can move outside the claimed poly's
# when we are moving around, we can move only within the poly
# check if the move is valid
# we will go through all lines and check that our path is not
# intersecting
if game.claiming and game_poly_dot:
self.close_claim(self.current_polygon + [game_poly_dot],
self.cube.current_speed,
game)
game.claiming = False
self.cube.set_drawing(False)
self.current_polygon = []
self.current_polygon_path.points = []
self.cube.x, self.cube.y = game_poly_dot
self.cube.current_line = game_utils.on_line(game_poly_dot, self.game_area)
return
on_current_poly = non_game_poly_dot and game_utils.on_line(non_game_poly_dot, self.current_polygon) is not None
if game.claiming and not on_current_poly and non_game_poly_dot:
if game_utils.in_area(non_game_poly_dot, self.game_rects, on_line=True):
self.cube.x, self.cube.y = non_game_poly_dot
self.current_polygon_path.points = self.current_polygon + [non_game_poly_dot]
if not game.claiming and game_poly_dot:
# legal move is one where the next dot is on the same line as the prev one
line = game_utils.on_line([self.cube.x, self.cube.y], self.game_area)
new_line, good_lines = None, []
if line:
prev1, prev2 = line
lines = [(dot1, dot2) for dot1, dot2 in zip(self.game_area, self.game_area[1:])]
lines.append((self.game_area[-1], self.game_area[0]))
good_lines = [line for line in lines if prev1 in line or prev2 in line]
new_line = game_utils.on_line(game_poly_dot, self.game_area)
if new_line in good_lines:
self.cube.x, self.cube.y = game_poly_dot
self.cube.current_line = new_line
