class blenderhive(bee.inithive):
_hivecontext = hivemodule.appcontext(blenderapp)
# Allows hives to be launched for bound game objects on startup
startupbinder = startup_binder_drone()
inputhandler = inputhandlerhive()
connect(("inputhandler", "evout"), "evin")
scheduler = simplescheduler()
pacemaker = blenderpacemaker()
currscene = current_scene()
scene = blenderscene()
entityloader()
entityclassloader()
cameraloader()
animationloader = animationloader()
processmanager = processmanager()
messagehandler = messagehandler()
near_drone = near_drone()
exitactuator = exitactuator()
# TODO read key from API
keyboardsensor_exit = keyboardsensor_trigger("ESCAPE")
connect("keyboardsensor_exit", "exitactuator")
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 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 consolehive(bee.inithive):
_hivecontext = hivemodule.appcontext(consoleapp)
inputhandler = inputhandlerhive()
connect(("inputhandler", "evout"), "evin")
scheduler = simplescheduler()
exitactuator = exitactuator()
keyboardsensor_exit = keyboardsensor_trigger("ESCAPE")
pacemaker = pacemaker_simple()
connect("keyboardsensor_exit", "exitactuator")
class myhive(dragonfly.pandahive.pandahive):
canvas = dragonfly.pandahive.pandacanvas()
start = dragonfly.sys.startsensor()
grid = dragonfly.std.variable(gridparamtype)((grid, box, params))
draw = dragonfly.canvas.draw(("object", "bgrid"))()
do_draw = dragonfly.std.transistor(gridparamtype)()
connect(grid, do_draw)
connect(do_draw, draw)
connect(start, do_draw)
class dynamicbindhive_(bee.frame):
# Create a binder worker
hive_binder = bind_class().worker()
bind_worker = bindworkerinterface()
# Weaver of these two
w_bind_ids = std.weaver(("id", "id"))()
bee.connect(bind_worker.process_identifier, w_bind_ids.inp1)
bee.connect(bind_worker.hivemap_name, 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)
bee.connect(bind_worker.trig, t_bind_ids.trig)
# TODO more event types
head = convert.pull.duck("id", "event")()
bee.connect(bind_worker.process_identifier, head)
keyboardevents = event.sensor_match_leader("keyboard")
add_head = event.add_head()
bee.connect(keyboardevents, add_head)
bee.connect(head, add_head)
bee.connect(add_head, hive_binder.event)
hivereg = hiveregister()
class mainhive(myhive):
pandalogic = pandalogichive2(hivereg="hivereg")
connect(pandalogic.set_panda, "v_panda")
connect(pandalogic.set_panda, "v_hivename")
connect(pandalogic.trig_spawn, "trig_spawn")
camerabind = camerabind2().worker()
myscene = myscene2(
scene="scene",
canvas="canvas",
mousearea="mousearea",
)
class myhive(dragonfly.pandahive.pandahive):
raiser = bee.raiser()
connect("evexc", raiser)
animation = dragonfly.scene.unbound.animation()
pandaid = dragonfly.std.variable("id")("mypanda")
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)
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)
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}
