def velocity2(puck_pos):
vec = [Vec2d(pos[0], pos[1]) for pos, t in puck_pos]
t = [t for pos, t in puck_pos]
#vec1 = Vec2d(puck_pos[0][0],puck_pos[0][1])
#vec2 = Vec2d(puck_pos[1][0],puck_pos[1][1])
velocityVec = []
if len(vec) > 4:
new_dir = vec[4] - vec[3]
if new_dir.length > 2.0:
td = t[4] - t[3]
velocityVec = new_dir / (td.total_seconds())
return velocityVec
elif 1.0 < new_dir.length <= 2.0:
new_dir = vec[4] - vec[2]
td = t[4] - t[2]
velocityVec = new_dir / (td.total_seconds())
return velocityVec
else:
return Vec2d.zero()
else:
return Vec2d.zero()
def explode_ringed_firework(self, prev_emitter):
"""Actions that happen when a firework shell explodes, resulting in a ringed firework"""
self.emitters.append(make_puff(prev_emitter))
self.emitters.append(make_flash(prev_emitter))
spark_texture, ring_texture = random.choice(SPARK_PAIRS)
sparks = arcade.Emitter(
pos=prev_emitter.get_pos(),
emit_controller=arcade.EmitBurst(25),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=spark_texture,
vel=arcade.rand_in_circle(Vec2d.zero(), 8.0),
lifetime=random.uniform(0.55, 0.8),
mutation_callback=firework_spark_mutator))
self.emitters.append(sparks)
ring = arcade.Emitter(
pos=prev_emitter.get_pos(),
emit_controller=arcade.EmitBurst(20),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=ring_texture,
vel=arcade.rand_on_circle(Vec2d.zero(
), 5.0) + arcade.rand_in_circle(Vec2d.zero(), 0.25),
lifetime=random.uniform(1.0, 1.6),
mutation_callback=firework_spark_mutator))
self.emitters.append(ring)
def emitter_3():
"""Burst, emit in circle"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitBurst(BURST_PARTICLE_COUNT),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_SLOW),
lifetime=DEFAULT_PARTICLE_LIFETIME,
pos=arcade.rand_in_circle(Vec2d.zero(), 100),
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_3.__doc__, e
def emitter_17():
"""Interval, emit on circle"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(DEFAULT_EMIT_INTERVAL,
DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_SLOW),
lifetime=DEFAULT_PARTICLE_LIFETIME,
pos=arcade.rand_on_circle(Vec2d.zero(), 100),
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_17.__doc__, e
def __init__(
self,
filename_or_texture: str,
vel: Vec2d,
pos: Vec2d = None,
angle: float = 0,
change_angle: float = 0,
scale: float = 1.0,
alpha: int = 255,
mutation_callback = None
):
if pos is None:
pos = Vec2d.zero()
if isinstance(filename_or_texture, Texture):
super().__init__(None, scale=scale)
self.append_texture(filename_or_texture)
self.set_texture(0)
else:
super().__init__(filename_or_texture, scale=scale)
self.center_x = pos.x
self.center_y = pos.y
self.change_x = vel.x
self.change_y = vel.y
self.angle = angle
self.change_angle = change_angle
self.alpha = alpha
self.mutation_callback = mutation_callback
def make_interval_emitter(
pos: Vec2d,
filenames_and_textures: List[
str], # Also supports Texture objects in the List
emit_interval: float,
emit_duration: float,
particle_speed: float,
particle_lifetime_min: float,
particle_lifetime_max: float,
particle_scale: float = 1.0,
fade_particles: bool = True):
"""Returns an emitter that emits its particles at a constant rate for a given amount of time"""
particle_factory = arcade.LifetimeParticle
if fade_particles:
particle_factory = arcade.FadeParticle
return arcade.Emitter(
pos=pos,
emit_controller=arcade.EmitterIntervalWithTime(emit_interval,
emit_duration),
particle_factory=lambda emitter: particle_factory(
filename_or_texture=random.choice(filenames_and_textures),
vel=arcade.rand_on_circle(Vec2d.zero(), particle_speed),
lifetime=random.uniform(particle_lifetime_min,
particle_lifetime_max),
scale=particle_scale))
def make_flash(prev_emitter):
"""Return emitter that displays the brief flash when a firework shell explodes"""
return arcade.Emitter(pos=prev_emitter.get_pos(),
emit_controller=arcade.EmitBurst(3),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=FLASH_TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), 3.5),
lifetime=0.15))
def pointify(self, csv_string, group_offset=Vec2d.zero()):
if group_offset.y:
offset = self.map_size.y - group_offset.y
else:
offset = 0
point_strings = [p.split(',') for p in csv_string.split()]
return [(group_offset.x + int(p[0]),
offset-int(p[1])) for p in point_strings]
def pointify(self, csv_string, group_offset=Vec2d.zero()):
if group_offset.y:
offset = self.map_size.y - group_offset.y
else:
offset = 0
point_strings = [p.split(',') for p in csv_string.split()]
return [(group_offset.x + int(p[0]), offset - int(p[1]))
for p in point_strings]
def __init__(self):
super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_TITLE)
# Set the working directory (where we expect to find files) to the same
# directory this .py file is in. You can leave this out of your own
# code, but it is needed to easily run the examples using "python -m"
# as mentioned at the top of this program.
file_path = os.path.dirname(os.path.abspath(__file__))
os.chdir(file_path)
arcade.set_background_color(arcade.color.BLACK)
self.emitters = []
self.frametime_plotter = arcade.FrametimePlotter()
self.launch_firework(0)
arcade.schedule(self.launch_spinner, 4.0)
stars = arcade.Emitter(
pos=Vec2d.zero(),
emit_controller=arcade.EmitMaintainCount(20),
particle_factory=lambda emitter: AnimatedAlphaParticle(
filename_or_texture=random.choice(STAR_TEXTURES),
vel=Vec2d.zero(),
start_alpha=0,
duration1=random.uniform(2.0, 6.0),
mid_alpha=128,
duration2=random.uniform(2.0, 6.0),
end_alpha=0,
pos=arcade.rand_in_rect(Vec2d.zero(), SCREEN_WIDTH,
SCREEN_HEIGHT)))
self.emitters.append(stars)
self.cloud = arcade.Emitter(
pos=Vec2d(50, 500),
vel=Vec2d(0.15, 0),
emit_controller=arcade.EmitMaintainCount(60),
particle_factory=lambda emitter: AnimatedAlphaParticle(
filename_or_texture=random.choice(CLOUD_TEXTURES),
vel=arcade.rand_in_circle(Vec2d.zero(), 0.04) + Vec2d(0.1, 0),
start_alpha=0,
duration1=random.uniform(5.0, 10.0),
mid_alpha=255,
duration2=random.uniform(5.0, 10.0),
end_alpha=0,
pos=arcade.rand_in_circle(Vec2d.zero(), 50)))
self.emitters.append(self.cloud)
def make_puff(prev_emitter):
"""Return emitter that generates the subtle smoke cloud left after a firework shell explodes"""
return arcade.Emitter(
pos=prev_emitter.get_pos(),
emit_controller=arcade.EmitBurst(4),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=PUFF_TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), 0.4) + Vec2d(0.3, 0.0),
lifetime=4.0))
def velocity(puck_pos, last_puck_pos, last_dir):
vec1 = Vec2d(puck_pos[0], puck_pos[1])
vec2 = Vec2d(last_puck_pos[0], last_puck_pos[1])
new_dir = vec1 - vec2
if new_dir.length > 0.1:
return new_dir
else:
return Vec2d.zero()
def emitter_27():
"""Maintain a steady count of particles"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitMaintainCount(3),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_on_circle(Vec2d.zero(), 2.0),
lifetime=random.uniform(1.0, 3.0),
))
return emitter_27.__doc__, e
def emitter_12():
"""Infinite emitting w/ eternal particle"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitInterval(0.02),
particle_factory=lambda emitter: arcade.EternalParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_12.__doc__, e
def make_emitter():
return arcade.Emitter(
pos=Vec2d(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2),
# pos=Vec2d.zero(),
emit_controller=arcade.EmitterIntervalWithTime(0.0004, 15.0),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), 5.0),
lifetime=1.0,
scale=0.5,
alpha=128))
def emitter_7():
"""Burst, emit from center, velocity fixed speed around 360 degrees"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitBurst(BURST_PARTICLE_COUNT // 4),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_on_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_7.__doc__, e
def emitter_28():
"""random particle textures"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(
DEFAULT_EMIT_INTERVAL * 5, DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=random.choice((TEXTURE, TEXTURE2, TEXTURE3)),
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=DEFAULT_SCALE))
return emitter_28.__doc__, e
def emitter_33():
"""Particles that fade over time"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(DEFAULT_EMIT_INTERVAL,
DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=DEFAULT_SCALE))
return emitter_33.__doc__, e
def emitter_1():
"""Burst, emit from center, particle lifetime 1.0 seconds"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitBurst(BURST_PARTICLE_COUNT),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=1.0,
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_1.__doc__, e
def emitter_26():
"""Interval, emit particles every 0.4 seconds and stop after emitting 5"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithCount(0.4, 5),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=0.6,
alpha=128))
return emitter_26.__doc__, e
def emitter_14():
"""Interval, emit from center, particle lifetime 1.0 seconds"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(DEFAULT_EMIT_INTERVAL,
DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=1.0,
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_14.__doc__, e
def emitter_8():
"""Burst, emit from center, velocity in rectangle"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitBurst(BURST_PARTICLE_COUNT),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_rect(Vec2d(-2.0, -2.0), 4.0, 4.0),
lifetime=DEFAULT_PARTICLE_LIFETIME,
pos=Vec2d.zero(),
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_8.__doc__, e
def emitter_20():
"""Interval, emit from center, velocity fixed speed around 360 degrees"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(DEFAULT_EMIT_INTERVAL,
DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_on_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_20.__doc__, e
def emitter_32():
"""animate particle angle"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(
DEFAULT_EMIT_INTERVAL * 5, DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE2,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
change_angle=2,
scale=DEFAULT_SCALE))
return emitter_32.__doc__, e
def emitter_30():
"""random particle alpha"""
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(
DEFAULT_EMIT_INTERVAL * 5, DEFAULT_EMIT_DURATION),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=DEFAULT_SCALE,
alpha=random.uniform(32, 128)))
return emitter_30.__doc__, e
def emitter_34():
"""Dynamically generated textures, burst emitting, fading particles"""
textures = [arcade.make_soft_circle_texture(48, p) for p in (arcade.color.GREEN, arcade.color.BLUE_GREEN)]
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitBurst(BURST_PARTICLE_COUNT),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=random.choice(textures),
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST),
lifetime=DEFAULT_PARTICLE_LIFETIME,
scale=DEFAULT_SCALE
)
)
return emitter_34.__doc__, e
def explode_firework(self, prev_emitter):
"""Actions that happen when a firework shell explodes, resulting in a typical firework"""
self.emitters.append(make_puff(prev_emitter))
self.emitters.append(make_flash(prev_emitter))
spark_texture = random.choice(SPARK_TEXTURES)
sparks = arcade.Emitter(
pos=prev_emitter.get_pos(),
emit_controller=arcade.EmitBurst(random.randint(30, 40)),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=spark_texture,
vel=arcade.rand_in_circle(Vec2d.zero(), 9.0),
lifetime=random.uniform(0.5, 1.2),
mutation_callback=firework_spark_mutator))
self.emitters.append(sparks)
def emitter_5():
"""Burst, emit in rectangle"""
width, height = 200, 100
centering_offset = Vec2d(-width / 2, -height / 2)
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitBurst(BURST_PARTICLE_COUNT),
particle_factory=lambda emitter: arcade.LifetimeParticle(
filename_or_texture=TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_SLOW),
lifetime=DEFAULT_PARTICLE_LIFETIME,
pos=arcade.rand_in_rect(centering_offset, width, height),
scale=DEFAULT_SCALE,
alpha=DEFAULT_ALPHA))
return emitter_5.__doc__, e
def emitter_35():
"""Use most features"""
soft_circle = arcade.make_soft_circle_texture(80, (255, 64, 64))
textures = (TEXTURE, TEXTURE2, TEXTURE3, TEXTURE4, TEXTURE5, TEXTURE6,
TEXTURE7, soft_circle)
e = arcade.Emitter(
pos=CENTER_POS,
emit_controller=arcade.EmitterIntervalWithTime(0.01, 1.0),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=random.choice(textures),
vel=arcade.rand_in_circle(Vec2d.zero(), PARTICLE_SPEED_FAST * 2),
lifetime=random.uniform(1.0, 3.5),
angle=random.uniform(0, 360),
change_angle=random.uniform(-3, 3),
scale=random.uniform(0.1, 0.8)))
return emitter_35.__doc__, e
def make_rocket(emit_done_cb):
"""Emitter that displays the smoke trail as the firework shell climbs into the sky"""
rocket = RocketEmitter(
pos=Vec2d(random.uniform(100, SCREEN_WIDTH - 100), 25),
emit_controller=arcade.EmitterIntervalWithTime(0.04, 2.0),
particle_factory=lambda emitter: arcade.FadeParticle(
filename_or_texture=ROCKET_SMOKE_TEXTURE,
vel=arcade.rand_in_circle(Vec2d.zero(), 0.08),
scale=0.5,
lifetime=random.uniform(1.0, 1.5),
start_alpha=100,
end_alpha=0,
mutation_callback=rocket_smoke_mutator),
emit_done_cb=emit_done_cb)
rocket.change_x = random.uniform(-1.0, 1.0)
rocket.change_y = random.uniform(5.0, 7.25)
return rocket
def explode_sparkle_firework(self, prev_emitter):
"""Actions that happen when a firework shell explodes, resulting in a sparkling firework"""
self.emitters.append(make_puff(prev_emitter))
self.emitters.append(make_flash(prev_emitter))
spark_texture = random.choice(SPARK_TEXTURES)
sparks = arcade.Emitter(
pos=prev_emitter.get_pos(),
emit_controller=arcade.EmitBurst(random.randint(30, 40)),
particle_factory=lambda emitter: AnimatedAlphaParticle(
filename_or_texture=spark_texture,
vel=arcade.rand_in_circle(Vec2d.zero(), 9.0),
start_alpha=255,
duration1=random.uniform(0.6, 1.0),
mid_alpha=0,
duration2=random.uniform(0.1, 0.2),
end_alpha=255,
mutation_callback=firework_spark_mutator))
self.emitters.append(sparks)
def __init__(self, name, img, up=None, left=None,
right=None, down=None, shoot=None):
self.name = name
# sprites
img = pygame.image.load(img)
flip_img = pygame.transform.flip(img, True, False)
images = (img, flip_img)
# animations
self.idle_loop = Animation(images, 1, 8, loop=True)
self.walk_loop = Animation(images, 3, 8, loop=True)
self.jump_loop = Animation(images, 5, 2, start_frame=4, loop=True)
self.spin_loop = Animation(
images, 7, 4, loop=True, frame_rate=0.4)
self.death_sequence = Animation(images, 8, 7)
# sounds
self.fall_sound = pygame.mixer.Sound("res/sfx/fall.wav")
self.fall_sound.set_volume(0.5)
self.jump_sound = pygame.mixer.Sound("res/sfx/jump.wav")
self.jump_sound.set_volume(0.5)
# keybindings
self.jump_key = up
self.left_key = left
self.right_key = right
self.down_key = down
self.shoot_key = shoot
# physics
self.body = pymunk.Body(5, pymunk.inf) # mass, moment
self.body.position = 100, 100
self.body.player = weakref.proxy(self)
# TODO: heads should be a separate collision type
self.head = pymunk.Circle(self.body, 14, (12, 7))
self.head.collision_type = PLAYER_COLLISION_TYPE
self.head.friction = 0
self.feet = pymunk.Circle(self.body, 14, (12, -16))
self.feet.collision_type = 1
# TODO: Make this zero whilst falling
self.feet.friction = 2
SPACE.add(self.body, self.head, self.feet)
# Character stats
self.max_jumps = 2
self.remaining_jumps = self.max_jumps
self.speed = 200 # 100
self.jump_speed = 400
self.max_health = 10
self.health = self.max_health
self.shot_cooldown = 0
# State tracking
self.landed = False
self.landed_hard = False
self.ground_velocity = Vec2d.zero()
self.ground_slope = 0
self.current_facing = self.right_key
self.bullets = []
