class myscene(myspyderframe):
scene = bee.parameter("bee")
canvas = bee.parameter("bee")
mousearea = bee.parameter("bee")
a = Spyder.AxisSystem()
a *= 0.25
a.origin += (-8, 42, 0)
env = Spyder.Model3D("models/environment", "egg", a)
a = Spyder.AxisSystem()
a *= 0.005
mypanda = Spyder.Actor3D("models/panda-model", "egg", [("walk", "models/panda-walk4", "egg")], a,
entityname="mypanda")
a = Spyder.AxisSystem()
a *= 0.005
pandaclass = Spyder.ActorClass3D("models/panda-model", "egg", [("walk", "models/panda-walk4", "egg")], a,
actorclassname="pandaclass")
box = Spyder.Box2D(50, 470, 96, 96)
icon = Spyder.Icon("pandaicon.png", "pandaicon", box, transparency=True)
m1 = Spyder.NewMaterial("red", (255, 0, 0))
m2 = Spyder.NewMaterial("green", (0, 255, 0))
m3 = Spyder.NewMaterial("blue", (0, 0, 255))
m_ax = Spyder.AxisSystem(origin=(5, -3, 0))
m_ax2 = Spyder.AxisSystem(origin=(-5, -3, 3))
m_ax2.rotateZ(30)
m_ax2.rotateX(-60)
del a, box
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_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_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 jumpworkerhive(bee.frame):
height = bee.parameter("float")
duration = bee.parameter("float")
i = dragonfly.time.interval_time(time=bee.get_parameter("duration"))
startconnector = dragonfly.std.pushconnector("trigger")()
connect(startconnector, i.start)
start = bee.antenna(startconnector.inp)
jump = jumpworker2(height=bee.get_parameter("height"))
connect(i, jump)
t_jump = dragonfly.std.transistor("float")()
connect(jump, t_jump)
dojump = dragonfly.scene.bound.setZ()
connect(t_jump, dojump)
tick = dragonfly.io.ticksensor(False)
connect(tick, t_jump)
connect(startconnector, tick.start)
connect(i.reach_end, tick.stop)
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 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"],
}
