def get_possible_zone_ids_for_situation(cls, host_sim_info=None, guest_ids=None):
possible_zones = []
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
venue_service = services.current_zone().venue_service
for venue_tuning in cls.compatible_venues:
if venue_tuning.is_residential:
if host_sim_info is not None:
home_zone_id = host_sim_info.household.home_zone_id
home_venue_tuning = venue_manager.get(build_buy.get_current_venue(home_zone_id))
if home_venue_tuning.is_residential:
possible_zones.append(home_zone_id)
if guest_ids is not None:
for guest_id in guest_ids:
guest_id = int(guest_id)
guest_info = services.sim_info_manager().get(guest_id)
if guest_info is not None:
guest_zone_id = guest_info.household.home_zone_id
if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones:
guest_venue_tuning = venue_manager.get(build_buy.get_current_venue(guest_zone_id))
if guest_venue_tuning.is_residential:
possible_zones.append(guest_zone_id)
travel_group = guest_info.travel_group
if travel_group is not None:
travel_group_zone_id = travel_group.zone_id
if travel_group_zone_id is not None and travel_group_zone_id and travel_group_zone_id not in possible_zones:
possible_zones.append(travel_group_zone_id)
else:
possible_zones.extend(venue_service.get_zones_for_venue_type_gen(venue_tuning))
else:
possible_zones.extend(venue_service.get_zones_for_venue_type_gen(venue_tuning))
return possible_zones
def load(self, zone_data=None):
persistence_service = services.get_persistence_service()
def _get_current_venue(zone_id):
neighborhood_data = persistence_service.get_neighborhood_proto_buf_from_zone_id(
zone_id)
for lot_data in neighborhood_data.lots:
if zone_id == lot_data.zone_instance_id:
return lot_data.venue_key
current_zone_id = services.current_zone_id()
zones = services.get_persistence_service().get_save_game_data_proto(
).zones
for zone_data_msg in zones:
if zone_data_msg is None:
continue
if zone_data_msg.zone_id == current_zone_id:
active_venue_tuning_id = get_current_venue(
zone_data_msg.zone_id)
raw_active_venue_tuning_id = get_current_venue(
zone_data_msg.zone_id, allow_ineligible=True)
else:
active_venue_tuning_id = _get_current_venue(
zone_data_msg.zone_id)
raw_active_venue_tuning_id = active_venue_tuning_id
if active_venue_tuning_id is None:
self.set_provider(zone_data_msg.zone_id, None)
else:
active_venue_type = services.venue_manager().get(
active_venue_tuning_id)
raw_active_venue_type = services.venue_manager().get(
raw_active_venue_tuning_id)
source_venue_type = VenueService.get_variable_venue_source_venue(
raw_active_venue_type)
if source_venue_type is None:
self.set_provider(zone_data_msg.zone_id, None)
elif source_venue_type.variable_venues is None:
self.set_provider(zone_data_msg.zone_id, None)
else:
existing_provider = self.get_provider(
zone_data_msg.zone_id)
if existing_provider is not None and existing_provider.source_venue_type is source_venue_type:
continue
provider = source_venue_type.variable_venues.civic_policy(
source_venue_type, active_venue_type)
if not provider:
self.set_provider(zone_data_msg.zone_id, None)
else:
self.set_provider(zone_data_msg.zone_id, provider)
if zone_data_msg.HasField('gameplay_zone_data'):
if zone_data_msg.gameplay_zone_data.HasField(
'venue_data'):
if zone_data_msg.gameplay_zone_data.venue_data.HasField(
'civic_provider_data'):
provider.load(
zone_data_msg.gameplay_zone_data.
venue_data.civic_provider_data)
def is_zone_valid_for_gathering(self, zone_id):
persistence_service = services.get_persistence_service()
household_manager = services.household_manager()
try:
venue_tuning_id = build_buy.get_current_venue(zone_id)
except RuntimeError:
return False
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is None:
return False
if not venue_tuning.allowed_for_clubs:
return False
if venue_tuning.is_residential or venue_tuning.is_university_housing:
zone_data = persistence_service.get_zone_proto_buff(zone_id)
if zone_data is None:
return False
lot_data = persistence_service.get_lot_data_from_zone_data(
zone_data)
if lot_data is None:
return False
household = household_manager.get(
lot_data.lot_owner[0].household_id
) if lot_data.lot_owner else None
if household is None:
return False
elif not any(club_member in self.members
for club_member in household):
return False
return True
def is_zone_valid_for_venue_type(self,
zone_id,
venue_types,
compatible_region=None,
ignore_region_compatability_tags=False,
region_blacklist=[]):
if not zone_id:
return False
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_type = venue_manager.get(build_buy.get_current_venue(zone_id))
if venue_type not in venue_types:
return False
if compatible_region is not None:
venue_region = get_region_instance_from_zone_id(zone_id)
if venue_region is None or not compatible_region.is_region_compatible(
venue_region,
ignore_tags=ignore_region_compatability_tags):
return False
elif region_blacklist:
venue_region_description_id = get_region_description_id_from_zone_id(
zone_id)
if venue_region_description_id in region_blacklist:
return False
elif region_blacklist:
venue_region_description_id = get_region_description_id_from_zone_id(
zone_id)
if venue_region_description_id in region_blacklist:
return False
return True
def _run(self):
zone_id = self._get_zone_id()
with telemetry_helper.begin_hook(telemetry_writer, TELEMETRY_HOOK_SITUATION_INVITED, sim_info=self._receiver_sim_info) as hook:
hook.write_guid(TELEMETRY_SITUATION_TYPE_ID, self._situation_to_run.guid64)
hook.write_int(TELEMETRY_CHOSEN_ZONE, zone_id)
additional_tokens = []
if zone_id == 0:
logger.error('Drama Node {} trying to be run with zone id of 0. This is probably an issue with getting the zone id from the street.', self)
zone_id = services.current_zone_id()
venue_tuning_id = build_buy.get_current_venue(zone_id)
if venue_tuning_id is not None:
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is not None:
additional_tokens.append(venue_tuning.display_name)
persistence_service = services.get_persistence_service()
zone_data = persistence_service.get_zone_proto_buff(zone_id)
if zone_data is not None:
additional_tokens.append(zone_data.name)
self._choose_dialog()
dialog = self._chosen_dialog(self._receiver_sim_info, target_sim_id=self._sender_sim_info.id, resolver=self._get_resolver())
if self._chosen_dialog is None:
return DramaNodeRunOutcome.FAILURE
dialog_zone_id = zone_id if self._show_venue_dialog else None
dialog.show_dialog(on_response=self._handle_dialog, zone_id=dialog_zone_id, additional_tokens=additional_tokens)
return DramaNodeRunOutcome.SUCCESS_NODE_INCOMPLETE
def generate_lot_info_data(*args, zone_id: int = None, **kwargs):
lot_infos = []
current_zone = services.current_zone()
lot = current_zone.lot
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service(
).get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
if zone_id is not None:
venue_tuning_id = build_buy.get_current_venue(zone_id)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is not None:
is_current_lot = lot_owner_info.zone_instance_id == lot.zone_id
cur_info = {
'neighborhood': neighborhood_proto.name,
'region_id': neighborhood_proto.region_id,
'lot_desc_id': lot_owner_info.lot_description_id,
'zone_id': str(hex(zone_id)),
'venue': venue_tuning.__name__,
'lot_name': lot_owner_info.lot_name,
'cur_lot': 'X' if is_current_lot else ''
}
if is_current_lot:
stat_entries = []
for stat in lot.get_all_stats_gen():
stat_entries.append({
'statistic': stat.stat_type.__name__,
'value': stat.get_value()
})
cur_info['statistics'] = stat_entries
lot_infos.append(cur_info)
return lot_infos
def get_valid_situation_locations(sim_id, situation_type, *guests, _connection=None):
sim = get_optional_target(sim_id, _connection)
if not sim:
sims4.commands.output('Invalid Sim ID: {}'.format(sim_id), _connection)
return
sim_info = sim.sim_info
possible_zones = []
possible_zones.append(sim_info.household.home_zone_id)
for guest_id in guests:
guest_id = int(guest_id)
guest_info = services.sim_info_manager().get(guest_id)
while guest_info is not None:
guest_zone_id = guest_info.household.home_zone_id
if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones:
possible_zones.append(guest_zone_id)
venue_service = services.current_zone().venue_service
for venue_type in situation_type.venue_types:
possible_zones.extend(venue_service.get_zones_for_venue_type(venue_type))
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
persistence_service = services.get_persistence_service()
locations_msg = Situations_pb2.SituationLocations()
cas_zones_msg = InteractionOps_pb2.CASAvailableZonesInfo()
world_info_msg = cas_zones_msg.zones.add()
for zone_id in possible_zones:
zone_data = persistence_service.get_zone_proto_buff(zone_id)
if zone_data is None:
pass
neighborhood_data = persistence_service.get_neighborhood_proto_buff(zone_data.neighborhood_id)
if neighborhood_data is None:
pass
lot_data = None
for lot_owner_data in neighborhood_data.lots:
while zone_id == lot_owner_data.zone_instance_id:
lot_data = lot_owner_data
break
while zone_data is not None and lot_data is not None:
location_data = Dialog_pb2.LotInfoItem()
location_data.zone_id = zone_data.zone_id
location_data.name = zone_data.name
location_data.world_id = zone_data.world_id
location_data.lot_template_id = zone_data.lot_template_id
location_data.lot_description_id = zone_data.lot_description_id
venue_type_id = build_buy.get_current_venue(zone_id)
venue_instance = venue_manager.get(venue_type_id)
if venue_instance is not None:
location_data.venue_type_name = venue_instance.display_name
if lot_data.lot_owner:
household_id = lot_data.lot_owner[0].household_id
household = services.household_manager().get(household_id)
if household is not None:
location_data.household_name = household.name
locations_msg.situation_locations.append(location_data)
with ProtocolBufferRollback(world_info_msg.zones) as zone_info_msg:
zone_info_msg.id = zone_data.zone_id
zone_info_msg.name = zone_data.name
zone_info_msg.world_id = zone_data.world_id
zone_info_msg.lot_template_id = zone_data.lot_template_id
zone_info_msg.lot_description_id = zone_data.lot_description_id
shared_messages.add_object_message_for_sim_id(sim.id, Consts_pb2.MSG_NS_AVAILABLE_ZONES_INFO, cas_zones_msg)
shared_messages.add_object_message_for_sim_id(sim.id, Consts_pb2.MSG_SITUATION_LOCATIONS, locations_msg)
def print_venues(_connection=None):
current_zone = services.current_zone()
lot = current_zone.lot
neighborhood_id = current_zone.neighborhood_id
lot_description_id = services.get_lot_description_id(lot.lot_id)
world_description_id = services.get_world_description_id(
current_zone.world_id)
neighborhood_description_id = services.get_persistence_service(
).get_neighborhood_proto_buff(neighborhood_id).region_id
def print_line():
sims4.commands.output('-' * 150, _connection)
print_line()
sims4.commands.output(
'Current Game Stats: \nLot: {}\nWorld/Street: {}\nRegion/Neighborhood: {}'
.format(lot_description_id, world_description_id,
neighborhood_description_id), _connection)
print_line()
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
venues = []
for neighborhood_proto in services.get_persistence_service(
).get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
venue_type = venue_manager.get(venue_type_id)
if venue_type is not None:
log = PrintVenueLog._make(
(neighborhood_proto.name, neighborhood_proto.region_id,
lot_owner_info.lot_description_id, zone_id,
venue_type.__name__, lot_owner_info.lot_name))
venues.append(log)
str_format = '{:20} ({:{center}15}) {:{center}20} {:15} ({:{center}20}) {:20}'
def print_columns():
sims4.commands.output(
str_format.format('Neighborhood_Name',
'Neighborhood_ID',
'Lot_Description_ID',
'Zone_Instance_ID',
'Venue_Tuning_Name',
'Lot_Name',
center='^'), _connection)
print_columns()
print_line()
for venue in sorted(venues):
sims4.commands.output(
str_format.format(venue.Neighborhood_Name,
venue.Neighborhood_ID,
venue.Lot_Description_ID,
venue.Zone_Instance_ID,
venue.Venue_Tuning_Name,
venue.Lot_Name,
center='^'), _connection)
print_line()
print_columns()
def on_client_connect(self, client):
zone = services.current_zone()
venue_type = get_current_venue(zone.id)
logger.assert_raise(venue_type is not None, ' Venue Type is None in on_client_connect for zone:{}', zone, owner='sscholl')
venue_tuning = self._get_venue_tuning(zone)
if venue_tuning is not None:
type_changed = self._set_venue(venue_tuning)
if type_changed:
self._create_automatic_objects(venue_tuning)
def get_current_venue_type() -> VenueTypes:
"""get_current_venue_type()
Retrieve the type of the current venue.
:return: The VenueType of the current lot.
:rtype: VenueTypes
"""
return build_buy.get_current_venue(CommonLocationUtils.get_current_lot_id())
def _validate_venue_tuning(self):
venue_tuning_id = build_buy.get_current_venue(self._zone_id)
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is None:
return False
elif type(self) not in venue_tuning.drama_node_events:
return False
return True
def get_zones_for_venue_type(self, venue_type):
possible_zones = []
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
if venue_manager.get(venue_type_id) is venue_type:
possible_zones.append(lot_owner_info.zone_instance_id)
return possible_zones
def on_client_connect(self, client):
zone = services.current_zone()
active_venue_key = get_current_venue(zone.id)
logger.assert_raise(active_venue_key is not None,
' Venue Type is None for zone id:{}',
zone.id,
owner='shouse')
raw_active_venue_key = get_current_venue(zone.id,
allow_ineligible=True)
logger.assert_raise(raw_active_venue_key is not None,
' Raw Venue Type is None for zone id:{}',
zone.id,
owner='shouse')
if not active_venue_key is None and not raw_active_venue_key is None:
active_venue_type = services.venue_manager().get(active_venue_key)
raw_active_venue_type = services.venue_manager().get(
raw_active_venue_key)
source_venue_type = VenueService.get_variable_venue_source_venue(
raw_active_venue_type)
self._set_venue(active_venue_type, source_venue_type)
def is_valid_career_location(self):
if self._zone_id:
venue_manager = services.venue_manager()
try:
venue_tuning_id = get_current_venue(self._zone_id)
except RuntimeError:
return False
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning in self.venues:
return True
return False
def _collect_residential_zones(self):
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
residential_zone_ids = []
for zone_id in get_zone_ids_from_street(self._street):
venue_key = build_buy.get_current_venue(zone_id,
allow_ineligible=True)
venue_tuning = venue_manager.get(venue_key)
if StreetUtilityShutoffEffect._should_have_utility_shut_off(
venue_tuning):
residential_zone_ids.append(zone_id)
return residential_zone_ids
def get_zones_for_venue_type(self, venue_type):
possible_zones = []
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service(
).get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
if venue_manager.get(venue_type_id) is venue_type:
possible_zones.append(lot_owner_info.zone_instance_id)
return possible_zones
def on_client_connect(self, client):
zone = services.current_zone()
venue_type = get_current_venue(zone.id)
logger.assert_raise(
venue_type is not None,
' Venue Type is None in on_client_connect for zone:{}',
zone,
owner='sscholl')
venue_tuning = self._get_venue_tuning(zone)
if venue_tuning is not None:
type_changed = self._set_venue(venue_tuning)
if type_changed:
self._create_automatic_objects(venue_tuning)
def on_zone_load(self):
current_zone_id = services.current_zone_id()
self._setup_curfew_text_message()
self._create_alarm_handles(current_zone_id)
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
current_venue_tuning = venue_manager.get(
build_buy.get_current_venue(current_zone_id))
if current_venue_tuning.is_residential or current_venue_tuning.is_university_housing:
current_setting = self._zone_curfew_data.get(
current_zone_id, CurfewService.UNSET)
self._update_curfew_settings(current_zone_id, current_setting)
else:
self._update_curfew_settings(current_zone_id, CurfewService.UNSET)
def has_zone_for_venue_type(self, venue_types):
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
venue_type = venue_manager.get(venue_type_id)
if venue_type and venue_type in venue_types:
return True
instance_manager = services.get_instance_manager(sims4.resources.Types.MAXIS_LOT)
for lot_instance in instance_manager.types.values():
while lot_instance.supports_any_venue_type(venue_types):
return True
return False
def __init__(self, zone_data, **kwargs):
super().__init__(**kwargs)
self.zone_id = zone_data.zone_id
self.name = zone_data.name
self.world_id = zone_data.world_id
self.lot_template_id = zone_data.lot_template_id
self.lot_description_id = zone_data.lot_description_id
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
venue_type_id = build_buy.get_current_venue(zone_data.zone_id)
if venue_type_id is not None:
venue_type = venue_manager.get(venue_type_id)
if venue_type is not None:
self.venue_type_name = venue_type.display_name
householdProto = services.get_persistence_service().get_household_proto_buff(zone_data.household_id)
self.household_name = householdProto.name if householdProto is not None else None
def _show_away_notification(self):
if self.away_notification is None:
return
zone_data = services.get_persistence_service().get_zone_proto_buff(
self._zone_id)
if zone_data is None:
return
venue_tuning_id = build_buy.get_current_venue(self._zone_id)
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is None:
return
dialog = self.away_notification(services.active_sim_info())
dialog.show_dialog(additional_tokens=(zone_data.name,
venue_tuning.display_name))
def __init__(self, zone_data, **kwargs):
super().__init__(**kwargs)
self.zone_id = zone_data.zone_id
self.name = zone_data.name
self.world_id = zone_data.world_id
self.lot_template_id = zone_data.lot_template_id
self.lot_description_id = zone_data.lot_description_id
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_type_id = build_buy.get_current_venue(zone_data.zone_id)
if venue_type_id is not None:
venue_type = venue_manager.get(venue_type_id)
if venue_type is not None:
self.venue_type_name = venue_type.display_name
householdProto = services.get_persistence_service(
).get_household_proto_buff(zone_data.household_id)
self.household_name = householdProto.name if householdProto is not None else None
def show_club_gathering_dialog(
self,
sim_info,
*,
flavor_text,
start_source=ClubGatheringStartSource.DEFAULT,
sender_sim_info=DEFAULT):
zone_id = self.get_hangout_zone_id()
if not zone_id:
return False
current_region = services.current_region()
hangout_region = get_region_instance_from_zone_id(zone_id)
if not current_region.is_region_compatible(hangout_region):
return False
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(build_buy.get_current_venue(zone_id))
def on_response(dialog):
if not dialog.accepted:
return
persistence_service = services.get_persistence_service()
if persistence_service.is_save_locked():
return
club_service = services.get_club_service()
if club_service is None:
return
club_service.start_gathering(self,
start_source=start_source,
host_sim_id=sim_info.sim_id,
invited_sims=(sim_info, ),
zone_id=zone_id,
spawn_sims_during_zone_spin_up=True)
zone_data = services.get_persistence_service().get_zone_proto_buff(
zone_id)
lot_name = zone_data.name
sender_sim_info = self.leader if sender_sim_info is DEFAULT else sender_sim_info
flavor_text = flavor_text(sim_info, sender_sim_info, self)
additional_tokens = (lot_name, venue_tuning.club_gathering_text(),
flavor_text)
self.show_club_notification(sim_info,
ClubTunables.CLUB_GATHERING_DIALOG,
target_sim_id=sender_sim_info.sim_id,
additional_tokens=additional_tokens,
on_response=on_response)
def has_zone_for_venue_type(self, venue_types):
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service(
).get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
venue_type = venue_manager.get(venue_type_id)
if venue_type and venue_type in venue_types:
return True
instance_manager = services.get_instance_manager(
sims4.resources.Types.MAXIS_LOT)
for lot_instance in instance_manager.types.values():
while lot_instance.supports_any_venue_type(venue_types):
return True
return False
def generate_lot_info_data(*args, zone_id:int=None, filter=None, **kwargs):
lot_infos = []
current_zone = services.current_zone()
lot = current_zone.lot
neighborhood_id = current_zone.neighborhood_id
lot_description_id = services.get_lot_description_id(lot.lot_id)
world_description_id = services.get_world_description_id(current_zone.world_id)
neighborhood_description_id = services.get_persistence_service().get_neighborhood_proto_buff(neighborhood_id).region_id
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
venue_type = venue_manager.get(venue_type_id)
if venue_type is not None:
cur_info = {'neighborhood': neighborhood_proto.name, 'region_id': neighborhood_proto.region_id, 'lot_desc_id': lot_owner_info.lot_description_id, 'zone_id': zone_id, 'venue_type': venue_type.__name__, 'lot_name': lot_owner_info.lot_name, 'cur_lot': 'X' if lot_owner_info.zone_instance_id == lot.zone_id else ''}
lot_infos.append(cur_info)
return lot_infos
def build_msg(self, zone_id=None, **kwargs):
msg = super().build_msg(**kwargs)
if zone_id is None:
return msg
persistence_service = services.get_persistence_service()
zone_data = persistence_service.get_zone_proto_buff(zone_id)
if zone_data is None:
return msg
venue_tuning_id = build_buy.get_current_venue(zone_id)
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is None:
return msg
msg.lot_title = self.zone_title(venue_tuning.display_name,
zone_data.name)
build_icon_info_msg(
IconInfoData(icon_resource=venue_tuning.venue_icon),
venue_tuning.display_name, msg.venue_icon)
return msg
def get_possible_zone_ids_for_situation(cls,
host_sim_info=None,
guest_ids=None):
possible_zones = []
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_service = services.current_zone().venue_service
for venue_tuning in cls.compatible_venues:
if venue_tuning.is_residential:
if host_sim_info is not None:
home_zone_id = host_sim_info.household.home_zone_id
home_venue_tuning = venue_manager.get(
build_buy.get_current_venue(home_zone_id))
if home_venue_tuning.is_residential:
possible_zones.append(home_zone_id)
possible_zones.extend(
venue_service.get_zones_for_venue_type_gen(
venue_tuning))
else:
possible_zones.extend(
venue_service.get_zones_for_venue_type_gen(venue_tuning))
return possible_zones
def _start_gathering(zone_id=None):
start_gathering = functools.partial(
club_service.start_gathering,
club,
invited_sims=(services.active_sim_info(), ))
if zone_id is None:
current_venue_tuning = venue_manager.get(
build_buy.get_current_venue(current_zone_id))
if current_venue_tuning.is_residential or current_venue_tuning.is_university_housing:
if not club.is_zone_valid_for_gathering(current_zone_id):
club.show_club_notification(
services.active_sim_info(), ClubTunables.
CLUB_GATHERING_START_RESIDENTIAL_INVALID_DIALOG)
return
elif not club.is_zone_valid_for_gathering(current_zone_id):
club.show_club_notification(
services.active_sim_info(),
ClubTunables.CLUB_GATHERING_START_INVALID_DIALOG)
return
start_gathering()
else:
start_gathering(zone_id=zone_id)
def print_venues(_connection=None):
current_zone = services.current_zone()
lot = current_zone.lot
neighborhood_id = current_zone.neighborhood_id
lot_description_id = services.get_lot_description_id(lot.lot_id)
world_description_id = services.get_world_description_id(current_zone.world_id)
neighborhood_description_id = services.get_persistence_service().get_neighborhood_proto_buff(neighborhood_id).region_id
def print_line():
sims4.commands.output('-'*150, _connection)
print_line()
sims4.commands.output('Current Game Stats: \nLot: {}\nWorld/Street: {}\nRegion/Neighborhood: {}'.format(lot_description_id, world_description_id, neighborhood_description_id), _connection)
print_line()
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
venues = []
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
venue_type = venue_manager.get(venue_type_id)
if venue_type is not None:
log = PrintVenueLog._make((neighborhood_proto.name, neighborhood_proto.region_id, lot_owner_info.lot_description_id, zone_id, venue_type.__name__, lot_owner_info.lot_name))
venues.append(log)
str_format = '{:20} ({:{center}15}) {:{center}20} {:15} ({:{center}20}) {:20}'
def print_columns():
sims4.commands.output(str_format.format('Neighborhood_Name', 'Neighborhood_ID', 'Lot_Description_ID', 'Zone_Instance_ID', 'Venue_Tuning_Name', 'Lot_Name', center='^'), _connection)
print_columns()
print_line()
for venue in sorted(venues):
sims4.commands.output(str_format.format(venue.Neighborhood_Name, venue.Neighborhood_ID, venue.Lot_Description_ID, venue.Zone_Instance_ID, venue.Venue_Tuning_Name, venue.Lot_Name, center='^'), _connection)
print_line()
print_columns()
def _get_venue_tuning(self, zone):
venue_tuning = None
venue_type = get_current_venue(zone.id)
if venue_type is not None:
venue_tuning = services.venue_manager().get(venue_type)
return venue_tuning
def get_current_venue_type() -> VenueTypes:
"""
Retrieve the type of the current venue.
"""
return build_buy.get_current_venue(
CommonLocationUtils.get_current_lot_id())
def get_venue_tuning(self, zone_id):
venue_tuning = None
venue_type = get_current_venue(zone_id)
if venue_type is not None:
venue_tuning = services.venue_manager().get(venue_type)
return venue_tuning
def _get_token(self, resolver, token_data):
if token_data.token_type == self.TOKEN_PARTICIPANT:
participants = token_data.objects.get_objects(resolver)
return token_data.formatter(participants)
if token_data.token_type == self.TOKEN_PARTICIPANT_COUNT:
participants = token_data.objects.get_objects(resolver)
if not participants:
return 0
return len(participants)
if token_data.token_type == self.TOKEN_DEFINITION:
return token_data.definition
elif token_data.token_type == self.TOKEN_MONEY:
interaction = getattr(resolver, 'interaction', None)
if interaction is not None:
from interactions.money_payout import MoneyLiability
money_liability = interaction.get_liability(
MoneyLiability.LIABILITY_TOKEN)
if money_liability is not None:
return money_liability.amounts[token_data.participant]
return 0
return 0
if token_data.token_type == self.TOKEN_BUCK:
participant = resolver.get_participant(
participant_type=token_data.participant)
tracker = BucksUtils.get_tracker_for_bucks_type(
token_data.bucks_type, owner_id=participant.id)
if not tracker:
return 0
return tracker.get_bucks_amount_for_type(token_data.bucks_type)
if token_data.token_type == self.TOKEN_STATISTIC:
participant = resolver.get_participant(
participant_type=token_data.participant)
if participant is not None:
tracker = participant.get_tracker(token_data.statistic)
if tracker is not None:
return tracker.get_value(token_data.statistic)
if token_data.token_type == self.TOKEN_OBJECT_PROPERTY:
participant = resolver.get_participant(ParticipantType.Object)
if participant is None:
return
return participant.get_object_property(token_data.obj_property)
if token_data.token_type == self.TOKEN_INTERACTION_COST:
interaction = getattr(resolver, 'interaction', None)
if interaction is not None:
return interaction.get_simoleon_cost()
affordance = getattr(resolver, 'affordance', None)
if affordance is not None:
return affordance.get_simoleon_cost(target=resolver.target,
context=resolver.context)
if token_data.token_type == self.TOKEN_INTERACTION_PAYOUT:
interaction = getattr(resolver, 'interaction', None)
if interaction is not None:
return interaction.get_simoleon_payout()
affordance = getattr(resolver, 'affordance', None)
if affordance is not None:
return affordance.get_simoleon_payout(target=resolver.target,
context=resolver.context)
if token_data.token_type == self.TOKEN_ASSOCIATED_CLUB:
if resolver.interaction is not None:
club = getattr(resolver.interaction, 'associated_club')
else:
club = resolver.interaction_parameters.get('associated_club')
if club is not None:
return club.name
if token_data.token_type == self.TOKEN_CAREER_DATA:
participant = resolver.get_participant(
participant_type=token_data.participant)
if participant is not None:
if participant.career_tracker is None:
return
career = participant.career_tracker.get_career_by_uid(
token_data.career_type.guid64)
if career is not None:
if token_data.career_data == self.TOKEN_CAREER_DATA_CURRENT_LEVEL_NAME:
current_level = career.current_level_tuning
return current_level.get_title(participant)
if token_data.career_data == self.TOKEN_CAREER_DATA_CURRENT_LEVEL_SALARY:
current_level = career.current_level_tuning
return current_level.simoleons_per_hour
if token_data.career_data == self.TOKEN_CAREER_DATA_NEXT_LEVEL_NAME:
next_level = career.next_level_tuning
if next_level is not None:
return next_level.get_title(participant)
elif token_data.career_data == self.TOKEN_CAREER_DATA_NEXT_LEVEL_SALARY:
next_level = career.next_level_tuning
if next_level is not None:
return next_level.simoleons_per_hour
elif token_data.career_data == self.TOKEN_CAREER_DATA_PREVIOUS_LEVEL_NAME:
previous_level = career.previous_level_tuning
if previous_level is not None:
return previous_level.get_title(participant)
elif token_data.career_data == self.TOKEN_CAREER_DATA_PREVIOUS_LEVEL_SALARY:
previous_level = career.previous_level_tuning
if previous_level is not None:
return previous_level.simoleons_per_hour
if token_data.token_type == self.TOKEN_GAME_COMPONENT:
participant = resolver.get_participant(
participant_type=token_data.participant)
if participant is not None:
game = participant.game_component
if game is None:
return
if token_data.game_component_data == self.TOKEN_GAME_COMPONENT_DATA_HIGH_SCORE and game.high_score is not None:
return game.high_score
if token_data.game_component_data == self.TOKEN_GAME_COMPONENT_DATA_HIGH_SCORE_SIM and game.high_score_sim_ids:
high_score_sim_id = game.high_score_sim_ids[0]
return services.sim_info_manager().get(high_score_sim_id)
if token_data.token_type == self.TOKEN_SCHOLARSHIP_LETTER:
participant = resolver.get_participant(
participant_type=token_data.participant)
if participant is not None:
scholarship_letter_component = participant.scholarship_letter_component
if scholarship_letter_component is None:
return
if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_APPLICANT_NAME:
return scholarship_letter_component.get_applicant_name()
if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_DATA_AMOUNT:
return scholarship_letter_component.get_scholarship_amount(
)
if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_DATA_NAME:
return scholarship_letter_component.get_scholarship_name()
if token_data.scholarship_letter_component_data == self.TOKEN_SCHOLARSHIP_LETTER_DATA_DESCRIPTION:
return scholarship_letter_component.get_scholarship_description(
)
if token_data.token_type == self.TOKEN_SICKNESS:
participant = resolver.get_participant(
participant_type=token_data.participant)
if participant is None or not participant.is_sim:
return
current_sickness = participant.current_sickness
if current_sickness is None:
return
return current_sickness.display_name(participant)
if token_data.token_type == self.TOKEN_GLOBAL_POLICY:
global_policy = services.global_policy_service().get_global_policy(
token_data.global_policy, create=False)
if global_policy is None:
return token_data.global_policy.get_non_active_display(
token_data)
return global_policy.get_active_policy_display(token_data)
if token_data.token_type == self.TOKEN_HOLIDAY:
active_household = services.active_household()
if active_household.holiday_tracker is None:
return
holiday_id = active_household.holiday_tracker.get_active_or_upcoming_holiday(
)
if holiday_id is None:
return
return services.holiday_service().get_holiday_display_name(
holiday_id)
if token_data.token_type == self.TOKEN_CURRENT_TRENDS:
trend_service = services.trend_service()
if trend_service is None:
return
return trend_service.get_current_trends_loc_string()
if token_data.token_type == self.TOKEN_LIFESTYLE_BRAND:
participant = resolver.get_participant(
participant_type=token_data.participant)
lifestyle_brand_tracker = participant.lifestyle_brand_tracker
if lifestyle_brand_tracker is None:
return
return lifestyle_brand_tracker.brand_name
if token_data.token_type == self.TOKEN_PICKED_PART:
participant = resolver.get_participant(ParticipantType.Object)
if participant is None:
return
context = getattr(resolver, 'context', None)
if context is not None and context.pick is not None:
target_objects = participant.get_closest_parts_to_position(
context.pick.location, has_name=True)
if target_objects:
part = target_objects.pop()
return part.part_name
if token_data.token_type == self.TOKEN_CIVIC_POLICY:
if token_data.civic_policy_data == self.TOKEN_CIVIC_POLICY_VOTING_START_TIME:
return services.street_service().voting_open_time
if token_data.civic_policy_data == self.TOKEN_CIVIC_POLICY_VOTING_END_TIME:
return services.street_service().voting_close_time
if token_data.token_type == self.TOKEN_STREET:
if token_data.street_data == self.TOKEN_STREET_POLICY_NAME_UP_FOR_REPEAL:
provider = token_data.street.get_street_provider()
if provider is not None:
policies = provider.get_up_for_repeal_policies()
if policies:
return list(policies)[0].display_name()
if token_data.street_data == self.TOKEN_STREET_POLICY_NAME_BALLOTED_RANDOM_LOSING:
provider = token_data.street.get_street_provider()
if provider is None:
return
policies = list(provider.get_balloted_policies())
if policies and len(policies) > 1:
winning_policy = max(
policies,
key=lambda policy: provider.get_stat_value(
policy.vote_count_statistic))
policies.remove(winning_policy)
random_losing_policy = random.choice(policies)
return random_losing_policy.display_name()
if token_data.street_data == self.TOKEN_STREET_POLICY_NAME_BALLOTED_WINNING:
provider = token_data.street.get_street_provider()
if provider is None:
return
policies = list(provider.get_balloted_policies())
if policies:
winning_policy = max(
policies,
key=lambda policy: provider.get_stat_value(
policy.vote_count_statistic))
return winning_policy.display_name()
if token_data.token_type == self.TOKEN_VENUE:
if token_data.venue_data == self.TOKEN_VENUE_ACTIVE_VENUE_NAME:
raw_active_venue_tuning_id = build_buy.get_current_venue(
services.current_zone_id(), allow_ineligible=True)
raw_active_venue_tuning = services.venue_manager().get(
raw_active_venue_tuning_id)
if raw_active_venue_tuning is None:
return
source_venue_tuning = type(
services.venue_service().source_venue)
if source_venue_tuning is raw_active_venue_tuning and source_venue_tuning.variable_venues is not None:
return raw_active_venue_tuning.variable_venues.variable_venue_display_name(
)
return raw_active_venue_tuning.display_name
elif token_data.venue_data == self.TOKEN_VENUE_SOURCE_VENUE_NAME:
source_venue_tuning = type(
services.venue_service().source_venue)
if source_venue_tuning is not None:
return source_venue_tuning.display_name
def enroll(major: TunableInstanceParam(sims4.resources.Types.UNIVERSITY_MAJOR),
university: TunableInstanceParam(sims4.resources.Types.UNIVERSITY),
opt_sim: OptionalSimInfoParam = None,
classes: int = 3,
elective: TunableInstanceParam(
sims4.resources.Types.UNIVERSITY_COURSE_DATA) = None,
tuition_cost: int = 0,
total_scholarship_taken: int = 0,
is_using_loan: bool = False,
destination_zone_id: int = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
sims4.commands.output('No valid target for university.enroll',
_connection)
return False
degree_tracker = sim_info.degree_tracker
if degree_tracker is None:
sims4.commands.output(
'Sim: {} has no degree tracker in university.enroll'.format(
sim_info), _connection)
return False
electives = () if elective is None else (elective, )
degree_tracker.enroll(major, university, classes, courses=electives)
if is_using_loan:
LoanTunables.add_debt(
sim_info,
LoanTunables.get_loan_amount(tuition_cost, LoanType.UNIVERSITY))
else:
sim_info.household.funds.try_remove(tuition_cost,
Consts_pb2.FUNDS_TUITION_COST,
sim_info)
UniversityTelemetry.send_university_tuition_telemetry(
sim_info, tuition_cost, is_using_loan)
degree_tracker.handle_scholarships_after_enrollment(
total_scholarship_taken)
UniversityTelemetry.send_university_housing_telemetry(destination_zone_id)
if destination_zone_id is None:
return True
home_zone_id = sim_info.household.home_zone_id
if home_zone_id == destination_zone_id:
degree_tracker.on_enroll_in_same_housing()
return True
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
venue = venue_manager.get(build_buy.get_current_venue(home_zone_id))
if venue.is_university_housing:
sim_info.degree_tracker.set_kickout_info(
destination_zone_id, UniversityHousingKickOutReason.MOVED)
return True
target_household_id = 0
if destination_zone_id != 0:
account = services.client_manager().get(_connection).account
target_household_id = get_target_household_id_for_zone(
destination_zone_id, account)
household_split(sourceHouseholdId=sim_info.household.id,
targetHouseholdId=target_household_id,
cancelable=False,
allow_sim_transfer=False,
selected_sim_ids=[sim_info.sim_id],
destination_zone_id=destination_zone_id)
return True
def get_current_venue_type():
return build_buy.get_current_venue(
TurboWorldUtil.Zone.get_current_zone_id())
def get_valid_situation_locations(sim_id,
situation_type,
*guests,
_connection=None):
sim = get_optional_target(sim_id, _connection)
if not sim:
sims4.commands.output('Invalid Sim ID: {}'.format(sim_id), _connection)
return
sim_info = sim.sim_info
possible_zones = []
possible_zones.append(sim_info.household.home_zone_id)
for guest_id in guests:
guest_id = int(guest_id)
guest_info = services.sim_info_manager().get(guest_id)
while guest_info is not None:
guest_zone_id = guest_info.household.home_zone_id
if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones:
possible_zones.append(guest_zone_id)
venue_service = services.current_zone().venue_service
for venue_type in situation_type.venue_types:
possible_zones.extend(
venue_service.get_zones_for_venue_type(venue_type))
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
persistence_service = services.get_persistence_service()
locations_msg = Situations_pb2.SituationLocations()
cas_zones_msg = InteractionOps_pb2.CASAvailableZonesInfo()
world_info_msg = cas_zones_msg.zones.add()
for zone_id in possible_zones:
zone_data = persistence_service.get_zone_proto_buff(zone_id)
if zone_data is None:
pass
neighborhood_data = persistence_service.get_neighborhood_proto_buff(
zone_data.neighborhood_id)
if neighborhood_data is None:
pass
lot_data = None
for lot_owner_data in neighborhood_data.lots:
while zone_id == lot_owner_data.zone_instance_id:
lot_data = lot_owner_data
break
while zone_data is not None and lot_data is not None:
location_data = Dialog_pb2.LotInfoItem()
location_data.zone_id = zone_data.zone_id
location_data.name = zone_data.name
location_data.world_id = zone_data.world_id
location_data.lot_template_id = zone_data.lot_template_id
location_data.lot_description_id = zone_data.lot_description_id
venue_type_id = build_buy.get_current_venue(zone_id)
venue_instance = venue_manager.get(venue_type_id)
if venue_instance is not None:
location_data.venue_type_name = venue_instance.display_name
if lot_data.lot_owner:
household_id = lot_data.lot_owner[0].household_id
household = services.household_manager().get(household_id)
if household is not None:
location_data.household_name = household.name
locations_msg.situation_locations.append(location_data)
with ProtocolBufferRollback(world_info_msg.zones) as zone_info_msg:
zone_info_msg.id = zone_data.zone_id
zone_info_msg.name = zone_data.name
zone_info_msg.world_id = zone_data.world_id
zone_info_msg.lot_template_id = zone_data.lot_template_id
zone_info_msg.lot_description_id = zone_data.lot_description_id
shared_messages.add_object_message_for_sim_id(
sim.id, Consts_pb2.MSG_NS_AVAILABLE_ZONES_INFO, cas_zones_msg)
shared_messages.add_object_message_for_sim_id(
sim.id, Consts_pb2.MSG_SITUATION_LOCATIONS, locations_msg)
def _score_and_schedule_drama_nodes_gen(self, timeline, from_zone_spin_up=False):
active_household = services.active_household()
if active_household is None:
return
current_time = services.time_service().sim_now
current_day = current_time.day()
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
if not zone_id:
continue
venue_tuning = venue_manager.get(build_buy.get_current_venue(zone_id))
if venue_tuning is None:
continue
if not venue_tuning.drama_node_events:
continue
if is_scoring_archive_enabled():
gsi_data = GSIDramaScoringData()
gsi_data.bucket = 'Venue'
else:
gsi_data = None
yield from self.score_and_schedule_nodes_gen(venue_tuning.drama_node_events, venue_tuning.drama_node_events_to_schedule, timeline=timeline, gsi_data=gsi_data, zone_id=zone_id)
if gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
if timeline is not None:
yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0)))
bucketted_nodes = defaultdict(list)
drama_node_manager = services.get_instance_manager(sims4.resources.Types.DRAMA_NODE)
for drama_node in drama_node_manager.types.values():
if drama_node.scoring is None:
continue
bucketted_nodes[drama_node.scoring.bucket].append(drama_node)
buckets_to_score = []
if from_zone_spin_up or not self._check_day(current_day, self.VENUE_BUCKET_DAYS) or from_zone_spin_up:
buckets = self.STARTUP_BUCKETS - self._startup_buckets_used
if current_time < create_date_and_time(days=int(current_time.absolute_days()), hours=self.SCORING_TIME):
day_modifier = -1
else:
day_modifier = 0
for bucket in buckets:
if not bucketted_nodes[bucket]:
continue
self._startup_buckets_used.add(bucket)
rules = self.BUCKET_SCORING_RULES[bucket]
smallest_day_modification = None
for (day, day_enabled) in rules.days.items():
if not day_enabled:
continue
potential_modification = current_day + day_modifier - day
potential_modification += DAYS_PER_WEEK
if not potential_modification < 0 or smallest_day_modification is None or potential_modification < smallest_day_modification:
smallest_day_modification = potential_modification
if smallest_day_modification is None:
time_modification = TimeSpan.ZERO
else:
time_modification = TimeSpan(current_time.absolute_ticks()) - create_time_span(days=int(current_time.absolute_days()) - smallest_day_modification + day_modifier, hours=self.SCORING_TIME)
buckets_to_score.append((bucket, rules, time_modification))
else:
for (bucket_type, rules) in self.BUCKET_SCORING_RULES.items():
valid_day = self._check_day(current_day, rules.days)
for drama_node in self._scheduled_nodes.values():
if drama_node.scoring is None:
continue
if drama_node.scoring.bucket == bucket_type:
break
else:
valid_day = True
if valid_day or not rules.score_if_no_nodes_are_scheduled or valid_day:
buckets_to_score.append((bucket_type, rules, TimeSpan.ZERO))
for (bucket_type, rules, time_modifier) in buckets_to_score:
if is_scoring_archive_enabled():
gsi_data = GSIDramaScoringData()
gsi_data.bucket = bucket_type
else:
gsi_data = None
if rules.number_to_schedule.option == NodeSelectionOption.BASED_ON_HOUSEHOLD:
nodes_to_schedule = 1 + math.floor(len(active_household)/2)
elif rules.number_to_schedule.option == NodeSelectionOption.STATIC_AMOUNT:
nodes_to_schedule = rules.number_to_schedule.number_of_nodes
else:
logger.error('Trying to determine how many nodes to run with invalid option {}', rules.number_to_schedule.option)
if gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
if nodes_to_schedule == 0:
if gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
for node in list(self._scheduled_nodes.values()):
if not not node.scoring is not None and node.scoring.bucket == bucket_type:
self.cancel_scheduled_node(node.uid)
yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data)
if not rules.refresh_nodes_on_scheduling or gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
if timeline is not None:
yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0)))
else:
gsi_data.nodes_to_schedule = nodes_to_schedule
for node in list(self._scheduled_nodes.values()):
if not not node.scoring is not None and node.scoring.bucket == bucket_type:
self.cancel_scheduled_node(node.uid)
yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data)
if not rules.refresh_nodes_on_scheduling or gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
if timeline is not None:
yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0)))
if nodes_to_schedule == 0:
if gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
for node in list(self._scheduled_nodes.values()):
if not not node.scoring is not None and node.scoring.bucket == bucket_type:
self.cancel_scheduled_node(node.uid)
yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data)
if not rules.refresh_nodes_on_scheduling or gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
if timeline is not None:
yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0)))
else:
gsi_data.nodes_to_schedule = nodes_to_schedule
for node in list(self._scheduled_nodes.values()):
if not not node.scoring is not None and node.scoring.bucket == bucket_type:
self.cancel_scheduled_node(node.uid)
yield from self.score_and_schedule_nodes_gen(bucketted_nodes[bucket_type], nodes_to_schedule, time_modifier=time_modifier, timeline=timeline, gsi_data=gsi_data)
if not rules.refresh_nodes_on_scheduling or gsi_data is not None:
archive_drama_scheduler_scoring(gsi_data)
if timeline is not None:
yield timeline.run_child(elements.SleepElement(date_and_time.TimeSpan(0)))
