def register(cls, name, auto_register=True):
"""Registers the class as a component
Args:
name: The name under which the class should be registered
auto_register: This sets whether components this component
derives from will have their registered_as property set to the same
name as this class.
Returns:
True if the component was registered, False if not.
"""
try:
ComponentManager.register_component(name, cls())
cls.__registered_as = name
if auto_register:
for sub_cls in inspect.getmro(cls):
if ((not (sub_cls is cls or sub_cls is Base))
and issubclass(sub_cls, Base)):
# pylint: disable=W0212
sub_cls.__registered_as = name
# pylint: enable=W0212
for dependency in cls.dependencies:
if not dependency.registered_as:
dependency.register()
return True
except AlreadyRegisteredError as error:
print(error)
return False
def register(cls, name, auto_register=True):
"""Registers the class as a component
Args:
name: The name under which the class should be registered
auto_register: This sets whether components this component
derives from will have their registered_as property set to the same
name as this class.
Returns:
True if the component was registered, False if not.
"""
try:
ComponentManager.register_component(name, cls())
cls.__registered_as = name
if auto_register:
for sub_cls in inspect.getmro(cls):
if ((not (sub_cls is cls or sub_cls is Base))
and issubclass(sub_cls, Base)):
# pylint: disable-msg=W0212
sub_cls.__registered_as = name
# pylint: enable-msg=W0212
for dependency in cls.dependencies:
if not dependency.registered_as:
dependency.register()
return True
except AlreadyRegisteredError as error:
print error
return False
def register_checkers():
"""Registers the components checkers"""
if not Lockable.registered_as:
raise NotRegisteredError("Lockable")
if FifeAgent.registered_as:
ComponentManager.register_checker(
(FifeAgent.registered_as, Lockable.registered_as),
check_lockable_fifeagent)
def register_checkers():
"""Registers the components checkers"""
if not Lockable.registered_as:
raise NotRegisteredError("Lockable")
if FifeAgent.registered_as:
ComponentManager.register_checker(
(FifeAgent.registered_as, Lockable.registered_as),
check_lockable_fifeagent)
def create_entity_dictionary(cls, entity, remove_default=True):
"""Creates a dictionary containing the values of the Entity
Args:
entity: The Entity instance
remove_default: Skips fields whose value is the same as the
default value.
Returns:
The created dictionary
"""
entity_dict = {}
components_data = entity_dict["Components"] = {}
components = ComponentManager.get_components()
for name, component in components.items():
component_values = getattr(entity, name)
if component_values:
component_data = None
for field in component.saveable_fields:
fields = component.fields
if not component_data:
component_data = components_data[name] = {}
value = getattr(component_values, field)
if remove_default and value == fields[field].default():
continue
component_data[field] = value
return entity_dict
def step(self, time_delta):
"""Performs actions every frame
Args:
time_delta: Time that passed since the last call
"""
World.step(self, time_delta)
checkers = ComponentManager.get_checkers()
for names, callback in checkers:
for components in self.components.join(*names):
callback(*components)
def configure(self):
"""Configure the worlds components and systems"""
World.configure(self)
components = ComponentManager.get_components()
for name, component in components.iteritems():
setattr(self.components, name, component)
systems = SystemManager.get_systems()
for name, system in systems.iteritems():
setattr(self.systems, name, system)
if not General.registered_as:
General.register()
def step(self, time_delta):
"""Performs actions every frame
Args:
time_delta: Time that passed since the last call
"""
World.step(self, time_delta)
checkers = ComponentManager.get_checkers()
for names, callback in checkers:
for components in self.components.join(*names):
callback(*components)
def configure(self):
"""Configure the worlds components and systems"""
World.configure(self)
components = ComponentManager.get_components()
for name, component in components.items():
setattr(self.components, name, component)
systems = SystemManager.get_systems()
for name, system in systems.items():
setattr(self.systems, name, system)
if not General.registered_as:
General.register()
def clear(self):
"""Clears all data and restores saved settings"""
self._maps = {}
self._current_map = None
self._components = {}
self._actions = {}
self._systems = {}
self._behaviours = {}
self.changed_maps = []
self.project_changed = False
self.entity_changed = False
self.editor_gui.reset_layerlist()
self.map_entities = None
self.set_selected_object(None)
tmp_settings = list(self.settings.getSettingsFromFile("fife-rpg").keys())
for setting in tmp_settings:
if setting in self.editor_settings:
self.settings.set("fife-rpg", setting,
self.editor_settings[setting])
else:
self.settings.remove("fife-rpg", setting)
ComponentManager.clear_components()
ComponentManager.clear_checkers()
ActionManager.clear_actions()
ActionManager.clear_commands()
SystemManager.clear_systems()
BehaviourManager.clear_behaviours()
self.editor.delete_maps()
self.editor.delete_objects()
if self.project_source is not None:
self.engine.getVFS().removeSource(self.project_source)
self.project_source = None
if self.project_dir is not None:
sys.path.remove(self.project_dir)
self.project_dir = None
self.project = None
for callback in self._project_cleared_callbacks:
callback()
self.create_world()
def edit_components(self):
"""Show the dialog to edit components"""
dialog = Components(self)
values = dialog.show_modal(self.editor_gui.editor_window,
self.engine.pump)
if not dialog.return_value:
return False
entities_hidden = self.map_entities is not None
entity = get_entity(self.world, self.selected_object)
tmp_entity_id = None
if entity is not None:
tmp_entity_id = entity.identifier
if entities_hidden:
self.show_map_entities(self.current_map.name)
tmp_file = StringIO()
self.dump_entities(tmp_file)
for entity in tuple(self.world.entities):
entity.delete()
ComponentManager.clear_components()
ComponentManager.clear_checkers()
current_items = list(values["current_items"])
self.project.set("fife-rpg", "Components", current_items)
self.world.register_mandatory_components()
self.register_components(current_items)
tmp_file.seek(0)
self.reset_world(tmp_file)
for game_map in self.maps.values():
game_map.update_entities()
self.update_agents(game_map)
if tmp_entity_id is not None:
tmp_entity = self.world.get_entity(tmp_entity_id)
fife_agent = getattr(tmp_entity, FifeAgent.registered_as)
self.set_selected_object(fife_agent.instance)
if entities_hidden:
self.hide_map_entities(self.current_map.name)
self.project_changed = True
def unregister(cls, auto_unregister=True):
"""Unregister a component class
Args:
auto_register: This sets whether components this component
derives from will have their registered_as property unset as well
Returns:
True if the component was unregistered, false if Not
"""
try:
ComponentManager.unregister_component(cls.__registered_as)
cls.__registered_as = None
if auto_unregister:
for sub_cls in inspect.getmro(cls):
if ((not (sub_cls is cls or sub_cls is Base))
and issubclass(sub_cls, Base)):
# pylint: disable=W0212
sub_cls.__registered_as = None
# pylint: enable=W0212
return True
except NotRegisteredError as error:
print(error)
return False
def create_entity_dictionary(cls, entity):
"""Creates a dictionary containing the values of the Entity
Args:
entity: The Entity instance
Returns:
The created dictionary
"""
entity_dict = {}
components_data = entity_dict["components"] = {}
components = ComponentManager.get_components()
for name, component in components.iteritems():
component_values = getattr(entity, name)
if component_values:
component_data = None
for field in component.saveable_fields:
if not component_data:
component_data = components_data[name] = {}
component_data[field] = getattr(component_values, field)
return entity_dict
