def operation_overrides(locked_args=frozendict()): locked_args = dict(locked_args) dynamic_skill_locked_args = dict(locked_args) if 'chance' not in locked_args: locked_args['chance'] = SuccessChance.ONE dynamic_skill_locked_args = dict(dynamic_skill_locked_args) if 'chance' not in dynamic_skill_locked_args: dynamic_skill_locked_args['chance'] = SuccessChance.ONE if 'advertise' not in dynamic_skill_locked_args: dynamic_skill_locked_args['advertise'] = False return { 'operations': TunableList( description= '\n A list of statistic operations that occur at each interval.\n ', tunable=TunableStatisticChange( dynamic_skill=DynamicSkillLootOp.TunableFactory( locked_args=dynamic_skill_locked_args), dynamic_variant_skill=DynamicVariantSkillLootOp. TunableFactory(), locked_args=locked_args, gain_type=GAIN_TYPE_RATE, statistic_override=StatisticOperation. get_statistic_override(pack_safe=True), default='statistic_change')) }
def setup_asm_posture(self, asm, sim, target, locked_params=frozendict(), actor_param_name=DEFAULT): if actor_param_name is DEFAULT: actor_param_name = self._actor_param_name if asm is None: logger.error('Attempt to setup an asm whose value is None.') return False if sim is None: logger.error('Attempt to setup an asm {0} on a sim whose value is None.', asm) return False if not asm.set_actor(actor_param_name, sim, actor_participant=AnimationParticipant.ACTOR): logger.error('Failed to set actor sim: {0} on asm {1}', actor_param_name, asm) return False sim.set_mood_asm_parameter(asm, actor_param_name) sim.set_trait_asm_parameters(asm, actor_param_name) if target.is_part: is_mirrored = target.is_mirrored() if is_mirrored is not None: locked_params += {'isMirrored': is_mirrored} part_suffix = self.get_part_suffix() if not (target is not None and self._target_name is not None and self._setup_asm_container_parameter(asm, target, actor_param_name, part_suffix)): logger.error('Failed to set actor target: {0} on asm {1}', self._target_name, asm) return False if not PostureTrack.is_body(self.track): self._update_non_body_posture_asm() sim.on_posture_event.append(self._update_on_posture_event) if locked_params: virtual_actor_map = {self._target_name: self.target} asm.update_locked_params(locked_params, virtual_actor_map) self._setup_asm_carry_parameter(asm, target) return True
def append_transition_to_arb(self, arb, source_posture, in_xevt_handler=False, locked_params=frozendict(), posture_spec=None, **kwargs): if in_xevt_handler: locked_params += {'surfaceHeight': 'from_xevt'} super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=in_xevt_handler, **kwargs) return carry_system_target = CarrySystemTerrainTarget(self.sim, self.target, False, self.target.transform) if self.target.is_in_inventory(): if self.target.is_in_sim_inventory(): obj_with_inventory = self.target.get_inventory().owner elif posture_spec is not None: surface = posture_spec[SURFACE_INDEX] obj_with_inventory = surface[SURFACE_TARGET_INDEX] else: obj_with_inventory = None if obj_with_inventory is None: obj_with_inventory = self.target.get_inventory().owner carry_system_target = CarrySystemInventoryTarget( self.sim, self.target, False, obj_with_inventory) else: runtime_slot = self.target.parent_slot if runtime_slot is not None: carry_system_target = CarrySystemRuntimeSlotTarget( self.sim, self.target, False, runtime_slot) if self.target.parent is not None: self.asm.set_actor('surface', self.target.parent) call_super = True if carry_system_target.has_custom_animation: def normal_carry_callback(): arb = animation.arb.Arb() self.append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=True) ArbElement(arb).distribute() carry_system_target.append_custom_animation_to_arb( arb, self, normal_carry_callback) call_super = False arb.register_event_handler(carry_system_target.carry_event_callback, animation.ClipEventType.Script, carry.SCRIPT_EVENT_ID_START_CARRY) if call_super: super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=in_xevt_handler, **kwargs)
def _get_available_transforms_gen(self, actor, target): animation_element = self.canonical_animation actor_name = animation_element.actor_name target_name = animation_element.target_name actor_age = actor.age.age_for_animation_cache target_age = target.age.age_for_animation_cache locked_params = { ('species', actor_name): SpeciesExtended.get_animation_species_param( actor.extended_species), ('age', actor_name): actor_age.animation_age_param, ('species', target_name): SpeciesExtended.get_animation_species_param( target.extended_species), ('age', target_name): target_age.animation_age_param } for (param_sequences, transform) in self.available_transforms: for param_sequence in param_sequences: if not do_params_match(param_sequence, locked_params): continue jig_params = frozendict({ param: value for (param, value) in param_sequence.items() if param not in locked_params }) yield (transform, jig_params)
def _make_boundary_conditions_list(self, actor, to_state_name, from_state_name, locked_params, entry=True, posture=DEFAULT): if any(pattern in str(self) for pattern in _verbose_logging_asms): verbose_logging = True else: verbose_logging = False if not Asm._bc_cache and should_use_boundary_condition_cache(): Asm._bc_cache.update(read_bc_cache_from_resource()) actor_name = self.get_actor_name_from_id(actor.id) if verbose_logging: logger.warn('Traversing as {} ({} -> {})', actor_name, from_state_name, to_state_name) posture = actor.posture if posture is DEFAULT else posture key = (self.name, actor_name, from_state_name, to_state_name, posture.name) containment_slot_data_list = self._bc_cache.get(key) if containment_slot_data_list is None: containment_slot_data_list = self._create_containment_slot_data_list(key, actor, actor_name, to_state_name, from_state_name, posture, entry, verbose_logging) if not containment_slot_data_list: return () if actor.age is not UNSET: real_age_param = {('age', actor_name): actor.age.animation_age_param} locked_params += {('age', actor_name): actor.age.age_for_animation_cache.animation_age_param} else: real_age_param = {} containment_slot_data_list_filtered = [] for (containment_slot, slots_to_params) in containment_slot_data_list: slots_to_params_valid = [] for (boundary_condition, param_sequences) in slots_to_params: param_sequences_valid = [frozendict(param_sequence, real_age_param) for param_sequence in param_sequences if do_params_match(param_sequence, locked_params)] while param_sequences_valid: slots_to_params_valid.append((boundary_condition, tuple(param_sequences_valid))) while slots_to_params_valid: containment_slot_data_list_filtered.append((containment_slot, tuple(slots_to_params_valid))) return tuple(containment_slot_data_list_filtered)
def append_transition_to_arb(self, arb, source_posture, in_xevt_handler=False, locked_params=frozendict(), **kwargs): if source_posture is not None: target = source_posture.target if target is not None: target_anim_overrides = target.get_anim_overrides( source_posture.get_target_name()) locked_params += target_anim_overrides.params self.asm.set_actor(source_posture.get_target_name(), source_posture.target) objects_to_find = [] for object_id in arb.actor_ids: object_found = services.object_manager().get(object_id) if object_found is not None: if object_found.carryable_component is not None: objects_to_find.append(object_found) for object_found in objects_to_find: if in_xevt_handler: object_found.carryable_component.on_object_uncarry(self.sim) else: arb.register_event_handler( lambda *args, **kwargs: object_found.carryable_component. on_object_uncarry(self.sim, *args, **kwargs), animation.ClipEventType.Script, SCRIPT_EVENT_ID_STOP_CARRY) super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=in_xevt_handler, **kwargs)
def get_valid_aops_gen(target, affordance, si_affordance, si, context, include_failed_aops_with_tooltip, push_super_on_prepare=False, considered=None, aop_kwargs=frozendict()): if context.source == InteractionContext.SOURCE_PIE_MENU and not affordance.allow_user_directed: if considered is not None: considered[affordance] = { 'affordance': str(affordance), 'target': str(target), 'test': 'Not allowed user directed' } return potential_interactions = affordance.potential_interactions( target, si_affordance, si, push_super_on_prepare=push_super_on_prepare, **aop_kwargs) for aop in potential_interactions: test_result = aop_valid_for_scoring(aop, affordance, target, context, include_failed_aops_with_tooltip, considered=considered) while test_result is not None: yield (aop, test_result)
def _tuning_loaded_callback(cls): super()._tuning_loaded_callback() incompatibility = defaultdict(list) for (clue, incompatible_clues) in cls.clue_incompatibility.items(): for incompatible_clue in incompatible_clues: incompatibility[clue].append(incompatible_clue) incompatibility[incompatible_clue].append(clue) cls.clue_incompatibility = frozendict(incompatibility)
def append_transition_to_arb(self, arb, source_posture, locked_params=frozendict(), **kwargs): if source_posture is not None: target = source_posture.target if target is not None: target_anim_overrides = target.get_anim_overrides(source_posture.target_name) locked_params += target_anim_overrides.params self.asm.set_actor(source_posture.target_name, source_posture.target) super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, **kwargs)
def SetLifeSpanMultipliers( short: typing.Union[int, float, None] = None, normal: typing.Union[int, float, None] = None, long: typing.Union[int, float, None] = None) -> None: if not isinstance(short, int) and not isinstance( short, float) and short is not None: raise Exceptions.IncorrectTypeException(short, "short", (int, float, None)) if not isinstance(normal, int) and not isinstance( normal, float) and normal is not None: raise Exceptions.IncorrectTypeException(normal, "normal", (int, float, None)) if not isinstance(long, int) and not isinstance( long, float) and long is not None: raise Exceptions.IncorrectTypeException(long, "long", (int, float, None)) currentMultipliers = aging_tuning.AgingTuning.AGE_SPEED_SETTING_MULTIPLIER if short is None: short = currentMultipliers[aging_tuning.AgeSpeeds.FAST] if normal is None: normal = currentMultipliers[aging_tuning.AgeSpeeds.NORMAL] if long is None: long = currentMultipliers[aging_tuning.AgeSpeeds.SLOW] if short != currentMultipliers[ aging_tuning.AgeSpeeds.FAST] and normal != currentMultipliers[ aging_tuning.AgeSpeeds.NORMAL] and long != currentMultipliers[ aging_tuning.AgeSpeeds.SLOW]: return changingMultipliers = { aging_tuning.AgeSpeeds.FAST: short, aging_tuning.AgeSpeeds.NORMAL: normal, aging_tuning.AgeSpeeds.SLOW: long } # noinspection PyUnresolvedReferences newMultipliers = collections.frozendict( currentMultipliers.items(), **changingMultipliers) # TODO way to revert aging_tuning.AgingTuning.AGE_SPEED_SETTING_MULTIPLIER = newMultipliers agingService = None # type: typing.Optional[aging_service.AgingService] try: agingService = services.get_aging_service( ) # type: aging_service.AgingService except Exception: pass if agingService is not None: agingService.set_aging_speed(agingService.aging_speed)
def _destination_filter(surfaces_and_var_maps, dest_spec, var_map): for (surface, slot_var_map) in surfaces_and_var_maps: combo_var_map = frozendict(var_map, slot_var_map) if PostureSpecVariable.SURFACE_TARGET in combo_var_map: surface = combo_var_map[PostureSpecVariable.SURFACE_TARGET] else: slot_child = combo_var_map[PostureSpecVariable.CARRY_TARGET] surface = slot_child.parent op = PostureOperation.TargetAlreadyInSlot(PostureSpecVariable.CARRY_TARGET, surface, PostureSpecVariable.SLOT) while not op.validate(None, None, combo_var_map): return False return True
def _get_param_sequences_for_cache(self, actor, actor_name, to_state_name, from_state_name, posture): internal_param_sequence_list = self._get_param_sequences(actor.id, to_state_name, from_state_name, None) param_sequence_list = [] posture_key = ('posture', actor_name) exact_str = posture.name + '-' family_str = posture.family_name if family_str is not None: family_str = '-' + family_str + '-' for param_sequence in internal_param_sequence_list or (None,): if param_sequence: posture_param_value = param_sequence.get(posture_key) if posture_param_value is not None: if not posture_param_value.startswith(exact_str): while not family_str is None: if family_str not in posture_param_value: pass for age in Age.get_ages_for_animation_cache(): new_sequence = frozendict(param_sequence, {('age', actor_name): age.animation_age_param}) param_sequence_list.append(new_sequence) for age in Age.get_ages_for_animation_cache(): new_sequence = frozendict(param_sequence, {('age', actor_name): age.animation_age_param}) param_sequence_list.append(new_sequence) return param_sequence_list
class TestableGameOptions(enum.IntFlags): CIVIC_POLICY_NPC_VOTING_ENABLED = ... ECO_FOOTPRINT_GAMEPLAY = ... REQUIRED_PACK_BY_OPTION = frozendict({ CIVIC_POLICY_NPC_VOTING_ENABLED: Pack.EP09, ECO_FOOTPRINT_GAMEPLAY: Pack.EP09 }) @property def supporting_pack_installed(self): pack = TestableGameOptions.REQUIRED_PACK_BY_OPTION.get(self, None) return pack is None or is_available_pack(pack)
def _destination_filter(surfaces_and_var_maps, dest_spec, var_map): for (surface, slot_var_map) in surfaces_and_var_maps: combo_var_map = frozendict(var_map, slot_var_map) if PostureSpecVariable.SURFACE_TARGET in combo_var_map: surface = combo_var_map[PostureSpecVariable.SURFACE_TARGET] else: slot_child = combo_var_map[PostureSpecVariable.CARRY_TARGET] surface = slot_child.parent op = PostureOperation.TargetAlreadyInSlot( PostureSpecVariable.CARRY_TARGET, surface, PostureSpecVariable.SLOT) if not op.validate(None, None, combo_var_map): return False return True
def _get_param_sequences_for_age_species_gen(self, param_sequence, actor_name, actor_species, actor_ages, target_name, target_species, target_ages): if target_name is None: params = itertools.product(actor_species, actor_ages) else: params = itertools.product(actor_species, actor_ages, target_species, target_ages) for (_actor_species, _actor_age, *target_params) in params: if not SpeciesExtended.is_age_valid_for_animation_cache(_actor_species, _actor_age): continue age_species_locked_args = {('species', actor_name): SpeciesExtended.get_animation_species_param(_actor_species), ('age', actor_name): _actor_age.animation_age_param} if target_name is not None: (_target_species, _target_age) = target_params if not SpeciesExtended.is_age_valid_for_animation_cache(_target_species, _target_age): continue age_species_locked_args.update({('species', target_name): SpeciesExtended.get_animation_species_param(_target_species), ('age', target_name): _target_age.animation_age_param}) yield frozendict(param_sequence, age_species_locked_args)
def append_transition_to_arb(self, arb, source_posture, locked_params=frozendict(), **kwargs): if source_posture is not None: target = source_posture.target if target is not None: target_anim_overrides = target.get_anim_overrides( source_posture.target_name) locked_params += target_anim_overrides.params self.asm.set_actor(source_posture.target_name, source_posture.target) super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, **kwargs)
def append_transition_to_arb(self, arb, source_posture, locked_params=frozendict(), **kwargs): if not self._entry_anim_complete: locked_params += self.get_locked_params(source_posture) if source_posture is not None: locked_params += {TRANSITION_POSTURE_PARAM_NAME: source_posture.name} if not self.setup_asm_posture(self.asm, self.sim, self.target, locked_params=locked_params): logger.error('Failed to setup the asm for the posture {}', self) return self._setup_asm_target_for_transition(source_posture) self.asm.request(self._enter_state_name, arb) linked_posture = self.linked_posture if linked_posture is not None: locked_params = linked_posture.get_locked_params(source_posture) linked_posture.setup_asm_posture(linked_posture._asm, linked_posture.sim, linked_posture.target, locked_params=locked_params) if not self.multi_sim: linked_posture._asm.request(linked_posture._enter_state_name, arb) self._entry_anim_complete = True
def __init__(self, definition, tuned_native_components=frozendict(), **kwargs): super().__init__() self.id = 0 self.manager = None self.definition = definition self._visible_to_client = False self._interaction_refs = None self._parts = None self.content_source = ContentSource.DEFAULT self.wall_or_fence_placement = self._has_placement_flag(build_buy.PlacementFlags.WALL_GRAPH_PLACEMENT) if definition is not None: services.definition_manager().register_definition(definition.id, self) for component_id in definition.components: comp = objects.components.native_component_id_to_class[component_id] if not comp.has_server_component(): continue factory = getattr(tuned_native_components, comp.CNAME, None) or comp.create_component self.add_component(factory(self))
def __init__(self, dest, dest_state, context, var_map, transition_spec=None, interaction=None, constraint=None, locked_params=frozendict()): super().__init__() self._source = None self._dest = dest self._dest_state = dest_state self._context = context self._var_map = var_map self._status = self.Status.INITIAL self._transition_spec = transition_spec self._interaction = interaction self._constraint = constraint self._locked_params = locked_params
def __init__(self, sim, constraint, geometry, los_reference_point=None, routing_surface_override=None, locked_params=frozendict(), target=None, weight_route_factor=1.0): self.routing_surface = sim.routing_surface if constraint.routing_surface is None else constraint.routing_surface if routing_surface_override is not None: self.routing_surface = routing_surface_override self.routing_surface_override = routing_surface_override super().__init__(geometry.polygon, self.routing_surface) self.locked_params = locked_params self.sim = sim self.constraint = constraint self.geometry = geometry self.los_reference_point = los_reference_point self.target = target self.weight_route_factor = weight_route_factor
def __init__(self, definition, tuned_native_components=frozendict(), **kwargs): super().__init__() self.id = 0 self.manager = None self.definition = definition self.visible_to_client = False self.interaction_refs = set() if definition is not None: services.definition_manager().register_definition( definition.id, self) for component_id in definition.components: comp = objects.components.native_component_id_to_class[ component_id] if not comp.has_server_component(): pass factory = tuned_native_components.get( comp.CNAME) or comp.create_component self.add_component(factory(self))
def create_tuningless_interaction(affordance, **kwargs): locked_fields = dict(basic_reserve_object=None, basic_focus=None, _forwarding=None, allow_from_world=True, basic_extras=(), _constraints=frozendict(), tests=TunableTestSet.DEFAULT_LIST, test_globals=TunableGlobalTestSet.DEFAULT_LIST, test_autonomous=TunableTestSet.DEFAULT_LIST, _static_commodities=(), _false_advertisements=(), _hidden_false_advertisements=(), _cancelable_by_user=True, visible=False, simless=False, allow_autonomous=False, allow_user_directed=False, debug=False, outcome=InteractionOutcome()) if kwargs: locked_fields.update(kwargs) lock_instance_tunables(affordance, **locked_fields)
def get_valid_aops_gen(target, affordance, si_affordance, si, context, include_failed_aops_with_tooltip, push_super_on_prepare=False, considered=None, aop_kwargs=frozendict()): potential_interactions = affordance.potential_interactions( target, si_affordance, si, push_super_on_prepare=push_super_on_prepare, **aop_kwargs) for aop in potential_interactions: test_result = aop_valid_for_scoring(aop, affordance, target, context, include_failed_aops_with_tooltip, considered=considered) if test_result is not None: yield (aop, test_result)
def _make_boundary_conditions_list(self, actor, to_state_name, from_state_name, locked_params, entry=True, posture=DEFAULT, base_object_name=None, target=None): if any(pattern in str(self) for pattern in _verbose_logging_asms): verbose_logging = True else: verbose_logging = False actor_name = self.get_actor_name_from_id(actor.id) target_name = self.get_actor_name_from_id(target.id) if target is not None else None if verbose_logging: logger.warn('Traversing as {} ({} -> {})', actor_name, from_state_name, to_state_name) if posture is DEFAULT: posture = getattr(actor, 'posture', None) key = (self.name, actor_name, target_name, from_state_name, to_state_name, posture.name if posture is not None else None) if caches.USE_ACC_AND_BCC & caches.AccBccUsage.BCC != caches.AccBccUsage.BCC or self._boundary_condition_dirty and key not in self._bc_cache_localwork_keys[self.name]: containment_slot_data_list = None else: containment_slot_data_list = self._bc_cache.get(key) if containment_slot_data_list is None: containment_slot_data_list = self._create_containment_slot_data_list(key, actor, actor_name, to_state_name, from_state_name, posture, entry, verbose_logging, base_object_name=base_object_name, target_name=target_name) if not containment_slot_data_list: return () age = getattr(actor, 'age', UNSET) if age is not UNSET: real_age_param = {('age', actor_name): age.animation_age_param} locked_params += {('age', actor_name): age.age_for_animation_cache.animation_age_param} else: real_age_param = {} containment_slot_data_list_filtered = [] for (containment_slot, slots_to_params) in containment_slot_data_list: slots_to_params_valid = [] for (boundary_condition, param_sequences) in slots_to_params: param_sequences_valid = [frozendict(param_sequence, real_age_param) for param_sequence in param_sequences if do_params_match(param_sequence, locked_params)] if param_sequences_valid: slots_to_params_valid.append((boundary_condition, tuple(param_sequences_valid))) if slots_to_params_valid: containment_slot_data_list_filtered.append((containment_slot, tuple(slots_to_params_valid))) return tuple(containment_slot_data_list_filtered)
def append_exit_to_arb(self, arb, dest_state, dest_posture, var_map, locked_params=frozendict()): if not self._exit_anim_complete: self._setup_asm_target_for_transition(dest_posture) locked_params += self.locked_params if dest_posture is not None: locked_params += {TRANSITION_POSTURE_PARAM_NAME: dest_posture.name} if locked_params: virtual_actor_map = {self._target_name: self.target} self.asm.update_locked_params(locked_params, virtual_actor_map) self.asm.request(self._exit_state_name, arb) self._exit_anim_complete = True
def append_transition_to_arb(self, arb, source_posture, in_xevt_handler=False, locked_params=frozendict(), posture_spec=None, **kwargs): if in_xevt_handler: locked_params += {'surfaceHeight': 'from_xevt'} super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=in_xevt_handler, **kwargs) return carry_system_target = CarrySystemTerrainTarget(self.sim, self.target, False, self.target.transform) if self.target.is_in_inventory(): if self.target.is_in_sim_inventory(): obj_with_inventory = self.target.get_inventory().owner elif posture_spec is not None: surface = posture_spec[SURFACE_INDEX] obj_with_inventory = surface[SURFACE_TARGET_INDEX] else: obj_with_inventory = None if obj_with_inventory is None: obj_with_inventory = self.target.get_inventory().owner carry_system_target = CarrySystemInventoryTarget(self.sim, self.target, False, obj_with_inventory) else: runtime_slot = self.target.parent_slot if runtime_slot is not None: carry_system_target = CarrySystemRuntimeSlotTarget(self.sim, self.target, False, runtime_slot) if self.target.parent is not None: self.asm.set_actor('surface', self.target.parent) call_super = True if carry_system_target.has_custom_animation: def normal_carry_callback(): arb = animation.arb.Arb() self.append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=True) ArbElement(arb).distribute() carry_system_target.append_custom_animation_to_arb(arb, self, normal_carry_callback) call_super = False arb.register_event_handler(carry_system_target.carry_event_callback, animation.ClipEventType.Script, carry.SCRIPT_EVENT_ID_START_CARRY) if call_super: super().append_transition_to_arb(arb, source_posture, locked_params=locked_params, in_xevt_handler=in_xevt_handler, **kwargs)
def generate_content_set(sim, super_affordance, super_interaction, context, potential_targets=(), include_failed_aops_with_tooltip=False, push_super_on_prepare=False, check_posture_compatibility=False, aop_kwargs=frozendict()): si_or_sa = super_interaction if super_interaction is not None else super_affordance if not si_or_sa.has_affordances(): return () yield_to_irq() phase_index = None if super_interaction and not _mixer_name_list: phase_index = super_interaction.phase_index valid = collections.defaultdict(list) if gsi_handlers.content_set_handlers.archiver.enabled: gsi_considered = {} else: gsi_considered = None if check_posture_compatibility and sim is not None and sim.posture.target is not None: show_posture_incompatible_icon = True else: show_posture_incompatible_icon = False if not si_or_sa.is_social or potential_targets: with sims4.callback_utils.invoke_enter_exit_callbacks( sims4.callback_utils.CallbackEvent.CONTENT_SET_GENERATE_ENTER, sims4.callback_utils.CallbackEvent.CONTENT_SET_GENERATE_EXIT): target_to_posture_icon_info = {} for affordance in si_or_sa.all_affordances_gen( phase_index=phase_index): if affordance.is_super: logger.error( 'Content set contains a super affordance: {} has {}', si_or_sa, affordance) targets = _test_affordance_and_get_targets( affordance, potential_targets, sim, considered=gsi_considered) if targets is None: pass for target in targets: valid_aops_gen = get_valid_aops_gen( target, affordance, super_affordance, super_interaction, context, include_failed_aops_with_tooltip, push_super_on_prepare=push_super_on_prepare, considered=gsi_considered, aop_kwargs=aop_kwargs) for (aop, test_result) in valid_aops_gen: if not aop.affordance.is_super: aop_show_posture_incompatible_icon = False if show_posture_incompatible_icon: aop_show_posture_incompatible_icon = show_posture_incompatible_icon if target not in target_to_posture_icon_info: if aop.compatible_with_current_posture_state( sim): aop_show_posture_incompatible_icon = False target_to_posture_icon_info[ target] = aop_show_posture_incompatible_icon else: aop_show_posture_incompatible_icon = target_to_posture_icon_info[ target] aop.show_posture_incompatible_icon = aop_show_posture_incompatible_icon mixer_weight = aop.affordance.calculate_autonomy_weight( sim) else: mixer_weight = 0 valid[affordance].append( (mixer_weight, aop, test_result)) if sim.posture.source_interaction is si_or_sa: for buff in sim.Buffs: buff_aops = get_buff_aops(sim, buff, sim.animation_interaction, context, potential_targets=potential_targets, gsi_considered=gsi_considered) while buff_aops: valid.update(buff_aops) if valid: return list( _select_affordances_gen(sim, super_affordance, valid, show_posture_incompatible_icon, gsi_considered)) return ()
def get_posture_specs_gen(self, interaction=None): for posture_manifest_entry in self.posture_manifest: var_map = {} (hand, carry_target) = posture_manifest_entry.carry_hand_and_target if hand is not None: allowed_hands = None if posture_manifest_entry.actor in _NOT_SPECIFIC_ACTOR: carry_actor = interaction.sim if interaction is not None else None else: carry_actor = posture_manifest_entry.actor if isinstance( carry_target, (str, Definition )) or carry_target == AnimationParticipant.CREATE_TARGET: carry = PostureAspectCarry( (PostureSpecVariable.POSTURE_TYPE_CARRY_NOTHING, None, PostureSpecVariable.HAND)) allowed_hands = carry_target.get_allowed_hands(carry_actor) else: carry = PostureAspectCarry( (PostureSpecVariable.POSTURE_TYPE_CARRY_OBJECT, PostureSpecVariable.CARRY_TARGET, PostureSpecVariable.HAND)) allowed_hands = carry_target.get_allowed_hands(carry_actor) var_map[PostureSpecVariable.CARRY_TARGET] = carry_target if not not allowed_hands is not None and hand not in allowed_hands: continue var_map[PostureSpecVariable.HAND] = hand else: carry = None surface_target = posture_manifest_entry.surface_target if surface_target is not None: surface_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get( surface_target, PostureSpecVariable.SURFACE_TARGET) elif posture_manifest_entry.allow_surface: surface_target = PostureSpecVariable.ANYTHING else: surface_target = None carryable_surfaces = [] other_surfaces = [] for slot_manifest_entry in self.slot_manifest: slot_var_map = {} slot_var_map[PostureSpecVariable.SLOT] = slot_manifest_entry slot_type = PostureSpecVariable.SLOT slot_child = slot_manifest_entry.actor slot_parent = slot_manifest_entry.target slot_child_is_carryable = False slot_target = None if isinstance(slot_child, str): slot_target = None elif isinstance( slot_child, Definition ) or slot_child == AnimationParticipant.CREATE_TARGET: slot_target = None slot_var_map[ PostureSpecVariable.SLOT_TEST_DEFINITION] = slot_child elif hasattr(slot_child, 'manager'): included_sis = [] if interaction.transition is not None: included_sis = interaction.transition.get_included_sis( ).union((interaction, )) else: included_sis = (interaction, ) slot_child_is_carryable = True if not interaction is not None or slot_child.has_component( CARRYABLE_COMPONENT) else False if slot_child_is_carryable and any( included_si.carry_target is slot_child for included_si in included_sis): slot_var_map[ PostureSpecVariable.CARRY_TARGET] = slot_child slot_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get( slot_child, PostureSpecVariable.CARRY_TARGET) elif any(included_si.target is slot_child for included_si in included_sis): slot_var_map[ PostureSpecVariable.SLOT_TARGET] = slot_child slot_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get( slot_child, PostureSpecVariable.SLOT_TARGET) else: logger.error( "Interaction {} has a slot_manifest_entry {} with a slot_child {} that doesn't appear to be a carry target or an interaction target. Please grab Tom Astle and show this to him.", interaction, slot_manifest_entry, slot_child, owner='tastle') if not variables_match(surface_target, slot_parent): logger.error( "One of the slotting requirements for this posture_state_spec has a target different from the posture manifest's surface target. This probably won't work: {} vs {} in {}", surface_target, slot_parent, posture_manifest_entry, owner='jpollak') surface = PostureAspectSurface( (slot_parent, slot_type, slot_target)) if slot_child_is_carryable: carryable_surfaces.append((surface, slot_var_map)) else: other_surfaces.append((surface, slot_var_map)) surface = None first_list_with_surfaces = carryable_surfaces or other_surfaces if first_list_with_surfaces: (surface, slot_var_map) = first_list_with_surfaces.pop() if carryable_surfaces: logger.error( 'Multiple slot requirements for carryable targets, arbitrarily choosing one to manipulate in transition: {}', posture_manifest_entry, owner='jpollak') other_surfaces.extend(carryable_surfaces) var_map.update(slot_var_map) var_map[PostureSpecVariable. DESTINATION_FILTER] = functools.partial( self._destination_filter, other_surfaces) elif surface_target == PostureSpecVariable.ANYTHING: surface = None elif surface_target == None: surface = PostureAspectSurface((None, None, None)) else: surface = PostureAspectSurface((surface_target, None, None)) if not posture_manifest_entry.posture_types: spec = PostureSpec((None, carry, surface)) yield (spec, frozendict(var_map)) else: if posture_manifest_entry.specific: posture_types = posture_manifest_entry.posture_types elif posture_manifest_entry.family: posture_types = [ posture_type for posture_type in services.posture_manager().types.values() if posture_type.family_name == posture_manifest_entry.family ] else: logger.error( 'Posture manifest entry has neither specific nor family.', owner='bhill') for posture_type in posture_types: target_object_filters = [ x.target_object_filter for x in self.posture_manifest if x.target_object_filter is not MATCH_ANY ] if target_object_filters: body = PostureAspectBody( (posture_type, PostureSpecVariable.BODY_TARGET_FILTERED)) var_map[ PostureSpecVariable.BODY_TARGET_FILTERED] = tuple( target_object_filters) else: body = PostureAspectBody( (posture_type, self.body_target)) spec = PostureSpec((body, carry, surface)) yield (spec, frozendict(var_map))
self.sim.routing_component.on_slot = None result = yield from super()._run_interaction_gen(timeline) if not result: return False yield elif self._run_element is not None: result = yield from element_utils.run_child( timeline, self._run_element) return result yield return True yield lock_instance_tunables(SitOrStandSuperInteraction, _constraints=frozendict(), _constraints_actor=ParticipantType.Object) class SatisfyConstraintSuperInteraction(SitOrStandSuperInteraction): INSTANCE_SUBCLASSES_ONLY = True create_tuningless_superinteraction(SatisfyConstraintSuperInteraction) class ForceSatisfyConstraintSuperInteraction(SatisfyConstraintSuperInteraction ): INSTANCE_SUBCLASSES_ONLY = True @classmethod
def post_load(cls, manager): species_to_provided_postures = {} for (species, provided_postures, _) in cls._animation_data.get_supported_postures_gen(): species_to_provided_postures[species] = provided_postures cls._provided_postures = frozendict(species_to_provided_postures)
def __init__(self, sim, constraint, geometry, los_reference_point=None, routing_surface_override=None, locked_params=frozendict(), target=None, weight_route_factor=1.0): self.routing_surface = sim.routing_surface if constraint.routing_surface is None else constraint.routing_surface if routing_surface_override is not None: self.routing_surface = routing_surface_override self.routing_surface_override = routing_surface_override super().__init__(geometry.polygon, self.routing_surface) self.locked_params = locked_params self.sim = sim self.constraint = constraint self.geometry = geometry self.los_reference_point = los_reference_point self.target = target self.weight_route_factor = weight_route_factor
def _do_transition(self, timeline) -> bool: source = self._source dest = self._dest sim = dest.sim posture_track = dest.track starting_position = sim.position def do_auto_exit(timeline): auto_exit_element = get_auto_exit((sim,), asm=source.asm) if auto_exit_element is not None: yield element_utils.run_child(timeline, auto_exit_element) arb = animation.arb.Arb() if dest.external_transition: dest_begin = dest.begin(None, self._dest_state, self._context) result = yield element_utils.run_child(timeline, must_run(dest_begin)) return result try: sim.active_transition = self posture_idle_started = False def start_posture_idle(*_, **__): nonlocal posture_idle_started if posture_idle_started: return dest.log_info('Idle') posture_idle_started = True idle_arb = animation.arb.Arb() dest.append_idle_to_arb(idle_arb) ArbElement(idle_arb, master=sim).distribute() arb.register_event_handler(start_posture_idle, handler_id=self.IDLE_TRANSITION_XEVT) if sim.posture.mobile and self._transition_spec.path is not None: yield element_utils.run_child(timeline, do_auto_exit) result = yield self.do_transition_route(timeline, sim, source, dest) if not result: return result else: result = self._transition_spec.do_reservation(sim) if not result: return result if self._transition_spec is not None and self._transition_spec.portal is not None: portal_transition = self._transition_spec.portal.get_portal_element(sim) yield element_utils.run_child(timeline, portal_transition) if source is dest: sim.on_posture_event(PostureEvent.POSTURE_CHANGED, self._dest_state, dest.track, source, dest) return TestResult.TRUE self._status = self.Status.ANIMATING source_locked_params = frozendict() dest_locked_params = frozendict() dest_posture_spec = None if self._transition_spec is not None and dest.track == PostureTrack.BODY: if not source.mobile: source_locked_params = self._transition_spec.locked_params if not dest.mobile: dest_locked_params = self._transition_spec.locked_params if self._interaction is not None: dest_locked_params += self._interaction.transition_asm_params dest_posture_spec = self._transition_spec.posture_spec def do_transition_animation(timeline): yield element_utils.run_child(timeline, do_auto_exit) source.append_exit_to_arb(arb, self._dest_state, dest, self._var_map, locked_params=source_locked_params) dest.append_transition_to_arb(arb, source, locked_params=dest_locked_params, posture_spec=dest_posture_spec) dest_begin = dest.begin(arb, self._dest_state, self._context) result = yield element_utils.run_child(timeline, [do_auto_exit, dest_begin]) return result sequence = (do_transition_animation,) from carry import interact_with_carried_object, holster_carried_object if dest.track.is_carry(dest.track): if dest.target is not None: carry_target = dest.target carry_posture_state = self._dest_state carry_animation_context = dest.asm.context else: carry_target = source.target carry_posture_state = sim.posture_state carry_animation_context = source.asm.context sequence = interact_with_carried_object(sim, carry_target, posture_state=carry_posture_state, interaction=dest.source_interaction, animation_context=carry_animation_context, sequence=sequence) sequence = holster_carried_object(sim, dest.source_interaction, self._get_unholster_predicate(sim, dest.source_interaction), flush_before_sequence=True, sequence=sequence) sequence = dest.add_transition_extras(sequence) sis = set() sis.add(source.source_interaction) sis.add(dest.source_interaction) sis.update(source.owning_interactions) sis.update(dest.owning_interactions) for si in sis: if si is None: pass with si.cancel_deferred(sis): result = yield element_utils.run_child(timeline, must_run(sequence)) break result = yield element_utils.run_child(timeline, must_run(sequence)) if result: start_posture_idle() yield sim.si_state.process_gen(timeline) finally: sim.active_transition = None self._status = self.Status.FINISHED if self._transition_spec is not None: self._transition_spec.release_additional_reservation_handlers() self._transition_spec.remove_props_created_to_reserve_slots(sim) if sim.posture_state.get_aspect(posture_track) is not dest: logger.debug("{}: _do_transition failed: after transition Sim's posture state aspect isn't destination posture.") if dest.source_interaction is not None: dest.source_interaction.cancel(FinishingType.TRANSITION_FAILURE, cancel_reason_msg='Transition canceled during transition.') return TestResult(False, "After transition Sim's posture state aspect isn't destination posture.") if not dest.unconstrained and sim.transition_controller is not None and not sims4.math.vector3_almost_equal(sim.position, starting_position, epsilon=sims4.geometry.ANIMATION_SLOT_EPSILON): sim.transition_controller.release_stand_slot_reservations((sim,)) return TestResult.TRUE
def _do_transition(self, timeline) -> bool: source = self._source dest = self._dest sim = dest.sim posture_track = dest.track starting_position = sim.position def do_auto_exit(timeline): auto_exit_element = get_auto_exit((sim, ), asm=source.asm) if auto_exit_element is not None: yield from element_utils.run_child(timeline, auto_exit_element) if self._transition_spec is not None and self._transition_spec.portal_obj is not None: portal_obj = self._transition_spec.portal_obj if self._transition_spec.portal_id is not None: new_routing_surface = portal_obj.get_target_surface( self._transition_spec.portal_id) elif not dest.unconstrained and dest.target is not None: new_routing_surface = dest.target.routing_surface elif self._constraint is not None: new_routing_surface = self._constraint.routing_surface else: new_routing_surface = sim.routing_surface arb = animation.arb.Arb() if dest.external_transition: dest_begin = dest.begin(None, self._dest_state, self._context, new_routing_surface) result = yield from element_utils.run_child( timeline, must_run(dest_begin)) return result yield try: sim.active_transition = self posture_idle_started = False def start_posture_idle(*_, **__): nonlocal posture_idle_started if posture_idle_started: return dest.log_info('Idle') posture_idle_started = True idle_arb = animation.arb.Arb() dest.append_idle_to_arb(idle_arb) distribute_arb_element(idle_arb, master=sim) arb.register_event_handler(start_posture_idle, handler_id=self.IDLE_TRANSITION_XEVT) if self._transition_spec is not None: if sim.posture.mobile and self._transition_spec.path is not None: yield from element_utils.run_child(timeline, do_auto_exit) result = yield from self.do_transition_route( timeline, sim, source, dest) if not result: if self._transition_spec.is_failure_path: ( failure_reason, failure_target ) = sim.transition_controller.get_failure_reason_and_target( sim) if failure_reason is not None or failure_target is not None: if self._interaction is not None: yield from element_utils.run_child( timeline, handle_transition_failure( sim, self._interaction.target, self._interaction, failure_reason=failure_reason, failure_object_id=failure_target)) sim.transition_controller.cancel( cancel_reason_msg= 'Transition canceled due to successful route failure.' ) return result yield else: result = self._transition_spec.do_reservation(sim) if not result: return result yield if source is dest: sim.on_posture_event(PostureEvent.POSTURE_CHANGED, self._dest_state, dest.track, source, dest) return TestResult.TRUE yield self._status = self.Status.ANIMATING source_locked_params = frozendict() dest_locked_params = frozendict() if self._transition_spec is not None: source_locked_params = self._transition_spec.locked_params dest_locked_params = self._transition_spec.locked_params dest_posture_spec = None import services zone = services.current_zone() fire_service = services.get_fire_service() lot_on_fire = fire_service.fire_is_active distance_param = PostureTransition.calculate_distance_param( source.target, dest.target) if self._transition_spec is not None: if dest.track == PostureTrack.BODY: if not source.mobile: source_locked_params += {'onFire': lot_on_fire} if distance_param is not None: source_locked_params += { 'distance': distance_param } if not dest.mobile: dest_locked_params += {'onFire': lot_on_fire} if self._interaction is not None: transition_asm_params = sim.get_transition_asm_params( ) dest_locked_params += transition_asm_params source_locked_params += transition_asm_params if distance_param is not None: dest_locked_params += {'distance': distance_param} elif self._transition_spec.portal_obj is not None: transition_asm_params = sim.get_transition_asm_params() dest_locked_params += transition_asm_params source_locked_params += transition_asm_params transition_global_asm_params = sim.get_transition_global_asm_params( ) dest_locked_params += transition_global_asm_params source_locked_params += transition_global_asm_params dest_posture_spec = self._transition_spec.posture_spec source_locked_params += self._locked_params dest_locked_params += self._locked_params if self._transition_spec is not None and self._transition_spec.portal_obj is not None: target_override = self._transition_spec.portal_obj portal_params = self._transition_spec.portal_obj.get_portal_asm_params( self._transition_spec.portal_id, sim) source_locked_params += portal_params dest_locked_params += portal_params else: target_override = None def do_transition_animation(timeline): yield from element_utils.run_child(timeline, do_auto_exit) if PostureTrack.is_carry( dest.track ) and dest.target is not None and dest.target.is_sim: auto_exit_element = get_auto_exit((dest.target, ), asm=source.asm) if auto_exit_element is not None: yield from element_utils.run_child( timeline, auto_exit_element) source.append_exit_to_arb(arb, self._dest_state, dest, self._var_map, locked_params=source_locked_params, target_override=target_override) dest.append_transition_to_arb(arb, source, locked_params=dest_locked_params, posture_spec=dest_posture_spec, target_override=target_override) dest_begin = dest.begin(arb, self._dest_state, self._context, new_routing_surface) result = yield from element_utils.run_child( timeline, [do_auto_exit, dest_begin]) return result yield sequence = (do_transition_animation, ) from carry.carry_utils import interact_with_carried_object, holster_carried_object, maybe_holster_objects_through_sequence if dest.track.is_carry(dest.track): if dest.target is not None: carry_target = dest.target carry_posture_state = self._dest_state carry_animation_context = dest.asm.context else: carry_target = source.target carry_posture_state = sim.posture_state carry_animation_context = source.asm.context sequence = interact_with_carried_object( sim, carry_target, posture_state=carry_posture_state, interaction=dest.source_interaction, animation_context=carry_animation_context, sequence=sequence) if sim.is_required_to_holster_for_transition(source, dest): sequence = maybe_holster_objects_through_sequence( sim, sequence=sequence, unholster_after_predicate=self. _get_unholster_after_predicate(sim, dest.source_interaction)) else: sequence = holster_carried_object( sim, dest.source_interaction, self._get_unholster_predicate(sim, dest.source_interaction), flush_before_sequence=True, sequence=sequence) sequence = dest.add_transition_extras(sequence, arb=arb) mutex_key = self.get_entry_exit_mutex_key() if mutex_key is not None: sequence = mutex.with_mutex( mutex_key, element_utils.build_element(sequence)) sis = set() sis.add(source.source_interaction) sis.add(dest.source_interaction) sis.update(source.owning_interactions) sis.update(dest.owning_interactions) for si in sis: if si is None: continue with si.cancel_deferred(sis): result = yield from element_utils.run_child( timeline, must_run(sequence)) break else: result = yield from element_utils.run_child( timeline, must_run(sequence)) if result: start_posture_idle() yield from sim.si_state.process_gen(timeline) finally: sim.active_transition = None self._status = self.Status.FINISHED if self._transition_spec is not None: self._transition_spec.release_additional_reservation_handlers() self._transition_spec.remove_props_created_to_reserve_slots( sim) if self._transition_spec.portal_obj is not None: self._transition_spec.portal_obj.clear_portal_cost_override( self._transition_spec.portal_id, sim=sim) if sim.posture_state.get_aspect(posture_track) is not dest: logger.debug( "{}: _do_transition failed: after transition Sim's posture state aspect isn't destination posture." ) if dest.source_interaction is not None: dest.source_interaction.cancel( FinishingType.TRANSITION_FAILURE, cancel_reason_msg='Transition canceled during transition.') return TestResult( False, "After transition Sim's posture state aspect isn't destination posture." ) yield if not dest.unconstrained and not not ( sim.transition_controller is not None and sims4.math.vector3_almost_equal( sim.position, starting_position, epsilon=sims4.geometry.ANIMATION_SLOT_EPSILON)): sim.transition_controller.release_stand_slot_reservations((sim, )) return TestResult.TRUE yield
def _create_containment_slot_data_list(self, key, actor, actor_name, to_state_name, from_state_name, posture, entry, verbose_logging): cache_containment_slot_data_list = True param_sequence_list = self._get_param_sequences_for_cache(actor, actor_name, to_state_name, from_state_name, posture) boundary_to_params = {} for param_sequence in param_sequence_list: self.set_param_sequence(param_sequence) yield_to_irq() if verbose_logging: logger.warn(' Setting parameter list on ASM:') for (key, value) in param_sequence.items(): logger.warn(' {}:\t{}', key, value) boundary = self.get_boundary_conditions(actor, to_state_name, from_state_name) boundary.debug_info = None pre_condition_reference_object_name = self.get_actor_name_from_id(boundary.pre_condition_reference_object_id) post_condition_reference_object_name = self.get_actor_name_from_id(boundary.post_condition_reference_object_id) if verbose_logging: logger.warn(' Pre conditions') logger.warn(' Object: {}', pre_condition_reference_object_name) logger.warn(' Translation: {}', boundary.pre_condition_transform.translation) logger.warn(' Orientation: {}', boundary.pre_condition_transform.orientation) logger.warn(' Post conditions') logger.warn(' Object: {}', post_condition_reference_object_name) logger.warn(' Translation: {}', boundary.post_condition_transform.translation) logger.warn(' Orientation: {}', boundary.post_condition_transform.orientation) required_slots = [] currently_set_actor_names = self._get_all_set_actor_names() if boundary.required_slots: for required_slot in boundary.required_slots: pre_condition_surface_child_id = required_slot[0] pre_condition_surface_object_id = required_slot[1] pre_condition_surface_child_name = self.get_actor_name_from_id(pre_condition_surface_child_id) pre_condition_surface_object_name = self.get_actor_name_from_id(pre_condition_surface_object_id) if pre_condition_surface_child_name and pre_condition_surface_object_name: required_slots.append((pre_condition_surface_child_name, pre_condition_surface_object_name, required_slot[2])) else: cache_containment_slot_data_list = False self._log_bc_error(logger.error, currently_set_actor_names, key, 'missing parent or child object', "The parent or child in Maya isn't one of the following actors:") if not required_slots and boundary.pre_condition_reference_object_id is None: pass if boundary.pre_condition_reference_object_id is not None and pre_condition_reference_object_name is None: pass for (boundary_existing, params_list) in boundary_to_params.items(): while pre_condition_reference_object_name == boundary_existing.pre_condition_reference_object_name and (post_condition_reference_object_name == boundary_existing.post_condition_reference_object_name and (self.transform_almost_equal_2d(boundary.pre_condition_transform, boundary_existing.pre_condition_transform) and self.transform_almost_equal_2d(boundary.post_condition_transform, boundary_existing.post_condition_transform))) and required_slots == boundary_existing.required_slots: params_list.append(param_sequence) break boundary_relative = self.BoundaryConditionRelative(pre_condition_reference_object_name, boundary.pre_condition_transform, post_condition_reference_object_name, boundary.post_condition_transform, required_slots, boundary.debug_info) boundary_to_params[boundary_relative] = [param_sequence] if verbose_logging: logger.warn(' Boundary -> Param Sequences') for (key, value) in boundary_to_params.items(): logger.warn(' {}', key) for param_sequence in value: logger.warn(' {}', param_sequence) boundary_list = [] if len(boundary_to_params) > 0: if len(boundary_to_params) == 1: boundary_list.append((boundary_to_params.popitem()[0], [{}])) else: boundary_param_sets = partition_boundary_on_params(boundary_to_params) for (boundary, param_set) in boundary_param_sets.items(): boundary_params_list_minimal = {frozendict({k: v for (k, v) in boundary_params.items() if k in param_set}) for boundary_params in boundary_to_params[boundary]} boundary_list.append((boundary, boundary_params_list_minimal)) relative_object_name = None containment_slot_data_list = [] for (boundary_condition, slot_params_list) in boundary_list: relative_object_name_key = boundary_condition.pre_condition_reference_object_name or boundary_condition.post_condition_reference_object_name if entry: if boundary_condition.post_condition_reference_object_name is not None: containment_transform = boundary_condition.post_condition_transform else: containment_transform = boundary_condition.pre_condition_transform else: containment_transform = boundary_condition.pre_condition_transform for (containment_transform_existing, slots_to_params) in containment_slot_data_list: while self.transform_almost_equal_2d(containment_transform, containment_transform_existing): slots_to_params.append((boundary_condition, slot_params_list)) break containment_slot_data_list.append((containment_transform, [(boundary_condition, slot_params_list)])) if cache_containment_slot_data_list: self._bc_cache[key] = tuple(containment_slot_data_list) return containment_slot_data_list
def generate_content_set(sim, super_affordance, super_interaction, context, potential_targets=(), include_failed_aops_with_tooltip=False, push_super_on_prepare=False, check_posture_compatibility=False, aop_kwargs=frozendict()): si_or_sa = super_interaction if super_interaction is not None else super_affordance if not si_or_sa.has_affordances(): return () yield_to_irq() phase_index = None if super_interaction and not _mixer_name_list: phase_index = super_interaction.phase_index valid = collections.defaultdict(list) if gsi_handlers.content_set_handlers.archiver.enabled: gsi_considered = {} else: gsi_considered = None if check_posture_compatibility and sim is not None and sim.posture.target is not None: show_posture_incompatible_icon = True else: show_posture_incompatible_icon = False if not si_or_sa.is_social or potential_targets: with sims4.callback_utils.invoke_enter_exit_callbacks(sims4.callback_utils.CallbackEvent.CONTENT_SET_GENERATE_ENTER, sims4.callback_utils.CallbackEvent.CONTENT_SET_GENERATE_EXIT): target_to_posture_icon_info = {} for affordance in si_or_sa.all_affordances_gen(phase_index=phase_index): if affordance.is_super: logger.error('Content set contains a super affordance: {} has {}', si_or_sa, affordance) targets = _test_affordance_and_get_targets(affordance, potential_targets, sim, considered=gsi_considered) if targets is None: pass for target in targets: valid_aops_gen = get_valid_aops_gen(target, affordance, super_affordance, super_interaction, context, include_failed_aops_with_tooltip, push_super_on_prepare=push_super_on_prepare, considered=gsi_considered, aop_kwargs=aop_kwargs) for (aop, test_result) in valid_aops_gen: if not aop.affordance.is_super: aop_show_posture_incompatible_icon = False if show_posture_incompatible_icon: aop_show_posture_incompatible_icon = show_posture_incompatible_icon if target not in target_to_posture_icon_info: if aop.compatible_with_current_posture_state(sim): aop_show_posture_incompatible_icon = False target_to_posture_icon_info[target] = aop_show_posture_incompatible_icon else: aop_show_posture_incompatible_icon = target_to_posture_icon_info[target] aop.show_posture_incompatible_icon = aop_show_posture_incompatible_icon mixer_weight = aop.affordance.calculate_autonomy_weight(sim) else: mixer_weight = 0 valid[affordance].append((mixer_weight, aop, test_result)) if sim.posture.source_interaction is si_or_sa: for buff in sim.Buffs: buff_aops = get_buff_aops(sim, buff, sim.animation_interaction, context, potential_targets=potential_targets, gsi_considered=gsi_considered) while buff_aops: valid.update(buff_aops) if valid: return list(_select_affordances_gen(sim, super_affordance, valid, show_posture_incompatible_icon, gsi_considered)) return ()
def get_posture_specs_gen(self): for posture_manifest_entry in self.posture_manifest: var_map = {} if posture_manifest_entry.posture_types: posture_type = posture_manifest_entry.posture_types[0] body = PostureAspectBody((posture_type, self.body_target)) else: body = None (hand, carry_target) = posture_manifest_entry.carry_hand_and_target if hand is not None: allowed_hands = None if isinstance(carry_target, (str, Definition)) or carry_target == AnimationParticipant.CREATE_TARGET: carry = PostureAspectCarry((PostureSpecVariable.POSTURE_TYPE_CARRY_NOTHING, None, PostureSpecVariable.HAND)) if isinstance(carry_target, Definition): allowed_hands = carry_target.cls.allowed_hands else: carry = PostureAspectCarry((PostureSpecVariable.POSTURE_TYPE_CARRY_OBJECT, PostureSpecVariable.CARRY_TARGET, PostureSpecVariable.HAND)) if hasattr(carry_target, 'manager'): allowed_hands = carry_target.allowed_hands var_map[PostureSpecVariable.CARRY_TARGET] = carry_target if allowed_hands is not None and hand not in allowed_hands: pass var_map[PostureSpecVariable.HAND] = hand else: carry = None surface_target = posture_manifest_entry.surface_target if surface_target is not None: surface_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get(surface_target, PostureSpecVariable.SURFACE_TARGET) elif posture_manifest_entry.allow_surface: surface_target = PostureSpecVariable.ANYTHING else: surface_target = None carryable_surfaces = [] other_surfaces = [] for slot_manifest_entry in self.slot_manifest: slot_var_map = {} slot_var_map[PostureSpecVariable.SLOT] = slot_manifest_entry slot_type = PostureSpecVariable.SLOT slot_child = slot_manifest_entry.actor slot_parent = slot_manifest_entry.target slot_child_is_carryable = False if isinstance(slot_child, str): slot_target = None elif isinstance(slot_child, Definition) or slot_child == AnimationParticipant.CREATE_TARGET: slot_target = None slot_var_map[PostureSpecVariable.SLOT_TEST_DEFINITION] = slot_child else: slot_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get(slot_child, PostureSpecVariable.CARRY_TARGET) if hasattr(slot_child, 'manager'): slot_var_map[PostureSpecVariable.CARRY_TARGET] = slot_child slot_child_is_carryable = True if slot_child.has_component(CARRYABLE_COMPONENT) else False if not variables_match(surface_target, slot_parent): logger.error("One of the slotting requirements for this posture_state_spec has a target different from the posture manifest's surface target. This probably won't work: {} vs {} in {}", surface_target, slot_parent, posture_manifest_entry, owner='jpollak') surface = PostureAspectSurface((slot_parent, slot_type, slot_target)) if slot_child_is_carryable: carryable_surfaces.append((surface, slot_var_map)) else: other_surfaces.append((surface, slot_var_map)) surface = None first_list_with_surfaces = carryable_surfaces or other_surfaces if first_list_with_surfaces: (surface, slot_var_map) = first_list_with_surfaces.pop() if carryable_surfaces: logger.error('Multiple slot requirements for carryable targets, arbitrarily choosing one to manipulate in transition: {}', posture_manifest_entry, owner='jpollak') other_surfaces.extend(carryable_surfaces) var_map.update(slot_var_map) var_map[PostureSpecVariable.DESTINATION_FILTER] = functools.partial(self._destination_filter, other_surfaces) elif surface_target == PostureSpecVariable.ANYTHING: surface = None elif surface_target == None: surface = PostureAspectSurface((None, None, None)) else: surface = PostureAspectSurface((surface_target, None, None)) spec = PostureSpec((body, carry, surface)) yield (spec, frozendict(var_map))
def get_posture_specs_gen(self): for posture_manifest_entry in self.posture_manifest: var_map = {} if posture_manifest_entry.posture_types: posture_type = posture_manifest_entry.posture_types[0] body = PostureAspectBody((posture_type, self.body_target)) else: body = None (hand, carry_target) = posture_manifest_entry.carry_hand_and_target if hand is not None: allowed_hands = None if isinstance( carry_target, (str, Definition )) or carry_target == AnimationParticipant.CREATE_TARGET: carry = PostureAspectCarry( (PostureSpecVariable.POSTURE_TYPE_CARRY_NOTHING, None, PostureSpecVariable.HAND)) if isinstance(carry_target, Definition): allowed_hands = carry_target.cls.allowed_hands else: carry = PostureAspectCarry( (PostureSpecVariable.POSTURE_TYPE_CARRY_OBJECT, PostureSpecVariable.CARRY_TARGET, PostureSpecVariable.HAND)) if hasattr(carry_target, 'manager'): allowed_hands = carry_target.allowed_hands var_map[ PostureSpecVariable.CARRY_TARGET] = carry_target if allowed_hands is not None and hand not in allowed_hands: pass var_map[PostureSpecVariable.HAND] = hand else: carry = None surface_target = posture_manifest_entry.surface_target if surface_target is not None: surface_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get( surface_target, PostureSpecVariable.SURFACE_TARGET) elif posture_manifest_entry.allow_surface: surface_target = PostureSpecVariable.ANYTHING else: surface_target = None carryable_surfaces = [] other_surfaces = [] for slot_manifest_entry in self.slot_manifest: slot_var_map = {} slot_var_map[PostureSpecVariable.SLOT] = slot_manifest_entry slot_type = PostureSpecVariable.SLOT slot_child = slot_manifest_entry.actor slot_parent = slot_manifest_entry.target slot_child_is_carryable = False if isinstance(slot_child, str): slot_target = None elif isinstance( slot_child, Definition ) or slot_child == AnimationParticipant.CREATE_TARGET: slot_target = None slot_var_map[ PostureSpecVariable.SLOT_TEST_DEFINITION] = slot_child else: slot_target = ANIMATION_PARTICIPANT_TO_POSTURE_SPEC_VARIABLE_MAP.get( slot_child, PostureSpecVariable.CARRY_TARGET) if hasattr(slot_child, 'manager'): slot_var_map[ PostureSpecVariable.CARRY_TARGET] = slot_child slot_child_is_carryable = True if slot_child.has_component( CARRYABLE_COMPONENT) else False if not variables_match(surface_target, slot_parent): logger.error( "One of the slotting requirements for this posture_state_spec has a target different from the posture manifest's surface target. This probably won't work: {} vs {} in {}", surface_target, slot_parent, posture_manifest_entry, owner='jpollak') surface = PostureAspectSurface( (slot_parent, slot_type, slot_target)) if slot_child_is_carryable: carryable_surfaces.append((surface, slot_var_map)) else: other_surfaces.append((surface, slot_var_map)) surface = None first_list_with_surfaces = carryable_surfaces or other_surfaces if first_list_with_surfaces: (surface, slot_var_map) = first_list_with_surfaces.pop() if carryable_surfaces: logger.error( 'Multiple slot requirements for carryable targets, arbitrarily choosing one to manipulate in transition: {}', posture_manifest_entry, owner='jpollak') other_surfaces.extend(carryable_surfaces) var_map.update(slot_var_map) var_map[PostureSpecVariable. DESTINATION_FILTER] = functools.partial( self._destination_filter, other_surfaces) elif surface_target == PostureSpecVariable.ANYTHING: surface = None elif surface_target == None: surface = PostureAspectSurface((None, None, None)) else: surface = PostureAspectSurface((surface_target, None, None)) spec = PostureSpec((body, carry, surface)) yield (spec, frozendict(var_map))
def get_boundary_conditions_list(self, actor, to_state_name, from_state_name=DEFAULT, entry=True, locked_params=frozendict(), posture=DEFAULT): if from_state_name is DEFAULT: from_state_name = 'entry' boundary_list = self._make_boundary_conditions_list(actor, to_state_name, from_state_name, locked_params, entry=entry, posture=posture) return boundary_list
def __init__(self, sim, current_posture_state, posture_spec, var_map, invalid_expected=False, body_state_spec_only=False, carry_posture_overrides=frozendict(), is_throwaway=False): def _get_default_carry_aspect(track): if track in carry_posture_overrides: return carry_posture_overrides[track] return postures.create_posture( CarryPostureStaticTuning.POSTURE_CARRY_NOTHING, sim, None, track=track) self._constraint_intersection = None self._constraint_intersection_dirty = True self._spec = posture_spec self._sim_ref = sim.ref() self._linked_posture_state = None self._valid = True self._constraints = {} self._invalid_expected = invalid_expected self.body_state_spec_only = body_state_spec_only self._posture_constraint = None self._posture_constraint_strict = None body_index = BODY_INDEX body_posture_type_index = BODY_POSTURE_TYPE_INDEX body_target_index = BODY_TARGET_INDEX spec_body = posture_spec[body_index] self.body_target = spec_body[body_target_index] if current_posture_state is None or spec_body[ body_posture_type_index] != current_posture_state.body.posture_type or spec_body[ body_target_index] != current_posture_state.body.target: animation_context = None if current_posture_state is not None: if not current_posture_state.body.mobile: if not spec_body[body_posture_type_index].mobile: animation_context = current_posture_state.body.animation_context self._aspect_body = postures.create_posture( spec_body[body_posture_type_index], self.sim, self.body_target, animation_context=animation_context, is_throwaway=is_throwaway) else: self._aspect_body = current_posture_state.body posture_manifest = self._aspect_body.get_provided_postures( surface_target=self.surface_target, concrete=True) posture_manifest = posture_manifest.get_constraint_version(self.sim) posture_state_spec = PostureStateSpec( posture_manifest, SlotManifest(), self._aspect_body.target or PostureSpecVariable.ANYTHING) self.body_posture_state_constraint = Constraint( debug_name='PostureStateManifestConstraint', posture_state_spec=posture_state_spec) if body_state_spec_only: self._constraints[None] = self.body_posture_state_constraint return body_slot_constraint = self._aspect_body.slot_constraint if not (body_slot_constraint is not None and (self._aspect_body.is_vehicle and current_posture_state is not None) and current_posture_state.body.is_vehicle): body_posture_constraint = self.body_posture_state_constraint.intersect( body_slot_constraint) else: body_posture_constraint = self.body_posture_state_constraint self._constraints[None] = body_posture_constraint if current_posture_state is not None: curr_spec_carry_target = current_posture_state.get_posture_spec( var_map)[CARRY_INDEX][CARRY_TARGET_INDEX] spec_carry = posture_spec[CARRY_INDEX] spec_carry_target = spec_carry[CARRY_TARGET_INDEX] if current_posture_state is not None and spec_carry_target != curr_spec_carry_target: if spec_carry_target is None: current_carry_target = var_map.get(curr_spec_carry_target) current_carry_track = current_posture_state.get_carry_track( current_carry_target) if current_carry_track == PostureTrack.RIGHT: self._aspect_carry_right = _get_default_carry_aspect( PostureTrack.RIGHT) self._aspect_carry_left = current_posture_state.left else: self._aspect_carry_left = _get_default_carry_aspect( PostureTrack.LEFT) self._aspect_carry_right = current_posture_state.right else: spec_carry_posture_type = spec_carry[CARRY_POSTURE_TYPE_INDEX] if spec_carry_target not in var_map: raise KeyError( 'spec_carry_target {} not in var_map:{}. Sim posture state {} and carry aspects {}, ' .format(spec_carry_target, var_map, current_posture_state, current_posture_state.carry_aspects)) if spec_carry_posture_type not in var_map: carry_target = var_map[spec_carry_target] aop = posture_specs.get_carry_posture_aop( sim, carry_target) if aop is None: raise RuntimeError( 'Sim {} failed to find carry posture aop for carry target {}.' .format(sim, carry_target)) carry_posture_type = aop.affordance._carry_posture_type if carry_posture_type is None: raise KeyError var_map += { PostureSpecVariable.POSTURE_TYPE_CARRY_OBJECT: carry_posture_type } carry_target = var_map[spec_carry_target] carry_posture_type = var_map[spec_carry_posture_type] if spec_carry[CARRY_HAND_INDEX] in var_map: hand = var_map[spec_carry[CARRY_HAND_INDEX]] else: for hand in sim.posture_state.get_free_hands(): if hand in carry_target.get_allowed_hands(sim): break else: raise RuntimeError('No allowable free hand was empty.') new_carry_aspect = postures.create_posture( carry_posture_type, self.sim, carry_target, track=hand_to_track(hand), is_throwaway=is_throwaway) if hand == Hand.LEFT: self._aspect_carry_left = new_carry_aspect if current_posture_state is not None: self._aspect_carry_right = current_posture_state.right else: self._aspect_carry_right = _get_default_carry_aspect( PostureTrack.RIGHT) elif hand == Hand.RIGHT: self._aspect_carry_right = new_carry_aspect if current_posture_state is not None: self._aspect_carry_left = current_posture_state.left else: self._aspect_carry_right = _get_default_carry_aspect( PostureTrack.LEFT) else: raise RuntimeError( 'Invalid value specified for hand: {}'.format(hand)) elif current_posture_state is not None: self._aspect_carry_left = current_posture_state.left self._aspect_carry_right = current_posture_state.right elif spec_carry_target is not None: carry_target = var_map[spec_carry_target] spec_carry_posture_type = spec_carry[CARRY_POSTURE_TYPE_INDEX] carry_posture_type = var_map.get(spec_carry_posture_type) if carry_posture_type is None: aop = get_carry_posture_aop(sim, carry_target) if aop is None and invalid_expected: return carry_posture_type = aop.affordance._carry_posture_type if spec_carry[CARRY_HAND_INDEX] in var_map: hand = var_map[spec_carry[CARRY_HAND_INDEX]] else: allowed_hands = carry_target.get_allowed_hands(sim) hand = allowed_hands[0] new_carry_aspect = postures.create_posture( carry_posture_type, self.sim, carry_target, track=hand_to_track(hand), is_throwaway=is_throwaway) if hand == Hand.LEFT: self._aspect_carry_left = new_carry_aspect self._aspect_carry_right = _get_default_carry_aspect( PostureTrack.RIGHT) else: self._aspect_carry_right = new_carry_aspect self._aspect_carry_left = _get_default_carry_aspect( PostureTrack.LEFT) else: self._aspect_carry_left = _get_default_carry_aspect( PostureTrack.LEFT) self._aspect_carry_right = _get_default_carry_aspect( PostureTrack.RIGHT)
def get_valid_aops_gen(target, affordance, si_affordance, si, context, include_failed_aops_with_tooltip, push_super_on_prepare=False, considered=None, aop_kwargs=frozendict()): if context.source == InteractionContext.SOURCE_PIE_MENU and not affordance.allow_user_directed: if considered is not None: considered[affordance] = {'affordance': str(affordance), 'target': str(target), 'test': 'Not allowed user directed'} return potential_interactions = affordance.potential_interactions(target, si_affordance, si, push_super_on_prepare=push_super_on_prepare, **aop_kwargs) for aop in potential_interactions: test_result = aop_valid_for_scoring(aop, affordance, target, context, include_failed_aops_with_tooltip, considered=considered) while test_result is not None: yield (aop, test_result)