def __init__(self):
self.smallSheep = SmallSheep()
self.bigSheep12 = BigSheep12()
self.bigSheep34 = BigSheep34()
self.signs = Signs()
self.flower = Flower()
self.current_block_num = -1
self.animations = []
self.plan = []
self.cycle_num = 0
def __init__(self):
self.start_time = datetime.datetime.now()
self.flower = Flower()
self.sheep = SmallSheep()
self.grass = Grass()
self.sign = Sign()
self.lake = Lake()
self.tree = Tree()
self.temp_stick = TempStick()
self.temp_stick.set_is_on(True)
self.sachi_meter = SachiMeter()
self.flower_animation = GlowFlowerAnimation(self.flower)
self.grass_animation = GlowGrassAnimation(self.grass)
self.lake_animation = GlowAnimation(self.lake, [0, 0, 255])
self.sheep_animation = GlowSheepAnimation(self.sheep)
self.sign_animation = GlowSignAnimation(self.sign)
self.tree_animation = GlowTreeAnimation(self.tree)
def __init__(self, file_name):
self.file_name = file_name
self.flower_animation = None
self.flower_animation_mul = 1
self.grass_animation = None
self.grass_animation_mul = 1
self.lake_animation = None
self.lake_animation_mul = 1
self.sheep_animation = None
self.sheep_animation_mul = 1
self.sign_animation = None
self.sign_animation_mul = 1
self.tree_animation = None
self.tree_animation_mul = 1
self.flower = Flower()
self.sheep = SmallSheep()
self.grass = Grass()
self.sign = Sign()
self.lake = Lake()
self.tree = Tree()
self.temp_stick = TempStick()
self.sachi_meter = SachiMeter()
with open(self.file_name, 'r') as f:
self.song_yml = yaml.load(f)
self.audio_file = "Music/" + self.song_yml['file_name']
self.pieces = self.song_yml['pieces']
self.current_piece_id = 0
self.offset = self.song_yml['offset']
self.is_transition = 'Transitions' in self.audio_file
self.temp_stick.set_is_on(self.is_transition)
self.temp_stick.set_brightness(1.0 if self.is_transition else 0.15)
print str(self.pieces[self.current_piece_id][0]) + " - " + str(
self.pieces[self.current_piece_id][1])
self.create_animations(self.pieces[self.current_piece_id][2])
class TransitionsDriver:
def __init__(self):
self.start_time = datetime.datetime.now()
self.flower = Flower()
self.sheep = SmallSheep()
self.grass = Grass()
self.sign = Sign()
self.lake = Lake()
self.tree = Tree()
self.temp_stick = TempStick()
self.temp_stick.set_is_on(True)
self.sachi_meter = SachiMeter()
self.flower_animation = GlowFlowerAnimation(self.flower)
self.grass_animation = GlowGrassAnimation(self.grass)
self.lake_animation = GlowAnimation(self.lake, [0, 0, 255])
self.sheep_animation = GlowSheepAnimation(self.sheep)
self.sign_animation = GlowSignAnimation(self.sign)
self.tree_animation = GlowTreeAnimation(self.tree)
def play_animations(self, curr_temerature, sachi_meter, input_type):
diff_time = (datetime.datetime.now() - self.start_time).total_seconds()
time_percent = (diff_time % 3.0) / 3.0
self.temp_stick.set_is_input_mode(
input_type == Decisions.InputType.TEMPERATURE)
self.sachi_meter.set_is_input_mode(
input_type == Decisions.InputType.SACHI)
self.sheep_animation.set_is_input_mode(
input_type == Decisions.InputType.SACHI)
self.flower_animation.apply(time_percent)
self.grass_animation.apply(time_percent)
self.lake_animation.apply(time_percent)
self.sheep_animation.apply(time_percent)
self.sign_animation.apply(time_percent)
self.tree_animation.apply(time_percent)
self.temp_stick.set_temperature(time_percent, curr_temerature)
self.sachi_meter.set_sachi_meter(time_percent, sachi_meter)
network.send(flower_data=self.flower.get_array(),
sheep_data=self.sheep.get_array(),
grass_data=self.grass.get_array(),
sign_data=self.sign.get_array(),
lake_data=self.lake.get_array(),
temp_stick=self.temp_stick.get_array(),
sachi_meter=self.sachi_meter.get_array(),
tree_data=self.tree.get_array())
class Song(object):
def __init__(self):
self.smallSheep = SmallSheep()
self.bigSheep12 = BigSheep12()
self.bigSheep34 = BigSheep34()
self.signs = Signs()
self.flower = Flower()
self.current_block_num = -1
self.animations = []
self.plan = []
self.cycle_num = 0
def play(self, pos=0):
cycle_num = 0
pygame.mixer.init()
pygame.mixer.music.load(self.file)
pygame.mixer.music.play(0, pos)
clock = pygame.time.Clock()
while pygame.mixer.music.get_busy():
song_time = pygame.mixer.music.get_pos()
#song_time = song_time/1000.0
song_time = max(song_time / 1000.0 - 0.6, 0)
self.apply_animations(song_time)
networking.send(cycle_num, self.smallSheep.get_array(),
self.bigSheep12.get_array(),
self.bigSheep34.get_array(),
self.signs.get_array(), self.flower.get_array())
clock.tick(50)
cycle_num += 1
def apply_animations(self, current_time):
#calculate current block
block_num = -1
for i in range(len(self.plan)):
block = self.plan[i]
start_time = block[0]
end_time = block[0] + block[3]
if current_time >= start_time and current_time < end_time:
block_num = i
current_block = self.plan[block_num]
if (block_num != self.current_block_num):
self.current_block_num = block_num
print str(block_num) + " - " + str(current_block)
self.show_random_animation(current_block)
#self.show_fade_in_out_animation(current_block)
percent = (current_time - current_block[0]) / current_block[3]
for animation in self.animations:
animation.apply(percent)
if (block_num == len(self.plan) - 1):
# fade out - end of the song
power = float(max(1 - percent * 2, 0))
print "fade_out " + str(power)
data = self.smallSheep.get_array() + self.bigSheep12.get_array(
) + self.bigSheep34.get_array() + self.signs.get_array(
) + self.flower.get_array()
for i in range(len(self.smallSheep.get_array())):
self.smallSheep.get_array()[i] = int(
math.floor(self.smallSheep.get_array()[i] * power))
for i in range(len(self.bigSheep12.get_array())):
self.bigSheep12.get_array()[i] = int(
math.floor(self.bigSheep12.get_array()[i] * power))
for i in range(len(self.bigSheep34.get_array())):
self.bigSheep34.get_array()[i] = int(
math.floor(self.bigSheep34.get_array()[i] * power))
for i in range(len(self.signs.get_array())):
self.signs.get_array()[i] = int(
math.floor(self.signs.get_array()[i] * power))
for i in range(len(self.flower.get_array())):
self.flower.get_array()[i] = int(
math.floor(self.flower.get_array()[i] * power))
def show_random_animation(self, current_block):
animationType = random.randrange(1, 8)
if (animationType == 0):
self.show_spinning_head_animation(current_block)
elif (animationType == 1):
self.show_fade_in_out_animation(current_block)
elif (animationType == 2):
self.show_alternate_animation(current_block)
elif (animationType == 3):
self.show_sheep_confetti_animation(current_block)
elif (animationType == 4):
self.show_rainbow_animation(current_block)
elif (animationType == 5):
self.show_snake_animation(current_block)
elif (animationType == 6):
self.show_broken_animation(current_block)
else:
self.show_fibonacci_animation(current_block)
def num_of_blocks(self, original, div):
while original % div != 0:
div = div / 2
return original / div
def show_alternate_animation(self, current_block):
print "alternate"
num_of_blocks = current_block[1]
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 2)
hue1 = random.random()
hue2 = hue1
hue3 = hue1
if current_block[2] == 'S':
hue2 = Colors.reduce_by_1(hue1 + 0.333)
hue3 = Colors.reduce_by_1(hue1 + 0.666)
self.animations = [
AlternateAnimation(self.smallSheep, num_of_blocks, hue2),
AlternateAnimation(self.bigSheep12, num_of_blocks, hue1),
AlternateAnimation(self.bigSheep34, num_of_blocks, hue3),
AlternateSignsAnimation(self.signs, num_of_blocks, hue2),
AlternateFlowerAnimation(self.flower, num_of_blocks, hue2)
]
def show_fade_in_out_animation(self, current_block):
print "fade_in_out"
num_of_blocks = current_block[1]
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 2)
hue1 = random.random()
hue2 = hue1
hue3 = hue1
hue4 = hue1
if current_block[2] == 'S':
hue2 = Colors.reduce_by_1(hue1 + 0.111)
hue3 = Colors.reduce_by_1(hue1 + 0.222)
hue3 = Colors.reduce_by_1(hue1 + 0.333)
self.animations = [
FadeInOutAnimation(self.smallSheep, num_of_blocks, hue2),
FadeInOutAnimation(self.bigSheep12, num_of_blocks, hue1),
FadeInOutAnimation(self.bigSheep34, num_of_blocks, hue3),
FadeInOutSignsAnimation(self.signs, num_of_blocks, hue2),
FadeInOutFlowerAnimation(self.flower, num_of_blocks, hue2)
]
def show_sheep_confetti_animation(self, current_block):
print "confetti"
leds_percent_per_cycle = 0.005
if current_block[2] == 'S':
leds_percent_per_cycle = 0.03
self.animations = [
SheepConfettiAnimation(self.smallSheep, leds_percent_per_cycle),
SheepConfettiAnimation(self.bigSheep12, leds_percent_per_cycle),
SheepConfettiAnimation(self.bigSheep34, leds_percent_per_cycle),
SignsConfettiAnimation(self.signs, leds_percent_per_cycle * 2),
ConfettiFlowerAnimation(self.flower, leds_percent_per_cycle)
]
def show_rainbow_animation(self, current_block):
print "rainbow"
num_of_blocks = self.num_of_blocks(current_block[1], 2)
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 4)
self.animations = [
RainbowAnimation(self.smallSheep, num_of_blocks),
RainbowAnimation(self.bigSheep12, num_of_blocks),
RainbowAnimation(self.bigSheep34, num_of_blocks),
RainbowSignsAnimation(self.signs, num_of_blocks),
RainbowFlowerAnimation(self.flower, num_of_blocks)
]
def show_snake_animation(self, current_block):
print "snake"
num_of_blocks = self.num_of_blocks(current_block[1], 2)
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 4)
self.animations = [
SnakeAnimation(self.smallSheep, num_of_blocks),
SnakeAnimation(self.bigSheep12, num_of_blocks),
SnakeAnimation(self.bigSheep34, num_of_blocks),
SignsConfettiAnimation(self.signs, 0.1),
SnakeFlowerAnimation(self.flower, num_of_blocks)
]
def show_spinning_head_animation(self, current_block):
print "spinning_head"
num_of_blocks = self.num_of_blocks(current_block[1], 1)
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 2)
hue = random.random()
self.animations = [
SpinningHeadAnimation(self.smallSheep, hue, num_of_blocks),
SpinningHeadAnimation(self.bigSheep12, hue, num_of_blocks),
SpinningHeadAnimation(self.bigSheep34, hue, num_of_blocks),
FadeInOutStarsAnimation(self.stars, num_of_blocks)
]
def show_fibonacci_animation(self, current_block):
print "fibonacci"
num_of_blocks = self.num_of_blocks(current_block[1], 2)
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 4)
hue1 = random.random()
hue2 = hue1
hue3 = hue1
if current_block[2] == 'S':
hue2 = Colors.reduce_by_1(hue1 + 0.111)
hue3 = Colors.reduce_by_1(hue1 + 0.222)
self.animations = [
FibonacciAnimation(self.smallSheep, num_of_blocks, hue2),
FibonacciAnimation(self.bigSheep12, num_of_blocks, hue1),
FibonacciAnimation(self.bigSheep34, num_of_blocks, hue3),
AlwaysOnSignsAnimation(self.signs, [30, 30, 30]),
FibonacciFlowerAnimation(self.flower, num_of_blocks, hue2)
]
def show_broken_animation(self, current_block):
print "broken"
num_of_blocks = self.num_of_blocks(current_block[1], 1)
if current_block[2] == 'W':
num_of_blocks = self.num_of_blocks(num_of_blocks, 2)
self.animations = [
BrokenAnimation(self.smallSheep, num_of_blocks, 3),
BrokenAnimation(self.bigSheep12, num_of_blocks, 6),
BrokenAnimation(self.bigSheep34, num_of_blocks, 6),
BrokenSignsAnimation(self.signs, num_of_blocks, 3),
BrokenFlowerAnimation(self.flower, num_of_blocks, 2)
]
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
# ui elements
flower = Flower()
sheep = SmallSheep()
grass = Grass()
sign = Sign()
lake = Lake()
with open(FILE, 'r') as f:
song = yaml.load(f)
audio_file = "../Music/" + song['file_name']
pieces = song['pieces']
offset = song['offset']
current_piece_id = 0
print pieces[current_piece_id]
# init music
#!/usr/bin/env python
import sys, os
sys.path.append(os.path.abspath('../'))
import Network.LedBurnProtocol as network
import time
from UIElements.SmallSheep import SmallSheep
sheep = SmallSheep()
from SpikeSheepAnimation import SpikeSheepAnimation
from FireSheepAnimation import FireSheepAnimation
from AlternateSheepAnimation import AlternateSheepAnimation
from SheepConfettiAnimation import SheepConfettiAnimation
from RainbowAnimation import RainbowAnimation
from FillFadeSheepAnimation import FillFadeSheepAnimation
from StarsSheepAnimation import StarsSheepAnimation
# animation = SpikeSheepAnimation(sheep, {'hue_start' :0.1})
# animation = FillFadeSheepAnimation(sheep, {'hue_start' : 'Rainbow'})
animation = StarsSheepAnimation(sheep, {'stars_percent': 0.01})
speed = 75 # in 50 hrz
current_time = 0
frame_id = 0
while True:
time_precent = float(current_time) / speed
FRAMES_IN_SEC = 50 MAX_DURATION = 1 MIN_DURATION = 0.1 DIFF_DURATION = 0.1 NUM_OF_BITS = 32 current_frame = 0 duration = 0.4 animations = [] faster = False slower = True smallSheep = SmallSheep() bigSheep12 = BigSheep12() bigSheep34 = BigSheep34() signs = Signs() ######################################################## # simulator ######################################################## USE_SIMULATOR = True pygame.init() simulator = SheepSimulator() ######################################################## # button defs ########################################################
class Song():
def __init__(self, file_name):
self.file_name = file_name
self.flower_animation = None
self.flower_animation_mul = 1
self.grass_animation = None
self.grass_animation_mul = 1
self.lake_animation = None
self.lake_animation_mul = 1
self.sheep_animation = None
self.sheep_animation_mul = 1
self.sign_animation = None
self.sign_animation_mul = 1
self.tree_animation = None
self.tree_animation_mul = 1
self.flower = Flower()
self.sheep = SmallSheep()
self.grass = Grass()
self.sign = Sign()
self.lake = Lake()
self.tree = Tree()
self.temp_stick = TempStick()
self.sachi_meter = SachiMeter()
with open(self.file_name, 'r') as f:
self.song_yml = yaml.load(f)
self.audio_file = "Music/" + self.song_yml['file_name']
self.pieces = self.song_yml['pieces']
self.current_piece_id = 0
self.offset = self.song_yml['offset']
self.is_transition = 'Transitions' in self.audio_file
self.temp_stick.set_is_on(self.is_transition)
self.temp_stick.set_brightness(1.0 if self.is_transition else 0.15)
print str(self.pieces[self.current_piece_id][0]) + " - " + str(
self.pieces[self.current_piece_id][1])
self.create_animations(self.pieces[self.current_piece_id][2])
def get_audio_file(self):
return self.audio_file
def get_effect(self, animation_dict, name, element, factory):
if animation_dict != None and name in animation_dict:
if 'Clear' in animation_dict[name]:
element.clear()
return None
else:
return factory.create_animation(animation_dict[name], element)
else:
return None
def get_mul(self, animation_dict, name):
if animation_dict != None and name in animation_dict and 'beat_mul' in animation_dict[
name]:
return animation_dict[name]['beat_mul']
return 1.0
def create_animations(self, animation_dict):
self.flower_animation = self.get_effect(animation_dict, 'flower',
self.flower,
FlowerAnimationFactory)
self.flower_animation_mul = self.get_mul(animation_dict, 'flower')
self.grass_animation = self.get_effect(animation_dict, 'grass',
self.grass,
GrassAnimationFactory)
self.grass_animation_mul = self.get_mul(animation_dict, 'grass')
self.lake_animation = self.get_effect(animation_dict, 'lake',
self.lake, LakeAnimationFactory)
self.lake_animation_mul = self.get_mul(animation_dict, 'lake')
self.sheep_animation = self.get_effect(animation_dict, 'sheep',
self.sheep,
SheepAnimationFactory)
self.sheep_animation_mul = self.get_mul(animation_dict, 'sheep')
self.sign_animation = self.get_effect(animation_dict, 'sign',
self.sign, SignAnimationFactory)
self.sign_animation_mul = self.get_mul(animation_dict, 'sign')
self.tree_animation = self.get_effect(animation_dict, 'tree',
self.tree, TreeAnimationFactory)
self.tree_animation_mul = self.get_mul(animation_dict, 'tree')
def apply_animation(self, animation, num_of_beats, duration,
relative_song_time):
if (animation == None):
return
if self.is_transition:
percent_beat_time = (relative_song_time % 3.0) / 3.0
else:
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
animation.apply(percent_beat_time)
def clear_leds(self):
self.flower.clear()
self.sheep.clear()
self.grass.clear()
self.sign.clear()
self.lake.clear()
self.tree.clear()
def play_animations(self, song_time, curr_temerature, sachi_meter=None):
song_time += self.offset
self.temp_stick.set_temperature(None, curr_temerature)
self.sachi_meter.set_sachi_meter(None, sachi_meter)
if self.current_piece_id < len(
self.pieces) - 1 and song_time > self.pieces[
self.current_piece_id + 1][0]:
self.current_piece_id += 1
print str(self.pieces[self.current_piece_id][0]) + " - " + str(
self.pieces[self.current_piece_id][1])
self.create_animations(self.pieces[self.current_piece_id][2])
if self.current_piece_id == len(self.pieces) - 1:
duration = 30.0
else:
duration = self.pieces[self.current_piece_id + 1][0] - self.pieces[
self.current_piece_id][0]
num_of_beats = self.pieces[self.current_piece_id][1]
relative_song_time = song_time - self.pieces[self.current_piece_id][0]
if self.flower_animation != None:
flower_num_of_beats = num_of_beats * self.flower_animation_mul
self.apply_animation(self.flower_animation, flower_num_of_beats,
duration, relative_song_time)
if self.grass_animation != None:
grass_num_of_beats = num_of_beats * self.grass_animation_mul
self.apply_animation(self.grass_animation, grass_num_of_beats,
duration, relative_song_time)
if self.lake_animation != None:
lake_num_of_beats = num_of_beats * self.lake_animation_mul
self.apply_animation(self.lake_animation, lake_num_of_beats,
duration, relative_song_time)
if self.sheep_animation != None:
sheep_num_of_beats = num_of_beats * self.sheep_animation_mul
self.apply_animation(self.sheep_animation, sheep_num_of_beats,
duration, relative_song_time)
if self.sign_animation != None:
sign_num_of_beats = num_of_beats * self.sign_animation_mul
self.apply_animation(self.sign_animation, sign_num_of_beats,
duration, relative_song_time)
if self.tree_animation != None:
tree_num_of_beats = num_of_beats * self.tree_animation_mul
self.apply_animation(self.tree_animation, tree_num_of_beats,
duration, relative_song_time)
network.send(flower_data=self.flower.get_array(),
sheep_data=self.sheep.get_array())
#!/usr/bin/env python
import sys, os
sys.path.append(os.path.abspath('../'))
import Network.LedBurnProtocol as network
import time
from UIElements.Flower import Flower
from UIElements.SmallSheep import SmallSheep
flower = Flower()
sheep = SmallSheep()
from Animations_Flower.ExplosionFlowerAnimation import ExplosionFlowerAnimation
from Animations_Flower.RainbowFlowerAnimation import RainbowFlowerAnimation
from Animations_Flower.AlternateFlowerAnimation import AlternateFlowerAnimation
from Animations_Flower.RoundRobinFlowerAnimation import RoundRobinFlowerAnimation
from Animations_Flower.NaturalFlowerAnimation import NaturalFlowerAnimation
from Animations_Flower.FireFlowerAnimation import FireFlowerAnimation
from Animations_Flower.ConfettiFlowerAnimation import ConfettiFlowerAnimation
from Animations_Flower.GlowFlowerAnimation import GlowFlowerAnimation
from Animations_Flower.SpikesFlowerAnimation import SpikesFlowerAnimation
animations_flower_arr = []
animations_flower_arr.append({
'animation': SpikesFlowerAnimation(flower, None),
'speed': 60
})
animations_flower_arr.append({
'animation': RainbowFlowerAnimation(flower, None),
socket.SOCK_DGRAM) # UDP
#sound
#f = wave.open(r'C:\Users\Amir\Downloads\dreams.wav', 'rb')
#sampleRate= f.getframerate()
#sound_frames_per_cicle = int(sampleRate / config_leds.frames_per_second)
#channels= f.getnchannels()n
#format= sound.AFMT_S16_LE
#snd= sound.Output( sampleRate, channels, format )
#sheep (Red, Green, Blue)
#star (Green, Red, Blue )
print "hey"
smallSheep = SmallSheep()
animation = BlinkCircleAnimation(smallSheep, 500, [200, 128, 150])
while True:
header = array.array('B', [0, (circle_number / (256 * 256) ) % 256, (circle_number / 256) % 256, circle_number % 256])
message_0 = (header + array.array('B', [0] * 900)).tostring()
header = array.array('B', [1, (circle_number / (256 * 256) ) % 256, (circle_number / 256) % 256, circle_number % 256])
message_1 = (header + array.array('B', [0] * 900)).tostring()
header = array.array('B', [2, (circle_number / (256 * 256) ) % 256, (circle_number / 256) % 256, circle_number % 256])
message_2 = (header + array.array('B', [0] * 900)).tostring()
FRAMES_IN_SEC = 50 MAX_DURATION = 1 MIN_DURATION = 0.1 DIFF_DURATION = 0.1 NUM_OF_BITS = 32 current_frame = 0 duration = 0.4 animations = [] faster = False slower = True smallSheep = SmallSheep() bigSheep12 = BigSheep12() bigSheep34 = BigSheep34() signs = Signs() ######################################################## # button defs ######################################################## # must divide 5 * NUM_OF_BITS SLOW_BUTTON_FRAMES = 16 FAST_BUTTON_FRAMES = 8 GPIO.cleanup() GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.IN, GPIO.PUD_DOWN)
for e in self.f_effects:
e.apply(time_percent, flower.get_array())
if __name__ == "__main__":
import pygame
import Network.LedBurnProtocol as network
from UIElements.SmallSheep import SmallSheep
from UIElements.Flower import Flower
flower = Flower()
grass = [0, 0, 0] * 600
sign = [0, 0, 0] * 150
lake = [0, 0, 0] * 1800
sheep = SmallSheep()
frame_id = random.randint(0, 10000000)
song = MoominsSong(sheep, flower)
clock = pygame.time.Clock()
pygame.mixer.init()
pygame.mixer.music.load(song.get_audio_file())
pygame.mixer.music.play(0, 0)
while pygame.mixer.music.get_busy():
song_time = (pygame.mixer.music.get_pos() - 170) / 1000.0
song.apply_animation(song_time)
network.send(flower.get_array(), sheep.get_array(), grass, sign, lake)