def __init__(self, *args, **kwargs):
super().__init__(
sprite=registry.global_controllers.assets_controller.
machine_gun_bullet_img,
z_index=30,
body_type=BodyNodeType.
kinematic, # MG bullets are kinematic bodies
lifetime=
3000, # will be removed from the scene automatically after 3 secs
*args,
**kwargs)
self.add_child(
HitboxNode(
shape=Polygon([
Vector(-13, -4),
Vector(13, -4),
Vector(13, 4),
Vector(-13, 4),
Vector(-13, -4)
]),
mask=HitboxMask.
bullet, # tell physics engine about object type
collision_mask=HitboxMask.
enemy, # tell physics engine which objects it can collide with
trigger_id=settings.COLLISION_TRIGGER_MG_BULLET
# ID to be used in custom collision handling function
))
def __init__(self):
self.camera.position = Vector(0., 0.)
self.space = self.root.add_child(SpaceNode(position=Vector(0, 0)))
self.box_image = Sprite(PYTHON_IMAGE_PATH)
self.timer = Timer(200, self.spawn, single_shot=False)
self.timer.start()
self.spawn()
def __init__(self, position, hp=100, *args, **kwargs):
# node's properties
super().__init__(body_type=BodyNodeType.dynamic, mass=1,
z_index=10, position=position,
transition=NodeSpriteTransition(registry.global_controllers.assets_controller.enemy_frames,
duration=max(200, random.gauss(400, 100)), loops=0),
*args, **kwargs)
# create a hitbox and add it as a child node to the Enemy
self.add_child(HitboxNode(
shape=Polygon([Vector(-8, -19), Vector(8, -19), Vector(8, 19), Vector(-8, 19), Vector(-8, -19)]),
mask=HitboxMask.enemy,
collision_mask=HitboxMask.all,
trigger_id=settings.COLLISION_TRIGGER_ENEMY,
))
# custom properties
self.hp = hp
self.stagger_time_left = 0
# 75% enemies will move towards player and 25% will move randomly
if random.randint(0, 100) < 75:
self.movement_mode = EnemyMovementMode.MoveToPlayer
else:
self.movement_mode = EnemyMovementMode.MoveToWaypoint
self.current_waypoint = None # for those which move to a waypoint, we'll keep its corrdinates here
self.randomize_new_waypoint() # and randomize new waypoint
self.acceleration_per_second = 300 # how fast will enemy accelerate
self.max_velocity = random.randint(75, 125) # we'll make enemy stop accelerating if velocity is above this value
def __init__(self, **kwargs):
self.is_moving = False
self.is_frozen = False
self.current_lane = 2
self.soap_fuel = self.soap_fuel_max = 30000
super().__init__(
body_type=BodyNodeType.kinematic,
position=LANE_HERO_SLOTS[self.current_lane],
scale=Vector.xy(0.7),
**kwargs,
)
self.hitbox = self.add_child(
HitboxNode(
trigger_id=CollisionTrigger.soap,
shape=Polygon.from_box(Vector(138, 330)),
# color=Color(1., 0., 0., 0.5),
z_index=100,
))
self.transitions_manager.set(
'animation',
NodeSpriteTransition(self.SPRITE_FRAMES,
loops=0,
duration=len(self.SPRITE_FRAMES) *
self.FRAME_DURATION),
)
def update(self, dt):
for event in self.input.events():
if event.keyboard_key and event.keyboard_key.is_key_down:
key = event.keyboard_key.key
if key == Keycode.q:
self.engine.quit()
elif key == Keycode.x:
self.pointer.shape = next(self.pointer_shapes_gen)
elif event.mouse_motion:
self.pointer.position = event.mouse_motion.position
elif (
event.mouse_button and event.mouse_button.button == MouseButton.left
):
if event.mouse_button.is_button_down:
self.pointer.color = POINTER_COLOR_ACTIVE
self._perform_shape_query()
else:
self.pointer.color = POINTER_COLOR_NORMAL
elif (
event.mouse_button
and event.mouse_button.button == MouseButton.right
and event.mouse_button.is_button_down
):
self._perform_point_query()
self._perform_ray_query(
Vector(0, 250), Vector(300, 250),
)
print("Visible nodes: ",
len(self.spatial_index.query_bounding_box(
BoundingBox(0, 0, 300, 300),
)))
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 update_camera(self):
if self.camera_shake_ticks:
if self.camera_shake_ticks > 1:
self.camera.position = Vector(
random.uniform(-10, 10),
random.uniform(-10, 10),
)
else:
self.camera.position = Vector(0, 0)
self.camera_shake_ticks -= 1
def __init__(self):
logger.info("Initializing scene: demo/basic.")
self.camera.position = Vector(0., 0.)
self.seg_node = Node()
self.seg_node.shape = Segment(Vector(-2., -2.),
Vector(2., 2.,))
self.circle_node = Node()
self.circle_node.shape = Circle(2., Vector(2., 2.))
self.box_node = Node()
self.box_node.shape = Polygon.from_box(Vector(1.5, 1.5))
logger.info("Node scene before adding to tree: %s", self.seg_node.scene)
self.root.add_child(self.seg_node)
self.root.add_child(self.circle_node)
self.root.add_child(self.box_node)
logger.info("Node scene after adding to tree: %s", self.seg_node.scene)
self.virtual_resolutions_cycle = itertools.cycle(
[Vector(10, 10), Vector(20, 20), Vector(5, 15), Vector(15, 5)]
)
self.virtual_resolution_modes_cycle = itertools.cycle(
[VirtualResolutionMode.aggresive_stretch,
VirtualResolutionMode.no_stretch,
VirtualResolutionMode.adaptive_stretch]
)
logger.info("Displays info:")
for display in self.engine.get_displays():
logger.info("* %r", display)
def update(self, dt):
for event in self.input.events():
if event.keyboard_key and event.keyboard_key.is_key_down:
if event.keyboard_key.key == Keycode.q:
self.engine.quit()
elif event.keyboard_key.key == Keycode.w:
self.camera.position += Vector(0, -20)
self.viewport.position += Vector(0, -20)
elif event.keyboard_key.key == Keycode.s:
self.camera.position += Vector(0, 20)
self.viewport.position += Vector(0, 20)
def __init__(self):
super().__init__()
self.root.add_child(Node(sprite=registry.global_controllers.assets_controller.title_screen_background_img,
z_index=0, position=Vector(0, 0), origin_alignment=Alignment.top_left))
self.root.add_child(TextNode(font=registry.global_controllers.assets_controller.font_2, font_size=30,
position=Vector(settings.VIEWPORT_WIDTH / 2, 500), text="Click to start the game",
z_index=1, origin_alignment=Alignment.center))
self.exit_label = TextNode(font=registry.global_controllers.assets_controller.font_2, font_size=30,
position=Vector(settings.VIEWPORT_WIDTH / 2, 550), text="Press ESC to exit",
z_index=1, origin_alignment=Alignment.center)
self.root.add_child(self.exit_label)
self.transitions_fun_stuff()
def __init__(self):
program = Program.from_files(
'demos/assets/shaders/vs_default.sc',
'demos/assets/shaders/fs_default.sc',
)
uniforms = {'u_blur': Uniform(UniformType.vec4)}
self.blur_quality = 20.
self.material = Material(program, uniforms)
self.material.set_uniform_value('u_blur', (self.blur_quality, 0, 0, 0))
self.node = self.root.add_child(
Node(sprite=Sprite(PYTHON_IMAGE_PATH),
position=Vector(400, 300),
scale=Vector.xy(2),
material=self.material))
def __init__(self, position, hp=100):
# node's properties
super().__init__(body_type=BodyNodeType.dynamic, mass=1,
z_index=10, sprite=registry.global_controllers.assets_controller.player_img, position=position)
# create a hitbox and add it as a child node to the Player
self.add_child(HitboxNode(
shape=Polygon([Vector(-10, -25), Vector(10, -25), Vector(10, 25), Vector(-10, 25), Vector(-10, -25)]),
mask=HitboxMask.player,
collision_mask=HitboxMask.enemy,
trigger_id=settings.COLLISION_TRIGGER_PLAYER
))
# custom properties
self.hp = hp
self.current_weapon = None
self.change_weapon(WeaponType.MachineGun)
def __init__(self):
super().__init__()
self.frag_count = 0
self.root.add_child(
TextNode(
font=registry.global_controllers.assets_controller.font_1,
origin_alignment=Alignment.left,
position=Vector(10, 20),
font_size=40,
z_index=1,
text="WASD to move, mouse to rotate, left mouse button to shoot"
))
self.root.add_child(
TextNode(font=registry.global_controllers.assets_controller.font_1,
origin_alignment=Alignment.left,
position=Vector(10, 45),
font_size=40,
z_index=1,
text="1, 2, 3 - change weapons. SPACE - spawn enemy"))
self.root.add_child(
TextNode(font=registry.global_controllers.assets_controller.font_2,
origin_alignment=Alignment.right,
position=Vector(1910, 20),
font_size=30,
z_index=1,
color=Color(1, 0, 0, 1),
text="Press Q to quit game"))
self.frag_count_label = TextNode(
font=registry.global_controllers.assets_controller.font_1,
origin_alignment=Alignment.left,
position=Vector(10, 70),
font_size=40,
z_index=1,
color=Color(1, 1, 0, 1),
text="")
self.root.add_child(self.frag_count_label)
self.space = SpaceNode(damping=0.3)
self.root.add_child(self.space)
self.player_controller = PlayerController(self)
self.enemies_controller = EnemiesController(self)
self.collisions_controller = CollisionsController(self)
self.root.add_child(
Node(sprite=registry.global_controllers.assets_controller.
background_img,
position=Vector(settings.VIEWPORT_WIDTH / 2,
settings.VIEWPORT_HEIGHT / 2),
z_index=0))
def update(self, dt):
for event in self.input.events():
if event.keyboard_key and event.keyboard_key.is_key_down:
if event.keyboard_key.key == Keycode.c:
self.collisions_enabled = not self.collisions_enabled
if not self.collisions_enabled:
self.obj1_hitbox.collision_mask = HitboxMask.side
self.obj2_hitbox.collision_mask = HitboxMask.side
print("Objects will NOT collide")
else:
self.obj1_hitbox.collision_mask = HitboxMask.all
self.obj2_hitbox.collision_mask = HitboxMask.all
print("Objects will collide")
if event.keyboard_key.key == Keycode.f:
self.engine.window.fullscreen = not self.engine.window.fullscreen
if event.keyboard_key.key == Keycode.l:
self.engine.window.size = self.engine.window.size + Vector(
20, 20)
if event.keyboard_key.key == Keycode.v:
self.engine.window.center()
if self.input.keyboard.is_pressed(Keycode.q):
print("q Pressed - Exiting")
self.engine.quit()
elif self.input.keyboard.is_pressed(Keycode.x) and self.space:
self.space.delete()
self.space = None
def __init__(self, *, speed_mod, faded=False, **kwargs):
assert self.SPRITE_FRAMES
assert self.TRIGGER_ID
super().__init__(
body_type=BodyNodeType.kinematic,
position=random.choice(LANE_ENEMY_SLOTS),
velocity=Vector(0, random.uniform(300, 300 + speed_mod)),
angular_velocity_degrees=random.uniform(-20, 20),
**kwargs,
)
self._is_destroying = False
self.hitbox = self.add_child(
HitboxNode(
trigger_id=self.TRIGGER_ID,
shape=Circle(48.),
# color=Color(1., 0., 0., 0.5),
z_index=100,
))
self.transitions_manager.set(
'animation',
NodeSpriteTransition(self.SPRITE_FRAMES,
loops=0,
duration=len(self.SPRITE_FRAMES) *
self.FRAME_DURATION),
)
if faded:
self.color = Color(0.5, 0.5, 0.5, 1.)
def update_position(node, dt):
# reimplements default position function
node.position += (node.velocity + node._velocity_bias) * dt
node.rotation += (node.angular_velocity + node._angular_velocity_bias) * dt
node._velocity_bias = Vector.xy(0)
node._angular_velocity_bias = 0
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 stagger(self):
# use the "stagger" sprite
self.sprite = registry.global_controllers.assets_controller.enemy_stagger_img
# stagger stops enemy from moving:
self.velocity = Vector(0, 0)
# track time for staying in the staggered state
self.stagger_time_left = 150
def __init__(self):
self.space = self.root.add_child(SpaceNode(
gravity=Vector(0., 15.),
sleeping_threshold=1.,
))
self.pointer_shapes_gen = itertools.cycle(POINTER_SHAPES)
self.pointer = self.root.add_child(Node(
position=Vector(-500, -500), # start offscreen
shape=next(self.pointer_shapes_gen),
color=POINTER_COLOR_NORMAL,
z_index=10,
))
self.spawn_timer = Timer(self._spawn_heartbeat)
self.spawn_timer.start(0.02, self)
def update(self, dt):
for event in self.input.events():
if event.keyboard_key and event.keyboard_key.is_key_down:
if event.keyboard_key.key == Keycode.n:
self.spawn_object()
elif event.keyboard_key.key == Keycode.r:
self.random_collisions = not self.random_collisions
print("Random collisions: {}".format(self.random_collisions))
elif event.keyboard_key.key == Keycode.c:
self.collision_spawning = not self.collision_spawning
if self.collision_spawning:
print("Collision spawning enabled (for one collision)")
elif event.keyboard_key.key == Keycode.s:
self.observed_ball.velocity *= 1.5
elif event.keyboard_key.key == Keycode.t:
print(self.observed_ball.transformation)
print(self.observed_ball.transformation.decompose())
self.observed_ball.transformation = \
(
Transformation(scale=Vector(2., 2.))
| Transformation(translate=Vector(100., 100.))
)
elif event.keyboard_key.key == Keycode.l:
all_balls = [
n for n in self.space.children if isinstance(n, FlyingBall)
]
if all_balls:
target_ball = random.choice(all_balls)
target_ball.lifetime = 1500
if (
event.mouse_button
and event.mouse_button.is_button_down
and event.mouse_button.button == MouseButton.left
):
self.spawn_object(
position=self.camera.unproject_position(
event.mouse_button.position,
),
velocity=Vector(0., 0.),
)
if self.input.keyboard.is_pressed(Keycode.q):
print("q Pressed - Exiting")
self.engine.quit()
self.camera.position = self.observed_ball.position
def __init__(self, slot_index, font, *args, **kwargs):
super().__init__(*args, **kwargs)
self.font = font
self.slot_index = slot_index
self.status_label = TextNode(
font=self.font,
font_size=16,
origin_alignment=Alignment.top_left,
position=Vector(0, 0),
text=
f"Controller #{slot_index} not connected. Please connect a controller."
)
self.add_child(self.status_label)
self.controller_stats_container = ControllerStatsContainer(
slot_index, font, None, position=Vector(0, 20))
self.add_child(self.controller_stats_container)
self.controller_stats_container.visible = False
def __init__(self):
self.camera.position = Vector(0., 0.)
self.my_font = Font(os.path.join('demos', 'assets', 'fonts', 'DejaVuSans.ttf'))
self.text_node = TextNode(font=self.my_font, content="Hello World", font_size=1.)
self.root.add_child(self.text_node)
self.text_buffer = []
self.input.register_callback(Event.keyboard_key, handle_quit)
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 spawn_object(self, position=None, velocity=None):
if position is None:
position = Vector(random.randint(-100, 100), random.randint(-100, 100))
if velocity is None:
velocity = Vector(random.gauss(0, 0.1), random.gauss(0, 0.1) * 100) * 10.
obj = self.space.add_child(FlyingBall(
sprite=self.python_img,
body_type=BodyNodeType.dynamic,
position=position,
velocity=velocity,
angular_velocity_degrees=random.gauss(0., 50.),
))
obj.add_child(HitboxNode(
shape=Circle(10.),
trigger_id=COLLISION_TRIGGER,
))
self.objects.append(obj)
def _spawn_heartbeat(self, context):
if random.random() > 0.8:
initial_position = Vector(
random.uniform(0, 300), -20.
)
self.space.add_child(
FallingPiece(initial_position)
)
return context.interval
def __init__(self, *, root_node, camera):
self.camera = camera
self.flasher = root_node.add_child(
Node(
shape=Polygon.from_box(Vector(1400, 800)),
color=Color(0., 0., 0., 0.),
z_index=100,
))
self.camera_shake_ticks = 0
def __init__(self):
self.camera.position = Vector(0., 0.)
self.python_img = Sprite(PYTHON_IMAGE_PATH)
self.obj = self.root.add_child(Node(
position=Vector(-50, 0),
shape=Circle(10.),
color=random_color(),
))
self.obj.transitions_manager.set(
'movement',
NodeTransition(
Node.position, Vector(100, 30), 3.,
advance_method=AttributeTransitionMethod.add,
loops=0, back_and_forth=True,
)
)
def __init__(self):
self.camera.position = Vector(0., 0.)
self.my_font = Font(
"kaacore/demos/assets/fonts/Roboto/Roboto-Regular.ttf")
self.text_node = TextNode(font=self.my_font,
content="Hello World",
font_size=1.)
self.root.add_child(self.text_node)
def update_count(self, new_count: int):
if new_count < self.current_count:
for powerup in self.single_powerups[new_count:self.current_count]:
powerup.transition = NodeTransitionsParallel([
NodeTransition(Node.scale, Vector(0., 0.), duration=400),
NodeTransition(Node.color,
Color(1., 1., 1., 0.),
duration=400),
])
elif new_count > self.current_count:
for powerup in self.single_powerups[self.current_count:new_count]:
powerup.transition = NodeTransitionsParallel([
NodeTransition(Node.scale, Vector(1., 1.), duration=400),
NodeTransition(Node.color,
Color(1., 1., 1., 1.),
duration=400),
])
self.current_count = new_count
def __init__(self, scene):
self.scene = scene
self.enemies = []
# add some initial enemies
self.add_enemy(
Enemy(position=Vector(200, 200),
rotation_degrees=random.randint(0, 360)))
self.add_enemy(
Enemy(position=Vector(1500, 600),
rotation_degrees=random.randint(0, 360)))
self.add_enemy(
Enemy(position=Vector(1000, 400),
rotation_degrees=random.randint(0, 360)))
self.add_enemy(
Enemy(position=Vector(1075, 420),
rotation_degrees=random.randint(0, 360)))
self.add_enemy(
Enemy(position=Vector(1150, 440),
rotation_degrees=random.randint(0, 360)))
