class pandalogichive(bee.frame):
do_set_panda = dragonfly.std.pushconnector("id")()
set_panda = bee.output(do_set_panda.outp)
do_trig_spawn = dragonfly.std.pushconnector("trigger")()
trig_spawn = bee.output(do_trig_spawn.outp)
c_hivereg = bee.configure("hivereg")
for name in pandadict:
mode, data, box, image, hivemap = pandadict[name]
hive = load_hive(hivemap)
c_hivereg.register_hive(name, hive)
locals()["v_panda_" + name] = dragonfly.std.variable("id")(name)
locals()["set_panda_" + name] = dragonfly.std.transistor("id")()
connect("v_panda_" + name, "set_panda_" + name)
connect("set_panda_" + name, do_set_panda)
locals()["pandaicon_click_" + name] = dragonfly.io.mouseareasensor(name)
connect("pandaicon_click_" + name, "set_panda_" + name)
connect("pandaicon_click_" + name, do_trig_spawn)
del name, hive
del mode, data, box, image, hivemap
class pandalogicframe(bee.frame):
name = bee.parameter("str")
name_ = bee.get_parameter("name")
do_trig_spawn = dragonfly.std.pushconnector("trigger")()
trig_spawn = bee.output(do_trig_spawn.outp)
v_panda = dragonfly.std.variable("id")(name_)
t_set_panda = dragonfly.std.transistor("id")()
connect(v_panda, t_set_panda)
set_panda = bee.output(t_set_panda.outp)
pandaicon_click = dragonfly.io.mouseareasensor(name_)
connect(pandaicon_click, t_set_panda)
connect(pandaicon_click, do_trig_spawn)
class tetris_select_block(bee.frame):
blocks = parameter("object")
blocks_ = get_parameter("blocks")
w_blocks = dragonfly.gen.gentuple2(blocks_)
sel = dragonfly.random.choice()
connect(w_blocks, sel)
do_select = dragonfly.gen.transistor()
connect(sel, do_select)
chosen = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
chosencontrol = dragonfly.grid.bgridcontrol()
connect(chosen, chosencontrol.grid)
connect(do_select, chosen)
do_select2 = dragonfly.gen.transistor()
connect(chosen, do_select2)
uptofour = dragonfly.std.variable(("int", "int"))((0, 4))
randint = dragonfly.random.randint()
connect(uptofour, randint)
rotate = dragonfly.std.transistor("int")()
connect(randint, rotate)
connect(rotate, chosencontrol.rotate)
trigger = dragonfly.std.pushconnector("trigger")()
connect(trigger, do_select)
connect(trigger, rotate)
connect(trigger, do_select2)
select = antenna(trigger.inp)
selected = output(do_select2.outp)
class tetris_control(bee.worker):
maingrid = antenna("pull", ("object", "bgrid"))
blockgrid = antenna("pull", ("object", "bgrid"))
grid1 = buffer("pull", ("object", "bgrid"))
connect(maingrid, grid1)
grid2 = buffer("pull", ("object", "bgrid"))
connect(blockgrid, grid2)
get_grids = triggerfunc(grid1, "input")
trigger(grid1, grid2, "input", "input")
lost = output("push", "trigger")
trig_lost = triggerfunc(lost)
place_init = antenna("push", "trigger")
@modifier
def m_place_init(self):
self.get_grids()
dx = int(self.grid1.maxx / 2) - self.grid2.minx
self.grid2.maxx += dx
self.grid2.minx += dx
dy = self.grid1.maxy - self.grid2.maxy
self.grid2.maxy += dy
self.grid2.miny += dy
if self.grid1.overlap(self.grid2):
self.trig_lost()
trigger(place_init, m_place_init)
class tetris_control(bee.worker):
maingrid = antenna("pull", ("object", "bgrid"))
blockgrid = antenna("pull", ("object", "bgrid"))
grid1 = buffer("pull", ("object", "bgrid"))
connect(maingrid, grid1)
grid2 = buffer("pull", ("object", "bgrid"))
connect(blockgrid, grid2)
get_grids = triggerfunc(grid1, "input")
trigger(grid1, grid2, "input", "input")
lost = output("push", "trigger")
trig_lost = triggerfunc(lost)
place_init = antenna("push", "trigger")
@modifier
def m_place_init(self):
self.get_grids()
dx = int(self.grid1.maxx / 2) - self.grid2.minx
self.grid2.maxx += dx
self.grid2.minx += dx
dy = self.grid1.maxy - self.grid2.maxy
self.grid2.maxy += dy
self.grid2.miny += dy
if self.grid1.overlap(self.grid2):
self.trig_lost()
trigger(place_init, m_place_init)
dropped = output("push", "trigger")
trig_dropped = triggerfunc(dropped)
move_down = antenna("push", "trigger")
@modifier
def m_move_down(self):
self.get_grids()
block = copy.copy(self.grid2)
block.translate(0, -1)
if block.miny < 0 or self.grid1.overlap(block):
self.grid1.merge(self.grid2)
self.trig_dropped()
else:
self.grid2.translate(0, -1)
trigger(move_down, m_move_down)
class tetris_select_block(bee.frame):
blocks = parameter("object")
blocks_ = get_parameter("blocks")
w_blocks = dragonfly.gen.gentuple2(blocks_)
sel = dragonfly.random.choice()
connect(w_blocks, sel)
do_select = dragonfly.gen.transistor()
connect(sel, do_select)
select = antenna(do_select.trig)
selected = output(do_select.outp)
class pandalogichive(bee.frame):
do_set_panda = dragonfly.std.pushconnector("id")()
set_panda = bee.output(do_set_panda.outp)
do_trig_spawn = dragonfly.std.pushconnector("trigger")()
trig_spawn = bee.output(do_trig_spawn.outp)
c_hivereg = bee.configure("hivereg")
for name in pandadict:
mode, data, box, image, hivemap = pandadict[name]
hive = load_hive(hivemap)
c_hivereg.register_hive(name, hive)
p = pandalogicframe(name)
connect(p.set_panda, do_set_panda)
connect(p.trig_spawn, do_trig_spawn)
locals()["pandalogicframe_%s" % name] = p
del mode, data, box, image, hivemap, hive, p, name
class tetris_init_main(bee.worker):
gridx = variable("int")
parameter(gridx)
gridy = variable("int")
parameter(gridy)
start = antenna("push", "trigger")
outp = output("push", ("object", "bgrid"))
grid = variable(("object", "bgrid"))
t_outp = transistor(("object", "bgrid"))
connect(grid, t_outp)
connect(t_outp, outp)
trig = triggerfunc(t_outp)
@modifier
def m_start(self):
self.grid = bgrid(0, self.gridx - 1, 0, self.gridy - 1)
self.trig()
trigger(start, m_start)
class tetris_control(bee.worker):
maingrid = antenna("pull", ("object", "bgrid"))
blockgrid = antenna("pull", ("object", "bgrid"))
grid1 = buffer("pull", ("object", "bgrid"))
connect(maingrid, grid1)
grid2 = buffer("pull", ("object", "bgrid"))
connect(blockgrid, grid2)
get_grids = triggerfunc(grid1, "input")
trigger(grid1, grid2, "input", "input")
lost = output("push", "trigger")
trig_lost = triggerfunc(lost)
place_init = antenna("push", "trigger")
@modifier
def m_place_init(self):
self.get_grids()
dx = int(self.grid1.maxx / 2) - self.grid2.minx
self.grid2.maxx += dx
self.grid2.minx += dx
dy = self.grid1.maxy - self.grid2.maxy
self.grid2.maxy += dy
self.grid2.miny += dy
if self.grid1.overlap(self.grid2):
self.trig_lost()
trigger(place_init, m_place_init)
dropped = output("push", "trigger")
trig_dropped = triggerfunc(dropped)
move_down = antenna("push", "trigger")
@modifier
def m_move_down(self):
self.get_grids()
block = copy.copy(self.grid2)
block.translate(0, -1)
if block.miny < 0 or self.grid1.overlap(block):
self.grid1.merge(self.grid2)
self.trig_dropped()
else:
self.grid2.translate(0, -1)
trigger(move_down, m_move_down)
def move_sideways(self, direction):
self.get_grids()
block = copy.copy(self.grid2)
block.translate(direction, 0)
if block.minx < 0: return
if block.maxx > self.grid1.maxx: return
if self.grid1.overlap(block): return
self.grid2.translate(direction, 0)
move_left = antenna("push", "trigger")
@modifier
def m_move_left(self):
self.move_sideways(-1)
trigger(move_left, m_move_left)
move_right = antenna("push", "trigger")
@modifier
def m_move_right(self):
self.move_sideways(1)
trigger(move_right, m_move_right)
def rotate(self, times):
self.get_grids()
block = copy.copy(self.grid2)
block.rotate(times)
if block.minx < 0:
block.translate(-block.minx, 0)
if block.maxx > self.grid1.maxx:
block.translate(self.grid1.maxx - block.maxx, 0)
if self.grid1.overlap(block): return
self.grid2.set(block)
rotate_cw = antenna("push", "trigger")
@modifier
def m_rotate_cw(self):
self.rotate(3)
trigger(rotate_cw, m_rotate_cw)
rotate_ccw = antenna("push", "trigger")
@modifier
def m_rotate_ccw(self):
self.rotate(1)
trigger(rotate_ccw, m_rotate_ccw)
drop = antenna("push", "trigger")
@modifier
def m_drop(self):
self.get_grids()
block = copy.copy(self.grid2)
while block.miny >= 0 and not self.grid1.overlap(block):
block.translate(0, -1)
block.translate(0, 1)
self.grid1.merge(block)
self.trig_dropped()
trigger(drop, m_drop)
class pandalogichive(bee.frame):
do_set_panda = dragonfly.std.pushconnector("id")()
set_panda = bee.output(do_set_panda.outp)
do_trig_spawn = dragonfly.std.pushconnector("trigger")()
trig_spawn = bee.output(do_trig_spawn.outp)
class tetris_control(bee.worker):
maingrid = antenna("pull", ("object", "bgrid"))
blockgrid = antenna("pull", ("object", "bgrid"))
grid1 = buffer("pull", ("object", "bgrid"))
connect(maingrid, grid1)
grid2 = buffer("pull", ("object", "bgrid"))
connect(blockgrid, grid2)
get_grids = triggerfunc(grid1, "input")
trigger(grid1, grid2, "input", "input")
lost = output("push", "trigger")
trig_lost = triggerfunc(lost)
place_init = antenna("push", "trigger")
@modifier
def m_place_init(self):
self.get_grids()
dx = int(self.grid1.maxx / 2) - self.grid2.minx
self.grid2.maxx += dx
self.grid2.minx += dx
dy = self.grid1.maxy - self.grid2.maxy
self.grid2.maxy += dy
self.grid2.miny += dy
if self.grid1.overlap(self.grid2):
self.trig_lost()
trigger(place_init, m_place_init)
dropped = output("push", "trigger")
trig_dropped = triggerfunc(dropped)
move_down = antenna("push", "trigger")
@modifier
def m_move_down(self):
self.get_grids()
block = copy.copy(self.grid2)
block.translate(0, -1)
if block.miny < 0 or self.grid1.overlap(block):
self.grid1.merge(self.grid2)
self.get_score_and_rewards()
linereward = self.remove_lines()
self.b_newscore = self.b_score + self.b_reward_block + linereward
self.trig_newscore()
self.trig_dropped()
else:
self.grid2.translate(0, -1)
trigger(move_down, m_move_down)
def move_sideways(self, direction):
self.get_grids()
block = copy.copy(self.grid2)
block.translate(direction, 0)
if block.minx < 0: return
if block.maxx > self.grid1.maxx: return
if self.grid1.overlap(block): return
self.grid2.translate(direction, 0)
move_left = antenna("push", "trigger")
@modifier
def m_move_left(self):
self.move_sideways(-1)
trigger(move_left, m_move_left)
move_right = antenna("push", "trigger")
@modifier
def m_move_right(self):
self.move_sideways(1)
trigger(move_right, m_move_right)
def rotate(self, times):
self.get_grids()
block = copy.copy(self.grid2)
block.rotate(times)
if block.minx < 0:
block.translate(-block.minx, 0)
if block.maxx > self.grid1.maxx:
block.translate(self.grid1.maxx - block.maxx, 0)
if self.grid1.overlap(block): return
self.grid2.set(block)
rotate_cw = antenna("push", "trigger")
@modifier
def m_rotate_cw(self):
self.rotate(3)
trigger(rotate_cw, m_rotate_cw)
rotate_ccw = antenna("push", "trigger")
@modifier
def m_rotate_ccw(self):
self.rotate(1)
trigger(rotate_ccw, m_rotate_ccw)
drop = antenna("push", "trigger")
@modifier
def m_drop(self):
self.get_grids()
block = copy.copy(self.grid2)
while block.miny >= 0 and not self.grid1.overlap(block):
block.translate(0, -1)
block.translate(0, 1)
self.grid1.merge(block)
self.get_score_and_rewards()
linereward = self.remove_lines()
self.b_newscore = self.b_score + self.b_reward_block + linereward
self.trig_newscore()
self.trig_dropped()
trigger(drop, m_drop)
def remove_lines(self):
values = self.grid1.get_values()
removed = 0
y = 0
while y < self.grid1.maxy + 1:
line = [v for v in values if v[1] == y]
if len(line) == self.grid1.maxx + 1:
values = [v for v in values if v[1] != y]
values = [(v[0], v[1] - 1) if v[1] > y else v for v in values]
removed += 1
else:
y += 1
if removed:
self.grid1.set_values(values)
if removed == 1: return self.b_reward_line
if removed == 2: return self.b_reward_line2
if removed == 3: return self.b_reward_line3
if removed == 4: return self.b_reward_line4
return 0
score = antenna("pull", "int")
b_score = buffer("pull", "int")
connect(score, b_score)
newscore = output("push", "int")
b_newscore = buffer("push", "int")
connect(b_newscore, newscore)
trig_newscore = triggerfunc(b_newscore)
reward_block = antenna("pull", "int")
b_reward_block = buffer("pull", "int")
connect(reward_block, b_reward_block)
reward_line = antenna("pull", "int")
b_reward_line = buffer("pull", "int")
connect(reward_line, b_reward_line)
reward_line2 = antenna("pull", "int")
b_reward_line2 = buffer("pull", "int")
connect(reward_line2, b_reward_line2)
reward_line3 = antenna("pull", "int")
b_reward_line3 = buffer("pull", "int")
connect(reward_line3, b_reward_line3)
reward_line4 = antenna("pull", "int")
b_reward_line4 = buffer("pull", "int")
connect(reward_line4, b_reward_line4)
get_score_and_rewards = triggerfunc(b_score, "update")
trigger(b_score, b_reward_block, "update", "update")
trigger(b_score, b_reward_line, "update", "update")
trigger(b_score, b_reward_line2, "update", "update")
trigger(b_score, b_reward_line3, "update", "update")
trigger(b_score, b_reward_line4, "update", "update")
class launch(bee.frame):
__doc__ = cls.__doc__
subprocess = bee.parameter("bool")
bind_worker = launch_helper(
subprocess=bee.get_parameter("subprocess"))
hive_binder = worker()
id_factory = id_suffix_worker()
# To push identifier base in id factory
id_transistor = std.transistor(("str", "identifier"))()
bee.connect(id_transistor.outp, id_factory.identifier_base)
# Create some hive IO pins
trig = bee.antenna(id_transistor.trig)
bee.connect(id_factory.trig_out, bind_worker.trig)
# Secondary calls
process_class = bee.antenna(id_transistor.inp)
bee.connect(process_class, bind_worker.process_class)
# Secondary calls
process_identifier = bee.output(id_factory.new_identifier)
bee.connect(process_identifier, bind_worker.process_identifier)
# Weaver of these two
w_bind_ids = std.weaver(("id", "id"))()
process_id_duck = convert.pull.duck("str", "id")()
bee.connect(id_factory.new_identifier, process_id_duck)
bee.connect(process_id_duck, w_bind_ids.inp1)
process_class_duck = convert.pull.duck("str", "id")()
bee.connect(process_class, process_class_duck)
bee.connect(process_class_duck, w_bind_ids.inp2)
# Connect weaver to binder
t_bind_ids = std.transistor(("id", "id"))()
bee.connect(w_bind_ids, t_bind_ids)
bee.connect(t_bind_ids, hive_binder.bind)
# This only triggers if we're a subprocess
bee.connect(bind_worker.trig_out, t_bind_ids.trig)
guiparams = {
"process_class": {
"name": "Process class",
"fold": True
},
"trig": {
"name": "Trigger"
},
"process_identifier": {
"name": "Process ID"
},
"subprocess": {
"name": "Subprocess"
},
"memberorder": ["trig", "process_class", "process_identifier"],
}
