def end_vacation(self):
active_household = services.active_household()
current_zone_id = services.current_zone_id()
current_region_id = get_region_description_id_from_zone_id(
current_zone_id)
rental_region_id = get_region_description_id_from_zone_id(
self._zone_id)
if current_region_id != rental_region_id or not active_household.any_member_belong_to_travel_group_id(
self.id):
at_home = current_zone_id == active_household.home_zone_id
for sim_info in self:
if active_household.id == sim_info.household_id and at_home:
if not sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
SimSpawner.spawn_sim(sim_info)
if sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
services.get_zone_situation_manager(
).make_sim_leave_now_must_run(
sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS))
else:
sim_info.inject_into_inactive_zone(
sim_info.household.home_zone_id)
elif sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
services.get_zone_situation_manager(
).make_sim_leave_now_must_run(
sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS))
else:
sim_info.inject_into_inactive_zone(
sim_info.household.home_zone_id)
services.travel_group_manager(
).destroy_travel_group_and_release_zone(self, return_objects=True)
return
for instanced_sim in active_household.instanced_sims_gen():
instanced_sim.queue.cancel_all()
travel_info = InteractionOps_pb2.TravelSimsToZone()
travel_info.zone_id = active_household.home_zone_id
active_sims_on_zone = [
active_sim_info for active_sim_info in active_household
if active_sim_info.zone_id == current_zone_id
]
for sim_info in itertools.chain(self, active_sims_on_zone):
if active_household.id == sim_info.household_id:
if sim_info.sim_id not in travel_info.sim_ids:
travel_info.sim_ids.append(sim_info.sim_id)
else:
sim_info.inject_into_inactive_zone(
sim_info.household.home_zone_id)
distributor.system.Distributor.instance().add_event(
Consts_pb2.MSG_TRAVEL_SIMS_TO_ZONE, travel_info)
services.game_clock_service().set_clock_speed(ClockSpeedMode.PAUSED)
services.travel_group_manager().destroy_travel_group_and_release_zone(
self)
def remove_sim_info(self, sim_info, destroy_on_empty=True):
if sim_info not in self._sim_infos:
logger.error(
'Trying to remove a sim from a travel group they do not belong to. Sim: {}, Travel Group: {}',
sim_info, self)
sim_info.remove_from_travel_group(self)
self._sim_infos.remove(sim_info)
sim_info.career_tracker.resend_at_work_infos()
if all(travel_sim_info.household.home_zone_id == 0
for travel_sim_info in self._sim_infos):
self.played = False
if not self._sim_infos and destroy_on_empty:
services.travel_group_manager(
).destroy_travel_group_and_release_zone(self,
last_sim_info=sim_info,
return_objects=True)
def _get_owner_sim_infos(self):
owner_household_or_travel_group = services.household_manager().get(
services.current_zone().lot.owner_household_id)
if owner_household_or_travel_group is None:
owner_household_or_travel_group = services.travel_group_manager(
).get_travel_group_by_zone_id(services.current_zone_id())
if owner_household_or_travel_group is None:
return
owner_sim_infos = tuple(owner_household_or_travel_group)
return owner_sim_infos
def _load_treasure_chest_data(self, reader):
if reader is None:
return
travel_group_manager = services.travel_group_manager()
group_ids = reader.read_uint64s(TREASURE_CHEST_GROUP, [])
obj_ids = reader.read_uint64s(TREASURE_CHEST_ID, [])
status = reader.read_uint64s(TREASURE_CHEST_STATUS, [])
for (index, group_id) in enumerate(group_ids):
if not travel_group_manager.get(group_id):
continue
if group_id not in self._treasure_chest_status:
self._treasure_chest_status[group_id] = []
treasure_chest = self._treasure_chest_status[group_id]
treasure_chest.append((obj_ids[index], status[index]))
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._obstacle_status = {}
self._path_obstacles = {}
self._treasure_chest_status = {}
travel_group_manager = services.travel_group_manager()
household = services.active_household()
travel_group = travel_group_manager.get_travel_group_by_household(household)
if travel_group is None:
logger.error("Trying to initialize the Jungle Open Street Director but there doesn't appear to be a travel group for the current household.")
self._current_travel_group_id = None
else:
self._current_travel_group_id = travel_group.id
services.get_event_manager().register_single_event(self, TestEvent.InteractionComplete)
self._current_temple_id = None
self._temple_state = self.TEMPLE_STATE_NEEDS_RESET
self._last_time_saved = None
def _load_custom_open_street_director(self, street_director_proto, reader):
if reader is None:
return
travel_group_manager = services.travel_group_manager()
group_ids = reader.read_uint64s(GROUP_TOKEN, [])
tags = reader.read_uint64s(TAG_TOKEN, [])
tag_status = reader.read_uint64s(TAG_STATUS_TOKEN, [])
clear_progress = reader.read_floats(CLEAR_PROGRESS_TOKEN, 0)
self._current_temple_id = reader.read_uint64(CURRENT_TEMPLE_ID, 0)
self._temple_state = reader.read_uint32(TEMPLE_STATE, self.TEMPLE_STATE_NEEDS_RESET)
last_time_saved = reader.read_uint64(LAST_TIME_SAVED, 0)
for (index, group_id) in enumerate(group_ids):
if not travel_group_manager.get(group_id):
continue
if group_id not in self._obstacle_status:
self._obstacle_status[group_id] = []
path_obstacles = self._obstacle_status[group_id]
path_obstacles.append((tags[index], tag_status[index], clear_progress[index]))
self._last_time_saved = DateAndTime(last_time_saved)
self._load_treasure_chest_data(reader)
def on_startup(self):
super().on_startup()
object_manager = services.object_manager()
self._path_obstacles = self._get_path_obstacles()
if self._current_travel_group_id in self._obstacle_status:
path_obstacle_data = self._obstacle_status[self._current_travel_group_id]
for (tag, status, progress) in path_obstacle_data:
obstacles = object_manager.get_objects_matching_tags((tag,))
for obstacle in obstacles:
if tag == self.TEMPLE_PATH_OBSTACLE:
if not obstacle.state_value_active(self.TEMPLE_PATH_OBSTACLE_UNLOCK_STATE):
self._update_temple_lock_commodity()
if obstacle.state_value_active(self.TEMPLE_PATH_OBSTACLE_UNLOCK_STATE):
status = JungleOpenStreetDirector.PATH_LOCKED
else:
status = JungleOpenStreetDirector.PATH_UNAVAILABLE
progress = 0
if status == JungleOpenStreetDirector.PATH_LOCKED:
self._lock_path_obstacle(obstacle, tag)
elif status == JungleOpenStreetDirector.PATH_UNAVAILABLE:
self._permanently_lock_path_obstacle(obstacle, tag)
elif status == JungleOpenStreetDirector.PATH_UNLOCKED:
self._unlock_path_obstacle(obstacle, tag)
else:
logger.error('Trying to setup an object that has a tag status that is not known. {}', status)
obstacle.set_stat_value(self.path_clearing_commodity, progress)
if self._current_travel_group_id in self._treasure_chest_status:
treasure_chest_data = self._treasure_chest_status[self._current_travel_group_id]
for (obj_id, status) in treasure_chest_data:
chest = object_manager.get(obj_id)
if chest is None:
continue
if status == JungleOpenStreetDirector.TREASURE_CHEST_OPEN:
chest.set_state(self.treasure_chest_open_state.state, self.treasure_chest_open_state)
else:
chest.set_state(self.treasure_chest_closed_state.state, self.treasure_chest_closed_state)
else:
always_available_paths = []
possible_paths = []
for (obj, tag) in self._path_obstacles.items():
if self.path_obstacle_data[tag].always_available:
always_available_paths.append((obj, tag))
else:
possible_paths.append((obj, tag))
available_paths = random.sample(possible_paths, min(len(possible_paths), self.num_of_paths_available))
unavailable_paths = [path for path in possible_paths if path not in available_paths]
for (path_obstacle, tag) in itertools.chain(always_available_paths, available_paths):
self._lock_path_obstacle(path_obstacle, tag, reset_commodity=True)
for (path_obstacle, tag) in unavailable_paths:
self._permanently_lock_path_obstacle(path_obstacle, tag)
for chest in object_manager.get_objects_matching_tags((self.treasure_chest_tag,)):
chest.set_state(self.treasure_chest_closed_state.state, self.treasure_chest_closed_state)
travel_group_manager = services.travel_group_manager()
travel_groups = travel_group_manager.get_travel_group_ids_in_region()
for group_id in travel_groups:
if group_id == self._current_travel_group_id:
continue
group = travel_group_manager.get(group_id)
if group.played:
break
else:
self._setup_for_first_travel_group()
if self._temple_needs_reset():
self.reset_temple()
def _show_off_lot_death_notification(self):
if self.off_lot_death_notification is None:
return False
if self._client is None:
return False
home_zone_id = self._client.household.home_zone_id
if home_zone_id == services.current_zone_id():
return False
end_vacation = True
dead_sim_info = self.sim.sim_info
travel_group = dead_sim_info.travel_group
sim_info_to_travel_to = None
for sim_info in self._client.selectable_sims:
if sim_info.is_baby:
continue
if travel_group is None:
end_vacation = False
elif sim_info in travel_group:
if sim_info.can_live_alone:
end_vacation = False
if sim_info.is_instanced():
sim_info_to_travel_to = None
break
if not sim_info_to_travel_to is None:
if sim_info.zone_id == home_zone_id:
sim_info_to_travel_to = sim_info
sim_info_to_travel_to = sim_info
else:
if sim_info.is_instanced():
sim_info_to_travel_to = None
break
if not sim_info_to_travel_to is None:
if sim_info.zone_id == home_zone_id:
sim_info_to_travel_to = sim_info
sim_info_to_travel_to = sim_info
if sim_info.is_instanced():
sim_info_to_travel_to = None
break
if not sim_info_to_travel_to is None:
if sim_info.zone_id == home_zone_id:
sim_info_to_travel_to = sim_info
sim_info_to_travel_to = sim_info
if travel_group is not None and not end_vacation:
travel_group.remove_sim_info(dead_sim_info)
if sim_info_to_travel_to is not None:
persistence_service = services.get_persistence_service()
zone_data = persistence_service.get_zone_proto_buff(
services.current_zone_id())
lot_name = zone_data.name
dialog = self.off_lot_death_notification(
self.sim, resolver=SingleSimResolver(self.sim))
dialog.show_dialog(additional_tokens=(lot_name, ))
if travel_group is not None and end_vacation:
if services.get_active_sim() is not None:
travel_group.end_vacation()
return
else:
services.travel_group_manager(
).destroy_travel_group_and_release_zone(travel_group)
def post_save_lock_travel():
zone_id = sim_info.zone_id or home_zone_id
sim_info.send_travel_switch_to_zone_op(zone_id=zone_id)
persistence_service.add_save_unlock_callback(
post_save_lock_travel)
return True
def post_save_lock_travel():
zone_id = sim_info.zone_id or home_zone_id
sim_info.send_travel_switch_to_zone_op(zone_id=zone_id)
persistence_service.add_save_unlock_callback(post_save_lock_travel)
return True
return False
def _disband_travel_group(self):
dead_sim_info = self.sim.sim_info
travel_group = dead_sim_info.travel_group
if travel_group is not None:
services.travel_group_manager(
).destroy_travel_group_and_release_zone(travel_group)
def get_particpants_shared(participant_type):
if participant_type == ParticipantType.Lot:
return (services.active_lot(), )
elif participant_type == ParticipantType.LotOwners:
owning_household = services.owning_household_of_active_lot()
if owning_household is not None:
return tuple(sim_info
for sim_info in owning_household.sim_info_gen())
return ()
return ()
if participant_type == ParticipantType.LotOwnersOrRenters:
owning_household = services.owning_household_of_active_lot()
if owning_household is not None:
return tuple(sim_info
for sim_info in owning_household.sim_info_gen())
else:
current_zone = services.current_zone()
travel_group = services.travel_group_manager(
).get_travel_group_by_zone_id(current_zone.id)
if travel_group is not None:
return tuple(sim_info
for sim_info in travel_group.sim_info_gen())
return ()
if participant_type == ParticipantType.LotOwnerSingleAndInstanced:
owning_household = services.owning_household_of_active_lot()
if owning_household is not None:
for sim_info in owning_household.sim_info_gen():
if sim_info.is_instanced():
return (sim_info, )
return ()
elif participant_type == ParticipantType.ActiveHousehold:
active_household = services.active_household()
if active_household is not None:
return tuple(active_household.sim_info_gen())
return ()
elif participant_type == ParticipantType.AllInstancedActiveHouseholdSims:
active_household = services.active_household()
if active_household is not None:
return tuple(active_household.instanced_sims_gen())
return ()
elif participant_type == ParticipantType.CareerEventSim:
career = services.get_career_service().get_career_in_career_event()
if career is not None:
return (career.sim_info.get_sim_instance()
or career.sim_info, )
return ()
return ()
if participant_type == ParticipantType.AllInstancedActiveHouseholdSims:
active_household = services.active_household()
if active_household is not None:
return tuple(active_household.instanced_sims_gen())
return ()
elif participant_type == ParticipantType.CareerEventSim:
career = services.get_career_service().get_career_in_career_event()
if career is not None:
return (career.sim_info.get_sim_instance()
or career.sim_info, )
return ()
return ()
if participant_type == ParticipantType.AllInstancedSims:
return tuple(services.sim_info_manager().instanced_sims_gen())
if participant_type == ParticipantType.Street:
street = services.current_zone().street
street_service = services.street_service()
if street_service is None:
return ()
street_civic_policy_provider = street_service.get_provider(street)
if street_civic_policy_provider is None:
return ()
return (street_civic_policy_provider, )
if participant_type == ParticipantType.VenuePolicyProvider:
venue_service = services.venue_service()
if venue_service.source_venue is None or venue_service.source_venue.civic_policy_provider is None:
return ()
else:
return (venue_service.source_venue.civic_policy_provider, )
