class myscene(bee.frame):
pandaclassname_ = bee.get_parameter("pandaclassname")
pandaname_ = bee.get_parameter("pandaname")
c1 = bee.configure("scene")
c1.import_mesh_EGG("models/environment")
a = NodePath("")
a.setScale(0.25)
a.setPos(-8, 42, 0)
mat = a.getMat()
m = (mat.getRow3(3), mat.getRow3(0), mat.getRow3(1), mat.getRow3(2))
c1.add_model_MATRIX(matrix=m)
c2 = bee.configure("scene")
c2.import_mesh_EGG("models/panda-model")
a = NodePath("")
a.setScale(0.005)
mat = a.getMat()
m = (mat.getRow3(3), mat.getRow3(0), mat.getRow3(1), mat.getRow3(2))
c2.add_actor_MATRIX(matrix=m, entityname=pandaname_)
c2.import_mesh_EGG("models/panda-walk4")
c2.add_animation("walk")
c3 = bee.configure("scene")
c3.import_mesh_EGG("models/panda-model")
a = NodePath("")
a.setScale(0.005)
mat = a.getMat()
m = (mat.getRow3(3), mat.getRow3(0), mat.getRow3(1), mat.getRow3(2))
c3.add_actorclass_MATRIX(matrix=m, actorclassname=pandaclassname_)
c3.import_mesh_EGG("models/panda-walk4")
c3.add_animation("walk")
del a, m, mat
def show_datablock(b):
cf = configure("scene")
cf.start_block(b.pname, mode="datablock")
cf.import_from_parentblock("materials")
cf2 = b.object[0].make_bee()
cf3 = configure("scene")
cf3.end_block()
return multiconfigure(cf, cf2, cf3)
def show_objectgroup(og):
cf = configure("scene")
cf.start_block(mode="compile")
cf.import_from_parentblock("materials")
cf2 = og.group.make_bee()
cf3 = configure("scene")
cf3.render_block_SPYDER(axissystem=og.axis)
cf3.end_block()
return multiconfigure(cf, cf2, cf3)
def show_entityclass(e):
cf = configure("scene")
cf.start_block(mode="compile")
cf.import_from_parentblock("materials")
cf2 = e.objects.make_bee()
cf3 = configure("scene")
cf3.add_block_entityclass(entityclassname=e.entityclassname, material=e.material)
cf3.end_block()
return multiconfigure(cf, cf2, cf3)
def show_entity(e):
cf = configure("scene")
cf.start_block(mode="compile")
cf.import_from_parentblock("materials")
cf2 = e.objects.make_bee()
cf3 = configure("scene")
cf3.render_block_SPYDER(entityname=e.entityname)
cf3.end_block()
return multiconfigure(cf, cf2, cf3)
def show_multi_entity_instance(mi):
cf = configure("scene")
cf.start_block(mode="compile")
cf.import_from_parentblock("materials")
cf2 = mi.object.make_bee()
cf3 = configure("scene")
for axis, entityname in zip(mi.instances, mi.entitynames):
cf3.render_block_SPYDER(axissystem=axis, entityname=entityname)
cf3.end_block()
return multiconfigure(cf, cf2, cf3)
def show_objectlist3d(ol):
cf = configure("scene")
cf.start_block()
cf.import_from_parentblock("materials")
configures = [cf]
for o in ol:
configures.append(o.make_bee())
cf = configure("scene")
cf.end_block()
configures.append(cf)
return multiconfigure(configures)
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
def show_object(obj):
# only works for objects without face-specific materials
#TODO: texturecoords
cf = configure("scene")
cf.start_block()
cf.import_from_parentblock("materials")
vertices = [(c.x, c.y, c.z) for c in obj.vertices]
faces = [tuple(f.vertices) for f in obj.faces]
normals = []
for f in obj.faces:
normal = f.normal
if f.normal is None:
verts = [obj.vertices[n] for n in f.vertices]
normal = spyder.tarantula.calc_normal(verts)
normals.append((normal.x, normal.y, normal.z))
if obj.lighting == "flat":
normals = None ###
cf.create_mesh_per_face("mesh", vertices, faces, normals, None, None, None, obj.material)
else:
vertexnormals = []
for vnr in range(len(vertices)):
avgnormal = Spyder.Coordinate(0, 0, 0)
for fnr, f in enumerate(faces):
if vnr in f: avgnormal += normals[fnr]
avgnormal = avgnormal.normalize()
vertexnormals.append((avgnormal.x, avgnormal.y, avgnormal.z))
cf.create_mesh_per_vertex("mesh", vertices, vertexnormals, None, None, faces, obj.material)
cf.add_model_SPYDER("mesh", "model", axissystem=obj.axis)
cf.end_block()
return cf
class myscene(bee.frame):
pandaclassname_ = bee.get_parameter("pandaclassname")
pandaname_ = bee.get_parameter("pandaname")
pandaicon_ = bee.get_parameter("pandaicon")
c1 = bee.configure("scene")
c1.import_mesh_EGG("models/environment")
a = NodePath("")
a.setScale(0.25)
a.setPos(-8, 42, 0)
mat = a.getMat()
m = (mat.getRow3(3), mat.getRow3(0), mat.getRow3(1), mat.getRow3(2))
c1.add_model_MATRIX(matrix=m)
c2 = bee.configure("scene")
c2.import_mesh_EGG("models/panda-model")
a = NodePath("")
a.setScale(0.005)
mat = a.getMat()
m = (mat.getRow3(3), mat.getRow3(0), mat.getRow3(1), mat.getRow3(2))
c2.add_actor_MATRIX(matrix=m, entityname=pandaname_)
c2.import_mesh_EGG("models/panda-walk4")
c2.add_animation("walk")
c3 = bee.configure("scene")
c3.import_mesh_EGG("models/panda-model")
a = NodePath("")
a.setScale(0.005)
mat = a.getMat()
m = (mat.getRow3(3), mat.getRow3(0), mat.getRow3(1), mat.getRow3(2))
c3.add_actorclass_MATRIX(matrix=m, actorclassname=pandaclassname_)
c3.import_mesh_EGG("models/panda-walk4")
c3.add_animation("walk")
box = box2d(50, 470, 96, 96)
params = parameters()
params.transparency = True
args = canvasargs("pandaicon.png", pandaicon_, box, params)
plugin = plugin_single_required(args)
pattern = ("canvas", "draw", "init", ("object", "image"))
d1 = dummydrone(plugindict={pattern: plugin})
i1 = bee.init("mousearea")
i1.register(pandaicon_, box)
del a, m, mat, box, params, args, plugin, pattern
def show_panda(c):
cf = bee.configure("scene")
cf.import_mesh_EGG("models/panda-model")
a = Spyder.AxisSystem()
a *= 0.001
a.origin = c
cf.add_model_SPYDER(axissystem=a)
return cf
def show_model(m):
cf = configure("scene")
cf.start_block()
cf.import_from_parentblock("materials")
if m.meshformat != "egg": raise ValueError("panda can render only egg/bam meshes, not '%s'" % m.meshformat)
cf.import_mesh_EGG(m.meshfilename)
cf.add_model_SPYDER(modelname="model", axissystem=m.axis, material=m.material, entityname=m.entityname)
cf.end_block()
return cf
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 myscene(bee.frame):
pandaclassname_ = bee.get_parameter("pandaclassname")
pandaname_ = bee.get_parameter("pandaname")
pandaicon_ = bee.get_parameter("pandaicon")
c1 = bee.configure("scene")
c1.import_mesh_EGG("models/environment")
a = Spyder.AxisSystem()
a *= 0.25
a.origin += (-8, 42, 0)
c1.add_model_SPYDER(axissystem=a)
c2 = bee.configure("scene")
c2.import_mesh_EGG("models/panda-model")
a = Spyder.AxisSystem()
a *= 0.005
c2.add_actor_SPYDER(axissystem=a, entityname=pandaname_)
c2.import_mesh_EGG("models/panda-walk4")
c2.add_animation("walk")
c3 = bee.configure("scene")
c3.import_mesh_EGG("models/panda-model")
a = Spyder.AxisSystem()
a *= 0.005
c3.add_actorclass_SPYDER(axissystem=a, actorclassname=pandaclassname_)
c3.import_mesh_EGG("models/panda-walk4")
c3.add_animation("walk")
box = box2d(50, 470, 96, 96)
params = parameters()
params.transparency = True
args = canvasargs("pandaicon.png", pandaicon_, box, params)
plugin = plugin_single_required(args)
pattern = ("canvas", "draw", "init", ("object", "image"))
d1 = dummydrone(plugindict={pattern: plugin})
i1 = bee.init("mousearea")
i1.register(pandaicon_, box)
del a, box, params, args, plugin, pattern
def show_actorclass(a):
cf = configure("scene")
cf.start_block()
cf.import_from_parentblock("materials")
if a.meshformat != "egg": raise ValueError("panda can render only egg/bam meshes, not '%s'" % a.meshformat)
cf.import_mesh_EGG(a.meshfilename)
cf.add_actorclass_SPYDER(a.actorclassname, axissystem=a.axis, material=a.material)
for m in a.animations:
# TODO check if every name is used only once
if m.format != "egg": raise ValueError("panda can render only egg/bam meshes, not '%s'" % m.format)
cf.import_mesh_EGG(m.filename)
cf.add_animation(m.pname)
cf.end_block()
return cf
class pandalogichive2(pandalogichive):
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
def reserve_slot(slot):
import bee
from bee.types import stringtupleparser
from dragonfly.canvas import box2d
c = bee.configure(slot.canvasname)
b = slot.box
box = box2d(b.x, b.y, b.sizex, b.sizey, b.mode)
params = None
col = slot.color
if col is not None:
params = parameters(color=(col.r,col.g,col.b,col.a))
c.reserve (
slot.slotname,
stringtupleparser(slot.slottype),
box=box,
parameters=params,
)
return c
def make_combo(self):
pandas = []
c_hivereg = bee.configure("hivereg")
pandalogics = [c_hivereg]
for name in pandadict:
panda = pandadict[name]
pandasceneframe = generate_pandasceneframe(name, panda)(
scene="scene", canvas="canvas", mousearea="mousearea")
pandas.append(pandasceneframe)
mode, data, box, image, hivemap = panda
hive = load_hive(hivemap)
c_hivereg.register_hive(name, hive)
p = pandalogicframe(name)
c1 = connect(p.set_panda, "do_set_panda")
c2 = connect(p.trig_spawn, "do_trig_spawn")
pandalogics += [p, c1, c2]
return {"myscene": pandas, "pandalogic": pandalogics}
def make_combo(self):
pandas = []
c_hivereg = bee.configure("hivereg")
pandalogics = [c_hivereg]
for name in pandadict:
panda = pandadict[name]
pandasceneframe = generate_pandasceneframe(name, panda)(scene="scene", canvas="canvas",
mousearea="mousearea")
pandas.append(pandasceneframe)
mode, data, box, image, hivemap = panda
hive = load_hive(hivemap)
c_hivereg.register_hive(name, hive)
p = pandalogicframe(name)
c1 = connect(p.set_panda, "do_set_panda")
c2 = connect(p.trig_spawn, "do_trig_spawn")
pandalogics += [p, c1, c2]
return {"myscene": pandas, "pandalogic": pandalogics}
def load_panda(mpanda):
pandas = []
c_hivereg = bee.configure("hivereg")
pandalogics = [c_hivereg]
pandas.append(mpanda.model[0])
icon = Spyder.Icon(mpanda.image,
mpanda.pname,
mpanda.box,
transparency=mpanda.transparency)
pandas.append(icon)
hive = load_hive(mpanda.hivemap)
c_hivereg.register_hive(mpanda.pname, hive)
p = pandalogicframe(mpanda.pname)
c1 = connect(p.set_panda, "do_set_panda")
c2 = connect(p.trig_spawn, "do_trig_spawn")
pandalogics += [p, c1, c2]
return {"myscene": pandas, "pandalogic": pandalogics}
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
def load_panda(mpanda):
pandas = []
c_hivereg = bee.configure("hivereg")
pandalogics = [c_hivereg]
pandas.append(mpanda.model[0])
icon = Spyder.Icon(
mpanda.image,
mpanda.pname,
mpanda.box,
transparency=mpanda.transparency
)
pandas.append(icon)
hive = load_hive(mpanda.hivemap)
c_hivereg.register_hive(mpanda.pname, hive)
p = pandalogicframe(mpanda.pname)
c1 = connect(p.set_panda, "do_set_panda")
c2 = connect(p.trig_spawn, "do_trig_spawn")
pandalogics += [p, c1, c2]
return {"myscene": pandas, "pandalogic": pandalogics}
class mycombohive(bee.combohive):
pandas = []
c_hivereg = bee.configure("hivereg")
pandalogics = [c_hivereg]
for name in pandadict:
panda = pandadict[name]
pandasceneframe = generate_pandasceneframe(name, panda)(scene="scene", canvas="canvas", mousearea="mousearea")
pandas.append(pandasceneframe)
mode, data, box, image, hivemap = panda
hive = load_hive(hivemap)
c_hivereg.register_hive(name, hive)
p = pandalogicframe(name)
c1 = connect(p.set_panda, "do_set_panda")
c2 = connect(p.trig_spawn, "do_trig_spawn")
pandalogics += [p, c1, c2]
del pandasceneframe
cb = bee.combodronewrapper({"myscene": pandas, "pandalogic": pandalogics})
del name, panda, pandas, pandalogics
del mode, data, box, image, hivemap
del hive, p, c1, c2
del c_hivereg
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)
def create_material(mat):
# only for color materials
cf = configure("scene")
c = mat.color
cf.create_material_COLOR(mat.pname, (c.r / 255.0, c.g / 255.0, c.b / 255.0))
return cf
