def position_shift(obj, game):
max_speed = 5.
if utils.norm(obj.speed) > max_speed:
obj.speed = utils.normalize(obj.speed, max_speed)
if obj.target_move:
vector = [
obj.target_move[0] - obj.pos[0],
obj.target_move[1] - obj.pos[1]
]
angle_target = utils.cartesian2polar(vector)[1]
if utils.dist(obj.pos, obj.target_move) < obj.rotation_radius:
angle_target += 0.5 * math.pi + math.pi / 60.
angle_max_shift = 2. * math.pi
elif utils.dist(obj.pos,
obj.target_move) > obj.rotation_radius > 0:
angle_target += 0.5 * math.pi - math.pi / 60.
angle_max_shift = 2. * math.pi
else:
angle_max_shift = math.pi / 60.
obj_speed_polar = utils.cartesian2polar(obj.speed)
obj_speed_polar[1] = utils.periodic_shift_to(
obj_speed_polar[1], angle_target, angle_max_shift)
obj.speed = utils.polar2cartesian(obj_speed_polar)
game.update_obj_pos(obj)
def draw(self, game, surface, erase):
if erase:
color = (255., 255., 255.)
else:
color = (50., 50.,
200.) if self._holder == game.get_player() else (200.,
50., 50.)
for i in range(self._count):
phi = utils.cartesian2polar([
self._holder.target_shoot[0] -
self._holder.pos[0], self._holder.target_shoot[1] -
self._holder.pos[1]
])[1] if self._holder.target_shoot else -0.5 * math.pi
vector = utils.polar2cartesian([
1.,
phi - self._spread + 2. * self._spread * i / (self._count - 1.)
])
N = 10
for idx in range(N // 2, N + N // 2):
draw_pos = [
int(self._holder.pos[0] +
2. * self._holder.radius * vector[0] * idx / N),
int(self._holder.pos[1] +
2. * self._holder.radius * vector[1] * idx / N),
]
surface.set_at(draw_pos, color)
def spread_shot(obj, game, bullet):
ro, phi = utils.cartesian2polar(bullet.speed)
for i in range(self._count):
angle = phi - self._spread + 2. * self._spread * i / (
self._count - 1.)
bullet_new = copy.copy(bullet)
bullet_new.pos = bullet.pos.copy()
bullet_new.speed = utils.polar2cartesian([ro, angle])
game.add_effect(bullet_new)
bullet.is_active = False
def draw(self, game, surface, erase):
if erase:
color_inner = (255., 255., 255.)
color_outer = (255., 255., 255.)
color_charged = (255., 255., 255.)
else:
color_inner = [255. - 155. * (self.hp % 1.)] * 3
color_outer = (0., 0., 0.)
color_intensity = 150. * self.charge if self.charge < 1. else 255.
color_charged = (
0., 0., color_intensity) if self == game.get_player() else (
color_intensity, 0., 0.)
draw_pos = (int(self.pos[0]), int(self.pos[1]))
for i in range(int(self.hp)):
if i == 0:
pygame.draw.circle(surface, color_charged, draw_pos,
int(self.radius), 1)
elif self.radius > 2 * i:
pygame.draw.circle(surface, color_outer, draw_pos,
int(self.radius) - 2 * i, 1)
if self.hp % 1 > 0.1 and self.radius > 2 * (i + 1):
pygame.draw.circle(surface, color_inner, draw_pos,
int(self.radius) - 2 * (i + 1), 1)
if self.target_shoot:
color = (
255.,
255.,
255.,
) if erase else (50., 50., 50.)
vector = [
self.target_shoot[0] - self.pos[0],
self.target_shoot[1] - self.pos[1]
]
phi = utils.cartesian2polar(vector)[1]
points = []
for vertex in [
utils.polar2cartesian(
[self.radius + 3., phi - 0.05 * math.pi]),
utils.polar2cartesian([self.radius + 6., phi]),
utils.polar2cartesian(
[self.radius + 3., phi + 0.05 * math.pi])
]:
points.append([
round(self.pos[0] + vertex[0]),
round(self.pos[1] + vertex[1])
])
pygame.draw.lines(surface, color, True, points, 1)
