class myhive(dragonfly.pandahive.pandahive):
pandaname = "mypanda"
pandaname_ = bee.attribute("pandaname")
pandaclassname = "pandaclass"
pandaclassname_ = bee.attribute("pandaclassname")
pandaicon = "pandaicon"
pandaicon_ = bee.attribute("pandaicon")
canvas = dragonfly.pandahive.pandacanvas()
mousearea = dragonfly.canvas.mousearea()
raiser = bee.raiser()
connect("evexc", raiser)
animation = dragonfly.scene.unbound.animation()
pandaid = dragonfly.std.variable("id")(pandaname_)
walk = dragonfly.std.variable("str")("walk")
connect(pandaid, animation.actor)
connect(walk, animation.animation_name)
key_w = dragonfly.io.keyboardsensor_trigger("W")
connect(key_w, animation.loop)
key_s = dragonfly.io.keyboardsensor_trigger("S")
connect(key_s, animation.stop)
pandaspawn = dragonfly.scene.spawn_actor()
v_panda = dragonfly.std.variable("id")(pandaclassname_)
connect(v_panda, pandaspawn)
panda_id = dragonfly.std.generator("id", id_generator)()
random_matrix = dragonfly.std.generator(("object", "matrix"), random_matrix_generator)()
w_spawn = dragonfly.std.weaver(("id", ("object", "matrix")))()
connect(panda_id, w_spawn.inp1)
connect(random_matrix, w_spawn.inp2)
do_spawn = dragonfly.std.transistor(("id", ("object", "matrix")))()
connect(w_spawn, do_spawn)
connect(do_spawn, pandaspawn.spawn_matrix)
key_z = dragonfly.io.keyboardsensor_trigger("Z")
connect(key_z, do_spawn)
pandaicon_click = dragonfly.io.mouseareasensor(pandaicon_)
connect(pandaicon_click, do_spawn)
myscene = myscene(
scene="scene",
pandaname=pandaname_,
pandaclassname=pandaclassname_,
canvas=canvas,
mousearea=mousearea,
pandaicon=pandaicon_
)
class main(dragonfly.pandahive.pandahive):
blocks = blocks
gridx = 10
gridy = 20
mainarea = box2d(100, 150, 225, 375)
mainarea_id = "main"
mainarea_parameters = parameters(color=(0.5, 0.5, 0.5, 0))
scorearea = box2d(170, 100, 80, 40)
scorearea_id = "score"
# define bee.attribute derivatives, allowing proper inheritance
blocks_ = attribute("blocks")
gridx_ = attribute("gridx")
gridy_ = attribute("gridy")
mainarea_ = attribute("mainarea")
mainarea_parameters_ = attribute("mainarea_parameters")
mainarea_id_ = attribute("mainarea_id")
scorearea_ = attribute("scorearea")
scorearea_id_ = attribute("scorearea_id")
maingrid = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
maingridcontrol = dragonfly.grid.bgridcontrol()
connect(maingrid, maingridcontrol.grid)
blockgrid = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
blockgridcontrol = dragonfly.grid.bgridcontrol()
connect(blockgrid, blockgridcontrol.grid)
select_block = tetris_select_block(blocks=blocks_)
test = dragonfly.std.trigger()
connect(test, select_block)
connect(select_block, blockgrid)
class myhive(dragonfly.pandahive.pandahive):
pandaname = "mypanda"
pandaname_ = bee.attribute("pandaname")
canvas = dragonfly.pandahive.pandacanvas()
mousearea = dragonfly.canvas.mousearea()
raiser = bee.raiser()
connect("evexc", raiser)
animation = dragonfly.scene.unbound.animation()
pandaid = dragonfly.std.variable("id")(pandaname_)
walk = dragonfly.std.variable("str")("walk")
connect(pandaid, animation.actor)
connect(walk, animation.animation_name)
key_w = dragonfly.io.keyboardsensor_trigger("W")
connect(key_w, animation.loop)
key_s = dragonfly.io.keyboardsensor_trigger("S")
connect(key_s, animation.stop)
random_matrix = dragonfly.std.generator(("object", "matrix"), random_matrix_generator)()
panda_id = dragonfly.std.generator("id", id_generator)()
w_spawn = dragonfly.std.weaver(("id", ("object", "matrix")))()
connect(panda_id, w_spawn.inp1)
connect(random_matrix, w_spawn.inp2)
pandalogic = generate_pandalogic()()
connect(w_spawn, pandalogic.inp)
myscene = myscene(
scene="scene",
canvas=canvas,
mousearea=mousearea,
)
class myhive(dragonfly.pandahive.pandahive):
pandaname = "mypanda"
pandaname_ = bee.attribute("pandaname")
pandaclassname = "pandaclass"
pandaclassname_ = bee.attribute("pandaclassname")
canvas = dragonfly.pandahive.pandacanvas()
mousearea = dragonfly.canvas.mousearea()
raiser = bee.raiser()
connect("evexc", raiser)
z_pandawalk = pandawalkbind().worker()
pandaid = dragonfly.std.variable("id")(pandaname_)
connect(pandaid, z_pandawalk.bindname)
camerabind = camerabind().worker()
camcenter = dragonfly.std.variable("id")("camcenter")
connect(camcenter, camerabind.bindname)
pandaspawn = dragonfly.scene.spawn_actor()
v_panda = dragonfly.std.variable("id")(pandaclassname_)
connect(v_panda, pandaspawn)
panda_id = dragonfly.std.generator("id", id_generator)()
random_matrix = dragonfly.std.generator(("object", "matrix"),
random_matrix_generator)()
w_spawn = dragonfly.std.weaver(("id", ("object", "matrix")))()
connect(panda_id, w_spawn.inp1)
connect(random_matrix, w_spawn.inp2)
do_spawn = dragonfly.std.transistor(("id", ("object", "matrix")))()
connect(w_spawn, do_spawn)
connect(do_spawn, pandaspawn.spawn_matrix)
key_z = dragonfly.io.keyboardsensor_trigger("Z")
connect(key_z, do_spawn)
pandaicon_click = dragonfly.io.mouseareasensor("pandaicon")
connect(pandaicon_click, do_spawn)
myscene = myscene(
scene="scene",
canvas=canvas,
mousearea=mousearea,
)
wininit = bee.init("window")
wininit.camera.setPos(0, -20, 3)
class main(dragonfly.pandahive.pandahive):
blocks = blocks
gridx = 10
gridy = 20
mainarea = box2d(100, 150, 225, 375)
mainarea_id = "main"
mainarea_parameters = parameters(color=(0.5, 0.5, 0.5, 0))
scorearea = box2d(170, 100, 80, 40)
scorearea_id = "score"
canvas = dragonfly.pandahive.pandacanvas()
blocks_ = attribute("blocks")
gridx_ = attribute("gridx")
gridy_ = attribute("gridy")
mainarea_ = attribute("mainarea")
mainarea_parameters_ = attribute("mainarea_parameters")
mainarea_id_ = attribute("mainarea_id")
scorearea_ = attribute("scorearea")
scorearea_id_ = attribute("scorearea_id")
c0 = configure("canvas") # must have a lower-alphabet name than "canvas"
c0.reserve(mainarea_id_, ("object", "bgrid"),
box=mainarea_,
parameters=mainarea_parameters_)
maingrid = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
maingridcontrol = dragonfly.grid.bgridcontrol()
connect(maingrid, maingridcontrol.grid)
blockgrid = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
blockgridcontrol = dragonfly.grid.bgridcontrol()
connect(blockgrid, blockgridcontrol.grid)
select_block = tetris_select_block(blocks=blocks_)
connect(select_block, blockgridcontrol.set)
init_main = tetris_init_main(gridx_, gridy_)
connect(init_main, maingridcontrol.set)
draw = tetris_draw()
connect(maingrid, draw.maingrid)
connect(blockgrid, draw.blockgrid)
control = tetris_control()
connect(maingrid, control.maingrid)
connect(blockgrid, control.blockgrid)
start = dragonfly.sys.startsensor()
connect(start, select_block)
connect(start, init_main.start)
connect(start, control.place_init)
connect(start, draw.start)
connect(start, draw.draw)
raiser = bee.raiser()
connect("evexc", raiser)
class mycombohive(bee.combohive):
pandadict = pandadict
pandadict_ = bee.attribute("pandadict")
cb1 = pandadictdrone(pandadict_)
camerahive = Spyder.Hivemap.fromfile("camera.web")
cb2 = Spyder.Combobee((("camerabindhive", camerahive), ))
#or: cb2 = bee.combodronewrapper({"camerabindhive":camerahive})
del camerahive
class tetris_draw_score(bee.frame):
scorearea_ = attribute("parent", "scorearea")
scorearea_id_ = attribute("parent", "scorearea_id")
scorestr = dragonfly.std.variable("mstr")("")
scorecontrol = dragonfly.mutable.mstrcontrol()
connect(scorestr, scorecontrol)
w_draw = dragonfly.canvas.draw3("mstr")(scorearea_id_)
do_draw = dragonfly.std.transistor("mstr")()
connect(scorestr, do_draw)
connect(do_draw, w_draw)
update = dragonfly.canvas.update3(scorearea_id_)
set_score = dragonfly.std.transistor("str")()
connect(set_score, scorecontrol.set)
set_score_trig = dragonfly.convert.trigger("str")()
connect(set_score, set_score_trig)
connect(set_score_trig, update)
get_score = dragonfly.convert.pull.cast("int", "str")()
connect(get_score, set_score)
start = antenna(do_draw.trig)
score = antenna(get_score.inp)
draw = antenna(set_score.trig)
class myhive(dragonfly.pandahive.pandahive):
pandaclassname = "pandaclass"
pandaclassname_ = bee.attribute("pandaclassname")
canvas = dragonfly.pandahive.pandacanvas()
mousearea = dragonfly.canvas.mousearea()
raiser = bee.raiser()
connect("evexc", raiser)
camerabind = camerabind().worker()
camcenter = dragonfly.std.variable("id")("camcenter")
connect(camcenter, camerabind.bindname)
startsensor = dragonfly.sys.startsensor()
cam = dragonfly.scene.get_camera()
camparent = dragonfly.scene.unbound.parent()
connect(cam, camparent.entityname)
connect(camcenter, camparent.entityparentname)
connect(startsensor, camparent)
cphide = dragonfly.scene.unbound.hide()
connect(camcenter, cphide)
connect(startsensor, cphide)
v_marker = dragonfly.std.variable("id")("marker")
hide_marker = dragonfly.scene.unbound.hide()
connect(v_marker, hide_marker)
show_marker = dragonfly.scene.unbound.show()
connect(v_marker, show_marker)
parent_marker = dragonfly.scene.unbound.parent()
connect(v_marker, parent_marker.entityname)
connect(startsensor, hide_marker)
pandaspawn = dragonfly.scene.spawn_actor()
v_panda = dragonfly.std.variable("id")(pandaclassname_)
connect(v_panda, pandaspawn)
panda_id_gen = dragonfly.std.generator("id", id_generator)()
panda_id = dragonfly.std.variable("id")("")
t_panda_id_gen = dragonfly.std.transistor("id")()
connect(panda_id_gen, t_panda_id_gen)
connect(t_panda_id_gen, panda_id)
random_matrix = dragonfly.std.generator(("object", "matrix"),
random_matrix_generator)()
w_spawn = dragonfly.std.weaver(("id", ("object", "matrix")))()
connect(panda_id, w_spawn.inp1)
connect(random_matrix, w_spawn.inp2)
hivereg = dragonfly.bind.hiveregister()
c_hivereg = bee.configure("hivereg")
c_hivereg.register_hive("pandawalk", pandawalkhive)
pandabinder = pandabind().worker()
v_hivename = dragonfly.std.variable("id")("pandawalk")
w_bind = dragonfly.std.weaver(("id", "id"))()
connect(panda_id, w_bind.inp1)
connect(v_hivename, w_bind.inp2)
t_bind = dragonfly.std.transistor("id")()
connect(panda_id, t_bind)
t_bind2 = dragonfly.std.transistor(("id", "id"))()
connect(w_bind, t_bind2)
connect(t_bind2, pandabinder.bind)
sel = dragonfly.logic.selector()
connect(t_bind, sel.register_and_select)
selected = dragonfly.std.variable("id")("")
connect(t_bind, selected)
t_get_selected = dragonfly.logic.filter("trigger")()
connect(sel.empty, t_get_selected)
tt_get_selected = dragonfly.std.transistor("id")()
do_select = dragonfly.std.pushconnector("trigger")()
connect(t_get_selected.false, do_select)
connect(do_select, tt_get_selected)
connect(sel.selected, tt_get_selected)
connect(tt_get_selected, selected)
disp_sel = dragonfly.io.display("id")("Selected: ")
connect(tt_get_selected, disp_sel)
connect(selected, parent_marker.entityparentname)
connect(do_select, show_marker)
connect(do_select, parent_marker)
key_tab = dragonfly.io.keyboardsensor_trigger("TAB")
connect(key_tab, sel.select_next)
connect(key_tab, t_get_selected)
key_bsp = dragonfly.io.keyboardsensor_trigger("BACKSPACE")
connect(key_bsp, sel.select_prev)
connect(key_bsp, t_get_selected)
kill = dragonfly.std.pushconnector("trigger")()
t_kill = dragonfly.std.transistor("id")()
connect(selected, t_kill)
connect(t_kill, pandabinder.stop)
remove = dragonfly.scene.unbound.remove_actor_or_entity()
connect(t_kill, remove)
disp_kill = dragonfly.io.display("id")("Killed: ")
connect(t_kill, disp_kill)
connect(kill, t_kill)
connect(kill, sel.unregister)
connect(kill, hide_marker)
connect(kill, t_get_selected)
testkill = dragonfly.logic.filter("trigger")()
connect(sel.empty, testkill)
connect(testkill.false, kill)
key_k = dragonfly.io.keyboardsensor_trigger("K")
connect(key_k, testkill)
do_spawn = dragonfly.std.transistor(("id", ("object", "matrix")))()
connect(w_spawn, do_spawn)
connect(do_spawn, pandaspawn.spawn_matrix)
trig_spawn = dragonfly.std.pushconnector("trigger")()
connect(trig_spawn, t_panda_id_gen)
connect(trig_spawn, do_spawn)
connect(trig_spawn, t_bind)
connect(trig_spawn, t_bind2)
connect(trig_spawn, do_select)
key_z = dragonfly.io.keyboardsensor_trigger("Z")
connect(key_z, trig_spawn)
pandaicon_click = dragonfly.io.mouseareasensor("pandaicon")
connect(pandaicon_click, trig_spawn)
myscene = myscene(
scene="scene",
canvas=canvas,
mousearea=mousearea,
)
wininit = bee.init("window")
wininit.camera.setPos(0, 45, 25)
wininit.camera.setHpr(180, -20, 0)
keyboardevents = dragonfly.event.sensor_match_leader("keyboard")
add_head = dragonfly.event.add_head()
head = dragonfly.convert.pull.duck("id", "event")()
connect(selected, head)
connect(keyboardevents, add_head)
connect(head, add_head)
connect(add_head, pandabinder.event)
class main(dragonfly.pandahive.pandahive):
blocks = blocks
gridx = 10
gridy = 20
mainarea = box2d(100, 150, 225, 375)
mainarea_id = "main"
mainarea_parameters = parameters(color=(0.5, 0.5, 0.5, 0))
scorearea = box2d(170, 100, 80, 40)
scorearea_id = "score"
canvas = dragonfly.pandahive.pandacanvas()
blocks_ = attribute("blocks")
gridx_ = attribute("gridx")
gridy_ = attribute("gridy")
mainarea_ = attribute("mainarea")
mainarea_parameters_ = attribute("mainarea_parameters")
mainarea_id_ = attribute("mainarea_id")
scorearea_ = attribute("scorearea")
scorearea_id_ = attribute("scorearea_id")
c0 = configure("canvas") # must have a lower-alphabet name than "canvas"
c0.reserve(mainarea_id_, ("object", "bgrid"),
box=mainarea_,
parameters=mainarea_parameters_)
maingrid = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
maingridcontrol = dragonfly.grid.bgridcontrol()
connect(maingrid, maingridcontrol.grid)
blockgrid = dragonfly.std.variable(("object", "bgrid"))(emptygrid)
blockgridcontrol = dragonfly.grid.bgridcontrol()
connect(blockgrid, blockgridcontrol.grid)
select_block = tetris_select_block(blocks=blocks_)
connect(select_block, blockgridcontrol.set)
init_main = tetris_init_main(gridx_, gridy_)
connect(init_main, maingridcontrol.set)
draw = tetris_draw()
connect(maingrid, draw.maingrid)
connect(blockgrid, draw.blockgrid)
control = tetris_control()
connect(maingrid, control.maingrid)
connect(blockgrid, control.blockgrid)
start = dragonfly.sys.startsensor()
connect(start, select_block)
connect(start, init_main.start)
connect(start, control.place_init)
connect(start, draw.start)
connect(start, draw.draw)
period = dragonfly.std.variable("float")(0.3)
cycle = dragonfly.time.cycle()
connect(period, cycle)
connect(cycle, control.move_down)
connect(cycle, draw.draw)
connect(control.dropped, select_block)
connect(control.dropped, control.place_init)
connect(control.lost, "exitactuator")
k_left = dragonfly.io.keyboardsensor_trigger("LEFT")
connect(k_left, control.move_left)
connect(k_left, draw.draw)
k_right = dragonfly.io.keyboardsensor_trigger("RIGHT")
connect(k_right, control.move_right)
connect(k_right, draw.draw)
k_return = dragonfly.io.keyboardsensor_trigger("RETURN")
connect(k_return, control.rotate_cw)
connect(k_return, draw.draw)
k_space = dragonfly.io.keyboardsensor_trigger("SPACE")
connect(k_space, control.rotate_ccw)
connect(k_space, draw.draw)
k_down = dragonfly.io.keyboardsensor_trigger("DOWN")
connect(k_down, control.drop)
connect(k_down, draw.draw)
raiser = bee.raiser()
connect("evexc", raiser)
class myhive(dragonfly.pandahive.pandahive):
pandaname = "mypanda"
pandaname_ = bee.attribute("pandaname")
pandaclassname = "pandaclass"
pandaclassname_ = bee.attribute("pandaclassname")
canvas = dragonfly.pandahive.pandacanvas()
mousearea = dragonfly.canvas.mousearea()
raiser = bee.raiser()
connect("evexc", raiser)
animation = dragonfly.scene.unbound.animation()
pandaid = dragonfly.std.variable("id")(pandaname_)
walk = dragonfly.std.variable("str")("walk")
connect(pandaid, animation.actor)
connect(walk, animation.animation_name)
key_w = dragonfly.io.keyboardsensor_trigger("W")
connect(key_w, animation.loop)
key_s = dragonfly.io.keyboardsensor_trigger("S")
connect(key_s, animation.stop)
setPos = dragonfly.scene.unbound.setPos()
connect(pandaid, setPos)
interval = dragonfly.time.interval_time(8)
connect(key_w, interval.start)
connect(key_s, interval.pause)
sequence = dragonfly.time.sequence(2)(4, 4)
connect(interval.value, sequence.inp)
ip = dragonfly.time.interpolation("Coordinate")((0, 0, 0), (0, -5, 0))
connect(sequence.outp1, ip)
connect(ip, setPos)
connect(key_w, ip.start)
connect(key_s, ip.stop)
ip2 = dragonfly.time.interpolation("Coordinate")((0, -5, 0), (0, 0, 0))
connect(sequence.outp2, ip2)
connect(ip2, setPos)
connect(key_w, ip2.start)
connect(key_s, ip2.stop)
pandaspawn = dragonfly.scene.spawn_actor()
v_panda = dragonfly.std.variable("id")(pandaclassname_)
connect(v_panda, pandaspawn)
panda_id = dragonfly.std.generator("id", id_generator)()
random_matrix = dragonfly.std.generator(("object", "matrix"),
random_matrix_generator)()
w_spawn = dragonfly.std.weaver(("id", ("object", "matrix")))()
connect(panda_id, w_spawn.inp1)
connect(random_matrix, w_spawn.inp2)
do_spawn = dragonfly.std.transistor(("id", ("object", "matrix")))()
connect(w_spawn, do_spawn)
connect(do_spawn, pandaspawn.spawn_matrix)
key_z = dragonfly.io.keyboardsensor_trigger("Z")
connect(key_z, do_spawn)
pandaicon_click = dragonfly.io.mouseareasensor("pandaicon")
connect(pandaicon_click, do_spawn)
myscene = myscene(
scene="scene",
canvas=canvas,
mousearea=mousearea,
)
class myhive(dragonfly.pandahive.pandahive):
pandaclassname = "pandaclass"
pandaclassname_ = bee.attribute("pandaclassname")
canvas = dragonfly.pandahive.pandacanvas()
mousearea = dragonfly.canvas.mousearea()
raiser = bee.raiser()
connect("evexc", raiser)
camerabind = camerabind().worker()
camcenter = dragonfly.std.variable("id")("camcenter")
connect(camcenter, camerabind.bindname)
startsensor = dragonfly.sys.startsensor()
cam = dragonfly.scene.get_camera()
camparent = dragonfly.scene.unbound.parent()
connect(cam, camparent.entityname)
connect(camcenter, camparent.entityparentname)
connect(startsensor, camparent)
cphide = dragonfly.scene.unbound.hide()
connect(camcenter, cphide)
connect(startsensor, cphide)
pandaspawn = dragonfly.scene.spawn_actor()
v_panda = dragonfly.std.variable("id")(pandaclassname_)
connect(v_panda, pandaspawn)
panda_id_gen = dragonfly.std.generator("id", id_generator)()
panda_id = dragonfly.std.variable("id")("")
t_panda_id_gen = dragonfly.std.transistor("id")()
connect(panda_id_gen, t_panda_id_gen)
connect(t_panda_id_gen, panda_id)
random_matrix = dragonfly.std.generator(("object", "matrix"),
random_matrix_generator)()
w_spawn = dragonfly.std.weaver(("id", ("object", "matrix")))()
connect(panda_id, w_spawn.inp1)
connect(random_matrix, w_spawn.inp2)
z_pandawalk = pandawalkbind().worker()
t_bind = dragonfly.std.transistor("id")()
connect(panda_id, t_bind)
connect(t_bind, z_pandawalk.bind)
do_spawn = dragonfly.std.transistor(("id", ("object", "matrix")))()
connect(w_spawn, do_spawn)
connect(do_spawn, pandaspawn.spawn_matrix)
trig_spawn = dragonfly.std.pushconnector("trigger")()
connect(trig_spawn, t_panda_id_gen)
connect(trig_spawn, do_spawn)
connect(trig_spawn, t_bind)
key_z = dragonfly.io.keyboardsensor_trigger("Z")
connect(key_z, trig_spawn)
pandaicon_click = dragonfly.io.mouseareasensor("pandaicon")
connect(pandaicon_click, trig_spawn)
myscene = myscene(
scene="scene",
canvas=canvas,
mousearea=mousearea,
)
wininit = bee.init("window")
wininit.camera.setPos(0, 45, 25)
wininit.camera.setHpr(180, -20, 0)
keyboardevents = dragonfly.event.sensor_match_leader("keyboard")
add_head = dragonfly.event.add_head()
head = dragonfly.std.variable("event")("spawnedpanda3")
connect(keyboardevents, add_head)
connect(head, add_head)
connect(add_head, z_pandawalk.event)
