def set_entity(self, event): entity = event.entity entity_components = self.context['entities'][entity]['components'] # clear views for i in range(self.component_tree_view.topLevelItemCount()-1,-1,-1): item = self.component_tree_view.takeTopLevelItem(i) for i in range(self.vector_list_view.count()-1,-1,-1): item = self.vector_list_view.takeItem(i) for i in range(self.debug_list_view.count()-1,-1,-1): item = self.debug_list_view.takeItem(i) # populate the component tree view self._find_components() # populate the vector list view vectors = entity_components['body'] for vector in vectors: widget_item = WidgetItemComponent(vector.text, vector) self.vector_list_view.addItem(widget_item) # populate debug list view debugs = entity_components['debug'] for deb in debugs: widget_item = WidgetItemComponent(deb.text, deb) self.debug_list_view.addItem(widget_item)
def set_entity(self, event): entity = event.entity bindings = self.context['entities'][entity]['components']['binding'] # do a "soft" clear of the list # if we actually call self.graphic_list_view.clear(), # the C++ Qt objects will be deleted for i in range(self.binding_list_view.count() - 1, -1, -1): self.binding_list_view.takeItem(i) for binding in bindings: widget_component = WidgetItemComponent(binding.text, binding) self.binding_list_view.addItem(widget_component) # now do it for execution components execs = self.context['entities'][entity]['components']['execution'] for i in range(self.exec_list_view.count() - 1, -1, -1): self.exec_list_view.takeItem(i) for exec_comp in execs: widget_component = WidgetItemComponent(exec_comp.text, exec_comp) self.exec_list_view.addItem(widget_component) # finally do it for moves moves = self.context['entities'][entity]['components']['move'] for i in range(self.move_list_view.count() - 1, -1, -1): self.move_list_view.takeItem(i) for move in moves: widget_component = WidgetItemComponent(move.text, move) self.move_list_view.addItem(widget_component)
def new_input(self, event): widget_component = WidgetItemComponent(event.input_component.text, event.input_component) self.inp_list_view.addItem(widget_component) mirror_component = WidgetItemComponent(event.input_component.text, event.input_component) self.mirror_list_view.addItem(mirror_component)
def update(self): entity = self.context['selected_entity'] self.graphic_list_view.clear() self.asset_list_view.clear() for asset in self.context['assets']: widget_component = WidgetItemComponent(asset.text, asset) self.asset_list_view.addItem(widget_component) if entity and entity != '': for graphic in self.context['entities'][entity]['components']['graphic']: widget_component = WidgetItemComponent(graphic.text, graphic) self.graphic_list_view.addItem(widget_component)
def update(self): entity = self.context['selected_entity'] # first update state list self.state_list_view.clear() if entity and entity != '': for state in self.context['entities'][entity]['components']['state']: widget_component = WidgetItemComponent(state.text, state) self.state_list_view.addItem(widget_component) # then update rules for rule in self.context['rules']: widget_component = WidgetItemComponent(rule.text, rule) self.rule_list_view.addItem(widget_component)
def add_frame(self): frame_name = str(self.frame_name_field.text()) entity = self.context['selected_entity'] ani = self.selected_animation crop = Rect(int(self.frame_x_field.text()), int(self.frame_y_field.text()), int(self.frame_width_field.text()), int(self.frame_height_field.text())) repeat = int(self.frame_repeat_field.text()) frame_component = FrameComponent(entity_id=entity, crop=crop, repeat=repeat) frame_component_wrapper = Component(frame_component, frame_name) widget_component = WidgetItemComponent(frame_name, frame_component_wrapper) self.frame_list_view.addItem(widget_component) # add new frame component to the selected animation's frame list ani.component.frames.append(frame_component_wrapper) # fire event new_event = Event('added_component', entity=entity, component_type='frame', component=frame_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_binding(self): entity = self.context['selected_entity'] binding_name = str(self.binding_name_field.text()) # begin by building the bindings dictionary bindings = dict() mirrors = dict() for i in range(self.selected_inp_list_view.count()): input_comp = self.selected_inp_list_view.item(i).component key = input_comp.component.name.text bindings[key] = input_comp mirrors[key] = input_comp.component.mirror binding_comp = InputComponent(entity_id=entity, bindings=bindings, mirror_bindings=mirrors) binding_comp_wrapper = Component(binding_comp, binding_name) widget_component = WidgetItemComponent(binding_name, binding_comp_wrapper) self.binding_list_view.addItem(widget_component) # add the component to the application context self.context['entities'][entity]['components']['binding'].append( binding_comp_wrapper) # fire event for adding new binding new_event = Event('added_binding', binding_component=binding_comp_wrapper) EVENT_MANAGER.fire_event(new_event) new_event = Event('added_component', entity=entity, component_type='binding', component=binding_comp_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_graphic(self): # add the new graphic to the UI selected_asset = self.asset_list_view.currentItem() selected_component = selected_asset.component file_name = selected_component.component.file_name graphic_name = str(self.graphic_name_field.text()) selected_anchor = self.anchor_list_view.currentItem().component graphic_component = GraphicsComponent(entity_id=self.context.get('selected_entity'), surface=selected_component.component.surface, file_name=file_name, dest=selected_anchor) graphic_component_wrapper = Component(graphic_component, graphic_name) widget_component = WidgetItemComponent(graphic_name, graphic_component_wrapper) self.graphic_list_view.addItem(widget_component) # render it to the label image holder self.show_graphic(file_name) # then add it to the application context entity_name = self.context.get('selected_entity') if entity_name: self.context['entities'][entity_name]['components']['graphic'].append(graphic_component_wrapper) # fire off an event new_event = Event('graphic_added', graphic_component=graphic_component_wrapper) EVENT_MANAGER.fire_event(new_event) new_event = Event('added_component', entity=entity_name, component_type='graphic', component=graphic_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_animation(self): animation_name = str(self.animation_name_field.text()) entity = self.context['selected_entity'] animation_component = AnimationComponent(entity_id=entity, graphic=self.selected_graphic) animation_component_wrapper = Component(animation_component, animation_name) widget_component = WidgetItemComponent(animation_name, animation_component_wrapper) self.animation_list_view.addItem(widget_component) # add new component to the application context context_animations = self.context['entities'][entity]['components'][ 'animation'] context_animations.append(animation_component_wrapper) # fire event for adding an animation new_event = Event( 'added_animation', animation_component=animation_component_wrapper, entity=animation_component_wrapper.component.entity_id) EVENT_MANAGER.fire_event(new_event) new_event = Event('added_component', entity=entity, component_type='animation', component=animation_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_move(self): move_name = str(self.move_name_field.text()) entity = self.context['selected_entity'] selected_animation = self.ani_list_view.currentItem().component # build a list of the chosen inputs inputs = list() for i in range(self.selected_inp_list_view.count()): item = self.selected_inp_list_view.item(i) inp_component = item.component inputs.append(inp_component) # construct the move component move = MoveComponent(entity_id=entity, name=move_name, animation=selected_animation, inputs=inputs) move_component_wrapper = Component(move, move_name) widget_component = WidgetItemComponent(move_name, move_component_wrapper) self.move_list_view.addItem(widget_component) # add the move component to the application context self.context['entities'][entity]['components']['move'].append(move_component_wrapper) # fire event for adding new move new_event = Event('added_move', move_component=move_component_wrapper) EVENT_MANAGER.fire_event(new_event) new_event = Event('added_component', entity=entity, component_type='move', component=move_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_component(self, event): entity = event.entity component_type = event.component_type component = event.component if component_type == 'body': widget_item = WidgetItemComponent(component.text, component) self.vector_list_view.addItem(widget_item)
def add_state(self): entity = self.context['selected_entity'] state_name = str(self.state_name_field.text()) # get activation event act_event_name = str(self.activation_list_view.currentItem().text()) # get deactivation event deact_event_name = str(self.deactivation_list_view.currentItem().text()) # get activation component act_component = self.activation_component_tree_view.currentItem().component # build list of rules added to this state rules = list() rule_values = dict() for i in range(self.selected_rule_list_view.count()): item = self.selected_rule_list_view.item(i) rule_component = item.component rules.append(rule_component.rule) rule_values[str(rule_component.rule.text)] = rule_component.rule_value # create state component state_component = StateComponent(entity_id=entity, rules=rules, activation_event_type=act_event_name, deactivation_event_type=deact_event_name, activation_component=act_component, rule_values=rule_values) state_component_wrapper = Component(state_component, state_name) widget_component = WidgetItemComponent(state_name, state_component_wrapper) self.state_list_view.addItem(widget_component) # add state component to application context self.context['entities'][entity]['components']['state'].append(state_component_wrapper) # fire event for adding component new_event = Event('added_component', entity=entity, component_type='state', component=state_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_rule(self): selected_item = self.rule_list_view.currentItem() selected_component = selected_item.component rule_name = selected_component.text # determine the rule value for this rule rule_value = str(self.rule_value_field.text()) rule_text = '{name} - {value}'.format(name=rule_name, value=rule_value) # if no value is entered in the rule value field, # we then look for a chosen component property if rule_value is None or rule_value == '': component_item = self.rule_value_component_tree_view.currentItem() component_text = str(component_item.text(0)) component = component_item.component rule_value = component if component_item.parent() != None: component_text = '{a}.{b}'.format(a=str(component_item.parent().text(0)), b=component_text) rule_text = '{name} - {value}'.format(name=rule_name, value=component_text) rule_wrapper = RuleRuleValueWrapper(selected_component, rule_value) #widget_component = WidgetItemComponent(rule_text, rule_value) widget_component = WidgetItemComponent(rule_text, rule_wrapper) self.selected_rule_list_view.addItem(widget_component)
def add_exec(self): entity = self.context['selected_entity'] exec_name = str(self.exec_name_field.text()) binding = self.binding_list_view.currentItem().component # build list of selected moves moves = list() for i in range(self.selected_move_list_view.count()): item = self.selected_move_list_view.item(i) move = item.component moves.append(move) exec_component = ExecutionComponent(entity_id=entity, executables=moves, inputs=binding) exec_component_wrapper = Component(exec_component, exec_name) widget_component = WidgetItemComponent(exec_name, exec_component_wrapper) self.exec_list_view.addItem(widget_component) # add execution component to the application context self.context['entities'][entity]['components']['execution'].append( exec_component_wrapper) # fire event for adding new execution new_event = Event('added_execution', execution_component=exec_component_wrapper) EVENT_MANAGER.fire_event(new_event) new_event = Event('added_component', entity=entity, component_type='execution', component=exec_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def add_box(self): box_name = str(self.box_name_field.text()) entity = self.context['selected_entity'] frame = self.selected_frame.component rect = Rect(int(self.box_x_field.text()), int(self.box_y_field.text()), int(self.box_width_field.text()), int(self.box_height_field.text())) hitactive = self.check_context['hitactive'] > 0 hurtactive = self.check_context['hurtactive'] > 0 blockactive = self.check_context['blockactive'] > 0 solid = self.check_context['solid'] > 0 box_component = BoxComponent(entity_id=entity, rect=rect, anchor=self.anchor, hitactive=hitactive, hurtactive=hurtactive, blockactive=blockactive, solid=solid) box_component_wrapper = Component(box_component, box_name) widget_component = WidgetItemComponent(box_name, box_component_wrapper) self.box_list_view.addItem(widget_component) # add box to the selected frame's box list frame.hitboxes.append(box_component_wrapper) # add the box component to the application context self.context['entities'][entity]['components']['hitbox'].append( box_component_wrapper) # fire event new_event = Event('added_component', entity=entity, component_type='hitbox', component=box_component_wrapper) EVENT_MANAGER.fire_event(new_event)
def update(self): # first update move list entity = self.context['selected_entity'] self.move_list_view.clear() if entity and entity != '': for move in self.context['entities'][entity]['components']['move']: widget_component = WidgetItemComponent(move.text, move) self.move_list_view.addItem(widget_component) # then update input list self.inp_list_view.clear() for inp in self.context['inputs']: widget_component = WidgetItemComponent(inp.text, inp) self.inp_list_view.addItem(widget_component) # finally update animation list self.ani_list_view.clear()
def update(self): entity = self.context['selected_entity'] self.exec_list_view.clear() if entity and entity != '': for execution in self.context[entity]['components']['execution']: widget_component = WidgetItemComponent(execution.text, execution) self.exec_list_view.addItem(widget_component)
def update(self): entity = self.context['selected_entity'] self.animation_list_view.clear() if entity and entity != '': for animation in self.context['entities'][entity]['components'][ 'animation']: widget_component = WidgetItemComponent(animation.text, animation) self.animation_list_view.addItem(widget_component)
def add_entity(self): entity_name = str(self.entity_name_field.text()) new_entity = Entity(entity_name) new_entity_wrapper = Component(new_entity, entity_name) widget_component = WidgetItemComponent(entity_name, new_entity_wrapper) self.entity_list_view.addItem(widget_component) self.context['entities'][entity_name] = dict() self.context['entities'][entity_name]['entity'] = new_entity self.context['entities'][entity_name]['components'] = defaultdict(list)
def update(self): # first update input list and mirror input list self.inp_list_view.clear() self.mirror_list_view.clear() for inp in self.context['inputs']: widget_component = WidgetItemComponent(inp.text, inp) self.inp_list_view.addItem(widget_component) mirror_component = WidgetItemComponent(inp.text, inp) self.mirror_list_view.addItem(mirror_component) # then update binding list entity = self.context['selected_entity'] self.binding_list_view.clear() if entity and entity != '': for bind in self.context['entities'][entity]['components'][ 'binding']: widget_component = WidgetItemComponent(binding.text, binding) self.binding_list_view.addItem(widget_component)
def select_state(self): ''' update the state editor GUI to show all properties of the selected state ''' entity = self.context['selected_entity'] selected_item = self.state_list_view.currentItem() selected_component = selected_item.component # start by setting the state name self.state_name_field.setText(selected_component.text) # then set the selected activation event for i in range(self.activation_list_view.count()): item = self.activation_list_view.item(i) if item.text() == selected_component.component.activation_event_type: self.activation_list_view.setCurrentRow(i) break # then set the selected deactivation event for i in range(self.deactivation_list_view.count()): item = self.deactivation_list_view.item(i) if item.text() == selected_component.component.deactivation_event_type: self.deactivation_list_view.setCurrentRow(i) break # then select activation component # begin by deselecting any selected node and collapsing all branches activation_component = selected_component.component.activation_component for i in range(self.activation_component_tree_view.topLevelItemCount()): tl_item = self.activation_component_tree_view.topLevelItem(i) for j in range(tl_item.childCount()): child_item = tl_item.child(j) child_item.setSelected(False) tl_item.setExpanded(False) # then find and select the proper node for i in range(self.activation_component_tree_view.topLevelItemCount()): tl_item = self.activation_component_tree_view.topLevelItem(i) for j in range(tl_item.childCount()): child_item = tl_item.child(j) if child_item.component == activation_component: tl_item.setExpanded(True) child_item.setSelected(True) break # then show the proper rules in the selected rule box # also, deselect any selected rule or rule component values for i in range(self.selected_rule_list_view.count()-1,-1,-1): item = self.selected_rule_list_view.takeItem(i) context_rules = self.context['entities'][entity]['components']['rules'] rules = [RuleRuleValueWrapper(x, y) for x in selected_component.component.rules for k,y in selected_component.component.rule_values.iteritems() if k == x.component.name] for rule in rules: comp = Component(rule, rule.rule.text) widget_item = WidgetItemComponent(comp.text, comp) self.selected_rule_list_view.addItem(widget_item) self.rule_list_view.setCurrentRow(-1)
def set_graphics(self, event): entity = event.entity available_graphics = self.context['entities'][entity]['components']['graphic'] # do a "soft" clear of the list # if we actually call self.graphic_list_view.clear(), # the C++ Qt objects will be deleted for i in range(self.graphic_list_view.count()-1,-1,-1): self.graphic_list_view.takeItem(i) for graphic in available_graphics: widget_component = WidgetItemComponent(graphic.text, graphic) self.graphic_list_view.addItem(widget_component) # clear and populate anchor list self.anchor_list_view.clear() available_anchors = self.context['entities'][entity]['components']['body'] for anchor in available_anchors: widget_component = WidgetItemComponent(anchor.text, anchor) self.anchor_list_view.addItem(widget_component)
def set_entity(self, event): entity = event.entity # first do a soft clear of the tree view for i in range(self.activation_component_tree_view.topLevelItemCount()-1,-1,-1): item = self.activation_component_tree_view.takeTopLevelItem(i) for j in range(item.childCount()-1,-1,-1): child_item = item.takeChild(j) # repopulate the tree with the current entity's components tl_items = self.context['entities'][entity]['components'].keys() # component types represent the top level tree items for item in tl_items: components = self.context['entities'][entity]['components'][item] tl_tree_item = TreeWidgetItemComponent(item, components) self.activation_component_tree_view.addTopLevelItem(tl_tree_item) # the components should all be listed under their respective # component type for component in components: tree_item = TreeWidgetItemComponent(component.text, component) tl_tree_item.addChild(tree_item) # now do this same stuff for the rule value component tree rule_value_tree = self.rule_value_component_tree_view # clear it out first for i in range(rule_value_tree.topLevelItemCount()-1,-1,-1): item = rule_value_tree.takeTopLevelItem(i) for j in range(item.childCount()-1,-1,-1): child_item = item.takeChild(j) for k in range(child_item.childCount()-1,-1,-1): grand_child_item = child_item.takeChild(k) # then repopulate the tree with components and component properties tl_items = self.context['entities'][entity]['components'].keys() for item in tl_items: components = self.context['entities'][entity]['components'][item] tl_tree_item = TreeWidgetItemComponent(item, components) rule_value_tree.addTopLevelItem(tl_tree_item) for component in components: component_item = TreeWidgetItemComponent(component.text, component) tl_tree_item.addChild(component_item) # then add a child item for each non-private attribute of # this component for name in (x for x in dir(component.component) if not x.startswith('_')): # still using outer component val = LambdaDef(component, name) component_attr_item = TreeWidgetItemComponent(name, val) component_item.addChild(component_attr_item) # finally, repopulate the state component list self.state_list_view.clear() for state in self.context['entities'][entity]['components']['state']: widget_component = WidgetItemComponent(state.text, state) self.state_list_view.addItem(widget_component)
def add_debug(self): entity = self.context['selected_entity'] name = self.debug_name_field.text() component_item = self.component_tree_view.currentItem() lambda_component = component_item.component color = self.color_list_view.currentItem().component location_vec = self.vector_list_view.currentItem().component inner_component = lambda_component.component.component #component_type = component_wrapper.__class__.__name__ attr = getattr(inner_component, lambda_component.attr).component component_type = attr.__class__.__name__ # create the debug component # extract the real component from a LambdaDef if component_type == 'BoxComponent': rect = getattr(inner_component, lambda_component.attr) debug_component = DebugComponent(entity_id=entity, rect=rect, style={'color': color}) else: lambda_name = lambda_component.attr text_lambda = TextLambdaDef(lambda_component, lambda_name, '{a}') text = str(getattr(lambda_component.component.component, lambda_name).component) text_comp = TextComponent(entity_id=entity, text=text, loc=location_vec, style={'color':color}) text_wrapper = Component(text_comp, text) # add this text component to the context self.context['entities'][entity]['components']['text'].append(text_wrapper) new_event = Event('added_component', entity=entity, component_type='text', component=text_wrapper) EVENT_MANAGER.fire_event(new_event) # finally create debug component debug_component = DebugComponent(entity_id=entity, text=text_wrapper, get_value=text_lambda, style={'color': color}) debug_wrapper = Component(debug_component, name) widget_item = WidgetItemComponent(name, debug_wrapper) self.debug_list_view.addItem(widget_item) # add to context self.context['entities'][entity]['components']['debug'].append(debug_wrapper) # fire event new_event = Event('added_component', entity=entity, component_type='debug', component=debug_wrapper) EVENT_MANAGER.fire_event(new_event)
def set_animations(self, event): entity = event.entity available_animations = self.context['entities'][entity]['components']['animation'] # do a "soft" clear of the list # if we actually call self.graphic_list_view.clear(), # the C++ Qt objects will be deleted for i in range(self.ani_list_view.count()-1,-1,-1): self.ani_list_view.takeItem(i) for animation in available_animations: widget_component = WidgetItemComponent(animation.text, animation) self.ani_list_view.addItem(widget_component) # now do the moves list available_moves = self.context['entities'][entity]['components']['move'] for i in range(self.move_list_view.count()-1,-1,-1): self.move_list_view.takeItem(i) for move in available_moves: widget_component = WidgetItemComponent(move.text, move) self.move_list_view.addItem(widget_component)
def add_inputs(self): # possible multiple selection selected_items = self.inp_list_view.selectedItems() widget_component = None if len(selected_items) > 0: # if multiple items selected, join each component's # text together, and use the list of components as the # component text = ' + '.join([str(x.text()) for x in selected_items]) agg_comp = Component([x.component for x in selected_items], text) widget_component = WidgetItemComponent(text, agg_comp) elif len(selected_items) == 1: # if just one item selected, follow the normal process comp = Component(selected_items[0].component, selected_items[0].text) widget_component = WidgetItemComponent(comp.text, comp) else: return # then add the widget item to the selected inputs list self.selected_inp_list_view.addItem(widget_component)
def add_input(self): inp_name = str(self.input_name_field.text()) inp = Input(name=inp_name) inp_wrapper = Component(inp, inp_name) widget_component = WidgetItemComponent(inp_name, inp_wrapper) self.input_list_view.addItem(widget_component) # add input to the application context self.context['inputs'].append(inp_wrapper) # fire event for adding new input new_event = Event('added_input', input_component=inp_wrapper) EVENT_MANAGER.fire_event(new_event)
def set_bindings(self, event): entity = event.entity available_bindings = self.context['entities'][entity]['components'][ 'binding'] # do a "soft" clear of the list # if we actually call self.graphic_list_view.clear(), # the C++ Qt objects will be deleted for i in range(self.binding_list_view.count() - 1, -1, -1): self.binding_list_view.takeItem(i) for binding in available_bindings: widget_component = WidgetItemComponent(binding.text, binding) self.binding_list_view.addItem(widget_component)
def set_entity(self, event): entity = event.entity self.entity = entity # soft clear physics object list for i in range(self.physics_list_view.count() - 1, -1, -1): self.physics_list_view.takeItem(i) available_physics = self.context['entities'][entity]['components'][ 'physics'] for phys in available_physics: widget_component = WidgetItemComponent(phys.text, phys) self.physics_list_view.addItem(widget_component)
def add_input(self): selected_item = self.inp_list_view.currentItem() selected_component = selected_item.component selected_key = self.key_list_view.currentItem().component selected_mirror = self.mirror_list_view.currentItem() selected_mirror = None if selected_mirror is None else selected_mirror.component bound_input = InputToKeyBinding(selected_component, selected_key, selected_mirror) bound_input_wrapper = Component( bound_input, '{a} - {b}'.format(a=selected_component.text, b=selected_key.text)) widget_component = WidgetItemComponent(bound_input_wrapper.text, bound_input_wrapper) self.selected_inp_list_view.addItem(widget_component)