def __init__(self,
bead_set,
color=_color.Color(),
speed=1,
length=1,
start_offset=0,
**kwargs):
super().__init__(name="ramp", bead_set=bead_set, color=color, **kwargs)
if len(bead_set) == 0:
self.r_delta = 0
self.g_delta = 0
self.b_delta = 0
self.a_delta = 0
else:
self.r_delta = (self.color.r - self.rosary.bgcolor.r) / len(
self.bead_list)
self.g_delta = (self.color.g - self.rosary.bgcolor.g) / len(
self.bead_list)
self.b_delta = (self.color.b - self.rosary.bgcolor.b) / len(
self.bead_list)
self.a_delta = (self.color.a - self.rosary.bgcolor.a) / len(
self.bead_list)
self.ramp_color = _color.Color()
self.ramp_color.set(self.rosary.bgcolor)
def __init__(self, bead_set, color=_color.Color(), direction=1, **kwargs):
super().__init__(name="roulette",
bead_set=bead_set,
color=color,
**kwargs)
#ring_set = self.rosary.set_registry('ring') & bead_set
length = 2
self.bin = bin.Bin(bead_set, rosary=self.rosary)
self.wheel = wheel.Wheel(
bead_set,
colors=[_color.Color(1, 0, 0),
_color.Color(0, 0, 0)],
length=length,
speed=0)
self.looper = looper.Looper(bead_set,
color=_color.Color(0, 1, 0),
length=length,
speed=0,
start_offset=1)
self.bin.add_effect_object(self.wheel)
self.bin.add_effect_object(self.looper)
self.set_speed(0.5)
def __init__(self, bead_set, color=_color.Color(), **kwargs):
bead_set = kwargs.get('rosary').set_registry['ring']
super().__init__(name="trigger_hijack_demo",
bead_set=bead_set,
color=color,
**kwargs)
# This effect uses 2 separate effects, so let's copy bin_demo.py
self.bin = bin.Bin(bead_set, rosary=self.rosary)
# If this were a game, this would be "the ball"
self.red_looper = looper.Looper(bead_set=bead_set,
color=_color.Color(1, 0, 0),
**kwargs)
self.bin.add_effect_object(self.red_looper)
# Specifically, if this were pong, these might be the "paddles"
self.hijacked_beads = set_color.SetColor(bead_set=frozenset(
[self.rosary.beads[11], self.rosary.beads[25]]),
color=_color.Color(1, 1, 1),
**kwargs)
self.bin.add_effect_object(self.hijacked_beads)
# NOTE: THIS IS THE MAIN ATTRACTION HERE!!!
self.trigger_hijacks = {
'left_nail': self.left_hijack,
'right_nail': self.right_hijack
}
# The base Effect class will check self.trigger_hijacks and
# modify the rosary's behavior
self.hijack_triggers()
def add_effect(self, *args, **kwargs):
"""
Expect kwargs to have all the effect initialization args.
If it doesn't, fail silently, but gracefully.
"""
effect_name = kwargs.get('name')
bead_set_name = kwargs.get('bead_set', 'rosary')
bead_set_sort = kwargs.get('bead_set_sort', 'cw')
# Accept either a color name or rgb values
color_name = kwargs.get('color', 'white')
r = kwargs.get('r', 0.0)
g = kwargs.get('g', 0.0)
b = kwargs.get('b', 0.0)
a = kwargs.get('a', 0.0)
# If you don't pass in a good name I'll pretend I didn't hear you
bead_set = self.set_registry.get(bead_set_name.lower(),
self.set_registry['all'])
if any([r, g, b]):
effect_color = color.Color(r, g, b, a)
else:
effect_color = self.color_registry.get(color_name.lower())
# If all else fails, just pick a random color from the registry
while effect_color in (None, color.Color(0, 0, 0)):
effect_color = random.choice(list(self.color_registry.values()))
# Whether we're overwriting the string or setting for the first time,
# it's all the same to us
kwargs['bead_set'] = bead_set
kwargs['color'] = effect_color
kwargs['bead_set_sort'] = bead_set_sort
# I'd rather be fancy and strip out kwargs that won't be accepted
# than force people writing effects to take **kwargs /flex
requested_effect = self.effect_registry.get(effect_name)
requested_effect_args = inspect.getargspec(requested_effect).args
# I don't want to add this to all the effects that are already written, but this
# solution feels like a gross hack
requested_effect_args.append('bead_set_sort')
# Er, "clean up" the kwargs to pass to an effect init method
for key in list(kwargs):
if key not in requested_effect_args:
kwargs.pop(key)
if requested_effect is not None:
effect_id = self.bin.add_effect_object(
requested_effect(*args, rosary=self, **kwargs))
self.expose_effect_knobs(requested_effect)
return effect_id
else:
return None
def __init__(self, bead_set, color=_color.Color(), **kwargs):
super().__init__(name="bin_demo", bead_set=bead_set, color=color, **kwargs)
self.count = 0
self.bin = bin.Bin(bead_set, rosary=self.rosary)
#self.bin = bin.Bin(bead_set)
self.looper1 = looper.Looper(bead_set, color=_color.Color(1, 0, 0), length=5, speed=0)
self.bin.add_effect_object(self.looper1)
self.bin.add_effect_object(looper.Looper(bead_set, color=_color.Color(0, 1, 0), length=4, speed=-.5))
self.bin.add_effect_object(sparkle.Sparkle(bead_set, color=_color.Color(1, 1, 1)))
self.speed_increment = .02
def __init__(self, bead_set, color=_color.Color(), **kwargs):
super().__init__(name="stigmata", bead_set=bead_set, color=color, **kwargs)
self.count = 0
self.bin = bin.Bin(bead_set, rosary=self.rosary)
self.bin.add_effect_object(
soft_edges_glow.Soft_Edges_Glow(
self.rosary.set_registry['stigmata_left'],
self.rosary.color_registry['red']))
self.bin.add_effect_object(
soft_edges_glow.Soft_Edges_Glow(
self.rosary.set_registry['stigmata_right'],
self.rosary.color_registry['red']))
self.bin.add_effect_object(
soft_edges_glow.Soft_Edges_Glow(
self.rosary.set_registry['stigmata_crown'],
self.rosary.color_registry['yellow']))
self.bin.add_effect_object(
soft_edges_glow.Soft_Edges_Glow(
self.rosary.set_registry['stigmata_left_foot'],
self.rosary.color_registry['red'], bead_set_sort = 'reverse'))
self.bin.add_effect_object(
soft_edges_glow.Soft_Edges_Glow(
self.rosary.set_registry['stigmata_right_foot'],
self.rosary.color_registry['red']))
def __init__(self,
bead_set,
color=color.Color(),
speed=.1,
initial_fires=1,
**kwargs):
super().__init__(name="fire_spreading",
bead_set=bead_set,
color=color,
**kwargs)
# I'm too scared to just remove the color arg, but in actuality
# I'm going to ignore whatever you pass and just set all beads
# to the same instance of the "fire" color
if self.rosary is not None:
self.color = self.rosary.color_registry['fire']
# NOTE: Speed here should definiltey be 0 < n < 1
# Even at speed 1, a bead's neighbours are 94% likely to be on fire
# after only 10 cycles (that's too fast!)
self.speed = speed
# Keep a mapping of how long each bead has been "on fire"
self.on_fire_cycles = {}
# To start, randomly light a bead on fire
# NOTE: During effect registration we get init'd with no bead_list
if len(self.bead_list) > 0:
for i in range(initial_fires):
some_bead_index = random.randrange(len(self.bead_list))
self.on_fire_cycles[some_bead_index] = 1
def __init__(self, bead_set, color=color.Color(), speed=1, **kwargs):
super().__init__(name="sweep",
bead_set=bead_set,
color=color,
**kwargs)
self.current = 0
self.speed = speed
def __init__(self, bead_set, color=_color.Color(1.0, 1.0, 1.0), **kwargs):
super().__init__(name="idle", bead_set=bead_set, color=color, **kwargs)
self.color = color
self.bin = bin.Bin(bead_set, rosary=self.rosary)
# define the trigger functions
self.trigger_hijacks = {
'left_nail': self.left_nail,
'right_nail': self.right_nail,
'bead': self.bead_trigger
}
self.hijack_triggers()
self.bead_effect = {}
for b in self.bead_list:
self.bead_effect[b.index] = None
# left and right nail flags
self.left_nail_isset = False
self.right_nail_isset = False
# left and right nail timers
self.left_nail_timer = time.time()
self.right_nail_timer = time.time()
self.left_nail_effect = None
self.right_nail_effect = None
def __init__(self, bead_set, color=color.Color(), **kwargs):
super().__init__(name="set_color_unique",
bead_set=bead_set,
color=color,
**kwargs)
# Give each bead its own copy of the color
self.bead_colors = [copy.copy(color) for b in bead_set]
def inner_fire(self):
bs = self.rosary.set_registry.get('all')
col = color.Color(0.3, 0.6, 0.9)
eff = bounce.Bounce(bead_set=bs, color=col)
eff.delay = 60
eff.fade_out(120.0)
self.rosary.add_effect_object(eff)
def inner_fire(self):
bounce1 = bounce.Bounce(self.rosary.set_registry.get('all'),
color.Color(1.0, 0.5, 0.7),
rosary=self.rosary,
duration=120)
# Shitty hack
bounce1.id = random.randrange(1000, 9999)
bounce2 = bounce.Bounce(self.rosary.set_registry.get('all'),
color.Color(0.8, 0.3, 0.5),
rosary=self.rosary,
duration=117,
delay=3)
bounce2.id = random.randrange(1000, 9999)
bounce3 = bounce.Bounce(self.rosary.set_registry.get('all'),
color.Color(0.8, 0.3, 0.5),
rosary=self.rosary,
duration=114,
delay=6)
bounce3.id = random.randrange(1000, 9999)
sinewav = sine_wave.SineWave(self.rosary.set_registry.get('all'),
color.Color(0.0, 0.3, 0.3),
rosary=self.rosary,
duration=120,
delay=75)
sinewav.id = random.randrange(1000, 9999)
threeps = sine_wave.ThreePhaseSineWave(self.rosary.set_registry.get('all'),
color.Color(1.0, 1.0, 1.0),
rosary=self.rosary,
duration=180,
delay=210)
threeps.id = random.randrange(1000, 9999)
self.rosary.add_effect_object(bounce1)
self.rosary.add_effect_object(bounce2)
self.rosary.add_effect_object(bounce3)
self.rosary.add_effect_object(sinewav)
self.rosary.add_effect_object(threeps)
def __init__(self, bead_set, color=_color.Color(), **kwargs):
super().__init__(name="test", bead_set=bead_set, color=color, **kwargs)
self.bin = bin.Bin(bead_set, rosary=self.rosary)
self.color = _color.Color(1, 1, 1)
self.supply_effect = {}
self.all_effect = None;
self.cross_effect = {}
self.spot_effect = {}
# define the trigger functions
self.trigger_hijacks = {
'test_supply': self.test_supply,
'test_color': self.test_color,
'test_all': self.test_all,
'test_cross': self.test_cross,
'test_spots': self.test_spots
}
self.hijack_triggers()
def __init__(self, bead_set, color=color.Color(), **kwargs):
super().__init__(name="level",
bead_set=bead_set,
color=color,
**kwargs)
self.level = 0
self.max_level = len(self.bead_list)
self.kick_up = 3
self.kick_down = 0.4
def __init__(self, bead_set, color=color.Color(), **kwargs):
super().__init__(name="sine_wave_evolve",
bead_set=bead_set,
color=color,
**kwargs)
self.period_delta = .01
self.period_max = 6
self.bin = bin.Bin(bead_set, rosary=self.rosary)
self.sine_wave = ThreePhaseSineWave(bead_set, color=color)
self.bin.add_effect_object(self.sine_wave)
def __init__(self, bead_set, color=color.Color(), speed=1, length=1, **kwargs):
super().__init__(name="bounce", bead_set=bead_set, color=color, **kwargs)
self.speed = speed
self.length = length
if self.length > len(self.bead_list):
self.length = len(self.bead_list)
if self.speed < 0:
self.current = len(self.bead_list) - self.length
else:
self.current = self.length
def __init__(self, bead_set, color=_color.Color(), direction=1, **kwargs):
super().__init__(name="cop_lights",
bead_set=bead_set,
color=color,
**kwargs)
self.bin = bin.Bin(bead_set, rosary=self.rosary)
self.bin.add_effect_object(
looper.Looper(bead_set, color=_color.Color(1, 0, 0), length=6))
self.bin.add_effect_object(
looper.Looper(bead_set,
color=_color.Color(1, 0, 0),
length=6,
speed=-0.5))
self.bin.add_effect_object(
looper.Looper(bead_set,
color=_color.Color(0, 0, 1),
length=6,
speed=-0.5,
start_offset=20))
self.bin.add_effect_object(
looper.Looper(bead_set,
color=_color.Color(0, 0, 1),
length=6,
start_offset=20))
self.bin.add_effect_object(
strobe.Strobe(bead_set, color=_color.Color(1, 1, 1)))
def __init__(self,
bead_set,
color=color.Color(1, 1, 1),
period=1,
direction=1,
**kwargs):
super().__init__(name="sine_wave",
bead_set=bead_set,
color=color,
**kwargs)
self.offset = 0
self.period = period
self.direction = direction
def next(self):
self.bin.next()
# I RAN OUT OF LYRICS, BUT HOW 'BOUT SOME FIREWORKS
if random.random() > .99:
if random.random() > .5:
direction = "cw"
else:
direction = "ccw"
firework_color = random.choice([
_color.Color(1, 0, 0, .7),
_color.Color(1, 1, 1, .7),
_color.Color(0, 0, 1, .7)
])
fw = firework.Firework(bead_set=self.rosary.\
set_registry['rosary'],
color=firework_color,
rosary=self.rosary,
direction=direction)
self.bin.add_effect_object(fw)
def __init__(self,
bead_set,
color=color.Color(),
speed=0.5,
length=3,
start_offset=0,
colors=[color.Color(0, 0, 0),
color.Color(1, 1, 1)],
**kwargs):
super().__init__(name="wheel",
bead_set=bead_set,
color=color,
**kwargs)
self.current = start_offset
self.speed = speed
self.length = length
self.colors = colors
# make sure we don't exceed our limits
if self.current > len(self.bead_list):
self.current = len(self.bead_list)
if self.length > len(self.bead_list):
self.length = len(self.bead_list)
def __init__(self,
bead_set,
color=color.Color(),
period=1,
step=.05,
offset=0.0,
**kwargs):
super().__init__(name="throb",
bead_set=bead_set,
color=color,
**kwargs)
#self.x = 0.0
self.x = float(offset)
self.period = period
self.step = step
def __init__(self,
bead_set,
color=color.Color(),
speed=1,
parabolic=True,
once=False,
**kwargs):
super().__init__(name="risefall",
bead_set=bead_set,
color=color,
**kwargs)
self.speed = speed
self.speed_delta = 0
self.parabolic = parabolic
self.once = once
self.current = 0
def __init__(self,
bead_set,
color=color.Color(),
duration=None,
size=1,
speed=2,
**kwargs):
super().__init__(name="sparkle",
bead_set=bead_set,
color=color,
duration=duration,
**kwargs)
self.speed = speed
self.size = size
self.count = 0
self.bead_set = bead_set # use a set intead of ordered list
random.seed()
def __init__(self,
bead_set,
color=color.Color(),
duration=None,
size=1,
speed=2,
**kwargs):
super().__init__(name="random_fill",
bead_set=bead_set,
color=color,
duration=duration,
**kwargs)
self.speed = speed
self.size = size
self.count = 0
self.remaining = set(bead_set)
random.seed()
self.current = set()
def __init__(self,
bead_set,
color=color.Color(),
duration=None,
speed=1,
**kwargs):
super().__init__(name="casino",
bead_set=bead_set,
color=color,
duration=duration,
**kwargs)
self.set_speed(speed)
if (self.speed < 0):
self.current = len(self.bead_list) - 1
else:
self.current = 0
self.end_position = len(self.bead_list) - 1
def __init__(self,
bead_set,
color=color.Color(),
speed=1,
length=1,
start_offset=0,
**kwargs):
super().__init__(name="launcher",
bead_set=bead_set,
color=color,
**kwargs)
self.my_bead_set = bead_set
self.looper = looper.Looper(bead_set,
color=color,
speed=speed,
length=length,
**kwargs)
self.in_stem = True
def __init__(self,
bead_set,
color=color.Color(1, 1, 1),
duration=None,
ym=1,
k=.25,
w=1,
**kwargs):
super().__init__(name='vibration_fixed',
bead_set=bead_set,
color=color,
duration=duration)
self.ym = ym
self.k = k
self.w = w
self.t = 0
self.max = 0
self.min = 0
self.t = 0
def __init__(self,
bead_set,
color=color.Color(),
speed=1,
length=1,
start_offset=0,
**kwargs):
super().__init__(name="looper",
bead_set=bead_set,
color=color,
**kwargs)
self.current = start_offset
self.speed = speed
self.length = length
# make sure we don't exceed our limits
if self.current > len(self.bead_list):
self.current = len(self.bead_list)
if self.length > len(self.bead_list):
self.length = len(self.bead_list)
def __init__(self,
bead_set,
color=color.Color(),
speed=1,
length=1,
parabolic=False,
**kwargs):
super().__init__(name="shooter",
bead_set=bead_set,
color=color,
**kwargs)
self.speed = speed
self.length = length
self.parabolic = parabolic
self.speed_delta = 0
if self.length > len(self.bead_list):
self.length = len(self.bead_list)
if self.speed < 0:
self.current = len(self.bead_list) - 1
else:
self.current = self.length
def __init__(self,
bead_set,
color=color.Color(),
duration=None,
size=1,
speed=2,
acceleration=None,
**kwargs):
super().__init__(name="random_fill",
bead_set=bead_set,
color=color,
duration=duration,
**kwargs)
self.speed = speed
self.size = size
# It gets pretty tedious waiting for this thing to finish
# Also it seems lower numbers 0...1 are faster
self.acceleration = acceleration
self.count = 0
self.remaining = set(bead_set)
random.seed()
self.current = set()
