def build_server(cls, i, ex, args): i.local_address = hive.property(cls, "local_address", "tuple") i.push_bind_address = hive.push_in(i.local_address) ex.bind_to = hive.antenna(i.push_bind_address) i.do_bind = hive.triggerable(cls.do_bind) hive.trigger(i.push_bind_address, i.do_bind) # Receiving connection i.connected_address = hive.property(cls, "connected_address", "tuple") i.push_connected_address = hive.push_out(i.connected_address) ex.on_client_connected = hive.output(i.push_connected_address) # Receiving connection i.disconnected_address = hive.property(cls, "disconnected_address", "tuple") i.push_disconnected_address = hive.push_out(i.disconnected_address) ex.on_client_disconnected = hive.output(i.push_disconnected_address) # Receiving i.from_address = hive.property(cls, "from_address", "tuple") i.pull_from_address = hive.pull_out(i.from_address) ex.from_address = hive.output(i.pull_from_address) 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 callbacks i.on_disconnected = hive.triggerfunc() i.on_connected = hive.triggerfunc() i.on_received = hive.triggerfunc() hive.trigger(i.on_received, i.push_received) hive.trigger(i.on_connected, i.push_connected_address) hive.trigger(i.on_disconnected, i.push_disconnected_address) # Sending i.to_address = hive.property(cls, "to_address", "tuple") i.pull_to_address = hive.pull_in(i.to_address) ex.to_address = hive.antenna(i.pull_to_address) 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.pull_to_address, pretrigger=True) 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_set(i, ex, args, meta_args): """Perform set operation on single sets""" i.set_ = hive.attribute('set', set()) i.pull_set_ = hive.pull_out(i.set_) ex.set_out = hive.output(i.pull_set_) i.push_set_ = hive.push_in(i.set_) ex.set_ = hive.antenna(i.push_set_) # Pop item i.popped_item = hive.attribute(meta_args.data_type) i.pull_pop = hive.pull_out(i.popped_item) ex.pop = hive.output(i.pull_pop) def do_pop(self): self._popped_item = self._set_.pop() i.do_pop = hive.modifier(do_pop) hive.trigger(i.pull_pop, i.do_pop, pretrigger=True) # Add item i.to_add = hive.attribute(meta_args.data_type) i.push_to_add = hive.push_in(i.to_add) ex.add = hive.antenna(i.push_to_add) def to_add(self): self._set_.add(self._to_add) i.do_add = hive.modifier(to_add) hive.trigger(i.push_to_add, i.do_add) # Remove item i.to_remove = hive.attribute(meta_args.data_type) i.push_to_remove = hive.push_in(i.to_remove) ex.remove = hive.antenna(i.push_to_remove) def do_remove(self): self._set_.remove(self._to_remove) i.do_remove = hive.modifier(do_remove) hive.trigger(i.push_to_remove, i.do_remove) def do_clear(self): self._set_.clear() i.do_clear = hive.modifier(do_clear) ex.clear = hive.entry(i.do_clear)
def build_convert(i, ex, args, meta_args): i.value_in = hive.variable(meta_args.from_data_type) i.value_out = hive.variable(meta_args.to_data_type) # For push in, push out if meta_args.mode == "push": i.ppin = hive.push_in(i.value_in) i.ppout = hive.push_out(i.value_out) hive.trigger(i.ppin, i.ppout) else: i.ppin = hive.pull_in(i.value_in) i.ppout = hive.pull_out(i.value_out) hive.trigger(i.ppout, i.ppin, pretrigger=True) ex.value_in = hive.antenna(i.ppin) ex.value_out = hive.output(i.ppout) # For casting (explicit conversion) if meta_args.conversion == "cast": to_base_type_name = hive.get_base_data_type(meta_args.to_data_type) value_cls = _type_map[to_base_type_name] def converter(self): self._value_out = value_cls(self._value_in) i.do_conversion = hive.modifier(converter) hive.trigger(i.ppout, i.do_conversion, pretrigger=True) # For duck typing, move value through else: i.move_value = hive.modifier(move_value) hive.trigger(i.ppin, i.move_value)
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_instantiator(cls, i, ex, args, meta_args): """Instantiates a Hive class at runtime""" # If this is built now, then it won't perform matchmaking, so use meta hive bind_meta_class = hive.meta_hive("BindEnvironment", build_bind_environment, declare_build_environment, builder_cls=BindEnvironmentClass) #assert bind_meta_class._hive_object_class i.bind_meta_class = hive.property(cls, "bind_meta_class", "class", bind_meta_class) i.trig_instantiate = hive.triggerfunc(cls.instantiate) i.do_instantiate = hive.triggerable(i.trig_instantiate) i.hive_class = hive.property(cls, "hive_class", "class") i.pull_hive_class = hive.pull_in(i.hive_class) ex.hive_class = hive.antenna(i.pull_hive_class) ex.create = hive.entry(i.do_instantiate) hive.trigger(i.trig_instantiate, i.pull_hive_class, pretrigger=True) ex.process_id = hive.property(cls, "last_created_process_id", "int.process_id") i.pull_process_id = hive.pull_out(ex.process_id) ex.last_process_id = hive.output(i.pull_process_id) i.push_stop_process = hive.push_in(cls.stop_hive) ex.stop_process = hive.antenna(i.push_stop_process) # Bind class plugin ex.bind_on_created = hive.socket(cls.add_on_created, identifier="bind.on_created", policy=hive.MultipleOptional) ex.add_get_plugins = hive.socket(cls.add_get_plugins, identifier="bind.get_plugins", policy=hive.MultipleOptional) ex.add_get_config = hive.socket(cls.add_get_config, identifier="bind.get_config", policy=hive.MultipleOptional) # Bind instantiator if meta_args.bind_process == 'child': # Add startup and stop callbacks ex.on_stopped = hive.plugin(cls.stop_all_processes, identifier="on_stopped")
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_attr(i, ex, args, meta_args): """Set/get attribute on object""" i.name = hive.attribute("str") i.value = hive.attribute(meta_args.attribute_type) i.object_ = hive.attribute(meta_args.object_type) i.pull_name = hive.pull_in(i.name) i.pull_object = hive.pull_in(i.object_) ex.object_ = hive.antenna(i.pull_object) ex.name = hive.antenna(i.pull_name) if meta_args.mode == "set": i.push_value = hive.push_in(i.value) ex.value = hive.antenna(i.push_value) i.do_set_attr = hive.modifier(do_setattr) hive.trigger(i.push_value, i.pull_object) hive.trigger(i.pull_object, i.pull_name) hive.trigger(i.pull_name, i.do_set_attr) else: i.pull_value = hive.pull_out(i.value) ex.value = hive.output(i.pull_value) i.do_get_attr = hive.modifier(do_getattr) hive.trigger(i.pull_value, i.pull_object, pretrigger=True) hive.trigger(i.pull_object, i.pull_name) hive.trigger(i.pull_name, i.do_get_attr)
def build_unpack_tuple(i, ex, args, meta_args): """Unpack a tuple from individual inputs""" i.tuple_ = hive.attribute('tuple') i.push_tuple = hive.push_in(i.tuple_) ex.tuple_ = hive.antenna(i.push_tuple) for index, data_type in enumerate(meta_args.types): attr = hive.attribute(data_type) setattr(i, "attr_{}".format(index), attr) pull_out = hive.pull_out(attr) setattr(i, "pull_out_{}".format(index), pull_out) setattr(ex, "item_{}".format(index), hive.output(pull_out)) def do_unpack_tuple(self): tuple_ = self._tuple_ data_types = meta_args.types assert len(tuple_) == len(data_types) for index, item in enumerate(tuple_): setattr(self, "_attr_{}".format(index), item) i.do_unpack_tuple = hive.modifier(do_unpack_tuple) hive.trigger(i.push_tuple, i.do_unpack_tuple)
def build_item(i, ex, args, meta_args): """Set/get item in object""" i.name = hive.attribute(meta_args.index_type) i.value = hive.attribute(meta_args.item_type) i.container_ = hive.attribute(meta_args.container_type) i.pull_name = hive.pull_in(i.name) i.pull_container = hive.pull_in(i.container_) ex.container_ = hive.antenna(i.pull_container) ex.name = hive.antenna(i.pull_name) if meta_args.mode == "set": i.push_value = hive.push_in(i.value) ex.value = hive.antenna(i.push_value) i.do_set_attr = hive.modifier(do_setitem) hive.trigger(i.push_value, i.pull_container) hive.trigger(i.pull_container, i.pull_name) hive.trigger(i.pull_name, i.do_set_attr) else: i.pull_value = hive.pull_out(i.value) ex.value = hive.output(i.pull_value) i.do_get_attr = hive.modifier(do_getitem) hive.trigger(i.pull_value, i.pull_container, pretrigger=True) hive.trigger(i.pull_container, i.pull_name) hive.trigger(i.pull_name, i.do_get_attr)
def build_buffer(i, ex, args, meta_args): """Store the input value and output saved value. In pull mode, the trigger is used to update the internal value. In push mode, the trigger is used to output the internal value. Can be used to cache changing values """ args.start_value = hive.parameter(meta_args.data_type, None) i.cached_value = hive.attribute(meta_args.data_type, args.start_value) if meta_args.mode == "push": i.push_value = hive.push_in(i.cached_value) ex.value = hive.antenna(i.push_value) i.push_cached_value = hive.push_out(i.cached_value) ex.cached_value = hive.output(i.push_cached_value) ex.output = hive.entry(i.push_cached_value) elif meta_args.mode == "pull": i.pull_value = hive.pull_in(i.cached_value) ex.value = hive.antenna(i.pull_value) i.pull_cached_value = hive.pull_out(i.cached_value) ex.cached_value = hive.output(i.pull_cached_value) ex.update_cache = hive.entry(i.pull_value)
def build_bind(cls, i, ex, args, meta_args): if meta_args.forward_events == "none": return if meta_args.forward_events == "by_leader": i.event_leader = hive.property(cls, "leader", "tuple") i.pull_event_leader = hive.pull_in(i.event_leader) ex.event_leader = hive.antenna(i.pull_event_leader) i.push_pause_in = hive.push_in(cls.pause) ex.pause_events = hive.antenna(i.push_pause_in) i.push_resume_in = hive.push_in(cls.resume) ex.resume_events = hive.antenna(i.push_resume_in) ex.on_created = hive.plugin(cls.on_created, "bind.on_created")
def build_print(i, ex, args): """Output object to Python stdout""" ex.value = hive.variable() i.value_in = hive.push_in(ex.value) ex.value_in = hive.antenna(i.value_in) i.func = hive.modifier(lambda self: print(self.value)) hive.trigger(i.value_in, i.func)
def build_struct(cls, i, ex, args): """Interface to Struct class""" i.tuple = hive.variable("tuple") i.pack_in = hive.push_in(i.tuple) ex.pack = hive.antenna(i.pack_in) i.bytes = hive.variable("bytes") i.unpack_out = hive.push_out(i.bytes) ex.unpack = hive.output(i.unpack_out) i.size_out = hive.pull_out(cls.size) ex.size = hive.output(i.size_out)
def build_myhive(cls, i, ex, args): ex.a_ = hive.property(cls, "a", "int") ex.b_ = hive.property(cls, "b", "int") i.a_in = hive.push_in(ex.a_) i.b_in = hive.push_in(ex.b_) ex.a = hive.antenna(i.a_in) ex.b = hive.antenna(i.b_in) ex.c_ = hive.attribute() i.c_out = hive.push_out(ex.c_) ex.c = hive.output(i.c_out) # On triggered def on_triggered(this): this.c_ = this.a_ + this.b_ this.c.push() i.on_triggered = hive.modifier(lambda this: setattr(this, 'c_', (this.a_ + this.b_))) ex.trigger = hive.entry(i.on_triggered)
def build_chessboard(cls, i, ex, args): prop_move = h.property(cls, "prop_move", "str") # TODO: make buffer i.make_move = h.push_in(prop_move) i.trig_make_move = h.triggerable(cls.trig_make_move) # TODO: make modifier h.trigger(i.make_move, i.trig_make_move) ex.make_move = h.antenna(i.make_move) ex.do_make_move = cls.make_move ex.p_make_move = h.plugin(cls.make_move) ex.prop_move = prop_move ex.set_turn = h.socket(cls.set_turn) ex.add_moveprocessor = h.socket(cls.add_moveprocessor)
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_dictionary(cls, i, ex, args, meta_args): """Interface to dictionary object""" ex.dict = hive.property(cls, "dict", "dict") i.dict_in = hive.push_in(ex.dict) ex.dict_ = hive.antenna(i.dict_in) i.dict_out = hive.pull_out(ex.dict) ex.dict_out = hive.output(i.dict_out) i.key = hive.property(cls, "key", meta_args.key_data_type) i.value = hive.property(cls, "value", meta_args.data_type) # Setitem i.set_key_in = hive.pull_in(i.key) ex.set_key = hive.antenna(i.set_key_in) i.in_value = hive.push_in(i.value) ex.in_value = hive.antenna(i.in_value) i.set_value = hive.triggerable(cls.set_value) hive.trigger(i.in_value, i.set_key_in) hive.trigger(i.set_key_in, i.set_value) i.get_key_in = hive.pull_in(i.key) ex.get_key = hive.antenna(i.get_key_in) i.out_value = hive.pull_out(i.value) ex.out_value = hive.output(i.out_value) i.get_value = hive.triggerable(cls.get_value) # Before outputting, update key hive.trigger(i.out_value, i.get_key_in, pretrigger=True) hive.trigger(i.get_key_in, i.get_value)
def build_input(i, ex, args): """Get input from Python stdin""" args.message = hive.parameter("str", "") ex.message = hive.attribute("str", args.message) i.message_in = hive.push_in(ex.message) ex.message_in = hive.antenna(i.message_in) ex.value = hive.attribute("str") i.value_out = hive.pull_out(ex.value) ex.value_out = hive.output(i.value_out) def get_input(self): self.value = input(self.message) i.get_input = hive.modifier(get_input) hive.trigger(i.value_out, i.get_input, pretrigger=True)
def build_random(cls, i, ex, args): """HIVE interface to Python random module""" i.push_seed = hive.push_in(cls.set_seed) ex.seed = hive.antenna(i.push_seed) i.pull_random = hive.pull_out(cls.get_rand) ex.random = hive.output(i.pull_random) i.pull_bool = hive.pull_out(cls.get_bool) ex.bool = hive.output(i.pull_bool) # Randint i.randint_min = hive.property(cls, "randint_min", "int") i.randint_max = hive.property(cls, "randint_max", "int") i.randint_step = hive.property(cls, "randint_step", "int") i.pull_randint_min = hive.pull_in(i.randint_min) i.pull_randint_max = hive.pull_in(i.randint_max) i.pull_randint_step = hive.pull_in(i.randint_step) ex.int_min = hive.antenna(i.pull_randint_min) ex.int_max = hive.antenna(i.pull_randint_max) ex.int_step = hive.antenna(i.pull_randint_step) i.pull_int = hive.pull_out(cls.get_randrange) ex.int = hive.output(i.pull_int) hive.trigger(i.pull_int, i.pull_randint_max, pretrigger=True) hive.trigger(i.pull_int, i.pull_randint_min, pretrigger=True) hive.trigger(i.pull_int, i.pull_randint_step, pretrigger=True) # Randrange i.uniform_min = hive.property(cls, "uniform_min", "float") i.uniform_max = hive.property(cls, "uniform_max", "float") i.uniform_min_in = hive.pull_in(i.uniform_min) i.uniform_max_in = hive.pull_in(i.uniform_max) ex.uniform_min = hive.antenna(i.uniform_min_in) ex.uniform_max = hive.antenna(i.uniform_max_in) i.pull_uniform = hive.pull_out(cls.get_uniform) ex.uniform = hive.output(i.pull_uniform) hive.trigger(i.pull_uniform, i.uniform_max_in, pretrigger=True) hive.trigger(i.pull_uniform, i.uniform_min_in, pretrigger=True)
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_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_tag(cls, i, ex, args, meta_args): """Access to entity tag API""" if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_bound_entity_id = hive.triggerable(cls.get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) i.do_get_bound_entity_id = hive.triggerable(i.pull_entity_id) i.tag_name = hive.property(cls, "tag_name", "str") i.tag_value = hive.property(cls, "tag_value", meta_args.data_type) i.pull_tag_name = hive.pull_in(i.tag_name) ex.name = hive.antenna(i.pull_tag_name) if meta_args.mode == 'get': ex.get_get_tag = hive.socket(cls.set_get_tag, identifier="entity.tag.get") i.pull_tag_value = hive.pull_out(i.tag_value) ex.value = hive.output(i.pull_tag_value) i.do_get_tag = hive.triggerable(cls.get_tag) hive.trigger(i.pull_tag_value, i.do_get_bound_entity_id) hive.trigger(i.pull_tag_value, i.pull_tag_name) hive.trigger(i.pull_tag_value, i.do_get_tag) else: ex.get_set_tag = hive.socket(cls.set_set_tag, identifier="entity.tag.set") i.push_tag_value = hive.push_in(i.tag_value) ex.value = hive.antenna(i.push_tag_value) i.do_get_tag = hive.triggerable(cls.get_tag) hive.trigger(i.push_tag_value, i.do_get_bound_entity_id) hive.trigger(i.push_tag_value, i.pull_tag_name) hive.trigger(i.push_tag_value, i.do_get_tag)
def event_builder(cls, i, ex, args): ex.add_handler = hive.plugin(cls.add_handler, identifier="event.add_handler", export_to_parent=True) ex.remove_handler = hive.plugin(cls.remove_handler, identifier="event.remove_handler", export_to_parent=True) ex.read_event = hive.plugin(cls.handle_event, identifier="event.process", export_to_parent=True) # Send startup and stop events ex.on_stopped = hive.plugin(cls.on_stopped, identifier="on_stopped") ex.on_started = hive.plugin(cls.on_started, identifier="on_started") # Allow events to be pushed in i.event_in = hive.property(cls, 'pushed_event', 'tuple') i.push_event = hive.push_in(i.event_in) ex.event_in = hive.antenna(i.push_event) i.on_event_in = hive.triggerable(cls.on_event_in) hive.trigger(i.push_event, i.on_event_in)
def build_visibility(cls, i, ex, args, meta_args): """Set/Get entity visibility""" if meta_args.bound: ex.get_bound_id = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_entity_id = hive.triggerable(cls.get_bound_entity) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.do_get_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.do_get_entity_id) if meta_args.mode == 'get': ex.get_get_visibility = hive.socket(cls.set_get_visibility, identifier="entity.visibility.get") i.pull_visibility = hive.pull_out(cls.get_visibility) ex.visibility = hive.output(i.pull_visibility) hive.trigger(i.pull_visibility, i.do_get_entity_id, pretrigger=True) else: ex.get_set_visibility = hive.socket(cls.set_set_visibility, identifier="entity.visibility.set") i.push_in_visibility = hive.push_in(cls.set_visibility) ex.visibility = hive.antenna(i.push_in_visibility) hive.trigger(i.push_in_visibility, i.do_get_entity_id, pretrigger=True)
def build_parent(cls, i, ex, args, meta_args): """Set/Get entity parent""" ex.get_get_parent = hive.socket(cls.set_get_parent, identifier="entity.parent.get") ex.get_set_parent = hive.socket(cls.set_set_parent, identifier="entity.parent.set") i.parent_id = hive.property(cls, "parent_id", "int.entity_id") if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_bound_entity_id = hive.triggerable(cls.get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) i.do_get_bound_entity_id = hive.triggerable(i.pull_entity_id) if meta_args.mode == "get": i.pull_parent_id = hive.pull_out(i.parent_id) ex.parent_id = hive.output(i.pull_parent_id) i.get_parent_id = hive.triggerable(cls.get_parent_id) hive.trigger(i.pull_parent_id, i.do_get_bound_entity_id, pretrigger=True) hive.trigger(i.pull_parent_id, i.get_parent_id, pretrigger=True) else: i.push_parent_id = hive.push_in(i.parent_id_id) ex.parent_id = hive.antenna(i.push_parent_id) i.set_parent = hive.triggerable(cls.set_parent) hive.trigger(i.push_parent_id, i.do_get_bound_entity_id) hive.trigger(i.push_parent_id, i.set_parent)
def build_position(cls, i, ex, args, meta_args): """Access to entity position API""" coordinate_system = meta_args.coordinate_system i.position = hive.property(cls, "position", "vector") if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_entity_id = hive.triggerable(cls.do_get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) if coordinate_system == 'relative': i.other_entity_id = hive.property(cls, "other_entity_id", "int.entity_id") i.pull_other_entity_id = hive.pull_in(i.other_entity_id) ex.other_entity_id = hive.antenna(i.pull_other_entity_id) if meta_args.mode == "get": i.pull_position = hive.pull_out(i.position) ex.position = hive.output(i.pull_position) else: i.push_position = hive.push_in(i.position) ex.position = hive.antenna(i.push_position) if meta_args.mode == "get": if coordinate_system == 'absolute': ex.get_get_position = hive.socket( cls.set_get_position, identifier="entity.position.get.absolute") i.do_get_position = hive.triggerable(cls.do_get_position) else: ex.get_get_position = hive.socket( cls.set_get_position, identifier="entity.position.get.relative") i.do_get_position = hive.triggerable(cls.do_get_relative_position) hive.trigger(i.pull_position, i.pull_other_entity_id, pretrigger=True) if meta_args.bound: hive.trigger(i.pull_position, i.do_get_entity_id, pretrigger=True) else: hive.trigger(i.pull_position, i.pull_entity_id, pretrigger=True) hive.trigger(i.pull_position, i.do_get_position, pretrigger=True) else: if coordinate_system == 'absolute': ex.get_set_position = hive.socket( cls.set_set_position, identifier="entity.position.set.absolute") i.do_set_position = hive.triggerable(cls.do_set_position) else: ex.get_set_position = hive.socket( cls.set_set_position, identifier="entity.position.set.relative") i.do_set_position = hive.triggerable(cls.do_set_relative_position) hive.trigger(i.push_position, i.pull_other_entity_id) if meta_args.bound: hive.trigger(i.push_position, i.do_get_entity_id) else: hive.trigger(i.push_position, i.pull_entity_id) hive.trigger(i.push_position, i.do_set_position)
def build_list(i, ex, args, meta_args): """Interface to list container""" data_type = "list[{}]".format(meta_args.data_type or '?') i.list_ = hive.variable(data_type, list()) i.pull_list_ = hive.pull_out(i.list_) ex.list_out = hive.output(i.pull_list_) i.push_list_ = hive.push_in(i.list_) ex.list_ = hive.antenna(i.push_list_) i.item = hive.variable(meta_args.data_type) # Pop item i.popped_item = hive.variable(meta_args.data_type) i.pull_pop = hive.pull_out(i.popped_item) ex.pop = hive.output(i.pull_pop) def do_pop(self): self._popped_item = self._list_.pop() i.do_pop = hive.modifier(do_pop) hive.trigger(i.pull_pop, i.do_pop, pretrigger=True) # Add item i.push_to_append = hive.push_in(i.item) ex.append = hive.antenna(i.push_to_append) def to_append(self): self._list_.append(self._item) i.do_append = hive.modifier(to_append) hive.trigger(i.push_to_append, i.do_append) # Remove item i.push_to_remove = hive.push_in(i.item) ex.remove = hive.antenna(i.push_to_remove) def do_remove(self): self._list_.remove(self._item) i.do_remove = hive.modifier(do_remove) hive.trigger(i.push_to_remove, i.do_remove) def do_clear(self): self._list_.clear() i.do_clear = hive.modifier(do_clear) ex.clear = hive.entry(i.do_clear) # Index i.index = hive.variable('int') # Getitem i.pull_getitem_index = hive.pull_in(i.index) ex.get_index = hive.antenna(i.pull_getitem_index) i.pull_getitem = hive.pull_out(i.item) ex.getitem = hive.output(i.pull_getitem) def do_getitem(self): self._item = self._list[self._index] i.do_getitem = hive.modifier(do_getitem) hive.trigger(i.pull_getitem, i.pull_getitem_index, pretrigger=True) hive.trigger(i.pull_getitem_index, i.do_getitem) # Setitem i.pull_setitem_index = hive.pull_in(i.item) ex.set_index = hive.antenna(i.pull_setitem_index) i.push_setitem = hive.push_in(i.item) ex.setitem = hive.antenna(i.push_setitem) def do_setitem(self): self._list[self._index] = self._item i.do_setitem = hive.modifier(do_setitem) hive.trigger(i.push_setitem, i.pull_setitem_index) hive.trigger(i.pull_setitem_index, i.do_setitem)
def build_velocity(cls, i, ex, args, meta_args): """Access to entity velocity API""" coordinate_system = meta_args.coordinate_system i.velocity = hive.property(cls, "velocity", "vector") if meta_args.bound: ex.get_bound = hive.socket(cls.set_get_entity_id, identifier="entity.get_bound") i.do_get_entity_id = hive.triggerable(cls.do_get_entity_id) else: i.entity_id = hive.property(cls, "entity_id", "int.entity_id") i.pull_entity_id = hive.pull_in(i.entity_id) ex.entity_id = hive.antenna(i.pull_entity_id) if coordinate_system == 'relative': i.other_entity_id = hive.property(cls, "other_entity_id", "int.entity_id") i.pull_other_entity_id = hive.pull_in(i.other_entity_id) ex.other_entity_id = hive.antenna(i.pull_other_entity_id) if meta_args.mode == "get": i.pull_velocity = hive.pull_out(i.velocity) ex.velocity = hive.output(i.pull_velocity) else: i.push_velocity = hive.push_in(i.velocity) ex.velocity = hive.antenna(i.push_velocity) if meta_args.mode == "get": if coordinate_system == 'absolute': ex.get_get_velocity = hive.socket(cls.set_get_velocity, identifier="entity.linear_velocity.get") i.do_get_velocity = hive.triggerable(cls.do_get_velocity) else: ex.get_get_velocity = hive.socket(cls.set_get_velocity, identifier="entity.linear_velocity.get") i.do_get_velocity = hive.triggerable(cls.do_get_relative_velocity) hive.trigger(i.pull_velocity, i.pull_other_entity_id, pretrigger=True) if meta_args.bound: hive.trigger(i.pull_velocity, i.do_get_entity_id, pretrigger=True) else: hive.trigger(i.pull_velocity, i.pull_entity_id, pretrigger=True) hive.trigger(i.pull_velocity, i.do_get_velocity, pretrigger=True) else: if coordinate_system == 'absolute': ex.get_set_velocity = hive.socket(cls.set_set_velocity, identifier="entity.linear_velocity.set") i.do_set_velocity = hive.triggerable(cls.do_set_velocity) else: ex.get_set_velocity = hive.socket(cls.set_set_velocity, identifier="entity.linear_velocity.set") i.do_set_velocity = hive.triggerable(cls.do_set_relative_velocity) hive.trigger(i.push_velocity, i.pull_other_entity_id) if meta_args.bound: hive.trigger(i.push_velocity, i.do_get_entity_id) else: hive.trigger(i.push_velocity, i.pull_entity_id) hive.trigger(i.push_velocity, i.do_set_velocity)