def make_constraint_default(cls, actor, target_sim, position, routing_surface, participant_type=ParticipantType.Actor, picked_object=None, participant_slot_overrides=None): if participant_type not in (ParticipantType.Actor, ParticipantType.TargetSim): return Anywhere() all_transforms = [] for (actor_transform, target_transform, routing_surface, _) in cls._get_jig_transforms_gen( actor, target_sim, picked_object=picked_object, participant_slot_overrides=participant_slot_overrides): if participant_type == ParticipantType.Actor: transform = actor_transform else: transform = target_transform if transform is None: continue all_transforms.append( interactions.constraints.Transform( transform, routing_surface=routing_surface, debug_name='JigGroupConstraint')) if not all_transforms: return Nowhere('Unable to get constraints from jig.') return create_constraint_set(all_transforms)
def constraint_gen(cls, inst, sim, target, participant_type, *args, **kwargs): if inst is not None and inst._edge_constraint is not None: yield inst._edge_constraint return inst_or_cls = cls if inst is None else inst pick_position = inst_or_cls.context.pick if pick_position is None: pick_position = target.position else: pick_position = pick_position.location pool_block_id = build_buy.get_block_id(sim.zone_id, pick_position, inst_or_cls.context.pick.level - 1) if pool_block_id == 0: if inst_or_cls.context.pick.routing_surface.type == SurfaceType.SURFACETYPE_POOL: if get_water_depth(sim.position.x, sim.position.z, sim.level) > 0: pool_edge_constraints = ANYWHERE else: pool_edge_constraints = OceanStartLocationConstraint.create_simple_constraint(WaterDepthIntervals.WET, 1, sim, target) return else: return else: pool = pool_utils.get_pool_by_block_id(pool_block_id) if pool is None: return pool_edge_constraints = pool.get_edge_constraint(constraint_width=inst_or_cls.edge_constraint_width, inward_dir=False, return_constraint_list=True, los_reference_point=pick_position) constraint_set = create_constraint_set(pool_edge_constraints) inst._edge_constraint = constraint_set yield constraint_set
def create_put_down_in_slot_type_constraint(sim, target, slot_types_and_costs): constraints = [] for (slot_type, cost) in slot_types_and_costs: if cost is None: pass slot_manifest_entry = SlotManifestEntry(target, PostureSpecVariable.ANYTHING, slot_type) slot_manifest = SlotManifest((slot_manifest_entry, )) posture_state_spec_stand = PostureStateSpec( STAND_POSTURE_MANIFEST, slot_manifest, PostureSpecVariable.ANYTHING) posture_constraint_stand = Constraint( debug_name='PutDownInSlotTypeConstraint_Stand', posture_state_spec=posture_state_spec_stand, cost=cost) constraints.append(posture_constraint_stand) posture_state_spec_sit = PostureStateSpec(SIT_POSTURE_MANIFEST, slot_manifest, PostureSpecVariable.ANYTHING) posture_constraint_sit = Constraint( debug_name='PutDownInSlotTypeConstraint_Sit', posture_state_spec=posture_state_spec_sit, cost=cost) constraints.append(posture_constraint_sit) if not constraints: return Nowhere() final_constraint = create_constraint_set(constraints) return final_constraint
def _get_constraint(self, sim): if self._focus is None: logger.error( 'Attempt to get a constraint for a Sim before the group constraint is initialized: {} for {}', self, sim, owner='camilogarcia') return Anywhere() geometric_constraint = self._constraint if geometric_constraint is None: logger.error( 'Attempt to get the constraint from a Social group before it has been initialized. Social Group is {}, Size of group is {}, and minimum number allowed for group is {}', self, len(self), self.minimum_sim_count, owner='camilogarcia') return Anywhere() scoring_constraints = [] for other_sim in self: if other_sim is sim: continue facing_anchor = self._anchor_object if self._anchor_object is not None else other_sim force_readjustment = sim.id in self._pending_adjustments if force_readjustment: self._pending_adjustments.remove(sim.id) scoring_constraint = self.facing_restriction.create_constraint( sim, facing_anchor, scoring_functions=(self.scoring_function( sim, other_sim, force_readjustment), )) scoring_constraints.append(scoring_constraint) scoring_constraints = create_constraint_set(scoring_constraints) geometric_constraint = geometric_constraint.intersect( scoring_constraints) return geometric_constraint
def callback(cls, fields, source, *, factory, overrides, actor_participant_type=ParticipantType.Actor, target_participant_type=ParticipantType.TargetSim, **kwargs): if cls is None: return participant_constraint_lists = {} run_in_sequence = factory.run_in_sequence for animation_element_factory in factory.animation_element_gen(): animation_element = animation_element_factory() asm_key = animation_element.asm_key actor_name = animation_element.actor_name target_name = animation_element.target_name carry_target_name = animation_element.carry_target_name create_target_name = animation_element.create_target_name initial_state = animation_element.initial_state begin_states = animation_element.begin_states instance_overrides = overrides() total_overrides = animation_element.overrides(overrides=instance_overrides) cls.register_tuned_animation(interaction_asm_type, asm_key, actor_name, target_name, carry_target_name, create_target_name, total_overrides, actor_participant_type, target_participant_type) if animation_element_factory._child_animations: for child_args in animation_element_factory._child_animations: cls.register_tuned_animation(*child_args) if should_use_animation_constaint_cache(): return if animation_element_factory._child_constraints: for child_args in animation_element_factory._child_constraints: cls.add_auto_constraint(*child_args) from interactions.utils.animation import InteractionAsmType while interaction_asm_type == InteractionAsmType.Interaction or (interaction_asm_type == InteractionAsmType.Canonical or interaction_asm_type == InteractionAsmType.Outcome) or interaction_asm_type == InteractionAsmType.Response: from interactions.constraints import create_animation_constraint def add_participant_constraint(participant_type, animation_constraint): if animation_constraint is not None: if interaction_asm_type == InteractionAsmType.Canonical: is_canonical = True else: is_canonical = False if run_in_sequence: cls.add_auto_constraint(participant_type, animation_constraint, is_canonical=is_canonical) else: if participant_type not in participant_constraint_lists: participant_constraint_lists[participant_type] = [] participant_constraint_lists[participant_type].append(animation_constraint) animation_constraint_actor = None try: animation_constraint_actor = create_animation_constraint(asm_key, actor_name, target_name, carry_target_name, create_target_name, initial_state, begin_states, total_overrides) except: if interaction_asm_type != InteractionAsmType.Outcome: logger.exception('Exception while processing tuning for {}', cls) add_participant_constraint(actor_participant_type, animation_constraint_actor) if target_name is not None: animation_context = get_throwaway_animation_context() asm = animation.asm.Asm(asm_key, animation_context, posture_manifest_overrides=total_overrides.manifests) target_actor_definition = asm.get_actor_definition(target_name) if target_actor_definition.actor_type == ASM_ACTORTYPE_SIM: animation_constraint_target = create_animation_constraint(asm_key, target_name, actor_name, carry_target_name, create_target_name, initial_state, begin_states, total_overrides) add_participant_constraint(target_participant_type, animation_constraint_target) if not run_in_sequence and participant_constraint_lists is not None: from interactions.constraints import create_constraint_set for (participant_type, constraints_list) in participant_constraint_lists.items(): cls.add_auto_constraint(participant_type, create_constraint_set(constraints_list))
def redraw(self, sim, constraint): color = pseudo_random_color(sim.id) (r, g, b, a) = sims4.color.to_rgba(color) (gr, gg, gb, ga) = sims4.color.to_rgba(Color.GREY) semitransparent = sims4.color.from_rgba((gr + r)/2, (gg + g)/2, (gb + b)/2, (ga + a)/2*0.4) transparent = sims4.color.from_rgba((gr + r)/2, (gg + g)/2, (gb + b)/2, (ga + a)/2*0.15) with Context(self.layer, routing_surface=constraint.routing_surface) as layer: direction_constraint = None direction_constraints = [] for sub_constraint in constraint: while sub_constraint._geometry is not None and sub_constraint._geometry.polygon is None and sub_constraint._geometry.restrictions is not None: direction_constraints.append(sub_constraint) if direction_constraints: direction_constraint = create_constraint_set(direction_constraints) for si in sim.si_state: participant_type = si.get_participant_type(sim) for si_constraint in si.constraint_intersection(participant_type=participant_type): if direction_constraint is not None: si_constraint = direction_constraint.intersect(si_constraint) si_color = transparent si_altitude = 0.01 if si.is_guaranteed(): si_color = semitransparent si_altitude = 0.02 _draw_constraint(layer, si_constraint, si_color, altitude_modifier=si_altitude) _draw_constraint(layer, constraint, color, altitude_modifier=0.03, anywhere_position=sim.position)
def _constraint_gen(cls, inst, sim, target, **kwargs): inst_or_cls = inst if inst is not None else cls yield from super(__class__, inst_or_cls)._constraint_gen(sim, target, **kwargs) if inst is not None: inst._slot_constraint = create_put_down_in_slot_type_constraint( sim, target, inst._slot_types_and_costs) inst._world_constraint = create_put_down_on_ground_constraint( sim, target, inst._terrain_transform, cost=inst._world_cost) inst._sim_inventory_constraint = create_put_down_in_self_inventory_constraint( inst, sim, target, cost=inst._sim_inventory_cost) inst._object_inventory_constraint = create_put_down_in_inventory_constraint( inst, sim, target, targets_with_inventory=inst._objects_with_inventory, cost=inst._object_inventory_cost) if inst._slot_constraint.valid or ( inst._world_constraint.valid or inst._sim_inventory_constraint.valid ) or inst._object_inventory_constraint.valid: constraints = [ inst._slot_constraint, inst._world_constraint, inst._sim_inventory_constraint, inst._object_inventory_constraint ] final_constraint = create_constraint_set(constraints) else: final_constraint = Nowhere( 'PutDownAnywhere could not create any valid putdown constraint.' ) yield final_constraint
def create_put_down_in_inventory_constraint(inst, sim, target, targets_with_inventory, cost=0): if cost is None or not targets_with_inventory: return Nowhere( 'No Cost({}) or No Targets with an inventory of the correct type. Sim: {} Target: {}', cost, sim, target) carry_constraint = create_carry_constraint( target, debug_name='CarryForPutDownInInventory') carry_constraint = carry_constraint.generate_constraint_with_cost(cost) object_constraints = [] for target_with_inventory in targets_with_inventory: if target_with_inventory.item_location == ItemLocation.SIM_INVENTORY: continue constraint = target_with_inventory.get_inventory_access_constraint( sim, True, target) if constraint is None: logger.error( '{} failed to get inventory access constraint for {}, \n If you cannot put down objects in this inventory, you should uncheck: Components -> Inventory -> Allow Putdown In Inventory.\n If you can, you need to properly tune GetPut', sim, target, owner='tastle') return Nowhere( 'Failed Inventory Access Constraint: See Gameplay Console for error.' ) constraint = constraint.apply_posture_state( None, inst.get_constraint_resolver(None)) object_constraints.append(constraint) final_constraint = create_constraint_set(object_constraints) final_constraint = carry_constraint.intersect(final_constraint) return final_constraint
def get_inventory_access_constraint(self, *args, **kwargs): constraint_list = [] for obj in self.owning_objects_gen(): constraint_list.append( obj.get_inventory_access_constraint(*args, **kwargs)) return create_constraint_set(constraint_list, debug_name='Object Inventory Constraints')
def _create_floor_feature_constraint_set(cls, inst, sim): inst_or_cls = inst if inst is not None else cls floor_feature_contraints = [] floor_features_and_surfaces = [] zone_id = services.current_zone_id() floor_features = build_buy.list_floor_features(inst_or_cls.terrain_feature) if floor_features is None: return Nowhere('No found floor features.') radius_object = None if inst_or_cls.radius_filter is not None: radius_object = inst_or_cls.get_participant(inst_or_cls.radius_filter.radius_actor) if inst_or_cls.radius_filter is not None and radius_object is None: return Nowhere('Radius filter is enabled but the radius actor has a None value.') for floor_feature in floor_features: if inst_or_cls.indoors_only and build_buy.is_location_natural_ground(floor_feature[0], floor_feature[1]): continue routing_surface = routing.SurfaceIdentifier(zone_id, floor_feature[1], routing.SurfaceType.SURFACETYPE_WORLD) floor_feature_location = floor_feature[0] if inst_or_cls.radius_filter is not None: if (radius_object.position - floor_feature_location).magnitude_squared() <= inst_or_cls.radius_filter.radius: floor_features_and_surfaces.append((floor_feature_location, routing_surface)) floor_features_and_surfaces.append((floor_feature_location, routing_surface)) else: floor_features_and_surfaces.append((floor_feature_location, routing_surface)) if floor_features_and_surfaces: for floor_feature_and_surface in floor_features_and_surfaces: circle_constraint = inst_or_cls.routing_circle_constraint.create_constraint(sim, None, target_position=floor_feature_and_surface[0], routing_surface=floor_feature_and_surface[1]) facing_constraint = inst_or_cls.routing_facing_constraint.create_constraint(sim, None, target_position=floor_feature_and_surface[0], routing_surface=floor_feature_and_surface[1]) constraint = circle_constraint.intersect(facing_constraint) floor_feature_contraints.append(constraint) return create_constraint_set(floor_feature_contraints) return Nowhere('With radius filter enabled, no found floor features are within range.')
def _constraint_gen(cls, inst, sim, target, participant_type=ParticipantType.Actor): if inst is not None: inst._slot_constraint = create_put_down_in_slot_type_constraint( sim, target, inst._slot_types_and_costs) inst._world_constraint = create_put_down_on_ground_constraint( sim, target, inst._terrain_transform, cost=inst._world_cost) inst._sim_inventory_constraint = create_put_down_in_inventory_constraint( inst, sim, target, targets_with_inventory=[sim], cost=inst._sim_inventory_cost) inst._object_inventory_constraint = create_put_down_in_inventory_constraint( inst, sim, target, targets_with_inventory=inst._objects_with_inventory, cost=inst._object_inventory_cost) constraints = [ inst._slot_constraint, inst._world_constraint, inst._sim_inventory_constraint, inst._object_inventory_constraint ] final_constraint = create_constraint_set(constraints) yield final_constraint
def _constraint_gen(cls, inst, sim, target, participant_type=ParticipantType.Actor): if inst is not None: inst._slot_constraint = create_put_down_in_slot_type_constraint(sim, target, inst._slot_types_and_costs) inst._world_constraint = create_put_down_on_ground_constraint(sim, target, inst._terrain_transform, cost=inst._world_cost) inst._sim_inventory_constraint = create_put_down_in_inventory_constraint(inst, sim, target, targets_with_inventory=[sim], cost=inst._sim_inventory_cost) inst._object_inventory_constraint = create_put_down_in_inventory_constraint(inst, sim, target, targets_with_inventory=inst._objects_with_inventory, cost=inst._object_inventory_cost) constraints = [inst._slot_constraint, inst._world_constraint, inst._sim_inventory_constraint, inst._object_inventory_constraint] final_constraint = create_constraint_set(constraints) yield final_constraint
def routing_debug_generate_routing_goals_from_geometry( *args, obj: OptionalTargetParam = None, _connection=None): output = sims4.commands.Output(_connection) obj = get_optional_target(obj, _connection=_connection) if obj is None: return False routing_component = obj.get_component(ROUTING_COMPONENT) if routing_component is None: return False total_string = ''.join(args) polygon_strs = find_substring_in_repr(total_string, POLYGON_STR, POLYGON_END_PARAM) if not polygon_strs: output('No valid polygons. must start with {} and end with {}'.format( POLYGON_STR, POLYGON_END_PARAM)) return constraints = [] routing_surface = routing.SurfaceIdentifier( services.current_zone_id(), 0, routing.SurfaceType.SURFACETYPE_OBJECT) for poly_str in polygon_strs: point_list = extract_floats(poly_str) if not point_list or len(point_list) % 2 != 0: output('Point list is not valid length. Too few or one too many.') return vertices = [] for index in range(0, len(point_list), 2): vertices.append( sims4.math.Vector3(point_list[index], 0.0, point_list[index + 1])) polygon = sims4.geometry.Polygon(vertices) geometry = RestrictedPolygon(polygon, []) constraints.append( Constraint(geometry=geometry, routing_surface=routing_surface)) constraint_set = create_constraint_set(constraints) if not postures.posture_graph.enable_debug_goals_visualization: sims4.commands.execute('debugvis.goals.enable', _connection) handles = constraint_set.get_connectivity_handles(obj) handles_str = 'Handles: {}'.format(len(handles)) sims4.commands.output(handles_str, _connection) all_goals = [] for handle in handles: goal_list = handle.get_goals() goals_str = '\tGoals: {}'.format(len(goal_list)) sims4.commands.output(goals_str, _connection) all_goals.extend(goal_list) if postures.posture_graph.enable_debug_goals_visualization: for constraint in constraints: with debugvis.Context( 'goal_scoring', routing_surface=constraint.routing_surface) as layer: for polygon in constraint.geometry.polygon: layer.add_polygon( polygon, routing_surface=constraint.routing_surface) for goal in all_goals: position = goal.location.transform.translation layer.add_point(position, routing_surface=constraint.routing_surface)
def _make_constraint(self, *args, **kwargs): all_constraints = [ self.get_constraint(sim) for sim in self._sim_transform_map ] if all_constraints: self._constraint = create_constraint_set(all_constraints) else: self._constraint = Anywhere() return self._constraint
def _make_constraint(self, *args, **kwargs): if self._constraint is None: constraints = [ interactions.constraints.Transform( t, routing_surface=self.routing_surface) for t in self._sim_transform_map.values() ] self._constraint = create_constraint_set( constraints) if constraints else Anywhere() return self._constraint
def create_put_down_in_inventory_constraint(inst, sim, target, targets_with_inventory, cost=0): if cost is None or not targets_with_inventory: return Nowhere() carry_constraint = create_carry_constraint(target, debug_name='CarryForPutDownInInventory') carry_constraint = carry_constraint.generate_constraint_with_cost(cost) object_constraints = [] for target_with_inventory in targets_with_inventory: constraint = target_with_inventory.get_inventory_access_constraint(sim, True, target) constraint = constraint.apply_posture_state(None, inst.get_constraint_resolver(None)) object_constraints.append(constraint) final_constraint = create_constraint_set(object_constraints) final_constraint = carry_constraint.intersect(final_constraint) return final_constraint
def create_constraint(self, actor, target, **kwargs): if target is None: return Nowhere( '{} is creating a RoutingSlotConstraint for a None Target.', actor) slot_constraints = [] asm_key = self.animation_element.asm_key actor_name = self.animation_element.actor_name target_name = self.animation_element.target_name state_name = self.animation_element.begin_states[0] asm = create_asm(asm_key, context=get_throwaway_animation_context()) asm.set_actor(actor_name, actor) asm.add_potentially_virtual_actor(actor_name, actor, target_name, target) asm.dirty_boundary_conditions() if actor.is_sim: age = actor.age.age_for_animation_cache else: age = None boundary_conditions = asm.get_boundary_conditions_list( actor, state_name) for (_, slots_to_params_entry) in boundary_conditions: if not slots_to_params_entry: continue slots_to_params_entry_absolute = [] for (boundary_condition_entry, param_sequences_entry) in slots_to_params_entry: (routing_transform_entry, containment_transform, _, reference_joint_exit ) = boundary_condition_entry.get_transforms(asm, target) slots_to_params_entry_absolute.append( (routing_transform_entry, reference_joint_exit, param_sequences_entry)) slot_constraint = RequiredSlotSingle( actor, target, asm, asm_key, None, actor_name, target_name, state_name, containment_transform, None, tuple(slots_to_params_entry_absolute), None, asm_name=asm.name, age=age) slot_constraints.append(slot_constraint) return create_constraint_set(slot_constraints)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) sim = self._context.sim self._routing_surface = routing.SurfaceIdentifier( self._routing_surface.primary_id, self._routing_surface.secondary_id, routing.SurfaceType.SURFACETYPE_POOL) position = self._target.position if self._target is not None else sim.position level = self._routing_surface.secondary_id self._start_constraint = None self._master_depth_constraint = None self._waypoint_constraints = [] self.keep_away_constraint = None self._location_is_pool = build_buy.is_location_pool(position, level) if self._location_is_pool: pool_block_id = build_buy.get_block_id(sim.zone_id, position, level - 1) pool = pool_utils.get_pool_by_block_id(pool_block_id) if pool is not None: pool_edge_constraints = pool.get_edge_constraint( constraint_width=self.constraint_width, inward_dir=True, return_constraint_list=True) pool_edge_constraints = [ constraint.generate_geometry_only_constraint() for constraint in pool_edge_constraints ] if self.keep_away_from_edges is not None: bb_polys = build_buy.get_pool_polys( pool_block_id, level - 1) if len(bb_polys) > 0: bb_poly = bb_polys[0] _WaypointGeneratorPool._push_poly_inward( bb_poly, self.keep_away_from_edges) bb_poly.reverse() keep_away_geom = sims4.geometry.RestrictedPolygon( sims4.geometry.Polygon(bb_poly), ()) self.keep_away_constraint = Constraint( routing_surface=pool.provided_routing_surface, geometry=keep_away_geom) else: logger.error( f'Pool Waypoint Generator: Pool polygon data unexpectedly empty while ${sim} was routing on a pool with id ${pool_block_id}.', owner='jmorrow') for i in range(len(pool_edge_constraints)): pool_edge_constraints[i] = pool_edge_constraints[ i].intersect(self.keep_away_constraint) self._start_constraint = create_constraint_set( pool_edge_constraints) self._waypoint_constraints = pool_edge_constraints
def redraw(self, sim, constraint): routing_surface = None if isinstance( constraint, _ConstraintSet) else constraint.routing_surface color = pseudo_random_color(sim.id) (r, g, b, a) = sims4.color.to_rgba(color) (gr, gg, gb, ga) = sims4.color.to_rgba(Color.GREY) semitransparent = sims4.color.from_rgba( (gr + r) / 2, (gg + g) / 2, (gb + b) / 2, (ga + a) / 2 * 0.4) transparent = sims4.color.from_rgba((gr + r) / 2, (gg + g) / 2, (gb + b) / 2, (ga + a) / 2 * 0.15) if isinstance(constraint, _ConstraintSet): for sub_constraint in constraint: if sub_constraint.routing_surface is not None: routing_surface = sub_constraint.routing_surface break else: routing_surface = constraint.routing_surface with Context(self.layer, routing_surface=routing_surface) as layer: direction_constraint = None direction_constraints = [] for sub_constraint in constraint: if sub_constraint._geometry is not None: if sub_constraint._geometry.polygon is None: if sub_constraint._geometry.restrictions is not None: direction_constraints.append(sub_constraint) if direction_constraints: direction_constraint = create_constraint_set( direction_constraints) for si in sim.si_state: participant_type = si.get_participant_type(sim) for si_constraint in si.constraint_intersection( participant_type=participant_type): if direction_constraint is not None: si_constraint = direction_constraint.intersect( si_constraint) si_color = transparent si_altitude = 0.01 if si.is_guaranteed(): si_color = semitransparent si_altitude = 0.02 _draw_constraint(layer, si_constraint, si_color, altitude_modifier=si_altitude) _draw_constraint(layer, constraint, color, altitude_modifier=0.03, anywhere_position=sim.position, draw_contours=True)
def get_constraint(self, sim): transforms = self._sim_transform_map.get(sim, None) if transforms is not None: all_transforms = [ interactions.constraints.Transform( transform, routing_surface=self.routing_surface, create_jig_fn=self._set_sim_intended_location) for (transform, _) in transforms ] return create_constraint_set(all_transforms) if sim in self._sim_transform_map: return Nowhere( "JigGroup, Sim is expected to have a transform but we didn't find a good spot for them. Sim: {}", sim) return Anywhere()
def create_put_down_in_slot_type_constraint(sim, target, slot_types_and_costs): constraints = [] for (slot_type, cost) in slot_types_and_costs: if cost is None: pass slot_manifest_entry = SlotManifestEntry(target, PostureSpecVariable.ANYTHING, slot_type) slot_manifest = SlotManifest((slot_manifest_entry,)) posture_state_spec_stand = PostureStateSpec(STAND_POSTURE_MANIFEST, slot_manifest, PostureSpecVariable.ANYTHING) posture_constraint_stand = Constraint(debug_name='PutDownInSlotTypeConstraint_Stand', posture_state_spec=posture_state_spec_stand, cost=cost) constraints.append(posture_constraint_stand) posture_state_spec_sit = PostureStateSpec(SIT_POSTURE_MANIFEST, slot_manifest, PostureSpecVariable.ANYTHING) posture_constraint_sit = Constraint(debug_name='PutDownInSlotTypeConstraint_Sit', posture_state_spec=posture_state_spec_sit, cost=cost) constraints.append(posture_constraint_sit) if not constraints: return Nowhere() final_constraint = create_constraint_set(constraints) return final_constraint
def get_lot_corners_constraint_set(self): lot_center = self.lot.center lot_corners = services.current_zone().lot.corners routing_surface = routing.SurfaceIdentifier( services.current_zone().id, 0, routing.SURFACETYPE_WORLD) constraint_list = [] for corner in lot_corners: diff = lot_center - corner if diff.magnitude_squared() != 0: towards_center_vec = sims4.math.vector_normalize(lot_center - corner) * 0.1 else: towards_center_vec = sims4.math.Vector3.ZERO() new_corner = corner + towards_center_vec constraint_list.append(interactions.constraints.Position( new_corner, routing_surface=routing_surface)) return create_constraint_set(constraint_list)
def create_constraint(self, *args, **kwargs): animation_constraints = [] if self._animation_ref: for animation_element_factory in self._animation_ref.animation_element_gen(): animation_element = animation_element_factory() asm_key = animation_element.asm_key actor_name = animation_element.actor_name target_name = animation_element.target_name carry_target_name = animation_element.carry_target_name create_target_name = animation_element.create_target_name initial_state = animation_element.initial_state begin_states = animation_element.begin_states from interactions.constraints import create_animation_constraint animation_constraint = create_animation_constraint(asm_key, actor_name, target_name, carry_target_name, create_target_name, initial_state, begin_states, animation_element.overrides) animation_constraints.append(animation_constraint) from interactions.constraints import create_constraint_set return create_constraint_set(animation_constraints)
def get_waypoint_constraints_gen(self, routing_agent, waypoint_count): zone = services.current_zone() constraint_set = zone.get_spawn_points_constraint(except_lot_id=self._except_lot_id, sim_spawner_tags=self.spawn_point_tags, generalize=True) routing_context = routing_agent.routing_component.pathplan_context source_handle = routing.connectivity.Handle(routing_agent.position, routing_agent.routing_surface) dest_handles = set() for constraint in constraint_set: handles = constraint.get_connectivity_handles(routing_agent) dest_handles.update(handles) connectivity = routing.test_connectivity_batch((source_handle,), dest_handles, routing_context=routing_context, compute_cost=True) vehicle_dest_handles = {dest for (_, dest, cost) in connectivity if sims4.math.almost_equal(cost, 0.0)} constraint_set = create_constraint_set([handle.constraint for handle in vehicle_dest_handles]) constraints_weighted = [] min_score = sims4.math.MAX_FLOAT for constraint in constraint_set: spawn_point_vector = constraint.average_position - self._sim.position score = sims4.math.vector_dot_2d(self._pick_vector, spawn_point_vector) min_score = score constraints_weighted.append((score, constraint)) constraints_weighted = [(score - min_score, constraint) for (score, constraint) in constraints_weighted] constraints_weighted = sorted(constraints_weighted, key=lambda i: i[0]) first_constraint = constraints_weighted[-1][1] del constraints_weighted[-1] first_constraint_circle = Circle(first_constraint.average_position, self.constraint_radius, routing_surface=first_constraint.routing_surface) jog_waypoint_constraints = [] jog_waypoint_constraints.append(first_constraint_circle) last_waypoint_position = first_constraint.average_position for _ in range(waypoint_count - 1): constraints_weighted_next = [] for (_, constraint) in constraints_weighted: average_position = constraint.average_position distance_last = (average_position - last_waypoint_position).magnitude_2d() distance_home = (average_position - self._origin_position).magnitude_2d() constraints_weighted_next.append((distance_last + distance_home, constraint)) break next_constraint = pop_weighted(constraints_weighted_next) next_constraint_circle = Circle(next_constraint.average_position, self.constraint_radius, routing_surface=next_constraint.routing_surface) jog_waypoint_constraints.append(next_constraint_circle) constraints_weighted = constraints_weighted_next break last_waypoint_position = next_constraint.average_position jog_waypoint_constraints = self.apply_water_constraint(jog_waypoint_constraints) yield from jog_waypoint_constraints yield self._start_constraint
def create_put_down_in_inventory_constraint(inst, sim, target, targets_with_inventory, cost=0): if cost is None or not targets_with_inventory: return Nowhere() carry_constraint = create_carry_constraint( target, debug_name='CarryForPutDownInInventory') carry_constraint = carry_constraint.generate_constraint_with_cost(cost) object_constraints = [] for target_with_inventory in targets_with_inventory: constraint = target_with_inventory.get_inventory_access_constraint( sim, True, target) constraint = constraint.apply_posture_state( None, inst.get_constraint_resolver(None)) object_constraints.append(constraint) final_constraint = create_constraint_set(object_constraints) final_constraint = carry_constraint.intersect(final_constraint) return final_constraint
def create_constraint(self, *args, **kwargs): animation_constraints = [] if self._animation_ref: for animation_element_factory in self._animation_ref.animation_element_gen( ): animation_element = animation_element_factory() asm_key = animation_element.asm_key actor_name = animation_element.actor_name target_name = animation_element.target_name carry_target_name = animation_element.carry_target_name create_target_name = animation_element.create_target_name initial_state = animation_element.initial_state begin_states = animation_element.begin_states end_states = animation_element.end_states from interactions.constraints import create_animation_constraint animation_constraint = create_animation_constraint( asm_key, actor_name, target_name, carry_target_name, create_target_name, initial_state, begin_states, end_states, animation_element.overrides) animation_constraints.append(animation_constraint) return create_constraint_set(animation_constraints)
def _constraint_gen(cls, inst, sim, target, participant_type=ParticipantType.Actor, **kwargs): inst_or_cls = cls if inst is None else inst yield from super(SuperInteraction, inst_or_cls)._constraint_gen( sim, target, participant_type=participant_type, **kwargs) if inst_or_cls.use_aggregated_affordance_constraints: aggregated_constraints = [] affordances = [] affordances = [ aop.super_affordance for (aop, _) in inst._valid_aops ] affordances = affordances if not inst is not None or not inst._valid_aops is not None or affordances else [ affordance_tuple.affordance for affordance_tuple in inst_or_cls.aggregated_affordances ] if not affordances: yield Nowhere for aggregated_affordance in affordances: intersection = ANYWHERE constraint_gen = aggregated_affordance.constraint_gen constraint_gen = super(SuperInteraction, aggregated_affordance)._constraint_gen for constraint in constraint_gen( sim, inst_or_cls.get_constraint_target(target), participant_type=participant_type, **kwargs): intersection = constraint.intersect(intersection) if not intersection.valid: continue aggregated_constraints.append(intersection) if aggregated_constraints: yield create_constraint_set( aggregated_constraints, debug_name='AggregatedConstraintSet')
def _create_floor_feature_constraint_set(cls, context): floor_feature_contraints = [] floor_features_and_distances = [] zone_id = sims4.zone_utils.get_zone_id() sim = context.sim sim_position = sim.position sim_routing_surface = sim.routing_surface floor_features = build_buy.list_floor_features(zone_id, cls.terrain_feature) for floor_feature in floor_features: if cls.indoors_only and build_buy.is_location_natural_ground( zone_id, floor_feature[0], floor_feature[1]): pass routing_surface = routing.SurfaceIdentifier( zone_id, floor_feature[1], routing.SURFACETYPE_WORLD) distance = estimate_distance_between_points( sim_position, sim_routing_surface, floor_feature[0], routing_surface) while distance is not None: floor_features_and_distances.append( [[floor_feature[0], routing_surface], distance]) if floor_features_and_distances: sorted(floor_features_and_distances, key=lambda feature: feature[1]) for floor_feature_and_distance in floor_features_and_distances: floor_feature = floor_feature_and_distance[0] circle_constraint = cls.routing_circle_constraint.create_constraint( sim, None, target_position=floor_feature[0], routing_surface=floor_feature[1]) facing_constraint = cls.routing_facing_constraint.create_constraint( sim, None, target_position=floor_feature[0], routing_surface=floor_feature[1]) constraint = circle_constraint.intersect(facing_constraint) floor_feature_contraints.append(constraint) return create_constraint_set(floor_feature_contraints)
def create_put_down_in_slot_type_constraint(sim, carry_target, slot_types_and_costs, target=None): constraints = [] for (slot_type, cost) in slot_types_and_costs: if cost is None: continue if target is not None and target is not carry_target: slot_manifest_entry = SlotManifestEntry( carry_target, PostureSpecVariable.INTERACTION_TARGET, slot_type) else: slot_manifest_entry = SlotManifestEntry( carry_target, PostureSpecVariable.ANYTHING, slot_type) slot_manifest = SlotManifest((slot_manifest_entry, )) posture_state_spec_stand = PostureStateSpec( STAND_POSTURE_MANIFEST, slot_manifest, PostureSpecVariable.ANYTHING) posture_constraint_stand = Constraint( debug_name='PutDownInSlotTypeConstraint_Stand', posture_state_spec=posture_state_spec_stand, cost=cost) constraints.append(posture_constraint_stand) posture_state_spec_sit = PostureStateSpec(SIT_POSTURE_MANIFEST, slot_manifest, PostureSpecVariable.ANYTHING) posture_constraint_sit = Constraint( debug_name='PutDownInSlotTypeConstraint_Sit', posture_state_spec=posture_state_spec_sit, cost=cost) constraints.append(posture_constraint_sit) if not constraints: return Nowhere( 'Carry Target has no slot types or costs tuned for put down: {} Sim:{}', carry_target, sim) final_constraint = create_constraint_set(constraints) return final_constraint
def combine_constraints( constraints: Iterator[Constraint], fallback_constraints: Iterator[Constraint] = (), debug_name: str = 'Combined' ) -> Union[_ConstraintSet, Constraint, Nowhere]: """combine_constraints(constraints, fallback_constraints=(), debug_name='Combined') Attempt to combine similar constraints into a constraint set. :param constraints: A collection of Constraints. :type constraints: Iterator[Constraint] :param fallback_constraints: A collection of Constraints to choose from as a fallback when the primary constraints fail to combine. Default is an empty collection. :type fallback_constraints: Iterator[Constraint], optional :param debug_name: The name of the constraint set being created. Default is 'Combined'. :type debug_name: str, optional :return: A constraint set containing the specified constraints, a Constraint chosen from one of the specified fallback constraints, or Nowhere when everything else fails. :rtype: Union[_ConstraintSet, Constraint, Nowhere] """ from interactions.constraints import create_constraint_set return create_constraint_set( tuple(constraints), invalid_constraints=tuple(fallback_constraints), debug_name=debug_name)
def _create_floor_feature_constraint_set(cls, context): floor_feature_contraints = [] floor_features_and_distances = [] zone_id = sims4.zone_utils.get_zone_id() sim = context.sim sim_position = sim.position sim_routing_surface = sim.routing_surface floor_features = build_buy.list_floor_features(zone_id, cls.terrain_feature) for floor_feature in floor_features: if cls.indoors_only and build_buy.is_location_natural_ground(zone_id, floor_feature[0], floor_feature[1]): pass routing_surface = routing.SurfaceIdentifier(zone_id, floor_feature[1], routing.SURFACETYPE_WORLD) distance = estimate_distance_between_points(sim_position, sim_routing_surface, floor_feature[0], routing_surface) while distance is not None: floor_features_and_distances.append([[floor_feature[0], routing_surface], distance]) if floor_features_and_distances: sorted(floor_features_and_distances, key=lambda feature: feature[1]) for floor_feature_and_distance in floor_features_and_distances: floor_feature = floor_feature_and_distance[0] circle_constraint = cls.routing_circle_constraint.create_constraint(sim, None, target_position=floor_feature[0], routing_surface=floor_feature[1]) facing_constraint = cls.routing_facing_constraint.create_constraint(sim, None, target_position=floor_feature[0], routing_surface=floor_feature[1]) constraint = circle_constraint.intersect(facing_constraint) floor_feature_contraints.append(constraint) return create_constraint_set(floor_feature_contraints)
def callback(cls, fields, source, *, factory, overrides, actor_participant_type=ParticipantType.Actor, target_participant_type=ParticipantType.TargetSim, **kwargs): if cls is None: return participant_constraint_lists = {} run_in_sequence = factory.run_in_sequence for animation_element_factory in factory.animation_element_gen(): animation_element = animation_element_factory() asm_key = animation_element.asm_key actor_name = animation_element.actor_name target_name = animation_element.target_name carry_target_name = animation_element.carry_target_name create_target_name = animation_element.create_target_name initial_state = animation_element.initial_state begin_states = animation_element.begin_states end_states = animation_element.end_states base_object_name = animation_element.base_object_name instance_overrides = overrides() total_overrides = animation_element.overrides( overrides=instance_overrides) cls.register_tuned_animation( interaction_asm_type, asm_key, actor_name, target_name, carry_target_name, create_target_name, total_overrides, actor_participant_type, target_participant_type) if animation_element_factory._child_animations: for child_args in animation_element_factory._child_animations: cls.register_tuned_animation(*child_args) if not interactions.interaction_instance_manager.BUILD_AC_CACHE and ( cls.resource_key not in sims4.resources.localwork_no_groupid and asm_key not in sims4.resources.localwork_no_groupid ) and caches.USE_ACC_AND_BCC & caches.AccBccUsage.ACC: return if animation_element_factory._child_constraints: for child_args in animation_element_factory._child_constraints: cls.add_auto_constraint(*child_args) from animation.animation_constants import InteractionAsmType if not interaction_asm_type == InteractionAsmType.Interaction: if not interaction_asm_type == InteractionAsmType.Canonical: if not interaction_asm_type == InteractionAsmType.Outcome: if interaction_asm_type == InteractionAsmType.Response: from interactions.constraints import create_animation_constraint def add_participant_constraint( participant_type, animation_constraint): if animation_constraint is not None: if interaction_asm_type == InteractionAsmType.Canonical: is_canonical = True else: is_canonical = False if run_in_sequence: cls.add_auto_constraint( participant_type, animation_constraint, is_canonical=is_canonical) else: if participant_type not in participant_constraint_lists: participant_constraint_lists[ participant_type] = [] participant_constraint_lists[ participant_type].append( animation_constraint) animation_constraint_actor = None try: animation_constraint_actor = create_animation_constraint( asm_key, actor_name, target_name, carry_target_name, create_target_name, initial_state, begin_states, end_states, total_overrides, base_object_name=base_object_name) except: if interaction_asm_type != InteractionAsmType.Outcome: logger.exception( 'Exception while processing tuning for {}', cls) add_participant_constraint( actor_participant_type, animation_constraint_actor) if target_name is not None: animation_context = get_throwaway_animation_context( ) asm = animation.asm.create_asm( asm_key, animation_context, posture_manifest_overrides= total_overrides.manifests) target_actor_definition = asm.get_actor_definition( target_name) if target_actor_definition.actor_type == ASM_ACTORTYPE_SIM: if not target_actor_definition.is_virtual: animation_constraint_target = create_animation_constraint( asm_key, target_name, actor_name, carry_target_name, create_target_name, initial_state, begin_states, end_states, total_overrides, base_object_name= base_object_name) add_participant_constraint( target_participant_type, animation_constraint_target) from interactions.constraints import create_animation_constraint def add_participant_constraint(participant_type, animation_constraint): if animation_constraint is not None: if interaction_asm_type == InteractionAsmType.Canonical: is_canonical = True else: is_canonical = False if run_in_sequence: cls.add_auto_constraint(participant_type, animation_constraint, is_canonical=is_canonical) else: if participant_type not in participant_constraint_lists: participant_constraint_lists[ participant_type] = [] participant_constraint_lists[ participant_type].append(animation_constraint) animation_constraint_actor = None try: animation_constraint_actor = create_animation_constraint( asm_key, actor_name, target_name, carry_target_name, create_target_name, initial_state, begin_states, end_states, total_overrides, base_object_name=base_object_name) except: if interaction_asm_type != InteractionAsmType.Outcome: logger.exception( 'Exception while processing tuning for {}', cls) add_participant_constraint(actor_participant_type, animation_constraint_actor) if target_name is not None: animation_context = get_throwaway_animation_context() asm = animation.asm.create_asm( asm_key, animation_context, posture_manifest_overrides=total_overrides.manifests) target_actor_definition = asm.get_actor_definition( target_name) if target_actor_definition.actor_type == ASM_ACTORTYPE_SIM: if not target_actor_definition.is_virtual: animation_constraint_target = create_animation_constraint( asm_key, target_name, actor_name, carry_target_name, create_target_name, initial_state, begin_states, end_states, total_overrides, base_object_name=base_object_name) add_participant_constraint( target_participant_type, animation_constraint_target) if not run_in_sequence: if participant_constraint_lists is not None: for (participant_type, constraints_list ) in participant_constraint_lists.items(): cls.add_auto_constraint( participant_type, create_constraint_set(constraints_list))
STAND_NO_CARRY_NO_SURFACE_STATE_SPEC = create_body_posture_state_spec(STAND_NO_CARRY_NO_SURFACE_POSTURE_MANIFEST) STAND_OR_MOVING_STAND_STATE_SPEC = create_body_posture_state_spec(STAND_OR_MOVING_STAND_POSTURE_MANIFEST) STAND_OR_MOVING_STAND_AT_NONE_STATE_SPEC = create_body_posture_state_spec(STAND_OR_MOVING_STAND_POSTURE_MANIFEST, body_target=None) STAND_CONSTRAINT = Constraint(debug_name='Stand', posture_state_spec=STAND_POSTURE_STATE_SPEC) STAND_NO_SURFACE_CONSTRAINT = Constraint(debug_name='Stand-NoSurface', posture_state_spec=STAND_NO_SURFACE_STATE_SPEC) STAND_NO_CARRY_NO_SURFACE_CONSTRAINT = Constraint(debug_name='Stand-NoCarryNoSurface', posture_state_spec=STAND_NO_CARRY_NO_SURFACE_STATE_SPEC) STAND_CONSTRAINT_OUTER_PENALTY = Constraint(debug_name='Stand', posture_state_spec=STAND_POSTURE_STATE_SPEC, ignore_outer_penalty_threshold=1.0) STAND_AT_NONE_CONSTRAINT = Constraint(debug_name='Stand@None', posture_state_spec=STAND_AT_NONE_POSTURE_STATE_SPEC) STAND_OR_MOVING_STAND_CONSTRAINT = Constraint(debug_name='Stand-Or-MovingStand', posture_state_spec=STAND_OR_MOVING_STAND_STATE_SPEC) STAND_OR_MOVING_STAND_AT_NONE_CONSTRAINT = Constraint(debug_name='Stand-Or-MovingStand@None', posture_state_spec=STAND_OR_MOVING_STAND_AT_NONE_STATE_SPEC) SIT_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'sit', 'FullBody', MATCH_ANY, MATCH_ANY, MATCH_ANY), PostureManifestEntry(None, '', 'sit', 'UpperBody', MATCH_ANY, MATCH_ANY, MATCH_ANY))).intern() SIT_NO_CARRY_ANY_SURFACE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'sit', 'FullBody', MATCH_NONE, MATCH_NONE, MATCH_ANY), PostureManifestEntry(None, '', 'sit', 'UpperBody', MATCH_NONE, MATCH_NONE, MATCH_ANY))).intern() SIT_POSTURE_STATE_SPEC = create_body_posture_state_spec(SIT_POSTURE_MANIFEST) SIT_NO_CARRY_ANY_SURFACE_STATE_SPEC = create_body_posture_state_spec(SIT_NO_CARRY_ANY_SURFACE_MANIFEST) SIT_CONSTRAINT = Constraint(debug_name='Sit', posture_state_spec=SIT_POSTURE_STATE_SPEC) SIT_NO_CARRY_ANY_SURFACE_CONSTRAINT = Constraint(debug_name='SitNoCarryAnySurface', posture_state_spec=SIT_NO_CARRY_ANY_SURFACE_STATE_SPEC) SWIM_POSTURE_TYPE = 'swim' SWIM_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, SWIM_POSTURE_TYPE, '', 'FullBody', None, None, MATCH_ANY), PostureManifestEntry(None, SWIM_POSTURE_TYPE, '', 'UpperBody', None, None, MATCH_ANY))).intern() SWIM_AT_NONE_POSTURE_STATE_SPEC = create_body_posture_state_spec(SWIM_POSTURE_MANIFEST, body_target=None) SWIM_AT_NONE_CONSTRAINT = Constraint(debug_name='swim@None', posture_state_spec=SWIM_AT_NONE_POSTURE_STATE_SPEC) class PostureConstants: SIT_POSTURE_TYPE = TunableReference(description='\n A reference to the sit posture type.\n ', manager=services.get_instance_manager(sims4.resources.Types.POSTURE)) SIT_INTIMATE_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, 'sitIntimate', '', 'FullBody', MATCH_NONE, MATCH_NONE, MATCH_ANY), PostureManifestEntry(None, 'sitIntimate', '', 'UpperBody', MATCH_NONE, MATCH_NONE, MATCH_ANY), PostureManifestEntry(None, 'sitIntimateBooth', '', 'FullBody', MATCH_NONE, MATCH_NONE, MATCH_ANY), PostureManifestEntry(None, 'sitIntimateBooth', '', 'UpperBody', MATCH_NONE, MATCH_NONE, MATCH_ANY))).intern() SIT_INTIMATE_POSTURE_STATE_SPEC = create_body_posture_state_spec(SIT_INTIMATE_POSTURE_MANIFEST) SIT_INTIMATE_CONSTRAINT = Constraint(debug_name='SitIntimate', posture_state_spec=SIT_INTIMATE_POSTURE_STATE_SPEC) STAND_OR_SIT_POSTURE_MANIFEST = PostureManifest(list(STAND_POSTURE_MANIFEST) + list(SIT_POSTURE_MANIFEST)).intern() STAND_OR_SIT_CONSTRAINT = create_constraint_set((STAND_CONSTRAINT, SIT_CONSTRAINT), debug_name='Stand-or-Sit') STAND_SIT_OR_SWIM_CONSTRAINT_OUTER_PENALTY = create_constraint_set((STAND_CONSTRAINT_OUTER_PENALTY, SIT_CONSTRAINT, SWIM_AT_NONE_CONSTRAINT), debug_name='Stand-Sit-Or-Swim-Outer-Penalty') ADJUSTMENT_CONSTRAINT = create_constraint_set((STAND_OR_MOVING_STAND_CONSTRAINT, SIT_CONSTRAINT), debug_name='Adjustment-Constraint')
def get_inventory_access_constraint(self, sim, is_put, carry_target, use_owner_as_target_for_resolver=False): constraint_list = [] for obj in self.owning_objects_gen(): constraint_list.append(obj.get_inventory_access_constraint(sim, is_put, carry_target, use_owner_as_target_for_resolver=use_owner_as_target_for_resolver)) return create_constraint_set(constraint_list, debug_name='Object Inventory Constraints')
from animation.posture_manifest import MATCH_ANY, MATCH_NONE, PostureManifestEntry, PostureManifest from interactions.constraints import Constraint, create_constraint_set from postures.posture_state_spec import create_body_posture_state_spec STAND_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'stand', 'FullBody', MATCH_ANY, MATCH_ANY, MATCH_ANY), PostureManifestEntry(None, '', 'stand', 'UpperBody', MATCH_ANY, MATCH_ANY, MATCH_ANY))).intern() STAND_NO_SURFACE_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'stand', 'FullBody', MATCH_ANY, MATCH_ANY, MATCH_NONE), PostureManifestEntry(None, '', 'stand', 'UpperBody', MATCH_ANY, MATCH_ANY, MATCH_NONE))).intern() STAND_NO_CARRY_NO_SURFACE_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'stand', 'FullBody', MATCH_NONE, MATCH_NONE, MATCH_NONE), PostureManifestEntry(None, '', 'stand', 'UpperBody', MATCH_NONE, MATCH_NONE, MATCH_NONE))).intern() STAND_POSTURE_STATE_SPEC = create_body_posture_state_spec(STAND_POSTURE_MANIFEST) STAND_NO_SURFACE_STATE_SPEC = create_body_posture_state_spec(STAND_NO_SURFACE_POSTURE_MANIFEST) STAND_NO_CARRY_NO_SURFACE_STATE_SPEC = create_body_posture_state_spec(STAND_NO_CARRY_NO_SURFACE_POSTURE_MANIFEST) STAND_CONSTRAINT = Constraint(debug_name = 'Stand', posture_state_spec = STAND_POSTURE_STATE_SPEC) STAND_NO_SURFACE_CONSTRAINT = Constraint(debug_name = 'Stand-NoSurface', posture_state_spec = STAND_NO_SURFACE_STATE_SPEC) STAND_NO_CARRY_NO_SURFACE_CONSTRAINT = Constraint(debug_name = 'Stand-NoCarryNoSurface', posture_state_spec = STAND_NO_CARRY_NO_SURFACE_STATE_SPEC) STAND_CONSTRAINT_OUTER_PENALTY = Constraint(debug_name = 'Stand', posture_state_spec = STAND_POSTURE_STATE_SPEC, ignore_outer_penalty_threshold = 1.0) STAND_AT_NONE_POSTURE_STATE_SPEC = create_body_posture_state_spec(STAND_POSTURE_MANIFEST, body_target = None) STAND_AT_NONE_CONSTRAINT = Constraint(debug_name = 'Stand@None', posture_state_spec = STAND_AT_NONE_POSTURE_STATE_SPEC) SIT_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'sit', 'FullBody', MATCH_ANY, MATCH_ANY, MATCH_ANY), PostureManifestEntry(None, '', 'sit', 'UpperBody', MATCH_ANY, MATCH_ANY, MATCH_ANY))).intern() SIT_NO_CARRY_NO_SURFACE_MANIFEST = PostureManifest((PostureManifestEntry(None, '', 'sit', 'FullBody', MATCH_NONE, MATCH_NONE, MATCH_NONE), PostureManifestEntry(None, '', 'sit', 'UpperBody', MATCH_NONE, MATCH_NONE, MATCH_NONE))).intern() SIT_POSTURE_STATE_SPEC = create_body_posture_state_spec(SIT_POSTURE_MANIFEST) SIT_NO_CARRY_NO_SURFACE_STATE_SPEC = create_body_posture_state_spec(SIT_NO_CARRY_NO_SURFACE_MANIFEST) SIT_CONSTRAINT = Constraint(debug_name = 'Sit', posture_state_spec = SIT_POSTURE_STATE_SPEC) SIT_NO_CARRY_NO_SURFACE_CONSTRAINT = Constraint(debug_name = 'SitNoCarryNoSurface', posture_state_spec = SIT_NO_CARRY_NO_SURFACE_STATE_SPEC) SIT_INTIMATE_POSTURE_MANIFEST = PostureManifest((PostureManifestEntry(None, 'sitIntimate', '', 'FullBody', MATCH_NONE, MATCH_NONE, MATCH_NONE), PostureManifestEntry(None, 'sitIntimate', '', 'UpperBody', MATCH_NONE, MATCH_NONE, MATCH_NONE))).intern() SIT_INTIMATE_POSTURE_STATE_SPEC = create_body_posture_state_spec(SIT_INTIMATE_POSTURE_MANIFEST) SIT_INTIMATE_CONSTRAINT = Constraint(debug_name = 'SitIntimate', posture_state_spec = SIT_INTIMATE_POSTURE_STATE_SPEC) STAND_OR_SIT_POSTURE_MANIFEST = PostureManifest(list(STAND_POSTURE_MANIFEST) + list(SIT_POSTURE_MANIFEST)).intern() STAND_OR_SIT_CONSTRAINT = create_constraint_set((STAND_CONSTRAINT, SIT_CONSTRAINT), debug_name = 'Stand-or-Sit') STAND_OR_SIT_CONSTRAINT_OUTER_PENALTY = create_constraint_set((STAND_CONSTRAINT_OUTER_PENALTY, SIT_CONSTRAINT), debug_name = 'Stand-or-Sit-Outer-Penalty')
def create_constraint(self, sim, target=None, **kwargs): constraint_list = map( lambda c: c.create_constraint(sim, target=target, **kwargs), self.constraints) return create_constraint_set(constraint_list)