Exemplo n.º 1
0
def createParticleBurst(x0,
                        y0,
                        partInterval,
                        totalDuration,
                        partSize,
                        partScale,
                        partSpeed,
                        color,
                        startAlpha,
                        endAlpha,
                        imagePath=None):
    e = arcade.Emitter(
        center_xy=(x0, y0),
        emit_controller=arcade.EmitterIntervalWithTime(partInterval,
                                                       totalDuration),
        particle_factory=lambda emitter: arcade.FadeParticle(
            filename_or_texture=imagePath
            if imagePath is not None else arcade.make_circle_texture(
                partSize, color),
            change_xy=arcade.rand_in_circle((0.0, 0.0), partSpeed),
            scale=partScale,
            lifetime=uniform(totalDuration / 4, totalDuration),
            start_alpha=startAlpha,
            end_alpha=endAlpha,
        ),
    )
    return e
Exemplo n.º 2
0
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_spinner():
    spinner = arcade.Emitter(
        center_xy=(SCREEN_WIDTH / 2, SPINNER_HEIGHT - 5),
        emit_controller=arcade.EmitterIntervalWithTime(0.025, 2.0),
        particle_factory=lambda emitter: arcade.FadeParticle(
            filename_or_texture=random.choice(STAR_TEXTURES),
            change_xy=(0, 6.0),
            lifetime=0.2))
    spinner.change_angle = 16.28
    return spinner
Exemplo n.º 4
0
def make_emitter():
    return arcade.Emitter(center_xy=(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2),
                          emit_controller=arcade.EmitterIntervalWithTime(
                              0.0004, 15.0),
                          particle_factory=lambda emitter: arcade.
                          LifetimeParticle(filename_or_texture=TEXTURE,
                                           change_xy=arcade.rand_in_circle(
                                               (0.0, 0.0), 5.0),
                                           lifetime=1.0,
                                           scale=0.5,
                                           alpha=128))
def emitter_22():
    """Interval, emit from center, velocity in fixed angle and speed"""
    e = arcade.Emitter(pos=CENTER_POS,
                       emit_controller=arcade.EmitterIntervalWithTime(
                           0.2, DEFAULT_EMIT_DURATION),
                       particle_factory=lambda emitter: arcade.
                       LifetimeParticle(filename_or_texture=TEXTURE,
                                        vel=Vec2d(1.0, 1.0),
                                        lifetime=DEFAULT_PARTICLE_LIFETIME,
                                        scale=DEFAULT_SCALE,
                                        alpha=128))
    return emitter_22.__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_37():
    """Rotating emitter. Particles initial velocity is relative to emitter's angle."""
    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=Vec2d(0.0, 2.0),
                                        lifetime=2.0,
                                        scale=DEFAULT_SCALE))
    e.change_angle = 10.0
    return emitter_37.__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_23():
    """Interval, emit from center, velocity in fixed angle and random speed"""
    e = arcade.Emitter(
        pos=CENTER_POS,
        emit_controller=arcade.EmitterIntervalWithTime(
            DEFAULT_EMIT_INTERVAL * 8, DEFAULT_EMIT_DURATION),
        particle_factory=lambda emitter: arcade.LifetimeParticle(
            filename_or_texture=TEXTURE,
            vel=arcade.rand_vec_magnitude(45, 1.0, 4.0),
            lifetime=DEFAULT_PARTICLE_LIFETIME,
            scale=DEFAULT_SCALE,
            alpha=DEFAULT_ALPHA))
    return emitter_23.__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_13():
    """Interval, emit particle every 0.01 seconds for one second"""
    e = arcade.Emitter(center_xy=CENTER_POS,
                       emit_controller=arcade.EmitterIntervalWithTime(
                           DEFAULT_EMIT_INTERVAL, DEFAULT_EMIT_DURATION),
                       particle_factory=lambda emitter: arcade.
                       LifetimeParticle(filename_or_texture=TEXTURE,
                                        change_xy=arcade.rand_in_circle(
                                            (0.0, 0.0), PARTICLE_SPEED_FAST),
                                        lifetime=DEFAULT_PARTICLE_LIFETIME,
                                        scale=DEFAULT_SCALE,
                                        alpha=DEFAULT_ALPHA))
    return emitter_13.__doc__, e
def emitter_31():
    """Constant particle angle"""
    e = arcade.Emitter(center_xy=CENTER_POS,
                       emit_controller=arcade.EmitterIntervalWithTime(
                           DEFAULT_EMIT_INTERVAL * 5, DEFAULT_EMIT_DURATION),
                       particle_factory=lambda emitter: arcade.
                       LifetimeParticle(filename_or_texture=TEXTURE2,
                                        change_xy=arcade.rand_in_circle(
                                            (0.0, 0.0), PARTICLE_SPEED_FAST),
                                        lifetime=DEFAULT_PARTICLE_LIFETIME,
                                        angle=45,
                                        scale=DEFAULT_SCALE))
    return emitter_31.__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_24():
    """Interval, emit from center, velocity from angle with spread"""
    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_vec_spread_deg(90, 45, 2.0),
            lifetime=DEFAULT_PARTICLE_LIFETIME,
            scale=DEFAULT_SCALE,
            alpha=DEFAULT_ALPHA))
    return emitter_24.__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_25():
    """Interval, emit from center, velocity along a line"""
    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_line(Vec2d(-2, 1), Vec2d(2, 1)),
            lifetime=DEFAULT_PARTICLE_LIFETIME,
            scale=DEFAULT_SCALE,
            alpha=DEFAULT_ALPHA))
    return emitter_25.__doc__, e
def emitter_29():
    """random particle scale"""
    e = arcade.Emitter(center_xy=CENTER_POS,
                       emit_controller=arcade.EmitterIntervalWithTime(
                           DEFAULT_EMIT_INTERVAL * 5, DEFAULT_EMIT_DURATION),
                       particle_factory=lambda emitter: arcade.
                       LifetimeParticle(filename_or_texture=TEXTURE,
                                        change_xy=arcade.rand_in_circle(
                                            (0.0, 0.0), PARTICLE_SPEED_FAST),
                                        lifetime=DEFAULT_PARTICLE_LIFETIME,
                                        scale=random.uniform(0.1, 0.8),
                                        alpha=DEFAULT_ALPHA))
    return emitter_29.__doc__, e
def emitter_21():
    """Interval, emit from center, velocity in rectangle"""
    e = arcade.Emitter(center_xy=CENTER_POS,
                       emit_controller=arcade.EmitterIntervalWithTime(
                           DEFAULT_EMIT_INTERVAL, DEFAULT_EMIT_DURATION),
                       particle_factory=lambda emitter: arcade.
                       LifetimeParticle(filename_or_texture=TEXTURE,
                                        change_xy=arcade.rand_in_rect(
                                            (-2.0, -2.0), 4.0, 4.0),
                                        lifetime=DEFAULT_PARTICLE_LIFETIME,
                                        scale=DEFAULT_SCALE,
                                        alpha=DEFAULT_ALPHA))
    return emitter_21.__doc__, e
Exemplo n.º 20
0
def emitter_15():
    """Interval, emit from center, particle lifetime random in range"""
    e = arcade.Emitter(
        center_xy=CENTER_POS,
        emit_controller=arcade.EmitterIntervalWithTime(DEFAULT_EMIT_INTERVAL, DEFAULT_EMIT_DURATION),
        particle_factory=lambda emitter: arcade.LifetimeParticle(
            filename_or_texture=TEXTURE,
            change_xy=arcade.rand_in_circle((0.0, 0.0), PARTICLE_SPEED_FAST),
            lifetime=random.uniform(DEFAULT_PARTICLE_LIFETIME - 1.0, DEFAULT_PARTICLE_LIFETIME),
            scale=DEFAULT_SCALE,
            alpha=DEFAULT_ALPHA
        )
    )
    return emitter_15.__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
Exemplo n.º 22
0
def dash_emitter_factory(color, pos_a, pos_b):
    """Interval, emit on line"""
    logging.info("Creating dash emitter")

    if pos_a[0] > pos_b[0]:
        angle = 0
    else:
        angle = 180
    textures = [
        arcade.Texture(f"{time.time()}", Image.new("RGBA", (10, 10), p))
        for p in rand_color(color)
    ]
    line_e = arcade.Emitter(
        center_xy=(0.0, 0.0),
        emit_controller=arcade.EmitterIntervalWithTime(LINE_EMIT_INTERVAL,
                                                       DEFAULT_EMIT_DURATION),
        particle_factory=lambda emitter: arcade.LifetimeParticle(
            filename_or_texture=random.choice(textures),
            change_xy=arcade.rand_in_circle((0.0, 0.0), PARTICLE_SPEED_SLOW),
            lifetime=DEFAULT_PARTICLE_LIFETIME,
            center_xy=arcade.rand_on_line(pos_a, pos_b),
            scale=LINE_SCALE,
            alpha=DEFAULT_ALPHA,
        ),
    )
    exhaust_plume_e = arcade.Emitter(
        center_xy=pos_a,
        emit_controller=arcade.EmitterIntervalWithTime(PLUME_EMIT_INTERVAL,
                                                       PLUME_EMIT_DURATION),
        particle_factory=lambda emitter: arcade.FadeParticle(
            filename_or_texture=random.choice(textures),
            change_xy=arcade.rand_vec_spread_deg(angle, 25, 4.0),
            lifetime=PLUME_PARTICLE_LIFETIME,
            scale=PLUME_SCALE,
        ),
    )
    return line_e, exhaust_plume_e
Exemplo n.º 23
0
def emitter_19():
    """Interval, emit on line"""
    e = arcade.Emitter(
        center_xy=(0.0, 0.0),
        emit_controller=arcade.EmitterIntervalWithTime(DEFAULT_EMIT_INTERVAL, DEFAULT_EMIT_DURATION),
        particle_factory=lambda emitter: arcade.LifetimeParticle(
            filename_or_texture=TEXTURE,
            change_xy=arcade.rand_in_circle((0.0, 0.0), PARTICLE_SPEED_SLOW),
            lifetime=DEFAULT_PARTICLE_LIFETIME,
            center_xy=arcade.rand_on_line((0.0, 0.0), (SCREEN_WIDTH, SCREEN_HEIGHT)),
            scale=DEFAULT_SCALE,
            alpha=DEFAULT_ALPHA
        )
    )
    return emitter_19.__doc__, e
Exemplo n.º 24
0
def firework(position):
    x = position.x
    y = position.y

    return arcade.Emitter(
        center_xy=(x, y),
        change_xy=(0, 5),
        emit_controller=arcade.EmitterIntervalWithTime(emit_interval=0.1, lifetime=3),
        particle_factory=lambda emitter: arcade.FadeParticle(
            filename_or_texture=FIREWORK_PARTICLE,
            change_xy=arcade.rand_in_circle((0.0, 0.0), 1.0),
            lifetime=1.5,
            scale=0.5 * random.random(),
        ),
    )
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 emitter_18():
    """Interval, emit in rectangle"""
    width, height = 200, 100
    centering_offset = Vec2d(-width / 2, -height / 2)
    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_in_rect(centering_offset, width, height),
            scale=DEFAULT_SCALE,
            alpha=DEFAULT_ALPHA))
    return emitter_18.__doc__, e
def make_rocket(emit_done_cb):
    """Emitter that displays the smoke trail as the firework shell climbs into the sky"""
    rocket = RocketEmitter(
        center_xy=(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,
            change_xy=arcade.rand_in_circle((0.0, 0.0), 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
Exemplo n.º 28
0
def explosion(x, y):
    """ Create an explosion when crate destroyed """
    e = arcade.Emitter(
        center_xy=(x, y),
        emit_controller=arcade.EmitterIntervalWithTime(
            constants.DEFAULT_EMIT_INTERVAL * 1.25,
            constants.DEFAULT_EMIT_DURATION / 6),
        particle_factory=lambda emitter: arcade.LifetimeParticle(
            filename_or_texture=constants.E_TEXTURE,
            change_xy=arcade.rand_in_circle(
                (0.0, 0.0), constants.PARTICLE_SPEED_FAST * 6),
            lifetime=random.uniform(0.05, 1),
            scale=random.uniform(0.05, 0.3),
            alpha=random.uniform(64, 250),
            change_angle=random.uniform(-30, 30),
            angle=random.uniform(0, 360)))
    return e
Exemplo n.º 29
0
def make_interval_emitter(center_xy: Point,
                          filenames_and_textures: List[FilenameOrTexture],
                          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(
        center_xy=center_xy,
        emit_controller=arcade.EmitterIntervalWithTime(emit_interval,
                                                       emit_duration),
        particle_factory=lambda emitter: particle_factory(
            filename_or_texture=random.choice(filenames_and_textures),
            change_xy=arcade.rand_on_circle((0.0, 0.0), particle_speed),
            lifetime=random.uniform(particle_lifetime_min,
                                    particle_lifetime_max),
            scale=particle_scale))