def validate_household_sim(test_sim):
if test_sim in self._ss3_requests or test_sim in self.special_case_sims:
return True
if test_sim.is_selectable:
run_affordance = self.species_interaction_speed_requirements.species_affordance_mapping.get(
test_sim.species)
if run_affordance is not None:
self.special_case_sims[test_sim] = run_affordance
return True
else:
roommate_service = services.get_roommate_service()
if roommate_service is not None and roommate_service.get_home_zone_id(
test_sim.sim_id
) == services.current_zone_id():
run_affordance = roommate_service.get_ss3_affordance(
)
if run_affordance is not None:
self.special_case_sims[
test_sim] = run_affordance
return True
else:
roommate_service = services.get_roommate_service()
if roommate_service is not None and roommate_service.get_home_zone_id(
test_sim.sim_id) == services.current_zone_id():
run_affordance = roommate_service.get_ss3_affordance(
)
if run_affordance is not None:
self.special_case_sims[
test_sim] = run_affordance
return True
return False
def perform(self, resolver):
roommate_service = services.get_roommate_service()
if roommate_service is not None:
participant = resolver.get_participant(self.subject)
if participant is not None:
roommate_service.queue_locked_out_sim_id(
participant.sim_id)
def travel_sims_to_zone(opt_sim_id:OptionalTargetParam, zone_id:int, *traveling_sim_ids, _connection=None):
sim_or_sim_info = get_optional_target(opt_sim_id, _connection)
if sim_or_sim_info is None:
if opt_sim_id:
sim_or_sim_info = services.sim_info_manager().get(opt_sim_id)
if sim_or_sim_info is None:
sims4.commands.output('Invalid Sim id: {} specified for travel.travel_sims_to_zone'.format(opt_sim_id), _connection)
return False
else:
sims4.commands.output('No Sim id specified for travel.travel_sims_to_zone', _connection)
return False
zone_proto_buff = services.get_persistence_service().get_zone_proto_buff(zone_id)
if zone_proto_buff is None:
sims4.commands.output('Invalid Zone Id: {}. Zone does not exist.'.format(zone_id), _connection)
return False
situation_manager = services.get_zone_situation_manager()
situation = situation_manager.DEFAULT_TRAVEL_SITUATION
guest_list = situation.get_predefined_guest_list()
if guest_list is None:
guest_list = SituationGuestList(invite_only=True, host_sim_id=sim_or_sim_info.id)
default_job = situation.default_job()
sim_info_manager = services.sim_info_manager()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
traveling_sim_ids = tuple(itertools.chain(traveling_sim_ids, (sim_info.sim_id for sim_info in roommate_service.get_auto_invite_sim_infos(sim_or_sim_info, situation))))
for sim_id in traveling_sim_ids:
sim_id = int(sim_id)
sim_info = sim_info_manager.get(sim_id)
if sim_info is None:
continue
guest_info = SituationGuestInfo.construct_from_purpose(sim_id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
guest_info = SituationGuestInfo.construct_from_purpose(sim_or_sim_info.id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
situation_manager.create_situation(situation, guest_list=guest_list, user_facing=False, zone_id=zone_id)
def set_restriction(self, sim_info, game_objects, preference_tag,
should_force):
zone_preference_data = self._zone_object_preference_datas[(
services.current_zone_id(), preference_tag)]
if not should_force and sim_info.sim_id in zone_preference_data:
return
object_id = None
subroot_index = None
for game_object in game_objects:
object_id = game_object.id
if game_object.is_part and game_object.restrict_autonomy_preference:
subroot_index = game_object.subroot_index
else:
subroot_index = None
if zone_preference_data.get_restricted_sim(
object_id, subroot_index) is not None:
continue
break
else:
if not should_force:
return
if object_id is not None:
old_sim_id = zone_preference_data.set_restriction(
object_id, subroot_index, sim_info.sim_id)
if old_sim_id is not None:
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.assign_bed(old_sim_id)
game_object.update_object_tooltip()
def test(cls, inst, *args, target=DEFAULT, context=None, **kwargs) -> TestResult: # pylint: disable=no-self-argument
try:
inst_or_cls = inst if inst is not None else cls
roommate_service = services.get_roommate_service()
if roommate_service is None:
return TestResult.NONE
Logger.log("testing SimRemoveRoomMateInteraction, context: {} {}"
.format(args, kwargs))
if target:
info_target = target.sim_info
if context.target_sim_id is not None:
target_id = context.target_sim_id
info_target = services.sim_info_manager().get(target_id)
household_id = context.sim.sim_info.household_id
Logger.log('info_target: {}'.format(info_target))
if context.sim.sim_info.id == info_target.id:
return TestResult(False, "sim can not be it's own roommate", inst)
if not roommate_service.is_sim_info_roommate(info_target, household_id):
return TestResult(False, "sim is not a roommate of current household", inst)
return (super(SimRemoveRoomMateInteraction, inst_or_cls)
.test(*args, target=target, context=context, **kwargs))
except BaseException:
Logger.log(traceback.format_exc())
def on_enter(self):
super().on_enter()
zone = services.current_zone()
zone.venue_service.build_buy_edit_mode = True
services.household_manager().load_households()
zone.on_households_and_sim_infos_loaded()
client = zone.zone_spin_up_service._client_connect_data.client
club_service = services.get_club_service()
if club_service is not None:
club_service.on_all_households_and_sim_infos_loaded(client)
relationship_service = services.relationship_service()
if relationship_service is not None:
relationship_service.on_all_households_and_sim_infos_loaded(client)
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.initialize_editmode_roommates()
situation_manager = services.get_zone_situation_manager()
situation_manager.spin_up_for_edit_mode()
object_manager = services.object_manager()
water_terrain_object_cache = object_manager.water_terrain_object_cache
build_buy.register_build_buy_exit_callback(
water_terrain_object_cache.refresh)
conditional_layer_service = services.conditional_layer_service()
conditional_layer_service.on_zone_load(editmode=True)
for obj in object_manager.values():
footprint_component = obj.get_component(FOOTPRINT_COMPONENT)
if footprint_component is not None:
footprint_component.on_finalize_load()
services.game_clock_service().restore_saved_clock_speed()
return _ZoneSpinUpStateResult.DONE
def test(self, tooltip=None, test_targets=()):
roommate_service = services.get_roommate_service()
if roommate_service is None:
if self.invert:
return TestResult.TRUE
return TestResult(
False,
"No roommate service, so sim can't have leave reason",
tooltip=tooltip)
for target in test_targets:
if roommate_service.has_leave_reasons(target.sim_info,
self.reasons):
if self.invert:
return TestResult(
False,
"{} has leave reasons {} but shouldn't be",
target,
self.reasons,
tooltip=tooltip)
if not self.invert:
return TestResult(
False,
'{} does not have reasons {} should be',
target,
self.reasons,
tooltip=tooltip)
elif not self.invert:
return TestResult(False,
'{} does not have reasons {} should be',
target,
self.reasons,
tooltip=tooltip)
return TestResult.TRUE
def perform(self, resolver):
roommate_service = services.get_roommate_service()
if roommate_service is not None:
participant = resolver.get_participant(self.subject)
if participant is not None:
sim_info = participant.sim_info
if self.clear:
roommate_service.remove_leave_reason(
sim_info, self.reason)
return
roommate_service.add_leave_reason(sim_info, self.reason)
def _run_interaction_gen(self, timeline):
try:
Logger.log("running remove roommate interaction...")
super()._run_interaction_gen(timeline)
sim_info = self.target.sim_info
if self.context.target_sim_id is not None:
sim_info = (services.sim_info_manager()
.get(self.context.target_sim_id))
Logger.log("got sim info {} {}"
.format(sim_info.first_name, sim_info.last_name))
services.get_roommate_service().remove_roommate(sim_info)
Logger.log("sim is now not a roommate anymore!")
return True
except BaseException:
Logger.log(traceback.format_exc())
def _run_interaction_gen(self, timeline):
try:
Logger.log("running turn into roommate interaction...")
super()._run_interaction_gen(timeline)
sim_info = self.target.sim_info
home_zone_id = self.get_sim_info_home_zone_id(self.context.sim.sim_info)
if self.context.target_sim_id is not None:
sim_info = (services.sim_info_manager()
.get(self.context.target_sim_id))
Logger.log("got sim info {} {}"
.format(sim_info.first_name, sim_info.last_name))
services.get_roommate_service().add_roommate(sim_info, home_zone_id)
Logger.log("sim is now a roommate!")
return True
except BaseException:
Logger.log(traceback.format_exc())
def validate_objects(self, zone_id):
roommate_service = services.get_roommate_service()
for (zone_preference_tuple, zone_preference_data
) in self._zone_object_preference_datas.items():
if zone_preference_tuple[0] != zone_id:
continue
for bad_object_id in zone_preference_data.get_invalid_object_ids():
sim_ids = zone_preference_data.get_restricted_sims(
bad_object_id)
if not sim_ids:
continue
zone_preference_data.clear_restriction(bad_object_id, None)
if roommate_service is not None:
for sim_id in sim_ids:
roommate_service.assign_bed(sim_id,
avoid_id=bad_object_id)
def clear_restriction(self, game_objects, preference_tag):
zone_preference_data = self._zone_object_preference_datas[(
services.current_zone_id(), preference_tag)]
object_id = None
subroot_index = None
for game_object in game_objects:
object_id = game_object.id
subroot_index = self.get_preferable_subroot_index(game_object)
sim_id = zone_preference_data.get_restricted_sim(
object_id, subroot_index)
if sim_id is not None:
zone_preference_data.clear_restriction(object_id,
subroot_index)
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.assign_bed(sim_id, avoid_id=object_id)
def on_enter(self):
super().on_enter()
active_household_id = services.active_household_id()
object_manager = services.object_manager()
services.current_zone().suppress_object_commodity_callbacks = False
for script_object in tuple(object_manager.get_all()):
script_object.finalize(active_household_id=active_household_id)
lot = services.active_lot()
lot.on_finalize_load()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.do_decorations()
water_terrain_object_cache = object_manager.water_terrain_object_cache
water_terrain_object_cache.refresh()
build_buy.register_build_buy_exit_callback(
water_terrain_object_cache.refresh)
return _ZoneSpinUpStateResult.DONE
def test(self, tooltip=None):
roommate_service = services.get_roommate_service()
if roommate_service is None:
if self.invert:
return TestResult.TRUE
return TestResult(False,
'No roommate service, so roommate ad is off',
tooltip=tooltip)
if roommate_service.are_interviews_scheduled():
if self.invert:
return TestResult(False,
'Ad is on, but testing for it off',
tooltip=tooltip)
return TestResult.TRUE
if self.invert:
return TestResult.TRUE
return TestResult(False,
'Ad is off, but testing for it on',
tooltip=tooltip)
def _generate_situation_guest_list(self, preferred_sim_id,
service_npc_type, hiring_household):
guest_list = SituationGuestList(invite_only=True)
blacklist_sim_ids = hiring_household.get_all_fired_service_npc_ids()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
blacklist_sim_ids.update(roommate_service.get_roommate_ids())
if preferred_sim_id is not None:
guest_info = SituationGuestInfo.construct_from_purpose(
preferred_sim_id, service_npc_type.situation.default_job(),
SituationInvitationPurpose.PREFERRED)
guest_info.expectation_preference = True
guest_list.add_guest_info(guest_info)
return guest_list
if service_npc_type.exclusive_to_household:
household_manager = services.household_manager()
if household_manager is None:
logger.error(
'Household manager is None when service npc is being scheduled for service type {}',
service_npc_type)
return guest_list
for household in household_manager.values():
if household.id == hiring_household:
continue
blacklist_sim_ids.update(
household.get_preferred_service_npcs())
worker_filter = service_npc_type.situation.default_job().filter
filter_results = services.sim_filter_service().submit_matching_filter(
sim_filter=worker_filter,
allow_yielding=False,
blacklist_sim_ids=blacklist_sim_ids,
gsi_source_fn=self.get_sim_filter_gsi_name)
if not filter_results:
return guest_list
for result in filter_results:
guest_info = SituationGuestInfo.construct_from_purpose(
result.sim_info.sim_id,
service_npc_type.situation.default_job(),
SituationInvitationPurpose.PREFERRED)
guest_info.expectation_preference = True
guest_list.add_guest_info(guest_info)
return guest_list
def perform(self, resolver):
roommate_service = services.get_roommate_service()
if roommate_service is not None:
participant = resolver.get_participant(self.subject)
if participant is not None:
sim_info = participant.sim_info
if self.remove:
roommate_service.remove_roommate(sim_info)
else:
zone_id = services.get_active_sim(
).household.home_zone_id
if roommate_service.conform_potential_roommate(
sim_info):
roommate_service.add_roommate(sim_info, zone_id)
else:
logger.error(
'Failed to conform {} to be a roommate',
sim_info)
sim_info.trait_tracker.remove_traits_of_type(
traits.traits.TraitType.ROOMMATE)
def test(self, tooltip=None, test_targets=(), households=None):
roommate_service = services.get_roommate_service()
if roommate_service is None:
if self.invert:
return TestResult.TRUE
return TestResult(
False,
'There are no roommates, but testing to be one',
tooltip=tooltip)
household_id = None
if households is not None:
if not households:
if self.invert:
return True
return TestResult(
False,
"Can't be a roommate of missing participant {}",
self.household,
tooltip=tooltip)
household_id = households[0].household_id
for target in test_targets:
if roommate_service.is_sim_info_roommate(
target.sim_info, household_id):
if self.invert:
return TestResult(False,
"{} is a roommate but shouldn't be",
target,
tooltip=tooltip)
if not self.invert:
return TestResult(
False,
'{} is not a roommate but should be',
target,
tooltip=tooltip)
elif not self.invert:
return TestResult(False,
'{} is not a roommate but should be',
target,
tooltip=tooltip)
return TestResult.TRUE
def _get_culling_score_for_npc(self, sim_info):
if sim_info.is_player_sim:
return 0
score = services.get_service_npc_service().get_culling_npc_score(
sim_info.id)
roommate_service = services.get_roommate_service()
if roommate_service is not None:
score += roommate_service.get_culling_npc_score(sim_info.id)
score += services.business_service().get_culling_npc_score(sim_info)
score += sum(trait.culling_behavior.get_culling_npc_score()
for trait in sim_info.trait_tracker)
if FameTunables.FAME_RANKED_STATISTIC is not None:
stat = sim_info.get_statistic(FameTunables.FAME_RANKED_STATISTIC,
add=False)
if stat is not None:
score += CullingTuning.FAME_CULLING_BONUS_CURVE.get(
stat.rank_level)
if sim_info.household.home_zone_id:
score += CullingTuning.CULLING_SCORE_IN_WORLD
if sim_info.is_premade_sim:
score += CullingTuning.CULLING_SCORE_PREMADE
return score
def test(self, tooltip=None):
roommate_service = services.get_roommate_service()
if roommate_service is None:
if self.invert:
return TestResult.TRUE
return TestResult(False,
'No room for roommates if the is no service',
tooltip=tooltip)
zone_id = services.active_household().home_zone_id
if roommate_service.get_available_roommate_count_for_zone(
zone_id) > 0:
if self.invert:
return TestResult(
False,
"Is room for roommate but we don't want room",
tooltip=tooltip)
return TestResult.TRUE
if self.invert:
return TestResult.TRUE
return TestResult(False,
"Isn't room for roommate but we want room",
tooltip=tooltip)
def on_enter(self):
super().on_enter()
services.household_manager().load_households()
zone = services.current_zone()
zone_spin_up_service = zone.zone_spin_up_service
household_id = zone_spin_up_service._client_connect_data.household_id
household = services.household_manager().get(household_id)
client = zone_spin_up_service._client_connect_data.client
account_service = services.account_service()
account_service.on_load_options(client)
zone.service_manager.on_zone_load()
game_services.service_manager.on_zone_load()
sims4.core_services.service_manager.on_zone_load()
for sim_info in household.sim_info_gen():
client.add_selectable_sim_info(sim_info,
send_relationship_update=False)
zone.on_households_and_sim_infos_loaded()
zone.service_manager.on_all_households_and_sim_infos_loaded(client)
game_services.service_manager.on_all_households_and_sim_infos_loaded(
client)
sims4.core_services.service_manager.on_all_households_and_sim_infos_loaded(
client)
organization_service = services.organization_service()
if organization_service is not None:
organization_service.post_game_services_zone_load()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.initialize_roommates()
services.ui_dialog_service().send_dialog_options_to_client()
client.clean_and_send_remaining_relationship_info()
services.current_zone().lot.send_lot_display_info()
for obj in itertools.chain(services.object_manager().values(),
services.inventory_manager().values()):
if obj.live_drag_component is not None:
obj.live_drag_component.resolve_live_drag_household_permission(
)
return _ZoneSpinUpStateResult.DONE
def perform(self, resolver):
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_service.trigger_interviews(self.turn_on)
def start_situation(resolver,
situation,
user_facing=True,
invite_participants=None,
invite_actor=True,
actor_init_job=None,
invite_picked_sims=True,
invite_target_sim=True,
target_init_job=None,
invite_household_sims_on_active_lot=False,
situation_default_target=None,
situation_created_callback=None,
linked_sim_participant=None,
situation_guest_info=None,
**kwargs):
situation_manager = services.get_zone_situation_manager()
def create_guest_info(sim_id, job_type):
if situation_guest_info is None:
return SituationGuestInfo.construct_from_purpose(
sim_id, job_type, SituationInvitationPurpose.INVITED)
return situation_guest_info(sim_id, job_type)
guest_list = situation.get_predefined_guest_list()
if guest_list is None:
sim = resolver.get_participant(ParticipantType.Actor)
guest_list = SituationGuestList(invite_only=True,
host_sim_id=sim.id)
if situation.targeted_situation is not None:
target_sim = resolver.get_participant(
ParticipantType.PickedSim)
if target_sim is None:
target_sim = resolver.get_participant(
ParticipantType.TargetSim)
target_sim_id = target_sim.id if target_sim is not None else None
job_assignments = situation.get_prepopulated_job_for_sims(
sim, target_sim_id)
for (sim_id, job_type_id) in job_assignments:
job_type = services.situation_job_manager().get(
job_type_id)
guest_info = create_guest_info(sim_id, job_type)
guest_list.add_guest_info(guest_info)
else:
default_job = situation.default_job()
if invite_picked_sims:
target_sims = resolver.get_participants(
ParticipantType.PickedSim)
roommate_service = services.get_roommate_service()
if roommate_service is not None:
target_sims = tuple(
itertools.chain(
target_sims,
roommate_service.get_auto_invite_sim_infos(
sim, situation)))
if target_sims:
for sim_or_sim_info in target_sims:
guest_info = create_guest_info(
sim_or_sim_info.sim_id, default_job)
guest_list.add_guest_info(guest_info)
if invite_target_sim:
target_sim = resolver.get_participant(
ParticipantType.TargetSim)
if target_sim is not None:
init_job = target_init_job if target_init_job is not None else default_job
guest_info = create_guest_info(
target_sim.sim_id, init_job)
guest_list.add_guest_info(guest_info)
if invite_actor and guest_list.get_guest_info_for_sim(
sim) is None:
init_job = actor_init_job if actor_init_job is not None else default_job
guest_info = create_guest_info(sim.sim_id, init_job)
guest_list.add_guest_info(guest_info)
if invite_household_sims_on_active_lot:
sims_to_invite = resolver.get_participants(
ParticipantType.ActiveHousehold)
if sims_to_invite:
for sim_info in sims_to_invite:
if guest_list.get_guest_info_for_sim(
sim_info) is not None:
continue
if sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
guest_info = create_guest_info(
sim_info.sim_id, default_job)
guest_list.add_guest_info(guest_info)
for (paticipant_type,
situation_jobs) in invite_participants.items():
target_sims = resolver.get_participants(
paticipant_type)
if target_sims:
jobs = situation_jobs if situation_jobs is not None else (
default_job, )
for (sim_or_sim_info,
job_to_assign) in zip(target_sims,
itertools.cycle(jobs)):
if not sim_or_sim_info.is_sim:
continue
guest_info = create_guest_info(
sim_or_sim_info.sim_id, job_to_assign)
guest_list.add_guest_info(guest_info)
zone_id = resolver.get_participant(
ParticipantType.PickedZoneId) or 0
default_target_id = None
default_location = None
if situation_default_target is not None:
target_obj = resolver.get_participant(situation_default_target)
if target_obj is not None:
default_target_id = target_obj.id
if target_obj.is_sim:
sim_instance = target_obj.get_sim_instance()
if sim_instance is not None:
default_location = sim_instance.location
else:
default_location = target_obj.location
linked_sim_id = 0
if linked_sim_participant is not None:
linked_sim = resolver.get_participant(linked_sim_participant)
if linked_sim is not None:
linked_sim_id = linked_sim.sim_id
situation_id = situation_manager.create_situation(
situation,
guest_list=guest_list,
user_facing=user_facing,
zone_id=zone_id,
default_target_id=default_target_id,
default_location=default_location,
linked_sim_id=linked_sim_id,
**kwargs)
if situation_id is None:
return False
if situation_created_callback is not None:
situation_created_callback(situation_id)
return True
def save(self,
object_list=None,
zone_data=None,
open_street_data=None,
store_travel_group_placed_objects=False,
**kwargs):
if object_list is None:
return
open_street_objects = file_serialization.ObjectList()
total_beds = 0
double_bed_exist = False
kid_bed_exist = False
alternative_sleeping_spots = 0
university_roommate_beds = 0
if store_travel_group_placed_objects:
objects_to_save_for_clean_up = []
roommate_bed_tags = set()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_bed_tags = roommate_service.BED_TAGS
for game_object in self._objects.values():
if self._should_save_object_on_lot(game_object):
save_result = ObjectManager.save_game_object(
game_object, object_list, open_street_objects)
if not save_result:
continue
if zone_data is None:
continue
if store_travel_group_placed_objects and save_result.owner_id != 0:
placement_flags = build_buy.get_object_placement_flags(
game_object.definition.id)
if build_buy.PlacementFlags.NON_INVENTORYABLE not in placement_flags:
objects_to_save_for_clean_up.append(save_result)
if not game_object.definition.has_build_buy_tag(
*self._all_bed_tags):
continue
if game_object.definition.has_build_buy_tag(
*self.BED_TAGS.double_beds):
double_bed_exist = True
total_beds += 1
elif game_object.definition.has_build_buy_tag(
*self.BED_TAGS.kid_beds):
total_beds += 1
kid_bed_exist = True
elif game_object.definition.has_build_buy_tag(
*self.BED_TAGS.other_sleeping_spots):
alternative_sleeping_spots += 1
elif game_object.definition.has_build_buy_tag(
*self.BED_TAGS.beds):
total_beds += 1
if len(roommate_bed_tags) > 0:
if game_object.definition.has_build_buy_tag(
*roommate_bed_tags):
university_roommate_beds += 1
if open_street_data is not None:
open_street_data.objects = open_street_objects
if zone_data is not None:
bed_info_data = gameplay_serialization.ZoneBedInfoData()
bed_info_data.num_beds = total_beds
bed_info_data.double_bed_exist = double_bed_exist
bed_info_data.kid_bed_exist = kid_bed_exist
bed_info_data.alternative_sleeping_spots = alternative_sleeping_spots
if roommate_service is not None:
household_and_roommate_cap = roommate_service.HOUSEHOLD_AND_ROOMMATE_CAP
bed_info_data.university_roommate_beds = min(
household_and_roommate_cap, university_roommate_beds)
zone_data.gameplay_zone_data.bed_info_data = bed_info_data
if store_travel_group_placed_objects:
current_zone = services.current_zone()
save_game_protocol_buffer = services.get_persistence_service(
).get_save_game_data_proto()
self._clear_clean_up_data_for_zone(current_zone,
save_game_protocol_buffer)
self._save_clean_up_destination_data(
current_zone, objects_to_save_for_clean_up,
save_game_protocol_buffer)
lot = services.current_zone().lot
for (inventory_type, inventory) in lot.get_all_object_inventories_gen(
shared_only=True):
for game_object in inventory:
game_object.save_object(object_list.objects,
ItemLocation.OBJECT_INVENTORY,
inventory_type)