def build_keyboard(cls, i, ex, args, meta_args): """Listen for keyboard event""" if meta_args.mode == 'single key': ex.on_event = hive.socket(cls.add_single_listener, identifier="event.add_handler") args.key = hive.parameter("str.keycode", "w") i.key = hive.property(cls, "key", "str.keycode", args.key) i.push_key = hive.push_in(i.key) ex.key = hive.antenna(i.push_key) i.on_key_changed = hive.triggerable(cls.change_listener_keys) hive.trigger(i.push_key, i.on_key_changed) i.on_pressed = hive.triggerfunc() ex.on_pressed = hive.hook(i.on_pressed) i.on_released = hive.triggerfunc() ex.on_released = hive.hook(i.on_released) i.is_pressed = hive.property(cls, "is_pressed", "bool") i.pull_is_pressed = hive.pull_out(i.is_pressed) ex.is_pressed = hive.output(i.pull_is_pressed) else: ex.on_event = hive.socket(cls.add_any_listener, identifier="event.add_handler") i.key_pressed = hive.property(cls, 'key_pressed', data_type='str.keycode') i.pull_key_pressed = hive.push_out(i.key_pressed) ex.key_pressed = hive.output(i.pull_key_pressed) i.key_released = hive.property(cls, 'key_released', data_type='str.keycode') i.pull_key_released = hive.push_out(i.key_released) ex.key_released = hive.output(i.pull_key_released)
def build_filler(i, ex, args, meta_args): print("NEW FILLER", meta_args.i) if meta_args.i: i.inner = FillerHive(meta_args.i - 1, import_namespace=True) ex.inner = hive.hook(i.inner) else: i.inner = DogHive(import_namespace=True, name="DOGGY") ex.inner = hive.hook(i.inner)
def build_house(cls, i, ex, args): ex.some_plugin = hive.plugin(cls.get_current_hive, identifier="get.house", data_type="float") # Auto connect i.filler = FillerHive() ex.filler = hive.hook(i.filler) # Manual connect i.fido = DogHive(name="Main", import_namespace=False) ex.fido = hive.hook(i.fido) hive.connect(ex.some_plugin, i.fido.some_socket)
def build_toggle(i, ex, args): """Toggle between two triggers""" args.start_value = hive.parameter('bool', False) i.toggle = hive.attribute("bool", args.start_value) i.modifier = hive.modifier(evaluate_toggle) ex.trig_in = hive.entry(i.modifier) i.trig_a = hive.triggerfunc() i.trig_b = hive.triggerfunc() ex.trig_a = hive.hook(i.trig_a) ex.trig_b = hive.hook(i.trig_b)
def build_watch(cls, i, ex, args, meta_args): """Watch value and indicate when it is changed. Uses a tick callback. """ args.start_value = hive.parameter(meta_args.data_type, None) i.value = hive.property(cls, "current_value", meta_args.data_type, args.start_value) if meta_args.mode == 'pull': i.value_in = hive.pull_in(i.value) else: i.value_in = hive.push_in(i.value) ex.value = hive.antenna(i.value_in) i.on_changed = hive.triggerfunc() ex.on_changed = hive.hook(i.on_changed) if meta_args.mode == 'pull': ex.get_add_handler = hive.socket(cls.set_add_handler, identifier="event.add_handler") else: i.compare_values = hive.triggerable(cls.compare_values) hive.trigger(i.value_in, i.compare_values)
def build_and(i, ex, args): ex.a_value = hive.attribute(("bool", ), False) ex.b_value = hive.attribute(("bool", ), False) i.a = hive.pull_in(ex.a_value) i.b = hive.pull_in(ex.b_value) ex.a = hive.antenna(i.a) ex.b = hive.antenna(i.b) def on_and(h): h._pull_inputs() if h.a_value and h.b_value: h.trig_out() i.trig_out = hive.triggerfunc() i.trig_in = hive.modifier(on_and) # Update attributes before calling modifier i.pull_inputs = hive.triggerfunc() hive.trigger(i.pull_inputs, i.a, pretrigger=True) hive.trigger(i.pull_inputs, i.b, pretrigger=True) ex.trig_out = hive.hook(i.trig_out) ex.trig_in = hive.entry(i.trig_in)
def build_foreach(i, ex, args, meta_args): """Iterate over iterable object""" # Set iterable i.iterable = hive.variable("$iterable[int]") i.pull_iterable = hive.pull_in(i.iterable) ex.iterable = hive.antenna(i.pull_iterable) i.do_trig = hive.triggerfunc() i.trig_in = hive.triggerable(i.do_trig) ex.start = hive.entry(i.trig_in) i.break_ = hive.variable('bool', False) i.item = hive.variable(meta_args.data_type) i.push_item = hive.push_out(i.item) ex.item = hive.output(i.push_item) i.index = hive.variable('int', 0) i.pull_index = hive.pull_out(i.index) ex.index = hive.output(i.pull_index) i.finished = hive.triggerfunc() i.do_break = hive.modifier(do_break) ex.break_ = hive.entry(i.do_break) ex.finished = hive.hook(i.finished) i.iter = hive.modifier(do_iter) hive.trigger(i.do_trig, i.pull_iterable) hive.trigger(i.do_trig, i.iter)
def build_dog(cls, i, ex, args): i.call = hive.triggerfunc(cls.call) i.woof = hive.triggerable(cls.woof) hive.trigger(i.call, i.woof) i.bark = hive.triggerfunc() hive.trigger(i.bark, i.woof) i.woof_only = hive.triggerable(cls.woof) i.woofed = hive.triggerfunc() ex.woofs = hive.property(cls, "woofs") ex.woof = hive.entry(i.woof) ex.woof_only = hive.entry(i.woof_only) ex.woofed = hive.hook(i.woofed) ex.bark = hive.hook(i.bark) ex.call = hive.hook(i.call)
def build_dog(cls, i, ex, args): i.call = h.triggerfunc(cls.call) i.woof = h.triggerable(cls.woof) #h.trigger(i.call, i.woof) h.connect(i.call, i.woof) i.woof2 = h.modifier(woof2) i.bark = h.triggerfunc() h.trigger(i.bark, i.woof) i.woofed = h.triggerfunc() ex.woofs = h.property(cls, "woofs") ex.name = h.property(cls, "name") ex.woofs2 = h.variable(data_type="int", start_value=0) ex.woof = h.entry(i.woof) ex.woofed = h.hook(i.woofed) ex.bark = h.hook(i.bark) ex.call = h.hook(i.call)
def build_switch(i, ex, args, meta_args): """Redirect input trigger to true / false outputs according to boolean evaluation of switch value""" ex.switch = hive.attribute(meta_args.data_type) i.input = hive.pull_in(ex.switch) ex.input = hive.antenna(i.input) i.true = hive.triggerfunc() ex.true = hive.hook(i.true) i.false = hive.triggerfunc() ex.false = hive.hook(i.false) i.do_evaluate = hive.modifier(evaluate_switch) i.do_trigger = hive.triggerfunc(i.do_evaluate) hive.trigger(i.do_trigger, i.input, pretrigger=True) i.on_trigger = hive.triggerable(i.do_trigger) ex.trigger = hive.entry(i.on_trigger)
def build_while(i, ex, args): """Trigger output while condition is True""" ex.condition = hive.attribute() i.condition_in = hive.pull_in(ex.condition) ex.condition_in = hive.antenna(i.condition_in) i.trig = hive.triggerfunc() ex.trig_out = hive.hook(i.trig) i.trig_in = hive.modifier(do_while) ex.trig_in = hive.entry(i.trig_in)
def build_listener(cls, i, ex, args, meta_args): """Tick event sensor, trigger on_tick every tick""" i.on_event = hive.triggerfunc() ex.on_event = hive.hook(i.on_event) ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler") if meta_args.mode == 'leader': i.after_leader = hive.property(cls, 'after_leader', 'tuple') i.pull_after_leader = hive.pull_out(i.after_leader) ex.after_leader = hive.output(i.pull_after_leader)
def build_mouse(cls, i, ex, args): ex.on_event = hive.socket(cls.set_add_handler, identifier="event.add_handler") i.on_tick = hive.triggerfunc() args.button = hive.parameter("str", "left", options={"left", "middle", "right"}) i.button = hive.property(cls, "button", "str", args.button) i.push_button = hive.push_in(i.button) ex.button = hive.antenna(i.push_button) i.on_button_changed = hive.triggerable(cls.change_listener_buttons) hive.trigger(i.push_button, i.on_button_changed) i.on_pressed = hive.triggerfunc() ex.on_pressed = hive.hook(i.on_pressed) i.on_moved = hive.triggerfunc() ex.on_moved = hive.hook(i.on_moved) i.pos_x = hive.property(cls, "pos_x", "float") i.pull_x = hive.pull_out(i.pos_x) ex.x = hive.output(i.pull_x) i.pos_y = hive.property(cls, "pos_y", "float") i.pull_y = hive.pull_out(i.pos_y) ex.y = hive.output(i.pull_y) i.dx = hive.property(cls, "dx", "float") i.pull_dx = hive.pull_out(i.dx) ex.dx = hive.output(i.pull_dx) i.dy = hive.property(cls, "dy", "float") i.pull_dy = hive.pull_out(i.dy) ex.dy = hive.output(i.pull_dy) i.is_pressed = hive.property(cls, "is_pressed", "bool") i.pull_is_pressed = hive.pull_out(i.is_pressed) ex.is_pressed = hive.output(i.pull_is_pressed)
def build_tick(cls, i, ex, args): """Tick event sensor, trigger on_tick every tick""" i.on_tick = hive.triggerfunc() ex.on_tick = hive.hook(i.on_tick) ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler", policy=hive.SingleRequired) ex.get_remove_handler = hive.socket(cls.set_remove_handler, "event.remove_handler", policy=hive.SingleRequired) i.enable = hive.triggerable(cls.enable) ex.enable = hive.entry(i.enable) i.disable = hive.triggerable(cls.disable) ex.disable = hive.entry(i.disable)
def build_keyboard(cls, i, ex, args): ex.on_event = hive.socket(cls.add_single_listener, identifier="event.add_handler") i.on_tick = hive.triggerfunc() ex.name = hive.variable(("str", ), "<Sensor>") ex.key = hive.property(cls, "key", "str") ex.is_positive = hive.variable(("bool", ), False) i.positive = hive.pull_out(ex.is_positive) ex.positive = hive.output(i.positive) i.trig_out = hive.triggerfunc() ex.trig_out = hive.hook(i.trig_out)
def build_house(cls, i, ex, args): i.brutus = dog("Brutus") i.fifi = dog("Fifi") i.dog_comes = h.triggerable(cls.dog_comes) h.trigger(i.brutus.call, i.dog_comes) i.mail = h.triggerfunc(cls.mail) h.trigger(i.mail, i.fifi.woof) ex.brutus = i.brutus ex.fifi = i.fifi ex.mail = h.hook(i.mail) ex.dog_comes = h.entry(i.dog_comes)
def build_house(cls, i, ex, args): i.brutus_ = DogHive("Brutus") i.fifi = DogHive("Fifi") i.dog_appeared = hive.triggerable(cls.dog_appeared) hive.trigger(i.brutus_.call, i.dog_appeared) i.mail_arrived = hive.triggerfunc(cls.mail_arrived) hive.trigger(i.mail_arrived, i.fifi.woof) ex.brutus = i.brutus_ ex.fifi = i.fifi ex.mail_arrived = hive.hook(i.mail_arrived) ex.dog_appeared = hive.entry(i.dog_appeared)
def build_server(cls, i, ex, args): i.connect_address = hive.property(cls, "server_address", "tuple") i.push_connect = hive.push_in(i.connect_address) ex.connect_to = hive.antenna(i.push_connect) i.do_connect = hive.triggerable(cls.do_connect) hive.trigger(i.push_connect, i.do_connect) # Hive callbacks i.on_disconnected = hive.triggerfunc() i.on_connected = hive.triggerfunc() i.on_received = hive.triggerfunc() # Receiving connection ex.on_connected = hive.hook(i.on_connected) # Lost connection ex.on_disconnected = hive.hook(i.on_disconnected) # Receiving i.received_data = hive.property(cls, "received_data", "bytes") i.push_received = hive.push_out(i.received_data) ex.on_received = hive.output(i.push_received) hive.trigger(i.on_received, i.push_received) # Sending i.outgoing_data = hive.property(cls, "outgoing_data", "bytes") i.push_outgoing_data = hive.push_in(i.outgoing_data) ex.send = hive.antenna(i.push_outgoing_data) i.do_send_data = hive.triggerable(cls.do_send) hive.trigger(i.push_outgoing_data, i.do_send_data) i.synchronise_data = hive.triggerable(cls.synchronise) i.on_tick = OnTick() hive.connect(i.on_tick.on_tick, i.synchronise_data)
def build_always(i, ex, args): ex.name = hive.variable(("str", ), "<Sensor>") ex.is_positive = hive.variable(("bool", ), True) i.positive = hive.pull_out(ex.is_positive) ex.positive = hive.output(i.positive) def trigger(h): h.trig_out() i.trig_in = hive.modifier(trigger) ex.trig_in = hive.entry(i.trig_in) i.trig_out = hive.triggerfunc() ex.trig_out = hive.hook(i.trig_out)
def build_variable(i, ex, args, meta_args): """Simple value-holding hive""" args.start_value = hive.parameter(meta_args.data_type) ex.value = hive.variable(meta_args.data_type, args.start_value) i.pull_value = hive.pull_out(ex.value) ex.value_out = hive.output(i.pull_value) i.push_value = hive.push_in(ex.value) ex.value_in = hive.antenna(i.push_value) if meta_args.advanced: i.pre_output = hive.triggerfunc() ex.pre_output = hive.hook(i.pre_output) i.do_pre_output = hive.triggerable(i.pre_output) hive.trigger(i.pull_value, i.do_pre_output, pretrigger=True)
def build_mainloop(cls, i, ex, args): """Blocking fixed-timestep trigger generator""" i.tick = hive.triggerfunc() i.stop = hive.triggerable(cls.stop) i.run = hive.triggerable(cls.run) ex.tick = hive.hook(i.tick) ex.run = hive.entry(i.run) ex.stop = hive.entry(i.stop) i.tick_rate = hive.property(cls, "tick_rate", 'int') i.pull_tick_rate = hive.pull_out(i.tick_rate) ex.tick_rate = hive.output(i.pull_tick_rate) ex.get_tick_rate = hive.plugin(cls.get_tick_rate, identifier="app.get_tick_rate") ex.quit = hive.plugin(cls.stop, identifier="app.quit")
def build_timer(i, ex, args): i.dt = hive.variable("float", 0.0) ex.step = hive.variable("float", 1 / 60) def start(self): last = clock() while True: now = clock() self._dt += now - last if self._dt > self.step: self._dt -= self.step self.tick() last = now i.start = hive.modifier(start) ex.start = hive.entry(i.start) i.tick = hive.triggerfunc() ex.tick = hive.hook(i.tick)
def build_delay(cls, i, ex, args): """Delay input trigger by X ticks, where X is the value of delay_in (greater than zero)""" i.on_elapsed = hive.triggerfunc() ex.on_elapsed = hive.hook(i.on_elapsed) i.trigger = hive.triggerfunc(cls.on_triggered) i.do_trig = hive.triggerable(i.trigger) ex.trig_in = hive.entry(i.do_trig) ex.delay = hive.property(cls, "delay", "float") i.delay_in = hive.pull_in(ex.delay) ex.delay_in = hive.antenna(i.delay_in) i.elapsed = hive.pull_out(cls.elapsed) ex.elapsed = hive.output(i.elapsed) hive.trigger(i.trigger, i.delay_in, pretrigger=True) ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler") ex.get_remove_handler = hive.socket(cls.set_remove_handler, "event.remove_handler") ex.get_get_tick_rate = hive.socket(cls.set_get_tick_rate, "app.get_tick_rate")
def build_collision(cls, i, ex, args): """Interface to collision events for bound hive""" i.hit_entity = hive.property(cls, "hit_entity_id", "int.entity_id") i.hit_position = hive.property(cls, "hit_position", "vector") i.hit_normal = hive.property(cls, "hit_normal", "vector") i.hit_impulse = hive.property(cls, "hit_impulse", "vector") i.pull_hit_entity = hive.pull_out(i.hit_entity) i.pull_hit_position = hive.pull_out(i.hit_position) i.pull_hit_normal = hive.pull_out(i.hit_normal) i.pull_hit_impulse = hive.pull_out(i.hit_impulse) ex.hit_entity = hive.output(i.pull_hit_entity) ex.hit_position = hive.output(i.pull_hit_position) ex.hit_normal = hive.output(i.pull_hit_normal) ex.hit_impulse = hive.output(i.pull_hit_impulse) i.on_collided = hive.triggerfunc() ex.on_collided = hive.hook(i.on_collided) ex.get_get_entity_id = hive.socket(cls.set_get_entity_id, "entity.get_bound") ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler")
def build_cycle(i, ex, args): """Emit trigger to trig_out when N triggers to trig_in are received, where N = period_in""" ex.period = hive.attribute("int", 0) ex.counter = hive.attribute("int", 0) i.period_in = hive.pull_in(ex.period) i.counter_out = hive.pull_out(ex.counter) ex.index = hive.output(i.counter_out) ex.period_in = hive.antenna(i.period_in) ex.trig_in = hive.entry(i.period_in) def cycle(self): self.counter += 1 if self.counter >= self.period: self.counter -= self.period self._output() i.trigger = hive.modifier(cycle) hive.trigger(i.period_in, i.trigger) i.output = hive.triggerfunc() ex.trig_out = hive.hook(i.output)
def build_on_stop(cls, i, ex, args): """Listen for quit event""" ex.get_add_handler = hive.socket(cls.set_add_handler, "event.add_handler") i.on_stop = hive.triggerfunc() ex.on_stop = hive.hook(i.on_stop)