def update(self, dt):
player_pos = self.scene.player_controller.player.position
for enemy in self.enemies:
# handle enemy stagger time and stagger recovery
if enemy.stagger_time_left > 0:
enemy.stagger_time_left -= dt
if enemy.stagger_time_left <= 0:
enemy.recover_from_stagger()
# handle enemy movement
if enemy.movement_mode == EnemyMovementMode.MoveToWaypoint:
# rotate towards the current waypoint:
enemy.rotation_degrees = (enemy.current_waypoint -
enemy.position).to_angle_degrees()
# # if we're less than 10 units from the waypoint, we randomize a new one!
if (enemy.current_waypoint - enemy.position).length() <= 10:
enemy.randomize_new_waypoint()
elif enemy.movement_mode == EnemyMovementMode.MoveToPlayer:
# rotate towards the player:
enemy.rotation_degrees = (player_pos -
enemy.position).to_angle_degrees()
else:
raise Exception('Unknown enemy movement mode: {}'.format(
enemy.movement_mode))
# if enemy velocity is lower than max velocity, then increment velocity. Otherwise do nothing - the enemy
# will be a freely moving object until the damping slows it down below max speed
if enemy.velocity.length() < enemy.max_velocity:
# increment the velocity
enemy.velocity += Vector.from_angle_degrees(enemy.rotation_degrees).normalize() * \
(enemy.acceleration_per_second * dt / 1000)
def spawn(self):
angles = list(range(0, 360, 10))
for angle in angles:
self.space.add_child(
TtlNode(mass=1e10,
sprite=self.box_image,
angular_velocity=1,
ttl=random.randrange(3000, 6000),
shape=Polygon.from_box(Vector(20, 20)),
velocity=Vector.from_angle_degrees(angle) * 50))
def shoot_bullet(self):
bullet_position = self.get_initial_bullet_position()
bullet_velocity = Vector.from_angle_degrees(
self.parent.rotation_degrees) * settings.GRENADE_LAUNCHER_BULLET_SPEED
self.scene.space.add_child(GrenadeLauncherBullet(position=bullet_position, velocity=bullet_velocity))
# reset cooldown time
self.cooldown_time_remaining = self.get_cooldown_time()
# play shooting sound
registry.global_controllers.assets_controller.grenade_launcher_shot_sound.play()
def shoot_bullet(self):
bullet_position = self.get_initial_bullet_position()
bullet_velocity = Vector.from_angle_degrees(
self.parent.rotation_degrees) * settings.FORCE_GUN_BULLET_SPEED
self.scene.space.add_child(
ForceGunBullet(position=bullet_position, velocity=bullet_velocity))
# reset cooldown time
self.cooldown_time_remaining = self.get_cooldown_time()
# play shooting sound
registry.global_controllers.assets_controller.force_gun_shot_sound.play(
)
def __init__(self):
self.camera.position = Vector(0., 0.)
self.space = self.root.add_child(
SpaceNode(position=Vector(0, 0),
gravity=Vector(0, 20),
damping=0.9))
image = Sprite(PYTHON_IMAGE_PATH)
random_angle = random.randrange(225, 315)
self.node = self.space.add_child(
BodyNode(mass=100,
sprite=image,
angular_velocity=10,
shape=Polygon.from_box(Vector(20, 20)),
velocity=Vector.from_angle_degrees(random_angle) * 100))
self.node.set_position_update_callback(update_position)
self.node.set_velocity_update_callback(update_velocity)
def test_vector():
v1 = Vector.xy(1.)
assert v1.x == 1. and v1.y == 1.
v2 = Vector(2., 2.)
assert v2.x == 2. and v2.y == 2.
assert v1 == Vector(1., 1.)
assert v2 == Vector(2., 2.)
zero = Vector(0, 0)
assert not zero
assert zero.is_zero()
assert v1 + v2 == Vector.xy(3)
assert Vector.xy(3.) - v2 == v1
assert v1 * 10 == Vector.xy(10.)
assert Vector.xy(10.) / 10 == v1
assert -v1 == Vector.xy(-1.)
rotated_vector = Vector(1, 0).rotate_angle_degrees(90)
assert pytest.approx(rotated_vector.x) == 0
assert pytest.approx(rotated_vector.y) == 1.
v = Vector.from_angle_degrees(90)
assert pytest.approx(rotated_vector.x) == 0
assert pytest.approx(rotated_vector.y) == 1.
assert v.to_angle_degrees() == 90
assert Vector(1., 0).angle_between_degrees(Vector(0, 1.)) == 90
assert Vector(1., 0).normalize().dot(Vector(1, 1.).normalize()) > 0
assert Vector(1., 0).normalize().dot(Vector(0, 1.).normalize()) == 0
assert Vector(1., 0).normalize().dot(Vector(-1, 1.).normalize()) < 0
assert Vector(0, 0).distance(Vector(10., 0)) == 10.
v = Vector(10., 10.)
assert v.normalize() == v / v.length()
assert v.length() == math.sqrt(v.x**2 + v.y**2)
fmt_print("bool({})\n --> {}", v1, bool(v1))
fmt_print("{} == {}\n --> {}", v1, v2, v1 == v2)
fmt_print("{} == {}\n --> {}", v1, v1, v1 == v1)
fmt_print("{} + {}\n --> {}", v1, v2, v1 + v2)
fmt_print("{} - {}\n --> {}", v1, v2, v1 - v2)
fmt_print("{} * {}\n --> {}", v1, m, v1 * m)
fmt_print("{} / {}\n --> {}", v1, m, v1 / m)
fmt_print("{} dot {}\n --> {}", v1, v2, v1.dot(v2))
fmt_print("{} distance to {}\n --> {}", v1, v2, v1.distance(v2))
fmt_print("negative {}\n --> {}", v1, -v1)
fmt_print("normalized {}\n --> {}", v1, v1.normalize())
fmt_print("length of {}\n --> {}", v1, v1.length())
fmt_print("{} rotated by {} degrees\n --> {}", v1, a_deg,
v1.rotate_angle_degrees(a_deg))
fmt_print("vector from angle (degrees) {}\n --> {}", a_deg,
Vector.from_angle_degrees(a_deg))
fmt_print("vector {} to angle (degrees)\n --> {}", v1,
v1.to_angle_degrees())
fmt_print("vector {} to angle (degrees)\n --> {}", v2,
v2.to_angle_degrees())
fmt_print("vector {} to angle (degrees)\n --> {}", v_up,
v_up.to_angle_degrees())
fmt_print("vector {} to angle (degrees)\n --> {}", v_down,
v_down.to_angle_degrees())
points = [Vector(0., 0.), Vector(1., 0.), Vector(0., 1.)]
rev_points = list(reversed(points))
points_invalid = [
Vector(0., 0.),
Vector(1., 1.),
Vector(1., -1.),
def get_initial_bullet_position(self):
player_pos = self.parent.position
player_rotation = self.parent.rotation_degrees
weapon_length = 50 # the bullet won't originate in the center of the player position but 50 pixels from it
result = player_pos + Vector.from_angle_degrees(player_rotation).normalize() * weapon_length
return result
