def _update_broadcaster_service_visualizer(self, broadcaster_service,
layer):
for broadcaster in broadcaster_service.get_broadcasters_debug_gen():
constraint = broadcaster.get_constraint()
if constraint is not None:
color = pseudo_random_color(broadcaster.guid)
_draw_constraint(layer, constraint, color)
broadcasting_object = broadcaster.broadcasting_object
if broadcasting_object is not None:
broadcaster_center = broadcasting_object.position
layer.add_circle(broadcaster_center, radius=0.3, color=color)
for linked_broadcaster in broadcaster.get_linked_broadcasters_gen(
):
linked_broadcasting_object = linked_broadcaster.broadcasting_object
if linked_broadcasting_object is not None:
layer.add_point(linked_broadcasting_object.position,
size=0.25,
color=color)
layer.add_segment(broadcaster_center,
linked_broadcasting_object.position,
color=color)
for broadcaster in broadcaster_service.get_pending_broadcasters_gen():
color = pseudo_random_color(broadcaster.guid)
(r, g, b, a) = sims4.color.to_rgba(color)
color = sims4.color.from_rgba(r, g, b, a * 0.5)
broadcasting_object = broadcaster.broadcasting_object
if broadcasting_object is not None:
layer.add_circle(broadcasting_object.position, color=color)
def redraw(self, sim):
routing_context = sim.get_routing_context()
routing_polygon = routing_context.get_quadtree_polygon()
def _draw_polygon(position, *, color):
if isinstance(routing_polygon, QtCircle):
layer.add_circle(position, routing_polygon.radius, color=color)
else:
layer.add_polygon(list(routing_polygon), color=color)
with Context(self.layer,
altitude=0.1,
routing_surface=sim.routing_surface) as layer:
position_color = pseudo_random_color(sim.id)
position = sim.position
orientation = sim.orientation
_draw_polygon(position, color=position_color)
if orientation != sims4.math.Quaternion.ZERO():
angle = sims4.math.yaw_quaternion_to_angle(orientation)
layer.add_arrow(position, angle, color=position_color)
if sim.parent is not None:
return
intended_transform = sim.intended_transform
intended_position = intended_transform.translation
intended_position_color = pseudo_random_color(sim.id + 1)
_draw_polygon(intended_position, color=intended_position_color)
intended_orientation = intended_transform.orientation
if intended_orientation != sims4.math.Quaternion.ZERO():
angle = sims4.math.yaw_quaternion_to_angle(
intended_orientation)
layer.add_arrow(intended_position,
angle,
color=intended_position_color)
def _on_update(self):
broadcaster_service = services.current_zone().broadcaster_service
with Context(self.layer) as layer:
for broadcaster in broadcaster_service.get_broadcasters_gen(
inspect_only=True):
constraint = broadcaster.get_constraint()
if constraint is not None:
color = pseudo_random_color(broadcaster.guid)
_draw_constraint(layer, constraint, color)
broadcasting_object = broadcaster.broadcasting_object
if broadcasting_object is not None:
broadcaster_center = broadcasting_object.position
layer.add_circle(broadcaster_center,
radius=0.3,
color=color)
for linked_broadcaster in broadcaster.get_linked_broadcasters_gen(
):
linked_broadcasting_object = linked_broadcaster.broadcasting_object
while linked_broadcasting_object is not None:
layer.add_point(linked_broadcasting_object.position,
size=0.25,
color=color)
layer.add_segment(broadcaster_center,
linked_broadcasting_object.position,
color=color)
for broadcaster in broadcaster_service.get_pending_broadcasters_gen(
):
color = pseudo_random_color(broadcaster.guid)
(r, g, b, a) = sims4.color.to_rgba(color)
color = sims4.color.from_rgba(r, g, b, a * 0.5)
broadcasting_object = broadcaster.broadcasting_object
while broadcasting_object is not None:
layer.add_circle(broadcasting_object.position, color=color)
def __init__(self, sim, layer):
self._sim_ref = sim.ref()
self.layer = layer
self._color = pseudo_random_color(sim.id)
color2 = pseudo_random_color(-sim.id)
(r, g, b, a) = sims4.color.to_rgba(color2)
(gr, gg, gb, ga) = sims4.color.to_rgba(Color.GREY)
self._color_semitrans = sims4.color.from_rgba((gr + r)/2, (gg + g)/2, (gb + b)/2, (ga + a)/2*0.4)
self._start()
def __init__(self, sim, layer):
self._sim_ref = sim.ref()
self.layer = layer
self._color = pseudo_random_color(sim.id)
color2 = pseudo_random_color(-sim.id)
(r, g, b, a) = sims4.color.to_rgba(color2)
(gr, gg, gb, ga) = sims4.color.to_rgba(Color.GREY)
self._color_semitrans = sims4.color.from_rgba(
(gr + r) / 2, (gg + g) / 2, (gb + b) / 2, (ga + a) / 2 * 0.4)
self._start()
def _on_transition_destinations_changed(self,
sim,
transition_destinations,
transition_sources,
max_cost,
preserve=False):
POSSIBLE_SOURCE = from_rgba(50, 50, 50, 0.5)
with Context(self.layer, preserve=preserve) as layer:
for (path_id, constraint, weight) in transition_destinations:
alpha = 1.0
if max_cost > 0:
alpha = alpha - weight / max_cost
if alpha < 0.01:
alpha = 0.01
color = pseudo_random_color(path_id, a=alpha)
if constraint.was_selected:
_draw_constraint(layer,
constraint,
color,
altitude_modifier=0.5)
else:
_draw_constraint(layer, constraint, color)
for constraint in transition_sources:
if constraint.was_selected:
_draw_constraint(layer,
constraint,
POSSIBLE_SOURCE,
altitude_modifier=0.5)
else:
_draw_constraint(layer, constraint, POSSIBLE_SOURCE)
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 debugvis_test(name, _connection=None):
client = services.client_manager().get(_connection)
sim = client.active_sim
time = services.time_service().sim_now
hour = time.hour() % 12*sims4.math.TWO_PI/12
minute = time.minute()*sims4.math.TWO_PI/60
a = sim.position + sims4.math.Vector3(0, 1, 0)
b = a + sims4.math.Vector3(math.cos(hour), 0, math.sin(hour))*3
c = a + sims4.math.Vector3(math.cos(minute), 0, math.sin(minute))*4
with Context(name, routing_surface=sim.routing_surface) as layer:
layer.set_color(Color.YELLOW)
layer.add_segment(a, b, color=Color.CYAN)
layer.add_segment(a, c, color=Color.RED)
layer.add_point(a, size=0.2)
layer.add_point(b, size=0.1, color=Color.BLUE)
layer.add_point(c, size=0.1, color=Color.MAGENTA)
layer.add_circle(a, 5, color=Color.GREEN)
for i in range(12):
theta = i*sims4.math.TWO_PI/12
x = sims4.math.Vector3(4.75*math.cos(theta), 0, 4.75*math.sin(theta))
color = sims4.color.interpolate(Color.YELLOW, Color.BLUE, i/11)
layer.add_arrow(a + x, 0.5*sims4.math.PI - theta, end_arrow=False, color=color)
layer.add_text_world(a + x, str(i), color_foreground=pseudo_random_color(i))
layer.add_text_screen(sims4.math.Vector2(4, 32), 'Displaying debug visualization tests.')
for i in range(200):
layer.add_text_object(sim, sims4.math.Vector3.ZERO(), str(i), bone_index=i)
return 1
def draw_transform(transform_str, _connection=None):
transform_str = transform_str.replace(VECTOR3_STR, '')
float_list = extract_floats(transform_str)
color = pseudo_random_color(id(float_list))
num_floats = len(float_list)
if num_floats == 7:
transform_quaternion = sims4.math.Quaternion(float_list[3],
float_list[4],
float_list[5],
float_list[6])
angle = sims4.math.yaw_quaternion_to_angle(transform_quaternion)
debugvis_draw_arrow(float_list[0],
float_list[1],
float_list[2],
angle=angle,
snap_to_terrain=True,
color=color,
_connection=_connection)
debugvis_draw_point(float_list[0],
float_list[1],
float_list[2],
snap_to_terrain=True,
color=color,
_connection=_connection)
else:
logger.warn(
"Transform string doesn't have vector3 and orientation: {}",
transform_str)
def redraw(self, sim):
with Context(self.layer, altitude=0.1) as layer:
for group in sim.get_groups_for_sim_gen():
if group is not None:
if self.sim in group:
if group.geometry:
for sim in group:
layer.routing_surface = sim.routing_surface
geometry = group.geometry.get(sim, None)
if geometry is not None:
color = pseudo_random_color(sim.id)
layer.add_polygon(geometry.field,
color=color)
layer.add_point(geometry.focus,
color=color)
layer.add_arrow_for_transform(
sim.transform,
color=color,
altitude=0.05)
layer.routing_surface = group.routing_surface
color = pseudo_random_color(id(group))
layer.add_polygon(group.geometry.field,
color=color,
altitude=0.125)
layer.add_point(group.geometry.focus,
color=color,
size=0.2)
if group.radius is not None:
layer.add_circle(group.geometry.focus,
group.radius,
color=color)
if group._focus is not None:
layer.add_point(group._focus.position,
color=sims4.color.Color.CYAN)
if isinstance(
group,
JigGroup) and group.jig_polygon is not None:
color = pseudo_random_color(id(group))
layer.add_polygon(group.jig_polygon,
color=color,
altitude=0.125)
for (index, sim) in enumerate(group):
for i in range(index):
layer.add_point(sim.position,
altitude=2 + i * 0.15,
size=0.025,
color=Color.RED)
def draw_vector3(vector3_str, _connection):
point_list = extract_floats(vector3_str)
color = pseudo_random_color(id(point_list))
num_floats = len(point_list)
if num_floats == 3:
debugvis_draw_point(point_list[0], point_list[1], point_list[2], True, color, _connection)
else:
logger.warn("Vector3 string doesn't have 3 points: {}", vector3_str)
def redraw(self, sim):
with Context(self.layer, altitude=0.1, routing_surface=sim.routing_surface) as layer:
position_color = pseudo_random_color(sim.id)
position = sim.position
orientation = sim.orientation
layer.add_circle(position, routing.get_default_agent_radius(), color=position_color)
if orientation != sims4.math.Quaternion.ZERO():
angle = sims4.math.yaw_quaternion_to_angle(orientation)
layer.add_arrow(position, angle, color=position_color)
while sim.intended_location is not None:
intended_position_color = pseudo_random_color(sim.id + 1)
intended_position = sim.intended_location.position
intended_orientation = sim.intended_location.orientation
layer.add_circle(intended_position, routing.get_default_agent_radius(), color=intended_position_color)
while intended_orientation != sims4.math.Quaternion.ZERO():
angle = sims4.math.yaw_quaternion_to_angle(intended_orientation)
layer.add_arrow(intended_position, angle, color=intended_position_color)
def draw_vector3(vector3_str, _connection):
point_list = extract_floats(vector3_str)
color = pseudo_random_color(id(point_list))
num_floats = len(point_list)
if num_floats == 3:
debugvis_draw_point(point_list[0], point_list[1], point_list[2], True,
color, _connection)
else:
logger.warn("Vector3 string doesn't have 3 points: {}", vector3_str)
def draw_polygon(polygon_str, _connection):
point_list = extract_floats(polygon_str)
color = pseudo_random_color(id(point_list))
num_floats = len(point_list)
if num_floats == 2:
debugvis_draw_point(point_list[0], 0.0, point_list[1], True, color, _connection)
elif num_floats % 2 == 0:
point_list.append(point_list[0])
point_list.append(point_list[1])
for index in range(0, num_floats, 2):
debugvis_draw_line(point_list[index], 0.0, point_list[index + 1], point_list[index + 2], 0.0, point_list[index + 3], True, color, _connection)
def _on_transition_destinations_changed(self, sim, transition_destinations, possible_sources, max_weight, preserve=False):
POSSIBLE_SOURCE = from_rgba(50, 50, 50, 0.5)
with Context(self.layer, preserve=preserve) as layer:
for (path_id, constraint, weight) in transition_destinations:
alpha = 1.0
if max_weight > 0:
alpha = weight/max_weight
color = pseudo_random_color(path_id, a=alpha)
_draw_constraint(layer, constraint, color)
for constraint in possible_sources:
_draw_constraint(layer, constraint, POSSIBLE_SOURCE, altitude_modifier=0.5)
def _on_update(self):
with Context(self.layer) as layer:
for ensemble in services.ensemble_service().get_all_ensembles():
color = pseudo_random_color(ensemble.guid)
if ensemble.last_center_of_mass is None:
continue
layer.add_circle(ensemble.last_center_of_mass,
radius=math.sqrt(
ensemble.max_ensemble_radius),
color=color)
for sim in ensemble:
layer.add_circle(sim.position, radius=0.3, color=color)
def draw_polygon(point_list, _connection):
color = pseudo_random_color(id(point_list))
num_floats = len(point_list)
if num_floats == 2:
debugvis_draw_point(point_list[0], 0.0, point_list[1], True, color,
_connection)
elif num_floats % 2 == 0:
point_list.append(point_list[0])
point_list.append(point_list[1])
for index in range(0, num_floats, 2):
debugvis_draw_line(point_list[index], 0.0, point_list[index + 1],
point_list[index + 2], 0.0,
point_list[index + 3], True, color, _connection)
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 _on_update(self):
broadcaster_service = services.current_zone().broadcaster_service
with Context(self.layer) as layer:
for broadcaster in broadcaster_service.get_broadcasters_gen(inspect_only=True):
constraint = broadcaster.get_constraint()
if constraint is not None:
color = pseudo_random_color(broadcaster.guid)
_draw_constraint(layer, constraint, color)
broadcasting_object = broadcaster.broadcasting_object
if broadcasting_object is not None:
broadcaster_center = broadcasting_object.position
layer.add_circle(broadcaster_center, radius=0.3, color=color)
for linked_broadcaster in broadcaster.get_linked_broadcasters_gen():
linked_broadcasting_object = linked_broadcaster.broadcasting_object
while linked_broadcasting_object is not None:
layer.add_point(linked_broadcasting_object.position, size=0.25, color=color)
layer.add_segment(broadcaster_center, linked_broadcasting_object.position, color=color)
for broadcaster in broadcaster_service.get_pending_broadcasters_gen():
color = pseudo_random_color(broadcaster.guid)
(r, g, b, a) = sims4.color.to_rgba(color)
color = sims4.color.from_rgba(r, g, b, a*0.5)
broadcasting_object = broadcaster.broadcasting_object
while broadcasting_object is not None:
layer.add_circle(broadcasting_object.position, color=color)
def _on_transition_destinations_changed(self,
sim,
transition_destinations,
possible_sources,
max_weight,
preserve=False):
POSSIBLE_SOURCE = from_rgba(50, 50, 50, 0.5)
with Context(self.layer, preserve=preserve) as layer:
for (path_id, constraint, weight) in transition_destinations:
alpha = 1.0
if max_weight > 0:
alpha = weight / max_weight
color = pseudo_random_color(path_id, a=alpha)
_draw_constraint(layer, constraint, color)
for constraint in possible_sources:
_draw_constraint(layer,
constraint,
POSSIBLE_SOURCE,
altitude_modifier=0.5)
def _update_routing_formation_visualizer(self, routing_formation,
transform, layer):
layer.add_circle(transform.translation,
radius=0.3,
color=sims4.color.Color.GREEN)
layer.add_circle(routing_formation.slave.position,
radius=0.3,
color=sims4.color.Color.RED)
constraint = routing_formation.get_routing_slave_constraint()
if constraint is not None or constraint is not ANYWHERE:
color = pseudo_random_color(routing_formation.guid)
_draw_constraint(layer, constraint, color)
offset = sims4.math.Vector3.ZERO()
previous_offset = sims4.math.Vector3.ZERO()
for attachment_info in routing_formation.attachment_info_gen():
color = sims4.color.Color.CYAN if attachment_info.node_type is RoutingFormationFollowType.NODE_TYPE_FOLLOW_LEADER else sims4.color.Color.MAGENTA
offset.x = offset.x + attachment_info.parent_offset.x
offset.z = offset.z + attachment_info.parent_offset.y
layer.add_segment(
transform.transform_point(previous_offset),
transform.transform_point(offset),
color=color,
routing_surface=routing_formation.slave.routing_surface)
previous_offset = sims4.math.Vector3.ZERO() + offset
offset.x = offset.x - attachment_info.offset.x
offset.z = offset.z - attachment_info.offset.y
transformed_point = transform.transform_point(offset)
layer.add_segment(
transform.transform_point(previous_offset),
transformed_point,
color=color,
routing_surface=routing_formation.slave.routing_surface)
previous_offset = sims4.math.Vector3.ZERO() + offset
layer.add_circle(
transformed_point,
radius=attachment_info.radius,
color=color,
routing_surface=routing_formation.slave.routing_surface)
def _draw_spawner_constraints(self):
with Context(self.layer) as layer:
for obj in services.object_manager(
).get_all_objects_with_component_gen(SPAWNER_COMPONENT):
position = obj.position
spawner_component = obj.get_component(SPAWNER_COMPONENT)
radii = []
slot_positions = []
for data in spawner_component._spawner_data:
if data.spawner_option.spawn_type == SpawnerTuning.GROUND_SPAWNER and data.spawner_option.radius not in radii:
radii.append(data.spawner_option.radius)
if data.spawner_option.spawn_type == SpawnerTuning.SLOT_SPAWNER:
slot_types = {data.spawner_option.slot_type}
for slot in obj.get_runtime_slots_gen(
slot_types=slot_types):
slot_positions.append(slot.position)
spawner_color = pseudo_random_color(obj.id)
for radius in radii:
layer.add_circle(position, radius, color=spawner_color)
for slot in slot_positions:
layer.add_point(slot,
color=spawner_color,
altitude=KEEP_ALTITUDE)
def debugvis_test(name, _connection=None):
client = services.client_manager().get(_connection)
sim = client.active_sim
time = services.time_service().sim_now
hour = time.hour() % 12 * sims4.math.TWO_PI / 12
minute = time.minute() * sims4.math.TWO_PI / 60
a = sim.position + sims4.math.Vector3(0, 1, 0)
b = a + sims4.math.Vector3(math.cos(hour), 0, math.sin(hour)) * 3
c = a + sims4.math.Vector3(math.cos(minute), 0, math.sin(minute)) * 4
with Context(name, routing_surface=sim.routing_surface) as layer:
layer.set_color(Color.YELLOW)
layer.add_segment(a, b, color=Color.CYAN)
layer.add_segment(a, c, color=Color.RED)
layer.add_point(a, size=0.2)
layer.add_point(b, size=0.1, color=Color.BLUE)
layer.add_point(c, size=0.1, color=Color.MAGENTA)
layer.add_circle(a, 5, color=Color.GREEN)
for i in range(12):
theta = i * sims4.math.TWO_PI / 12
x = sims4.math.Vector3(4.75 * math.cos(theta), 0,
4.75 * math.sin(theta))
color = sims4.color.interpolate(Color.YELLOW, Color.BLUE, i / 11)
layer.add_arrow(a + x,
0.5 * sims4.math.PI - theta,
end_arrow=False,
color=color)
layer.add_text_world(a + x,
str(i),
color_foreground=pseudo_random_color(i))
layer.add_text_screen(sims4.math.Vector2(4, 32),
'Displaying debug visualization tests.')
for i in range(200):
layer.add_text_object(sim,
sims4.math.Vector3.ZERO(),
str(i),
bone_index=i)
return 1
def draw_jig(layer, sim_a_transform, sim_b_transform, polygon):
color = pseudo_random_color(id(polygon))
layer.add_point(sim_a_transform.translation, color=color)
layer.add_arrow_for_transform(sim_a_transform, color=color)
layer.add_arrow_for_transform(sim_b_transform, color=color)
layer.add_polygon(polygon, color=color)
def _on_transition_constraints_changed(self, constraint_history):
with Context(self.layer) as layer:
for constraint in constraint_history:
color = pseudo_random_color(id(constraint))
_draw_constraint(layer, constraint, color)
def _on_transition_constraints_changed(self, constraint_history):
with Context(self.layer) as layer:
for constraint in constraint_history:
color = pseudo_random_color(id(constraint))
_draw_constraint(layer, constraint, color)
