def __init__(self, grass, props):
GrassAnimation.__init__(self, grass, props)
self.effects = []
self.on_time_percent = 0.5
self.hue = 0.33
self.pixel_hue = 0.7
self.brightness = 1.0
if self.props != None:
if 'on_time_percent' in self.props:
self.on_time_percent = self.props['on_time_percent']
if 'hue_start' in self.props:
self.hue = self.props['hue_start']
if 'pixel_hue' in self.props:
self.pixel_hue = self.props['pixel_hue']
if 'brightness' in self.props:
self.brightness = self.props['brightness']
max_height = 0
for leaf in self.grass.get_leaves_array():
max_height = max(max_height, len(leaf[0]))
max_height = max(max_height, len(leaf[1]))
for leaf in self.grass.get_leaves_array():
rand_leaf_color = Colors.hls_to_rgb(
self.hue, random.uniform(0.6, 1),
random.uniform(0.2, self.brightness))
pixel_color = Colors.hls_to_rgb(self.pixel_hue, 1.0, 1.0)
self.effects.append(
SinglePixelEffect(leaf[0], rand_leaf_color, pixel_color,
max_height * (1 + self.on_time_percent)))
self.effects.append(
SinglePixelEffect(leaf[1][::-1], rand_leaf_color, pixel_color,
max_height * (1 + self.on_time_percent)))
def create_effects(self):
self.effects = []
color1 = Colors.hls_to_rgb(self.hue1, 1, 1)
color2 = Colors.hls_to_rgb(self.hue2, 1, 1)
self.effects.append(AlternateColorEvery3Effect(self.sheep.body, color1, color2))
self.effects.append(AlwaysOnEffect(self.sheep.head + self.sheep.legs, color1))
self.effects.append(AlwaysOnEffect(self.sheep.eyes, color2))
def create_effects(self):
self.effects = []
color1 = Colors.hls_to_rgb(self.hue1, 1, 1)
color2 = Colors.hls_to_rgb(self.hue2, 1, 1)
for l in self.grass.get_leaves_array():
self.effects.append(AlternateColorEvery3Effect(l[0], color1, color2))
self.effects.append(AlternateColorEvery3Effect(l[1][:], color1, color2))
def create_effects(self):
self.effects = []
hue = random.random()
for leaf in self.tree.get_leaves_and_stem():
self.effects.append(
SinglePixelEffect(leaf[0][::-1], [0, 0, 0],
Colors.hls_to_rgb(hue, 1.0, 1.0),
len(leaf[0])))
self.effects.append(
SinglePixelEffect(leaf[1][::-1], [0, 0, 0],
Colors.hls_to_rgb(hue, 1.0, 1.0),
len(leaf[1])))
def next_hue(self):
self.effects = []
new_hue = self.hue + self.hue_speed
if new_hue > 1 : new_hue -= 1
prev_color = Colors.hls_to_rgb(self.hue, 1.0, 1.0)
new_color = Colors.hls_to_rgb(new_hue, 1.0, 1.0)
self.effects.append(GoToColorEffect(self.flower.get_leaves() + self.flower.seeds, prev_color, new_color))
self.hue = new_hue
self.effects.append(AlwaysOnEffect(self.flower.line, [50, 200, 0]))
self.effects.append(AlwaysOnEffect(self.flower.leaves, [0, 200, 0]))
def create_effects(self):
self.effects = []
color1 = Colors.hls_to_rgb(self.hue1, 1, 1)
color2 = Colors.hls_to_rgb(self.hue2, 1, 1)
self.effects.append(
AlternateColorEvery3Effect(self.flower.bottom_parts, color1,
color2))
self.effects.append(
AlternateColorEvery3Effect(self.flower.get_leaves(), color1,
color2))
self.effects.append(AlwaysOnEffect(self.flower.seeds, color1))
def apply_animation(ui_element, num_of_beats, duration, relative_song_time): beat_duration = duration/num_of_beats beats_played = math.floor(relative_song_time / beat_duration) relative_beat_time = relative_song_time - beat_duration * beats_played percent_beat_time = relative_beat_time / beat_duration if beats_played % 2 == 0: color = Colors.hls_to_rgb(hue, 1 ,1) else: color = Colors.hls_to_rgb(hue + 0.1, 1 ,1) for i in range(len(ui_element.get_array())/3): ui_element.get_array()[i*3 : i*3+3] = color
def _start_spike(self):
self.effects = []
self.last_hue += self.hue_speed
if self.last_hue > 1:
self.last_hue -= 1
rand_color = Colors.hls_to_rgb(self.last_hue, 1.0, 1.0)
self.effects.append(AlwaysOnEffect(self.lake.waves_arr[self.last_wave], rand_color))
contour_color = Colors.hls_to_rgb(self.last_hue, 0.5, 0.7)
self.effects.append(AlwaysOnEffect(self.lake.contour, contour_color))
self.last_wave += 1
if self.last_wave >= len(self.lake.waves_arr):
self.last_wave = 0
def create_bottom_animation(self):
self.effects = []
hue = self.previous_hue + 0.1 + random.random() * 0.8
if hue > 1: hue -= 1
self.previous_hue = hue
self.previous_color = self.color
self.color = Colors.hls_to_rgb(hue, 1, 1)
self.effects.append(
AdvanceEffect.initColor(self.flower.line_back, self.previous_color,
self.color))
self.effects.append(
AdvanceEffect.initColor(self.flower.line_front,
self.previous_color, self.color))
self.effects.append(
AdvanceEffect.initColor(self.flower.leaf_right_front,
self.previous_color, self.color))
self.effects.append(
AdvanceEffect.initColor(self.flower.leaf_right_back,
self.previous_color, self.color))
self.effects.append(
AdvanceEffect.initColor(self.flower.leaf_left_front,
self.previous_color, self.color))
self.effects.append(
AdvanceEffect.initColor(self.flower.leaf_left_back,
self.previous_color, self.color))
self.effects.append(
AlwaysOnEffect(self.flower.seeds, self.previous_color))
self.effects.append(
AlwaysOnEffect(self.flower.get_leaves(), self.previous_color))
def add_effect_for_index(self, index, location_percent):
start_t = random.uniform(0.0, 0.4)
dark_time = 1.0 - random.uniform(0.00, 0.4)
on_tot_time = dark_time - start_t
on_start_t = start_t + random.uniform(0.1, on_tot_time / 2.0)
on_end_t = dark_time - random.uniform(0.1, on_tot_time / 2.0)
rgb_color = Colors.hls_to_rgb(random.random(), random.uniform(0, 0.5), 1.0)
self.effects.append(
StarEffect([index], ConstTimedColor(rgb_color), start_t, on_start_t, on_end_t, dark_time, location_percent))
def apply(self, parent_array):
for i in range(len(self.indexes)):
# color
hue = (i / float(len(self.indexes)) * self.num_of_rainbows) % 1
color = Colors.hls_to_rgb(hue, self.max_brightness, 1.0)
index = self.indexes[i]
parent_array[index * 3:index * 3 + 3] = color
def next_hue(self):
self.effects = []
new_hue = self.hue + self.hue_speed
if new_hue > 1: new_hue -= 1
if self.full_color == True:
prev_color = Colors.hls_to_rgb(self.hue, 1.0, 1.0)
new_color = Colors.hls_to_rgb(new_hue, 1.0, 1.0)
else:
prev_color = Colors.hls_to_rgb(self.hue, 0.5, 0.7)
new_color = Colors.hls_to_rgb(new_hue, 0.5, 0.7)
if self.animated == True:
self.effects.append(
GoToColorEffect(self.sign.whole_sign, prev_color, new_color))
else:
self.effects.append(AlwaysOnEffect(self.sign.whole_sign,
new_color))
self.hue = new_hue
def apply(self, is_change, parent_array):
# change hue
if (is_change):
self.current_hue = (self.current_hue + self.diff) % 1
# color
color = Colors.hls_to_rgb(self.current_hue, self.max_brightness, 1.0)
# apply
for i in self.indexes:
parent_array[i * 3:i * 3 + 3] = color
def apply(self, time_percent, parent_array):
if time_percent < self.last_time_percent:
self.eq_start = random.uniform(0.2, 0.7)
self.last_time_percent = time_percent
percent = (self.eq_start + random.uniform(-0.00, 0.00)) + (
(self._global_value(time_percent) - 0.2) * 0.5)
percent = max(percent, 0.0)
percent = min(percent, 1.0)
self.curr_pos = self.curr_pos + min(
(percent - self.curr_pos) * 0.4, int(len(self.indexes) * 0.03))
v = int(len(self.indexes) * self.curr_pos)
""" fade to black """
for i in range(0, v):
obj_pixel = self.indexes[i]
parent_array[3 * obj_pixel:3 * obj_pixel + 3] = Colors.hls_to_rgb(
self.hue1, 1.0, self.brightness)
for i in range(v, len(self.indexes)):
obj_pixel = self.indexes[i]
parent_array[3 * obj_pixel:3 * obj_pixel + 3] = Colors.hls_to_rgb(
self.hue2, 1.0, self.brightness)
def apply(self, time_percent):
if time_percent < 0.5:
c = time_percent * 0.25
else:
c = (1.0 - time_percent) * 0.25
c = c + 0.01
c = math.pow(c, 0.5)
for letter_index in range(0, len(self.sign.get_letters())):
letter = self.sign.get_letters()[letter_index]
hue = self.hues[letter_index]
for i in letter:
self.sign.get_array()[i * 3:i * 3 + 3] = Colors.hls_to_rgb(
hue, 1.0, c)
def _start_spike(self):
self.effects = []
self.last_hue += self.hue_speed
if self.last_hue > 1:
self.last_hue -= 1
rand_color = Colors.hls_to_rgb(self.last_hue, 1.0, 1.0)
new_animation = AlwaysOnEffect(
self.grass.get_leaves_array()[self.last_leaf][0] +
self.grass.get_leaves_array()[self.last_leaf][1], rand_color)
self.effects.append(new_animation)
self.last_leaf += 1
if self.last_leaf >= len(self.grass.get_leaves_array()):
self.last_leaf = 0
def __init__(self, lake, props):
LakeAnimation.__init__(self, lake, props)
self.effects = []
self.brightness = 0.2
self.hue1 = 0.7
self.hue2 = 0.8
if self.props != None:
if 'hue1' in self.props:
self.hue1 = self.props['hue1']
if 'hue2' in self.props:
self.hue2 = self.props['hue2']
if 'brightness' in self.props:
self.brightness = self.props['brightness']
for i in range(0, len(self.lake.waves_arr)):
w = self.lake.waves_arr[i]
self.effects.append(
EqEffect(w,
brightness=self.brightness,
hue1=self.hue1,
hue2=self.hue2))
#the lake segments between the waves
for i in range(1, len(self.lake.waves_arr)):
high_start = self.lake.conn_arr[i][0]
high_end = self.lake.conn_arr[i - 1][0]
if high_start < high_end:
high_indexes = range(high_start, high_end)
else:
high_indexes = range(
high_start, self.lake.contour[-1]) + range(0, high_end)
low_indexes = range(self.lake.conn_arr[i - 1][1],
self.lake.conn_arr[i][1])
self.effects.append(
AlwaysOnEffect(
high_indexes,
Colors.hls_to_rgb(self.hue1, 1.0, self.brightness)))
self.effects.append(
AlwaysOnEffect(
low_indexes,
Colors.hls_to_rgb(self.hue2, 1.0, self.brightness)))
#make nice transitions in the corners
self.effects.append(
GradientEffect(
range(self.lake.conn_arr[0][0], self.lake.conn_arr[0][1]),
Colors.hls_to_rgb(self.hue1, 1.0, self.brightness),
Colors.hls_to_rgb(self.hue2, 1.0, self.brightness)))
self.effects.append(
GradientEffect(
range(self.lake.conn_arr[12][1], self.lake.conn_arr[12][0]),
Colors.hls_to_rgb(self.hue2, 1.0, self.brightness),
Colors.hls_to_rgb(self.hue1, 1.0, self.brightness)))
def _restart(self):
self.effects = []
self.effects.append(AlwaysOnEffect(self.tree.get_stem(),
[133, 87, 35]))
self.last_hue += self.hue_speed
if self.last_hue > 1:
self.last_hue -= 1
rand_color = Colors.hls_to_rgb(self.last_hue, 1.0, 1.0)
arr = self.tree.get_leaves_array()
self.effects.append(AlwaysOnEffect(arr[self.last_leaf][0], rand_color))
self.effects.append(AlwaysOnEffect(arr[self.last_leaf][1], rand_color))
self.last_leaf += 1
if self.last_leaf >= len(arr):
self.last_leaf = 0
def __init__(self, lake, props):
LakeAnimation.__init__(self, lake, props)
self.effects = []
self.previous_time = 1
self.hue = 0.67
if self.props != None:
if 'hue_start' in self.props:
self.hue = self.props['hue_start']
self.base_effect = AlwaysOnEffect(self.lake.whole_lake, Colors.hls_to_rgb(self.hue, 1, 1))
self.start_times = []
self.speeds = []
self.create_effects()
def apply(self, time_percent):
if (time_percent < self.previous_time):
self.effects = []
if self.frame_counter % 2 == 0:
hue = self.previous_hue + 0.1 + random.random() * 0.8
if hue > 1: hue -= 1
self.previous_hue = hue
self.previous_color = self.color
self.color = Colors.hls_to_rgb(hue, 1, 1)
self.effects.append(
AdvanceEffect.initColor(self.tree.get_right_stem(),
self.previous_color, self.color))
self.effects.append(
AdvanceEffect.initColor(self.tree.get_left_stem(),
self.previous_color, self.color))
for leaf in self.tree.get_leaves_array():
self.effects.append(
AlwaysOnEffect(leaf[0], self.previous_color))
self.effects.append(
AlwaysOnEffect(leaf[1], self.previous_color))
if self.frame_counter % 2 == 1:
self.effects.append(
AlwaysOnEffect(self.tree.get_right_stem(), self.color))
self.effects.append(
AlwaysOnEffect(self.tree.get_left_stem(), self.color))
for leaf in self.tree.get_leaves_array():
self.effects.append(
AdvanceEffect.initColor(leaf[0][::-1],
self.previous_color,
self.color))
self.effects.append(
AdvanceEffect.initColor(leaf[1][::-1],
self.previous_color,
self.color))
self.frame_counter += 1
for effect in self.effects:
effect.apply(time_percent, self.tree.get_array())
self.previous_time = time_percent
def _start_spike(self):
self.effects = []
self.last_hue += self.hue_speed
if self.last_hue > 1:
self.last_hue -= 1
rand_color = Colors.hls_to_rgb(self.last_hue, 1.0, 1.0)
self.effects.append(
AlwaysOnEffect(self.flower.get_leaves_array()[self.last_leaf],
rand_color))
self.effects.append(AlwaysOnEffect(self.flower.seeds, rand_color))
self.effects.append(
AlwaysOnEffect(self.flower.bottom_parts, rand_color))
self.last_leaf += 1
if self.last_leaf >= len(self.flower.get_leaves_array()):
self.last_leaf = 0
def apply_animation(self, song_time):
if self.time_stamps and song_time > self.time_stamps[0][0]:
sheep.clear()
flower.clear()
label = self.time_stamps[0][1]
if label == "H":
self.s_effects = [
AlwaysOnEffect(
sheep.get_head_indexes() + sheep.get_ears_indexes(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.f_effects = [
AlwaysOnEffect(self.flower.get_seeds(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
elif label == "BP":
self.s_effects = [
AlwaysOnEffect(sheep.get_body_part_indexes(self.body_part),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.f_effects = [
AlwaysOnEffect(self.flower.get_leaves_array()[self.leaf],
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.body_part = (self.body_part + self.body_part_dir)
if self.body_part == self.sheep.get_num_of_body_parts() - 1:
self.body_part_dir = -1
elif self.body_part == 0:
self.body_part_dir = 1
self.leaf = (self.leaf + 1) % len(
self.flower.get_leaves_array())
elif label == "L1":
self.s_effects = [
AlwaysOnEffect(sheep.get_leg12_indexes(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.f_effects = [
AlwaysOnEffect(self.flower.get_left_leaf(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
#self.f_effects = [
# AlwaysOnEffect(self.flower.get_left_leaf(), Colors.hls_to_rgb(0.0, 1.0, 1.0))
#]
self.hue = (self.hue + 0.3) % 1
elif label == "L2":
self.s_effects = [
AlwaysOnEffect(sheep.get_leg34_indexes(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.f_effects = [
AlwaysOnEffect(self.flower.get_right_leaf(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.hue = (self.hue + 0.3) % 1
elif label == "W":
self.s_effects = [
AlwaysOnEffect(sheep.get_all_indexes(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.f_effects = [
AlwaysOnEffect(self.flower.get_all_indexes(),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
else:
print "unknown label: " + label
self.s_effects = [
AlwaysOnEffect(sheep.get_body_part_indexes(self.body_part),
Colors.hls_to_rgb(self.hue, 1.0, 1.0))
]
self.body_part = (self.body_part +
1) % self.sheep.get_num_of_body_parts()
self.hue = (self.hue + 0.05) % 1
self.curr_effect_start = self.time_stamps[0][0]
del self.time_stamps[0]
self.curr_effect_time = (
self.time_stamps[0][0] -
self.curr_effect_start) if len(self.time_stamps) > 0 else 1
time_percent = (song_time -
self.curr_effect_start) / self.curr_effect_time
for e in self.s_effects:
e.apply(time_percent, sheep.get_array())
for e in self.f_effects:
e.apply(time_percent, flower.get_array())
def create_effects(self):
self.effects = []
color1 = Colors.hls_to_rgb(self.hue1, 1, 1)
color2 = Colors.hls_to_rgb(self.hue2, 1, 1)
self.effects.append(AlternateColorEvery3Effect(self.tree.get_all_indexes(), color1, color2))
def createEffects(self):
one = self.flower.l1 + self.flower.l3 + self.flower.l5 + self.flower.l7 + self.flower.l9
two = self.flower.l8 + self.flower.l10 + self.flower.l2 + self.flower.l4 + self.flower.l6
self.effects = []
self.effects.append(RainbowEffect(one[::-1]))
self.effects.append(RainbowEffect(two))
seeds_order = self.flower.seeds[:]
random.shuffle(seeds_order)
self.effects.append(RainbowEffect(seeds_order))
if self.frame_counter % 2 == 0:
self.hue = random.random()
color = Colors.hls_to_rgb(self.hue, 1, 1)
light_color = [x * 0.2 for x in color]
gradient1_front = Colors.gradient_array(light_color, color,
len(self.flower.line_front), 4)
gradient2_front = Colors.gradient_array([30, 30, 30], [100, 100, 100],
len(self.flower.line_front), 4)
gradient1_back = Colors.gradient_array(light_color, color,
len(self.flower.line_back), 4)
gradient2_back = Colors.gradient_array([30, 30, 30], [100, 100, 100],
len(self.flower.line_back), 4)
if self.frame_counter % 2 == 0:
self.effects.append(
GoToColorsEffect(self.flower.line_front, gradient2_front,
gradient1_front))
self.effects.append(
GoToColorsEffect(self.flower.line_back, gradient2_back,
gradient1_back))
else:
self.effects.append(
GoToColorsEffect(self.flower.line_front, gradient1_front,
gradient2_front))
self.effects.append(
GoToColorsEffect(self.flower.line_back, gradient1_back,
gradient2_back))
gradient1_leaf1 = Colors.gradient_array(
light_color, color,
len(self.flower.leaf_right_front + self.flower.leaf_right_back), 4)
gradient2_leaf1 = Colors.gradient_array(
[30, 30, 30], [100, 100, 100],
len(self.flower.leaf_right_front + self.flower.leaf_right_back), 4)
gradient1_leaf2 = Colors.gradient_array(
light_color, color,
len(self.flower.leaf_left_front + self.flower.leaf_left_back), 4)
gradient2_leaf2 = Colors.gradient_array(
[30, 30, 30], [100, 100, 100],
len(self.flower.leaf_left_front + self.flower.leaf_left_back), 4)
if self.frame_counter % 2 == 0:
self.effects.append(
GoToColorsEffect(
self.flower.leaf_right_front + self.flower.leaf_right_back,
gradient2_leaf1, gradient1_leaf1))
self.effects.append(
GoToColorsEffect(
self.flower.leaf_left_front + self.flower.leaf_left_back,
gradient2_leaf2, gradient1_leaf2))
else:
self.effects.append(
GoToColorsEffect(
self.flower.leaf_right_front + self.flower.leaf_right_back,
gradient1_leaf1, gradient2_leaf1))
self.effects.append(
GoToColorsEffect(
self.flower.leaf_left_front + self.flower.leaf_left_back,
gradient1_leaf2, gradient2_leaf2))
